World of zuul

1. Game 클래스 
 
- "World of Zuul" 어플리케이션의 main 클래스 
- 이 게임을 플레이하려면 이 클래스의 인스턴스를 만들고 "플레이" 호출
- 다른 모든 클래스를 만들고 초기화
- 모든 room과 parser을 만들고 게임 시작
 또한 parser가 반환하는 명령을 평가하고 실행
 

package WorldOfZull;

public class Game
{
	private Parser parser;
	private Room currentRoom;
	//게임을 창조하고 internal map을 초기화 
	public Game()
	{
		parser= new Parser();
		createRooms();
	}
	
	//모든 Room을 창조하고 그들의 exit을 연결
	private void createRooms()
	{
		Room outside,theater,pub,lab,office;
		
		//Room 생성
		outside = new Room("outside the main entrance of the university");
		theater = new Room("in a lecture theater");
		pub = new Room("in the campus pub");
		lab = new Room("in a computing lab");
		office = new Room("in the computing admin office");
		
		//Room exit 초기화
		outside.setExit("east", theater);
        outside.setExit("south", lab);
        outside.setExit("west", pub);
        theater.setExit("west", outside);
        pub.setExit("east", outside);
        lab.setExit("north", outside);
        lab.setExit("east", office);
        office.setExit("west", lab);
        
        //Room에 item 추가 
        lab.addItem(new Item("computer", 5001));
        theater.addItem(new Item("notebook", 20));
        theater.addItem(new Item("chair", 1000));
        pub.addItem(new Item("beer", 15));
        office.addItem(new Item("paper", 1));
        
        //Room에 player 생성
        currentRoom = outside;
	}
	
	//메인 플레이 루틴, 게임 끝날떄 까지 반복
	public void play()
	{
		printWelcome();
		
		//주요 명령 루프에 들어가라, 여기서 우리는 게임이 끝날떄까지 명령을 읽고 실행함
		boolean finished = false;
		while(! finished) {
			Command command = parser.getCommand();
			finished = processCommand(command);
		}
		System.out.println("Thank you for playing.  Good bye.");
	}
	
	//player의 오픈 메시지 출력
	 private void printWelcome()
	 {
	        System.out.println();
	        System.out.println("Welcome to the World of Zuul!");
	        System.out.println("World of Zuul is a new, incredibly boring adventure game.");
	        System.out.println("Type 'help' if you need help.");
	        System.out.println();
	        System.out.println(currentRoom.getLongDescription());
	 }
	 
	 //주어진 명령에 따라 명령 실행
	 //파라미터 : 명령
	 //리턴 : 만약에 명령이 게임을 끝낸다면 true 아니면 false
	 private boolean processCommand(Command command)
	 {
		 boolean wantToQuit = false;
		 
		 if(command.isUnknown()) {
			 System.out.println("I don't know what you mean...");
	            return false;
		 }
		 
		 String commandWord = command.getCommandWord();
		 if(commandWord.equals("help")) {
			 printHelp();
		 }
		 else if(commandWord.equals("go")) {
			 goRoom(command);
		 }
		 else if(commandWord.equals("quit")) {
			 wantToQuit = quit(command);
		 }
		 
		 //else command not recognised.
		 return wantToQuit;
		 
	 }
	 
	 //help 정보 출력
	 private void printHelp() 
	 {
	        System.out.println("You are lost. You are alone. You wander");
	        System.out.println("around at the university.");
	        System.out.println();
	        System.out.println("Your command words are:");
	        parser.showCommands();
	  }
	 
	 //한 방향으로 가도록 하세요. 나가는 곳이 있으면 새 룸에 들어가고, 그렇지 않으면 오류 메시지를 출력
	 private void goRoom(Command command)
	 {
		 if(!command.hasSecondWord()) {
			 //만약에 second word가 없다면, 우리는 어디로 갈지 모름
			 System.out.println("Go where?");
			 return;
		 }
		 
		 String direction = command.getSecondWord();
		 //현재 방을 떠나기를 시도 
		 Room nextRoom = currentRoom.getExit(direction);
		 
		 if(nextRoom == null) {
			 System.out.println("There is no door")
		 }
		 else {
			 currentRoom = nextRoom;
			 System.out.println(currentRoom.getLongDescription());
		 }
	 }
	 
