Subversion Repositories AndroidProjects

package com.gebauz.PonPonChun.gamestates;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Preferences;
import com.gebauz.Bauzoid.graphics.Font;
import com.gebauz.Bauzoid.graphics.sprite.AtlasSprite;
import com.gebauz.Bauzoid.graphics.sprite.AtlasSpriteInstance;
import com.gebauz.Bauzoid.graphics.sprite.SpriteRegion;
import com.gebauz.Bauzoid.input.Input.Finger;
import com.gebauz.Bauzoid.math.Vector4;
import com.gebauz.Bauzoid.menu.Menu;
import com.gebauz.Bauzoid.menu.MenuItem;
import com.gebauz.Bauzoid.menu.MenuUtil;
import com.gebauz.PonPonChun.game.GameConsts;
import com.gebauz.PonPonChun.game.GameModeLogicPuzzle;

public class SubMenuPuzzle implements MainMenuState.SubMenu
{

        // Constants========================================================================================
       
        public static int TIERBLOCK_PANEL = 0;
        public static int TIERBLOCK_BOX_CHECKED = 1;
        public static int TIERBLOCK_BOX_UNCHECKED = 2;
       
        public static int NUM_TIERBLOCK_REGIONS = 3;
       

       
        public static float STAGE_X = 30;
        public static float STAGE_Y = 30;
        public static float STAGE_SIZE = 28;
        public static float STAGE_OFFSET = 10; 
       
        public static float SLIDE_TIME = 0.5f;

        // Embedded Types===================================================================================
       
        public class LevelInfo
        {
                public boolean isFinished[] = new boolean[GameModeLogicPuzzle.NUM_STAGES_PER_LEVEL];
                public int level;
               
                public LevelInfo(int _level)
                {
                        level = _level;
                        for (int i = 0; i < GameModeLogicPuzzle.NUM_STAGES_PER_LEVEL; i++)
                                isFinished[i] = false;
                }              
        }
       
        public enum SliderState
        {
                NORMAL,
                SLIDE_LEFT,
                SLIDE_RIGHT
        }
       
        // Members==========================================================================================

        private Menu mSubMenu = null;
        private MainMenuState mParentState = null;
       
        private AtlasSprite mTierBlock = null;
        private AtlasSpriteInstance mTierBlockSprites[] = new AtlasSpriteInstance[NUM_TIERBLOCK_REGIONS];
       
        private Vector4 mTierTextColor = new Vector4(0.7f, 1, 0.3f, 1);
       
        private LevelInfo mLevels[] = new LevelInfo[GameModeLogicPuzzle.NUM_LEVELS];
       
        private int mCurrentSelectedLevel = 0;
        private boolean mIsDragging = false;
        private float mLastX = 0;
        private SliderState mSliderState = SliderState.NORMAL;
        private float mSliderStateTime = 0.0f;

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

        public SubMenuPuzzle(MainMenuState parentState)
        {
                mParentState = parentState;    
               
                mTierBlock = new AtlasSprite(mParentState.getGraphics(), "data/textures/tierblock.png");
        }
       
