Как random поменять на Math.random()

[wvxvw]

Кстати, врезультате тестов появилось следующее:

/**
 * ...
 * @author wvxvw
 */
class org.wvxvw.Type
{
	private var _name:String;
	private var _value:Function;
	private static var _tpyeHash:Object = { };
 
	private function Type(value:Function) 
	{
		super();
		if (!value) throw new Error("Cannot resolve type");
		var package:String;
		var nameChain:Array/*String*/;
		_global.ASSetPropFlags(_global, null, 6, true);
		for (var p:String in _global)
		{
			if (_global[p] === value)
			{
				this._name = p;
			}
			if (!(_global[p] instanceof Object)) continue;
			nameChain = this.findRefRecursive(_global[p], [p], value);
			if (nameChain) break;
		}
		if (!this._name)
		{
			if (!nameChain)
			{
				throw new Error("Cannot resolve type");
			}
			else
			{
				this._name = String(nameChain.pop());
				package = nameChain.join(".");
				this._name = package + "::" + this._name;
			}
		}
		this._value = value;
	}
 
	public static function resolveType(value:Function):Type
	{
		for (var p:String in _tpyeHash)
		{
			trace(_tpyeHash[p]);
			if (Type(_tpyeHash[p]).valueOf() == Object(value))
				return Type(_tpyeHash[p]);
		}
		var t:Type;
		t = new Type(value);
		_tpyeHash[t.toString()] = t;
		return t;
	}
 
	public function is(value:Object):Boolean
	{
		switch (this._value)
		{
			case Boolean:
				return typeof value == "boolean";
			case String:
				return typeof value == "string";
			case Number:
				return typeof value == "number";
		}
		return Boolean(this._value(value));
	}
 
	public function valueOf():Object { return this._value; }
 
	private function findRefRecursive(where:Object/*Object*/, 
									nameChain:Array/*String*/,
									meth:Function):Array/*String*/
	{
		var o:Object;
		var nextSibling:Array/*String*/;
		for (var p:String in where)
		{
			o = where[p];
			if (o === meth)
			{
				nameChain.push(p);
				return nameChain;
			}
			else if (o instanceof Object && !(o instanceof Function))
			{
				nextSibling = this.findRefRecursive(o, nameChain.concat([p]), meth);
				if (nextSibling) return nextSibling;
			}
		}
		return null;
	}
 
	public function toString():String { return this._name; }
}

import org.wvxvw.Type;
 
/**
 * ...
 * @author wvxvw
 */
class org.wvxvw.ArrayList
{
	public function get type():Type { return this._type; }
 
	public function get array():Array { return this._array.concat(); }
 
	private var _type:Type;
	private var _array:Array/*T*/;
 
	public function ArrayList(type:Type)/*T*/
	{
		super();
		this._type = type;
		this._array = [];
	}
 
	public function push(param:Object/*Null<T>*/):Number
	{
		if (param === null || this._type.is(param))
			return this._array.push(param);
		throw new Error(param + " is not a a valid type.");
		return NaN;
	}
 
	public function unshift(param:Object/*Null<T>*/):Number
	{
		if (param === null || this._type.is(param))
			return this._array.unshift(param);
		throw new Error(param + " is not a a valid type.");
		return NaN;
	}
 
	public function pop():Object/*Null<T>*/
	{
		return this._array.pop();
	}
 
	public function shift():Object/*Null<T>*/
	{
		return this._array.shift();
	}
 
	public function splice(where:Number, items:Number, 
					replaceWith:ArrayList/*T*/):ArrayList/*T*/
	{
		if (replaceWith && replaceWith.type !== this._type)
			throw new Error("Type mismatch");
		var arr:ArrayList/*T*/ = new ArrayList(this._type)/*T*/;
		var clone:Array;
		var cloneHead:Array = this._array.slice(0, where);
		var cloneTail:Array = this._array.slice(where + items, this._array.length);
		var insert:Array
		if (replaceWith)
		{
			insert = replaceWith.array;
			clone = cloneHead.concat(insert.concat(cloneTail));
		}
		else clone = cloneHead.concat(cloneTail);
		ArrayList/*T*/.setSource(arr, clone);
		return arr;
	}
 
	public function slice(from:Number, to:Number):ArrayList/*T*/
	{
		var arr:Array = this._array.splice(from, to);
		var arrList:ArrayList = new ArrayList(this._type)/*T*/;
		ArrayList/*T*/.setSource(arrList, arr);
		return arrList;
	}
 
	public function toString():String
	{
		return "ArrayList<" + this._type + ">[" + this._array.join(", ") + "]";
	}
 
	private static function setSource(to:ArrayList/*T*/, source:Array/*T*/):Void
	{
		to._array = source;
	}
}

Нечем было заняться

Самое интересное то, что если вычитать а не складывать, то результат опять же будет неправильным... и если последовательно трейсить trace(a) в первом цикле, то видно, что иногда массив не изменяется... вобщем, скорее всего какай-нибудь пропущенная команда в сгенерированом коде, либо плеер неправильно читает команду (забывает при каких-то обстоятельствах)...