java programming

17 Jan java programming

1. Open the zuul-bad project in BlueJ and save it as LastName-zuul1, using your last name, e.g., Smith-zuul1.
2. Start by completing Exercises 6e: 8.1, 8.2, and 8.3  There is nothing to turn in for these exercises. As you design your game scenario, keep in mind the following:
   • Your game should have at least 6 rooms and no more than 10 rooms.
   • Each room should have a descriptive name.
   • Your rooms should be different from the rooms in the program already. Do not simply extend the existing scenario; create your own.
   • Be creative. This game scenario will be the basis for future assignments so make it something that will keep your interest.
3. Complete Exercise 6e: 8.4 
   • Create a map of your game scenario in any common electronic format (such as .pdf, .doc, .pptx, .jpg, etc.).
   • Update the source code of your zuul project to create the rooms and connections as you designed them.
   • Update the welcome and help messages to match your scenario.
   • The rooms created in your zuul project and the connections from one room to another should match your map.
     • Make sure the connections between rooms are clear in your map. I will assume that connections between rooms are bidirectional unless you indicate otherwise (e.g., with arrowheads).
4. Test your program.
5. Document your changes.
   • Adjust the comment block at the top of the file to include a 1-2 sentence description of your specific game scenario.
   • Add your name to the @author list and update the version.
6. When you have completed the assignment, create a jar file of your project:
   1. From BlueJ, choose Project->Create Jar File…
   2. Check the “Include source” checkbox  ← Very important!
   3. Name the file LastName-zuul1

Part 3: Git

In this part, you will install Git, a version control system, and use it to track source code for a simple project. Version control systems have two big advantages: (1) tracking versions of source code, and (2) facilitating collaboration among multiple developers working on the same code. In this lab, you will learn to use Git to track versions of source code.

Note: This part is a repeat of an assignment from CIS 133J. If you already have Git installed you don’t need to do that step, but you should complete all the other steps anew. Practicing the Git flow again will help you learn it. Do not resubmit a project from 133J. Each time you commit, a timestamp is associated with the commit.

1. Walk through all the documents in the module Version Control with Git, learning about version control and following along with the steps. You may want to keep the Git Cheat Sheet for CIS 133J handy.
   1. Git and Version Control – informational.
   2. Install and Set Up Git – steps you need to follow to install Git on your local system.
   3. Set Up a Repository for a Project – steps you need to follow to create a local repository for a Java project.
   4. Add Features to a Project – steps you need to follow to add features to your Java project while tracking the changes in the repository.
2. In the process of walking through the documents above you should have created a Hello World project and repository, which is what you will submit for this part of the lab.
3. For full credit, your project repository must meet the criteria below. (If you followed along with the videos, you should have everything you need.)
   • The Java code must compile and run without error, printing a hello message to the terminal.
   • The repository must have a feature branch on which the work was done, which has been merged into the master. (Check with ‘git branch’ – your feature branch should be listed.)
   • There must be at least 2 commits with feature work, beyond initializing the project. (Check with ‘git log’)
   • Your commits must have descriptive messages.
   • Your commits must have timestamps from this quarter.
   • Your name and email address must be set up in your Git installation. (Look at the Author line in ‘git log’)
   • The repository must be clean with no uncommitted changes. (When you do ‘git status’ it should say “On branch master, nothing to commit, working tree clean”)
