adolphenom
972 lines
46 KiB
Java
972 lines
46 KiB
Java
package mars.tools;
|
|
import mars.*;
|
|
import mars.mips.hardware.*;
|
|
import java.awt.*;
|
|
import java.awt.event.*;
|
|
import javax.swing.*;
|
|
import java.util.*;
|
|
import javax.swing.JOptionPane;
|
|
import mars.util.*;
|
|
|
|
/**
|
|
* Demo of Mars tool capability. Ken Vollmar, 27 Oct 2006 KenVollmar@missouristate.edu
|
|
* This tool displays movements by a series of players in a game of ScavengerHunt.
|
|
* Players will read and write MIPS memory-mapped locations to move and regain energy.
|
|
* See accompanying documentation for memory-mapped addresses, rules of the game, etc.
|
|
*/
|
|
|
|
public class ScavengerHunt implements Observer, MarsTool
|
|
{
|
|
private static final int GRAPHIC_WIDTH = 712;
|
|
private static final int GRAPHIC_HEIGHT = 652;
|
|
|
|
private static final int NUM_PLAYERS = 22; // Number of players in the game, including "baseline" player
|
|
private static final int MAX_X_MOVEMENT = 2; // Max. movement in X direction
|
|
private static final int MAX_Y_MOVEMENT = 2; // Max. movement in X direction
|
|
private static final double MAX_MOVE_DISTANCE = 2.5; // Max. distance (Euclidean measure)
|
|
private static final int ENERGY_AWARD = 20; // Energy awarded for each task completion
|
|
private static final int ENERGY_PER_MOVE = 1; // Energy used in making each move (regardless of distance)
|
|
private static final int SIZE_OF_TASK = 20; // Number of elements in the task
|
|
|
|
private static final int NUM_LOCATIONS = 7; // Number of locations to which ScavengerHunt players travel.
|
|
// The first (n-1) locations are "random" locations, the last is START_AND_END_LOCATION
|
|
|
|
private static final int START_AND_END_LOCATION = 255; // Start and end location of the ScavengerHunt
|
|
private static final int ADMINISTRATOR_ID = 999; // Special ID for administrator
|
|
|
|
|
|
// MIPS addresses of administrative memory space.
|
|
// The administrator MIPS program writes a value to the Authentication field prior to writing a new
|
|
// value to the PlayerID field. The value of the Authentication field is not itself verified until
|
|
// the PlayerID field changes. Each new value of the Authentication field is one of some sequence
|
|
// known to the Tool program (one-time pad system).
|
|
// Each change of data in the PlayerID field is a signal for the Tool to check the value of the Authentication
|
|
// field. If the value of the Authentication field is correct, the value of the PlayerID field is used
|
|
// for memory bounds checking. A new value of the Authentication field is expected at each change of the
|
|
// PlayerID field (one-time pad system).
|
|
private static final int ADDR_AUTHENTICATION = 0xffffe000; // MIPS byte address of Authentication field
|
|
private static final int ADDR_PLAYER_ID = 0xffffe004; // MIPS byte address of PlayerID field
|
|
private static final int ADDR_GAME_ON = 0xffffe008; // MIPS byte address of signal that administration has initialized data
|
|
private static final int ADDR_NUM_TURNS = 0xffffe00c; // MIPS byte address of number of turns remaining in the game
|
|
|
|
|
|
|
|
// MIPS addresses of various data in each player's memory space.
|
|
// Each player's assigned memory is the MEM_PER_PLAYER bytes which begin at
|
|
// location ADDR_BASE + (ID * MEM_PER_PLAYER)
|
|
private static final int ADDR_BASE = 0xffff8000; // MIPS byte address of memory space for first player
|
|
private static final int MEM_PER_PLAYER = 0x400; // MIPS bytes of memory space given to each player
|
|
private static final int OFFSET_WHERE_AM_I_X = 0x0; // MIPS byte offset to this field
|
|
private static final int OFFSET_WHERE_AM_I_Y = 0x4; // MIPS byte offset to this field
|
|
private static final int OFFSET_MOVE_TO_X = 0x8; // MIPS byte offset to this field
|
|
private static final int OFFSET_MOVE_TO_Y = 0xc; // MIPS byte offset to this field
|
|
private static final int OFFSET_MOVE_READY = 0x10; // MIPS byte offset to this field
|
|
private static final int OFFSET_ENERGY = 0x14; // MIPS byte offset to this field
|
|
private static final int OFFSET_NUMBER_LOCATIONS = 0x18; // MIPS byte offset to this field
|
|
private static final int OFFSET_PLAYER_COLOR = 0x1c; // MIPS byte offset to this field
|
|
private static final int OFFSET_SIZE_OF_TASK = 0x20; // MIPS byte offset to this field
|
|
private static final int OFFSET_LOC_ARRAY = 0x24; // MIPS byte offset to this field
|
|
private static final int OFFSET_TASK_COMPLETE = 0x124; // MIPS byte offset to this field
|
|
private static final int OFFSET_TASK_ARRAY = 0x128; // MIPS byte offset to this field
|
|
// Other MIPS memory locations are available to the player's use.
|
|
|
|
private ScavengerHuntDisplay graphicArea;
|
|
private int authenticationValue = 0;
|
|
private boolean GameOn = false; // MIPS programs readiness
|
|
private static int SetWordCounter = 0;
|
|
private static int accessCounter = 0;
|
|
private static int playerID = ADMINISTRATOR_ID; // Range 0...(NUM_PLAYERS-1), plus ADMINISTRATOR_ID
|
|
private boolean KENVDEBUG = false;
|
|
|
|
|
|
// Used to define (X,Y) coordinate of a location to which ScavengerHunt players
|
|
// will travel.
|
|
private class Location
|
|
{
|
|
public int X;
|
|
public int Y;
|
|
}
|
|
|
|
// private inner class to provide the data on each player needed for display
|
|
private class PlayerData
|
|
{
|
|
int whereAmIX = START_AND_END_LOCATION; // Read only. Memory Address: Base
|
|
int whereAmIY = START_AND_END_LOCATION; // Read only. Memory Address: Base + 0x4
|
|
//int moveToX; // Memory Address: Base + 0x8
|
|
//int moveToY; // Memory Address: Base + 0xc
|
|
//int goalX; // Read only. Memory Address: Base + 0x10
|
|
//int goalY; // Read only. Memory Address: Base + 0x14
|
|
int energy = 20; // Read only. Memory Address: Base + 0x18
|
|
int color = 0; // Memory Address: Base + 0x1c
|
|
long finishTime;
|
|
//int locID; // ID of the location to which ScavengerHunt players are headed. Not used by player.
|
|
boolean hasVisitedLoc[] = new boolean[NUM_LOCATIONS]; // boolean: player has visited each location
|
|
boolean finis = false;
|
|
|
|
// Class PlayerData has no constructor
|
|
|
|
public void setWhereAmI(int gX, int gY) { whereAmIX = gX; whereAmIY = gY; }
|
|
//public void setGoal(int gX, int gY) { goalX = gX; goalY = gY; }
|
|
public void setEnergy(int e) { energy = e; }
|
|
public void setColor(int c) { color = c; }
|
|
public int getWhereAmIX() {
|
|
return whereAmIX; }
|
|
public int getWhereAmIY() {
|
|
return whereAmIY; }
|
|
public int getColor() {
|
|
return color; }
|
|
public boolean hasVisited(int i) {
|
|
return hasVisitedLoc[i]; }
|
|
public void setVisited(int i) { hasVisitedLoc[i] = true; }
|
|
public void setFinished() { finis = true; }
|
|
public boolean isFinished() {
|
|
return finis; }
|
|
public long getFinishTime() {
|
|
return finishTime; }
|
|
public long getFinishMin() {
|
|
return (finishTime / 60000); } // Minutes portion of finishTime
|
|
public long getFinishSec() {
|
|
return (finishTime % 60000) / 1000; // Seconds portion of finishTime
|
|
} // Seconds portion of finishTime
|
|
public long getFinishMillisec() {
|
|
return (finishTime % 1000); } // Millisec portion of finishTime
|
|
public void setFinishTime(long t) { finishTime = t; }
|
|
//public int getGoalX() { return goalX; }
|
|
//public int getGoalY() { return goalY; }
|
|
//public int getMoveToX() { return moveToX; }
|
|
//public int getMoveToY() { return moveToY; }
|
|
public int getEnergy() {
|
|
return energy; }
|
|
//public int getLocationID() { return locID; }
|
|
} // end class PlayerData
|
|
|
|
private static PlayerData[] pd = new PlayerData[NUM_PLAYERS];
|
|
private static Location[] loc = new Location[NUM_LOCATIONS];
|
|
private Random randomStream;
|
|
private long startTime;
|
|
|
|
|
|
// private inner class
|
|
private class ScavengerHuntRunnable implements Runnable
|
|
{
|
|
JPanel panel;
|
|
public ScavengerHuntRunnable() // constructor
|
|
{
|
|
// final JFrame frame = new JFrame("ScavengerHunt");
|
|
// Recommended by Pete Sanderson, 2 Nov. 2006, so that the Tool window and
|
|
// MARS window can be on the screen at the same time.
|
|
final JDialog frame = new JDialog(Globals.getGui(),"ScavengerHunt");
|
|
|
|
// System.out.println("ScavengerHuntRunnable.constructor: starting....");
|
|
|
|
panel = new JPanel(new BorderLayout());
|
|
graphicArea = new ScavengerHuntDisplay(GRAPHIC_WIDTH, GRAPHIC_HEIGHT);
|
|
JPanel buttonPanel = new JPanel();
|
|
JButton resetButton = new JButton("Reset");
|
|
resetButton.addActionListener(
|
|
new ActionListener()
|
|
{
|
|
public void actionPerformed(ActionEvent e)
|
|
{
|
|
graphicArea.clear();
|
|
|
|
// TBD ------- TBD
|
|
// Reset actions here
|
|
initializeScavengerData();
|
|
//JOptionPane.showMessageDialog(null, "Reset needs to be implemented!" );
|
|
|
|
}
|
|
|
|
});
|
|
buttonPanel.add(resetButton);
|
|
|
|
|
|
panel.add(graphicArea, BorderLayout.CENTER);
|
|
panel.add(buttonPanel, BorderLayout.SOUTH);
|
|
|
|
|
|
// Snippet by Pete Sanderson, 2 Nov. 2006, to be a window-closing sequence
|
|
frame.addWindowListener(
|
|
new WindowAdapter() {
|
|
public void windowClosing(WindowEvent e) {
|
|
frame.setVisible(false);
|
|
frame.dispose();
|
|
}
|
|
});
|
|
|
|
frame.getContentPane().add(panel);
|
|
frame.setLocationRelativeTo(null);
|
|
frame.pack();
|
|
frame.setVisible(true);
|
|
frame.setTitle(" This is the ScavengerHunt");
|
|
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // TBD --- This should close only the Tool, not the entire MARS
|
|
frame.setPreferredSize(new Dimension(GRAPHIC_WIDTH, GRAPHIC_HEIGHT)); // TBD SIZE
|
|
frame.setVisible(true); // show();
|
|
|
|
} // end ScavengerHuntRunnable() constructor
|
|
|
|
public void run()
|
|
{
|
|
|
|
double tempAngle;
|
|
|
|
// infinite loop: play the Scavenger Hunt game
|
|
do
|
|
{
|
|
|
|
// Pause to slow down the redisplay of the game. This is separate from
|
|
// the execution speed of the MIPS program, so the display may lag behind
|
|
// the state of the MIPS program.
|
|
try
|
|
{
|
|
// System.out.println(" Hello from the ScavengerHuntRunnable runner, sleeping here ...");
|
|
// System.out.print(".");
|
|
Thread.sleep(100); // millisec
|
|
}
|
|
catch (InterruptedException exception)
|
|
{// no action
|
|
}
|
|
|
|
panel.repaint(); // show new ScavengerHunt position
|
|
} while (true);
|
|
|
|
} // end run method of ScavengerHuntRunnable class
|
|
|
|
} // end ScavengerHuntRunnable class
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/** ScavengerHuntDisplay does not have access to the same MIPS Memory class object used by
|
|
* the ScavengerHunt class object. Need read-only access to a similar data structure maintained
|
|
* within ScavengerHunt.
|
|
*
|
|
*/
|
|
private class ScavengerHuntDisplay extends JPanel
|
|
{
|
|
private int width;
|
|
private int height;
|
|
private boolean clearTheDisplay = true;
|
|
|
|
|
|
public ScavengerHuntDisplay(int tw, int th)
|
|
{
|
|
// System.out.println("ScavengerHuntDisplay.constructor: starting....");
|
|
width = tw;
|
|
height = th;
|
|
|
|
}
|
|
|
|
public void redraw()
|
|
{
|
|
repaint();
|
|
}
|
|
|
|
public void clear()
|
|
{
|
|
// clear the graphic display
|
|
clearTheDisplay = true;
|
|
//System.out.println("ScavengerHuntDisplay.clear: called to clear the display");
|
|
repaint();
|
|
}
|
|
|
|
/** paintComponent does not have access to the same MIPS Memory class object used by
|
|
* the ScavengerHunt class object. Need read-only access to a similar data structure maintained
|
|
* within ScavengerHunt.
|
|
*
|
|
*/
|
|
public void paintComponent(Graphics g)
|
|
{
|
|
long tempN;
|
|
int xCoord;
|
|
int yCoord;
|
|
|
|
// System.out.println("ScavengerHuntDisplay.paintComponent: I'm painting! n is " + n);
|
|
|
|
|
|
// Recover Graphics2D
|
|
Graphics2D g2 = (Graphics2D) g;
|
|
|
|
if (! GameOn) // Make sure game is ready before continuing
|
|
{
|
|
g2.setColor(Color.lightGray);
|
|
g2.fillRect(0, 0, width - 1, height - 1); // Clear all previous drawn information
|
|
g2.setColor(Color.black);
|
|
g2.drawString(" ScavengerHunt not yet initialized by MIPS administrator program.",
|
|
100, 200);
|
|
return;
|
|
}
|
|
|
|
// Clear all previous drawn information
|
|
g2.setColor(Color.lightGray);
|
|
g2.fillRect(0, 0, width - 1, height - 1);
|
|
|
|
|
|
// Draw the locations to which the players will be moving
|
|
// All players have the same location data.
|
|
for (int i = 0; i < NUM_LOCATIONS; i++)
|
|
{
|
|
xCoord = loc[i].X; // toolReadPlayerData(0, OFFSET_LOC_ARRAY + (i*8) + 0);
|
|
yCoord = loc[i].Y; // toolReadPlayerData(0, OFFSET_LOC_ARRAY + (i*8) + 4);
|
|
g2.setColor(Color.blue);
|
|
g2.fillRect( xCoord, yCoord, 20, 20); // coord is upper left corner of oval
|
|
g2.setColor(Color.white);
|
|
g2.drawString(" " + i, xCoord + 4, yCoord + 15); // coord is lower left corner of string text box
|
|
|
|
/*
|
|
System.out.println("ScavengerHuntDisplay.paintComponent: drew loc " + i + " at (" +
|
|
xCoord +
|
|
", " +
|
|
yCoord +
|
|
")" );
|
|
*/
|
|
}
|
|
|
|
//System.out.println("ScavengerHuntDisplay.paintComponent: special exit!");
|
|
//System.exit(0);
|
|
|
|
|
|
// Draw scoreboard
|
|
g2.setColor(Color.black);
|
|
g2.drawString("Player", width - 160, 30);
|
|
g2.drawString("Locations", width - 110, 30);
|
|
g2.drawString("Energy", width - 50, 30);
|
|
g2.drawLine( width - 160, 35, width - 10, 35); // line under column headings
|
|
g2.drawLine( width - 120, 35, width - 120, 35 + (NUM_PLAYERS * 15)); // vertical line for location-visited marks
|
|
g2.drawLine( width - 50, 35, width - 50, 35 + (NUM_PLAYERS * 15)); // vertical line for location-visited marks
|
|
for (int i = 0; i < NUM_PLAYERS; i++)
|
|
{
|
|
// Draw player's symbol
|
|
g2.setColor( new Color(pd[i].getColor()) );
|
|
// g2.setColor(Color.red); // TBD hardcoded
|
|
|
|
|
|
xCoord = pd[i].getWhereAmIX();
|
|
yCoord = pd[i].getWhereAmIY();
|
|
|
|
// ystem.out.println("paintComponent loop " + i + ": Loc coord is (" + xCoord + ", " + yCoord);
|
|
|
|
// Draw player symbol and label it with player ID number.
|
|
// Hardcoded size of location graphic and label.
|
|
g2.drawOval( xCoord, yCoord, 20, 20); // coord is upper left corner of oval
|
|
g2.drawString(" " + i, xCoord + 4, yCoord + 15); // coord is lower left corner of string text box
|
|
|
|
// Draw player's info on scoreboard
|
|
g2.setColor(Color.black);
|
|
g2.drawString(" " + i, width - 150, 50 + (i*15)); // Player's ID on scoreboard
|
|
g2.drawString(" " + pd[i].getEnergy(), width - 40, 50 + (i*15)); // Player's energy on scoreboard
|
|
|
|
// Display player's progress or finishing time, whichever is applicable
|
|
if (pd[i].isFinished())
|
|
{
|
|
// Display finishing time
|
|
// This doesn't display leading zeroes to align time components (e.g. 27 millisec ought to print as 027)
|
|
g2.drawString (pd[i].getFinishMin() + ":" + // Minutes
|
|
pd[i].getFinishSec() + ":" + // Seconds
|
|
pd[i].getFinishMillisec() , // Milliseconds
|
|
width - 115, 50 + (i*15));
|
|
// System.out.println("Time is " + pd[i].getFinishTime());
|
|
//g2.drawString (" " + pd[i].getFinishTime(),
|
|
// width - 255, 50 + (i*15));
|
|
}
|
|
else // player either has not finished or is just now finishing
|
|
{
|
|
int visCount = 0;
|
|
for (int j = 0; j < NUM_LOCATIONS; j++)
|
|
{
|
|
if (pd[i].hasVisited(j)) // count number of locations that player has visited
|
|
{
|
|
visCount++;
|
|
}
|
|
}
|
|
if (visCount == NUM_LOCATIONS) // player has visited every location -- finished!
|
|
{
|
|
pd[i].setFinished();
|
|
pd[i].setFinishTime( System.currentTimeMillis() - startTime );
|
|
|
|
}
|
|
else // player has not yet visited every location
|
|
{
|
|
// Display locations that the player has actually visited
|
|
for (int j = 0; j < NUM_LOCATIONS; j++)
|
|
{
|
|
if (pd[i].hasVisited(j)) // Player has visited this location
|
|
{
|
|
g2.fillRect ((width -120)+(j*10), 42 + (i*15), 10, 8);
|
|
}
|
|
}
|
|
}
|
|
} // end player had not previously finished
|
|
|
|
} // end display score/results for each player
|
|
|
|
// System.out.println("paintComponent: Player " + 0 + " is at (" + pd[0].getWhereAmIX() + ", " + pd[0].getWhereAmIY() + ")" );
|
|
|
|
|
|
|
|
|
|
/*
|
|
g2.setColor(Color.blue);
|
|
g2.setFont(new Font(g2.getFont().getName(), g2.getFont().getStyle(), 20) ); // same font and style in larger size
|
|
g2.drawOval( width/2 - 30, // TBD Hardcoded oval size
|
|
height/2 - 30,
|
|
60,
|
|
60);
|
|
g2.drawString(" " + n, width/2, height/2);
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
} // end private inner class ScavengerHuntDisplay
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
// A constructor for ScavengerHunt would be called immediately on MARS startup, perhaps
|
|
// before all MARS classes have been created. Do not include any action in a constructor
|
|
// but rather postpone any action until the action() class,
|
|
// at which time all MARS classes will be ready for use.
|
|
public ScavengerHunt()
|
|
{
|
|
// System.out.println("ScavengerHunt.constructor: starting....");
|
|
}
|
|
|
|
public String getName()
|
|
{
|
|
return "ScavengerHunt";
|
|
}
|
|
|
|
/*
|
|
* This will set up the ScavengerHunt's GUI. Invoked when ScavengerHunt menu item selected.
|
|
*/
|
|
public void action()
|
|
{
|
|
|
|
|
|
|
|
ScavengerHuntRunnable shr = new ScavengerHuntRunnable();
|
|
Thread t1 = new Thread(shr);
|
|
t1.start();
|
|
|
|
|
|
// Register as observer for a particular MIPS data range. Other ranges
|
|
// are not used by this Tool.
|
|
try {
|
|
Globals.memory.addObserver(this, 0xffff8000, 0xfffffff0); // must be on word boundaries
|
|
}
|
|
catch (AddressErrorException e)
|
|
{
|
|
System.out.println("\n\nScavengerHunt.action: Globals.memory.addObserver caused AddressErrorException.\n\n");
|
|
System.exit(0);
|
|
}
|
|
|
|
} // end ScavengerHunt.action()
|
|
|
|
/*
|
|
* This method observes MIPS memory for directives to modify ScavengerHunt activity (that is,
|
|
* MIPS program write to MMIO) and updates instance variables to reflect that directive.
|
|
* This method takes action when it "observes" MIPS memory changes -- but this method
|
|
* must not write to those memory locations in order to prevent an infinite cycle of events.
|
|
* This method observes certain locations and then may (and does) write to OTHER locations.
|
|
*/
|
|
public void update(Observable o, Object arg)
|
|
{
|
|
MemoryAccessNotice notice;
|
|
int address;
|
|
int data;
|
|
boolean isWrite;
|
|
boolean isRead;
|
|
int energyLevel;
|
|
|
|
// Here we are only interested in MemoryAccessNotice. For anything else, just return.
|
|
if ( ! (arg instanceof MemoryAccessNotice))
|
|
return;
|
|
|
|
// Get pertinent information about this MemoryAccessNotice.
|
|
notice = (MemoryAccessNotice) arg;
|
|
address = notice.getAddress();
|
|
data = notice.getValue();
|
|
isWrite = (notice.getAccessType() == AccessNotice.WRITE);
|
|
isRead = ! isWrite;
|
|
|
|
|
|
// If we are only interested in MIPS memory WRITES, then just return on READS.
|
|
// That's a matter of policy: perhaps players should be prohibited from
|
|
// reading each other's memory spaces.
|
|
if ( ! isWrite)
|
|
return;
|
|
|
|
//System.out.println("ScavengerHunt.update: observed write access by player " + playerID + " on Mem[ " +
|
|
// Binary.intToHexString(address) + " ]");
|
|
|
|
// TBD TBD DEBUGGING SPECIAL
|
|
/*
|
|
accessCounter++;
|
|
if (accessCounter > 100000)
|
|
{
|
|
System.out.println("\n\nScavengerHunt.update: hardcoded exit to prevent runaway" );
|
|
System.exit(0);
|
|
}
|
|
*/
|
|
// TBD TBD DEBUGGING SPECIAL
|
|
|
|
|
|
|
|
|
|
// Take the appropriate action, depending on data written and priority of user.
|
|
if (isWrite && playerID == ADMINISTRATOR_ID && address == ADDR_GAME_ON)
|
|
{
|
|
|
|
// ADMINISTRATOR_ID can write to any location, because it's trusted software
|
|
//System.out.println( "ScavengerHunt.update(): Administrator wrote to Mem[ " +
|
|
// Binary.intToHexString(address) + " ] == " + Binary.intToHexString(data) );
|
|
|
|
// No need to authenticate since administrator runs first, then
|
|
// this location has no effect thereafter.
|
|
GameOn = true;
|
|
// System.out.println( "ScavengerHunt.update(): Administrator wrote GAME_ON!" );
|
|
|
|
initializeScavengerData();
|
|
}
|
|
else if (isWrite && address == ADDR_AUTHENTICATION)
|
|
{
|
|
// Anyone is allowed to write to the authentication location -- but if that value is not
|
|
// correct (authentic) then action can be taken.
|
|
// NO ACTION HERE
|
|
}
|
|
else if (isWrite && address == ADDR_NUM_TURNS)
|
|
{
|
|
// Anyone is allowed to write to the "number of turns" location
|
|
// NO ACTION HERE
|
|
}
|
|
else if (isWrite && address == ADDR_PLAYER_ID) // if the data written will change the PlayerID, authenticate the write
|
|
{
|
|
// 2006 Oct 31 dummy validation scheme, suitable for distribution
|
|
// to students for development: Initial authentication value is zero.
|
|
// Each successive authentication value is one greater
|
|
// than the preceding value, modulo 0xffffffff.
|
|
authenticationValue += 1; // "server's" updated version of the authenticationValue
|
|
if (toolGetWord(ADDR_AUTHENTICATION) == authenticationValue) // Compare to "client's" version of the authenticationValue
|
|
{
|
|
playerID = toolGetWord(ADDR_PLAYER_ID); // Use the new player ID
|
|
//System.out.println( "ScavengerHunt.update(): New playerID of " + playerID);
|
|
}
|
|
else
|
|
{
|
|
System.out.println( "ScavengerHunt.update(): Invalid write of player ID! \nPlayer " +
|
|
playerID + " tried to write. Expected: " +
|
|
Binary.intToHexString(authenticationValue) +
|
|
", got: " + Binary.intToHexString(toolGetWord(ADDR_AUTHENTICATION)) + "\n" );
|
|
}
|
|
}
|
|
|
|
else if (isWrite &&
|
|
address == (ADDR_BASE + (playerID * MEM_PER_PLAYER) + OFFSET_MOVE_READY) &&
|
|
data != 0) // Player wrote data to his/her assigned MoveReady location
|
|
{
|
|
/*
|
|
System.out.println(" ******** ScavengerHunt.update: Player " + playerID + " requests move to (" +
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_X) + ", " +
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_Y) + ")" );
|
|
*/
|
|
|
|
energyLevel = toolReadPlayerData(playerID, OFFSET_ENERGY); // find if player has energy
|
|
if (energyLevel <= 0) // No energy. Player not allowed to move
|
|
{
|
|
//JOptionPane.showMessageDialog(null, "Player " + playerID + " can't move -- no energy.\n" +
|
|
// "(This msg. in ScavengerHunt.update()" );
|
|
// System.out.println("Player " + playerID + " can't move -- no energy.");
|
|
return;
|
|
}
|
|
|
|
if (toolReadPlayerData(playerID, OFFSET_MOVE_TO_X) < 0 ||
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_X) > GRAPHIC_WIDTH ||
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_Y) < 0 ||
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_Y) > GRAPHIC_HEIGHT
|
|
) // Out of bounds. Player not allowed to move
|
|
{
|
|
//JOptionPane.showMessageDialog(null, "Player " + playerID + " can't move -- out of bounds.\n" +
|
|
// "(This msg. in ScavengerHunt.update()" );
|
|
System.out.println("Player " + playerID + " can't move -- out of bounds.");
|
|
return;
|
|
}
|
|
|
|
|
|
// Verify movement is allowed (does not exceed maximum movement)
|
|
if (Math.sqrt(
|
|
Math.pow( toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_X) -
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_X), 2.0)
|
|
+
|
|
Math.pow( toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_Y) -
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_Y), 2.0) )
|
|
<= MAX_MOVE_DISTANCE)
|
|
{
|
|
|
|
// Write the new position of the player
|
|
toolWritePlayerData(playerID, OFFSET_WHERE_AM_I_X,
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_X));
|
|
toolWritePlayerData(playerID, OFFSET_WHERE_AM_I_Y,
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_Y));
|
|
pd[playerID].setWhereAmI( toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_X),
|
|
toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_Y) );
|
|
|
|
// Write the new (reduced) energy of the player
|
|
// Policy: Constant ENERGY_PER_MOVE for any move regardless of length.
|
|
toolWritePlayerData(playerID, OFFSET_ENERGY,
|
|
toolReadPlayerData(playerID, OFFSET_ENERGY) - ENERGY_PER_MOVE);
|
|
pd[playerID].setEnergy( toolReadPlayerData(playerID, OFFSET_ENERGY) );
|
|
|
|
|
|
// TBD FUTURE --- need to keep track of locations that the player has actually got to
|
|
// -- be able to tell that the player has reached a certain location
|
|
// -- be able to tell that the player has reached every location
|
|
for (int i = 0; i < NUM_LOCATIONS; i++)
|
|
{
|
|
if (toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_X) == loc[i].X &&
|
|
toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_Y) == loc[i].Y )
|
|
{
|
|
pd[playerID].setVisited(i); // Player has visited this location
|
|
}
|
|
}
|
|
|
|
|
|
// Write 0 to "move ready" location, signifying that the move request was processed
|
|
// Here we must write to the same location that we're now reading from, and we
|
|
// can't cause an infinite loop. Temporarily switch player ID to that of the administrator,
|
|
// and restore ID after the write. With the playerID set to administrator, the event
|
|
// caused by the write will not go through this same logic.
|
|
int tempPlayerID = playerID;
|
|
playerID = ADMINISTRATOR_ID;
|
|
toolWritePlayerData(tempPlayerID, OFFSET_MOVE_READY, 0);
|
|
playerID = tempPlayerID;
|
|
|
|
}
|
|
else
|
|
{
|
|
System.out.println( "Player " + playerID + " can't move -- exceeded max. movement." );
|
|
System.out.println(" Player is at (" +
|
|
toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_X) + ", " +
|
|
toolReadPlayerData(playerID, OFFSET_WHERE_AM_I_Y) + "), wants to go to (" +
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_X) + "," +
|
|
toolReadPlayerData(playerID, OFFSET_MOVE_TO_Y) + ")" );
|
|
|
|
return;
|
|
}
|
|
|
|
} // end if Player wrote nonzero data to his/her assigned MoveReady location
|
|
|
|
|
|
else if (isWrite &&
|
|
address == (ADDR_BASE + (playerID * MEM_PER_PLAYER) + OFFSET_TASK_COMPLETE) &&
|
|
data != 0) // Player wrote data to his/her assigned TaskComplete location
|
|
{
|
|
|
|
// System.out.println(" ******** ScavengerHunt.update: Player " + playerID + " requests more energy (task complete)" );
|
|
|
|
// Player indicates he/she has completed a task. Check to see if task is completed correctly.
|
|
// Task for this assignment: Numbers are sorted in ascending order.
|
|
int prevData, currentData;
|
|
prevData = toolReadPlayerData(playerID, OFFSET_TASK_ARRAY);
|
|
for (int i = 1; i < SIZE_OF_TASK; i++)
|
|
{
|
|
currentData = toolReadPlayerData(playerID, OFFSET_TASK_ARRAY + (i*4));
|
|
if (prevData > currentData)
|
|
{
|
|
// Task failure! Task not completed correctly!
|
|
System.out.println("Whoops! Player has NOT completed task correctly");
|
|
return;
|
|
}
|
|
prevData = currentData; // update for next iteration
|
|
|
|
}
|
|
|
|
// If program flow has reached this point, the task is completed correctly.
|
|
// Award energy, reset TaskComplete, and set new task values for future use.
|
|
toolWritePlayerData(playerID, OFFSET_ENERGY, ENERGY_AWARD);
|
|
toolWritePlayerData(playerID, OFFSET_TASK_COMPLETE, 0);
|
|
for (int j = 0; j < SIZE_OF_TASK; j++) // Initialize the task data for this player
|
|
{
|
|
toolWritePlayerData(playerID, OFFSET_TASK_ARRAY + (j * 4),
|
|
(int)(randomStream.nextDouble() * Integer.MAX_VALUE) ); // Set a random number for the task (sort them)
|
|
}
|
|
// System.out.println("Player has completed task correctly and been awarded energy");
|
|
pd[playerID].setEnergy( ENERGY_AWARD );
|
|
|
|
} // end if Player wrote nonzero data to his/her assigned TaskComplete location
|
|
|
|
|
|
else if (isWrite &&
|
|
address == (ADDR_BASE + (playerID * MEM_PER_PLAYER) + OFFSET_PLAYER_COLOR))
|
|
// Player wrote data to his/her assigned PlayerColor location
|
|
{
|
|
// PPlayer indicates he/she has changed the color of display
|
|
pd[playerID].setColor( toolReadPlayerData(playerID, OFFSET_PLAYER_COLOR) );
|
|
}
|
|
|
|
|
|
// TBD TBD TBD
|
|
// TBD TBD TBD
|
|
// TBD TBD TBD
|
|
// Yet to be implemented: Enforce only one write of MoveRequest per player per turn
|
|
|
|
|
|
else if (isWrite &&
|
|
address >= (ADDR_BASE + (playerID * MEM_PER_PLAYER)) &&
|
|
address < (ADDR_BASE + ((playerID + 1) * MEM_PER_PLAYER)) )
|
|
// Player wrote data elsewhere within his/her assigned location
|
|
{
|
|
// Player can write to any location within his/her assigned location
|
|
//System.out.println( "ScavengerHunt.update(): Player " + playerID + " wrote to valid location");
|
|
}
|
|
else if (isWrite && playerID == ADMINISTRATOR_ID)
|
|
{
|
|
// ADMINISTRATOR_ID can write to any location, because it's trusted software
|
|
//System.out.println( "ScavengerHunt.update(): Administrator wrote to Mem[ " +
|
|
// Binary.intToHexString(address) + " ] == " + Binary.intToHexString(data) );
|
|
}
|
|
else if (isWrite)
|
|
{
|
|
// This player is writing outside his/her assigned memory location
|
|
/*
|
|
System.out.println("ScavengerHunt.update(): Player " + playerID + " writing outside assigned mem. loc. at address " +
|
|
Binary.intToHexString(address) +
|
|
" -- not implemented!");
|
|
*/
|
|
|
|
JOptionPane.showMessageDialog(null,
|
|
"ScavengerHunt.update(): Player " + playerID + " writing outside assigned mem. loc. at address " +
|
|
Binary.intToHexString(address) +
|
|
" -- not implemented!");
|
|
}
|
|
else if (isRead)
|
|
{
|
|
// Policy: anyone can read any location.
|
|
}
|
|
|
|
|
|
|
|
} // end ScavengerHunt.update()
|
|
|
|
|
|
|
|
|
|
// Write one word to MIPS memory. This is a wrapper to isolate the try..catch blocks.
|
|
private void toolSetWord(int address, int data)
|
|
{
|
|
|
|
if (KENVDEBUG)
|
|
{
|
|
System.out.println(" ScavengerHunt.toolSetWord: Setting MIPS Memory[" +
|
|
Binary.intToHexString(address) + "] to " + Binary.intToHexString(data) + " = " + data );
|
|
}
|
|
SetWordCounter++;
|
|
|
|
try {
|
|
Globals.memory.setWord(address, data); // Write
|
|
}
|
|
catch ( AddressErrorException e) {
|
|
System.out.println("ScavengerHunt.toolSetWord: deliberate exit on AEE exception.");
|
|
System.out.println(" SetWordCounter = " + SetWordCounter);
|
|
System.out.println(" address = " + Binary.intToHexString(address) );
|
|
System.out.println(" data = " + data );
|
|
System.exit(0);
|
|
}
|
|
catch ( Exception e) {
|
|
System.out.println("ScavengerHunt.toolSetWord: deliberate exit on " + e.getMessage() + " exception.");
|
|
System.out.println(" SetWordCounter = " + SetWordCounter);
|
|
System.out.println(" address = " + Binary.intToHexString(address) );
|
|
System.out.println(" data = " + data );
|
|
System.exit(0);
|
|
}
|
|
|
|
if (KENVDEBUG)
|
|
{
|
|
// Verify data written correctly
|
|
int verifyData = toolGetWord(address);
|
|
if (verifyData != data)
|
|
{
|
|
System.out.println("\n\nScavengerHunt.toolSetWord: Can't verify data! Special exit.");
|
|
System.out.println(" address = " + Binary.intToHexString(address) );
|
|
System.out.println(" data = " + data);
|
|
System.out.println(" verifyData = " + verifyData);
|
|
System.exit(0);
|
|
}
|
|
else
|
|
System.out.println(" ScavengerHunt.toolSetWord: Mem[" +
|
|
Binary.intToHexString(address) +
|
|
" verified as " + Binary.intToHexString(data));
|
|
}
|
|
|
|
} // end toolSetWord
|
|
|
|
|
|
|
|
|
|
// Read one word from MIPS memory. This is a wrapper to isolate the try..catch blocks.
|
|
private int toolGetWord(int address)
|
|
{
|
|
|
|
int returnValue;
|
|
|
|
//System.out.println("ScavengerHunt.toolGetWord: called with address " +
|
|
// Binary.intToHexString(address) );
|
|
|
|
try {
|
|
/*
|
|
System.out.println("ScavengerHunt.toolGetWord: returning " +
|
|
Binary.intToHexString(Globals.memory.getWord(address)) +
|
|
" which is at MIPS Memory[" + Binary.intToHexString(address) + "]" );
|
|
*/
|
|
returnValue = Globals.memory.getWord(address);
|
|
|
|
/*
|
|
System.out.println("ScavengerHunt.toolGetWord: Mem[" +
|
|
Binary.intToHexString(address) + "] = " +
|
|
Binary.intToHexString(returnValue) + " --- returning normally");
|
|
*/
|
|
|
|
return returnValue;
|
|
}
|
|
catch ( AddressErrorException e) {
|
|
System.out.println("ScavengerHunt.toolGetWord: deliberate exit on AEE exception.");
|
|
System.out.println(" SetWordCounter = " + SetWordCounter);
|
|
System.out.println(" address = " + Binary.intToHexString(address) );
|
|
System.exit(0);
|
|
}
|
|
catch ( Exception e) {
|
|
System.out.println("ScavengerHunt.toolGetWord: deliberate exit on " + e.getMessage() + " exception.");
|
|
System.out.println(" SetWordCounter = " + SetWordCounter);
|
|
System.out.println(" address = " + Binary.intToHexString(address) );
|
|
System.exit(0);
|
|
}
|
|
|
|
return 0; // Must have return statement
|
|
} // end toolGetWord
|
|
|
|
|
|
|
|
|
|
// Read player's data field.
|
|
private int toolReadPlayerData(int p, int offset)
|
|
{
|
|
|
|
if (KENVDEBUG)
|
|
{
|
|
System.out.println("ScavengerHunt.toolReadPlayerData: called with player " + p +
|
|
", offset = " +
|
|
Binary.intToHexString(offset) + " ---> address " +
|
|
Binary.intToHexString(ADDR_BASE + (p * MEM_PER_PLAYER) + offset)
|
|
);
|
|
}
|
|
|
|
int returnValue = toolGetWord( ADDR_BASE + (p * MEM_PER_PLAYER) + offset);
|
|
|
|
if (KENVDEBUG)
|
|
{
|
|
//if ((ADDR_BASE + (p * MEM_PER_PLAYER) + offset) >= 0xffff8000 &&
|
|
// (ADDR_BASE + (p * MEM_PER_PLAYER) + offset) < 0xffff8800) // Show debug for player 0 and 1 only
|
|
//{
|
|
//System.out.println(" ScavengerHunt.toolReadPlayerData: Reading MIPS Memory[" +
|
|
// Binary.intToHexString(ADDR_BASE + (p * MEM_PER_PLAYER) + offset) +
|
|
// "] which is " + Binary.intToHexString(returnValue) +
|
|
// " = " + Binary.intToHexString( returnValue) );
|
|
//}
|
|
|
|
System.out.println("ScavengerHunt.toolReadPlayerData: Mem[" +
|
|
Binary.intToHexString(ADDR_BASE + (p * MEM_PER_PLAYER) + offset) + "] = " +
|
|
Binary.intToHexString(returnValue) + " --- returning normally");
|
|
}
|
|
|
|
return returnValue;
|
|
} // end toolReadPlayerData
|
|
|
|
// Write player's data field.
|
|
private void toolWritePlayerData(int p, int offset, int data)
|
|
{
|
|
|
|
int address = ADDR_BASE + (p * MEM_PER_PLAYER) + offset;
|
|
|
|
if (KENVDEBUG)
|
|
{
|
|
System.out.println("ScavengerHunt.toolWritePlayerData: called with player " + p +
|
|
", offset = " + Binary.intToHexString(offset) +
|
|
", data = " + Binary.intToHexString(data) );
|
|
}
|
|
|
|
toolSetWord( address, data);
|
|
|
|
if (KENVDEBUG)
|
|
{
|
|
int verifyData = toolGetWord(address);
|
|
if (data != verifyData)
|
|
{
|
|
System.out.println("\n\nScavengerHunt.toolWritePlayerData: MAYDAY data not verified !");
|
|
System.out.println(" requested data to be written was " + Binary.intToHexString(data));
|
|
System.out.println(" actual data at that loc is " + Binary.intToHexString(toolGetWord(address)));
|
|
System.exit(0);
|
|
}
|
|
else
|
|
System.out.println(" ScavengerHunt.toolWritePlayerData: Mem[" +
|
|
Binary.intToHexString(address) +
|
|
" verified as " + Binary.intToHexString(data));
|
|
}
|
|
|
|
} // end toolWritePlayerData
|
|
|
|
|
|
private void initializeScavengerData()
|
|
{
|
|
//GameOn = false; // MIPS programs readiness
|
|
authenticationValue = 0;
|
|
playerID = ADMINISTRATOR_ID;
|
|
startTime = System.currentTimeMillis(); // Clock time for program run
|
|
|
|
// This is a dubious use of the tool (this Java program) to initialize data values for the game.
|
|
// The administrator portion of the MIPS program should initialize all data for each
|
|
// player -- but it's easier to work with random numbers in the Java program
|
|
// Initialize the locations and task data for each player
|
|
randomStream = new Random(42); // TBD Use a seed for development. Remove seed for randomizing.
|
|
|
|
for (int j = 0; j < NUM_LOCATIONS - 1; j++) // The first (n-1) locations are "random"
|
|
{ // Two coordinates (x and y) for each location
|
|
loc[j] = new Location(); // Initialize each location element
|
|
loc[j].X = (int)(randomStream.nextDouble() * GRAPHIC_WIDTH); // X coord.
|
|
loc[j].Y = (int)(randomStream.nextDouble() * (GRAPHIC_HEIGHT - 50)); // Y coord. (leave room for buttons in window)
|
|
|
|
/*
|
|
System.out.println("ScavengerHunt.update(): set up a location at (" +
|
|
loc[j].X +
|
|
", " +
|
|
loc[j].Y +
|
|
")" );
|
|
*/
|
|
|
|
}
|
|
loc[NUM_LOCATIONS - 1] = new Location(); // The last location is a return to the starting position
|
|
loc[NUM_LOCATIONS - 1].X = START_AND_END_LOCATION;
|
|
loc[NUM_LOCATIONS - 1].Y = START_AND_END_LOCATION;
|
|
|
|
for (int i = 0; i < NUM_PLAYERS; i++) // Initialize data for each player
|
|
{
|
|
|
|
//System.out.println("ScavengerHunt.update(): Player loop " + i);
|
|
|
|
pd[i] = new PlayerData(); // Initialize each player data structure.
|
|
|
|
for (int j = 0; j < NUM_LOCATIONS; j++) // Initialize the locations this player goes to
|
|
{
|
|
toolWritePlayerData(i, OFFSET_LOC_ARRAY + (j * 8) + 0, loc[j].X); // Set the same locations for each player
|
|
toolWritePlayerData(i, OFFSET_LOC_ARRAY + (j * 8) + 4, loc[j].Y); // Set the same locations for each player
|
|
}
|
|
|
|
for (int j = 0; j < SIZE_OF_TASK; j++) // Initialize the task data for this player
|
|
{
|
|
toolWritePlayerData(i, OFFSET_TASK_ARRAY + (j * 4),
|
|
(int)(randomStream.nextDouble() * Integer.MAX_VALUE) ); // Set a random number for the task (sort them)
|
|
}
|
|
}
|
|
|
|
} // end initializeScavengerData
|
|
|
|
} // end ScavengerHunt
|
|
|