septon

一些JAVA的小程序

X    { NORTH_AFRICA, EGYPT, WESTERN_EUROPE, NORTHERN_EUROPE, UKRAINE, MIDDLE_EAST },
X    { SCANDINAVIA, NORTHERN_EUROPE, SOUTHERN_EUROPE, MIDDLE_EAST, AFGHANISTAN, URAL },
X    // Asia
X    { UKRAINE, AFGHANISTAN, SIBERIA, CHINA },
X    { URAL, CHINA, MONGOLIA, IRKUTSK, YAKUTSK },
X    { SIBERIA, IRKUTSK, KAMCHATKA },
X    { ALASKA, YAKUTSK, IRKUTSK, MONGOLIA, JAPAN },
X    { UKRAINE, MIDDLE_EAST, URAL, CHINA, INDIA },
X    { SIBERIA, YAKUTSK, KAMCHATKA, MONGOLIA },
X    { INDIA, AFGHANISTAN, URAL, SIBERIA, MONGOLIA, SIAM },
X    { CHINA, SIBERIA, IRKUTSK, KAMCHATKA, JAPAN },
X    { KAMCHATKA, MONGOLIA },
X    { EGYPT, EAST_AFRICA, SOUTHERN_EUROPE, UKRAINE, AFGHANISTAN, INDIA },
X    { MIDDLE_EAST, AFGHANISTAN, CHINA, SIAM },
X    { INDIA, CHINA, INDONESIA },
X    // Australia
X    { SIAM, NEW_GUINEA, WESTERN_AUSTRALIA },
X    { INDONESIA, WESTERN_AUSTRALIA, EASTERN_AUSTRALIA },
X    { INDONESIA, NEW_GUINEA, EASTERN_AUSTRALIA },
X    { NEW_GUINEA, WESTERN_AUSTRALIA }
X  };
X
X  // (unclosed) Polygon points, in x1, y1, x2, y2, etc. order.
X  private static int points[][] = {
X    // North America
X    { 24,61, 60,67, 60,96, 84,114, 81,118, 60,102, 40,97, 30,107, 6,100, 5,72 },
X    { 60,67, 144,72, 161,59, 187,75, 160,104, 71,104, 60,96 },
X    { 254,8, 312,5, 336,13, 315,65, 277,82, 269,100, 247,75, 241,43, 216,40, 208,28 },
X    { 71,104, 138,104, 138,133, 97,133, 81,118, 84,114 },
X    { 138,104, 160,104, 186,117, 189,125, 189,146, 161,133, 137,133 },
X    { 189,125, 195,123, 199,114, 197,93, 205,92, 218,106, 225,100, 244,123, 233,140, 216,138, 189,146 },
X    { 97,133, 150,133, 143,183, 112,176, 95,158 },
X    { 150,133, 161,133, 189,146, 216,138, 233,140, 225,147, 216,147, 201,167, 188,179, 192,191, 189,193, 183,182, 163,181, 154,191, 142,183 },
X    { 112,176, 142,183, 154,191, 157,207, 166,208, 169,203, 177,200, 174,213, 193,228, 190,232, 138,206 },
X    // South America
X    { 210,223, 229,225, 254,240, 220,240, 213,252, 195,244, 198,231 },
X    { 195,244, 213,252, 207,264, 235,279, 243,308, 200,281, 189,260 },
X    { 220,240, 254,240, 259,249, 289,260, 289,269, 280,277, 275,300, 259,305, 252,321, 243,308, 235,279, 207,264 },
X    { 213,289, 243,308, 252,321, 231,338, 216,370, 220,382, 211,382, 204,369 },
X    // Africa
X    { 385,164, 407,180, 413,207, 413,239, 383,239, 372,234, 345,237, 327,218, 327,201, 353,169 },
X    { 411,175, 431,180, 447,209, 413,207, 407,180 },
X    { 383,239, 430,239, 428,271, 394,271 },
X    { 413,207, 447,209, 457,227, 474,222, 471,240, 453,252, 452,271, 428,271, 430,239, 413,239 },
X    { 394,271, 452,271, 442,299, 427,322, 407,326, 390,288 },
X    { 471,276, 474,281, 468,301, 464,304, 459,297, 460,284 },
X    // Europe
X    { 313,79, 332,78, 336,83, 324,89, 316,86 },
X    { 356,103, 368,123, 364,127, 355,129, 357,119, 350,106 },
X    { 423,60, 431,65, 433,91, 425,97, 412,98, 411,90, 419,82, 413,79, 402,98, 401,111, 392,111, 387,101, 379,105,377,93, 408,64 },
X    { 372,127, 382,147, 378,150, 373,148, 367,159, 359,165, 345,163, 345,147, 361,147, 362,139, 356,135 },
X    { 387,117, 415,117, 413,134, 395,134, 378,139, 372,127 },
X    { 395,134, 413,134, 410,156, 394,141, 392,145, 403,155, 399,160, 399,157, 385,144, 382,147, 378,139 },
X    { 431,65, 456,76, 475,72, 475,160, 461,158, 441,152, 424,155, 410,156, 415,117, 425,97, 433,91 },
X    // Asia
X    { 475,72, 506,68, 555,131, 538,145, 475,125 },
X    { 506,68, 517,51, 539,50, 590,32, 610,39, 611,48, 582,123, 575,129, 555,132 },
X    { 611,48, 642,48, 651,60, 671,53, 688,58, 655,98, 598,79 },
X    { 688,58, 694,60, 712,59, 716,94, 676,100, 660,116, 671,124, 667,138, 657,147, 638,120 },
X    { 475,125, 538,145, 526,156, 529,169, 521,182, 484,160, 475,160 },
X    { 598,79, 655,98, 638,120, 618,129, 597,131, 582,123 },
X    { 575,129, 581,149, 592,152, 612,144, 629,154, 622,163, 628,176, 624,188, 615,198, 600,198, 586,197, 575,183, 556,189, 542,181, 536,175, 535,170, 529,169, 526,156, 555,131 },
X    { 582,123, 597,131, 618,129, 638,120, 657,147, 629,154, 612,144, 592,152, 581,149, 575,129 },
X    { 672,142, 683,146, 675,151, 668,170, 658,172, 648,180, 647,174, 659,166, 670,153 },
X    { 424,155, 441,152, 461,158, 475,160, 484,160, 521,182, 512,195, 485,188, 485,193, 495,200, 486,210, 461,220, 436,178, 443,164, 423,165, 424,155 },
X    { 529,169, 535,170, 536,175, 542,181, 556,189, 557,200, 538,215, 538,226, 533,230, 522,200, 518,202, 512,195, 521,182 },
X    { 575,183, 586,197, 600,198, 593,205, 603,219, 595,230, 582,219, 580,226, 576,227, 576,210, 570,213, 563,198, 557,200, 556,189 },
X    // Australia
X    { 579,232, 599,256, 623,263, 642,265, 642,271, 616,270, 594,262, 571,236 },
X    { 649,251, 665,251, 695,257, 699,268, 697,275, 654,262 },
X    { 658,274, 663,284, 663,330, 647,318, 614,326, 609,299, 639,280 },
X    { 676,273, 698,305, 699,309, 687,334, 667,334, 663,330, 663,284, 670,285 },
X  };
X
X  // Coordinate to place army numbers.
X  private static int armyCoods[][] = {
X    { 28,89 }, { 110,92 }, { 275,45 }, { 109,125 }, { 156,127 }, { 208,130 }, { 116,162 }, { 165,170 }, { 138,202 },
X    { 208,238 }, { 208,282 }, { 246,283 }, { 216,330 },
X    { 370,210 }, { 424,198 }, { 406,258 }, { 440,242 }, { 416,300 }, { 462,295 },
X    { 322,88 }, { 358,125 }, { 390,96 }, { 354,160 }, { 391,130 }, { 402,146 }, { 442,126 },
X    { 500,112 }, { 557,89 }, { 631,77 }, { 685,90 }, { 496,158 }, { 606,116 }, { 571,172 }, { 628,145 }, { 663,170 }, { 460,190 }, { 530,200 }, { 583,215 },
X    { 592,264 }, { 671,266 }, { 638,304 }, { 675,314 }
X  };
X  
X  // Make an array of countries comprising the entire world.
X  public static Country[] makeWorld()
X  {
X    Country[] world = new Country[NUM_COUNTRIES];
X    
X    for (int i = 0; i < NUM_COUNTRIES; i++) {
X      world[i] = new Country(i);
X    }
X
X    return world;
X  }
X
X  public static String getName(int i)
X  {
X    return countryNames[i];
X  }
X  
X  // Instance variables.
X
X  private int num;
X  private Integer id;
X  private String name;
X  private int[] adjacent;
X
X  private Player owner;
X  private int numArmies;
X  
X  public Country(int c)
X  {
X    num = c;
X    id = new Integer(num);
X    name = countryNames[c];
X    adjacent = adjacencies[c];
X
X    for (int i = 0; i < points[c].length; i += 2) {
X      addPoint(points[c][i], points[c][i+1]);
X    }
X    addPoint(points[c][0], points[c][1]); // close the Polygon
X  }
X
X  // AWT methods.
X  
X  public void paint(Graphics g)
X  {
X    if (owner != null) {
X      g.setColor(owner.getColor());
X    }
X    else {
X      g.setColor(Color.pink);
X    }
X    g.fillPolygon(this);
X
X    // Draw outline, to distinguish borders.
X    g.setColor(Color.black);
X    g.drawPolygon(this);
X
X    g.drawString("" + numArmies, armyCoods[num][0]+1, armyCoods[num][1]+1);
X    g.setColor(Color.white);
X    g.drawString("" + numArmies, armyCoods[num][0], armyCoods[num][1]);
X  }
X
X  // Game methods.
X
X  public int getNum()
X  {
X    return num;
X  }
X  
X  public Integer getID()
X  {
X    return id;
X  }
X  
X  public String getName()
X  {
X    return name;
X  }
X
X  public Player getOwner()
X  {
X    return owner;
X  }
X
X  public void setOwner(Player pl)
X  {
X    owner = pl;
X  }
X
X  public int getArmies()
X  {
X    return numArmies;
X  }
X
X  public void setArmies(int i)
X  {
X    numArmies = i;
X  }
X  
X  public void decrementArmies(int i)
X  {
X    numArmies -= i;
X  }
X
X  public void incrementArmies(int i)
X  {
X    numArmies += i;
X  }
X
X  // Returns true if this is adjacent to the target parameter.
X  public boolean isAdjacentTo(Country target)
X  {
X    for (int i = 0; i < adjacencies[num].length; i++) {
X      if (adjacencies[num][i] == target.num) {
X	return true;
X      }
X    }
X    return false;
X  }
X  
X  public int[] attackCountry(Country target)
X  {
X    int myRolls[] = new int[Math.min(numArmies - 1, 3)];
X    int hisRolls[] = new int[Math.min(target.numArmies, 2)];
X    Random rand = new Random();
X    int sortedRolls[] = new int[5];
X
X    // Roll the die.
X    for (int i = 0; i < myRolls.length; i++) {
X      myRolls[i] = ((Math.abs(rand.nextInt())) % 6) + 1;
X    }
X    for (int i = 0; i < hisRolls.length; i++) {
X      hisRolls[i] = ((Math.abs(rand.nextInt())) % 6) + 1;
X    }
X
X    // Sort the rolls.
X    int t;
X    if ((myRolls.length > 1) && (myRolls[1] > myRolls[0])) {
X      t = myRolls[0];
X      myRolls[0] = myRolls[1];
X      myRolls[1] = t;
X    }
X    if ((myRolls.length > 2) && (myRolls[2] > myRolls[1])) {
X      t = myRolls[1];
X      myRolls[1] = myRolls[2];
X      myRolls[2] = t;
X
X      if ((myRolls[1] > myRolls[0])) {
X	t = myRolls[0];
X	myRolls[0] = myRolls[1];
X	myRolls[1] = t;
X      } 
X    }
X    if ((hisRolls.length > 1) && (hisRolls[1] > hisRolls[0])) {
X      t = hisRolls[0];
X      hisRolls[0] = hisRolls[1];
X      hisRolls[1] = t;
X    }
X
X    sortedRolls[0] = myRolls[0];
X    sortedRolls[1] = hisRolls[0];
X    if (myRolls.length > 1) {
X      sortedRolls[2] = myRolls[1];
X    }
X    if (hisRolls.length > 1) {
X      sortedRolls[3] = hisRolls[1];
X    }
X    if (myRolls.length > 2) {
X      sortedRolls[4] = myRolls[2];
X    }
X    
X    // Compute the battle results.
X    for (int i = 0; i < Math.min(myRolls.length, hisRolls.length); i++) {
X      if (myRolls[i] > hisRolls[i]) {
X	target.numArmies--;
X
X	if (target.numArmies == 0) {    // Victory!
X	  Player oldOwner = target.owner;
X	  target.owner.removeCountry(target);
X	  this.owner.addCountry(target);
X	  target.numArmies = 1;
X	  this.numArmies--;
X
X	  if (oldOwner.numCountries() == 0) {
X	    owner.vanquished(oldOwner);
X	  }
X	  
X	  break;
X	}
X      }
X      else {
X	this.numArmies--;
X      }
X    }
X
X    return sortedRolls;
X  }
}
SHAR_EOF
  $shar_touch -am 1210132596 'Country.java' &&
  chmod 0644 'Country.java' ||
  $echo 'restore of' 'Country.java' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'Country.java:' 'MD5 check failed'
