source: advance-wars/src/com/medievaltech/advancewars/GameView.java@ 379005b

package com.medievaltech.advancewars;

import java.io.*;

import com.medievaltech.advancewars.Enum.*;
import com.medievaltech.unit.*;
import com.medievaltech.gui.*;

import android.content.Context;
import android.graphics.*;
import android.os.*;
import android.view.*;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.TextView;

class GameView extends SurfaceView implements SurfaceHolder.Callback {
        
    class DrawingThread extends Thread {        
        public AppState mAppState;
        public GameState mGameState;

        /*
         * Member (state) fields
         */

        private int mCanvasHeight = 1;
        private int mCanvasWidth = 1;

        /** Message handler used by thread to interact with TextView */
        private Handler mHandler;

        /** Used to figure out elapsed time between frames */
        private long mLastTime;

        /** Paint to draw the lines on screen. */
        private Paint mLinePaint, mTextPaint, mButtonPaint, mTilePaint1, mTilePaint2, mSelectionPaint,
                mUnitPaint;
        
        //maybe make this private and make an accessor for it
        public Map mMap;
        
        public Tile grassTile, oceanTile;

        /** Indicate whether the surface has been created & is ready to draw */
        private boolean mRun = false;

        /** Handle to the surface manager object we interact with */
        private SurfaceHolder mSurfaceHolder;
        
        private com.medievaltech.gui.Window wndMainMenu;
        private Unit selectedUnit;
        
        public DrawingThread(SurfaceHolder surfaceHolder, Context context, Handler handler) {
            // get handles to some important objects
            mSurfaceHolder = surfaceHolder;
            mHandler = handler;
            
            mLinePaint = new Paint();
            mLinePaint.setAntiAlias(true);
            mLinePaint.setARGB(255, 0, 255, 0);

            mTextPaint = new Paint();
            mTextPaint.setAntiAlias(true);
            mTextPaint.setARGB(255, 255, 255, 255);
            mTextPaint.setTextSize(12);
            mTextPaint.setTextAlign(Paint.Align.CENTER);
            
            mButtonPaint = new Paint();
            mButtonPaint.setAntiAlias(true);
            mButtonPaint.setARGB(255, 0, 0, 0);
            mButtonPaint.setTextSize(20);
            mButtonPaint.setTextAlign(Paint.Align.CENTER);
            
            mTilePaint1 = new Paint();
            mTilePaint1.setAntiAlias(true);
            mTilePaint1.setARGB(255, 0, 255, 0);
            
            mTilePaint2 = new Paint();
            mTilePaint2.setAntiAlias(true);
            mTilePaint2.setARGB(255, 0, 0, 255);
            
            mUnitPaint = new Paint();
            mUnitPaint.setAntiAlias(true);
            mUnitPaint.setARGB(255, 255, 0, 0);
            
            mSelectionPaint = new Paint();
            mSelectionPaint.setAntiAlias(true);
            mSelectionPaint.setARGB(255, 255, 127, 0);
            
            wndMainMenu = new com.medievaltech.gui.Window(0, 0, 320, 450);;
            wndMainMenu.addGUIObject("txtTitle", new Text("Main Menu", 100, 30, 120, 20, mTextPaint));
            wndMainMenu.addGUIObject("btnNewGame", new Button("New Game", 100, 90, 120, 20, mLinePaint, mButtonPaint));
            wndMainMenu.addGUIObject("btnLoadGame", new Button("Load Game", 100, 125, 120, 20, mLinePaint, mButtonPaint));
            wndMainMenu.addGUIObject("btnMapEditor", new Button("Map Editor", 100, 160, 120, 20, mLinePaint, mButtonPaint));
            wndMainMenu.addGUIObject("btnQuit", new Button("Quit", 100, 195, 120, 20, mLinePaint, mButtonPaint));
            
            grassTile = new Tile(mTilePaint1, TerrainType.LAND);
            oceanTile = new Tile(mTilePaint2, TerrainType.SEA);
            
            mMap = new Map(grassTile, 6, 8, new Point(10, 25));
            
            boolean land = true;
            
            for(int x=0; x<mMap.getWidth(); x++) {
                        for(int y=0; y<mMap.getHeight(); y++) {
                                if(land)
                                        mMap.setTile(x, y, new Tile(grassTile, new Point(x, y)));
                                else
                                        mMap.setTile(x, y, new Tile(oceanTile, new Point(x, y)));
                                land = !land;
                        }
                        land = !land;
            }
            
            mMap.getTile(2, 3).addUnit(new Soldier(mUnitPaint));
            mMap.getTile(5, 6).addUnit(new Soldier(mUnitPaint));
            
            mGameState = GameState.MAIN_MENU;
        }
        
