super-snuvi/src/me/hammerle/supersnuvi/Game.java

package me.hammerle.supersnuvi;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import me.hammerle.snuviengine.api.ColorRenderer;
import me.hammerle.snuviengine.api.Engine;
import me.hammerle.snuviengine.api.FontRenderer;
import me.hammerle.snuviengine.api.KeyBinding;
import me.hammerle.snuviengine.api.Shader;
import me.hammerle.supersnuvi.gamelogic.Level;
import me.hammerle.supersnuvi.savegame.SimpleConfig;
import me.hammerle.supersnuvi.tiles.*;
import me.hammerle.supersnuvi.util.SoundUtils;

public class Game extends Engine
{
    public static final int MS_PER_TICK = 50;
    public static final float SECS_PER_TICK = MS_PER_TICK / 1000.0f;
    
    public static int getTicksForMillis(int millis)
    {
        return millis / MS_PER_TICK;
    }
    
    private static Game instance;
    
    public static Game get()
    {
        return instance;
    }
    
    // constants
    public static final NullTile FALLBACK_TILE = new NullTile();
    
    // tiles
    private final HashMap<Integer, Tile> registeredTiles = new HashMap<>();;
    
    // levels
    private Level currentLevel = null;
    private final Level[] levels;
    private int levelIndex = 0;
    
    // config and savegames
    private final SimpleConfig config = new SimpleConfig("options.txt", true);
    private final SimpleConfig[] saveSlots = new SimpleConfig[] 
    {
        new SimpleConfig("slot1.txt", true), 
        new SimpleConfig("slot2.txt", true), 
        new SimpleConfig("slot3.txt", true)
    };
    
    private int screen = 0;
    private int startScreenIndex = 0;
    private int optionScreenIndex = 0;
    private int slotScreenIndex = 0;
    
    private boolean optionsDirty = false;
    
    // sound
    private boolean sound = config.getBoolean("sound", false);

    public Game()
    {
        instance = this;
        registerTiles();
        
        File[] files = new File("./levels").listFiles();
        Arrays.sort(files, (o1, o2) -> o1.compareTo(o2));
        ArrayList<Level> levelList = new ArrayList<>();
        for(File file : files)
        {
            if(file.isFile())
            {
                Level l = new Level(file);
                levelList.add(l);
            }
        }
        levels = levelList.toArray(new Level[levelList.size()]);
    }
    
    @Override
    public void init()
    {
        setMaxFps(120);
        setNanosPerTick(MS_PER_TICK * 1_000_000);
    }
    
    // -------------------------------------------------------------------------
    // tick, rendering
    // -------------------------------------------------------------------------

