Subversion Repositories AndroidProjects

package com.gebauz.PonPonChun.gamestates;

import java.util.Vector;

import com.badlogic.gdx.Gdx;
import com.gebauz.Bauzoid.game.Game;
import com.gebauz.Bauzoid.gamestates.BaseGameState;
//import com.gebauz.Bauzoid.input.Input.Finger;
import com.gebauz.Bauzoid.math.Interpolation;
import com.gebauz.Bauzoid.math.MathUtil;
import com.gebauz.Bauzoid.menu.EventProcessor;
import com.gebauz.Bauzoid.menu.Menu;
import com.gebauz.Bauzoid.menu.MenuEventListener;
import com.gebauz.Bauzoid.menu.MenuItem;
import com.gebauz.Bauzoid.menu.MenuUtil;
//import com.gebauz.PonPonChun.PonPonChunCustomServices;
import com.gebauz.PonPonChun.game.GameConsts;
import com.gebauz.PonPonChun.game.OptionsScreen;

public class MainMenuState extends BaseGameState implements MenuEventListener
{
        // Constants========================================================================================
       
        public static final float SHIFT_TIME = 0.5f;
       
        // Embedded Types===================================================================================
       
        public interface SubMenu
        {
                public void init();
                public void exit();
                public void update(float deltaTime);
                public void render();
                public boolean processMessage(Menu menu, MenuItem sender, String command);
               
                public void open();
                public Menu getMenu();
        }
       
        enum State
        {
                NORMAL,
                SHIFT_AWAY,
                SHIFT_BACK,
                HIDDEN,
        }

        // Members==========================================================================================
       
        private Menu mMenu = null;
       
        private SubMenuEndless mSubMenuEndless = null;
        private SubMenuPuzzle mSubMenuPuzzle = null;
        private SubMenuTimeTrial mSubMenuTimeTrial= null;
       
        private SubMenu mCurrentSubMenu = null;
       
        private OptionsScreen mOptionsScreen = null;
       
        private State mCurrentState = State.NORMAL;
        private float mStateTimer = 0.0f;
       
        //private boolean mIsDragging = false;
        //private float mLastX = 0;
       
        // Methods==========================================================================================

        public MainMenuState(Game game)
        {
                super(game);
                setFading(true, true);
               
                mSubMenuEndless = new SubMenuEndless(this);
                mSubMenuPuzzle = new SubMenuPuzzle(this);
                mSubMenuTimeTrial = new SubMenuTimeTrial(this);
       
                mOptionsScreen = new OptionsScreen(game);
        }

        @Override
        public void init(String param)
        {
                mMenu = MenuUtil.createMenuFromFile(getGame(), Gdx.files.internal("data/menus/mainmenu.txt"));
                mMenu.init();
                mMenu.setEventListener(this);

                mSubMenuEndless.init();
                mSubMenuPuzzle.init();
                mSubMenuTimeTrial.init();
               
                mOptionsScreen.init();         
        }

        @Override
        public void exit()
        {
                if (mSubMenuEndless != null)
                {
                        mSubMenuEndless.exit();
                        mSubMenuEndless = null;
                }
               
                if (mSubMenuPuzzle != null)
                {
                        mSubMenuPuzzle.exit();
                        mSubMenuPuzzle = null;
                }
               
                if (mSubMenuTimeTrial != null)
                {
                        mSubMenuTimeTrial.exit();
                        mSubMenuTimeTrial = null;
                }
               
                if (mMenu != null)
                {
                        mMenu.exit();
                        mMenu = null;
                }
               
                if (mOptionsScreen != null)
                {
                        mOptionsScreen.exit();
                        mOptionsScreen = null;
                }
        }