	 private boolean quit(Command command)
	 {
		 if(command.hasSecondWord()) {
			 System.out.println("Quit what?");
			 return false;
		 }
		 else {
			 return true; 
		 }
	 }
}

 
2.Room 클래스
 
- 게임의 풍경의 위치를 대표
- exit를 통해 다른방들을 연결
- 각 exit를 통해 각 Room은 이웃 Room의 참조(위치)를 저장
 

package WorldOfZull;

import java.util.Set;
import java.util.HashMap;
import java.util.ArrayList;

public class Room {

	private String description;
	//이 방의 출구 필드
	private HashMap<String,Room> exits;
	//이 방의 item 정의 
	private ArrayList<Item>items;
	
	public Room(String description)
	{
		this.description = description;
		exits = new HashMap<>();
		items = new ArrayList<>();
	}
	
	//Room의 출구 정의 메서드
	public void setExit(String direction, Room neighbor)
	{
		exits.put(direction, neighbor);
	}
	
	//Room에 item 추가 
	public void addItem(Item item)
	{
		items.add(item);
	}
	
	//Room에 짧은 묘사
	public String getShortDescription()
	{
		return description;
	}
	
	//Room에 긴 묘사 
	public String getLongDescription()
	{
		return "You are " + description + ".\n" + getExitString() + ".\n" + getItemString() + "\n";
	}
	
	//Room의 출구 묘사를 리턴 -"Exits: north west"
	private String getExitString()
	{
		String returnString = "Exits:";
		Set<String>keys = exits.keySet();
		for(String exit : keys) {
			returnString +=" "+exit;
		}
		return returnString;
	}
	
	//Room의 Item 묘사
	private String getItemString()
	{
		String returnString ="Items:";
		if(items.isEmpty()) {
			return returnString;
		}
		
		int i;
		for(i=0; i <items.size()-1; i++) {
			returnString +=items.get(i).getName()+",";		
		}
		returnString +=items.get(i).getName()+".";
		
		return returnString;
	}
	
	// 만약 "direction" 지시에 원래 방으로부터 나간다면 도달한 방 리턴
	public Room getExit(String direction)
	{
		//direction key 가져오기
		return exits.get(direction);
	}
}

 
3. Item 클래스 
 
 - Item은 게임의 Item을 대표 
 - Item은 이름과 무게를 가짐
 

package WorldOfZull;

public class Item {
	private String name;
	private int weight;
	
	public Item(String name)
	{
		//초기화
		this(name,0);
	}
	
	//Item의 name과 weight 생성
	public Item(String name, int weight)
	{
		this.name = name;
		this.weight = weight;
	}
	
	//Item의 이름 가져오기
	public String getName()
	{
		return name;
	}
	
	//Item의 무게 가져오기
	public int getWeight()
	{
		return weight;
	}
}

 
4. parser 클래스 
 
- 유저의 입력을 읽고 "Adventure"로써 해석시도
- terminal로 부터 라인을 읽는것을 요청 받고 두개의 단어 명령으로써 라인 해석을 시도 
- class 명령의 객체로써  명령을 리턴
- parser는 command words로 알려진 set을 가짐
- command words는 command를 대신하여 사용자의 입력을 확인하고 입력이 commands 중 하나가 아니라면 
unknown 명령 리턴
 

package WorldOfZull;

import java.util.Scanner;

public class Parser {
	//모든 유효한 command words 잡기
	private CommandWords commands;
	//유저
	private Scanner reader;
	
	public Parser()
	{
		commands = new CommandsWords();
		reader = new Scanner(System.in);
	}
	
	//user로 부터 다음 명령 리턴
	public Command getCommand()
	{
		String inputLine;
		String word1 = null;
		String word2 = null;
		
		System.out.print(">"); //print prompt
		
		inputLine = reader.nextLine();
		
		//line에서 두 단어 찾기 
		Scanner tokenizer = new Scanner(inputLine);
		if(tokenizer.hasNext()) {
			word1 = tokenizer.next(); //get first word
			if(tokenizer.hasNext()) {
				word2=tokenizer.next(); //get second word
				
			}
		}
		
		//이 단어가 있는지 없는지 체크. 만약에 있다면 명령 생성
		//없다면 null 
		//isCommand(CommandsWords) -주어진 String이 유효한 command word인지
		if(commands.isCommand(word1)) {
			return new Command(word1,word2);
		}
		else {
			return new Command(null,word2);
		}		
	}
	