        /**
         * Starts the game, setting parameters for the current difficulty.
         */
        // I don't think this gets called now. maybe we should call it in the thread constructor
        public void doStart() {
            synchronized (mSurfaceHolder) {
                mLastTime = System.currentTimeMillis() + 100;
                setState(AppState.RUNNING);
                Log.i("AdvanceWars", "Player's turn starting now");
                mGameState = GameState.MAIN_MENU;
            }
        }

        /**
         * Pauses the physics update & animation.
         */
        public void pause() {
            synchronized (mSurfaceHolder) {
                if (mAppState == AppState.RUNNING) setState(AppState.PAUSE);
            }
        }

        @Override
        public void run() {
            while (mRun) {
                Canvas c = null;
                try {
                    c = mSurfaceHolder.lockCanvas(null);
                    synchronized(mSurfaceHolder) {
                        if(mAppState == AppState.RUNNING)
                                updatePhysics();
                        doDraw(c);
                    }
                } finally {
                    // do this in a finally so that if an exception is thrown
                    // during the above, we don't leave the Surface in an
                    // inconsistent state
                    if (c != null) {
                        mSurfaceHolder.unlockCanvasAndPost(c);
                    }
                }
            }
        }

        /**
         * Used to signal the thread whether it should be running or not.
         * Passing true allows the thread to run; passing false will shut it
         * down if it's already running. Calling start() after this was most
         * recently called with false will result in an immediate shutdown.
         * 
         * @param b true to run, false to shut down
         */
        public void setRunning(boolean b) {
            mRun = b;
        }

        /**
         * Sets the game mode. That is, whether we are running, paused, in the
         * failure state, in the victory state, etc.
         * 
         * @see #setState(int, CharSequence)
         * @param mode one of the STATE_* constants
         */
        public void setState(AppState state) {
            synchronized (mSurfaceHolder) {
                setState(state, null);
            }
        }
        
        public void setGameState(GameState state) {
            synchronized (mSurfaceHolder) {
                mGameState = state;
            }
        }

        /**
         * Sets the game mode. That is, whether we are running, paused, in the
         * failure state, in the victory state, etc.
         * 
         * @param mode one of the STATE_* constants
         * @param message string to add to screen or null
         */
        public void setState(AppState mode, CharSequence message) {
            /*
             * This method optionally can cause a text message to be displayed
             * to the user when the mode changes. Since the View that actually
             * renders that text is part of the main View hierarchy and not
             * owned by this thread, we can't touch the state of that View.
             * Instead we use a Message + Handler to relay commands to the main
             * thread, which updates the user-text View.
             */
            synchronized (mSurfaceHolder) {
                mAppState = mode;

                if (mAppState == AppState.RUNNING) {
                    Message msg = mHandler.obtainMessage();
                    Bundle b = new Bundle();
                    b.putString("text", "");
                    b.putInt("viz", GameView.INVISIBLE);
                    msg.setData(b);
                    mHandler.sendMessage(msg);
                } else {
                    CharSequence str = "";
                    str = "Mode probably changed";

                    if (message != null) {
                        str = message + "\n" + str;
                    }

                    Message msg = mHandler.obtainMessage();
                    Bundle b = new Bundle();
                    b.putString("text", str.toString());
                    b.putInt("viz", GameView.VISIBLE);
                    msg.setData(b);
                    //mHandler.sendMessage(msg);
                }
            }
        }
        
        /* Callback invoked when the surface dimensions change. */
        public void setSurfaceSize(int width, int height) {
            // synchronized to make sure these all change atomically
            synchronized (mSurfaceHolder) {
                mCanvasWidth = width;
                mCanvasHeight = height;
                
                Log.i("AdvanceWars", "width: "+mCanvasWidth+", height: "+mCanvasHeight);
            }
        }

        /**
         * Resumes from a pause.
         */
        public void unpause() {
            // Move the real time clock up to now
            synchronized (mSurfaceHolder) {
                mLastTime = System.currentTimeMillis() + 100;
            }
            setState(AppState.RUNNING);
        }

        /**
         * Handles a key-down event.
         * 
         * @param keyCode the key that was pressed
         * @param msg the original event object
         * @return true
         */
        boolean doKeyDown(int keyCode, KeyEvent msg) {
            synchronized (mSurfaceHolder) {
                boolean okStart = false;
                if (keyCode == KeyEvent.KEYCODE_DPAD_UP) okStart = true;
                if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) okStart = true;
                if (keyCode == KeyEvent.KEYCODE_S) okStart = true;

                if (okStart
                        && (mAppState == AppState.READY || mAppState == AppState.LOSE || mAppState == AppState.WIN)) {
                    // ready-to-start -> start
                    doStart();
                    return true;
                } else if (mAppState == AppState.PAUSE && okStart) {
                    // paused -> running
                    unpause();
                    return true;
                } else if (mAppState == AppState.RUNNING) {
                    return true;
                }

                return false;
            }
        }

