src/se/umu/cs/dit06ajnajs/agent/AgentPrototypeFactory.java

   1 package se.umu.cs.dit06ajnajs.agent;
   2
   3 import java.awt.Image;
   4 import java.awt.image.BufferedImage;
   5 import java.io.IOException;
   6 import java.net.URL;
   7 import javax.imageio.ImageIO;
   8 import java.util.Set;
   9 import java.util.HashMap;
  10 import se.umu.cs.dit06ajnajs.AntiTD;
  11
  12 /**
  13  * AgentPrototypeFactory is used to create new instances of different
  14  * implementations of agents from a String. Implemented as a Singleton.
  15  */
  16 public class AgentPrototypeFactory {
  17     private static final AgentPrototypeFactory INSTANCE
  18         = new AgentPrototypeFactory();
  19     // private static Logger logger = Logger.getLogger("AntiTD");
  20
  21     private java.util.Map<String, Unit> unitMap;
  22     private java.util.Map<String, Tower> towerMap;
  23     private int lowestCost;
  24
  25     /**
  26      * Gets the only instance of this class, if none exists one is created.
  27      *
  28      * @return The only instance of this class.
  29      */
  30     public static AgentPrototypeFactory getInstance() {
  31         return INSTANCE;
  32     }
  33
  34     /**
  35      * AgentPrototypeFactory initialices all different types of Units and Towers
  36      * and puts them in a java.util.Map.
  37      *
  38      * Private constructor makes sure there can only be one instance of this
  39      * class, and that instance is created by the class itself from the first
  40      * invocation of getInstance()
  41      *
  42      */
  43     private AgentPrototypeFactory() {
  44         unitMap = new HashMap<String, Unit>();
  45         towerMap = new HashMap<String, Tower>();
  46
  47         // Instantiate Units and Towers
  48         try {
  49             // Get directory containing images
  50             // TODO: move to config class of file
  51             URL imagesURL = this.getClass().getResource("/resources/unit-images/");
  52
  53             // Init Units
  54
  55             // Create Standard FootmanUnit
  56             HashMap<Direction, Image> images = new HashMap<Direction, Image>();
  57
  58             BufferedImage image = ImageIO.read(new URL(imagesURL, "footmanDown.gif"));
  59             images.put(Direction.DOWN, image);
  60             image = ImageIO.read(new URL(imagesURL, "footmanUp.gif"));
  61             images.put(Direction.UP, image);
  62             image = ImageIO.read(new URL(imagesURL, "footmanLeft.gif"));
  63             images.put(Direction.LEFT, image);
  64             image = ImageIO.read(new URL(imagesURL, "footmanRight.gif"));
  65             images.put(Direction.RIGHT, image);
  66             unitMap.put("Footman",
  67                         new FootmanUnit("Footman", 40, 40, 2, 100, 500, images));
  68
  69             // Create Seal
  70             images = new HashMap<Direction, Image>();
  71
  72             image = ImageIO.read(new URL(imagesURL, "sealDown.gif"));
  73             images.put(Direction.DOWN, image);
  74             image = ImageIO.read(new URL(imagesURL, "sealUp.gif"));
  75             images.put(Direction.UP, image);
  76             image = ImageIO.read(new URL(imagesURL, "sealLeft.gif"));
  77             images.put(Direction.LEFT, image);
  78             image = ImageIO.read(new URL(imagesURL, "sealRight.gif"));
  79             images.put(Direction.RIGHT, image);
  80             unitMap.put("Seal",
  81                         new FootmanUnit("Seal", 33, 33, 1, 100, 100, images));
  82
  83             // Create SuperFootmanUnit
  84 //            image = ImageIO.read(new URL(imagesURL, "knightDown.gif"));
  85 //            images.put(Direction.DOWN, image);
  86 //            image = ImageIO.read(new URL(imagesURL, "unit.gif"));
  87 //            images.put(Direction.UP, image);
  88 //            image = ImageIO.read(new URL(imagesURL, "unit.gif"));
  89 //            images.put(Direction.LEFT, image);
  90 //            image = ImageIO.read(new URL(imagesURL, "unit.gif"));
  91 //            images.put(Direction.RIGHT, image);
  92 //            image = ImageIO.read(new URL(imagesURL, "knight.gif"));
  93 //            unitMap.put("SuperFootmanUnit",
  94 //                        new FootmanUnit("Knight", 40, 40, 4, 100, 1000, images));
  95
  96
  97             // Init Towers
  98             imagesURL = this.getClass().getResource("/resources/tower-images/");
  99
 100             // Create Basic Tower
 101             image = ImageIO.read(new URL(imagesURL, "basicTower.gif"));
 102             towerMap.put("BasicTower",
 103                          new BasicTower(41, 41, 3,
 104                                         (int) (AntiTD.SQUARE_SIZE*1.5),
 105                                         image));
 106
 107         } catch (IOException e) {
 108             System.err.println("Couldn't find image. Exception: "
 109                                + e.getMessage());
 110         }
 111
 112         // Find cost of cheapest unit
 113         this.lowestCost = Integer.MAX_VALUE;
 114         for (String s : getUnitTypes()) {
 115             Unit unit = createUnit(s);
 116             if (unit.getCost() < this.lowestCost) {
 117                 this.lowestCost = unit.getCost();
 118             }
 119         }
 120     }
 121
 122     // TODO: Implement and think, is this crazy? Lot's of stuff shouldn't have
 123     // to be in the parameterlist, needed info is x, y, Direction and map, the
 124     // rest is information about the unit-type. Create a Unit with only a
 125     // startSquare as a parameter?
 126     public Unit createUnit(String type) {
 127         Unit unitPrototype = unitMap.get(type);
 128         if (unitPrototype == null) {
 129             throw new IllegalArgumentException("The specified type '" + type
 130                                                + "' doesn't exist");
 131         }
 132         Unit resultUnit = (Unit) unitPrototype.clone();
 133         // resultUnit.setX(x);
 134         // resultUnit.setY(y);
 135         // resultUnit.setWidth(width);
 136         // resultUnit.setHeight(health);
 137         // resultUnit.setSpeed(speed);
 138         // resultUnit.setHealth(health);
 139         // resultUnit.setCost(cost);
 140         // resultUnit.setDirection(direction);
 141         // resultUnit.setMap(map);
 142         return resultUnit;
 143     }
 144
 145     public Tower createTower(String type) {
 146         Tower towerPrototype = towerMap.get(type);
 147         if (towerPrototype == null) {
 148             throw new IllegalArgumentException("The specified type '" + type
 149                                                + "' doesn't exist");
 150         }
 151         Tower resultTower = (Tower) towerPrototype.clone();
 152         resultTower.init();
 153         return resultTower;
 154     }
 155
 156     // TODO: How to get all keys? Hashtable can return Enumeration
 157     // public List<String> getUnitTypes() {}
 158
 159     @Override
 160     public Object clone() throws CloneNotSupportedException {
 161         throw new CloneNotSupportedException("AgentPrototypeFactory is a "
 162                                              + "Singleton no clones are"
 163                                              + " supported.");
 164     }
 165
 166     /**
 167      * Returns a Set containing all unitTypes this Class can produce.
 168      *
 169      * @return A Set containing all unitTypes this Class can produce.
 170      */
 171     public Set<String> getUnitTypes() {
 172         return unitMap.keySet();
 173     }
 174
 175     /**
 176      * Returns int representing the cost for the cheapest unit
 177      * @return int representing the cost for the cheapest unit
 178      */
 179     public int getLowestCost() {
 180         return this.lowestCost;
 181     }
 182 }