xref: /external/replicaisland/src/com/replica/replicaisland/Game.java

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.replica.replicaisland;

import android.content.Context;
import android.os.Build;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.WindowManager;
import android.widget.Toast;

/**
 * High-level setup object for the AndouKun game engine.
 * This class sets up the core game engine objects and threads.  It also passes events to the
 * game thread from the main UI thread.
 */
public class Game extends AllocationGuard {
    private GameThread mGameThread;
    private Thread mGame;
    private ObjectManager mGameRoot;

    private GameRenderer mRenderer;
    private GLSurfaceView mSurfaceView;
    private boolean mRunning;
    private boolean mBootstrapComplete;
    private LevelTree.Level mPendingLevel;
    private LevelTree.Level mCurrentLevel;
    private LevelTree.Level mLastLevel;
    private boolean mGLDataLoaded;
    private ContextParameters mContextParameters;
    private TouchFilter mTouchFilter;

    public Game() {
        super();
        mRunning = false;
        mBootstrapComplete = false;
        mGLDataLoaded = false;
        mContextParameters = new ContextParameters();
    }

    /**
     * Creates core game objects and constructs the game engine object graph.  Note that the
     * game does not actually begin running after this function is called (see start() below).
     * Also note that textures are not loaded from the resource pack by this function, as OpenGl
     * isn't yet available.
     * @param context
     */
    public void bootstrap(Context context, int viewWidth, int viewHeight, int gameWidth, int gameHeight, int difficulty) {
        if (!mBootstrapComplete) {
            mRenderer = new GameRenderer(context, this, gameWidth, gameHeight);

            // Create core systems
            BaseObject.sSystemRegistry.openGLSystem = new OpenGLSystem(null);

            BaseObject.sSystemRegistry.customToastSystem = new CustomToastSystem(context);

            ContextParameters params = mContextParameters;
            params.viewWidth = viewWidth;
            params.viewHeight = viewHeight;
            params.gameWidth = gameWidth;
            params.gameHeight = gameHeight;
            params.viewScaleX = (float)viewWidth / gameWidth;
            params.viewScaleY = (float)viewHeight / gameHeight;
            params.context = context;
            params.difficulty = difficulty;
            BaseObject.sSystemRegistry.contextParameters = params;

            final int sdkVersion = Integer.parseInt(Build.VERSION.SDK);
            if (sdkVersion < Build.VERSION_CODES.ECLAIR) {
            	mTouchFilter = new SingleTouchFilter();
            } else {
            	mTouchFilter = new MultiTouchFilter();
            }

            // Short-term textures are cleared between levels.
            TextureLibrary shortTermTextureLibrary = new TextureLibrary();
            BaseObject.sSystemRegistry.shortTermTextureLibrary = shortTermTextureLibrary;

            // Long-term textures persist between levels.
            TextureLibrary longTermTextureLibrary = new TextureLibrary();
            BaseObject.sSystemRegistry.longTermTextureLibrary = longTermTextureLibrary;

            // The buffer library manages hardware VBOs.
            BaseObject.sSystemRegistry.bufferLibrary = new BufferLibrary();



            BaseObject.sSystemRegistry.soundSystem = new SoundSystem();

            // The root of the game graph.
            MainLoop gameRoot = new MainLoop();

            InputSystem input = new InputSystem();
            BaseObject.sSystemRegistry.inputSystem = input;
            BaseObject.sSystemRegistry.registerForReset(input);

            WindowManager windowMgr = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
            int rotationIndex = windowMgr.getDefaultDisplay().getOrientation();
            input.setScreenRotation(rotationIndex);

            InputGameInterface inputInterface = new InputGameInterface();
            gameRoot.add(inputInterface);
            BaseObject.sSystemRegistry.inputGameInterface = inputInterface;

            LevelSystem level = new LevelSystem();
            BaseObject.sSystemRegistry.levelSystem = level;

            CollisionSystem collision = new CollisionSystem();
            BaseObject.sSystemRegistry.collisionSystem = collision;
            BaseObject.sSystemRegistry.hitPointPool = new HitPointPool();

            GameObjectManager gameManager = new GameObjectManager(params.viewWidth * 2);
            BaseObject.sSystemRegistry.gameObjectManager = gameManager;

            GameObjectFactory objectFactory = new GameObjectFactory();
            BaseObject.sSystemRegistry.gameObjectFactory = objectFactory;

            BaseObject.sSystemRegistry.hotSpotSystem = new HotSpotSystem();

            BaseObject.sSystemRegistry.levelBuilder = new LevelBuilder();

            BaseObject.sSystemRegistry.channelSystem = new ChannelSystem();
            BaseObject.sSystemRegistry.registerForReset(BaseObject.sSystemRegistry.channelSystem);

            CameraSystem camera = new CameraSystem();


            BaseObject.sSystemRegistry.cameraSystem = camera;
            BaseObject.sSystemRegistry.registerForReset(camera);

            collision.loadCollisionTiles(context.getResources().openRawResource(R.raw.collision));

            gameRoot.add(gameManager);

            // Camera must come after the game manager so that the camera target moves before the camera
            // centers.

            gameRoot.add(camera);


            // More basic systems.

            GameObjectCollisionSystem dynamicCollision = new GameObjectCollisionSystem();
            gameRoot.add(dynamicCollision);
            BaseObject.sSystemRegistry.gameObjectCollisionSystem = dynamicCollision;


            RenderSystem renderer = new RenderSystem();
            BaseObject.sSystemRegistry.renderSystem = renderer;
            BaseObject.sSystemRegistry.vectorPool = new VectorPool();
            BaseObject.sSystemRegistry.drawableFactory = new DrawableFactory();

            HudSystem hud = new HudSystem();
            hud.setFuelDrawable(
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_bar), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_bar_bg), 0, 0));
            hud.setFadeTexture(longTermTextureLibrary.allocateTexture(R.drawable.black));
            hud.setButtonDrawables(
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_fly_disabled), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_fly_off), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_fly_on), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_stomp_off), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_stomp_on), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_movement_slider_base), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_movement_slider_button_off), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_movement_slider_button_on), 0, 0));
            Texture[] digitTextures = {
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_0),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_1),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_2),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_3),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_4),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_5),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_6),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_7),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_8),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_9)
            };
            DrawableBitmap[] digits = {
                    new DrawableBitmap(digitTextures[0], 0, 0),
                    new DrawableBitmap(digitTextures[1], 0, 0),
                    new DrawableBitmap(digitTextures[2], 0, 0),
                    new DrawableBitmap(digitTextures[3], 0, 0),
                    new DrawableBitmap(digitTextures[4], 0, 0),
                    new DrawableBitmap(digitTextures[5], 0, 0),
                    new DrawableBitmap(digitTextures[6], 0, 0),
                    new DrawableBitmap(digitTextures[7], 0, 0),
                    new DrawableBitmap(digitTextures[8], 0, 0),
                    new DrawableBitmap(digitTextures[9], 0, 0)
            };
            DrawableBitmap xDrawable = new DrawableBitmap(
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_x), 0, 0);

            hud.setDigitDrawables(digits, xDrawable);
            hud.setCollectableDrawables(
                    new DrawableBitmap(
                            longTermTextureLibrary.allocateTexture(R.drawable.ui_pearl), 0, 0),
                    new DrawableBitmap(
                            longTermTextureLibrary.allocateTexture(R.drawable.ui_gem), 0, 0));

            BaseObject.sSystemRegistry.hudSystem = hud;
            if (AndouKun.VERSION < 0) {
            	hud.setShowFPS(true);
            }
            gameRoot.add(hud);

            BaseObject.sSystemRegistry.vibrationSystem = new VibrationSystem();

            EventRecorder eventRecorder = new EventRecorder();
            BaseObject.sSystemRegistry.eventRecorder = eventRecorder;
            BaseObject.sSystemRegistry.registerForReset(eventRecorder);

            gameRoot.add(collision);

            // debug systems
            //BaseObject.sSystemRegistry.debugSystem = new DebugSystem(longTermTextureLibrary);
            //dynamicCollision.setDebugPrefs(false, true);


            objectFactory.preloadEffects();

            mGameRoot = gameRoot;

            mGameThread = new GameThread(mRenderer);
            mGameThread.setGameRoot(mGameRoot);


            mCurrentLevel = null;

            mBootstrapComplete = true;
        }
    }


    protected synchronized void stopLevel() {
        stop();
        GameObjectManager manager = BaseObject.sSystemRegistry.gameObjectManager;
        manager.destroyAll();
        manager.commitUpdates();

        //TODO: it's not strictly necessary to clear the static data here, but if I don't do it
        // then two things happen: first, the static data will refer to junk Texture objects, and
        // second, memory that may not be needed for the next level will hang around.  One solution
        // would be to break up the texture library into static and non-static things, and
        // then selectively clear static game components based on their usefulness next level,
        // but this is way simpler.
        GameObjectFactory factory = BaseObject.sSystemRegistry.gameObjectFactory;
        factory.clearStaticData();
        factory.sanityCheckPools();

        // Reset the level
        BaseObject.sSystemRegistry.levelSystem.reset();

        // Ensure sounds have stopped.
        BaseObject.sSystemRegistry.soundSystem.stopAll();

        // Reset systems that need it.
        BaseObject.sSystemRegistry.reset();

        // Dump the short-term texture objects only.
        mSurfaceView.flushTextures(BaseObject.sSystemRegistry.shortTermTextureLibrary);
        BaseObject.sSystemRegistry.shortTermTextureLibrary.removeAll();
        mSurfaceView.flushBuffers(BaseObject.sSystemRegistry.bufferLibrary);
        BaseObject.sSystemRegistry.bufferLibrary.removeAll();
    }

    public synchronized void requestNewLevel() {
    	// tell the Renderer to call us back when the
    	// render thread is ready to manage some texture memory.
    	mRenderer.requestCallback();
    }

    public synchronized void restartLevel() {
        DebugLog.d("AndouKun", "Restarting...");
        final LevelTree.Level level = mCurrentLevel;
        stop();

        // Destroy all game objects and respawn them.  No need to destroy other systems.
        GameObjectManager manager = BaseObject.sSystemRegistry.gameObjectManager;
        manager.destroyAll();
        manager.commitUpdates();

        // Ensure sounds have stopped.
        BaseObject.sSystemRegistry.soundSystem.stopAll();

        // Reset systems that need it.
        BaseObject.sSystemRegistry.reset();

        LevelSystem levelSystem = BaseObject.sSystemRegistry.levelSystem;
        levelSystem.incrementAttemptsCount();
        levelSystem.spawnObjects();

        BaseObject.sSystemRegistry.hudSystem.startFade(true, 0.2f);

        mCurrentLevel = level;
        mPendingLevel = null;
        start();
    }

    protected synchronized void goToLevel(LevelTree.Level level) {

        ContextParameters params = BaseObject.sSystemRegistry.contextParameters;
        BaseObject.sSystemRegistry.levelSystem.loadLevel(level,
                params.context.getResources().openRawResource(level.resource), mGameRoot);

        Context context = params.context;
        mRenderer.setContext(context);
        mSurfaceView.loadTextures(BaseObject.sSystemRegistry.longTermTextureLibrary);
        mSurfaceView.loadTextures(BaseObject.sSystemRegistry.shortTermTextureLibrary);
        mSurfaceView.loadBuffers(BaseObject.sSystemRegistry.bufferLibrary);

        mGLDataLoaded = true;

        mCurrentLevel = level;
        mPendingLevel = null;

        TimeSystem time = BaseObject.sSystemRegistry.timeSystem;
        time.reset();

        HudSystem hud = BaseObject.sSystemRegistry.hudSystem;
        if (hud != null) {
            hud.startFade(true, 1.0f);
        }


        CustomToastSystem toast = BaseObject.sSystemRegistry.customToastSystem;
        if (toast != null) {
        	if (level.inThePast) {
        		toast.toast(context.getString(R.string.memory_playback_start), Toast.LENGTH_LONG);
        	} else {
        		if (mLastLevel != null && mLastLevel.inThePast) {
            		toast.toast(context.getString(R.string.memory_playback_complete), Toast.LENGTH_LONG);
        		}
        	}
        }

        mLastLevel = level;

        start();
    }

    /** Starts the game running. */
    public void start() {
        if (!mRunning) {
            assert mGame == null;
            // Now's a good time to run the GC.
            Runtime r = Runtime.getRuntime();
            r.gc();
            DebugLog.d("AndouKun", "Start!");
            mGame = new Thread(mGameThread);
            mGame.setName("Game");
            mGame.start();
            mRunning = true;
            AllocationGuard.sGuardActive = false;
        } else {
            mGameThread.resumeGame();
        }
    }

    public void stop() {
        if (mRunning) {
            DebugLog.d("AndouKun", "Stop!");
            if (mGameThread.getPaused()) {
                mGameThread.resumeGame();
            }
            mGameThread.stopGame();
            try {
                mGame.join();
            } catch (InterruptedException e) {
                mGame.interrupt();
            }
            mGame = null;
            mRunning = false;
            mCurrentLevel = null;
            AllocationGuard.sGuardActive = false;
        }
    }

    public boolean onTrackballEvent(MotionEvent event) {
        if (mRunning) {
        	if (event.getAction() == MotionEvent.ACTION_MOVE) {
        		BaseObject.sSystemRegistry.inputSystem.roll(event.getRawX(), event.getRawY());
        	} else if (event.getAction() == MotionEvent.ACTION_DOWN) {
        		onKeyDownEvent(KeyEvent.KEYCODE_DPAD_CENTER);
        	} else if (event.getAction() == MotionEvent.ACTION_UP) {
        		onKeyUpEvent(KeyEvent.KEYCODE_DPAD_CENTER);
        	}
        }
        return true;
    }

    public boolean onOrientationEvent(float x, float y, float z) {
        if (mRunning) {
        	BaseObject.sSystemRegistry.inputSystem.setOrientation(x, y, z);
        }
        return true;
    }

    public boolean onTouchEvent(MotionEvent event) {
        if (mRunning) {
        	mTouchFilter.updateTouch(event);
        }
        return true;
    }



    public boolean onKeyDownEvent(int keyCode) {
        boolean result = false;
        if (mRunning) {
            BaseObject.sSystemRegistry.inputSystem.keyDown(keyCode);
        }
        return result;
    }

    public boolean onKeyUpEvent(int keyCode) {
        boolean result = false;
        if (mRunning) {
        	BaseObject.sSystemRegistry.inputSystem.keyUp(keyCode);
        }
        return result;
    }

    public GameRenderer getRenderer() {
        return mRenderer;
    }

    public void onPause() {
    	if (mRunning) {
    		mGameThread.pauseGame();
    	}
    }

    public void onResume(Context context, boolean force) {
    	if (force && mRunning) {
    		mGameThread.resumeGame();
    	} else {
	        mRenderer.setContext(context);
	        // Don't explicitly resume the game here.  We'll do that in
	        // the SurfaceReady() callback, which will prevent the game
	        // starting before the render thread is ready to go.
	        BaseObject.sSystemRegistry.contextParameters.context = context;
    	}
    }

    public void onSurfaceReady() {
        DebugLog.d("AndouKun", "Surface Ready");

        if (mPendingLevel != null && mPendingLevel != mCurrentLevel) {
            if (mRunning) {
                stopLevel();
            }
            goToLevel(mPendingLevel);
        } else if (mGameThread.getPaused() && mRunning) {
            mGameThread.resumeGame();
        }
    }

    public void setSurfaceView(GLSurfaceView view) {
        mSurfaceView = view;
    }

    public void onSurfaceLost() {
        DebugLog.d("AndouKun", "Surface Lost");

        BaseObject.sSystemRegistry.shortTermTextureLibrary.invalidateAll();
        BaseObject.sSystemRegistry.longTermTextureLibrary.invalidateAll();
        BaseObject.sSystemRegistry.bufferLibrary.invalidateHardwareBuffers();

        mGLDataLoaded = false;
    }

    public void onSurfaceCreated() {
        DebugLog.d("AndouKun", "Surface Created");

        // TODO: this is dumb.  SurfaceView doesn't need to control everything here.
        // GL should just be passed to this function and then set up directly.

        if (!mGLDataLoaded && mGameThread.getPaused() && mRunning && mPendingLevel == null) {

            mSurfaceView.loadTextures(BaseObject.sSystemRegistry.longTermTextureLibrary);
            mSurfaceView.loadTextures(BaseObject.sSystemRegistry.shortTermTextureLibrary);
            mSurfaceView.loadBuffers(BaseObject.sSystemRegistry.bufferLibrary);
            mGLDataLoaded = true;
        }
    }

    public void setPendingLevel(LevelTree.Level level) {
        mPendingLevel = level;
    }

	public void setSoundEnabled(boolean soundEnabled) {
		BaseObject.sSystemRegistry.soundSystem.setSoundEnabled(soundEnabled);
	}

	public void setControlOptions(boolean clickAttack,
			boolean tiltControls, int tiltSensitivity, int movementSensitivity, boolean onScreenControls) {
		BaseObject.sSystemRegistry.inputGameInterface.setUseClickForAttack(clickAttack);
		BaseObject.sSystemRegistry.inputGameInterface.setUseOrientationForMovement(tiltControls);
		BaseObject.sSystemRegistry.inputGameInterface.setOrientationMovementSensitivity((tiltSensitivity / 100.0f));
		BaseObject.sSystemRegistry.inputGameInterface.setMovementSensitivity((movementSensitivity / 100.0f));
		BaseObject.sSystemRegistry.inputGameInterface.setUseOnScreenControls(onScreenControls);
		BaseObject.sSystemRegistry.hudSystem.setMovementSliderMode(onScreenControls);
	}

	public void setSafeMode(boolean safe) {
		mSurfaceView.setSafeMode(safe);
	}

	public float getGameTime() {
		return BaseObject.sSystemRegistry.timeSystem.getGameTime();
	}

	public Vector2 getLastDeathPosition() {
		return BaseObject.sSystemRegistry.eventRecorder.getLastDeathPosition();
	}

	public void setLastEnding(int ending) {
		BaseObject.sSystemRegistry.eventRecorder.setLastEnding(ending);
	}

	public int getLastEnding() {
		return BaseObject.sSystemRegistry.eventRecorder.getLastEnding();
	}

	public boolean isPaused() {
		return (mRunning && mGameThread != null && mGameThread.getPaused());
	}

	public void setKeyConfig(int leftKey, int rightKey, int jumpKey,
			int attackKey) {
		BaseObject.sSystemRegistry.inputGameInterface.setKeys(leftKey, rightKey, jumpKey, attackKey);
	}

	public int getRobotsDestroyed() {
		return BaseObject.sSystemRegistry.eventRecorder.getRobotsDestroyed();
	}

	public int getPearlsCollected() {
		return BaseObject.sSystemRegistry.eventRecorder.getPearlsCollected();
	}

	public int getPearlsTotal() {
		return BaseObject.sSystemRegistry.eventRecorder.getPearlsTotal();
	}
}