    @Override
    public void tick()
    {
        if(currentLevel != null)
        {
            SoundUtils.playSound(SoundUtils.Sound.SONG_1);
            SoundUtils.stopSound(SoundUtils.Sound.MENU_MUSIC);
            
            currentLevel.tick();
            
            // doing that here to prevent concurent modification
            if(currentLevel.shouldFinish())
            {
                String base = "level." + currentLevel.getFileName();
                SimpleConfig sp = saveSlots[slotScreenIndex];
                
                // save success
                sp.set(base, true);
                
                // update time, if a new highscore was scored
                double time = sp.getDouble(base + ".time", Integer.MAX_VALUE);
                if(currentLevel.getTime() < time)
                {
                    sp.set(base + ".time", currentLevel.getTime());
                }
                
                // update bottles, if a new highscore was scored
                int bottles = sp.getInt(base + ".bottles", 0);
                if(currentLevel.getCurrentBottles() > bottles)
                {
                    sp.set(base + ".bottles", currentLevel.getCurrentBottles());
                }
                
                // final save
                sp.save();
                
                currentLevel.resetLevel();
                currentLevel = null;
                return;
            }
            
            if(currentLevel.shouldReset())
            {
                if(currentLevel.resetLevel())
                {
                    currentLevel = null;
                }
            }
            
            if(Keys.ESCAPE.isReleased())
            {
                currentLevel = null;
            }
        }
        else
        {
            SoundUtils.playSound(SoundUtils.Sound.MENU_MUSIC);
            SoundUtils.stopSound(SoundUtils.Sound.SONG_1);
            switch(screen)
            {
                case 0: // start screen
                {
                    menuMove(() -> 
                    {
                        // do nothing on escape in start screen
                    }, () -> 
                    {
                        switch(startScreenIndex)
                        { 
                            case 0:
                                screen = 1;
                                break;
                            case 1:
                                screen = 2;
                                break;
                            case 2:
                                stop();
                                break;
                        }
                    }, () -> startScreenIndex++, () -> startScreenIndex--, () -> 
                    {
                        if(startScreenIndex < 0)
                        {
                            startScreenIndex = 0;
                        }
                        else if(startScreenIndex >= 3)
                        {
                            startScreenIndex = 2;
                        }
                    });
                    break;
                }
                case 1: // slot screen
                {
                    menuMove(() -> 
                    {
                        screen = 0;
                    }, () -> 
                    {
                        if(slotScreenIndex == 3)
                        {
                            screen = 0;
                            return;
                        }
                        screen = 3;
                    }, () -> slotScreenIndex++, () -> slotScreenIndex--, () -> 
                    {
                        if(slotScreenIndex < 0)
                        {
                            slotScreenIndex = 0;
                        }
                        else if(slotScreenIndex >= 4)
                        {
                            slotScreenIndex = 3;
                        }
                    });
                    break;
                }
                case 2: // option screen
                {
                    menuMove(() -> 
                    {
                        screen = 0;
                    }, () -> 
                    {
                        switch(optionScreenIndex)
                        {
                            case 0: // toggle sound
                                sound = !sound;
                                if(!sound)
                                {
                                    SoundUtils.turnSoundOff();
                                }
                                optionsDirty = true;
                                break;
                            case 15: // save options
                                Keys.write(config);
                                config.set("sound", sound);
                                config.save();
                                optionsDirty = false;
                                break;
                            case 16: // go back
                                screen = 0;
                                break;
                            default: // rebind keys
                                Keys.rebind(Keys.get(optionScreenIndex - 1));
                                optionsDirty = true;
                                break;
                        }
                    }, () -> optionScreenIndex++, () -> optionScreenIndex--, () -> 
                    {
                        if(optionScreenIndex < 0)
                        {
                            optionScreenIndex = 0;
                        }
                        int options = Keys.getAmount() + 3;
                        if(optionScreenIndex >= options)
                        {
                            optionScreenIndex = options - 1;
                        }
                    });
                    break;
                }
                case 3: // level choose screen
                {                   
                    menuMove(() -> 
                    {
                        screen = 1;
                    }, () -> currentLevel = levels[levelIndex], () -> levelIndex++, () -> levelIndex--, () -> 
                    {
                        if(levelIndex < 0)
                        {
                            levelIndex = 0;
                        }
                        else if(levelIndex >= levels.length)
                        {
                            levelIndex = levels.length - 1;
                        }
                    });
                    break;
                }
            }
        }
    }
    
    public void tickTiles()
    {
        registeredTiles.values().forEach(tile -> tile.tick());
    }
    
    private final static int COLOR_BROWN = 0xFF13458B;
    private final static int COLOR_OVERLAY = 0x77000000;

    private String getKeyName(KeyBinding key)
    {
        if(key.isRebinding())
        {
            return "[...]";
        }
        return key.getName();
    }
    