f3e116b8db669aeb72083d38e3ce5d12  Country.java
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'Country.java'`"
    test 14555 -eq "$shar_count" ||
    $echo 'Country.java:' 'original size' '14555,' 'current size' "$shar_count!"
  fi
fi
# ============= Player.java ==============
if test -f 'Player.java' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'Player.java' '(file already exists)'
else
  $echo 'x -' extracting 'Player.java' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Player.java' &&
// CS 582 - Fall 1996 - OSU
// Jean-Guy Speton
X
import java.awt.*;
import java.util.*;
X
public class Player
{
X  private Risk risk;
X  
X  private String name;
X  private Color color;
X
X  private Hashtable countries;
X  private Pile pile;
X  private int numArmies;
X
X  // Tracks whether or not the player has captured at least 1 enemy
X  // territory in the current turn.  Should be cleared at the end of
X  // each turn.
X  private boolean cardFlag;
X
X  public Player(Risk risk, String name, Color color)
X  {
X    this.risk = risk;
X    this.name = name;
X    this.color = color;
X    countries = new Hashtable();
X    pile = new Pile();
X    numArmies = 0;
X  }
X
X  // Game methods.
X  
X  public String getName()
X  {
X    return name;
X  }
X  
X  public Color getColor()
X  {
X    return color;
X  }
X
X  public Pile getPile()
X  {
X    return pile;
X  }
X
X  public void addCard(Card c)
X  {
X    pile.addCard(c);
X  }
X
X  public boolean canTradeCards()
X  {
X    Card c[] = new Card[3];
X    int j = 0;
X    
X    c[2] = null;  // marker
X    for (int i = 0; i < pile.size(); i++) {
X      if (pile.cardAt(i).isSelected()) {
X	c[j++] = pile.cardAt(i);
X      }
X    }
X
X    if (c[2] != null) {
X      return Card.isSet(c[0], c[1], c[2]);
X    }
X
X    return false;
X  }
X
X  public void tradeCards(int a)
X  {
X    boolean hasBonus = false;  // only 1 bonus per trade!
X
X    for (int i = 0; i < pile.size(); i++) {
X      if (pile.cardAt(i).isSelected()) {
X
X	// If we own the country on the card, award with bonus 2 armies.
X	Country cn;
X	if (!hasBonus &&
X	    (cn = hasCountry(pile.cardAt(i).getCountry())) != null) {
X	  hasBonus = true;
X	  cn.incrementArmies(2);
X	}
X	
X	pile.removeCardAt(i);
X	i--;  // to offset the end-of-for increment
X      }
X    }
X    incrementArmies(a);    
X  }
X  
X  public void addCountry(Country c)
X  {
X    countries.put(c.getID(), c);
X    c.setOwner(this);
X  }
X
X  public void removeCountry(Country c)
X  {
X    countries.remove(c.getID());
X    c.setOwner(null);
X  }
X
X  public int numCountries()
X  {
X    return countries.size();
X  }
X
X  public Country hasCountry(int i)
X  {
X    Enumeration enum = countries.elements();
X
X    while (enum.hasMoreElements()) {
X      Country c = (Country)enum.nextElement();
X      if (c.getNum() == i) {
X	return c;
X      }
X    }
X    return null;
X  }
X  
X  public int getArmies()
X  {
X    return numArmies;
X  }
X  
X  public void setArmies(int i)
X  {
X    numArmies = i;
X  }
X
X  public void decrementArmies(int i)
X  {
X    numArmies -= i;
X  }
X
X  public void incrementArmies(int i)
X  {
X    numArmies += i;
X  }
X
X  // Calculate start-of-turn bonus armies based on holdings.
X  public void gainBonusArmies()
X  {
X    int bonus = countries.size() / 3;
X
X    if (bonus < 3) {
X      bonus = 3;
X    }
X
X    // Calculate continent bonuses.
X    World world = risk.getWorld();
X
X    for (int i = Country.NORTH_AMERICA; i <= Country.AUSTRALIA; i++) {
X      if (world.ownerOfContinent(i) == this) {
X	bonus += Country.ARMY_BONUS[i];
X      }
X    }
X
X    incrementArmies(bonus);
X  }
X  
X  // Randomly distribute reserve armies.  Usually only called during
X  // game setup.
X  public void distributeArmies()
X  {
X    while (numArmies > 0) {
X      Enumeration e = countries.elements();
X      while (e.hasMoreElements()) {
X	if (numArmies == 0) {
X	  break;
X	}
X	((Country)e.nextElement()).incrementArmies(1);
X	numArmies--;
X      }
X    }
X  }
X
X  public int getTotalCountries()
X  {
X    return countries.size();
X  }
X
X  public int getTotalArmies()
X  {
X    int n = 0;
X    Enumeration enum = countries.elements();
X
X    while (enum.hasMoreElements()) {
X      Country c = (Country)enum.nextElement();
X      n += c.getArmies();
X    }
X    return n;
X  }