	//유효한 commands words 리스트 출력
	public void showCommands()
	{
		//showAll(CommandsWords) -print all vaild commands to System.out
		commands.showAll();
	}
}

 
5.commandsWords 클래스 

- 게임에 알려진 모든 명령어 열거
- 그들이 타이핑 쳐진대로 알아들음
- Constant Array[]
 

package WorldOfZull;

public class CommandsWords {
	// a constant array that holds all valild command words
	private static final String[] vaildCommands = {
			"go","quit","help"
	};
	
	public CommandsWords()
	{
		
	}
	//String이 유효한 command word인지 확인
	public boolean isCommand(String aString)
	{
		for(int i=0; i<vaildCommands.length; i++) {
			if(vaildCommands[i].equals(aString))
				return true;
		}
		return false;
	}
	
	//모든 유효한 명령 출력
	public void showAll()
	{
		for(String command : vaildCommands) {
			System.out.print(command+" ");
		}
		System.out.println();
	}
}

 
6. Command 클래스 
 
- user로 부터 발행된 명령들의 정보
- 명령은 두개의 String으로 구성 : command word, second word
-  user가 잘못된 명령을 입력한 경우 명령어 <null>
- user가 한 단어만 가지고 있다면 second word는 <null>

package WorldOfZull;

public class Command {
	private String commandWord;
	private String secondWord;
	
	public Command(String firstWord, String secondWord)
	{
		commandWord = firstWord;
		this.secondWord= secondWord;
	}
	
	//이 명령의 commandWord(first word)리턴
	public String getCommandWord()
	{
		return commandWord;
	}
	
	//이 명령의 second word 리턴 
	public String getSecondWord()
	{
		return secondWord;
	}
	
	//이 명령이 이해 불가능하면 true 리턴 
	public boolean isUnknown()
	{
		return (commandWord == null);
	}
	
	//Second word 명령을 가진다면 true 리턴
	public boolean hasSecondWord()
	{
		return (secondWord!=null);
	}
}

 
 

---

    /**
     * doDrop: 
     *   1. checks if user specified a thing to be dropped
     *   2. checks that it's there in inventory
     *   3. deletes that item from inventory, and adds to currentRoom
     *   4. prints a message about it.
     */
    public void doDrop(Command c) {
        if (! c.hasSecondWord()) {  // "DROP",but no object named
            System.out.println("Drop what?");
            return;
        }
        String s = c.getSecondWord();
        Item i = findByName(s, inventory);
        if (i == null) {
            System.out.println("You don't have a " + s);
            return;
        }
        inventory.remove(i);    
        currentRoom.addItem(i);
        System.out.println("You have dropped the " + s);
    }
    
     /**
     * doTake: doesn't do anything yet
     */
    public void doTake(Command c) {
        System.out.println("Doesn't do anything yet.");
    }
    
}

import java.util.ArrayList;
/**
 * 
 * @author ChoiJiWoo
 * @version 2023-06-19
 */
public class Plyaer
{
    private Room playerRoom; //Plyaer의 현재 룸 
    private ArrayList<Item> playerItem; //Player의 지니고 있는 Item
    private int itemweight;
    final int MAX_CARRY_WEIGHT = 5000; //운반 가능한 최대 무게 
    
    public Plyaer()
    {   this.playerRoom = playerRoom;
        playerItem = new ArrayList<Item>();

    }
     
    public String takeItem(Item name) {
        System.out.println("take" + name);
        if(name.getWeight() <MAX_CARRY_WEIGHT)
        {
            playerItem.add(name);
            return "You are carrying now the" + name;  
        }
        return " ";    
    }
    
    public String dropItem(Item name) {
        System.out.println("drop" + name);
        playerItem.remove(name);
        return "You have dropped the" + name;
    }

    
}