        /**
         * Handles a key-up event.
         * 
         * @param keyCode the key that was pressed
         * @param msg the original event object
         * @return true if the key was handled and consumed, or else false
         */
        boolean doKeyUp(int keyCode, KeyEvent msg) {
            boolean handled = false;

            synchronized (mSurfaceHolder) {
                if (mAppState == AppState.RUNNING) {
                    if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER
                            || keyCode == KeyEvent.KEYCODE_SPACE) {
                        handled = true;
                    } else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT
                            || keyCode == KeyEvent.KEYCODE_Q
                            || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT
                            || keyCode == KeyEvent.KEYCODE_W) {
                        handled = true;
                    }
                }
            }

            return handled;
        }

        /**
         * Draws the ship, fuel/speed bars, and background to the provided
         * Canvas.
         */
        private void doDraw(Canvas canvas) {
                canvas.drawColor(Color.BLACK);
                
                switch(mGameState) {
                case MAIN_MENU:
                wndMainMenu.draw(canvas);
                        break;
                case BATTLE_MAP:
                        mTextPaint.setTextSize(12);
                
                mMap.draw(canvas);
                
                if(selectedUnit != null) {
                        for(Point p : selectedUnit.getMovementRange()) {
                                canvas.drawRect(p.x*50+10, p.y*50+25, p.x*50+50+10, p.y*50+50+25, mSelectionPaint);
                        }
                }
                
                mMap.drawUnits(canvas);
                
                        break;
                }
        }

        /**
         * Figures the lander state (x, y, fuel, ...) based on the passage of
         * realtime. Does not invalidate(). Called at the start of draw().
         * Detects the end-of-game and sets the UI to the next state.
         */
        private void updatePhysics() {
            long now = System.currentTimeMillis();

            // Do nothing if mLastTime is in the future.
            // This allows the game-start to delay the start of the physics
            // by 100ms or whatever.
            if (mLastTime > now) return;
            
            // DO SHIT HERE

            mLastTime = now+50;
        }
    }

    /** Pointer to the text view to display "Paused.." etc. */
    private TextView mStatusText;

    /** The thread that actually draws the animation */
    private DrawingThread thread;
    
    public Game mGame;

    public GameView(Context context, AttributeSet attrs) {
        super(context, attrs);

        // register our interest in hearing about changes to our surface
        SurfaceHolder holder = getHolder();
        holder.addCallback(this);

        // create thread only; it's started in surfaceCreated()
        thread = new DrawingThread(holder, context, new Handler() {
            @Override
            public void handleMessage(Message m) {
                mStatusText.setVisibility(m.getData().getInt("viz"));
                mStatusText.setText(m.getData().getString("text"));
            }
        });

        setFocusable(true); // make sure we get key events
    }

    @Override public boolean onTouchEvent(MotionEvent event) {
        Log.i("AdvanceWars", "Detected touch event");
        
        if(event.getAction() == MotionEvent.ACTION_UP) {
                Log.i("AdvanceWars", "Detected UP touch action");
                switch(thread.mGameState) {
                case MAIN_MENU:
                        Log.i("AdvanceWars", "Switching to battle map");
                        if(thread.wndMainMenu.getGUIObject("btnNewGame").isClicked(event.getX(), event.getY())) {
                                thread.mGameState = GameState.BATTLE_MAP;
                        }else if(thread.wndMainMenu.getGUIObject("btnLoadGame").isClicked(event.getX(), event.getY())) {
                                BufferedReader b;
                        try {
                                b = new BufferedReader(new FileReader(android.os.Environment.getExternalStorageDirectory()+"/save.txt"));
                                
                                int width = Integer.parseInt(b.readLine());
                                int height = Integer.parseInt(b.readLine());
                                
                                String offset = b.readLine();
                                Log.i("GameSave", offset);
                                int offsetX = Integer.parseInt(offset.substring(0, offset.indexOf("x")));
                                int offsetY = Integer.parseInt(offset.substring(offset.indexOf("x")+1));
                                
                                thread.mMap = new Map(thread.grassTile, width, height, new Point(offsetX, offsetY));
                                
                                Log.i("GameSave", "Created the map");
                                
                                for(int x=0; x<width; x++) {
                                        String line = b.readLine();
                                        Log.i("GameSave", line);
                                        String[] arr = line.split(",");
                                        for(int y=0; y<arr.length; y++) {
                                                TerrainType type = TerrainType.values()[Integer.parseInt(arr[y])];
                                                if(type.equals(TerrainType.LAND))
                                                        thread.mMap.setTile(x, y, new Tile(thread.grassTile, new Point(10, 25)));
                                                else
                                                        thread.mMap.setTile(x, y, new Tile(thread.oceanTile, new Point(10, 25)));
                                        }
                                }
                                
                                while(b.ready()) {
                                        String unit = b.readLine();
                                        Log.i("GameSave", unit);
                                        int x = Integer.parseInt(unit.substring(0, unit.indexOf(",")));
                                        int y = Integer.parseInt(unit.substring(unit.indexOf(",")+1));
                                        
                                        mGame.mThread.mMap.getTile(x, y).addUnit(new Soldier(mGame.mThread.mUnitPaint));
                                }
                                
                                b.close();
                        }catch(IOException ioe) {
                                ioe.printStackTrace();
                        }
                                thread.mGameState = GameState.BATTLE_MAP;
                        }else if(thread.wndMainMenu.getGUIObject("btnQuit").isClicked(event.getX(), event.getY())) {
                                mGame.finish();
                        }
                        break;
                case BATTLE_MAP:
                        Log.i("AdvanceWars", "Touch event detected on battle map");
                        
                        if(event.getX() >= thread.mMap.offset.x && event.getY() >= thread.mMap.offset.y) {
                                int x = ((int)event.getX() - thread.mMap.offset.x) / 50;
                                int y = ((int)event.getY() - thread.mMap.offset.y) / 50;
                                
                                Unit target = thread.mMap.getTile(x, y).currentUnit;
                                
                                if(thread.selectedUnit != null && thread.selectedUnit.getMovementRange().contains(new Point(x, y))) {
                                        if(target == null || target == thread.selectedUnit) {
                                                        thread.mMap.getTile(thread.selectedUnit.location.x, thread.selectedUnit.location.y).removeUnit();
                                                        thread.mMap.getTile(x, y).addUnit(thread.selectedUnit);
                                        }else {
                                                // the target contains another unit. If the unit is enemy-controlled, attack it
                                        }
                                        thread.selectedUnit = null;
                                }else
                                        thread.selectedUnit = target;
                        }
                        
                        break;
                }
        }else if(event.getAction() == MotionEvent.ACTION_DOWN) {
                
        }
        
        return true;
    }
    
    /**
     * Fetches the animation thread corresponding to this LunarView.
     * 
     * @return the animation thread
     */
    public DrawingThread getThread() {
        return thread;
    }

    /**
     * Standard override to get key-press events.
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent msg) {
        return thread.doKeyDown(keyCode, msg);
    }

    /**
     * Standard override for key-up. We actually care about these, so we can
     * turn off the engine or stop rotating.
     */
    @Override
    public boolean onKeyUp(int keyCode, KeyEvent msg) {
        return thread.doKeyUp(keyCode, msg);
    }

    /**
     * Standard window-focus override. Notice focus lost so we can pause on
     * focus lost. e.g. user switches to take a call.
     */
    @Override
    public void onWindowFocusChanged(boolean hasWindowFocus) {
        if (!hasWindowFocus) thread.pause();
    }

    /**
     * Installs a pointer to the text view used for messages.
     */
    public void setTextView(TextView textView) {
        mStatusText = textView;
    }

    /* Callback invoked when the surface dimensions change. */
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
        thread.setSurfaceSize(width, height);
    }

    /*
     * Callback invoked when the Surface has been created and is ready to be
     * used.
     */
    public void surfaceCreated(SurfaceHolder holder) {
        // start the thread here so that we don't busy-wait in run()
        // waiting for the surface to be created
        thread.setRunning(true);
        
        //if(thread.mAppState == AppState.PAUSE)
                //thread.unpause();
        //else
                thread.start();
    }

    /*
     * Callback invoked when the Surface has been destroyed and must no longer
     * be touched. WARNING: after this method returns, the Surface/Canvas must
     * never be touched again!
     */
    public void surfaceDestroyed(SurfaceHolder holder) {
        // we have to tell thread to shut down & wait for it to finish, or else
        // it might touch the Surface after we return and explode
        boolean retry = true;
        thread.setRunning(false);
        while (retry) {
            try {
                thread.join();
                retry = false;
            } catch (InterruptedException e) {
            }
        }
    }
}