phaser/src/structs/List.js

1042 lines
24 KiB
JavaScript
Raw Normal View History

2018-02-12 16:01:20 +00:00
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2018 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
var Class = require('../utils/Class');
var NOOP = require('../utils/NOOP');
2018-03-19 21:57:46 +00:00
/**
* @callback EachListCallback
2018-03-30 12:43:58 +00:00
* @generic I - [item]
2018-03-19 21:57:46 +00:00
*
* @param {*} item - [description]
2018-03-28 15:00:19 +00:00
* @param {...*} [args] - Additional arguments that will be passed to the callback, after the child.
2018-03-19 21:57:46 +00:00
*/
2018-02-09 04:35:23 +00:00
/**
* @classdesc
* [description]
*
* @class List
* @memberOf Phaser.Structs
* @constructor
* @since 3.0.0
*
* @generic T
*
2018-03-20 16:15:49 +00:00
* @param {*} parent - [description]
2018-02-09 04:35:23 +00:00
*/
var List = new Class({
initialize:
function List (parent)
{
2018-02-09 04:35:23 +00:00
/**
* The parent of this list.
*
* @name Phaser.Structs.List#parent
2018-03-20 16:15:49 +00:00
* @type {*}
2018-02-09 04:35:23 +00:00
* @since 3.0.0
*/
this.parent = parent;
2018-02-09 04:35:23 +00:00
/**
* The objects that belong to this collection.
*
2018-03-29 10:56:47 +00:00
* @genericUse {T[]} - [$type]
*
2018-02-09 04:35:23 +00:00
* @name Phaser.Structs.List#list
2018-03-23 15:54:12 +00:00
* @type {Array.<*>}
2018-02-09 04:35:23 +00:00
* @default []
* @since 3.0.0
*/
this.list = [];
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @name Phaser.Structs.List#position
* @type {integer}
* @default 0
* @since 3.0.0
*/
this.position = 0;
/**
* A callback that is invoked every time a child is added to this list.
*
* @name Phaser.Structs.List#addCallback
* @type {function}
* @since 3.4.0
*/
this.addCallback = NOOP;
/**
* A callback that is invoked every time a child is removed from this list.
*
* @name Phaser.Structs.List#removeCallback
* @type {function}
* @since 3.4.0
*/
this.removeCallback = NOOP;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#add
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child,$return]
*
* @param {*|Array.<*>} child - [description]
* @param {boolean} [skipCallback=false] - Skip calling the List.addCallback if this child is added successfully.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
add: function (child, skipCallback)
{
if (Array.isArray(child))
{
2018-04-05 14:28:22 +00:00
return this.addMultiple(child, skipCallback);
}
else
{
// Is child already in this display list?
if (this.getIndex(child) === -1)
{
this.list.push(child);
if (!skipCallback)
{
this.addCallback(this, child);
}
}
return child;
}
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#addAt
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
* @param {integer} [index=0] - [description]
* @param {boolean} [skipCallback=false] - Skip calling the List.addCallback if this child is added successfully.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
addAt: function (child, index, skipCallback)
{
if (index === undefined) { index = 0; }
if (this.list.length === 0)
{
return this.add(child, skipCallback);
}
if (index >= 0 && index <= this.list.length)
{
if (this.getIndex(child) === -1)
{
this.list.splice(index, 0, child);
if (!skipCallback)
{
this.addCallback(this, child);
}
}
}
return child;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#addMultiple
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T[]} - [children,$return]
*
2018-03-23 15:54:12 +00:00
* @param {Array.<*>} children - [description]
* @param {boolean} [skipCallback=false] - Skip calling the List.addCallback if this child is added successfully.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {Array.<*>} [description]
2018-02-09 04:35:23 +00:00
*/
addMultiple: function (children, skipCallback)
{
if (Array.isArray(children))
{
for (var i = 0; i < children.length; i++)
{
this.add(children[i], skipCallback);
}
}
return children;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#getAt
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [$return]
*
2018-02-09 04:35:23 +00:00
* @param {integer} index - [description]
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
getAt: function (index)
{
return this.list[index];
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#getIndex
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
*
* @return {integer} [description]
*/
getIndex: function (child)
{
// Return -1 if given child isn't a child of this display list
return this.list.indexOf(child);
},
2018-02-09 04:35:23 +00:00
/**
* Given an array of objects, sort the array and return it,
* so that the objects are in index order with the lowest at the bottom.
*
* @method Phaser.Structs.List#sort
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T[]} - [children,$return]
*
2018-03-23 15:54:12 +00:00
* @param {Array.<*>} children - [description]
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {Array.<*>} [description]
2018-02-09 04:35:23 +00:00
*/
sort: function (children)
{
if (children === undefined) { children = this.list; }
return children.sort(this.sortIndexHandler.bind(this));
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#sortIndexHandler
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [childA,childB]
*
2018-03-23 15:54:12 +00:00
* @param {*} childA - [description]
* @param {*} childB - [description]
2018-02-09 04:35:23 +00:00
*
* @return {integer} [description]
*/
sortIndexHandler: function (childA, childB)
{
// The lower the index, the lower down the display list they are
var indexA = this.getIndex(childA);
var indexB = this.getIndex(childB);
if (indexA < indexB)
{
return -1;
}
else if (indexA > indexB)
{
return 1;
}
// Technically this shouldn't happen, but if the GO wasn't part of this display list then it'll
// have an index of -1, so in some cases it can
return 0;
},
/**
2018-02-09 04:35:23 +00:00
* Gets the first item from the set based on the property strictly equaling the value given.
* Returns null if not found.
*
* @method Phaser.Structs.List#getByKey
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [value]
2018-03-30 12:43:58 +00:00
* @genericUse {T | null} - [$return]
*
2018-02-09 04:35:23 +00:00
* @param {string} property - The property to check against the value.
2018-03-20 16:15:49 +00:00
* @param {*} value - The value to check if the property strictly equals.
2018-02-09 04:35:23 +00:00
*
* @return {?*} The item that was found, or null if nothing matched.
2018-02-09 04:35:23 +00:00
*/
getByKey: function (property, value)
{
for (var i = 0; i < this.list.length; i++)
{
if (this.list[i][property] === value)
{
return this.list[i];
}
}
return null;
},
/**
2018-02-09 04:35:23 +00:00
* Searches the Group for the first instance of a child with the `name`
* property matching the given argument. Should more than one child have
* the same name only the first instance is returned.
*
* @method Phaser.Structs.List#getByName
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T | null} - [$return]
*
2018-02-09 04:35:23 +00:00
* @param {string} name - The name to search for.
*
* @return {?*} The first child with a matching name, or null if none were found.
2018-02-09 04:35:23 +00:00
*/
getByName: function (name)
{
return this.getByKey('name', name);
},
/**
2018-02-09 04:35:23 +00:00
* Returns a random child from the group.
*
* @method Phaser.Structs.List#getRandom
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T | null} - [$return]
*
2018-02-09 04:35:23 +00:00
* @param {integer} [startIndex=0] - Offset from the front of the group (lowest child).
* @param {integer} [length=(to top)] - Restriction on the number of values you want to randomly select from.
*
* @return {?*} A random child of this Group.
2018-02-09 04:35:23 +00:00
*/
getRandom: function (startIndex, length)
{
if (startIndex === undefined) { startIndex = 0; }
if (length === undefined) { length = this.list.length; }
if (length === 0 || length > this.list.length)
{
return null;
}
var randomIndex = startIndex + Math.floor(Math.random() * length);
return this.list[randomIndex];
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#getFirst
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [value]
2018-03-30 12:43:58 +00:00
* @genericUse {T | null} - [$return]
*
2018-03-19 01:00:21 +00:00
* @param {string} property - [description]
2018-03-20 16:15:49 +00:00
* @param {*} value - [description]
2018-03-19 01:00:21 +00:00
* @param {number} [startIndex=0] - [description]
* @param {number} [endIndex] - [description]
2018-02-09 04:35:23 +00:00
*
* @return {?*} [description]
2018-02-09 04:35:23 +00:00
*/
getFirst: function (property, value, startIndex, endIndex)
{
if (startIndex === undefined) { startIndex = 0; }
if (endIndex === undefined) { endIndex = this.list.length; }
for (var i = startIndex; i < endIndex; i++)
{
var child = this.list[i];
if (child[property] === value)
{
return child;
}
}
return null;
},
/**
2018-02-09 04:35:23 +00:00
* Returns all children in this List.
*
* You can optionally specify a matching criteria using the `property` and `value` arguments.
*
* For example: `getAll('visible', true)` would return only children that have their visible property set.
*
* Optionally you can specify a start and end index. For example if this List had 100 children,
* and you set `startIndex` to 0 and `endIndex` to 50, it would return matches from only
* the first 50 children in the List.
*
* @method Phaser.Structs.List#getAll
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [value]
* @genericUse {T[]} - [$return]
*
2018-02-09 04:35:23 +00:00
* @param {string} [property] - An optional property to test against the value argument.
2018-03-20 16:15:49 +00:00
* @param {*} [value] - If property is set then Child.property must strictly equal this value to be included in the results.
2018-02-09 04:35:23 +00:00
* @param {integer} [startIndex=0] - The first child index to start the search from.
* @param {integer} [endIndex] - The last child index to search up until.
*
2018-03-23 15:54:12 +00:00
* @return {Array.<*>} [description]
2018-02-09 04:35:23 +00:00
*/
getAll: function (property, value, startIndex, endIndex)
{
if (startIndex === undefined) { startIndex = 0; }
if (endIndex === undefined) { endIndex = this.list.length; }
var output = [];
for (var i = startIndex; i < endIndex; i++)
{
var child = this.list[i];
if (property)
{
if (child[property] === value)
{
output.push(child);
}
}
else
{
output.push(child);
}
}
return output;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#count
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [value]
*
2018-02-09 04:35:23 +00:00
* @param {string} property - [description]
2018-03-20 16:15:49 +00:00
* @param {*} value - [description]
2018-02-09 04:35:23 +00:00
*
* @return {integer} [description]
*/
count: function (property, value)
{
var total = 0;
for (var i = 0; i < this.list.length; i++)
{
var child = this.list[i];
if (child[property] === value)
{
total++;
}
}
return total;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#swap
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child1,child2]
*
2018-03-23 15:54:12 +00:00
* @param {*} child1 - [description]
* @param {*} child2 - [description]
2018-02-09 04:35:23 +00:00
*/
swap: function (child1, child2)
{
if (child1 === child2)
{
return;
}
var index1 = this.getIndex(child1);
var index2 = this.getIndex(child2);
if (index1 < 0 || index2 < 0)
{
throw new Error('List.swap: Supplied objects must be children of the same list');
}
this.list[index1] = child2;
this.list[index2] = child1;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#moveTo
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
* @param {integer} index - [description]
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
moveTo: function (child, index)
{
var currentIndex = this.getIndex(child);
if (currentIndex === -1 || index < 0 || index >= this.list.length)
{
throw new Error('List.moveTo: The supplied index is out of bounds');
}
// Remove
this.list.splice(currentIndex, 1);
// Add in new location
this.list.splice(index, 0, child);
return child;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#remove
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
* @param {boolean} [skipCallback=false] - Skip calling the List.removeCallback.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
remove: function (child, skipCallback)
{
var index = this.list.indexOf(child);
if (index !== -1)
{
this.list.splice(index, 1);
if (!skipCallback)
{
this.removeCallback(this, child);
}
}
2018-03-19 01:00:21 +00:00
return child;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#removeAt
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [$return]
*
2018-02-09 04:35:23 +00:00
* @param {integer} index - [description]
* @param {boolean} [skipCallback=false] - Skip calling the List.removeCallback.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
removeAt: function (index, skipCallback)
{
var child = this.list[index];
if (child)
{
this.children.splice(index, 1);
if (!skipCallback)
{
this.removeCallback(this, child);
}
}
return child;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#removeBetween
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T[]} - [$return]
*
* @param {integer} [beginIndex=0] - [description]
* @param {integer} [endIndex] - [description]
* @param {boolean} [skipCallback=false] - Skip calling the List.removeCallback.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {Array.<*>} [description]
2018-02-09 04:35:23 +00:00
*/
removeBetween: function (beginIndex, endIndex, skipCallback)
{
if (beginIndex === undefined) { beginIndex = 0; }
if (endIndex === undefined) { endIndex = this.list.length; }
var range = endIndex - beginIndex;
if (range > 0 && range <= endIndex)
{
var removed = this.list.splice(beginIndex, range);
if (!skipCallback)
{
this.removeCallback(this, removed);
}
return removed;
}
else if (range === 0 && this.list.length === 0)
{
return [];
}
else
{
throw new Error('List.removeBetween: Range Error, numeric values are outside the acceptable range');
}
},
/**
2018-02-09 04:35:23 +00:00
* Removes all the items.
*
* @method Phaser.Structs.List#removeAll
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {Phaser.Structs.List.<T>} - [$return]
*
* @param {boolean} [skipCallback=false] - Skip calling the List.removeCallback.
2018-03-30 12:43:58 +00:00
*
2018-02-09 04:35:23 +00:00
* @return {Phaser.Structs.List} This List object.
*/
removeAll: function (skipCallback)
{
var i = this.list.length;
while (i--)
{
this.remove(this.list[i], skipCallback);
}
return this;
},
/**
2018-02-09 04:35:23 +00:00
* Brings the given child to the top of this List.
*
* @method Phaser.Structs.List#bringToTop
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
bringToTop: function (child)
{
if (this.getIndex(child) < this.list.length)
{
this.remove(child, true);
this.add(child, true);
}
return child;
},
/**
2018-02-09 04:35:23 +00:00
* Sends the given child to the bottom of this List.
*
* @method Phaser.Structs.List#sendToBack
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
sendToBack: function (child)
{
if (this.getIndex(child) > 0)
{
this.remove(child, true);
this.addAt(child, 0, true);
}
return child;
},
/**
2018-02-09 04:35:23 +00:00
* Moves the given child up one place in this group unless it's already at the top.
*
* @method Phaser.Structs.List#moveUp
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
moveUp: function (child)
{
var a = this.getIndex(child);
if (a !== -1 && a < this.list.length - 1)
{
var b = this.getAt(a + 1);
if (b)
{
this.swap(child, b);
}
}
return child;
},
/**
2018-02-09 04:35:23 +00:00
* Moves the given child down one place in this group unless it's already at the bottom.
*
* @method Phaser.Structs.List#moveDown
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T} - [child,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} [description]
2018-02-09 04:35:23 +00:00
*/
moveDown: function (child)
{
var a = this.getIndex(child);
if (a > 0)
{
var b = this.getAt(a - 1);
if (b)
{
this.swap(child, b);
}
}
return child;
},
/**
2018-02-09 04:35:23 +00:00
* Reverses the order of all children in this List.
*
* @method Phaser.Structs.List#reverse
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {Phaser.Structs.List.<T>} - [$return]
*
2018-02-09 04:35:23 +00:00
* @return {Phaser.Structs.List} This List object.
*/
reverse: function ()
{
this.list.reverse();
return this;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @method Phaser.Structs.List#shuffle
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {Phaser.Structs.List.<T>} - [$return]
*
2018-02-09 04:35:23 +00:00
* @return {Phaser.Structs.List} This List object.
*/
shuffle: function ()
{
for (var i = this.list.length - 1; i > 0; i--)
{
var j = Math.floor(Math.random() * (i + 1));
var temp = this.list[i];
this.list[i] = this.list[j];
this.list[j] = temp;
}
return this;
},
/**
2018-02-09 04:35:23 +00:00
* Replaces a child of this List with the given newChild. The newChild cannot be a member of this List.
*
* @method Phaser.Structs.List#replace
* @since 3.0.0
*
2018-03-30 12:43:58 +00:00
* @genericUse {T} - [oldChild,newChild,$return]
*
2018-03-23 15:54:12 +00:00
* @param {*} oldChild - The child in this List that will be replaced.
* @param {*} newChild - The child to be inserted into this List.
2018-02-09 04:35:23 +00:00
*
2018-03-23 15:54:12 +00:00
* @return {*} Returns the oldChild that was replaced within this group.
2018-02-09 04:35:23 +00:00
*/
replace: function (oldChild, newChild)
{
var index = this.getIndex(oldChild);
if (index !== -1)
{
this.remove(oldChild);
this.addAt(newChild, index);
return oldChild;
}
},
/**
2018-02-09 04:35:23 +00:00
* [description]
*
* @method Phaser.Structs.List#exists
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [child]
*
2018-03-23 15:54:12 +00:00
* @param {*} child - [description]
2018-02-09 04:35:23 +00:00
*
* @return {boolean} True if the item is found in the list, otherwise false.
*/
exists: function (child)
{
return (this.list.indexOf(child) > -1);
},
/**
2018-02-09 04:35:23 +00:00
* Sets the property `key` to the given value on all members of this List.
*
* @method Phaser.Structs.List#setAll
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {T} - [value]
*
2018-02-09 04:35:23 +00:00
* @param {string} key - [description]
2018-03-20 16:15:49 +00:00
* @param {*} value - [description]
2018-02-09 04:35:23 +00:00
*/
setAll: function (key, value)
{
for (var i = 0; i < this.list.length; i++)
{
if (this.list[i])
{
this.list[i][key] = value;
}
}
},
/**
2018-02-09 04:35:23 +00:00
* Passes all children to the given callback.
*
* @method Phaser.Structs.List#each
* @since 3.0.0
*
2018-03-29 10:56:47 +00:00
* @genericUse {EachListCallback.<T>} - [callback]
*
* @param {EachListCallback} callback - The function to call.
2018-03-23 15:54:12 +00:00
* @param {*} [thisArg] - Value to use as `this` when executing callback.
2018-03-28 15:00:19 +00:00
* @param {...*} [args] - Additional arguments that will be passed to the callback, after the child.
2018-02-09 04:35:23 +00:00
*/
each: function (callback, thisArg)
{
var args = [ null ];
for (var i = 1; i < arguments.length; i++)
{
args.push(arguments[i]);
}
for (i = 0; i < this.list.length; i++)
{
args[0] = this.list[i];
callback.apply(thisArg, args);
}
},
/**
* [description]
*
* @method Phaser.Structs.List#shutdown
* @since 3.0.0
*/
shutdown: function ()
{
this.removeAll();
},
/**
* [description]
*
* @method Phaser.Structs.List#destroy
* @since 3.0.0
*/
destroy: function ()
{
this.removeAll();
this.list = [];
this.parent = null;
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @name Phaser.Structs.List#length
* @type {integer}
* @readOnly
* @since 3.0.0
*/
length: {
get: function ()
{
return this.list.length;
}
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @name Phaser.Structs.List#first
* @type {integer}
* @readOnly
* @since 3.0.0
*/
first: {
get: function ()
{
this.position = 0;
if (this.list.length > 0)
{
return this.list[0];
}
else
{
return null;
}
}
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @name Phaser.Structs.List#last
* @type {integer}
* @readOnly
* @since 3.0.0
*/
last: {
get: function ()
{
if (this.list.length > 0)
{
this.position = this.list.length - 1;
return this.list[this.position];
}
else
{
return null;
}
}
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @name Phaser.Structs.List#next
* @type {integer}
* @readOnly
* @since 3.0.0
*/
next: {
get: function ()
{
if (this.position < this.list.length)
{
this.position++;
return this.list[this.position];
}
else
{
return null;
}
}
},
2018-02-09 04:35:23 +00:00
/**
* [description]
*
* @name Phaser.Structs.List#previous
* @type {integer}
* @readOnly
* @since 3.0.0
*/
previous: {
get: function ()
{
if (this.position > 0)
{
this.position--;
return this.list[this.position];
}
else
{
return null;
}
}
}
});
module.exports = List;