Merge branch 'master' of ssh://repo.or.cz/srv/git/AntiTD

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

package se.umu.cs.dit06ajnajs;


import java.awt.Graphics;
import java.awt.Point;
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.Agent;
import se.umu.cs.dit06ajnajs.agent.AgentPrototypeFactory;
import se.umu.cs.dit06ajnajs.agent.BasicTower;
import se.umu.cs.dit06ajnajs.agent.Direction;
import se.umu.cs.dit06ajnajs.agent.Unit;
import se.umu.cs.dit06ajnajs.map.GoalSquare;
import se.umu.cs.dit06ajnajs.map.Level;
import se.umu.cs.dit06ajnajs.map.MapSquare;
import se.umu.cs.dit06ajnajs.map.StartSquare;

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

    private final int FRAMES_PER_SECOND = 20;

    private ATDModel model;
    private ATDView view;

    private boolean running;
    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();
        newGame();
    }

    public void newGame() {
        // TODO: game related init
        model.newGame();        
        
        this.running = true;
        this.animationThread = new Thread(new AnimationThread());
        this.creditThread = new Thread(new CreditThread());
        animationThread.start();
        creditThread.start();
    }

    private class AnimationThread implements Runnable {
        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 Auto-generated method stub
            while (running) {
                List<Agent> agents = model.getAgents();
                List<Unit> units = new ArrayList<Unit>();
                
                // Check for collisions
                for (Agent agent : agents) {
                    // Extract all units
                    if (agent instanceof Unit) {
                        units.add((Unit)agent);
                    }
                }
                
                // Update all agents
                List<Agent> deadAgents = new ArrayList<Agent>();
                for (Agent agent : agents) {
                    if (agent.isAlive()) {
                        if (agent instanceof Unit) {
                            // Collisioncheck
                            for (Unit unit : units) {
                                if (agent != unit) {
                                    if (((Unit) agent).intersectsNextMove(unit)) {
                                        // Collision!
                                        ((Unit) agent).collision(unit);
                                    }
                                }
                            }
                            agent.act();
                        } else {
                            agent.act();
                        }
                    } else {
                        deadAgents.add(agent);
                        logger.info("Dead unit is collected to list deadAgents");
                    }
                }
                if (!deadAgents.isEmpty()) {
                    model.removeAgents(deadAgents);
                    logger.info("Dead agents cleared");
                }

                // 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();
                }
                if (credit > 0 || numOfUnits > 0) {
                    model.addCredit(credit);    
                    model.addGoalUnit(numOfUnits);
                    view.updateScoreboard();
                }
                 


                // 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
                Graphics g = view.getGameGraphics();
                for (Agent agent : agents) {
                    //TODO kan det finnas en agent som inte är paintable?
                    agent.paint(g);
                }

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

                // Try to keep a given number of frames per second.
                try {
                    Thread.sleep(1000 / 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(running) {
                try {
                    // Sleep an interval, calculate earned credits, update model
                    Thread.sleep(1000);
                    int credit = calculateCredit();
                    model.addCredit(credit);
                    view.updateScoreboard();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        
        private int calculateCredit() {
            List<Agent> agents = model.getAgents();
            List<Unit> units = new ArrayList<Unit>();
            for (Agent agent : agents) {
                // Extract all units
                if(agent instanceof Unit) {
                    units.add((Unit)agent);
                }
            }
            int credit = units.size() * 10;            
            return credit;
        }
        
    }
    /* 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());
    }

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

    private class MapListener extends MouseAdapter {
        @Override
        public void mouseClicked(MouseEvent me) {
            final int x = me.getX();
            final int y = me.getY();

            //             SwingUtilities.invokeLater(new Runnable() {
            //                     public void run() {
            //                     }
            //                 });
            Level level = model.getLevel();
            final MapSquare square = level.getMapSquareAtPoint(x, y);
            logger.info("Mouse clicked @ (" +  x + ", " + y + ")");
            logger.info("MapSquare @ " + square);
            square.click();
            view.updateBackgroundImage();
            //if (square instanceof StartSquare) {}
            //if (square instanceof TurnSquare) {}
        }
    }

    private class ClosingListener extends WindowAdapter
        implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            logger.info("Closing program");
            System.exit(0);
        }

        @Override
        public void windowClosing(WindowEvent we) {
            logger.info("Closing program");
            System.exit(0);
        }
    }

    private class PausResumeListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            if (running) {
                ATDController.this.running = false;
                view.updatePauseMenu("Resume");
            } else {
                ATDController.this.running = true;
                ATDController.this.animationThread
                    = new Thread(new AnimationThread());
                ATDController.this.creditThread
                    = new Thread(new CreditThread());
                animationThread.start();
                creditThread.start();
                view.updatePauseMenu("Pause");
            }
        }
    }

    private class ReleaseUnitListener implements ActionListener {
        public void actionPerformed(ActionEvent ae) {
            // Release Unit from active StartSquare
            // TODO: implement
            System.out.println("hej");
            AgentPrototypeFactory factory = AgentPrototypeFactory.getInstance();
            model.addUnit(factory.createUnit(view.getSelectedUnitType()));
        }
    }
}