4. Your submission for this part should be a zip file containing your project folder (e.g., hello-world). Creating a jar file from the BlueJ project is not sufficient because the jar does not include the repository files. Git uses a hidden folder named .git to store its internal files, and this folder needs to be in the zip file along with your project files.
6. game 
7. /**
8.  *  This class is the main class of the “World of Zuul” application. 
9.  *  “World of Zuul” is a very simple, text based adventure game.  Users 
10.  *  can walk around some scenery. That’s all. It should really be extended 
11.  *  to make it more interesting!
12.  * 
13.  *  To play this game, create an instance of this class and call the “play”
14.  *  method.
15.  * 
16.  *  This main class creates and initialises all the others: it creates all
17.  *  rooms, creates the parser and starts the game.  It also evaluates and
18.  *  executes the commands that the parser returns.
19.  * 
20.  * @author  Michael Kölling and David J. Barnes
21.  * @version 2016.02.29
22.  */
24. public class Game 
25. {
26.     private Parser parser;
27.     private Room currentRoom;
28.         
29.     /**
30.      * Create the game and initialise its internal map.
31.      */
32.     public Game() 
33.     {
34.         createRooms();
35.         parser = new Parser();
36.     }
38.     /**
39.      * Create all the rooms and link their exits together.
40.      */
41.     private void createRooms()
42.     {
43.         Room outside, theater, pub, lab, office;
44.       
45.         // create the rooms
46.         outside = new Room(“outside the main entrance of the university”);
47.         theater = new Room(“in a lecture theater”);
48.         pub = new Room(“in the campus pub”);
49.         lab = new Room(“in a computing lab”);
50.         office = new Room(“in the computing admin office”);
51.         
52.         // initialise room exits
53.         outside.setExits(null, theater, lab, pub);
54.         theater.setExits(null, null, null, outside);
55.         pub.setExits(null, outside, null, null);
56.         lab.setExits(outside, office, null, null);
57.         office.setExits(null, null, null, lab);
59.         currentRoom = outside;  // start game outside
60.     }
62.     /**
63.      *  Main play routine.  Loops until end of play.
64.      */
65.     public void play() 
66.     {            
67.         printWelcome();
69.         // Enter the main command loop.  Here we repeatedly read commands and
70.         // execute them until the game is over.
71.                 
72.         boolean finished = false;
73.         while (! finished) {
74.             Command command = parser.getCommand();
75.             finished = processCommand(command);
76.         }
77.         System.out.println(“Thank you for playing.  Good bye.”);
78.     }
80.     /**
81.      * Print out the opening message for the player.
82.      */
83.     private void printWelcome()
84.     {
85.         System.out.println();
86.         System.out.println(“Welcome to the World of Zuul!”);
87.         System.out.println(“World of Zuul is a new, incredibly boring adventure game.”);
88.         System.out.println(“Type ‘help’ if you need help.”);
89.         System.out.println();
90.         System.out.println(“You are ” + currentRoom.getDescription());
91.         System.out.print(“Exits: “);
92.         if(currentRoom.northExit != null) {
93.             System.out.print(“north “);
94.         }
95.         if(currentRoom.eastExit != null) {
96.             System.out.print(“east “);
97.         }
98.         if(currentRoom.southExit != null) {
99.             System.out.print(“south “);
100.         }
101.         if(currentRoom.westExit != null) {
102.             System.out.print(“west “);
103.         }
104.         System.out.println();
105.     }
107.     /**
108.      * Given a command, process (that is: execute) the command.
109.      * @param command The command to be processed.
110.      * @return true If the command ends the game, false otherwise.
111.      */
112.     private boolean processCommand(Command command) 
113.     {
114.         boolean wantToQuit = false;
116.         if(command.isUnknown()) {
117.             System.out.println(“I don’t know what you mean…”);
118.             return false;
119.         }
121.         String commandWord = command.getCommandWord();
122.         if (commandWord.equals(“help”)) {
123.             printHelp();
124.         }
125.         else if (commandWord.equals(“go”)) {
126.             goRoom(command);
127.         }
128.         else if (commandWord.equals(“quit”)) {
129.             wantToQuit = quit(command);
130.         }
132.         return wantToQuit;
133.     }
135.     // implementations of user commands:
137.     /**
138.      * Print out some help information.
139.      * Here we print some stupid, cryptic message and a list of the 
140.      * command words.
141.      */
142.     private void printHelp() 
143.     {
144.         System.out.println(“You are lost. You are alone. You wander”);
145.         System.out.println(“around at the university.”);
146.         System.out.println();
147.         System.out.println(“Your command words are:”);
148.         System.out.println(”   go quit help”);
149.     }
151.     /** 
152.      * Try to go in one direction. If there is an exit, enter
153.      * the new room, otherwise print an error message.
154.      */
155.     private void goRoom(Command command) 
156.     {
157.         if(!command.hasSecondWord()) {
158.             // if there is no second word, we don’t know where to go…
159.             System.out.println(“Go where?”);
160.             return;
161.         }
163.         String direction = command.getSecondWord();
165.         // Try to leave current room.
166.         Room nextRoom = null;
167.         if(direction.equals(“north”)) {
168.             nextRoom = currentRoom.northExit;
169.         }
170.         if(direction.equals(“east”)) {
171.             nextRoom = currentRoom.eastExit;
172.         }
173.         if(direction.equals(“south”)) {
174.             nextRoom = currentRoom.southExit;
175.         }
176.         if(direction.equals(“west”)) {
177.             nextRoom = currentRoom.westExit;
178.         }
180.         if (nextRoom == null) {
181.             System.out.println(“There is no door!”);
182.         }
183.         else {
184.             currentRoom = nextRoom;
185.             System.out.println(“You are ” + currentRoom.getDescription());
186.             System.out.print(“Exits: “);
187.             if(currentRoom.northExit != null) {
188.                 System.out.print(“north “);
189.             }
190.             if(currentRoom.eastExit != null) {
191.                 System.out.print(“east “);
192.             }
193.             if(currentRoom.southExit != null) {
194.                 System.out.print(“south “);
195.             }
196.             if(currentRoom.westExit != null) {
197.                 System.out.print(“west “);
198.             }
199.             System.out.println();
200.         }
201.     }
203.     /** 
204.      * “Quit” was entered. Check the rest of the command to see
205.      * whether we really quit the game.
206.      * @return true, if this command quits the game, false otherwise.
207.      */
208.     private boolean quit(Command command) 
209.     {
210.         if(command.hasSecondWord()) {
211.             System.out.println(“Quit what?”);
212.             return false;
213.         }
214.         else {
215.             return true;  // signal that we want to quit
216.         }
217.     }
218. }
220. ” command

