nape.phys.BodyList

type
class
Nape list of Body type objects

Internally this list is at present implemented as a linked list with object pooled nodes and iterators with various fast paths made for standard access patterns (For instance accessing successive elements runs in constant time when using random access functions)

Iteration of this list can be done in various ways, but the preferred way on all targets, is through use of the foreach function:
list.foreach(function (obj) {
});
This method is inlined so that in haxe no closure will need to be created.

In AS3, a closure would need to be created in general, so for performance reasons you 'may' choose to use iteration as follows:
for (var i:int = 0; i < list.length; i++) {
    var obj:Body = list.at(i);
}

NOTE: It is 'not' safe to modify a list whilst iterating over it. If you wish to remove elements during an iteration you should use the filter method, for example:
list.filter(function (obj) {
    // operate on object.
    // ...
    return (false if you want object to be removed);
});


In AS3, if you wish to avoid a closure generation, you can perform such an iteration in a safe manner as follows:
var i:int = 0;
while (i < list.length) {
    var obj:Body = list.at(i);
    // operate on object.
    // ...
    if (should remove obj) {
        list.remove(obj);
        continue;
    }
    else i++;
}
Or if you are always clearing the list entirely you could write:
while (!list.empty()) {
    var obj:Body = list.pop();
    // operate on object.
    // ...
}

Static Methods

static function fromArray(array:Array<Body>):BodyList

+ Convert standard Array to Nape list.

static function fromVector(vector:flash.Vector<Body>):BodyList

+ Convert flash.Vector to Nape list.

Constructor

function new()
Construct a new list.

Instance Properties

readonly var length : Int

Length of list.

Instance Methods

inline function add(obj:Body):Bool

+ Insert element into list in most effecient way.

function at(index:Int):Body

+ Random access to elements of list by index.

function clear():Void

Clear the list, removing all elements.

function copy(deep:Bool = null):BodyList

+ Produce a possibly deep copy of list.

inline function empty():Bool

+ Test if list is empty or not.

function filter(lambda:Body -> Bool):BodyList

+ Iterate over list filtering elements.

inline function foreach(lambda:Body -> Void):BodyList

+ Iterate over list applying function.

function has(obj:Body):Bool

+ Check if element is already in the list

inline function iterator():BodyIterator

+ Return Haxe iterator for list.

function merge(xs:BodyList):Void

+ Merge given list into this one.

function pop():Body

+ Pop element from back of list.

function push(obj:Body):Bool

+ Push element to back of list.

function remove(obj:Body):Bool

+ Remove element from list.

function shift():Body

+ Pop element from front of list.

function unshift(obj:Body):Bool

+ Push element to front of list.