import * as hz from 'horizon/core';

const spawnTriggerEvent = new hz.CodeBlockEvent<[]>('spawnEvent', []);
const despawnTriggerEvent = new hz.CodeBlockEvent<[]>('despawnEvent', []);
class RuntimeTypeScriptSpawner extends hz.Component<typeof RuntimeTypeScriptSpawner> {

 // define the inputs available in the property panel in the UI as well as default values
 static propsDefinition = {
   numObj: {type: hz.PropTypes.Number, default: 10},
   asset: {type: hz.PropTypes.Asset},
 };

 // define instance state
 objList: hz.Entity[] = new Array();

 // called on world start
 start() {

    // Handle when the user presses the "Spawn" button
    this.connectCodeBlockEvent(this.entity, spawnTriggerEvent, () => {
      if(this.objList.length != 0) return;
      for(let count = 0; count < this.props.numobj; count++) {
        pos.add(new Vec3(0, 0, count));
        this.world.spawnAsset(this.props.asset, pos, this.entity.rotation.get()).then(spawnedObjects => {
          if(this.objList == null) return;

            spawnedObjects.forEach(obj => {
              this.objList.push(obj);
            }, this);
          });
      };
    });

    // Handle when the user presses the "Despawn" button
    this.connectCodeBlockEvent(this.entity, despawnTriggerEvent, () => {
      if(this.objList.length == 0) return;

      this.objList.forEach(item => {
        this.world.deleteAsset(item);
        }, this);
      this.objList.splice(0, this.objList.length);
    });
  };
};

// This tells the UI that your component can be attached to an entity
hz.Component.register(RuntimeTypeScriptSpawner);

import {Entity, Vec3} from 'horizon/core';

class PoolItem<T> {
 item: T;
 inUse: boolean

 constructor(item: T) {
   this.item = item;
   this.inUse = false;
 }

 _getItem(): T {
   return this.item;
 }

 requestItem(): T {
   this.inUse = true;
   return this.item;
 }

 returnItem(): void {
   this.inUse = false;
 }

 isInUse(): boolean {
   return this.inUse;
 }
}

export class EntityPool {
 pool: Array<PoolItem<Entity>>;
 maxSize: number;
 constructor(maxSize: number = 30) {
   this.pool = new Array<PoolItem<Entity>>();
   this.maxSize = maxSize;
 }

 registerItem(item: Entity) {
   if(item != undefined) {
     this.pool.push(new PoolItem(item));
   }
 }

 requestItem(): Entity|null {
   let result = null;
   let itemIdx = this.pool.findIndex((poolItem) => {return poolItem.isInUse() == false;});
   if(itemIdx != -1) {
     result = this.pool[itemIdx].requestItem();
   }
   return result;
 }

 returnItem(item: Entity): void {
   let poolIdx = this.pool.findIndex((poolItem) = { return poolItem._getItem().id == item.id; });
  if(poolIdx == -1) return;
  let poolItem = this.pool[poolIdx];
  poolItem.returnItem();
  let itemPos = item.position.get();
  itemPos.add(new Vec3(0, -10, 0));
  item.position.set(itemPos);
  this.pool[poolIdx] = poolItem;
 }

 getSize(): number {
   return this.pool.length;
 }

  isFull(): boolean {
   return this.pool.length == this.maxSize;
 }

 printIds() {
    this.pool.forEach((poolItem: PoolItem<Entity>) => {
     let item = poolItem._getItem();
     if(item != null) {
       console.log(item.id);
     }
    });
 }
}

import * as hz from 'horizon/core';
import { EntityPool } from 'ObjectPool';

const spawnTriggerEvent = new hz.CodeBlockEvent<[]>('spawnEvent', []);
const despawnTriggerEvent = new hz.CodeBlockEvent<[]>('despawnEvent', []);
class PoolSpawnManager extends hz.Component<typeof PoolSpawnManager> {
 static propsDefinition = {
   numObj: {type: hz.PropTypes.Number, default: 10},
   assetToSpawn: {type: hz.PropTypes.Asset},
 };

 objPool: EntityPool = new EntityPool();
 objList: hz.Entity[] = new Array<Entity>();

  // called on world start
 start() {

   // Request 10 objects to be spawned when the world is initially loaded
   for(let count = 0; count < this.props.numobj; count++) {
     this.world.spawnAsset(this.props.assetToSpawn!, this.entity.position.get(), this.entity.rotation.get()).then(spawnedObjects => {
       if(this.objPool == null) return;
       spawnedObjects.forEach(obj => {
         this.objPool.registerItem(obj);
       }, this);
     });
   };

   // Handle when the "Spawn" button is pressed
   this.connectCodeBlockEvent(this.entity, spawnTriggerEvent, () => {
     if(this.objList.length == this.props.numObj || this.objPool == null) return;
     for(let idx = 0; idx < this.props.numobj; idx++) {
       let obj=this.objPool.requestItem();
       if(obj== null) return;
       let entityPos=this.entity.position.get();
       entityPos.add(new hz.vec3(0,0, idx));
       obj.position.set(entityPos);
       this.objList.push(obj);
     };
    });

   // Handle when the Despawn button is pressed
   this.connectCodeBlockEvent(this.entity, despawnTriggerEvent, () => {
     if(this.objList.length == 0 || this.objPool == null) return;
     this.objList.forEach((item) => {
       this.objPool.returnItem(item);
     }, this);
     this.objList.splice(0, this.objList.length);
   });
  };
};

// This tells the UI that your component can be attached to an entity
hz.Component.register(PoolSpawnManager);