super-snuvi/src/me/hammerle/supersnuvi/gamelogic/Level.java

package me.hammerle.supersnuvi.gamelogic;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import me.hammerle.snuviscript.code.Script;
import me.hammerle.supersnuvi.Game;
import me.hammerle.supersnuvi.entity.Entity;
import me.hammerle.supersnuvi.entity.EntityBuilder;
import me.hammerle.supersnuvi.rendering.TileUpdater;
import me.hammerle.supersnuvi.tiles.Location;
import me.hammerle.supersnuvi.tiles.Tile;
import me.hammerle.supersnuvi.util.CollisionObject;
import me.hammerle.supersnuvi.util.Utils;

public abstract class Level
{
    // -------------------------------------------------------------------------
    // level data
    // -------------------------------------------------------------------------
    
    private final TileUpdater tileUpdater = new TileUpdater();
    
    public abstract LevelData getData();
    
    public String getName()
    {
        return "Unknown";
    }
    
    public String getFileName()
    {
        return "Unknown";
    }
    
    public final TileUpdater getTileUpdater()
    {
        return tileUpdater;
    }
    
    // -------------------------------------------------------------------------
    // level stats
    // -------------------------------------------------------------------------
    
    public int getCurrentBottles()
    {
        return 0;
    }
    
    public int getMaxBottles()
    {
        return 0;
    }
    
    public void addBottles(int bottles)
    {
    }
    
    public float getTime()
    {
        return 0;
    }
    
    public void addMessage(String message)
    {
    }
    
    public String getMessage()
    {
        return null;
    }
    
    // -------------------------------------------------------------------------
    // entity related
    // -------------------------------------------------------------------------
    
    private final HashMap<Integer, Entity> entities = new HashMap<>();
    private final LinkedList<Entity> spawnQueue = new LinkedList<>();
    private Entity hero = null;
    private int entityCounter = 0;
    
    public final Entity getHero()
    {
        return hero;
    }
    
    public final void setHero(Entity hero)
    {
        this.hero = hero;
    }
    
    public final void removeEntities()
    {
        entities.clear();
    }
    
    public final void spawnEntity(Entity ent)
    {
        spawnQueue.add(ent);
    }
    
    public final void tickEntities()
    {
        entities.values().removeIf(ent -> 
        {
            ent.tick(this);
            if(ent.getHealth().shouldDespawn() || (ent.getY() > getData().getHeight() * Tile.SIZE))
            {
                ent.getHealth().onDespawn();
                callEvent("entity_despawn", (sc) -> 
                {
                    sc.setVar("entity", ent);
                }, null);
                return true;
            }
            return false;
        });

        if(!spawnQueue.isEmpty())
        {
            spawnQueue.forEach(ent -> 
            {
                entities.put(entityCounter++, ent);
                callEvent("entity_spawn", (sc) -> 
                {
                    sc.setVar("entity", ent);
                }, null);
            });
            spawnQueue.clear();
        }
    }
    
    public final List<Entity> getEntitiesCollidingWith(Entity not, CollisionObject cb)
    {
        return entities.values().stream().filter(ent -> ent != not && ent.getBox().isColliding(cb)).collect(Collectors.toList());
    }
    
    public final void forEachEntity(Consumer<Entity> c)
    {
        entities.values().forEach(c);
    }
    
    // -------------------------------------------------------------------------
    // controlling
    // -------------------------------------------------------------------------
    
    private boolean shouldReset = false;
    private boolean done = false;
    
    public abstract void tick();
    
    public final void finishLevel()
    {
        shouldReset = true;
        done = true;
    }
    
    public final boolean isFinished()
    {
        return done;
    }
    
    public final boolean shouldReset()
    {
        return shouldReset;
    }
    
    public final void scheduleReset()
    {
        shouldReset = true;
    }
    
    public final void reset()
    {
        onReset();
        shouldReset = false;
        done = false;
        
        // spawn entities
        getData().forEachEntity((x, y, tile) -> 
        {
            if(tile > 0)
            {
                Entity ent = EntityBuilder.fromId(tile, this, Utils.toCoord(x), Utils.toCoord(y));
                if(ent != null)
                {
                    entities.put(entityCounter++, ent);
                }
            }
        }, 0, getData().getWidth(), 0, getData().getHeight());
    }
    
    protected void onReset()
    {
    };
    
    // -------------------------------------------------------------------------
    // collision
    // -------------------------------------------------------------------------
    
    private Tile getInteractionTile(int x, int y)
    {
        int i = getData().getInteractionTile(x, y);
        if(i == -1)
        {
            return Game.FALLBACK_TILE;
        }
        return Game.get().getTile(i);
    }
    
    private CollisionObject getMovementBox(int x, int y)
    {
        int i = getData().getInteractionTile(x, y);
        if(i == -1)
        {
            return CollisionObject.NULL_BOX;
        }
        return Game.get().getTile(i).getMovementBox(x, y, this).reset().offset(Utils.toCoord(x), Utils.toCoord(y));
    }
    
    public final List<CollisionObject> getMovementBoxesAt(CollisionObject box, Entity not)
    {
        List<CollisionObject> boxes;
        if(not != null)
        {
            boxes = getEntitiesCollidingWith(not, box).stream().map(ent -> ent.getBox()).collect(Collectors.toList());
        }
        else
        {
            boxes = new LinkedList<>();
        }
        int startX = Utils.toBlock(box.getMinX());
        int endX = Utils.toBlock(box.getMaxX());
        int startY = Utils.toBlock(box.getMinY());
        int endY = Utils.toBlock(box.getMaxY());
        
        for(int x = startX; x <= endX; x++)
        {
            for(int y = startY; y <= endY; y++)
            {
                CollisionObject cb = getMovementBox(x, y);
                if(cb.mayCollide(box) && cb != CollisionObject.NULL_BOX)
                {
                    boxes.add(cb.copy());
                }
            }
        }
        return boxes;
    }
    
    private CollisionObject getCollisionBox(int x, int y)
    {
        int i = getData().getInteractionTile(x, y);
        if(i == -1)
        {
            return CollisionObject.NULL_BOX;
        }
        return Game.get().getTile(i).getCollisionBox(x, y, this).reset().offset(Utils.toCoord(x), Utils.toCoord(y));
    }
    
    public final List<Location> getCollisionBoxesAt(CollisionObject cb)
    {
        LinkedList<Location> boxes = new LinkedList<>();
        int startX = Utils.toBlock(cb.getMinX());
        int endX = Utils.toBlock(cb.getMaxX());
        int startY = Utils.toBlock(cb.getMinY());
        int endY = Utils.toBlock(cb.getMaxY());
        
        for(int x = startX; x <= endX; x++)
        {
            for(int y = startY; y <= endY; y++)
            {
                if(getCollisionBox(x, y).isColliding(cb))
                {
                    boxes.add(new Location(getInteractionTile(x, y), this, x, y));
                }
            }
        }
        return boxes;
    }
    
    // -------------------------------------------------------------------------
    // scripting
    // -------------------------------------------------------------------------
    
    public void callEvent(String name, Consumer<Script> before, Consumer<Script> after)
    {
    }
    
    public final void callEvent(String name)
    {
        callEvent(name, null, null);
    }
}