*/

public class Command

{

    private String commandWord;

    private String secondWord;

    /**

     * Create a command object. First and second word must be supplied, but

     * either one (or both) can be null.

     * @param firstWord The first word of the command. Null if the command

     *                  was not recognised.

     * @param secondWord The second word of the command.

     */

    public Command(String firstWord, String secondWord)

    {

        commandWord = firstWord;

        this.secondWord = secondWord;

    }

    /**

     * Return the command word (the first word) of this command. If the

     * command was not understood, the result is null.

     * @return The command word.

     */

    public String getCommandWord()

    {

        return commandWord;

    }

    /**

     * @return The second word of this command. Returns null if there was no

     * second word.

     */

    public String getSecondWord()

    {

        return secondWord;

    }

    /**

     * @return true if this command was not understood.

     */

    public boolean isUnknown()

    {

        return (commandWord == null);

    }

    /**

     * @return true if the command has a second word.

     */

    public boolean hasSecondWord()

    {

        return (secondWord != null);

    }

}

room “

 */

public class Room 

{

    public String description;

    public Room northExit;

    public Room southExit;

    public Room eastExit;

    public Room westExit;

    /**

     * Create a room described “description”. Initially, it has

     * no exits. “description” is something like “a kitchen” or

     * “an open court yard”.

     * @param description The room’s description.

     */

    public Room(String description) 

    {

        this.description = description;

    }

    /**

     * Define the exits of this room.  Every direction either leads

     * to another room or is null (no exit there).

     * @param north The north exit.

     * @param east The east east.

     * @param south The south exit.

     * @param west The west exit.

     */

    public void setExits(Room north, Room east, Room south, Room west) 

    {

        if(north != null) {

            northExit = north;

        }

        if(east != null) {

            eastExit = east;

        }

        if(south != null) {

            southExit = south;

        }

        if(west != null) {

            westExit = west;

        }

    }

    /**

     * @return The description of the room.

     */

    public String getDescription()

    {

        return description;

    }

}

“Parser

*/

public class Parser 

{

    private CommandWords commands;  // holds all valid command words

    private Scanner reader;         // source of command input

    /**

     * Create a parser to read from the terminal window.

     */

    public Parser() 

    {

        commands = new CommandWords();

        reader = new Scanner(System.in);

    }

    /**

     * @return The next command from the user.

     */

    public Command getCommand() 

    {

        String inputLine;   // will hold the full input line

        String word1 = null;

        String word2 = null;

        System.out.print(“> “);     // print prompt

        inputLine = reader.nextLine();

        // Find up to two words on the line.

        Scanner tokenizer = new Scanner(inputLine);

        if(tokenizer.hasNext()) {

            word1 = tokenizer.next();      // get first word

            if(tokenizer.hasNext()) {

                word2 = tokenizer.next();      // get second word

                // note: we just ignore the rest of the input line.

            }

        }

        // Now check whether this word is known. If so, create a command

        // with it. If not, create a “null” command (for unknown command).

        if(commands.isCommand(word1)) {

            return new Command(word1, word2);

        }

        else {

            return new Command(null, word2); 

        }

    }

}

 “command Words “

 */

public class CommandWords

{

    // a constant array that holds all valid command words

    private static final String[] validCommands = {

        “go”, “quit”, “help”

    };

    /**

     * Constructor – initialise the command words.

     */

    public CommandWords()

    {

        // nothing to do at the moment…

    }

    /**

     * Check whether a given String is a valid command word. 

     * @return true if a given string is a valid command,

     * false if it isn’t.

     */

    public boolean isCommand(String aString)

    {

        for(int i = 0; i < validCommands.length; i++) {

            if(validCommands[i].equals(aString))

                return true;

        }

        // if we get here, the string was not found in the commands

        return false;

    }

}

3.