Fixed bug in collecting credits and changed behaviour of playing music

[AntiTD.git] / src / se / umu / cs / dit06ajnajs / ATDController.java

package se.umu.cs.dit06ajnajs;

import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import se.umu.cs.dit06ajnajs.agent.AgentPrototypeFactory;
import se.umu.cs.dit06ajnajs.agent.Tower;
import se.umu.cs.dit06ajnajs.agent.Unit;
import se.umu.cs.dit06ajnajs.level.GoalSquare;
import se.umu.cs.dit06ajnajs.level.Level;
import se.umu.cs.dit06ajnajs.level.StartSquare;

import se.umu.cs.edu.jap.highscoreservice.HighScoreServiceClient;
import se.umu.cs.edu.jap.highscoreservice.Entry;
import java.net.URL;
import se.umu.cs.edu.jap.highscoreservice.stubs.FailureFaultException;
import java.net.MalformedURLException;
import java.util.Date;
import java.awt.Point;

public class ATDController {
    private static Logger logger = Logger.getLogger("AntiTD");

    private final int FRAMES_PER_SECOND = 20;
    private static boolean mute;

    private ATDModel model;
    private ATDView view;

    private boolean running;
    private boolean clocking;
    private boolean changeLevel;
    private boolean paused;
    private Thread animationThread;
    private Thread creditThread;
    
    public ATDController(List<Level> levels) {
        // Create model and view
        this.model = new ATDModel(levels);
        this.view = new ATDView(model);
        connectListeners();
        
        // TODO: game related init
        newGame();
        
        // Sound is on by default
        mute = false;
        this.running = true;
        this.clocking = true;
        this.changeLevel = false;
        this.animationThread = new Thread(new AnimationThread());
        this.creditThread = new Thread(new CreditThread());
        animationThread.start();
        creditThread.start();
    }

    public void advanceLevel() {
        ATDSoundPlayer.killMusic();
        if (model.advanceLevel()) {
            view.updateScoreboard();
            view.updateBackgroundImage();
            ATDSoundPlayer.playMusic(model.getNextTrack());
        } else {
            // Game won
            winGame();
        }
    }

    public void newGame() {
        ATDSoundPlayer.killMusic();
        model.newGame();
        view.updateScoreboard();
        view.updateBackgroundImage();
        view.repaintGame();
        ATDSoundPlayer.playMusic(model.getNextTrack());
    }
    
    public void restartLevel() {
        ATDSoundPlayer.killMusic();
        model.restartLevel();
        view.updateScoreboard();
        view.updateBackgroundImage();
        ATDSoundPlayer.playMusic(model.getNextTrack());
    }

    public void winGame() {
        ATDSoundPlayer.killMusic();
        try {
            String urlString = "http://salt.cs.umu.se:37080/axis2/services/HighScoreService";
            URL url = new URL(urlString);
            HighScoreServiceClient client = new HighScoreServiceClient(url);
            
            String name = view.promtForHighScoreEntry();
            String date = new Date().toString();
            String score = model.getScore() + "";
            
            client.store(new Entry(name, date, score));
            view.printMessage("Score stored.");
            newGame();
        } catch (FailureFaultException e) {
            // e.printStackTrace();
            view.printMessage("Couldn't store score");
        } catch (MalformedURLException e) {
            // TODO - fix error message
            e.printStackTrace();
        }
    }
    
    public void loseGame() {
        ATDSoundPlayer.killMusic();
        if (view.showLevelLostDialog() == 0) {
            newGame();
        } else {
            quitApplication();
        }
    }

    /**
     * Wrapper method, calls clickPoint(int x, int y).
     *
     * @param point The point to click.
     */
    public void clickPoint(Point point) {
        clickPoint(point.x, point.y);
    }


    /**
     * Clicks all Clickables at the specified x, y point.
     *
     * @param x The x-location to click.
     * @param y The y-location to click.
     */
    public void clickPoint(int x, int y) {
        List<Unit> units = model.getUnits();
        for (Unit unit : units) {
            if (unit.contains(x, y)) {
                unit.click();
            }
        }
        model.getCurrentLevel().getMapSquareAtPoint(x, y).click();
    }
    
