Subversion Repositories AndroidProjects

package com.gebauz.Bauzoid.gamestates;

import java.lang.reflect.InvocationTargetException;

import android.util.Log;

import com.gebauz.Bauzoid.app.Consts;
import com.gebauz.Bauzoid.app.Game;
import com.gebauz.Bauzoid.app.GameObject;
import com.gebauz.Bauzoid.graphics.model.SimpleGeometry;
import com.gebauz.Bauzoid.math.MathUtil;

/** Manages game state switching, updating, rendering, and initialization/destruction. */
public class GameStateManager extends GameObject
{
        static final float FADE_TIME = 1.0f;
       
        private enum StateMode
        {
                MODE_NORMAL,    // everything normal
                MODE_FADEIN,    // fade in
                MODE_FADEOUT    // fade out
        };
       
        private BaseGameState mCurrentState = null;
        private Class<?> mNextStateClass = null;
        private StateMode mStateMode = StateMode.MODE_NORMAL;
        private float mFadeTimer = 0.0f;
       
        private SimpleGeometry mFadeOverlay = null;
       
        /** Constructor. */
        public GameStateManager(Game game)
        {
                super(game);           
        }
       
        /** Called when the GameStateManager should initially set up its internals. */
        public void init()
        {
               
        }
       
        /** Called when the GameStateManager should clean up. */
        public void exit()
        {
                if (mCurrentState != null)
                {
                        // reset everything
                       
                        mCurrentState.exit();
                        mCurrentState = null;
                       
                        mNextStateClass = null;
                        mStateMode = StateMode.MODE_NORMAL;
                        mFadeTimer = 0.0f;
                }
        }
       
        /** Queue a game state switch. */
        public void switchTo(Class<?> nextState)
        {
                if ((mCurrentState != null) && (mCurrentState.doFadeOut()))
                {
                        mStateMode = StateMode.MODE_FADEOUT;
                        mFadeTimer = 0.0f;
                }
               
                mNextStateClass = nextState;           
        }
       
        /** Switch to state specified by String - must be fully qualified Class name! */
        public void switchTo(String nextState)
        {
                try
                {
                        mNextStateClass = Class.forName(nextState);
                }
                catch (ClassNotFoundException ex)
                {
                        Log.v(Consts.LOG_TAG, "ClassNotFoundException when switching to " + nextState);
                }
        }
       
        /** Actually perform the switch. */
        private void performSwitch(Class<?> newState)
        {
                if (newState == null)
                {
                        return;
                }
               
                if (mCurrentState != null)
                {
                        mCurrentState.exit();
                        mCurrentState = null;
                }
               
                try
                {
                        //mCurrentState = (BaseGameState)newState.newInstance();
                        mCurrentState = (BaseGameState)newState.getDeclaredConstructor(Game.class).newInstance(getGame());
                }
                catch (NoSuchMethodException ex)
                {
                        Log.v(Consts.LOG_TAG, "NoSuchMethodException when switching to " + newState.toString());
                        return;
                }
                catch (InvocationTargetException ex)
                {
                        Log.v(Consts.LOG_TAG, "InvocationTargetEception when switching to " + newState.toString());
                        return;
                }
                catch (InstantiationException ex)
                {
                        Log.v(Consts.LOG_TAG, "InstantiationException when switching to " + newState.toString());
                        return;
                }
                catch (IllegalAccessException ex)
                {
                        Log.v(Consts.LOG_TAG, "IllegalAccessException when switching to " + newState.toString());
                        return;
                }
               
                if (mCurrentState != null)
                {
                        mCurrentState.init();
                        //mCurrentState.onSurfaceChanged(GLUtil.getInstance().getWidth(), GLUtil.getInstance().getHeight());
                       
                        if (mCurrentState.doFadeIn())
                        {
                                mStateMode = StateMode.MODE_FADEIN;
                                mFadeTimer = 0.0f;
                        }
                }
        }

        /** Update the current game state (if one is running). */
        public void update(float deltaTime)
        {
                if (mStateMode != StateMode.MODE_NORMAL)
                {
                        mFadeTimer += deltaTime;
                        if (mFadeTimer > FADE_TIME)
                        {
                                mStateMode = StateMode.MODE_NORMAL;
                        }
                }
               
                if ((mStateMode == StateMode.MODE_NORMAL) && (mNextStateClass != null))
                {
                        // perform the actual switch
                        performSwitch(mNextStateClass);
                        mNextStateClass = null;
                }              
               
                if ((mCurrentState != null) && (mStateMode == StateMode.MODE_NORMAL))
                {
                        mCurrentState.update(deltaTime);
                }
               
                float alpha = MathUtil.clamp(mFadeTimer / FADE_TIME, 0.0f, 1.0f);
                if (mStateMode == StateMode.MODE_FADEOUT)
                        alpha = 1.0f - alpha;
       
                // TODO: do it with shader!
/*              Mesh.AttributeArray colors = new Mesh.AttributeArray(Mesh.COLOR_ELEMENTS_COUNT * mFadeOverlay.getColorCount());
                for (int i = 0; i < mFadeOverlay.getColorCount(); i++)
                {
                        colors.fill(alpha, alpha, alpha, 1.0f);
                        //colors.fill(1.0f, 1.0f, 1.0f, alpha);
                }
                mFadeOverlay.setColors(colors.getAttributeArray());*/
        }

        /** Render the current game state (if one is running). */
        public void render()
        {
                if (mCurrentState != null)
                {                      
                        mCurrentState.render();
                }              
               
                if (mStateMode != StateMode.MODE_NORMAL)
                {
/*                      gl.glMatrixMode(GL10.GL_PROJECTION);
                        gl.glLoadIdentity();
                        gl.glOrthof(0, GameConsts.VIRTUAL_SCREEN_WIDTH-1.0f, GameConsts.VIRTUAL_SCREEN_HEIGHT-1.0f, 0, 0, 1);
                        gl.glMatrixMode(GL10.GL_MODELVIEW);
                        gl.glLoadIdentity();
                       

                        if (mFadeTimer <= GameConsts.FADE_TIME)
                        {
                                RenderStates rs = GLUtil.getRenderStates();
                                rs.blending.setEnabled(true);
                                rs.blending.setBlendingMode(BlendingMode.MULTIPLY);
                                rs.depthTest.setEnabled(false);
                                rs.culling.setEnabled(false);
                                rs.getTextureStage(0).bindTexture(null, true);
                                rs.activate();
                                mFadeOverlay.render();
                                rs.deactivate();
                        }*/
                }
        }
       
        /** Called when the surface properties changed. */
        public void onSurfaceChanged(int w, int h)
        {
                if (mCurrentState != null)
                {
                        mCurrentState.onSurfaceChanged(w, h);
                }
        }
       
        /** Called when resuming after pausing and initially. */
        public void onResume()
        {
               
        }
       
        /** Called when the app is paused. */
        public void onPause()
        {
               
        }
       
}