January 2018 – Aidan Takami Game Development

Game Sample: 9

Hey! Below is the source code to a simple game I created a few years back as a final project for my AP CS class. It’s written in java and was inspired by the game “A Dark Room”, created by Amir Rajan & released in 2013.

Below is some gameplay!

Screen Shot 2018-01-26 at 4.19.48 PM Screen Shot 2018-01-26 at 4.23.17 PM Screen Shot 2018-01-26 at 4.24.31 PM

Very simple but an interesting play! Here is the code:

import java.util.Scanner;
import java.awt.event.*;
public class GameMain
{
 /**
  * Main runs intro sequence and then calls <code> explore </code> method
  */
    public static void main(String []args)
   {
       System.out.println("WELCOME to 9");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println("Instructions: use w,d,s,a and 'Enter' to guide yourself through missions.");
       System.out.println("(Make sure your window fits the entire map) ");
       System.out.println(" ");
       System.out.println("Object guide:");
       System.out.println("1: you");
       System.out.println("2: home");
       System.out.println("3: northern base");
       System.out.println("4: southern wall");
       System.out.println("5: hospital");
       System.out.println("6: market");
       System.out.println("7: motel");
       System.out.println("8: object");
       System.out.println("9: family");
       System.out.println("(type any of these numbers at any time in the game for a quick reminder)");
       System.out.println(" ");
       System.out.println("When you are ready to begin, type 'start'");
       Scanner start = new Scanner(System.in);
       String begin = start.next();
       if(begin.indexOf("start") >= 0)
       {
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
       System.out.println(" ");
           try {
      Thread.sleep(7000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
       System.out.println("It's dark here...");
              System.out.println(" ");
       try {
      Thread.sleep(7000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
      System.out.println("It wasn't always like this.");
      try {
      Thread.sleep(7000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.print("My home...");
           try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("My family...");
     try {
      Thread.sleep(7000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     explore();
    }
}
    public static void explore()
   {
    int[][] myArray = {
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  },
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} };  

    int[][] myMapKey = {
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2},
    {2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2},
    {2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,9,2,2,2,2,2,2,2},
    {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2} };
    for(int print1 = 0; print1 < 26; print1++ )
    {
        for(int print2 = 0; print2 < 40; print2++)
        {
            System.out.print(myArray[print1][print2]);
            System.out.print(" ");
        }
        System.out.println(" ");
    }
   System.out.println("energy = 20");
   boolean first = true;
   boolean exploring = true;
   int currentRep = 0;
   int currentCount = 0;
   int energy = 19;
   int progress = 0;
   int clue = 0;
   int food = 5;
   int finish = 0;
    while(first == true)
    {
    int xx = 23;
    int yy = 9;
    myArray = move(xx,yy, myArray);
    mapPrint(myArray, energy, progress);
    energy --;
    first = false;
   }

   while(exploring == true)
   {
       for(int rep = 0; rep < 26; rep ++)
       {
           for(int count = 0; count < 40; count++)            {                if(myArray[rep][count] == 1)                {                    currentRep = rep;                    currentCount = count;                 }             }         }        if(energy > -1 && progress <= 5)       {         myArray = move(currentRep,currentCount, myArray);        mapPrint(myArray, energy, progress);        myArray = significance(currentCount, currentRep, myArray, progress);        energy = energizer(energy, currentCount,currentRep, progress);        progress = progress(progress,currentCount, currentRep);        energy --;               }       if(energy > -1 && progress >= 6 && clue < 20)       {           myArray = advancedMove(currentRep, currentCount, myArray, myMapKey);           mapPrint2(myArray, energy, food);           clue = clue(currentCount, currentRep, myMapKey, clue);           energy = home(energy,currentCount, currentRep);           food = foodSupply(currentCount, currentRep, food);           energy --;         }       if(clue == 20 && finish == 0)       {           myArray = finalMove(currentRep, currentCount, myArray, myMapKey);           mapPrint2(myArray, energy, food);           energy = home(energy,currentCount, currentRep);           food = foodSupply(currentCount, currentRep, food);           finish = family(currentCount, currentRep, finish);           energy --;         }       if(finish == 1)       {           gameFinish();           exploring = false;         }       if(energy == -1)       {           gameOver();           exploring = false;         }       if(food == 0)       {           starve();           exploring = false;         }     } } public static int[][] move(int x, int y, int[][] myNewArray)  {      Scanner input2 = new Scanner(System.in);      String direction = input2.next();      boolean moving = true;      boolean answered = false;      while(moving == true)      {          if(direction.indexOf("w") >= 0 && myNewArray[x-1][y] != 4)
         {
         myNewArray[x][y] = 0;
         myNewArray[x-1][y] = 1;
         answered = true;
         moving = false;
        }
        if(direction.indexOf("d") >= 0 && myNewArray[x][y+1] != 4)
        {
            myNewArray[x][y] = 0;
            myNewArray[x][y+1] = 1;
            answered = true;
            moving = false;
        }
        if(direction.indexOf("s") >= 0 && myNewArray[x+1][y] != 4)
        {
            myNewArray[x][y] = 0;
            myNewArray[x+1][y] = 1;
            answered = true;
            moving = false;
        }
        if(direction.indexOf("a") >= 0 && myNewArray[x][y-1] != 4)
        {
            myNewArray[x][y] = 0;
            myNewArray[x][y-1] = 1;
            answered = true;
            moving = false;
        }
        if(direction.indexOf("1") >= 0)
        {
            System.out.println(" This is you.");
            direction = input2.next();
        }
        if(direction.indexOf("2") >= 0)
        {
            System.out.println(" This is your old home.");
            direction = input2.next();
        }
        if(direction.indexOf("3") >= 0)
        {
            System.out.println(" This is the base to the north.");
            direction = input2.next();
        }
        if(direction.indexOf("4") >= 0)
        {
            System.out.println(" This is a large wall which surrounded the southern base.");
            direction = input2.next();
        }
        if(direction.indexOf("5") >= 0)
        {
            System.out.println(" This is an old hospital. They must have some medical supplies.");
            direction = input2.next();
        }
        if(direction.indexOf("6") >= 0)
        {
            System.out.println(" This is the old market. I'll visit here when my food supply is low.");
            direction = input2.next();
        }
        if(direction.indexOf("7") >= 0)
        {
            System.out.println(" This is an old motel, and my current refuge. Here i can replenish my energy.");
            direction = input2.next();
        }
        if(direction.indexOf("8") >= 0)
        {
            System.out.println(" This is an object. It could possibly help me find them..");
            direction = input2.next();
        }
        if(direction.indexOf("9") >= 0)
        {
            System.out.println(" My Family..");
            direction = input2.next();
        }
        /*if(answered = false)
        *{
        *   System.out.println("Invalid");
        *   direction = input.next();
        *}
        */
    }
     return myNewArray;
    }
public static int[][] mapPrint(int[][]myArray, int energy, int progress)
{
    for(int print1 = 0; print1 < 26; print1++ )
    {
        for(int print2 = 0; print2 < 40; print2++)         {             System.out.print(myArray[print1][print2]);             System.out.print(" ");         }         System.out.println(" ");     }     if(progress >= 1)
    {
        myArray[10][5] = 2;
    }
    if(progress >= 2)
    {
        myArray[4][14] = 3;
    }
    if(progress >= 3)
    {
        myArray[22][20] = 4;
        myArray[22][21] = 4;
        myArray[23][20] = 4;
        myArray[24][20] = 4;
        myArray[25][20] = 4;
        myArray[22][22] = 4;
        myArray[22][23] = 4;
        myArray[22][24] = 4;
        myArray[22][25] = 4;
        myArray[22][26] = 4;
        myArray[22][27] = 4;
        myArray[22][28] = 4;
        myArray[22][29] = 4;
        myArray[22][30] = 4;
        myArray[22][31] = 4;
        myArray[22][31] = 4;
        myArray[22][32] = 4;
        myArray[22][33] = 4;
        myArray[22][34] = 4;
        myArray[22][35] = 4;
        myArray[22][36] = 4;
        myArray[22][37] = 4;
        myArray[22][38] = 4;
        myArray[22][39] = 4;
    }
    if(progress >= 4)
    {
        myArray[14][15] = 5;
    }
    if(progress >= 5)
    {
        myArray[9][34] = 6;
    }
    if(progress >=6)
    {
        myArray[17][10] = 7;
    }
    if(energy >= 4)
    {
        System.out.println("energy = " + energy);
    }
    if(energy < 4)
    {
        System.out.println("ENERGY = " + energy);
    }
    return myArray;
}
public static int[][] significance(int xSpot, int ySpot, int[][] nextLocation, int progress)
{
    if(xSpot == 5 && ySpot == 10 &&  progress == 0)
    {
        System.out.println("I can't believe what this world has come to...");
                   try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
        System.out.println(" ");
        System.out.println("an engraving on the wall reads:");
        System.out.println("'To the north we are safe.'");
                   try {
      Thread.sleep(7000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("I must go to the north base");
                     try {
      Thread.sleep(3000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     nextLocation[4][15] = 3;
     System.out.println("Energy replenished");
     System.out.println("(Exit to the North)");
     progress++;
     return nextLocation;
    }
    if(xSpot == 14 && ySpot == 4 && progress == 1)
    {
     System.out.println("More wreckage..");
                           try {
      Thread.sleep(6000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("The North is nothing now.");
     System.out.println(" ");
                        try {
      Thread.sleep(3000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("It makes me wonder of the south...");
                        try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     nextLocation[22][20] = 4;
     System.out.println("Energy upgraded");
     System.out.println("(Exit to the South)");
     progress++;
     return nextLocation;
    }
    if(xSpot == 18 && ySpot == 21 && progress == 2 || xSpot == 19 && ySpot == 22 && progress == 2 || xSpot == 18 && ySpot == 22 && progress == 2)
    {
     System.out.println("It's hard to believe how much has changed..");
                                   try {
      Thread.sleep(6000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("A huge wall seperates me from the far south now..");
                                try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("There used to be a hospital around here.. Maybe they're safe...");
                                try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     nextLocation[14][14] = 5;
     System.out.println("Energy replenished");
     System.out.println("(Exit to the North)");
     progress++;
     return nextLocation;

    }
    if(xSpot == 15 && ySpot == 14 && progress == 3)
    {
        System.out.println("How can I be the only one?");
         try {
      Thread.sleep(6000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("The only..");
      try {
      Thread.sleep(1500);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("Survivor.?");
      try {
      Thread.sleep(5000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("To survive I must find food..");
      try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     nextLocation[9][34] = 6;
     System.out.println("Energy upgraded");
     System.out.println("(Exit to the North)");
     progress++;
     return nextLocation;
    }
    if(xSpot == 33 && ySpot == 9 && progress == 4)
    {
     System.out.println("The world has been brought to nothing..");
     try {
      Thread.sleep(6000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("I can only carry enough food for 5 days..");
     System.out.println("A place to take refuge is necesary.");
      try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     nextLocation[17][10] = 7;
     System.out.println("Energy upgraded");
     System.out.println("(Exit to the South)");
     progress++;
     return nextLocation;
    }
    if(xSpot == 11 && ySpot == 17 && progress == 5)
    {
        System.out.println("This motel will suffice.");
        System.out.println(" ");
         try {
      Thread.sleep(6000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("I am starting to feel the effects of the radiation..");
      try {
      Thread.sleep(3000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("I can only imagine how they feel...");
      try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("My search truly begins here.");
      try {
      Thread.sleep(2000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("This will be my home for now. Here I will rest after each day.");
     System.out.println("But only for now..");
     System.out.println(" ");
      try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("(Find clues (8) in order to find your family");
     System.out.println("All clues are different. Some can only be seen from an angle..");
     System.out.println("Some aren't clues at all.");
     System.out.println("The '8' only represents an area in which a possible clue is near.");
     System.out.println("Therefore, be sure to search the immediate surrounding area as well.");
       try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println(" ");
     System.out.println("As winds speed up, the dust of everything that once was has limited your vision.");
     System.out.println("The '2' now represents explored territory as well as range of vision.)");
       try {
      Thread.sleep(4000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("(Exit to the North)");
     progress++;
     return nextLocation;
    }
    else
    {
     return nextLocation;
    }
}

public static int energizer(int energy,int xSpot, int ySpot, int progress)
{
  if(xSpot == 5 && ySpot == 10)
  {
      return 20;
    }
  if(xSpot == 14 && ySpot == 4 && progress == 1)
  {
      return 25;
    }
  if(xSpot == 19 && ySpot == 22 && progress == 2 || xSpot == 18 && ySpot == 21 && progress == 2 || xSpot == 18 && ySpot == 22 && progress == 2)
  {
      return 25;
    }
  if(xSpot == 15 && ySpot == 14 && progress == 3)
  {
      return 30;
    }
  if(xSpot == 33 && ySpot == 9 && progress == 4)
  {
      return 35;
    }
  if(xSpot == 11 && ySpot == 17 && progress == 5)
  {
      return 40;
    }
    else
    {
        return energy;
    }
}
public static int progress(int progress, int xSpot, int ySpot)
{
    if(xSpot == 5 && ySpot == 10)
    {
        progress++;
    }
    if(xSpot == 14 && ySpot == 4 && progress == 1)
    {
        progress++;
    }
    if(xSpot == 19 && ySpot == 22 && progress == 2 || xSpot == 18 && ySpot == 21 && progress == 2 || xSpot == 18 && ySpot == 22 && progress == 2)
    {
        progress++;
    }
    if(xSpot == 15 && ySpot == 14 && progress == 3)
    {
        progress++;
    }
    if(xSpot == 33 && ySpot == 9 && progress == 4)
    {
        progress++;
    }
    if(xSpot == 11 && ySpot == 17 && progress == 5)
    {
        progress++;
    }
    return progress;
}
public static int[][] mapPrint2(int[][]myArray, int energy, int food)
{
    for(int print1 = 0; print1 < 26; print1++ )
    {
        for(int print2 = 0; print2 < 40; print2++)         {             System.out.print(myArray[print1][print2]);             System.out.print(" ");         }         System.out.println(" ");     }     myArray[10][5] = 2;     myArray[4][14] = 3;     myArray[22][20] = 4;     myArray[22][21] = 4;     myArray[23][20] = 4;     myArray[24][20] = 4;     myArray[25][20] = 4;     myArray[22][22] = 4;     myArray[22][23] = 4;     myArray[22][24] = 4;     myArray[22][25] = 4;     myArray[22][26] = 4;     myArray[22][27] = 4;     myArray[22][28] = 4;     myArray[22][29] = 4;     myArray[22][30] = 4;     myArray[22][31] = 4;     myArray[22][31] = 4;     myArray[22][32] = 4;     myArray[22][33] = 4;     myArray[22][34] = 4;     myArray[22][35] = 4;     myArray[22][36] = 4;     myArray[22][37] = 4;     myArray[22][38] = 4;     myArray[22][39] = 4;     myArray[14][15] = 5;     myArray[9][34] = 6;     myArray[17][10] = 7;       if(energy >= 4)
    {
        System.out.println("energy = " + energy);
    }
    if(energy < 4)     {         System.out.println("ENERGY = " + energy);     }     if(food > 2)
    {
        System.out.println("food supply = " + food + " days");
    }
     if(food <= 2)     {         System.out.println("food supply = " + food + " days");         System.out.println("food supply dangerously low!");     }     return myArray; } public static int[][] advancedMove(int x, int y, int[][] myNewArray, int[][] keyMap) {     Scanner input = new Scanner(System.in);      String direction = input.next();      boolean moving = true;      boolean answered = false;      while(moving == true)      {          if(direction.indexOf("w") >= 0 && myNewArray[x-1][y] != 4)
         {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x-1][y] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x][y+1] == 0)
        {
         myNewArray[x][y+1] = keyMap[x][y+1];
        }
        if(myNewArray[x][y-1] == 0)
        {
         myNewArray[x][y-1] = keyMap[x][y-1];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
        if(myNewArray[x+1][y] == 0)
        {
            myNewArray[x+1][y] = keyMap[x+1][y];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("d") >= 0 && myNewArray[x][y+1] != 4)
        {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x][y+1] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x-1][y] == 0)
        {
         myNewArray[x-1][y] = keyMap[x-1][y];
        }
        if(myNewArray[x][y-1] == 0)
        {
         myNewArray[x][y-1] = keyMap[x][y-1];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
        if(myNewArray[x+1][y] == 0)
        {
            myNewArray[x+1][y] = keyMap[x+1][y];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("s") >= 0 && myNewArray[x+1][y] != 4)
        {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x+1][y] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x][y+1] == 0)
        {
         myNewArray[x][y+1] = keyMap[x][y+1];
        }
        if(myNewArray[x][y-1] == 0)
        {
         myNewArray[x][y-1] = keyMap[x][y-1];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("a") >= 0 && myNewArray[x][y-1] != 4)
        {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x][y-1] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x-1][y] == 0)
        {
         myNewArray[x-1][y] = keyMap[x][y+1];
        }
        if(myNewArray[x-1][y] == 0)
        {
         myNewArray[x-1][y] = keyMap[x-1][y];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
        if(myNewArray[x+1][y] == 0)
        {
            myNewArray[x+1][y] = keyMap[x+1][y];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("1") >= 0)
        {
            System.out.println(" This is you.");
            direction = input.next();
        }
        if(direction.indexOf("2") >= 0)
        {
            System.out.println(" This is your old home. This also will represent your vision/ explored territory.");
            direction = input.next();
        }
        if(direction.indexOf("3") >= 0)
        {
            System.out.println(" This is the base to the north.");
            direction = input.next();
        }
        if(direction.indexOf("4") >= 0)
        {
            System.out.println(" This is a large wall which surrounded the southern base.");
            direction = input.next();
        }
        if(direction.indexOf("5") >= 0)
        {
            System.out.println(" This is an old hospital. They must have some medical supplies.");
            direction = input.next();
        }
        if(direction.indexOf("6") >= 0)
        {
            System.out.println(" This is the old market. I'll visit here when my food supply is low.");
            direction = input.next();
        }
        if(direction.indexOf("7") >= 0)
        {
            System.out.println(" This is an old motel, and my current refuge. Here i can replenish my energy.");
            direction = input.next();
        }
        if(direction.indexOf("8") >= 0)
        {
            System.out.println(" This is a clue, necesary for finding them.");
            direction = input.next();
        }
        if(direction.indexOf("9") >= 0)
        {
            System.out.println(" My Family..");
            direction = input.next();
        }

    }
     return myNewArray;
}
public static int[][] finalMove(int x, int y, int[][] myNewArray, int[][] keyMap)
{
    Scanner input = new Scanner(System.in);
     String direction = input.next();
     boolean moving = true;
     boolean answered = false;
     while(moving == true)
     {
         if(direction.indexOf("w") >= 0)
         {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x-1][y] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x][y+1] == 0)
        {
         myNewArray[x][y+1] = keyMap[x][y+1];
        }
        if(myNewArray[x][y-1] == 0)
        {
         myNewArray[x][y-1] = keyMap[x][y-1];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
        if(myNewArray[x+1][y] == 0)
        {
            myNewArray[x+1][y] = keyMap[x+1][y];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("d") >= 0)
        {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x][y+1] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x-1][y] == 0)
        {
         myNewArray[x-1][y] = keyMap[x-1][y];
        }
        if(myNewArray[x][y-1] == 0)
        {
         myNewArray[x][y-1] = keyMap[x][y-1];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
        if(myNewArray[x+1][y] == 0)
        {
            myNewArray[x+1][y] = keyMap[x+1][y];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("s") >= 0)
        {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x+1][y] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x][y+1] == 0)
        {
         myNewArray[x][y+1] = keyMap[x][y+1];
        }
        if(myNewArray[x][y-1] == 0)
        {
         myNewArray[x][y-1] = keyMap[x][y-1];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("a") >= 0)
        {
         myNewArray[x][y] = keyMap[x][y];
         myNewArray[x][y-1] = 1;
         if(myNewArray[x-2][y] == 0)
         {
         myNewArray[x-2][y] = keyMap[x-2][y];
        }
        if(myNewArray[x-3][y] == 0)
        {
          myNewArray[x-3][y] = keyMap[x-3][y];
        }
        if(myNewArray[x-1][y-1] == 0)
        {
         myNewArray[x-1][y-1] = keyMap[x-1][y-1];
        }
        if(myNewArray[x+1][y+1] == 0)
        {
         myNewArray[x+1][y+1] = keyMap[x+1][y+1];
        }
        if(myNewArray[x-1][y+1] == 0)
        {
         myNewArray[x-1][y+1] = keyMap[x-1][y+1];
        }
         if(myNewArray[x+1][y-1] == 0)
        {
         myNewArray[x+1][y-1] = keyMap[x+1][y-1];
        }
        if(myNewArray[x-1][y] == 0)
        {
         myNewArray[x-1][y] = keyMap[x][y+1];
        }
        if(myNewArray[x-1][y] == 0)
        {
         myNewArray[x-1][y] = keyMap[x-1][y];
        }
        if(myNewArray[x][y+2] == 0)
        {
         myNewArray[x][y+2] = keyMap[x][y+2];
        }
        if(myNewArray[x][y-2] == 0)
        {
         myNewArray[x][y-2] = keyMap[x][y-2];
        }
        if(myNewArray[x+1][y] == 0)
        {
            myNewArray[x+1][y] = keyMap[x+1][y];
        }
         answered = true;
         moving = false;
        }
        if(direction.indexOf("1") >= 0)
        {
            System.out.println(" This is you.");
            direction = input.next();
        }
        if(direction.indexOf("2") >= 0)
        {
            System.out.println(" This is your old home. This also will represent your vision/ explored territory.");
            direction = input.next();
        }
        if(direction.indexOf("3") >= 0)
        {
            System.out.println(" This is the base to the north.");
            direction = input.next();
        }
        if(direction.indexOf("4") >= 0)
        {
            System.out.println(" This is a large wall which surrounded the southern base.");
            direction = input.next();
        }
        if(direction.indexOf("5") >= 0)
        {
            System.out.println(" This is an old hospital. They must have some medical supplies.");
            direction = input.next();
        }
        if(direction.indexOf("6") >= 0)
        {
            System.out.println(" This is the old market. I'll visit here when my food supply is low.");
            direction = input.next();
        }
        if(direction.indexOf("7") >= 0)
        {
            System.out.println(" This is an old motel, and my current refuge. Here i can replenish my energy.");
            direction = input.next();
        }
        if(direction.indexOf("8") >= 0)
        {
            System.out.println(" This is a clue, necesary for finding them.");
            direction = input.next();
        }
        if(direction.indexOf("9") >= 0)
        {
            System.out.println(" My Family..");
            direction = input.next();
        }

    }
     return myNewArray;
}
public static int clue(int y, int x, int[][] key, int clue)
{

    if(key[x][y] == 8)
    {
        clue++;
        key[x][y] = 0;
    }
        if(clue == 1)
      {
      System.out.println("The remains of some sort of animal.. it makes me sick to my stomach");
      clue++;
     }
     if(clue == 3)
     {
        System.out.println("Death is everywhere..");
        clue++;
     }
     if(clue == 5)
     {
        Scanner input20 = new Scanner(System.in);
        String choice = input20.next();
        System.out.println("A man. He looks so ill..");
        System.out.println("I have a choice to make:");
        System.out.println(" ");
        System.out.println("(a) I give him a day's worth of my food.");
        System.out.println("(b) I leave him to die.");
        System.out.println(" ");
        if(choice.indexOf("a")>=0)
        {
            System.out.println("The man's eyes flutter, and he asks to be left to die.");
        }
        if(choice.indexOf("b")>=0)
        {
            System.out.println("As I'm walking away, the world feels quieter than ever.");
        }
        clue++;
     }
     if(clue == 7)
     {
         System.out.println("Ever since 'the end', these burrows seem to have popped up everywhere.");
         clue++;
        }
     if(clue == 9)
     {
         System.out.println("This bracelet smells exactly like home... It was one of theirs.");
         clue++;
        }
     if(clue == 11)
     {
         System.out.println("A single tree..");
         clue++;
        }
     if(clue == 13)
     {
         System.out.println("Dogs, resorted to their primal instinct. Their meal looks too familiar.");
         clue++;
        }
     if(clue == 15)
     {
         System.out.println("These are her shoes. I'm absolutely sure of it. They're covered in mud.");
         clue++;
        }
     if(clue == 17)
     {
         System.out.println("Blood. It's not theirs. It's not theirs..");
         clue++;
        }
     if(clue == 19)
     {
         System.out.println("A tattered piece of paper. it's addressed to me..");
         System.out.println("'South'. thats all it says. How do i get past the wall. How.");
         finalThoughts();
         clue++;
        }

    return clue;
}
public static int home(int energy, int xSpot, int ySpot)
{
    if(xSpot == 10 && ySpot == 18)
    {
        System.out.println("Home sweet home..");
        System.out.println("(exit to the east or west)");
        energy = 50;
    }
    if(xSpot == 33 && ySpot == 9)
    {
        energy = 50;
    }
    return energy;
}
public static int foodSupply(int xSpot, int ySpot, int food)
{
    if(xSpot == 11 && ySpot == 17 && food > 0)
    {
        food --;
    }
    if(xSpot == 11 && ySpot == 17 && food == 0)
    {
        starve();
    }
    if(xSpot == 33 && ySpot == 9 && food <span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span>< 5)
    {
        System.out.println( 5 - food + " more days worth of food. Good.");
        food = 5;
    }
    return food;
}
public static int family(int xSpot, int ySpot, int finish)
{
    if(xSpot == 32 && ySpot == 24)
    {
        finish = 1;
    }
    return finish;
}
public static void finalThoughts()
{
    System.out.println(" ");
    System.out.println("it's so tall...");
    try {
      Thread.sleep(3000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
    System.out.println("But nothing will keep me from them. I know what I must do.");
}
public static void gameOver()
{
    System.out.println("ENERGY = 0");
    System.out.println("GAME OVER");
}
public static void starve()
{
    System.out.println("You lack the necesary food to venture on.");
    System.out.println("GAME OVER");
}
public static void gameFinish()
{
    System.out.print("My");
    try {
      Thread.sleep(1000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.print(".");
     try {
      Thread.sleep(1000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.print(".");
       try {
      Thread.sleep(1000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.print(".");
            try {
      Thread.sleep(3000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("family..");
                 try {
      Thread.sleep(7000);
     } catch(InterruptedException ex) {
      Thread.currentThread().interrupt();
     }
     System.out.println("I'm Home.");
}
}

Game Sample: Pig

Development Samples

This is a game which I wrote for a computer science class. 2 of these classes were written by my prof. Adam Smith. He wrote the humanPigPlayer, and theAbstract pigPlayer.

The game’s rules can be read here.

The class Pig serves as a template for the game to be played within. It keeps track of the scores of each player, and facilitates the play of the game by generating a random number, which represents the die. It also initializes the players. As the code is on this site, the 2 players will be 1 human, and 1 AI which can be viewed below. They are named “Name” and “Name2”

Screen Shot 2018-01-26 at 4.37.01 PM Screen Shot 2018-01-26 at 4.41.21 PM

<pre>
import java.util.Scanner;
/**
 * Skeleton for a pig game
 * @author Aidan Takami
 * @version   1.1
 */

class Pig {
	/**
	 * The score needed to win a round.
	 */
	public static final int WINNING_SCORE = 100;

	public static void main(String[] args) {

		// intro, initialize players
		System.out.println("Welcome to Pig!");
		PigPlayer human = new HumanPigPlayer("Name");
		PigPlayer opponent = new AidansPigPlayer("Name2"); // This is a bot, can also be human.
		int[] roundsWon = new int[2];

		// round 1
		System.out.println("Round 1!");
		if (playRound(human, opponent)) roundsWon[0]++;
		else roundsWon[1]++;

		System.out.println();

		// round 2
		System.out.println("Round 2!");
		if (playRound(opponent, human)) roundsWon[1]++;
		else roundsWon[0]++;

		// report the final results
		reportFinalTally(roundsWon, human, opponent);
	}

	/**
	 * Do one round, crediting the winner.
	 * @param player1 the first player
	 * @param player2 the second player
	 * @return true if player1 won, false if player2
	 */
	// This function does the following:
	// 1. Enter an infinite loop, with player 1 taking a turn, then player 2.
	// 2. Keep track of each player's score and the turn number.
	// 3. When a player wins, print the winner, and break out of the loop.
	// 4. Return
	private static boolean playRound(PigPlayer player1, PigPlayer player2) {
		//declares int values for turn number, player1 score, and player2 score. Also declares a boolean continueOn for loop
		int turn = 0;
		boolean continueOn = true;
		int player1Score = 0;
		int player2Score = 0;

		//loop allows players to play their turn until there is a winner
		while(continueOn == true){

			//adds score from player's turns to their score, and ends loop once WINNING_SCORE is reached
			player1Score += playTurn(player1, turn, player1Score, player2Score);
			if(player1Score >= WINNING_SCORE){
				return true;
			}
			player2Score += playTurn(player2, turn, player2Score, player1Score);
			if(player2Score >= WINNING_SCORE){
				return false;
			}
			turn++;
		}
		return false;
	}

	/**
	 * Play a single turn, returning how many points the player got.
	 * @param player the player whose turn it is
	 * @param turnNum the turn number (0-indexed)
	 * @param score the player's score
	 * @param opponentsScore the player's adversary's score
	 * @return the points that the player won
	 */
	// This function must do the following:
	// 1. Call the player's beginTurn() method.
	// 2. Loop so long as the player wants to continue rolling.
	// 3. Roll a die:
	//     a. If a 1 is rolled, return 0.
	//     b. On any other roll, add it to the pool.
	// 4. If the loop ends, return the pool's value.
	// 5. Be sure to print events frequently, so the human player can see what's
	//    happening!
	private static int playTurn(PigPlayer player, int turnNum, int score, int opponentsScore) {
		//calls beginTurn()
		player.beginTurn(score, opponentsScore);
		System.out.println();

		//declares a boolean for the loop and an int for the die roll
		boolean continueOn = true;
		int dieRoll;
		int rollNumber = 0;

		//sets score for this turn = to 0
		int roundScore = 0;

		//takes input from user before turn starts, but only users. Not ComputerPigPlayer
		if(player instanceof HumanPigPlayer){
		System.out.println(player.getName() + ", when you are ready, type something.");
		Scanner input = new Scanner(System.in);
		input.nextLine();
		}

		//While loop to iterate as long as player wishes to continue on
		while(continueOn == true){

			//rolls a random die value, prints out roll, and returns 0 if a 0 is rolled
			rollNumber++;
			dieRoll = (int )(Math.random() * 6 + 1);
			System.out.println("You rolled a " + dieRoll + "!");
			if(dieRoll == 1){
				System.out.println("Too bad! End of turn!");
				return 0;
			}

			//adds roll to score and prints score
			else{
				roundScore += dieRoll;
				score += dieRoll;
			}
			System.out.println("Your score is now " + score + ".");

			//if score == WinningScore, score is returned. also gives player option to continue or not
			if(score >= WINNING_SCORE || !(player.decideIfShouldRoll(turnNum, rollNumber, roundScore, score, opponentsScore))){

				//ends loop
				continueOn = false;
			}
			System.out.println();
		}
		//returns the score
		return roundScore;
	}

	/**
	 * Deliver a final report, indicating the overall winner after all rounds
	 * have been played.
	 * @param roundsWon an array of <code>int</code>s indicating the number of rounds each player won
	 * @param player1 the first player
	 * @param player2 the second player
	 */
	// This function must do the following:
	// 1. Print out both player's scores.
	// 2. Indicate who the winner was (or if there was a tie).
	private static void reportFinalTally(int[] roundsWon, PigPlayer player1, PigPlayer player2) {
		if(roundsWon[0] > roundsWon[1]){
			System.out.println("Congrats " + player1.getName() + " you won!!");
			System.out.println("The final tally was " + roundsWon[0] + " to " + roundsWon[1] + "!");
		}
		if(roundsWon[1] > roundsWon[0]){
			System.out.println("Congrats " + player2.getName() + " you won!!");
			System.out.println("The final tally was " + roundsWon[1] + " to " + roundsWon[0] + "!");
		}
		if(roundsWon[0] == roundsWon[1]){
			System.out.println("TIE!");
			System.out.println("The final tally was " + roundsWon[0] + " to " + roundsWon[1] + "!");
		}
	}
}
</pre>

This is the base pigPlayer class, created by Adam Smith. AI and the human class both extend this class

<pre>
/**
 * This is the base pig player. Other pig players (e.g. <code>HumanPigPlayer</code>) must
 * extend this class.
 * @author   Adam Smith
 * @version   1.0
 */

abstract public class PigPlayer {
	private String name; // player's name

	/**
	 * The main constructor for <code>PigPlayer</code>.
	 * @param name The <code>PigPlayer</code>'s name
	 */
	public PigPlayer(String name) {
		this.name = name;
	}

	/**
	 * Accessor for the <code>PigPlayer</code>'s name.
	 * @return the <code>PigPlayer</code>'s name
	 */
	public String getName() {
		return name;
	}

	/**
	 * Alert the <code>PigPlayer</code> that its turn is beginning. This method
	 * needs to be implemented in the subclass (even if it is an empty
	 * function).
	 * @param myScore the player's current score
	 * @param opponentsScore the opponent's current score
	 */
	abstract public void beginTurn(int myScore, int opponentsScore);

	/**
	 * Should the <code>PigPlayer</code> roll again? This method needs to be
	 * implemented in the subclass, taking the exact same arguments (even though
	 * some of them may be unused).
	 * @param turnNumber which turn the player is on (0-indexed)
	 * @param rollNumber which roll the player is on (0-indexed)
	 * @param poolSize the number of points currently in the pool
	 * @param myScore the number of points the player has already won
	 * @param opponentsScore the number of points the opponent has already won
	 * @return true to roll again, false to stop
	 */
	abstract public boolean decideIfShouldRoll(int turnNumber, int rollNumber, int poolSize, int myScore, int opponentsScore);
}
</pre>

This is the human pigPlayer class. Also created by Adam Smith, it allows a human to participate in the game, when initialized in the Pig class.

<pre>
import java.util.Scanner;

/**
 * This is the human pig player. It makes all of its decisions based on input
 * from the keyboard.
 * @author      Adam Smith
 * @version     1.0
 */

public class HumanPigPlayer extends PigPlayer {

	// the shared Scanner among all human pig players (in case there are many)
	static Scanner inputScanner = null;

	/**
	 * The main constructor for <code>HumanPigPlayer</code>.
	 * @param name The <code>HumanPigPlayer</code>'s name
	 */
	public HumanPigPlayer(String name) {
		super(name);

		// if this is the first HumanPigPlayer, allocate the Scanner
		if (inputScanner == null) inputScanner = new Scanner(System.in);
	}

	/**
	 * Alert the human player that his/her turn is beginning.
	 * @param myScore the player's current score
	 * @param opponentsScore the opponent's current score
	 */
	public void beginTurn(int myScore, int opponentsScore) {
		System.out.println(getName() +", it is now your turn!");
		System.out.println("\tYour score is "+myScore+", and your opponent's is " +opponentsScore+".");
	}

	/**
	 * Should the player roll again? This method just asks the human at the
	 * keyboard.
	 * @param turnNumber which turn the player is on (unused)
	 * @param rollNumber which roll the player is on (unused)
	 * @param poolSize the number of points currently in the pool
	 * @param myScore the number of points the player has already won (unused)
	 * @param opponentsScore the number of points the opponent has already won
	 * (unused)
	 * @return true to roll again, false to stop
	 */
	public boolean decideIfShouldRoll(int turnNumber, int rollNumber, int poolSize, int myScore, int opponentsScore) {
		System.out.println("The pool is now " +poolSize+".");
		return getYesNoQuestion("Do you wish to roll?");
	}

	// private helper function that keeps asking a question until it gets a yes or a no
	private static boolean getYesNoQuestion(String question) {
		while (true) {
			System.out.print(question +" ");
			String answer = inputScanner.nextLine();
			if (answer.equalsIgnoreCase("y") || answer.equalsIgnoreCase("yes")) return true;
			if (answer.equalsIgnoreCase("n") || answer.equalsIgnoreCase("no")) return false;
		}
	}

}
</pre>

This is extremely simple AI created by me to serve as an opponent in a game of Pig.

I simplified resources found here and tried to best optimize the AI’s chance of winning against a human player.

<pre>
/**
 * Pig Player AI which uses resources found online to hopefully best optimize
* the AI's chance of winning.
 * @author      Aidan
 * @version     1.0
 */

public class AidansPigPlayer extends PigPlayer {

	/**
	 * The main constructor for <code>ComputerPigPlayer</code>.
	 * @param name The <code>ComputerPigPlayer</code>'s name
	 */
	public AidansPigPlayer(String name) {
		super(name);
	}

	/**
	 * This function does nothing. It is here to fulfill the requirements of the abstract <code>PigPlayer</code> class.
	 * @param myScore the player's current score (unused)
	 * @param opponentsScore the opponent's current score (unused)
	 */
	@Override
	public void beginTurn(int myScore, int opponentsScore) {
                System.out.println();
		System.out.println("Bot's turn!");
	}
<span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span>
	/**
	 * Should the player roll again? The computer always rolls once.
	 * @param turnNumber which turn the player is on (unused)
	 * @param rollNumber which roll the player is on
	 * @param poolSize the number of points currently in the pool (unused)
	 * @param myScore the number of points the player has already won (unused)
	 * @param opponentsScore the number of points the opponent has already won
	 * (unused)
	 * @return true to roll again, false to stop
	 */
	@Override
	public boolean decideIfShouldRoll(int turnNumber, int rollNumber, int poolSize, int myScore, int opponentsScore) {
		if(myScore >= opponentsScore + 25){
			if(poolSize < 14){
				return true;
			}
		}
		if (poolSize <span 				data-mce-type="bookmark" 				id="mce_SELREST_start" 				data-mce-style="overflow:hidden;line-height:0" 				style="overflow:hidden;line-height:0" 			></span>< 20) return true;
		else return false;
	}
}

</pre>

Game Sample: Speak Method

C++ Samples, Programming Samples, The Terf Mop Inn

This method is a small part of a game I worked on. The purpose of the method is to create a life-like output of words, to mimic dialogue and feel more realistic when characters are communicating.

The method takes a string which is the words to be output, an int which represents, in milliseconds, the pause between each word, and another string, speaker, which is the name of the person speaking.

This method works in a fascinating way and really is able to break down a barrier which is often present in text based games, the lack of realistic interaction.

I am not sure if I will post the entirety of this adventure on my site, but I will continue to update on methods which go into the game.

Screen Shot 2018-01-28 at 11.39.59 AM

<pre>
/*
    Method which creates life like speech by dividing up and outputting single words seperated by intervals
 */

void speak(string statement, int pause, string speaker){
    cout << endl;
    //temp string and stringstream are created
    string temp;
    stringstream ss(statement);
    cout << speaker << ":   ";          //Creates pauses between the output of words     while(ss >> temp){
        std::this_thread::sleep_for(std::chrono::milliseconds(pause));
        cout << temp << " " << flush;
    }
}

</pre>

Linked List

Java Samples, Programming Samples

This is a Linked List object which can take any kind of input as a Node and organize it as an arrayList would organize it.

The Object inherits from the interfaces Stack and Queue, written by professor Adam Smith, provided at the bottom!

Enjoy!

/**
 * Linked List object which implements the Stack and Queue interfaces, allowing users to create
 * a linked list of Nodes
 *
 * @version 1.0
 * @author AidanTakami
 *
 */
public class LinkedList implements Queue, Stack{
	//Fields
	public  Node head;
	public  Node tail;
	public  int size;

//*************************
//LinkedList
//*************************

	/**
	 * The constructor for the LinkedList which takes the head and the tail Node
	 * @param Node head
	 * @param Node tail
	 * @since 1.0
	 */
	public LinkedList(Node head, Node tail){
		this.head = head;
		this.tail = tail;
		this.head.setNext(this.tail);
		size = 2;
	}

	/**
	 * adds the E value to the head of the LinkedList
	 *
	 * @param value  the value to be added to the tail
	 * @since 1.0
	 */
	public void addtoHead(E value){
		Node newNode = new Node(value);
		newNode.setNext(head);
		head = newNode;
		size++;
	}

	/**
	 * adds the E value to the tail of the LinkedList
	 *
	 * @param value  the value to be added to the tail
	 * @since 1.0
	 */
	public void addToTail(E value){
		Node newNode = new Node(value);
		tail.setNext(newNode);
		tail = newNode;
		size++;
	}

	/**
	 * Checks to see if the specified value is contained
	 *
	 * @param value  the value to be checked for within the LinkedList
	 * @return boolean  whether or not the value is contained
	 * @since 1.0
	 */
	public boolean contains(E value){
		//if head == value, return true
		if(head.getData().equals(value)) return true;

		Node inspect = head.getPointer();
		//otherwise
		for(int rep = 1; rep  0){
			Node oldHead = head;
			head = oldHead.getPointer();
			size--;
			return (E )oldHead.getData();
		}
		else return null;
	}

	/**
	 * toString method for the LinkedList
	 */
	@Override
	public String toString(){
		//creates string to be returned
		String listString = (" " + head.toString());

		//creates node to be changed and cycle through LinkedList
		Node subject = head;

		//loop which adds each next node to the String
		for(int rep = 0; rep  " + subject + " ");
			}
		}

		//returns the String
		return listString;
	}

//*************************
//Queue Methods
//*************************

	/**
	 * sets the head to the 2nd item in LinkedList and then returns the data
	 * of the previous head
	 *
	 * @since 1.0
	 */
	public E dequeue(){
		Node oldHead = head;
		head = oldHead.getPointer();
		size--;
		return (E )oldHead.getData();
	}

	/**
	 * Adds a Node to the end of the queue and sets that as the new tail
	 *
	 * @param Object value the object to be added to the end
	 * @since 1.0
	 */
	public void enqueue(Object value){
		Node addOn = new Node(value);
		tail.setNext(addOn);
		tail = tail.getPointer();
		size++;
	}

	/**
	 * Peeks at the head of the Queue or Stack
	 *
	 * @since 1.0
	 */
	public E peek(){
		return (E )head.getData();
	}

//*************************
//Stack Methods
//*************************

	/**
	 * removes an item from the head of the Stack, and returns it
	 *
	 * @return the value removed
	 */
	public E pop(){
		Node oldHead = head;
		head = head.getPointer();
		size--;
		return (E )oldHead.getData();
	}

	/**
	 * adds an item to the top of the Stack
	 *
	 * @param value  the value to be added
	 */
	public void push(Object value){
		Node newHead = new Node(value);
		newHead .setNext(head);
		head = newHead;
		size++;
	}

//*************************
//Node Object
//*************************

	/**
	 * Node object which contains a constructor method and a toString.
	 * Node holds an E value as well as a pointer to the next node in a LinkedList.
	 *
	 * @author AidanTakami
	 * @param 
	 * @since 1.0
	 */
	public static class Node{
		//Field
		E data;
		Node nextNode = null;

		/**
		 * Constructor for the Node object. takes the data which will be stored in the Node.
		 * @param data
		 * @since 1.0
		 */
		public Node(E data){
			this.data = data;
		}

		/**
		 * toString Method for the Node object.
		 *
		 * @since 1.0
		 */
		@Override
		public String toString(){
			return "(" + data + ")";
		}

		/*
		 * Returns the Node nextNode of the Node, which is the next Node in the sequence
		 */
		private Node getPointer(){
			return nextNode;
		}

		/*
		 * Returns the data of the Node
		 */
		private E getData(){
			return data;
		}

		/*
		 * Sets the nextNode of the node, only to be accessible by the LinkedList object
		 */
		private void setNext(Node next){
			nextNode = next;
		}

	}

/**
 * This is an interface for a Queue. An object which implements this interface
 * is thus a "first in, first out", or "FIFO" structure. It can enqueue to the
 * end, dequeue from the front, or peek at the front.
 *
 * @author Adam Smith
 * @version 1.0
 */
public interface Queue {
/**
* Removes an item from the front of the queue.
*
* @return the value removed
*/

public E dequeue();

/**
* Adds an item to the end of the queue.
*
* @param value the value to be enqueued
*/

public void enqueue(E value);

/**
* Checks item at the front of the queue, without altering the queue.
*
* @return the value checked
*/

public E peek();
}

/**
 * This is an interface for a Stack. An object which implements this interface
 * is thus a "first in, last out", or "FILO" structure. It can push to the top,
 * pop from the top, or peek at the top.
 *
 * @author Adam Smith
 * @version 1.0
 */

public interface Stack {
	/**
	 * Checks item at the top of the stack, without altering the stack.
	 *
	 * @return the value checked
	 */

	public E peek();

	/**
	 * Removes an item from the top of the stack.
	 *
	 * @return the value removed
	 */

	public E pop();

	/**
	 * Adds an item to the top of the stack.
	 *
	 * @param value  the value to be enqueued
	 */

	public void push(E value);
}