    @Override
    public void renderTick(float lag)
    {
        if(currentLevel != null)
        {
            currentLevel.renderTick(lag);
            return;
        }
        Shader.translateTo(0.0f, 0.0f);
        Shader.updateMatrix();
        switch(screen)
        {
            case 0:
            {
                ColorRenderer cr = Shader.getColorRenderer();
                FontRenderer fr = Shader.getFontRenderer();
                
                float width = Shader.getViewWidth();
                float height = Shader.getViewHeight();
                
                float line = fr.getHeight();
                
                float left = width * 0.25f;
                float right = width * 0.75f;
                float top = (height - line * 7.0f) * 0.5f;
                float bottom = top + line * 7.0f;
                
                Shader.setTextureEnabled(false);
                Shader.setColorEnabled(true);
                
                // brown background
                cr.drawRectangle(0, 0, width, height, COLOR_BROWN); 
                
                Shader.setBlendingEnabled(true);
                cr.drawRectangle(left, top, right, bottom, COLOR_OVERLAY);
                float base = top + (3 + startScreenIndex) * line;
                cr.drawRectangle(left, base, right, base + line, COLOR_OVERLAY);
                Shader.setBlendingEnabled(false);
                        
                Shader.setTextureEnabled(true);
                float y = top + line;
                y = fr.drawString(left + line, y, "Super Snuvi"); 
                y += line;
                y = fr.drawString(left + line, y, "Start Game"); 
                y = fr.drawString(left + line, y, "Options"); 
                fr.drawString(left + line, y, "Exit Game");
                break;
            }
            case 1:
            {
                ColorRenderer cr = Shader.getColorRenderer();
                FontRenderer fr = Shader.getFontRenderer();
                
                float width = Shader.getViewWidth();
                float height = Shader.getViewHeight();
                
                float line = fr.getHeight();
                
                float left = width * 0.25f;
                float right = width * 0.75f;
                float top = (height - line * 8.0f) * 0.5f;
                float bottom = top + line * 8.0f;
                
                Shader.setTextureEnabled(false);
                Shader.setColorEnabled(true);
                
                // brown background
                cr.drawRectangle(0, 0, width, height, COLOR_BROWN); 
                
                Shader.setBlendingEnabled(true);
                cr.drawRectangle(left, top, right, bottom, COLOR_OVERLAY);
                float base = top + (3 + slotScreenIndex) * line;
                cr.drawRectangle(left, base, right, base + line, COLOR_OVERLAY);
                Shader.setBlendingEnabled(false);
                        
                Shader.setTextureEnabled(true);
                float y = top + line;
                y = fr.drawString(left + line, y, "Choose a Savegame"); 
                y += line;
                y = fr.drawString(left + line, y, "Slot 1"); 
                y = fr.drawString(left + line, y, "Slot 2"); 
                y = fr.drawString(left + line, y, "Slot 3"); 
                fr.drawString(left + line, y, "Back"); 
                break;
            }
            case 2:
            {
                ColorRenderer cr = Shader.getColorRenderer();
                FontRenderer fr = Shader.getFontRenderer();
                
                float width = Shader.getViewWidth();
                float height = Shader.getViewHeight();
                
                float line = fr.getHeight();
                
                float left = width * 0.2f;
                float right = width * 0.8f;
                float top = (height - line * 21.0f) * 0.5f;
                float bottom = top + line * 21.0f;
                
                Shader.setTextureEnabled(false);
                Shader.setColorEnabled(true);
                
                // brown background
                cr.drawRectangle(0, 0, width, height, COLOR_BROWN); 
                
                Shader.setBlendingEnabled(true);
                cr.drawRectangle(left, top, right, bottom, COLOR_OVERLAY);
                float base = top + (3 + optionScreenIndex) * line;
                cr.drawRectangle(left, base, right, base + line, COLOR_OVERLAY);
                Shader.setBlendingEnabled(false);
                        
                Shader.setTextureEnabled(true);
                left += line;
                float secLeft = right - line * 11;
                float y = top + line;
                y = fr.drawString(left, y, "Options"); 
                y += line;
                fr.drawString(left, y, "Sound"); 
                y = fr.drawString(secLeft, y, sound ? "yes" : "no"); 
                fr.drawString(left, y, "K: Up");
                y = fr.drawString(secLeft, y, getKeyName(Keys.UP)); 
                fr.drawString(left, y, "K: Down");
                y = fr.drawString(secLeft, y, getKeyName(Keys.DOWN)); 
                fr.drawString(left, y, "K: Left");
                y = fr.drawString(secLeft, y, getKeyName(Keys.LEFT)); 
                fr.drawString(left, y, "K: Right");
                y = fr.drawString(secLeft, y, getKeyName(Keys.RIGHT)); 
                fr.drawString(left, y, "K: Jump");
                y = fr.drawString(secLeft, y, getKeyName(Keys.JUMP)); 
                fr.drawString(left, y, "K: Run");
                y = fr.drawString(secLeft, y, getKeyName(Keys.RUN)); 
                fr.drawString(left, y, "K: Back");
                y = fr.drawString(secLeft, y, getKeyName(Keys.ESCAPE)); 
                fr.drawString(left, y, "K: Enter");
                y = fr.drawString(secLeft, y, getKeyName(Keys.ENTER)); 
                fr.drawString(left, y, "K: Combat");
                y = fr.drawString(secLeft, y, getKeyName(Keys.COMBAT)); 
                fr.drawString(left, y, "K: Switch Face");
                y = fr.drawString(secLeft, y, getKeyName(Keys.COMBAT_SWITCH_FACE)); 
                fr.drawString(left, y, "K: Dash/Dodge");
                y = fr.drawString(secLeft, y, getKeyName(Keys.COMBAT_DASH)); 
                fr.drawString(left, y, "K: Dash/Dodge");
                y = fr.drawString(secLeft, y, getKeyName(Keys.COMBAT_DODGE)); 
                fr.drawString(left, y, "K: Block");
                y = fr.drawString(secLeft, y, getKeyName(Keys.COMBAT_BLOCK)); 
                fr.drawString(left, y, "K: Attack");
                y = fr.drawString(secLeft, y, getKeyName(Keys.COMBAT_ATTACK)); 
                if(optionsDirty)
                {
                    y = fr.drawString(left, y, true, "&cSave");
                }
                else
                {
                    y = fr.drawString(left, y, true, "Save");
                }
                fr.drawString(left, y, true, "Back");
                break;
            }
            case 3:
            {
                ColorRenderer cr = Shader.getColorRenderer();
                FontRenderer fr = Shader.getFontRenderer();
                
                float width = Shader.getViewWidth();
                float height = Shader.getViewHeight();
                
                float line = fr.getHeight();
                
                int maxView = 7; // only for odd numbers
                int half = maxView / 2;
                
                float left = width * 0.2f;
                float right = width * 0.8f;
                float top = (height - line * (maxView + 4)) * 0.5f;
                float bottom = top + line * (maxView + 4);
                
                Shader.setTextureEnabled(false);
                Shader.setColorEnabled(true);
                
                // brown background
                cr.drawRectangle(0, 0, width, height, COLOR_BROWN); 
                
                Shader.setBlendingEnabled(true);
                cr.drawRectangle(left, top, right, bottom, COLOR_OVERLAY);
                int firstIndex;
                int lastIndex;
                int baseIndex;
                if(levelIndex <= half) // first half
                {
                    firstIndex = 0;
                    lastIndex = Math.min(levels.length, maxView);
                    baseIndex = levelIndex;
                }
                else if(levelIndex >= levels.length - half) // last half
                {
                    lastIndex = levels.length;
                    firstIndex = Math.max(lastIndex - maxView, 0);
                    if(levels.length <= maxView)
                    {
                        baseIndex = levelIndex;
                    }
                    else
                    {
                        baseIndex = levelIndex - (levels.length - half - 1) + half;
                    }
                }
                else // middle
                {
                    firstIndex = levelIndex - half;
                    lastIndex = firstIndex + maxView;
                    baseIndex = half;
                }
                float base = top + (3 + baseIndex) * line;
                cr.drawRectangle(left, base, right, base + line, COLOR_OVERLAY);
                Shader.setBlendingEnabled(false);
                        
                Shader.setTextureEnabled(true);
                left += line;
                float secLeft = right - line * 12;
                float thirdLeft = right - line * 6;
                float y = top + line;
                y = fr.drawString(left, y, "Choose a Level ..."); 
                y += line;
                
                if(firstIndex >= 1)
                {
                    y = fr.drawString(left, y, "..."); 
                    firstIndex++;
                }
                SimpleConfig sc = saveSlots[slotScreenIndex];
                for(int i = firstIndex; i < lastIndex - 1; i++)
                {
                    Level l = levels[i];
                    fr.drawString(left, y, l.getName()); 
                    fr.drawString(secLeft, y, l.formatBottles(sc.getInt("level." + l.getFileName() + ".bottles", 0))); 
                    y = fr.drawString(thirdLeft, y, l.formatTime(sc.getFloat("level." + l.getFileName() + ".time", 0))); 
                }
                if(lastIndex == levels.length)
                {
                    Level l = levels[lastIndex - 1];
                    fr.drawString(left, y, l.getName()); 
                    fr.drawString(secLeft, y, l.formatBottles(sc.getInt("level." + l.getFileName() + ".bottles", 0))); 
                    fr.drawString(thirdLeft, y, l.formatTime(sc.getFloat("level." + l.getFileName() + ".time", 0))); 
                }
                else
                {
                    fr.drawString(left, y, "..."); 
                }
                break;
            }
        }
    }
    
