Haxe implementation for http://www.squidi.net/three/entry.php?id=166

TileRules.hx

private typedef TileRule = 
{
    var tileIndex:Int;
    var map:{nw:String, n:String, ne:String, w:String, e:String, sw:String, s:String, se:String};
}

private typedef TileType =
{
    var typeStr:String;
    var defaultTileIndex:Int;
    var rules:Array<TileRule>;
}

private typedef GetTileTypeFunction = Int->Int->String;

class TileRules
{
    var getTileType:GetTileTypeFunction;
    var tileTypes:Map<String, TileType>;

    public function new(types:Dynamic<TileType>, getTileType:GetTileTypeFunction)
    {
        this.getTileType = getTileType;
        tileTypes = new Map();
        for (type in Reflect.fields(types))
        {
            var typeData:TileType = Reflect.field(types, type);
            typeData.typeStr = type;
            tileTypes.set(type, typeData);
        }
    }

    inline function getTypeAt(x:Int, y:Int):TileType
    {
        return tileTypes.get(getTileType(x, y));
    }

    function checkType(x:Int, y:Int, ruleTypeStr:String, baseType:TileType)
    {
        var type = getTypeAt(x, y);
        
        if (type == null)
        {
            if (ruleTypeStr == "NIL")
                return true;
            type = baseType;
        }
        
        if (ruleTypeStr == null || ruleTypeStr == "ANY")
            return true;
            
        if (ruleTypeStr.charAt(0) == "!")
            return (type.typeStr != ruleTypeStr.substr(1));
        else
            return (ruleTypeStr == type.typeStr);
    }

    function checkRule(rule:TileRule, x:Int, y:Int):Bool
    {
        var base = getTypeAt(x, y);
        
        if (!checkType(x-1, y-1, rule.map.nw, base)) return false;
        if (!checkType(x,   y-1, rule.map.n,  base)) return false;
        if (!checkType(x+1, y-1, rule.map.ne, base)) return false;
        if (!checkType(x-1, y,   rule.map.w,  base)) return false;
        if (!checkType(x+1, y,   rule.map.e,  base)) return false;
        if (!checkType(x-1, y+1, rule.map.sw, base)) return false;
        if (!checkType(x,   y+1, rule.map.s,  base)) return false;
        if (!checkType(x+1, y+1, rule.map.se, base)) return false;
        
        return true;
    }

    public function getViewIndexForType(x:Int, y:Int):Int
    {
        var base = getTypeAt(x, y);
        if (base == null)
            return -1;

        for (rule in base.rules)
        {
            if (checkRule(rule, x, y))
                return rule.tileIndex;
        }
        
        return base.defaultTileIndex;
    }
}