Defender's Quest Performance Profiling References

AABB.hx

package com.leveluplabs.tdrpg.qtree;
import com.leveluplabs.tdrpg.Popup_OverworldMenu;
import flixel.util.FlxDestroyUtil.IFlxDestroyable;
import flixel.util.FlxPool;

/**
 * ...
 * @author larsiusprime
 */
class AABB implements IFlxDestroyable
{
	public var center_x:Float;
	public var center_y:Float;
	public var halfSize_x:Float;
	public var halfSize_y:Float;
	private var destroyed:Bool = false;
	
	private static var pool:FlxPool<AABB> = new FlxPool<AABB>(AABB);
	
	public function destroy()
	{
		destroyed = true;
		center_x = 0;
		center_y = 0;
		halfSize_x = 0;
		halfSize_y = 0;
	}
	
	public function new(){}
	
	public static function put(aabb:AABB)
	{
		if (aabb == null) return;
		if (@:privateAccess aabb.destroyed) return;
		pool.putUnsafe(aabb);
	}
	
	public static function get(Center_x:Float, Center_y:Float, HalfSize_x:Float, HalfSize_y:Float):AABB
	{
		var aabb = pool.get();
		@:privateAccess aabb.destroyed = false;
		aabb.center_x = Center_x;
		aabb.center_y = Center_y;
		aabb.halfSize_x = HalfSize_x;
		aabb.halfSize_y = HalfSize_y;
		return aabb;
	}
	
	public static function create(Center_x:Float,Center_y:Float,HalfSize_x:Float,HalfSize_y:Float):AABB
	{
		var aabb = new AABB();
		aabb.center_x = Center_x;
		aabb.center_y = Center_y;
		aabb.halfSize_x = HalfSize_x;
		aabb.halfSize_y = HalfSize_y;
		return aabb;
	}
	
	public inline function set(centerX:Float, centerY:Float, halfX:Float, halfY:Float):Void
	{
		center_x = centerX;
		center_y = centerY;
		halfSize_x = halfX;
		halfSize_y = halfY;
	}
	
	public inline function containsPoint(X:Float,Y:Float):Bool
	{
		var value = false;
		if (X >= center_x - halfSize_x && X <= center_x + halfSize_x)
		{
			if (Y >= center_y - halfSize_y && Y <= center_y + halfSize_y)
			{
				value = true;
			}
		}
		return value;
	}
	
	public inline function intersectAABB(other:AABB):Bool
	{
		var x1 = (center_x - other.center_x);
		if (x1 < 0) x1 *= -1;
		
		var y1 = (center_y - other.center_y);
		if (y1 < 0) y1 *= -1;
		
		if (x1 > (halfSize_x + other.halfSize_x)) return false;
		if (y1 > (halfSize_y + other.halfSize_y)) return false;
		
		return true;
	}
}

ByteMap.hx

package com.leveluplabs.tdrpg;
import haxe.io.BytesData;
import lime.utils.Bytes;

/**
 * ...
 * @author 
 */
class ByteMap 
{
	private var bytes:Bytes;
	
	public var width:Int;
	public var height:Int;
	
	private static inline var MAX:Int = 255;
	
	public function new(w:Int,h:Int) 
	{
		var mapSize = Math.ceil(w * h);
		width = w;
		height = h;
		bytes = Bytes.alloc(mapSize);
	}
	
        public function print():String
        {
            var str = "";
            for(i in 0...height)
            {
              str = "";
              for(j in 0...width)
              {
                  var value = bytes.get(i*width+j);
                  str += value + " ";
              }
              trace(str);
            }
            return str;
        }
    
	public function peek(x:Int, y:Int):Int
	{
            if (false == (x >= 0 && y >= 0 && x < width && y < height))
	    {
		return 0;
	    }
	    var i = y * width + x;
	    return bytes.get(i);
	}
	
	public function poke(x:Int, y:Int, value:Int)
	{
            if (false == (x >= 0 && y >= 0 && x < width && y < height))
	    {
	        return;
	    }
	    var i = y * width + x;
	    return bytes.set(i,value);
	}
	
	public function clear()
	{
	    bytes.fill(0, bytes.length, 0);
	}
	
	public function blit(x:Int, y:Int, w:Int, h:Int, value:Int)
	{
	    if (x < 0) x = 0;
	    if (y < 0) y = 0;
            if (x + w >= width) w = (width-x);
            if (y + h >= height) h = (height-y);
		
            for (i in 0...h)
	    {
		var row = y + i;
		var pos = row * width + x;
                bytes.fill(pos, w, value);
	    }
	}
	
	public function blitEmptyTest(x:Int, y:Int, w:Int, h:Int, value:Int):Float
	{
	    if (x < 0) x = 0;
	    if (y < 0) y = 0;
            if (x + w >= width) w = (width-x);
            if (y + h >= height) h = (height-y);
		
            var area = w * h;
	    var cells = 0;
	    var emptyCells = 0;
		
            for (i in 0...h)
	    {
		var row = y + i;
		var pos = row * width + x;
		for (j in pos...pos + w)
		{
                    var v = bytes.get(j);
	            cells += v;
		    v += value;
		    if (v == 0)
		    {
			emptyCells++;
		    }
		    if (v < MAX)
		    {
			bytes.set(j, v);
		    }
		}
	    }
		
	    if (emptyCells > 0) return 0;
	    return cells / area;
	}
}

XYVector.hx

package com.leveluplabs.tdrpg.qtree;
import flixel.util.FlxDestroyUtil.IFlxDestroyable;
import flixel.util.FlxPool;
import haxe.ds.Vector;

/**
 * ...
 * @author 
 */
class XYVector implements IFlxDestroyable
{
	public var size(default, null):Int;
	private var xy:Vector<Float>;
	private var int_id:Vector<Int>;
	private var destroyed:Bool = false;
	
	public static inline var CAPACITY:Int = 64;
	private static var pool:FlxPool<XYVector> = new FlxPool<XYVector>(XYVector);
	
	public function new()
	{
		size = 0;
		xy = new Vector<Float>(CAPACITY*2);
		int_id = new Vector<Int>(CAPACITY*2);
	}
	
	public static function put(xy:XYVector)
	{
		if (xy == null) return;
		if (@:privateAccess xy.destroyed) return;
		pool.putUnsafe(xy);
	}
	
	public static function get():XYVector
	{
		var xy = pool.get();
		@:privateAccess xy.destroyed = false;
		return xy;
	}
	
	public function destroy()
	{
		destroyed = true;
		clear();
	}
	
	public inline function clear()
	{
		for (i in 0...size)
		{
			var index = i * 2;
			xy[index] = 0.0;
			xy[index + 1] = 0.0;
			int_id[index] = 0;
			int_id[index + 1] = 0;
		}
		size = 0;
	}
	
	public inline function set(i:Int, X:Float, Y:Float, int:Int, id:Int)
	{
		var index = i * 2;
		xy[index] = X;
		xy[index + 1] = Y;
		int_id[index] = int;
		int_id[index + 1] = id;
	}
	
	public inline function getX(i:Int):Float{ return xy[i * 2]; }
	public inline function getY(i:Int):Float{ return xy[(i * 2) + 1]; }
	public inline function getInt(i:Int):Int { return int_id[i * 2]; }
	public inline function getId(i:Int):Int { return int_id[(i * 2) + 1]; }
}