    /**
     * Toggles sound on/off.
     */
    private void toggleMute() {
        if (ATDSoundPlayer.isMute()) {
            ATDSoundPlayer.setMute(false);
            view.updateMuteMenu("Mute");
            view.printMessage("Sound is on");
        } else {
            ATDSoundPlayer.setMute(true);
            view.updateMuteMenu("unMute");
            view.printMessage("Sound is muted");
        }
    }
    
    /**
     * Toggles pause, which freezes game.
     */
    private void togglePause() {
        if (paused) {
            ATDController.this.paused = false;
            view.updatePauseMenu("Pause");
            view.printMessage("");
        } else {
            ATDController.this.paused = true;
            view.updatePauseMenu("Resume");
            view.printMessage("Game is paused");
        }
    }
    
    /**
     * Quits this application.
     */
    private void quitApplication() {
        this.running = false;
        this.clocking = false;
        logger.info("Closing program");
        System.exit(0);
    }


    private class AnimationThread implements Runnable {
        private long usedTime;
        public AnimationThread() {
            // Paint background

            view.repaintGame();
        }

        /**
         * While running, the thread loops through all actions the game can
         * generate as many times per second determined by the final class
         * variable FRAMES_PER_SECOND
         */
        public void run() {
            // TODO Will running ever be false?
            while (running) {
                // Check if game is paused
                while (paused) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                long startTime = System.currentTimeMillis();

                // Update all units
                List<Unit> units = model.getUnits();
                List<Unit> deadUnits = new ArrayList<Unit>();
                for (Unit unit : units) {
                    if (unit.isAlive()) {
                        // Collisioncheck
                        for (Unit otherUnit : units) {
                            if (unit != otherUnit) {
                                if (unit.intersectsNextMove(otherUnit)) {
                                    // Collision!
                                    unit.collision(otherUnit);
                                }
                            }
                        }
                        unit.act();
                    } else {
                        // Add dead unit
                        deadUnits.add(unit);
                        logger.info("Dead unit is collected to list deadUnits");
                        //TODO 
                        /*the towers should be rewarded for dead units
                        Remember that cleared units are also "dead" 
                        but should not be counted
                         */
                    }
                }
                
                // Collect dead units
                if (!deadUnits.isEmpty()) {
                    model.removeUnits(deadUnits);
                    logger.info("Dead agents cleared");
                }
                
                // Update all towers
                List<Tower> towers = model.getTowers();
                for (Tower tower : towers) {
                    tower.act();
                }

                // Remove units from goalsquares and count points
                GoalSquare[] goalSquares = model.getGoalSquares();
                int credit = 0;
                int numOfUnits = 0;
                for (GoalSquare square : goalSquares) {
                    numOfUnits = square.getNumUnits();
                    credit += square.getCredit();
                }
                // Only update model if changes has been made and level is not
                // completed
                if ((credit > 0 || numOfUnits > 0) 
                        && !model.isLevelComplete()) {
                    model.addCredit(credit);    
                    model.addGoalUnit(numOfUnits);
                    view.updateScoreboard();
                    ATDSoundPlayer.play(model.getSound("goal"));
                }
                
                // Release Unit from StartSquares
                StartSquare[] startSquares = model.getStartSquares();
                for (StartSquare startSquare : startSquares) {
                    Unit unitToStart = startSquare.getUnitToStart();
                    boolean unitToStartCollided = false;
                    if (unitToStart != null) {
                        for (Unit unit : units) {
                            unitToStartCollided = unitToStart.intersects(unit);
                            if (unitToStartCollided) {
                                // Collision
                                break;
                            }
                        }
                        if (!unitToStartCollided) {
                            // No collision found
                            startSquare.removeUnit(unitToStart);

                            model.releaseUnit(unitToStart);
                        }
                    }
                }

                // Repaint all agents
                //TODO kan det finnas en agent som inte är paintable?
                Graphics g = view.getGameGraphics();
                for (Unit unit : units) {
                    unit.paint(g);
                }
                for (Tower tower : towers) {
                    tower.paint(g);
                }

                // Refresh the game view
                view.repaintGame();

                this.usedTime = System.currentTimeMillis() - startTime;
                // Try to keep a given number of frames per second.
                try {
                    // TODO think, fps???
                    Thread.sleep((1000 - usedTime) / FRAMES_PER_SECOND);
                } catch (InterruptedException e) {
                    System.err.println("Error in thread, exiting.");
                    return;
                }
            }
        }
    }

