具有动态对象类型的 Haxe Starling 对象池

Question

我是haxe openfl 的新手，我以前用flash 和starling 开发游戏，我对从flash 到openfl haxe 的转换感到困惑。

public class StarlingPool
{
public var items:Array;
private var counter:int;

    public function StarlingPool(type:Class, len:int)
    {
        items = new Array();
        counter = len;

        var i:int = len;
        while(--i > -1)
            items[i] = new type();
    }

    public function getSprite():DisplayObject
    {
        if(counter > 0)
            return items[--counter];
        else
            throw new Error("You exhausted the pool!");
    }

    public function returnSprite(s:DisplayObject):void
    {
        items[counter++] = s;
    }

    public function destroy():void
    {
        items = null;
    }
}

这是由 Lee Brimelow 创建的 Starling Pool Class 我想知道如何将其转换为 Haxe，

我试过了 -

 class StarlingPool
{
    public var items:Array<Class>;
    private var counter:Int;

    public function new(type:Class<Dynamic>, len:Int)
    {
        items = new Array<Class<Dynamic>>();
        counter = len;

        var i:Int = len;
        while (--i > -1)
            items[i] = type;
    }

    public function getSprite():Class<Dynamic>
    {
        if (counter > 0)
            return items[--counter];
        else
            throw new Error("You exhausted the pool!");
            return null;
    }

    public function returnSprite(s:Dynamic):Void
    {
        items[counter++] = s;
    }

    public function destroy():Void
    {
        items = null;
    }
}

但是我不工作，也许我没有正确地投射它？， 例如 -

pool = new StarlingPool(Bullet, 100);
var b:Bullet = cast(pool.getSprite()); //or 
var b:Bullet = cast(pool.getSprite(),Bullet)

Answer 1

最好不要使用动态，尤其是如果您可以创建 typed object pool 更多关于Type Parameters的信息

Answer 2

这就是我要让它以 Haxe 方式工作的方法：

• 使用类型参数制作 StarlingPool。然后它是通用的，所以我们也可以将函数名称更改为getItem 和putItem。
• len 和 items 是只读的（默认获取访问权限，没有设置访问权限）。
• 不要使用 Class 数组，而是提供一个返回 instance 的分配器函数。这可能很好，因为您可以在 pool 类之外准备/装饰新的 Sprite。当拥有不同的池时，这会很方便。
• 我不会在池为空时抛出错误，而是使用分配器函数返回新实例。这对我来说更有意义。当然，您必须测量一个合适的池长度，以实现内存使用的良好平衡，因此您可以在此处记录警告以进行调试。

这是 StarlingPool 类：

class StarlingPool<T>
{
    public var items(default, null):Array<T>;
    public var len(default, null):Int;

    private var _allocator:Void->T;

    public function new(len:Int, allocator:Void->T)
    {
        this.len = len;
        _allocator = allocator;

        // create array full of instances using comprehension syntax
        items = [for(i in 0...len) allocator()];
    }

    public function getItem():T
    {
        if (items.length > 0)
            return items.pop();
        else
            // instead of returning null, why not just provide new objects.
            return _allocator();
    }

    public function putItem(item:T):Void
    {
        if(items.length < len)
        {
            items.push(item);
        }
    }

    public function destroy():Void
    {
        _allocator = null;
        items = null;
    }
}

现在这是一个不错的游泳池，您可以这样使用它：

var pool = new StarlingPool(50, function() return new Sprite());

trace(pool.items.length); // actual items in pool: 50
var item = pool.getItem();
trace(pool.items.length); // actual items in pool: 49
pool.putItem(item); // give item back
trace(pool.items.length); // actual items in pool: 50

$type(item); // type of this item is: Sprite

由于池是通用的，您可以创建一个不同的对象池，其中包含其他对象。 （当然，你不能混合多种类型）

var pool2 = new StarlingPool(50, function() return new OtherObject());

var item2 = pool2.getItem();
$type(item2); // type of this item is: OtherObject

希望这会有所帮助。自己玩吧：https://try.haxe.org/#979E1