gamestate.hx

package;

import effects.Ripple;
import effects.Tile;
import flixel.group.FlxGroup;
import flixel.math.FlxPoint;
import flixel.math.FlxRect;
import openfl.display.Tileset;
import registry.REG;
import flixel.FlxG;
import flixel.FlxSprite;
import flixel.FlxState;
import flixel.text.FlxText;
import flixel.util.FlxColor;
import flixel.math.FlxMath;
import flixel.tile.FlxTilemap;
import flixel.addons.editors.ogmo.FlxOgmoLoader;
import flixel.FlxObject;
import flixel.util.FlxSort;
import flixel.math.FlxMath;

class GameState extends FlxState
{
    //Map
    public var tileMap:FlxOgmoLoader;
    public var floor:FlxTilemap;
    public var maxAng:Float = 8;
    public var tiles:FlxTypedGroup<Tile>;

    //Background
    public var baseBG:FlxSprite;
    public var layer1:FlxTypedGroup<FlxSprite>;
    public var layer2:FlxTypedGroup<FlxSprite>;
    public var layer3:FlxTypedGroup<FlxSprite>;

    //Details
    public var ripples:FlxTypedGroup<Ripple>;
    public var shadows:FlxTypedGroup<FlxSprite>;

    //Entities
    public var entities:FlxTypedGroup<Entity>;

    public var player:Player;

    override public function create():Void
    {
        super.create();

        REG.applyOptions();

        //Tilemap
        tileMap = new FlxOgmoLoader('assets/maps/' + REG.levelType + '_' + Std.string(REG.levelID) + '.oel');

        floor = tileMap.loadTilemap('assets/maps/tiles/' + REG.levelType + '.png', 96, 96, "tiles");

        tiles = new FlxTypedGroup<Tile>();

        //Backgrounds
        baseBG = new FlxSprite(0, 0, 'assets/sprites/backgrounds/base.png');
        layer1 = new FlxTypedGroup<FlxSprite>();
        layer2 = new FlxTypedGroup<FlxSprite>();
        layer3 = new FlxTypedGroup<FlxSprite>();
        ripples = new FlxTypedGroup<Ripple>();

        /*for (i in 0 ... 16)
        {
            var r:Ripple = new Ripple(FlxG.random.float(106.5, FlxG.width - 106.5), FlxG.random.float(80, FlxG.height - 80), 2, false);
            ripples.add(r);
        }*/

        getTBG(1, layer1);
        getTBG(2, layer2);
        getTBG(3, layer3);

        addObjects();
    }

    //Get Tiled Backdrops
    function getTBG(LayerID:Int, Layer:FlxTypedGroup<FlxSprite>)
    {
        var tS:FlxPoint = new FlxPoint(200, 182); //Tile Size
        var T:FlxPoint = new FlxPoint(FlxG.width / tS.x, FlxG.height / tS.y);

        for (i in 0 ... Math.round(T.y + 1))
        {
            for (b in 0 ... Math.round(T.x + 1))
            {
                var d:FlxSprite = new FlxSprite(b * tS.x, i * tS.y, 'assets/sprites/backgrounds/layer' + Std.string(LayerID) + '.png');

                switch(LayerID)
                {
                    case 1:
                        d.velocity.y = -10;
                        d.alpha = 0.2;
                    case 2:
                        d.alpha = 0.2;
                    case 3:
                        d.velocity.y = -20;
                        d.alpha = 0.3;

                }

                if (LayerID == 2)
                {
                    d.loadGraphic('assets/sprites/backgrounds/layer2.png', true, 200, 182);
                    d.animation.add('water', [0, 1, 2, 3, 4, 5, 6, 7, 8], 8, true);
                    d.animation.play('water', true);
                }

                Layer.add(d);
            }
        }
    }

    //Convert tiles to sprites
    function convertTiles():Void
    {
        var mS:FlxPoint = new FlxPoint(floor.widthInTiles, floor.heightInTiles);

        for (i in 0 ... Std.int(mS.x))
        {
            for (b in 0 ... Std.int(mS.y))
            {
                if (floor.getTile(i, b) != 0)
                {
                    var sprite:FlxSprite;
                    sprite = floor.tileToSprite(i, b, 0);
                    sprite.angle = FlxG.random.float( -maxAng, maxAng);
                    sprite.alive = false; //For seeing if it's pushed down or not
                    tiles.add(new Tile(0, 0, this, sprite));
                    //Maybe do some more dynamic stuff here later, like if the tile is overlapping a beacon
                }
            }
        }
    }

    //Get entities
    function loadEntities(name:String, data:Xml):Void
    {
        var x:Int = Std.parseInt(data.get("x"));
        var y:Int = Std.parseInt(data.get("y"));

        switch (name)
        {
            case 'player':
                player.x = x - 32;
                player.y = y - 32;
        }
    }

    //Add Objects

    function addObjects()
    {
        //Load Objects
        entities = new FlxTypedGroup<Entity>();
        shadows = new FlxTypedGroup<FlxSprite>();

        player = new Player(0, 0, this);

        //Load Entities
        tileMap.loadEntities(loadEntities, 'entities');
        convertTiles();
        tiles.sort(FlxSort.byY);

        //BG
        add(baseBG);
        add(layer1);
        add(layer2);
        add(layer3);
        add(ripples);

        //Tilemap
        add(tiles);

        //Entities
        entities.add(player);

        //Add Groups
        add(shadows);
        add(entities);
    }

    function setTileProperties(Layer:FlxTilemap, T:Array<Int>)
    {
        var tmap:FlxTilemap = Layer;

        for (i in 1 ... T.length)
        {
            tmap.setTileProperties(i, T[i-1]);
        }

        return tmap;
    }

    override public function update(elapsed:Float):Void
    {
        super.update(elapsed);

        layer1.forEach(bgTile);
        layer2.forEach(bgTile);
        layer3.forEach(bgTile);

        entities.sort(FlxSort.byY);

        FlxG.overlap(tiles, entities, sinkTiles);

        tiles.forEachAlive(function (T:Tile)
        {
            if (!FlxG.overlap(entities, T))
                T.floatUp();
        });

    }

    function sinkTiles(T:Tile, E:Entity)
    {
        if (T.alive == false)
            T.startSink();
    }

    function bgTile(S:FlxSprite)
    {
        if (S.y <= -182)
            S.y = FlxG.height+12;
    }

}