    // -------------------------------------------------------------------------
    // config
    // -------------------------------------------------------------------------
    
    public boolean isSoundEnabled()
    {
        return sound;
    }   
    
    // -------------------------------------------------------------------------
    // tile stuff
    // -------------------------------------------------------------------------
    
    private void registerTiles()
    {
        // dirt
        for(int i = 0; i < 16; i++)
        {
            registeredTiles.put(i, new BaseBoxTile(0.125f, 0.0f, 0.1875f, 0.0625f));
        }
        
        // grass
        BaseBoxTile grass = new BaseBoxTile(0.0625f, 0.0f, 0.125f, 0.0625f);
        registeredTiles.put(20, grass);
        registeredTiles.put(21, grass);
        registeredTiles.put(22, grass);
        registeredTiles.put(23, grass);
        registeredTiles.put(28, grass);
        registeredTiles.put(29, grass);
        registeredTiles.put(30, grass);
        registeredTiles.put(31, grass);
        
        // bottled soul
        registeredTiles.put(32, new BottledSoulTile(1));
        registeredTiles.put(33, new BottledSoulTile(2));
        registeredTiles.put(34, new BottledSoulTile(3));
        
        // bounce shroom
        registeredTiles.put(48, new TrampolinTile());
        
        // crumbling stones
        registeredTiles.put(64, new CrumblingStoneTile());
        
        // spike trap
        registeredTiles.put(80, new SpikeTile());
        
        // water
        for(int i = 0; i < 16; i++)
        {
            registeredTiles.put(96 + i, new WaterTile(15 - i));
        }
        
        // snuvi start block
        registeredTiles.put(StartTile.ID, new StartTile());
        
        // sky
        registeredTiles.put(128, new SkyTile());
        
        // slippery slime
        SlipperyTile slime = new SlipperyTile();
        registeredTiles.put(148, slime);
        registeredTiles.put(149, slime);
        registeredTiles.put(150, slime);
        registeredTiles.put(151, slime);
        registeredTiles.put(156, slime);
        registeredTiles.put(157, slime);
        registeredTiles.put(158, slime);
        registeredTiles.put(159, slime);
        
        // end level
        registeredTiles.put(160, new GoalTile(0.25f, 0.125f, 0.3125f, 0.1875f));
        registeredTiles.put(161, new GoalTile(0.25f, 0.0625f, 0.3125f, 0.125f));
        
        // thorns
        registeredTiles.put(176, new KillTile(0.0f, 0.125f, 0.0625f, 0.1875f, 2));
        registeredTiles.put(177, new KillTile(0.0625f, 0.125f, 0.125f, 0.1875f, 2));
        registeredTiles.put(178, new KillTile(0.125f, 0.125f, 0.1875f, 0.1875f, 2));
        registeredTiles.put(179, new KillTile(0.0f, 0.125f, 0.0625f, 0.1875f, -3));
        registeredTiles.put(180, new KillTile(0.0625f, 0.125f, 0.125f, 0.1875f, -3));
        registeredTiles.put(181, new KillTile(0.125f, 0.125f, 0.1875f, 0.1875f, -3));
        
        // decoration shrooms
        registeredTiles.put(208, new DecoShroomTile(0.0f, 0.21875f, 0.0625f, 0.25f));
        registeredTiles.put(209, new DecoShroomTile(0.0f, 0.1875f, 0.0625f, 0.21875f));
        registeredTiles.put(210, new DecoShroomTile(0.0625f, 0.21875f, 0.125f, 0.25f));
        registeredTiles.put(211, new DecoShroomTile(0.0625f, 0.1875f, 0.125f, 0.21875f));
        
        // fog, starting late to make length changes possible
        for(int i = 0; i < 16; i++)
        {
            registeredTiles.put(16000 + i, new FogTile((i + 1) / 16.0));
        }
        
        // london stuff
        //registeredTiles.put(224, new BaseBoxTile("london_background/london_background"));
        
        // london streets
        for(int i = 0; i < 16; i++)
        {
            //registeredTiles.put(240 + i, new BaseBoxTile("london_streets/london_streets" + i));
        }
        
        // london street light
        for(int i = 0; i < 25; i++)
        {
            //registeredTiles.put(256 + i, new BaseBoxTile("street_light/street_light" + (i % 5) + "_" + (i / 5)));
        }
    }
    
    public Tile getTile(int id)
    {
        return registeredTiles.getOrDefault(id, FALLBACK_TILE);
    }
    
    public void resetTiles()
    {
        registeredTiles.values().forEach(v -> v.reset());
    }

    private void menuMove(Runnable esc, Runnable enter, Runnable down, Runnable up, Runnable end)
    {
        if(Keys.ESCAPE.isReleased())
        {
            esc.run();
            return;
        }
        if(Keys.ENTER.isReleased())
        {
            enter.run();
            return;
        }

        if(Keys.DOWN.getTime() > 4)
        {
            Keys.DOWN.setTime(0);
            down.run();
        }
        else if(Keys.UP.getTime() > 4)
        {
            Keys.UP.setTime(0);
            up.run();
        }
        else if(Keys.DOWN.isReleased())
        {
            down.run();
        }
        else if(Keys.UP.isReleased())
        {
            up.run();
        }
        end.run();
    }
}