People.java |
1 import java.awt.*; 2 import java.applet.*; 3 import javax.swing.*; 4 import java.awt.image.*; 5 import java.awt.geom.*; 6 import java.net.*; 7 import java.util.*; 8 /** 9 * Class to define People, the superclass of Person, Player and Trainer. Carry Items 10 * Monsters and Monsters at Home 11 * 12 * @see Monster 13 * @see Item 14 * @see Person 15 * @see Player 16 * @see Trainer 17 */ 18 public abstract class People extends MapObject 19 { 20 /** 21 * The Maximum number of Monsters to cary 22 */ 23 protected final int MAXMON = 4; 24 25 /** 26 * The Monsters caught, and able to be used, ie in the Pepole's hand 27 */ 28 protected Vector mon; // For the Monsters 29 /** 30 * The Monsters caught, and not able to be used, ie in the Pepole's home collection 31 */ 32 protected Vector hmon; // Monsters at home 33 /** 34 * The Items bought. 35 */ 36 protected Vector items; // For the items 37 38 /** 39 * The index of the active Monster 40 */ 41 protected int activeMon; // The index of the active Monster 42 /** 43 * True if has beed beaten by the Player 44 */ 45 protected boolean beaten; // Have I been Beaten by player? 46 /** 47 * True if in a battle, with Player or Person 48 */ 49 protected boolean battling; // Am I in a battle? 50 /** 51 * The amount of money carrying 52 */ 53 protected int money; // Amount of cash 54 /** 55 * The MapObject to paint this on top of 56 */ 57 protected static MapObject behind; // Object to Draw Behind 58 /** 59 * The direction facing as specified in Grid 60 * 61 * @see Grid 62 */ 63 protected int dir; // What way facing 64 /** 65 * The name of this 66 */ 67 protected String name; // The name of the People 68 /** 69 * The dialogue to present when in Battle 70 * 71 * @see Battle 72 */ 73 protected String dlg; 74 75 /** 76 * Gets the dialogue associated with this 77 * 78 * @return the dialogue associated with this 79 */ 80 public String getDialogue() { return dlg; } 81 /** 82 * Sets the dialogue associated with this 83 * 84 * @param slf the dialogue associated with this 85 */ 86 public void setDialogue(String slf) 87 { 88 if(slf != null) 89 this.dlg = slf; 90 } 91 /** 92 * Returns false, as this cannot be entered 93 */ 94 public boolean isEnterable() { return false; } 95 /** 96 * Sets the directio of this as specified in Grid 97 * 98 * @param direct the direction to face 99 * @return true iff direct is a valid direction 100 * @see Grid 101 */ 102 public boolean setDirection(int direct) 103 { 104 if(direct == Grid.LEFT || direct == Grid.RIGHT || direct == Grid.UP || direct == Grid.DOWN) 105 { 106 dir = direct; 107 return true; 108 } 109 else 110 return false; 111 } 112 /** 113 * Gets the direction facing 114 * 115 * @return the direction facing, as specified in Grid 116 * @see Grid 117 */ 118 public int getDirection() { return dir; } 119 /** 120 * Sets the MapObject to paint behind 121 * 122 * @param beh the MapObject to paint this over 123 */ 124 public void setBehind(MapObject beh) 125 { 126 if(beh.canBeEntered()) 127 { 128 behind = beh; 129 } 130 } 131 /** 132 * Gets the MapObject standing on 133 * 134 * @return the MapObject standing on 135 */ 136 public MapObject getBehind() { return behind; } 137 /** 138 * Defeat this, ie sets beaten to true. 139 */ 140 public void beat() { beaten = true; } 141 /** 142 * Gets if this is in a Battle 143 * 144 * @return true if is in a Battle 145 * @see Battle 146 * @see PersonAI 147 */ 148 public boolean isBattling() { return battling; } 149 /** 150 * Begins a battle with this, sets battle to true. 151 */ 152 public void battle() { battling = true; } 153 /** 154 * Ends a battle with this, sets battle to false. 155 */ 156 public void stopBattle() { battling = false; } 157 /** 158 * Sets the amount of Money carried. 159 * 160 * @param mon the amount of money carried 161 */ 162 public void setMoney(int mon) 163 { 164 if(mon > 0) money = mon; 165 else money = 0; 166 } 167 /** 168 * Gets the amount of Money carried. 169 * 170 * @return mon the amount of money carried 171 */ 172 public int getMoney() { return money; } 173 /** 174 * Gets the name of this. 175 * 176 * @return the name of this 177 */ 178 public String getName() { return name; } 179 /** 180 * Sets the name of this. 181 * 182 * @param name the name of this 183 */ 184 public void setName(String name) 185 { 186 if(name != null) 187 this.name = name; 188 } 189 /** 190 * Determine if this has been beaten. 191 * 192 * @return true iff this has been beaten. 193 */ 194 public boolean isBeaten() { return beaten; } 195 /** 196 * Adds a Monster to this, either to the hand or to 197 * home if the hand has more than this.MAXMON 198 * 199 * @param p the Monster to add 200 * @return true if added to hand, false otherwise 201 * @see Monster 202 */ 203 public boolean addMonster(Monster p) 204 { 205 if(p == null) 206 return false; 207 if(mon.size() < MAXMON) 208 { 209 mon.add(p); 210 return true; 211 } 212 else 213 { 214 hmon.add(p); 215 return false; 216 } 217 } 218 /** 219 * Adds a Monster to the Home collection 220 * 221 * @param the Monster to add 222 * @see Monster 223 */ 224 public void addMonsterHome(Monster p) 225 { 226 if(p != null) 227 { 228 hmon.add(p); 229 } 230 } 231 /** 232 * Switches a Monster from Home collection to the 233 * Hand collection. 234 * 235 * @param hand the Monster in the hand to send home 236 * @param home the Monster at home to send to the hand 237 * @see Monster 238 */ 239 public boolean switchMonster(Monster hand, Monster home) 240 { 241 int i, j; 242 i = mon.indexOf(hand); 243 j = hmon.indexOf(home); 244 if(i >= 0 && j >= 0) 245 { 246 hmon.remove(home); 247 mon.remove(hand); 248 hmon.add(hand); 249 mon.add(home); 250 return true; 251 } 252 return false; 253 } 254 /** 255 * Sets the ActiveMonster for this. Does not count Monsters that 256 * have no HP. 257 * 258 * @param i the new index of the ActiveMonster for this. 259 */ 260 public void setActiveMonster(int i) 261 { 262 if(i >= 0 && i < mon.size()) 263 { 264 activeMon = i; 265 } 266 } 267 /** 268 * Gets the index of the Active Monster. Does not count Monsters that 269 * have no HP. 270 * 271 * @return the index of the Active Monster 272 */ 273 public int getActiveMonster() { return activeMon; } 274 /** 275 * Gets the Monster from the hand at the specified index, ignoring Monsters that have no HP. 276 * 277 * @param i the index to retrieve the Monster from 278 * @return the Monster at the specified index, not counting Monsters that have no HP 279 */ 280 public Monster getMonster(int i) 281 { 282 int j = 0; 283 if(i >= 0 && i < mon.size()) 284 { 285 Monster m; 286 for(int q = 0; q < mon.size(); q++) 287 { 288 m = (Monster)mon.get(q); 289 if(m.getHP() > 0) 290 { 291 if(j == i) 292 return m; 293 j++; 294 } 295 } 296 } 297 return null; 298 } 299 /** 300 * Gets the Monster from home at the specified index, ignoring Monsters that have no HP. 301 * 302 * @param i the index to retrieve the Monster from 303 * @return the Monster at the specified index, not counting Monsters that have no HP 304 */ 305 public Monster getMonsterAtHome(int i) 306 { 307 int j = 0; 308 if(i >= 0 && i < hmon.size()) 309 { 310 Monster m; 311 for(int q = 0; q < hmon.size(); q++) 312 { 313 m = (Monster)hmon.get(q); 314 if(m.getHP() > 0) 315 { 316 if(j == i) 317 return m; 318 j++; 319 } 320 } 321 } 322 return null; 323 } 324 /** 325 * Gets the number of Monsters in the hand that do not 326 * have 0 hp. 327 * 328 * @return the number of Monsters in the hand that do not have 0 hp. 329 */ 330 public int getNumberOfMonsters() 331 { 332 int num = 0; 333 for(int i = 0; i < mon.size(); i++) 334 { 335 if(((Monster)mon.get(i)).getHP() > 0) 336 num++; 337 } 338 return num; 339 } 340 /** 341 * Gets the number of Monsters at home that do not 342 * have 0 hp. 343 * 344 * @return the number of Monsters at home that do not have 0 hp. 345 */ 346 public int getNumberOfMonstersAtHome() 347 { 348 int num = 0; 349 for(int i = 0; i < hmon.size(); i++) 350 { 351 if(((Monster)hmon.get(i)).getHP() > 0) 352 num++; 353 } 354 return num; } 355 /** 356 * Adds the Item specified to this. 357 * 358 * @param i the Item to add 359 * @see Item 360 */ 361 public void addItem(Item i) 362 { 363 if(i == null) 364 return; 365 Item it; 366 for(int j = 0; j < items.size(); j++) 367 { 368 it = (Item)items.get(j); 369 if(i.equals(it)) 370 { 371 it.addItem(); 372 return; 373 } 374 } 375 items.add(i); 376 } 377 378 /** 379 * Gets the Item corresponding to the name specified. 380 * 381 * @param the name to search Item Collection for 382 * @return the Item corresponding to the name specified. 383 * @see Item 384 */ 385 public Item getItem(String name) 386 { 387 Item it; 388 for(int i = 0; i < items.size(); i++) 389 { 390 it = (Item)items.get(i); 391 if(it.getName().equalsIgnoreCase(name)) 392 { 393 return it; 394 } 395 } 396 return null; 397 } 398 /** 399 * Uses the Item specified on the Monster specified 400 * 401 * @param it the Item to use on the Monster 402 * @param m the Monster to use the Item on 403 * @see Monster 404 * @see Item 405 */ 406 public void useItem(Item it, Monster m) 407 { 408 it.useItem(m); 409 if(it.getItemCount() == 0) 410 items.remove(it); 411 } 412 /** 413 * Gets the number of Item this has. 414 * 415 * @param name the name of the Item to get the count of. 416 * @see Item 417 */ 418 public int getItemCount(String name) 419 { 420 Item it; 421 for(int i = 0; i < items.size(); i++) 422 { 423 it = (Item)items.get(i); 424 if(it.getName().equalsIgnoreCase(name)) 425 { 426 return it.getItemCount(); 427 } 428 } 429 return 0; 430 } 431 /** 432 * Heals all Monster to full HP, Attack Points, and Defense Points 433 * 434 * @see Monster 435 * @see Shop 436 */ 437 public void healAllMonsters() 438 { 439 Monster m; 440 for(int i = 0; i < mon.size(); i++) 441 { 442 m = (Monster)mon.get(i); 443 m.setHP(m.getMaxHP()); 444 m.setAttack(m.getMaxAttack()); 445 m.setDefense(m.getMaxDefense()); 446 } 447 } 448 /** 449 * Gets an array of String for the Attacks available for the 450 * Monster at index p, ignoring the Monsters with no HP. 451 * 452 * @param the index of the Monster to get the Attacks for, ignoring those with no HP 453 * @return an array of String for the Attacks available for the Monster at index p, ignoring the Monsters with no HP. 454 * @see Monster 455 * @see Battle 456 */ 457 public String[] getMonsterAttacks(int p) 458 { 459 if(p < mon.size() && p >= 0) 460 { 461 int j = 0; 462 Monster m; 463 for(int q = 0; q < mon.size(); q++) 464 { 465 m = (Monster)mon.get(q); 466 if(m.getHP() > 0) 467 { 468 if(j == p) 469 return m.getAttacks(); 470 j++; 471 } 472 } 473 } 474 return new String[Monster.MAXATTACKS]; 475 } 476 /** 477 * Gets an array of Strings of the Monsters that the Player is currently carrying, ignoring 478 * those with no HP. 479 * 480 * @return an array of Strings of the Monsters that the Player is currently carrying, ignoring those with no HP. 481 * @see Monster 482 * @see Battle 483 */ 484 public String[] getMonsters() 485 { 486 String[] s = new String[MAXMON]; 487 Monster m; 488 for(int i = 0, j = 0; i < mon.size(); i++) 489 { 490 m = (Monster)mon.get(i); 491 if(m.getHP() > 0) 492 { 493 s[j++] = m.getName(); 494 } 495 } 496 return s; 497 } 498 /** 499 * Gets an array of Strings of the Item that the Player is currently carrying 500 * 501 * @return an array of Strings of the Item that the Player is currently carrying. 502 * @see Item 503 * @see Battle 504 * @see Shop 505 */ 506 public String[] getItems() 507 { 508 if(items.size() == 0) 509 return new String[4]; 510 String[] s; 511 if(items.size() >= 4) 512 s = new String[items.size()]; 513 else 514 s = new String[4]; 515 for(int i = 0; i < items.size(); i++) 516 { 517 s[i] = ((Item)items.get(i)).getName(); 518 } 519 return s; 520 } 521 }