public RepairDroidCoordinate CreateCoordinate(int x, int y, char item)
{
RepairDroidCoordinate coordinate = new RepairDroidCoordinate(x, y, item, this);
this.coordinates.Add(coordinate);
return(coordinate);
}
///* public RepairDroidCoordinate FindNeighbor(int direction) */{
// int xNeighbor = this.x;
// int yNeighbor = this.y;
// switch (direction) {
// case RepairDroid.NORTH:
// yNeighbor--;
// break;
// case RepairDroid.SOUTH:
// yNeighbor++;
// break;
// case RepairDroid.WEST:
// xNeighbor--;
// break;
// case RepairDroid.EAST:
// xNeighbor++;
// break;
// default:
// Console.WriteLine("ERROR in FindNeighbor()!");
// break;
// }
// return map.FindCoordinate(xNeighbor, yNeighbor);
// }
public RepairDroidCoordinate FindNeighbor(int direction, bool createForMe)
{
int xNeighbor = this.x;
int yNeighbor = this.y;
switch (direction)
{
case RepairDroid.NORTH:
yNeighbor--;
break;
case RepairDroid.SOUTH:
yNeighbor++;
break;
case RepairDroid.WEST:
xNeighbor--;
break;
case RepairDroid.EAST:
xNeighbor++;
break;
default:
Console.WriteLine("ERROR in FindNeighbor()!");
break;
}
RepairDroidCoordinate neighbor = map.FindCoordinate(xNeighbor, yNeighbor);
if (createForMe)
{
Program.Assert(neighbor == null, "ERROR in RepairDroidCoordinate.FindNeighbor!");
return(map.CreateCoordinate(xNeighbor, yNeighbor, '?'));
}
return(map.FindCoordinate(xNeighbor, yNeighbor));
}
public RepairDroid(string[] instructionsInput)
{
// The computer's available memory should be much larger than the initial program. Memory beyond the initial program starts with
// the value 0 and can be read or written like any other memory. (It is invalid to try to access memory at a negative address, though.)
this.instructions = new string[10000];
for (int index = 0; index < instructions.Length; index++)
{
instructions.SetValue("0", index);
}
for (int index = 0; index < instructionsInput.Length; index++)
{
instructions.SetValue(instructionsInput[index], index);
}
// Initialize our map.
this.map = new RepairDroidMap();
RepairDroidCoordinate currentLocation = this.map.CreateCoordinate(0, 0, 'D');;
this.map.start = currentLocation;
}
public int PickDirection(RepairDroidCoordinate currentCoordinate) //, int currentFailedDirection) { //, int cameFromDirection) {
//if (newDirection == 5) newDirection = 1;
{
int newDirection = RepairDroid.NORTH;
int attemptCount = 1;
while (attemptCount <= 4)
{
// check to see if we have already gone that route. Only do that if all other paths ...
RepairDroidCoordinate newCoordinate = currentCoordinate.FindNeighbor(newDirection, false);
if (newCoordinate == null)
{
return(newDirection);
}
//if (newDirection == cameFromDirection) {
// // do nothing;
//}
//else {
// // do nothing
//}
newDirection = this.RotateDirection(newDirection);
attemptCount++;
}
return(-99);
//Console.WriteLine("HELP! STUCK!");
// throw new Exception() ;
////
//return cameFromDirection;
}
//public char DrawThisTile(char tileId) {
// // 0 is an empty tile.No game object appears in this tile.
// // 1 is a wall tile.Walls are indestructible barriers.
// // 2 is a block tile.Blocks can be broken by the ball.
// // 3 is a horizontal paddle tile. The paddle is indestructible.
// // 4 is a ball tile.The ball moves diagonally and bounces off objects.
// switch (tileId) {
// case '0':
// return ' ';
// case '1':
// return 'W';
// case '2':
// return 'B';
// case '3':
// return 'P';
// case '4':
// return 'O';
// default:
// return '?';
// }
//}
////public void Print() {
// this.CalculateScreenSize()
//}
//public void PrintScreen(Dictionary<string, string> robotCommands) {
// this.CalculateScreenSize(robotCommands);
// Console.WriteLine("\n");
// Dictionary<string, string> robotCommandsFormatted = new Dictionary<string, string>();
// foreach (string key in robotCommands.Keys) {
// string[] coordinates = key.Split(',');
// int x = Convert.ToInt32(coordinates[0]) + (-(this.minimumX));
// int y = Convert.ToInt32(coordinates[1]) + (-(this.minimumY));
// string newKey = x.ToString() + "," + y.ToString();
// robotCommandsFormatted[newKey] = robotCommands[key];
// }
// int realMaximumX = this.maximumX + (-(this.minimumX));
// int realMaximumY = this.maximumY + (-(this.minimumY));
// // Console.WriteLine("SCORE: " + this.CurrentScore);
// char[][] rows = new char[(realMaximumY)][];
// for (int row=0; row<realMaximumY; row++) {
// char[] rowData = new char[realMaximumX];
// rows[row] = rowData;
// }
// foreach (string key in robotCommandsFormatted.Keys) {
// string[] coordinates = key.Split(',');
// int x = Convert.ToInt32(coordinates[0]);
// int y = Convert.ToInt32(coordinates[1]);
// string rawChar = (string)robotCommandsFormatted[key];
// char actualChar = rawChar.ToCharArray()[0];
// rows[y][x] = actualChar; // this.DrawThisTile(actualChar);
// //// Where is the paddle and ball?
// //if (actualChar == '3') {
// // this.currentColPaddle = x;
// //}
// //else if (actualChar == '4') {
// // this.currentColBall = x;
// //}
// }
// foreach (char[] row in rows) {
// string rowString = "";
// foreach (char currentChar in row) {
// rowString += currentChar;
// }
// Console.WriteLine(rowString);
// }
// return;
//}
//private void ConstructCoordinates(int xPos, int yPos, out int xPosNew, out int yPosNew, int direction) {
// switch (direction) {
// case NORTH:
// xPosNew = xPos;
// yPosNew = yPos - 1;
// break;
// case SOUTH:
// xPosNew = xPos;
// yPosNew = yPos + 1;
// break;
// case WEST:
// xPosNew = xPos - 1;
// yPosNew = yPos;
// break;
// case EAST:
// xPosNew = xPos + 1;
// yPosNew = yPos;
// break;
// default:
// xPosNew = xPos;
// yPosNew = yPos;
// Console.WriteLine("ERROR!");
// break;
// }
//}
public Dictionary <string, string> FindTheOxygenSystem()
{
//int xPos = 0;
//int yPos = 0;
//int lastDirection = -1;
this.input = DEFAULT_DIRECTION.ToString();
bool keepGoing = true;
//bool calculatedScreenSize = false;
this.currentlyRunning = true;
RepairDroidMap map = new RepairDroidMap();
RepairDroidCoordinate currentLocation = map.CreateCoordinate(0, 0, 'D');;
map.start = currentLocation;
while (keepGoing)
{
int output = Convert.ToInt32(this.ContinueProgram());
Console.WriteLine("");
Console.WriteLine("Tried moving " + this.directionFriendly[System.Convert.ToInt32(this.input)] + ", got code "
+ this.returnCodeFriendly[output]);
// What is the target of this attempted move?
RepairDroidCoordinate targetLocation = currentLocation.FindNeighbor(Convert.ToInt32(this.input), true);
switch (output)
{
case FOUND_OXYGEN_SYSTEM:
// Mark the spot we are at now with a "." on the map.
currentLocation.item = '.';
// Move our current position.
currentLocation = targetLocation; // currentLocation.FindNeighbor(Convert.ToInt32(this.input), true);
// Mark that position as a "O" for Oxygen.
currentLocation.item = 'O';
// Let's cache this one.
map.end = currentLocation;
// Let's get out of here, yo!
Console.WriteLine("FOUND IT!");
//keepGoing = false;
break;
case FAILURE_WALL:
// Mark the wall we just hit as a wall in our map.
//RepairDroidCoordinate neighbor = currentLocation.FindNeighbor(Convert.ToInt32(this.input), true);
targetLocation.item = '#';
// Move to the next direction we want to try, amoeba-like, until we hit something interesting.
// this.input = map.PickDirection(currentLocation).ToString();
break;
case SUCCESSFUL_MOVE:
// Mark the spot we just moved from as a "." on the map.
currentLocation.item = '.';
// Move our current position.
currentLocation = targetLocation; // currentLocation.FindNeighbor(Convert.ToInt32(this.input), true);
// Mark that position as a "D" for Droid.
currentLocation.item = 'D';
break;
default:
Console.WriteLine("ERROR! We got some super bogus output code.");
Console.WriteLine("Press any key to continue...");
System.Console.ReadKey();
break;
}
// Figure out what direction to go to next.
this.input = map.PickDirection(currentLocation).ToString();
// Are we stuck? Let's teleport to some other spot that we haven't evaluated yet.
if (this.input == "-99")
{
// Mark the spot we are about to move away from as a "." on the map.
currentLocation.item = '.';
currentLocation = map.TeleportToBetterSpot();
if (currentLocation == null)
{
Console.WriteLine("DONE: We navigated everything!");
keepGoing = false;
}
else
{
currentLocation.item = 'D';
this.input = map.PickDirection(currentLocation).ToString();
}
}
// Print out the map so we can follow along.
//map.Print();
// Keep the console window open.
Console.WriteLine("");
//Console.WriteLine("Press any key to continue...");
//System.Console.ReadKey();
}
return(null); // robotCommands;
}