Day 43

Day 42 (object oriented design)/Improve the design - refactored more/Player.java

@@ -0,0 +1,68 @@
+// Here we merged the CoinInventory in with the Player class.
+// The class still represents one coherent concept (a player), has only 3 instance variables, and is easy to understand.
+// This is ok design unless there is a need for reusing CoinInventory elsewhere in the program.
+
+import java.util.*;
+
+public class Player {
+	private String name;
+	private int[] coinCounts; //cp (pennies), sp (dimes), ep (half-dollars), gp (dollar bills), pp (five dollar bills)
+	private ArrayList<Item> otherInventory;
+
+	public Player(String name) {
+		this.name = name;
+		otherInventory = new ArrayList<Item>();
+		coinCounts = new int[5];
+	}
+
+	public void addItem(Item item) {
+		otherInventory.add(item);
+	}
+
+	public void collectMoney(int cp, int sp, int ep, int gp, int pp) {
+		coinCounts[0] += cp;
+		coinCounts[1] += sp;
+		coinCounts[2] += ep;
+		coinCounts[3] += gp;
+		coinCounts[4] += pp;
+	}
+
+	public double getRunningSpeed() {
+		double speed = 5 * (1 - getEncumbrance() / 1000.0); //Speed 5 if unencumbered; speed 0 if 1000 units carried or more.
+		if (speed < 0) {
+			return 0;
+		}
+		else {
+			return speed;
+		}
+	}
+
+	public double getMoneyValue() {
+		return .01 * coinCounts[0] + .1 * coinCounts[1] + .5 * coinCounts[2] + 1 * coinCounts[3] + 5 * coinCounts[4];
+	}
+
+	public int getEncumbrance() {
+		int encumbrance = coinCounts[0] + coinCounts[1] + coinCounts[2] + coinCounts[3] + coinCounts[4];
+		for(Item i : otherInventory) encumbrance += i.getWeight();
+		return encumbrance;
+	}
+
+	//Test method.
+	public static void main(String[] args) {
+		Player p = new Player("Whistlestick");
+		Item sword = new Item("Magic sword +2", 20);
+		Item shield = new Item("Normal shield", 40);
+		p.addItem(sword);
+		p.addItem(shield);
+		if (p.getEncumbrance() != 60) throw new RuntimeException("getEncumbrance() should be 60, not " + p.getEncumbrance());
+		p.collectMoney(10,2,0,40,2);
+		if (p.getEncumbrance() != 60+54) throw new RuntimeException("getEncumbrance() should be 114, not " + p.getEncumbrance());
+		if (p.getMoneyValue() != 50.3) throw new RuntimeException("getMoneyValue() should be 50.3, not " + p.getMoneyValue());
+		p.collectMoney(0,0,0,6,0);
+		if (p.getEncumbrance() != 120) throw new RuntimeException("getEncumbrance() should be 120, not " + p.getEncumbrance());
+		if (p.getRunningSpeed() != 4.4) throw new RuntimeException("getRunningSpeed() should be 4.4, not " + p.getRunningSpeed());
+		System.out.println("All tests passed.");
+	}
+
+
+}

Day 42 (object oriented design)/Improve the design - refactored/CoinInventory.java

@@ -1,3 +1,4 @@
+//We took the code that deals with coinCounts and moved it into this class.  The weight variable is eliminated too.  This is better design.
 
 public class CoinInventory {
 	private int[] coinCounts; //cp (pennies), sp (dimes), ep (half-dollars), gp (dollar bills), pp (five dollar bills)

Day 42 (object oriented design)/Improve the design - refactored/Item.java

@@ -0,0 +1,19 @@
+//This class remained unchanged from the original.
+
+public class Item {
+	private String description;
+	private int weight;
+
+	public Item(String description, int weight) {
+		this.description = description;
+		this.weight = weight;
+	}
+
+	public int getWeight() {
+		return weight;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+}

Day 42 (object oriented design)/Improve the design - refactored/Player.java

@@ -1,11 +1,7 @@
-//The design among these 3 classes needs improvement, and the code has a couple of bugs, too.
-//Improve the design and fix the bugs.
-//The public interface of Player should remain the same as it is now.
 
-//Hints:
+// The encumbrance variable is eliminated - it was duplicate data since we can derive that from the items themselves.
-	//Avoid duplicate data
+// This class no longer needs to understand the internal implementation of CoinInventory (i.e. which elements of the int array represented which coin).
-	//Methods and instance data should have high cohesion
+// The addItem(), collectMoney(), and getMoneyValue() methods are now wrappers for the CoinInventory class.  That's ok in this circumstance.
-	//Coupling should be loose between classes
 
 import java.util.*;
 

Day 43 (design chess application)/chess program design.txt

@@ -0,0 +1,27 @@
+Possible classes:
+	GUI
+		Display the game board
+		Show the selected first half of the move
+		Show the list of moves that are performed so far
+		Show the captured pieces
+		Show highlighting for the most recent move
+	GameBoard
+		Direct storage of piece data in a 2D array (speed of computation)
+		Knowledge of whether or not castling, en passant are available
+		Be able to set up the starting positions
+		Perform the move (remove piece if a capture, promote to queen if get to the end)
+	Piece (subclasses?)
+		Symbol
+		Position (else captured)
+	Player
+		Enacts moves on the GameBoard
+
+Where are the rules going to be programmed in?
+	A piece has to be aware of other stuff going on around it in order to calculate if a move is legal or not.
+
+What is a piece location useful for?
+	Checking for legality of moves
+	Drawing the pieces on the board
+
+Duplicating game states will be easier if we don't have lots of objects attached to the game board.
+	

Day 43 (design chess application)/requirements and spec.txt

@@ -0,0 +1,27 @@
+Chess program 
+=============
+This simple application allows the user to play chess.  Moves can be made by human or computer.
+
+GUI
+===
+The GUI shows a 2D grid of colored chess squares and whichever pieces are in play (it starts with a new game, ready to play).
+
+Text feedback is given for the game state (who's turn it is, and if it is checkmate or stalemate).
+
+The user makes a move by clicking the source and destination square (for castling and en passant move the king or pawn to its natural destination square).
+	Any click (if it is one of your pieces) highlights that square
+	If some square highlighted, then:
+		if second click is legal move, do it and unhighlight
+		otherwise unhighlight with no move
+	else unhighlight without moving
+	
+
+An "AI move" button makes the computer move (choose a random move from those available).
+
+An "Undo" button takes back the most recent move.
+
+A "Reset" button puts the board in its correct configuration for the first turn of the game.
+
+Game rules
+==========
+Standard chess rules apply.  The 3-move-repetition, 50-move rule, and underpromotion are not implemented in this version.