        @Override
        public void init()
        {
                mSubMenu = MenuUtil.createMenuFromFile(mParentState.getGame(), Gdx.files.internal("data/menus/submenu_puzzle.txt"));
                mSubMenu.init();
                mSubMenu.setEventListener(mParentState);
                mSubMenu.setEnabled(false);
                mSubMenu.setVisible(false);
               
                mTierBlock.init();
               
                SpriteRegion regions[] = new SpriteRegion[NUM_TIERBLOCK_REGIONS];
                regions[TIERBLOCK_PANEL] = new SpriteRegion(mTierBlock.getTexture(), 0, 0, 112, 32);
                regions[TIERBLOCK_BOX_CHECKED] = new SpriteRegion(mTierBlock.getTexture(), 113, 1, 6, 6);
                regions[TIERBLOCK_BOX_UNCHECKED] = new SpriteRegion(mTierBlock.getTexture(), 113, 8, 6, 6);
                mTierBlock.setRegions(regions);
               
                for (int i = 0; i < NUM_TIERBLOCK_REGIONS; i++)
                        mTierBlockSprites[i] = mTierBlock.createSpriteInstance(i);
               
                Preferences prefs = Gdx.app.getPreferences(GameConsts.PREFERENCES);
                for (int i = 0; i < GameModeLogicPuzzle.NUM_LEVELS; i++)
                {
                        mLevels[i] = new LevelInfo(i);
                       
                        // fill with info whether or not the single stages have been solved
                        for (int j = 0; j < GameModeLogicPuzzle.NUM_STAGES_PER_LEVEL; j++)
                        {
                                String levelName = GameModeLogicPuzzle.LEVEL_NAMES[i] + String.valueOf(j) + "_finished";
                                mLevels[i].isFinished[j] = prefs.getBoolean(levelName);
                        }
                }
                prefs.flush();
        }
       
        @Override
        public void exit()
        {
                for (int i = 0; i < NUM_TIERBLOCK_REGIONS; i++)
                        mTierBlockSprites[i] = null;

                if (mTierBlock != null)
                {
                        mTierBlock.dispose();
                        mTierBlock = null;
                }
               
                if (mSubMenu != null)
                {
                        mSubMenu.exit();
                        mSubMenu = null;
                }      
        }
       
        @Override
        public void update(float deltaTime)
        {
                mSubMenu.update(deltaTime);
                               
                if ((mSliderState == SliderState.SLIDE_LEFT) ||
                        (mSliderState == SliderState.SLIDE_RIGHT))
                {
                        mSliderStateTime += deltaTime;
                        if (mSliderStateTime > SLIDE_TIME)
                        {
                                mSliderStateTime = 0.0f;
                                mSliderState = SliderState.NORMAL;
                        }
                       
                        // no further input allowed
                        return;
                }
               
                // handle drag input           
                Finger finger = mParentState.getInput().getFingerInsideVirtual(0, 200, 480, 400);
                if (finger != null)
                {
                        if (finger.isJustTouched() && !mIsDragging)
                        {
                                mIsDragging = true;
                                mLastX = finger.getVirtualX();
                        }
                        else if (mIsDragging)
                        {
                                float delta = finger.getVirtualX() - mLastX;
                                if (delta < -5.0f)
                                {
                                        if (mCurrentSelectedLevel < (GameModeLogicPuzzle.NUM_LEVELS-1))
                                        {
                                                mCurrentSelectedLevel++;
                                                sliderLeft();
                                        }
                                        mIsDragging = false;
                                }
                                else if (delta > 5.0f)
                                {
                                        if (mCurrentSelectedLevel > 0)
                                        {
                                                mCurrentSelectedLevel--;
                                                sliderRight();
                                        }
                                        mIsDragging = false;
                                }
                        }
                }
                else
                {
                        mIsDragging = false;
                }
        }
       
        public void sliderLeft()
        {
                mSliderState = SliderState.SLIDE_LEFT;
                mSliderStateTime = 0.0f;
        }
       
        public void sliderRight()
        {
                mSliderState = SliderState.SLIDE_RIGHT;
                mSliderStateTime = 0.0f;
        }
       
