Subversion Repositories AndroidProjects

package com.gebauz.PonPonChun.game;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Preferences;
import com.badlogic.gdx.files.FileHandle;
import com.gebauz.Bauzoid.gamestates.GameStateManager;
import com.gebauz.Bauzoid.parser.ScanException;
import com.gebauz.Bauzoid.parser.Tokenizer;
import com.gebauz.PonPonChun.game.entities.PlayField;

public class GameModeLogicPuzzle extends GameModeLogic
{

        // Constants========================================================================================
       
        public static final float SUCCESS_TIME = 2.0f;
        public static final float SUCCESS_FADEOUT_TIME = 0.3f;

        public static int NUM_LEVELS = 6;
        public static int NUM_STAGES_PER_LEVEL = 10;
        public static String LEVEL_NAMES[] = new String[]
                {
                        "A", "B", "C", "D", "E", "F"  
                };
       
        // Embedded Types===================================================================================
       
        enum State
        {
                NORMAL,
                GAMEOVER,
                SUCCESS,
                SUCCESS_FADEOUT
        }

        // Members==========================================================================================
       
        private int mLevelNumber = 1;
        private String mLevelName = "";
        private int mNumMoves = 99;
       
        private State mCurrentState = State.NORMAL;    
        private float mStateTimer = 0.0f;

        // Methods==========================================================================================

        public GameModeLogicPuzzle(GameLogic gameLogic)
        {
                super(gameLogic, GameLogic.GameMode.ENDLESS);
        }

        @Override
        public void init(String param)
        {
                mLevelNumber = Integer.parseInt(param);
               
                loadLevel(mLevelNumber);
        }
       
        @Override
        public void restart()
        {
                GameStateManager gs = getGameLogic().getGameStateManager();
                gs.switchTo(gs.getCurrentState().getClass(), String.valueOf(mLevelNumber));
        }

        @Override
        public void exit()
        {

        }
       
        public void loadLevel(int level)
        {
                loadPuzzle(Gdx.files.internal(String.format("data/levels/puzzle%02d.txt", level)));
               
                getGameLogic().getPlayField().setAdvanceSpeed(0.0f);
                getGameLogic().getHeadsUpDisplay().getLabelA().getTextElement().setCaption(mLevelName);
                getGameLogic().getHeadsUpDisplay().getLabelB().getTextElement().setCaption(String.format("%02d", mNumMoves));
               
                mCurrentState = State.NORMAL;
                mStateTimer = 0.0f;
        }
       
        /** Load a PlayField from a text file. */
        public void loadPuzzle(FileHandle file)
        {              
                PlayField pf = getGameLogic().getPlayField();
                pf.clearAllBlocks();
               
                String puzzleFile = file.readString();
                Tokenizer t = new Tokenizer(puzzleFile);
               
                try
                {
                        while (!t.isEndOfString())
                        {
                                String id = t.readIdentifier();
                               
                                if (id.equalsIgnoreCase("name"))
                                {
                                        mLevelName = t.readString();
                                        t.readToken(";");
                                }
                                else if (id.equalsIgnoreCase("count"))
                                {
                                        mNumMoves = (int)t.readNumber();
                                        t.readToken(";");
                                }
                                else if (id.equalsIgnoreCase("level"))
                                {
                                        t.readToken("{");
                                       
                                        String level = t.readUntilToken("}");
                                        pf.loadPlayField(level);
                                       
                                        t.readToken("}");
                                }
                               
                        }
                }
                catch (ScanException e)
                {
                        e.log(GameConsts.LOG_TAG);
                }
        }
       
        @Override
        public void onPostPerformSwap()
        {
                mNumMoves--;
                getGameLogic().getHeadsUpDisplay().getLabelB().getTextElement().setCaption(String.format("%02d", mNumMoves));
               
                if (mNumMoves == 0)
                {
                        getGameLogic().getPlayField().getPlayFieldLogic().setInputEnabled(false);
                        //mWaitTimer = WAIT_TIME;
                }
        }
       
        boolean success = false;
       
        @Override
        public void update(float deltaTime)
        {      
                mStateTimer += deltaTime;
               
                if (mCurrentState == State.NORMAL)
                        updateNormal(deltaTime);
                else if (mCurrentState == State.GAMEOVER)
                        updateGameOver(deltaTime);
                else if (mCurrentState == State.SUCCESS)
                        updateSuccess(deltaTime);
                else if (mCurrentState == State.SUCCESS_FADEOUT)
                        updateSuccessFadeOut(deltaTime);
        }
               
        public void updateNormal(float deltaTime)
        {
                PlayField pf = getGameLogic().getPlayField();
               
                if (pf.isGameOver())
                        return;
               
                if (pf.getNumBlocks() == 0)
                {
                        // cleared everything -> success
                        getGameLogic().getSounds().playSound(GameSounds.SFX_SUCCESS);
                        mCurrentState = State.SUCCESS;
                        mStateTimer = 0.0f;
                       
                        // write to preferences
                        Preferences prefs = Gdx.app.getPreferences(GameConsts.PREFERENCES);
                        int levelNumber = (mLevelNumber - 1) / NUM_STAGES_PER_LEVEL;
                        int stageNumber = (mLevelNumber - 1) % NUM_STAGES_PER_LEVEL;
                        String levelName = LEVEL_NAMES[levelNumber] + String.valueOf(stageNumber) + "_finished";
                        prefs.putBoolean(levelName, true);
                        prefs.flush();
                       
                        getGameLogic().getHeadsUpDisplay().setPauseButtonActive(false);                
                        getGameLogic().getSuccessScreen().showScreen();
                       
                        mLevelNumber++;                        
                        return;
                }
               
                if (mNumMoves == 0)
                {
                        // check if still activity
                        if (!isStillActivity())
                        {
                                getGameLogic().getPlayField().setGameOver();
                                mCurrentState = State.GAMEOVER;
                                mStateTimer = 0.0f;
                        }
                }
        }
       
        public void updateGameOver(float deltaTime)
        {
               
        }
       
        public void updateSuccess(float deltaTime)
        {
                if (mStateTimer > SUCCESS_TIME)
                {
                        mCurrentState = State.SUCCESS_FADEOUT;
                        mStateTimer = 0.0f;
                       
                        getGameLogic().getSuccessScreen().hideScreen();
                }
                else
                {
                        getGameLogic().getSuccessScreen().update(deltaTime);
                }
        }
       
        public void updateSuccessFadeOut(float deltaTime)
        {
                if (mStateTimer > SUCCESS_FADEOUT_TIME)
                {
                        // load next level
                        loadLevel(mLevelNumber);
                        mCurrentState = State.NORMAL;
                        mStateTimer = 0.0f;
                        getGameLogic().getHeadsUpDisplay().setPauseButtonActive(true);
                        getGameLogic().getPlayField().getPlayFieldLogic().setInputEnabled(true);
                }
                else
                {
                        getGameLogic().getSuccessScreen().update(deltaTime);
                }
        }

        @Override
        public void render()
        {
                /*if (mCurrentState == State.SUCCESS)
                {
                        // render success text
                        getGameLogic().getFonts().getFont("scoring").drawText("SUCCESS!", 10, 10, 3.0f);
                }*/
               
                getGameLogic().getSuccessScreen().render();
        }
       
        // Getters/Setters==================================================================================
       
        public int getDifficulty() { return 1; }
}