WebSVN - AndroidProjects - Rev 625 - /BauzoidApps/PonPonChun/ponponchun/src/com/gebauz/PonPonChun/gamestates/SubMenuPuzzle.java

package com.gebauz.PonPonChun.gamestates;

import com.badlogic.gdx.Gdx;
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;

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 int NUM_LEVELS = 6;
public static int NUM_STAGES_PER_LEVEL = 10;

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 String LEVEL_NAMES[] = new String[]
{
"A", "B", "C", "D", "E", "F"
};

public static float SLIDE_TIME = 0.5f;

// Embedded Types===================================================================================

public class LevelInfo
{
public boolean isFinished[] = new boolean[NUM_STAGES_PER_LEVEL];
public int level;

public LevelInfo(int _level)
{
level = _level;
for (int i = 0; i < 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[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);

for (int i = 0; i < NUM_LEVELS; i++)
{
mLevels[i] = new LevelInfo(i);

// fill with info whether or not the single stages have been solved
}

mLevels[0].isFinished[0] = true;
mLevels[0].isFinished[1] = true;
mLevels[0].isFinished[2] = true;
mLevels[0].isFinished[3] = true;
}

@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 < -50.0f)
{
if (mCurrentSelectedLevel < (NUM_LEVELS-1))
{
mCurrentSelectedLevel++;
sliderLeft();
}
mIsDragging = false;
}
else if (delta > 50.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 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 >= NUM_LEVELS))
continue;

final float posX = -300 + 300*i + t*300;

renderTier(mLevels[level], posX, 300.0f, scales[i], alphas[i]);

// 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 < 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 = 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);
getParentState().getGameStateManager().switchTo(com.gebauz.PonPonChun.gamestates.PuzzleState.class, "1");
}
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; }

}

Subversion Repositories AndroidProjects

(root)/BauzoidApps/PonPonChun/ponponchun/src/com/gebauz/PonPonChun/gamestates/SubMenuPuzzle.java - Rev 625