Fixed bug in collecting credits and changed behaviour of playing music

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

package se.umu.cs.dit06ajnajs;

import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.Dimension;
import java.awt.Image;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

import se.umu.cs.dit06ajnajs.agent.AgentPrototypeFactory;
import se.umu.cs.dit06ajnajs.agent.Tower;
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.dit06ajnajs.agent.Unit;
import java.util.Collection;

public class ATDModel { 
    private static Logger logger = Logger.getLogger("AntiTD");
    
    private Player player;
    private List<Unit> units;
    private List<Tower> towers;
    private List<Level> levels;
    private Level currentLevel;
    private Map<String, AudioClip> sounds;
    //private Map<String, File> tracks;
    private List<File> tracks;
    private int currentTrack;
    
        
    public ATDModel(List<Level> levels) {
        this.levels = levels;
        this.currentLevel = levels.get(0);
        
        // Load sounds for model
        try {
            URL soundsURL = getClass().getResource("/resources/sounds/");
            sounds = new HashMap<String, AudioClip>();
            AudioClip sound = Applet.newAudioClip(new URL(soundsURL, "goal.wav"));
            sounds.put("goal", sound);
            sound = Applet.newAudioClip(new URL(soundsURL, "victory.wav"));
            sounds.put("victory", sound);
            
            // Music tracks
//            tracks = new HashMap<String, File>();
//            File trackFile = new File(new URL(soundsURL, "track1.mid").toURI());
//            tracks.put("track1", trackFile);
//            trackFile = new File(new URL(soundsURL, "track2.mid").toURI());
//            tracks.put("track2", trackFile);
//            trackFile = new File(new URL(soundsURL, "track3.mid").toURI());
//            tracks.put("track3", trackFile);
//            trackFile = new File(new URL(soundsURL, "track4.mid").toURI());
//            tracks.put("track4", trackFile);
            
            // Music tracks
            tracks = new ArrayList<File>();
            currentTrack = 0;
            File trackFile = new File(new URL(soundsURL, "track1.mid").toURI());
            tracks.add(trackFile);
            trackFile = new File(new URL(soundsURL, "track2.mid").toURI());
            tracks.add(trackFile);
            trackFile = new File(new URL(soundsURL, "track3.mid").toURI());
            tracks.add(trackFile);
            trackFile = new File(new URL(soundsURL, "track4.mid").toURI());
            tracks.add(trackFile);
            
        } catch (IOException e) {
            System.err.println("Couldn't find sound. Exception: "
                    + e.getMessage());
        } catch (URISyntaxException e) {
            System.err.println("Couldn't find midi. Exception: "
                    + e.getMessage());
        }
        
    }

    /**
     * Creates a new player and initialises the first level.
     */
    public void newGame() {
        this.player = new Player();
        initLevel();
        // TODO: ...reset stuff
    }
    
    /**
     * Restart the current level
     */
    public void restartLevel() {
        player.loadSavedScore();
        initLevel();
    }
    
    public boolean advanceLevel() {
        player.saveScore();
        if (player.getCurrentLevel() + 1 < levels.size()) {
            player.setCurrentLevel(player.getCurrentLevel() + 1);
            initLevel();
            return true;
        } else {
            // game won, ask for highscore entry
            return false;
        }
    }
    
    /**
     * Initialises the level that is next in turn for the player
     */
    private void initLevel() {
        // Check if there is more levels
        if (player.getCurrentLevel() < levels.size()) {
            this.currentLevel = levels.get(player.getCurrentLevel());
            // If restartet game, the level must be reset
            this.currentLevel.resetLevel();
            this.towers = new ArrayList<Tower>();
            this.units = new ArrayList<Unit>();

            for (Tower tower : currentLevel.getTowers()) {
                towers.add(tower);
            }
            player.initCredit();
        } else {
            //TODO vad händer om det är slut på banor?
        }
    }
    
    public void addTower(Tower t) {
        currentLevel.addTower(t);
        towers.add(t);
    }

    public boolean addUnit(Unit unit) {
        // TODO Auto-generated method stub
        if (player.getCredit() >= unit.getCost()) {
            this.player.removeCredit(unit.getCost());
            StartSquare startSquare = this.currentLevel.getActiveStartSquare();
            unit.setMap(this.currentLevel);
            startSquare.addUnit(unit);
            return true;
        } else {
            return false;
        }
    }

    public void releaseUnit(Unit unit) {
        units.add(unit);
    }

    public List<Unit> getUnits() {
        // TODO Auto-generated method stub
        // Copy array
        List<Unit> resultList = new ArrayList<Unit>(this.units.size());
        resultList.addAll(this.units);
        return resultList;
    }
    
    public List<Tower> getTowers() {
        // Copy array
        List<Tower> resultList = new ArrayList<Tower>(this.towers.size());
        resultList.addAll(this.towers);
        return resultList;
    }

    /**
     * Removes all supplied units from this model. This is called when dead
     * units are cleared from a game.
     *
     * @param units A collection of units to remove.
     */
    public void removeUnits(Collection<Unit> units) {
        this.units.removeAll(units);
    }
    
    /**
     * Returns the current level.
     *
     * @return The current level.
     */
    public Level getCurrentLevel() {
        return this.currentLevel;
    }
    
    public Image getMapImage() {
        return currentLevel.getMapImage();
    }
    
    public Dimension getMapDimension() {
        return currentLevel.getDimension();     
    }
    
    public GoalSquare[] getGoalSquares() {
        return this.currentLevel.getGoalSquares();
    }

    public StartSquare[] getStartSquares() {
        return this.currentLevel.getStartSquares();
    }

    /**
     * Adds credit to the player
     * @param credit The credit to be added
     */
    public void addCredit(int credit) {
        player.addCredit(credit);
    }

    public int getCredit() {
        return player.getCredit();
    }
    
    public int getScore() {
        return player.getScore();
    }
    
    public int getSavedScore() {
        return this.player.getSavedScore();
    }
    
    public void saveScore() {
        player.saveScore();
    }
    
    public int getNumOfClearedUnits() {
        return currentLevel.getNumOfClearedUnits();
    }
    
    public int getUnitsToWin() {
        return currentLevel.getUnitsToWin();
    }

    /**
     * Adds to the number of units that have reached the goalsquare
     * @param num Number of units that have reached the goalsquare
     * @author dit06ajs
     */
    public void addGoalUnit(int num) {
        currentLevel.addClearedUnits(num);
    }
    
    /**
     * Checks if the goal for the current level is reached
     * @return True if the goal is reached
     */
    public boolean isLevelComplete() {
        return currentLevel.getNumOfClearedUnits() 
            >= currentLevel.getUnitsToWin();
    }
    
    /**
     * Checks if the level is lost
     * @return True if no units on the map and no credits to buy one unit
     */
    public boolean isLevelLost() {
        AgentPrototypeFactory factory = AgentPrototypeFactory.getInstance();
        int lowestCost = factory.getLowestCost();
        return (player.getCredit() <  lowestCost && units.size() == 0);
    }
    
    /**
     * Returns the sound matching the String
     * @param s The key for the sound
     * @return The sound as AudioClip
     */
    public AudioClip getSound(String s) {
        return sounds.get(s);
    }
    
    /**
     * 
     * Returns the track matching the String
     * @param s The key for the sound
     * @return The sound as File
     */
    public File getNextTrack() {
        int nextIndex = (currentTrack + 1) % tracks.size();
        currentTrack = nextIndex;
        // TODO, verify. Should get next track from list.
        return tracks.get(currentTrack);
    }
}