        @Override
        public void render()
        {
                mSubMenu.render();
               
                float alphaFactor = 1.0f;
                if (mParentState.getState() == MainMenuState.State.SHIFT_AWAY)
                {
                        alphaFactor = mParentState.getShiftFactor();
                }
                else if (mParentState.getState() == MainMenuState.State.SHIFT_BACK)
                {
                        alphaFactor = 1-mParentState.getShiftFactor();
                }
               
                float t = 0.0f;
                float delta = 0.0f;  
                if (mSliderState == SliderState.SLIDE_LEFT)
                {
                        delta = mSliderStateTime / SLIDE_TIME;
                        t = 1-delta;
                }
                else if (mSliderState == SliderState.SLIDE_RIGHT)
                {
                        delta = mSliderStateTime / SLIDE_TIME;
                        t = delta-1;
                }
               
                final float scales[] = { 1, 1.0f, 1 };
                final float alphas[] = { 0.5f, 1.0f, 0.5f };
                for (int i = 0; i < 3; i++)
                {
                        int level = mCurrentSelectedLevel - 1 + i;
                       
                        if ((level < 0) || (level >= GameModeLogicPuzzle.NUM_LEVELS))
                                continue;

                        final float posX = -300 + 300*i + t*300;
                       
                        renderTier(mLevels[level], posX, 300.0f, scales[i], alphas[i]*alphaFactor*alphaFactor);
                       
//                      renderTier(mLevels[i], 0, 300.0f, 1.0f, 1.0f);
//                      renderTier(mLevels[1], 300, 300.0f, 0.8f, 0.7f);
                }
               
        }
       
        public void renderTier(LevelInfo info, float x, float y, float sizeFactor, float alpha)
        {
                final float tierWidth = 280.0f;
               
                AtlasSpriteInstance s = mTierBlockSprites[TIERBLOCK_PANEL];
                s.x = 240.0f + mSubMenu.getOrigin().x + x;
                s.y = y;
                s.w = tierWidth * sizeFactor;
                s.h = 100.0f * sizeFactor;
                s.pivotX = s.w/2;
                s.pivotY = s.h/2;
                s.alpha = alpha;
                s.render();
               
                final float startX = STAGE_X * sizeFactor + s.x - s.pivotX;
                final float startY = STAGE_Y * sizeFactor + s.y - s.pivotY;
                float posX = startX;
                float posY = startY;
                for (int i = 0; i < GameModeLogicPuzzle.NUM_STAGES_PER_LEVEL; i++)
                {
                        if (info.isFinished[i])
                                s = mTierBlockSprites[TIERBLOCK_BOX_CHECKED];
                        else
                                s = mTierBlockSprites[TIERBLOCK_BOX_UNCHECKED];
                        s.x = posX;
                        s.y = posY;
                        s.w = STAGE_SIZE * sizeFactor;
                        s.h = STAGE_SIZE * sizeFactor;
                        s.pivotX = s.w/2;
                        s.pivotY = s.h/2;
                        s.alpha = alpha;
                        s.render();
                       
                        posX += (STAGE_OFFSET + STAGE_SIZE) * sizeFactor;
                       
                        if (((i+1) % 5) == 0)
                        {
                                posX = startX;
                                posY += (STAGE_OFFSET + STAGE_SIZE) * sizeFactor;
                        }
                }
               
                final String levelName = GameModeLogicPuzzle.LEVEL_NAMES[info.level];
               
                Font font = mParentState.getFonts().getFont("scoring");
                final float scale = 6;
                float w = font.getTextWidth(levelName, scale * sizeFactor);
                final float textX = (startX-STAGE_X * sizeFactor) + tierWidth * sizeFactor - w - STAGE_X * sizeFactor;
                final float textY = startY;
                mTierTextColor.w = alpha;
                font.drawText(levelName, textX, textY, mTierTextColor, scale * sizeFactor);
        }
       
        @Override
        public boolean processMessage(Menu menu, MenuItem sender, String command)
        {
                if (command.equalsIgnoreCase("start_puzzle"))
                {
                        //String stateParam = String.format("%d:%d", mSelectedSpeed, mSelectedRows);
                       
                        String startingLevel = String.valueOf((mCurrentSelectedLevel*10)+1);                   
                       
                        getParentState().getGameStateManager().switchTo(com.gebauz.PonPonChun.gamestates.PuzzleState.class, startingLevel);
                }
                else
                {
                        return false;
                }
                return true;
        }
       
        public void open()
        {
                mSubMenu.setEnabled(true);
                mSubMenu.setVisible(true);
        }

        // Getters/Setters==================================================================================

        public MainMenuState getParentState() { return mParentState; }
       
        public Menu getMenu() { return mSubMenu; }
       
}