        @Override
        public void update(float deltaTime)
        {
                final float shiftWidth = GameConsts.VIRTUAL_SCREEN_WIDTH + 300.0f;
               
                mStateTimer += deltaTime;
               
                mOptionsScreen.update(deltaTime);
               
                if (!mOptionsScreen.isActive())
                        mMenu.update(deltaTime);

               
                if (mCurrentState == State.NORMAL)
                {

                }
                else if (mCurrentState == State.SHIFT_AWAY)
                {
                        float s = MathUtil.clamp(mStateTimer/SHIFT_TIME, 0, 1);
                        s = Interpolation.simpleEaseInOut(s);
                        mMenu.getOrigin().x = -s * (shiftWidth);
                       
                        if (mCurrentSubMenu != null)
                                mCurrentSubMenu.getMenu().getOrigin().x = shiftWidth - (s * shiftWidth);

                        if (mStateTimer > SHIFT_TIME)
                        {
                                mCurrentState = State.HIDDEN;
                                mStateTimer = 0.0f;
                        }                      
                }
                else if (mCurrentState == State.SHIFT_BACK)
                {
                        float s = 1-MathUtil.clamp(mStateTimer/SHIFT_TIME, 0, 1);
                        s = Interpolation.simpleEaseInOut(s);
                        mMenu.getOrigin().x = -s * (shiftWidth);
                        if (mCurrentSubMenu != null)
                                mCurrentSubMenu.getMenu().getOrigin().x = shiftWidth - (s * shiftWidth);

                        if (mStateTimer > SHIFT_TIME)
                        {
                                mCurrentState = State.NORMAL;
                                mStateTimer = 0.0f;
                                mCurrentSubMenu = null;
                        }      
                }
                else if (mCurrentState == State.HIDDEN)
                {
                }
               
                if (mCurrentSubMenu != null)
                {
                        mCurrentSubMenu.update(deltaTime);
                }
        }

        @Override
        public void render()
        {
                //getGraphics().clear(0.35f, 0.25f, 0.35f, 0.0f);
                getGraphics().clear(1, 1, 0, 0);
               
                getRenderStates().projection.setOrtho(
                                0.0f,
                                GameConsts.VIRTUAL_SCREEN_WIDTH-1,
                                GameConsts.VIRTUAL_SCREEN_HEIGHT-1,
                                0.0f,
                                0.0f,
                                1.0f
                        );
               
                //if (mCurrentSubMenu == null)
                {
                        mMenu.render();
                }              
                if (mCurrentSubMenu != null)
                {
                        mCurrentSubMenu.render();
                }
               
                mOptionsScreen.render();
               
                //getFonts().getDefaultFont().drawText("FPS: " + getGame().getFps(), 30, 30, GameConsts.WHITE_COLOR);
        }
       
        @Override
        public void onMessage(Menu menu, MenuItem sender, String msgType, Vector<String> paramList)
        {
                for (String param : paramList)
                {
                        if (param.equalsIgnoreCase("submenu_back"))
                        {
                                getMainMenu().setEnabled(true);
                                startShiftBackMainMenu();
                        }
                        else if (param.equalsIgnoreCase("submenu_endless"))
                        {
                                openSubMenu(mSubMenuEndless);
                        }
                        else if (param.equalsIgnoreCase("submenu_puzzle"))
                        {
                                openSubMenu(mSubMenuPuzzle);
                        }
                        else if (param.equalsIgnoreCase("submenu_timetrial"))
                        {
                                openSubMenu(mSubMenuTimeTrial);
                        }
                        /*else if (!mSubMenuEndless.processMessage(menu, sender, param) &&
                                         !mSubMenuPuzzle.processMessage(menu, sender, param) &&
                                         !mSubMenuTimeTrial.processMessage(menu, sender, param))*/
                        else if (param.equalsIgnoreCase("showOptions"))
                        {
                                mOptionsScreen.show();
                        }
                        else
                        {
                                boolean handled = false;
                                if (mCurrentSubMenu != null)
                                        handled = mCurrentSubMenu.processMessage(menu, sender, param);
                                       
                                if (!handled)
                                        EventProcessor.processEvent(menu, sender, msgType, param);
                        }
                }
        }
       
        public void openSubMenu(SubMenu subMenu)
        {
                getMainMenu().setEnabled(false);
                startShiftAwayMainMenu();
                setCurrentSubMenu(subMenu);
               
                subMenu.open();
        }
       
        public void startShiftAwayMainMenu()
        {
                mCurrentState = State.SHIFT_AWAY;
                mStateTimer = 0.0f;
        }
       
        public void startShiftBackMainMenu()
        {
                mCurrentState = State.SHIFT_BACK;
                mStateTimer = 0.0f;
        }      


        // Getters/Setters==================================================================================
       
        public Menu getMainMenu() { return mMenu; }
       
        public void setCurrentSubMenu(SubMenu subMenu) { mCurrentSubMenu = subMenu; }
       
        public State getState() { return mCurrentState; }
        public float getShiftFactor() { return mStateTimer/SHIFT_TIME; }

}