    private class CreditThread implements Runnable {
        public CreditThread() {

        }

        /**
         * While running, the thread sleeps for an interval and then calculates
         * the earned credits from units on the map. The credits are then added
         * to the player
         */
        public void run() {
            while(clocking) {
                // Check if game is paused
                while(paused) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                // Calculate earned credits
                int credit = calculateCredit();
                if (credit > 0) {
                    model.addCredit(credit);
                    view.updateScoreboard();
                }
                // Goal check
                if (model.isLevelComplete()) {
                    System.out.println("Victory!");
                    ATDSoundPlayer.killMusic();
                    ATDSoundPlayer.play(model.getSound("victory"));
                    // Check if user wants to restart level or go to next
                    if(view.showLevelCompleteDialog() == 0) {
                        advanceLevel();
                    } else {
                        restartLevel();
                    }
                }
                // Lose check
                if (model.isLevelLost()) {
                    
                    System.out.println("You lose!");
                    loseGame();
                }
                try {
                    // Sleep an interval
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
        }

        private int calculateCredit() {
            List<Unit> units = model.getUnits();
            int credit = units.size() * 10;            
            return credit;
        }
    }


    public void saveToHighScoreService() {
        // Save highscore to Highscoreservice
    }
    /* Connect listeners to View *************************************/

    private void connectListeners() {
        this.view.addMapListener(new MapListener());
        this.view.addClosingListener(new ClosingListener());
        this.view.addReleaseUnitListener(new ReleaseUnitListener());
        this.view.addPauseMenuItemListener(new PausResumeListener());
        this.view.addMuteMenuItemListener(new MuteListener());
        this.view.addNewGameMenuItemListener(new NewGameListener());
        this.view.addAboutMenuItemListener(new AboutListener());
        this.view.addHelpMenuItemListener(new HelpListener());
        this.view.addRestartLevelMenuItemListener(new RestartLevelListener());
    }

    /* Inner Listener classes ****************************************/

    private class MapListener extends MouseAdapter {
        @Override
        public void mouseClicked(MouseEvent me) {
            clickPoint(me.getX(), me.getY());
            // TODO, only update what is needed.
            view.updateBackgroundImage();
        }
    }

    private class ClosingListener extends WindowAdapter
    implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            quitApplication();
        }

        @Override
        public void windowClosing(WindowEvent we) {
            quitApplication();
        }
    }

    private class PausResumeListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            ATDController.this.togglePause();
        }
    }

    private class MuteListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            ATDController.this.toggleMute();
        }
    }

    private class NewGameListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            ATDController.this.newGame();
        }
    }
    
    private class RestartLevelListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            ATDController.this.restartLevel();
        }
    }
    
    private class AboutListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            if (!paused) {
                ATDController.this.togglePause();
            }
            view.showAboutDialog();
            ATDController.this.togglePause();
        }
    }
    
    private class HelpListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            if (!paused) {
                ATDController.this.togglePause();
            }
            view.showHelpDialog();
            ATDController.this.togglePause();
        }        
    }

    /**
     * Creates a new unit and adds it to the game model.
     */
    private class ReleaseUnitListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            AgentPrototypeFactory factory = AgentPrototypeFactory.getInstance();
            if (!model.addUnit(factory.createUnit(view.getSelectedUnitType()))) {
                view.printMessage("Insufficient funds!");
            } else {
                view.printMessage("");
            }
        }
    }
}