/*Drew Schuster
  dtschust
  ECE462
*/

import java.io.File;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.util.*;


/* Generic object, everything inherits from this*/
class ZorkObject
{
  public String status;
  public ArrayList<ZorkTrigger> trigger = new ArrayList<ZorkTrigger>();
  public ZorkObject()
  {
  }
}

/* Generic condition*/
abstract class ZorkCondition
{
  String object;
  public abstract boolean evaluate(Zork zork);
}

/* Status conditions*/
class ZorkConditionStatus extends ZorkCondition
{
  String status;
  public boolean evaluate(Zork zork)
  {
    ZorkObject tested = zork.Objects.get(object);
    if (tested != null && tested.status.equals(status))
      return true;
    else
      return false;
  }
}

/* Has conditions*/
class ZorkConditionHas extends ZorkCondition
{
  String has;
  String owner;
  public boolean evaluate(Zork zork)
  {
    /*Inventory is a special case as it isn't the name of any object in the game, check for it specifically*/
    if (owner.equals("inventory"))
    {
      if (zork.Inventory.get(object) != null && has.equals("yes") || zork.Inventory.get(object) == null && has.equals("no"))
      {
        return true;
      }
      else
      {
        return false;
      }
    }
    else
    {
      /* is it a room?*/
      ZorkRoom roomObject = zork.Rooms.get(owner);
      if ( roomObject != null )
      {
        if ((roomObject).item.get(object) != null && has.equals("yes") || (roomObject).item.get(object) == null && has.equals("no"))
        {
          return true;
        }
        else
        {
          return false;
        }
      }
      /* is it a container?*/
      else
      {
        ZorkContainer containerObject = zork.Containers.get(owner);
        if (containerObject != null )
        {
          if ((containerObject).item.get(object) != null && has.equals("yes") || (containerObject).item.get(object) == null && has.equals("no"))
          {
            return true;
          }
          else
          {
            return false;
          }

        }
      }
    }
    
    return false;
  }
}
/* Special Command condition*/
class ZorkCommand extends ZorkCondition
{
  String command;
  public boolean evaluate(Zork zork)
  {
    if (command.equals(zork.userInput))
      return true;
    else
      return false;
  }
}

/*Trigger*/
class ZorkTrigger
{
  public ArrayList<ZorkCondition> conditions = new ArrayList<ZorkCondition>();
  String type="single"; /*By default, single*/
  boolean hasCommand = false; 
  public ArrayList<String> print = new ArrayList<String>();
  public ArrayList<String> action = new ArrayList<String>();

  public boolean evaluate(Zork zork)
  {
    for(int i=0;i<conditions.size();i++)
    {
      if (!conditions.get(i).evaluate(zork))
      {
        return false;
      }
    }
    return true;
  }
}
  
  
/*  Room*/
class ZorkRoom extends ZorkObject
{
  public String name;
  public String type="regular";
  public String description;
  public HashMap<String,String> border = new HashMap<String,String>();
  public HashMap<String,String> container = new HashMap<String,String>();
  public HashMap<String,String> item = new HashMap<String,String>();
  public HashMap<String,String> creature = new HashMap<String,String>();
  public ZorkRoom()
  {
  }
}

/* Item*/
class ZorkItem extends ZorkObject
{
  public String name;
  public String description;
  public String writing;
  public ArrayList<String> turnOnPrint = new ArrayList<String>();
  public ArrayList<String> turnOnAction = new ArrayList<String>();
  public ZorkItem()
  {
  }
}

/* Container*/
class ZorkContainer extends ZorkObject
{
  public String name;
  public HashMap<String,String> item = new HashMap<String,String>();
  public String description;
  public ArrayList<String> accept = new ArrayList<String>();
  boolean isOpen;
  public ZorkContainer()
  {
  }
}

/* Creature*/
class ZorkCreature extends ZorkObject
{
  public String name;
  public String description;
  public HashMap<String,String> vulnerability = new HashMap<String,String>();
  public ArrayList<ZorkCondition> conditions = new ArrayList<ZorkCondition>();
  public ArrayList<String> print = new ArrayList<String>();
  public ArrayList<String> action = new ArrayList<String>();
  public ZorkCreature()
  {
  }
  /* Evaluate the success of an attack*/
  public boolean attack(Zork zork,String weapon)
  {
    if (vulnerability.get(weapon) == null)
    {
      return false;
    }
    for(int i=0;i<conditions.size();i++)
    {
      if (!conditions.get(i).evaluate(zork))
      {
        return false;
      }
    }
    return true;
  }
}

/* And away we go*/
public class Zork
{
  Scanner source = new Scanner(System.in);
  public String userInput="";

  /*Hashmaps to store the instance of the game*/
  public HashMap<String,ZorkRoom> Rooms = new HashMap<String,ZorkRoom>();
  public HashMap<String,ZorkItem> Items = new HashMap<String,ZorkItem>();
  public HashMap<String,ZorkContainer> Containers = new HashMap<String,ZorkContainer>();
  public HashMap<String,ZorkObject> Objects = new HashMap<String,ZorkObject>();
  public HashMap<String,ZorkCreature> Creatures = new HashMap<String,ZorkCreature>();
  public HashMap<String,String> Inventory = new HashMap<String,String>();
  public HashMap<String,String> ObjectLookup = new HashMap<String,String>();
  public String currentRoom;
  public File file;
  public Zork(String filename)
  {
    int i,j,k,l,x,y,z;





    file = new File(filename);
    if (!file.canRead())
    {
      System.out.println("Error opening file.  Exiting...");
      return;
    }

    try 
    {
      /* Open the xml file*/
      DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
      Document doc = builder.parse(file);

      Element rootElement = doc.getDocumentElement();

      /* Every single first generation child is a room, container, creature, or item.  So load them in*/
      NodeList nodes = rootElement.getChildNodes();
      for (k=0;k<nodes.getLength();k++)
      {
        Node node = nodes.item(k);
        Element element;
        if (node instanceof Element)
        {
          element = (Element)node;
          String tagType = element.getTagName();
  
          /* If it's a room ... */
          if (tagType.equals("room"))
          {
            ZorkRoom tempRoom = new ZorkRoom();

            /*Get all possible Room attributes*/

            NodeList name = element.getElementsByTagName("name");
            tempRoom.name = getString((Element)name.item(0));
            NodeList type = element.getElementsByTagName("type");
            if (type.getLength() > 0)
            {
              tempRoom.type = getString((Element)type.item(0));
            }
            else
            {
              tempRoom.type = "regular";
            }
            NodeList status = element.getElementsByTagName("status");
            if (status.getLength() > 0)
            {
              tempRoom.status = getString((Element)type.item(0));
            }
            else
            {
              tempRoom.status = "";
            }
            NodeList description = element.getElementsByTagName("description");
            tempRoom.description = getString((Element)description.item(0));
            
            NodeList items = element.getElementsByTagName("item");
            for (j=0;j<items.getLength();j++)
            {
              Element item = (Element)items.item(j);
              String itemName = getString(item);
              tempRoom.item.put(itemName,itemName);
            }

            NodeList creatures = element.getElementsByTagName("creature");
            for (j=0;j<creatures.getLength();j++)
            {
              Element creature = (Element)creatures.item(j);
              String creatureName = getString(creature);
              tempRoom.creature.put(creatureName,creatureName);
            }
            
            NodeList triggers = element.getElementsByTagName("trigger");
            for (j=0;j<triggers.getLength();j++)
            {
              ZorkTrigger tempTrigger = new ZorkTrigger();
              Element trigger = (Element)triggers.item(j);
              NodeList commands = trigger.getElementsByTagName("command");
              for (l=0;l<commands.getLength();l++)
              {
                Element command = (Element)commands.item(l);
                ZorkCommand tempCommand = new ZorkCommand();
                tempCommand.command = getString(command);
                tempTrigger.conditions.add(tempCommand);
                tempTrigger.hasCommand = true;
              }
              NodeList conditions = trigger.getElementsByTagName("condition");
              for (l=0;l<conditions.getLength();l++)
              {
                Element condition = (Element)conditions.item(l);
                NodeList object = condition.getElementsByTagName("object");
                NodeList has = condition.getElementsByTagName("has");
                if (has.getLength() > 0)
                {
                  ZorkConditionHas tempConditionHas = new ZorkConditionHas();
                  tempConditionHas.has = getString((Element)has.item(0));
                  tempConditionHas.object = getString((Element)object.item(0));
                  NodeList owner = condition.getElementsByTagName("owner");
                  tempConditionHas.owner = getString((Element)owner.item(0));
                  tempTrigger.conditions.add(tempConditionHas);

                }
                else
                {
                  ZorkConditionStatus tempConditionStatus = new ZorkConditionStatus();
                  tempConditionStatus.object = getString((Element)object.item(0));
                  NodeList sstatus = condition.getElementsByTagName("status");
                  tempConditionStatus.status = getString((Element)sstatus.item(0));
                  tempTrigger.conditions.add(tempConditionStatus);
                }
                
              }
              NodeList ttype = element.getElementsByTagName("type");
              if (ttype.getLength() > 0)
              {
                tempTrigger.type = getString((Element)ttype.item(0));
              }
              else
              {
                tempTrigger.type = "single";
              }
              NodeList prints = trigger.getElementsByTagName("print");
              for (l=0;l<prints.getLength();l++)
              {
                Element print = (Element)prints.item(l);
                tempTrigger.print.add(getString(print));
              }
              NodeList actions = trigger.getElementsByTagName("action");
              for (l=0;l<actions.getLength();l++)
              {
                Element action = (Element)actions.item(l);
                tempTrigger.action.add(getString(action));
              }

              tempRoom.trigger.add(tempTrigger);
            }
 
            NodeList containers = element.getElementsByTagName("container");
            for (j=0;j<containers.getLength();j++)
            {
              Element container = (Element)containers.item(j);
              String containerName = getString(container);
              tempRoom.container.put(containerName,containerName);
            }

            NodeList borders = element.getElementsByTagName("border");
            for (j=0;j<borders.getLength();j++)
            {
              Element border = (Element)borders.item(j);
              String borderdirection = getString((Element)border.getElementsByTagName("direction").item(0));
              String bordername = getString((Element)border.getElementsByTagName("name").item(0));
              tempRoom.border.put(borderdirection,bordername);
            } 
            
            /*Add this room to the rooms hashmap, put it in the generic objects hashmap, and store it's type in the objectlookup hashmap*/
            Rooms.put(tempRoom.name,tempRoom);
            Objects.put(tempRoom.name,(ZorkObject)tempRoom);
            ObjectLookup.put(tempRoom.name,"room");
          }

          /* If it's an item... */
          else if (tagType.equals("item"))
          {
            ZorkItem tempItem = new ZorkItem();

            /* Get all possible item attributes*/
            NodeList name = element.getElementsByTagName("name");
            if (name.getLength() > 0)
              tempItem.name = getString((Element)name.item(0));

            NodeList status = element.getElementsByTagName("status");
            if (status.getLength() > 0)
            {
              tempItem.status = getString((Element)status.item(0));
            }
            else
            {
              tempItem.status = "";
            }

            NodeList description = element.getElementsByTagName("description");
            if (description.getLength()>0)
              tempItem.description = getString((Element)description.item(0));

            NodeList writing = element.getElementsByTagName("writing");
            if (writing.getLength()>0)
              tempItem.writing = getString((Element)writing.item(0));

            NodeList turnon = element.getElementsByTagName("turnon");
            if (turnon.getLength()>0)
            {
              NodeList prints = element.getElementsByTagName("print");
              for(j=0;j<prints.getLength();j++)
              {
                tempItem.turnOnPrint.add(getString((Element)prints.item(j)));
              }
              NodeList actions = element.getElementsByTagName("action");
              for(j=0;j<actions.getLength();j++)
              {
                tempItem.turnOnAction.add(getString((Element)actions.item(j)));
              }
              
            }

            NodeList triggers = element.getElementsByTagName("trigger");
            for (j=0;j<triggers.getLength();j++)
            {
              ZorkTrigger tempTrigger = new ZorkTrigger();
              Element trigger = (Element)triggers.item(j);
              NodeList commands = trigger.getElementsByTagName("command");
              for (l=0;l<commands.getLength();l++)
              {
                Element command = (Element)commands.item(l);
                ZorkCommand tempCommand = new ZorkCommand();
                tempCommand.command = getString(command);
                tempTrigger.conditions.add(tempCommand);
                tempTrigger.hasCommand = true;
              }
              NodeList conditions = trigger.getElementsByTagName("condition");
              for (l=0;l<conditions.getLength();l++)
              {
                Element condition = (Element)conditions.item(l);
                NodeList object = condition.getElementsByTagName("object");
                NodeList has = condition.getElementsByTagName("has");
                if (has.getLength() > 0)
                {
                  ZorkConditionHas tempConditionHas = new ZorkConditionHas();
                  tempConditionHas.has = getString((Element)has.item(0));
                  tempConditionHas.object = getString((Element)object.item(0));
                  NodeList owner = condition.getElementsByTagName("owner");
                  tempConditionHas.owner = getString((Element)owner.item(0));
                  tempTrigger.conditions.add(tempConditionHas);

                }
                else
                {
                  ZorkConditionStatus tempConditionStatus = new ZorkConditionStatus();
                  tempConditionStatus.object = getString((Element)object.item(0));
                  NodeList sstatus = condition.getElementsByTagName("status");
                  tempConditionStatus.status = getString((Element)sstatus.item(0));
                  tempTrigger.conditions.add(tempConditionStatus);
                }
                
              }
              NodeList ttype = element.getElementsByTagName("type");
              if (ttype.getLength() > 0)
              {
                tempTrigger.type = getString((Element)ttype.item(0));
              }
              else
              {
                tempTrigger.type = "single";
              }
              NodeList prints = trigger.getElementsByTagName("print");
              for (l=0;l<prints.getLength();l++)
              {
                Element print = (Element)prints.item(l);
                tempTrigger.print.add(getString(print));
              }
              NodeList actions = trigger.getElementsByTagName("action");
              for (l=0;l<actions.getLength();l++)
              {
                Element action = (Element)actions.item(l);
                tempTrigger.action.add(getString(action));
              }

              tempItem.trigger.add(tempTrigger);
            }
          
            /* Put each item in the items hashmap, the generic objects hashmap, and store its type in objectlookup*/
            Items.put(tempItem.name,tempItem);
            Objects.put(tempItem.name,(ZorkObject)tempItem);
            ObjectLookup.put(tempItem.name,"item");
          
          }

          /* If it's a container... */
          else if (tagType.equals("container"))
          {
            ZorkContainer tempCont = new ZorkContainer();

            /*Get all possible container attributes*/

            NodeList name = element.getElementsByTagName("name");
            if (name.getLength()>0)
              tempCont.name = getString((Element)name.item(0));

            NodeList status = element.getElementsByTagName("status");
            if (status.getLength()>0)
              tempCont.status = getString((Element)status.item(0));
            
            /*Initially assume a closed container*/
            tempCont.isOpen = false;
            NodeList description = element.getElementsByTagName("description");
            if (description.getLength()>0)
              tempCont.description = getString((Element)description.item(0));

            NodeList accepts = element.getElementsByTagName("accept");
            for(j=0;j<accepts.getLength();j++)
            {
              /* If container has an accepts attribute, then it is always open*/
              tempCont.isOpen = true;
              tempCont.accept.add(getString((Element)accepts.item(j)));
            }
            
            NodeList citems = element.getElementsByTagName("item");
            for (j=0;j<citems.getLength();j++)
            {
              Element item = (Element)citems.item(j);
              String itemName = getString(item);
              tempCont.item.put(itemName,itemName);
            }

            NodeList triggers = element.getElementsByTagName("trigger");
            for (j=0;j<triggers.getLength();j++)
            {
              ZorkTrigger tempTrigger = new ZorkTrigger();
              Element trigger = (Element)triggers.item(j);
              NodeList commands = trigger.getElementsByTagName("command");
              for (l=0;l<commands.getLength();l++)
              {
                Element command = (Element)commands.item(l);
                ZorkCommand tempCommand = new ZorkCommand();
                tempCommand.command = getString(command);
                tempTrigger.conditions.add(tempCommand);
                tempTrigger.hasCommand = true;
              }
              NodeList conditions = trigger.getElementsByTagName("condition");
              for (l=0;l<conditions.getLength();l++)
              {
                Element condition = (Element)conditions.item(l);
                NodeList object = condition.getElementsByTagName("object");
                NodeList has = condition.getElementsByTagName("has");
                if (has.getLength() > 0)
                {
                  ZorkConditionHas tempConditionHas = new ZorkConditionHas();
                  tempConditionHas.has = getString((Element)has.item(0));
                  tempConditionHas.object = getString((Element)object.item(0));
                  NodeList owner = condition.getElementsByTagName("owner");
                  tempConditionHas.owner = getString((Element)owner.item(0));
                  tempTrigger.conditions.add(tempConditionHas);

                }
                else
                {
                  ZorkConditionStatus tempConditionStatus = new ZorkConditionStatus();
                  tempConditionStatus.object = getString((Element)object.item(0));
                  NodeList sstatus = condition.getElementsByTagName("status");
                  tempConditionStatus.status = getString((Element)sstatus.item(0));
                  tempTrigger.conditions.add(tempConditionStatus);
                }
                
              }
              NodeList ttype = element.getElementsByTagName("type");
              if (ttype.getLength() > 0)
              {
                tempTrigger.type = getString((Element)ttype.item(0));
              }
              else
              {
                tempTrigger.type = "single";
              }
              NodeList prints = trigger.getElementsByTagName("print");
              for (l=0;l<prints.getLength();l++)
              {
                Element print = (Element)prints.item(l);
                tempTrigger.print.add(getString(print));
              }
              NodeList actions = trigger.getElementsByTagName("action");
              for (l=0;l<actions.getLength();l++)
              {
                Element action = (Element)actions.item(l);
                tempTrigger.action.add(getString(action));
              }

              tempCont.trigger.add(tempTrigger);
            }

            /* Put each container in the containers hashmap, the generic object hashmap, and the objectlookup hashmap*/
            Containers.put(tempCont.name,tempCont);
            Objects.put(tempCont.name,(ZorkObject)tempCont);
            ObjectLookup.put(tempCont.name,"container");
          }

          /* And finally, if it's a creature...*/
          else if (tagType.equals("creature"))
          {
            ZorkCreature tempCreature = new ZorkCreature();

            /* Get all possible creature attributes*/

            NodeList name = element.getElementsByTagName("name");
            if (name.getLength()>0)
              tempCreature.name = getString((Element)name.item(0));

            NodeList status = element.getElementsByTagName("status");
            if (status.getLength()>0)
              tempCreature.status = getString((Element)status.item(0));

            NodeList description = element.getElementsByTagName("description");
            if (description.getLength()>0)
              tempCreature.description = getString((Element)description.item(0));

            NodeList vulns = element.getElementsByTagName("vulnerability");
            for(j=0;j<vulns.getLength();j++)
            {
              String vulnString = getString((Element)vulns.item(j));
              tempCreature.vulnerability.put(vulnString,vulnString);
            }

            NodeList attacks = element.getElementsByTagName("attack");
            for (j=0;j<attacks.getLength();j++)
            {
              Element attack = (Element)attacks.item(j);
              NodeList conditions = attack.getElementsByTagName("condition");
              for (l=0;l<conditions.getLength();l++)
              {
                Element condition = (Element)conditions.item(l);
                NodeList object = condition.getElementsByTagName("object");
                NodeList has = condition.getElementsByTagName("has");
                if (has.getLength() > 0)
                {
                  ZorkConditionHas tempConditionHas = new ZorkConditionHas();
                  tempConditionHas.has = getString((Element)has.item(0));
                  tempConditionHas.object = getString((Element)object.item(0));
                  NodeList owner = condition.getElementsByTagName("owner");
                  tempConditionHas.owner = getString((Element)owner.item(0));
                  tempCreature.conditions.add(tempConditionHas);

                }
                else
                {
                  ZorkConditionStatus tempConditionStatus = new ZorkConditionStatus();
                  tempConditionStatus.object = getString((Element)object.item(0));
                  NodeList sstatus = condition.getElementsByTagName("status");
                  tempConditionStatus.status = getString((Element)sstatus.item(0));
                  tempCreature.conditions.add(tempConditionStatus);
                }
                
              }
              NodeList prints = attack.getElementsByTagName("print");
              for (l=0;l<prints.getLength();l++)
              {
                Element print = (Element)prints.item(l);
                tempCreature.print.add(getString(print));
              }
              NodeList actions = attack.getElementsByTagName("action");
              for (l=0;l<actions.getLength();l++)
              {
                Element action = (Element)actions.item(l);
                tempCreature.action.add(getString(action));
              }

            }

            NodeList triggers = element.getElementsByTagName("trigger");
            for (j=0;j<triggers.getLength();j++)
            {
              ZorkTrigger tempTrigger = new ZorkTrigger();
              Element trigger = (Element)triggers.item(j);
              NodeList commands = trigger.getElementsByTagName("command");
              for (l=0;l<commands.getLength();l++)
              {
                Element command = (Element)commands.item(l);
                ZorkCommand tempCommand = new ZorkCommand();
                tempCommand.command = getString(command);
                tempTrigger.conditions.add(tempCommand);
                tempTrigger.hasCommand = true;
              }
              NodeList conditions = trigger.getElementsByTagName("condition");
              for (l=0;l<conditions.getLength();l++)
              {
                Element condition = (Element)conditions.item(l);
                NodeList object = condition.getElementsByTagName("object");
                NodeList has = condition.getElementsByTagName("has");
                if (has.getLength() > 0)
                {
                  ZorkConditionHas tempConditionHas = new ZorkConditionHas();
                  tempConditionHas.has = getString((Element)has.item(0));
                  tempConditionHas.object = getString((Element)object.item(0));
                  NodeList owner = condition.getElementsByTagName("owner");
                  tempConditionHas.owner = getString((Element)owner.item(0));
                  tempTrigger.conditions.add(tempConditionHas);

                }
                else
                {
                  ZorkConditionStatus tempConditionStatus = new ZorkConditionStatus();
                  tempConditionStatus.object = getString((Element)object.item(0));
                  NodeList sstatus = condition.getElementsByTagName("status");
                  tempConditionStatus.status = getString((Element)sstatus.item(0));
                  tempTrigger.conditions.add(tempConditionStatus);
                }
                
              }
              NodeList ttype = element.getElementsByTagName("type");
              if (ttype.getLength() > 0)
              {
                tempTrigger.type = getString((Element)ttype.item(0));
              }
              else
              {
                tempTrigger.type = "single";
              }
              NodeList prints = trigger.getElementsByTagName("print");
              for (l=0;l<prints.getLength();l++)
              {
                Element print = (Element)prints.item(l);
                tempTrigger.print.add(getString(print));
              }
              NodeList actions = trigger.getElementsByTagName("action");
              for (l=0;l<actions.getLength();l++)
              {
                Element action = (Element)actions.item(l);
                tempTrigger.action.add(getString(action));
              }

              tempCreature.trigger.add(tempTrigger);
            }
             
            /* Put each creature in the creatures hashmap, the generic object hashmap, and the objectlookup hashmap*/
            Creatures.put(tempCreature.name,tempCreature);
            Objects.put(tempCreature.name,(ZorkObject)tempCreature);
            ObjectLookup.put(tempCreature.name,"creature");
          }
            
        }
      }
    }
    catch (Exception e)
    {
      System.out.println("Invalid XML file, exiting");
      System.exit(-1);
      //e.printStackTrace();
    }

    /*Phew, we're finally done with that ... let's get playing!!*/

    /* Some temporary initialization variables*/
    String tempString;
    ZorkContainer tempContainer;
    ZorkTrigger tempTrigger;
    currentRoom = "Entrance";
    boolean skip = false;

 
    /* Print out the first entrance description, starting the game!*/
    System.out.println(Rooms.get(currentRoom).description);
    
    /* There is no stopping in Zork, until we're done!!*/ 
    while(true)
    {
      skip=false;
      userInput = source.nextLine();

      /*Now that we have the user command, check the input*/
      skip = checkAllTriggers();
 
      /*We only skip if a matched trigger overwrites the execution of a command*/ 
      if (skip)
      {
        continue;
      }

      /* If we haven't skipped, perform the user action*/
      action(userInput);

      /* Clear the user input, and check the triggers again (various states have changed, gnomes need to be found!*/
      userInput = "";
      checkAllTriggers();
    }
  }

  /* Execute a user action or an action command from some <action> element that is not one of the "Special Commands"*/
  public void action(String input)
  {
    int i,j,k,l,x,y,z;
    String tempString;
    ZorkContainer tempContainer;

    /* Movement */
    if (input.equals("n") || input.equals("s") || input.equals("e") || input.equals("w"))
    {
      move(input);
    }
    /* Inventory */
    else if (input.equals("i"))
    {
      inventory();
    }
    /* Take */
    else if (input.startsWith("take") && input.split(" ").length>=1)
    {
      tempString = input.split(" ")[1];
      if ((Rooms.get(currentRoom)).item.get(tempString) != null)
      {
        Inventory.put(tempString,tempString);
        ZorkRoom tempRoom = (Rooms.get(currentRoom));
        tempRoom.item.remove(tempString);
        Rooms.put(tempRoom.name,tempRoom);
        System.out.println("Item "+tempString+" added to inventory.");
      }
      else
      {
        /*Search all containers in the current room for the item!*/
        boolean found=false;
        for (String key : Rooms.get(currentRoom).container.keySet()) 
        {
          tempContainer = Containers.get(key); 
          if (tempContainer != null && tempContainer.isOpen && tempContainer.item.get(tempString) != null)
          {
            Inventory.put(tempString,tempString);
            tempContainer.item.remove(tempString);
            Containers.put(tempContainer.name,tempContainer);
            System.out.println("Item "+tempString+" added to inventory.");
            found=true;
            break;
          }
        }
        if (!found)
          System.out.println("Error");
      }
    }
    /* Open Exit (you should be so lucky)*/
    else if (input.equals("open exit"))
    {
      if (Rooms.get(currentRoom).type.equals("exit"))
      {
        System.out.println("Game Over");
        System.exit(0);
      }
      else
      {
        System.out.println("Error");
      }
    }
    /* Open a container */
    else if (input.startsWith("open") && input.split(" ").length>=1)
    {
      tempString = input.split(" ")[1];
      String found = Rooms.get(currentRoom).container.get(tempString);
      if (found != null)
      {
        tempContainer = Containers.get(tempString);
        tempContainer.isOpen = true;
        containerInventory(tempContainer.item,tempString);
      }
      else
      {
        System.out.println("Error");
      }
    }
    /* Read an object */
    else if (input.startsWith("read") && input.split(" ").length>=1)
    {
      tempString = input.split(" ")[1];
      ZorkItem tempItem;
      if (Inventory.get(tempString) != null)
      {
        tempItem = Items.get(tempString);
        if (tempItem.writing != null && tempItem.writing != "")
        {
          System.out.println(tempItem.writing); 
        }
        else
        {
          System.out.println("Nothing written.");
        }
      }
      else
      {
        System.out.println("Error");
      }
    }    
    /* Drop an item*/
    else if (input.startsWith("drop") && input.split(" ").length>=1)
    {
      tempString = input.split(" ")[1];
      if (Inventory.get(tempString) != null)
      {
        ZorkRoom tempRoom = Rooms.get(currentRoom);
        tempRoom.item.put(tempString,tempString);
        Rooms.put(tempRoom.name,tempRoom);
        Inventory.remove(tempString);
        System.out.println(tempString+" dropped.");
      }
      else
      {
        System.out.println("Error");
      }
    }
    /* Put an item somewhere */
    else if (input.startsWith("put") && input.split(" ").length>=4)
    {
      tempString = input.split(" ")[1];
      String destination = input.split(" ")[3];
      if (Rooms.get(currentRoom).container.get(destination) != null && Containers.get(destination).isOpen && Inventory.get(tempString) != null)
      {
        tempContainer = Containers.get(destination);
        tempContainer.item.put(tempString,tempString);
        Inventory.remove(tempString);
        System.out.println("Item "+tempString+" added to "+destination+".");
      }
      else
      {
        System.out.println("Error");
      }
    }
    /* Turn on an item*/
    else if (input.startsWith("turn on") && input.split(" ").length>=3)
    {
      tempString = input.split(" ")[2];
      ZorkItem tempItem;
      if (Inventory.get(tempString) != null)
      {
        tempItem = Items.get(tempString);
        System.out.println("You activate the "+tempString+".");
        if (tempItem != null) 
        {
          for (y=0;y<tempItem.turnOnPrint.size();y++)
          {
            System.out.println(tempItem.turnOnPrint.get(y));
          }
          for (y=0;y<tempItem.turnOnAction.size();y++)
          {
            performAction(tempItem.turnOnAction.get(y));
          }
        }
        else
        {
          System.out.println("Error");
        }
      }
      else
      {
        System.out.println("Error");
      }

    }
    /* Attempt an attack, you feeling lucky?*/
    else if (input.startsWith("attack") && input.split(" ").length>=4)
    {
      tempString = input.split(" ")[1];
      ZorkCreature tempCreature; 
      String weapon = input.split(" ")[3];
      if (Rooms.get(currentRoom).creature.get(tempString) != null)
      {
        tempCreature = Creatures.get(tempString);
        if (tempCreature != null && Inventory.get(weapon)!= null)
        {
          if (tempCreature.attack(this,weapon))
          {
            System.out.println("You assault the "+tempString+" with the "+weapon+".");
            for (y=0;y<tempCreature.print.size();y++)
            {
              System.out.println(tempCreature.print.get(y));
            }
            for (y=0;y<tempCreature.action.size();y++)
            {
              performAction(tempCreature.action.get(y));
            }
          }
          else
          {
            System.out.println("Error");
          } 
        }
        else
        {
          System.out.println("Error");
        }
      }
      else
          System.out.println("Error");
    }
    /* Invalid command*/
    else
    {
      System.out.println("Error");
    }
    return;
  }


  /* Get a string from an element (XML parsing stuff)*/
  public static String getString(Element e) 
  {
     Node child = e.getFirstChild();
     if (child instanceof CharacterData) 
     {
       CharacterData cd = (CharacterData) child;
       return cd.getData();
     }
     return "?";
  }

  /* Check triggers */
  public boolean checkAllTriggers()
  {
 
    /*Variable initialization*/
    boolean skip=false;
    int i,j,k,l,x,y,z;
    ZorkTrigger tempTrigger;
    ZorkContainer tempContainer;

    /*Check Room triggers*/
    for(x=0;x<Rooms.get(currentRoom).trigger.size();x++)
    {
      tempTrigger=Rooms.get(currentRoom).trigger.get(x);
      if (tempTrigger.evaluate(this))
      {
        for (y=0;y<tempTrigger.print.size();y++)
        {
          System.out.println(tempTrigger.print.get(y));
        }
        for (y=0;y<tempTrigger.action.size();y++)
        {
          performAction(tempTrigger.action.get(y));
        }
        if (tempTrigger.hasCommand)
        {
          skip = true;
        }
        if (tempTrigger.type.equals("single"))
        {
          Rooms.get(currentRoom).trigger.remove(x);
        }
      }
    }

    /* Check items in the containers in the room */
    for(String key: Rooms.get(currentRoom).container.keySet())
    {
      tempContainer = Containers.get(key);
      for(String key2: tempContainer.item.keySet())
      {
        ZorkItem tempItem = Items.get(key2);
        for(x=0;x<tempItem.trigger.size();x++)
        {
          tempTrigger = tempItem.trigger.get(x);
          if (tempTrigger.evaluate(this))
          {
            for (y=0;y<tempTrigger.print.size();y++)
            {
              System.out.println(tempTrigger.print.get(y));
            }
            for (y=0;y<tempTrigger.action.size();y++)
            {
              performAction(tempTrigger.action.get(y));
            }
            if (tempTrigger.hasCommand)
            {
              skip = true;
            }
            if (tempTrigger.type.equals("single"))
            {
              tempItem.trigger.remove(x);
            }
          }
        }
      }
       
      /* Check all containers in the room*/
      for(x=0;x<tempContainer.trigger.size();x++)
      {
        tempTrigger = tempContainer.trigger.get(x);
        if (tempTrigger.evaluate(this))
        {
          for (y=0;y<tempTrigger.print.size();y++)
          {
            System.out.println(tempTrigger.print.get(y));
          }
          for (y=0;y<tempTrigger.action.size();y++)
          {
            performAction(tempTrigger.action.get(y));
          }
          if (tempTrigger.hasCommand)
          {
            skip = true;
          }
          if (tempTrigger.type.equals("single"))
          {
            tempContainer.trigger.remove(x);
          }
        }
      }
    }

    /* Check all creatures in the room */
    for(String key: Rooms.get(currentRoom).creature.keySet())
    {
      ZorkCreature tempCreature = Creatures.get(key);
      for(x=0;x<tempCreature.trigger.size();x++)
      {
        tempTrigger = tempCreature.trigger.get(x);
        if (tempTrigger.evaluate(this))
        {
          for (y=0;y<tempTrigger.print.size();y++)
          {
            System.out.println(tempTrigger.print.get(y));
          }
          for (y=0;y<tempTrigger.action.size();y++)
          {
            performAction(tempTrigger.action.get(y));
          }
          if (tempTrigger.hasCommand)
          {
            skip = true;
          }
          if (tempTrigger.type.equals("single"))
          {
            tempCreature.trigger.remove(x);
          }
        }
      }
    }

    /* Check items in inventory */
    for(String key: Inventory.keySet())
    {
      ZorkItem tempItem = Items.get(key);
      for(x=0;x<tempItem.trigger.size();x++)
      {
        tempTrigger = tempItem.trigger.get(x);
        if (tempTrigger.evaluate(this))
        {
          for (y=0;y<tempTrigger.print.size();y++)
          {
            System.out.println(tempTrigger.print.get(y));
          }
          for (y=0;y<tempTrigger.action.size();y++)
          {
            performAction(tempTrigger.action.get(y));
          }
          if (tempTrigger.hasCommand)
          {
            skip = true;
          }
          if (tempTrigger.type.equals("single"))
          {
            tempItem.trigger.remove(x);
          }
        }
      }
    }

    /* Check items in room */
    for(String key: Rooms.get(currentRoom).item.keySet())
    {
      ZorkItem tempItem = Items.get(key);
      for(x=0;x<tempItem.trigger.size();x++)
      {
        tempTrigger = tempItem.trigger.get(x);
        if (tempTrigger.evaluate(this))
        {
          for (y=0;y<tempTrigger.print.size();y++)
          {
            System.out.println(tempTrigger.print.get(y));
          }
          for (y=0;y<tempTrigger.action.size();y++)
          {
            performAction(tempTrigger.action.get(y));
          }
          if (tempTrigger.hasCommand)
          {
            skip = true;
          }
          if (tempTrigger.type.equals("single"))
          {
            tempItem.trigger.remove(x);
          }
        }
      }
    }
    return skip;
  }

  /*Basic movement function */
  public void move(String direction)
  {
    String fullDirection = "";
    String destination="";
    if (direction.equals("n"))
    {
      fullDirection="north";
    }
    else if (direction.equals("s"))
    {
      fullDirection="south";
    }
    else if (direction.equals("e"))
    {
      fullDirection="east";
    }
    else if (direction.equals("w"))
    {
      fullDirection="west";
    }
     
    destination = (Rooms.get(currentRoom)).border.get(fullDirection);
    if (destination != null)
    {
      currentRoom = destination;
      System.out.println(Rooms.get(currentRoom).description);
    }
    else
    {
      System.out.println("Can't go that way.");
    }
  }

  /* This is used to perform the "Special Actions"*/
  public void performAction(String action)
  {
    String object;
    String objectType;
    /* Update: figure out what type of item it is, and then change it's status*/
    if (action.startsWith("Update"))
    {
      object = action.split(" ")[1];
      String newStatus = action.split(" ")[3];

      objectType = ObjectLookup.get(object);
      if (objectType.equals("room"))
      {
        ZorkRoom tempRoom = Rooms.get(object);
        tempRoom.status = newStatus;
        Rooms.put(tempRoom.name,tempRoom);
      }
      else if (objectType.equals("container"))
      {
        ZorkContainer tempContainer = Containers.get(object);
        tempContainer.status = newStatus;
        Containers.put(tempContainer.name,tempContainer);

      }
      else if (objectType.equals("creature"))
      {
        ZorkCreature tempCreature = Creatures.get(object);
        tempCreature.status = newStatus;
        Creatures.put(tempCreature.name,tempCreature);

      }
      else if (objectType.equals("item"))
      {
        ZorkItem tempItem = Items.get(object);
        tempItem.status = newStatus;
        Items.put(tempItem.name,tempItem);

      }
      
    }
    /*Game Over: pretty straight forward*/
    else if (action.equals("Game Over"))
    {
      System.out.println("Victory!");
      System.exit(0);
    }

    /* Add: figure out what type the destination is, then what type the object is.  Then add object to destination if it makes sense */
    else if (action.startsWith("Add"))
    {
      String destination = action.split(" ")[3];
      object = action.split(" ")[1];
      objectType = ObjectLookup.get(object);
      String destinationType = ObjectLookup.get(destination);
      if (destinationType.equals("room"))
      {
        ZorkRoom tempRoom = Rooms.get(destination);
        if (objectType.equals("item"))
          tempRoom.item.put(object,object);
        else if (objectType.equals("creature"))
          tempRoom.creature.put(object,object);
        else if (objectType.equals("container"))
          tempRoom.container.put(object,object);
        else
          System.out.println("Error");
        Rooms.put(tempRoom.name,tempRoom);
      }
      else if (destinationType.equals("container"))
      {
        ZorkContainer tempContainer = Containers.get(destination);
        if (objectType.equals("item"))
          tempContainer.item.put(object,object);
        else
          System.out.println("Error");
        Containers.put(tempContainer.name,tempContainer);
      }
      else
      {
        System.out.println("Error");
      }
    }

    /* Delete: figure out what object it is and delete it accordingly.  Rooms are especially tricky */ 
    else if (action.startsWith("Delete"))
    {
      object = action.split(" ")[1];
      objectType = ObjectLookup.get(object);
      Objects.remove(object);
      if (objectType.equals("room"))
      {
        ZorkRoom tempRoom;
        for (String key : Rooms.keySet()) 
        {
          tempRoom = Rooms.get(key);
          for (String key2 : tempRoom.border.keySet())
          { 
            if (tempRoom.border.get(key2).equals(object))
            {
              tempRoom.border.remove(key2);
            }
          }
          Rooms.put(tempRoom.name,tempRoom);
        }
      }
      else if (objectType.equals("item"))
      {
        ZorkRoom tempRoom;
        for (String key : Rooms.keySet()) 
        {
          tempRoom = Rooms.get(key);
          if (tempRoom.item.get(object) != null)
          {
            tempRoom.item.remove(object);
            Rooms.put(tempRoom.name,tempRoom);
          }
        }
        ZorkContainer tempContainer;
        for (String key : Containers.keySet())
        {
          tempContainer = Containers.get(key);
          if (tempContainer.item.get(object) != null)
          {
            tempContainer.item.remove(object);
            Containers.put(tempContainer.name,tempContainer);
          }
        }
      }
      else if (objectType.equals("container"))
      {
        ZorkRoom tempRoom;
        for (String key : Rooms.keySet()) 
        {
          tempRoom = Rooms.get(key);
          if (tempRoom.container.get(object) != null)
          {
            tempRoom.container.remove(object);
            Rooms.put(tempRoom.name,tempRoom);
          }
        }
      }
      else if (objectType.equals("creature"))
      {
        ZorkRoom tempRoom;
        for (String key : Rooms.keySet()) 
        {
          tempRoom = Rooms.get(key);
          if (tempRoom.creature.get(object) != null)
          {
            tempRoom.creature.remove(object);
            Rooms.put(tempRoom.name,tempRoom);
          }
        }
      }
    }
    else
    {
      /*If it's not a "Special Action", just treat it normally */
      userInput = action;
      action(action);
    }
  }

  /* Print out the what's in a container when it's been opened*/
  public void containerInventory(HashMap<String,String> Container, String Name)
  {
    String output = "";
    if (Container.isEmpty())
    {
      System.out.println(Name+" is empty");
    }
    else
    {
      System.out.print(Name+" contains ");
      for (String key : Container.keySet()) 
      {
        output += key+", "; 
      }
      output = output.substring(0,output.length()-2);
      System.out.println(output+".");
    }
  }

  /* Print out the inventory when user types i */
  public void inventory()
  {
    String output = "Inventory: ";
    if (Inventory.isEmpty())
    {
      System.out.println("Inventory: empty");
    }
    else
    {
      for (String key : Inventory.keySet()) 
      {
        output += key+", "; 
      }
      output = output.substring(0,output.length()-2);
      System.out.println(output);
    }
  }


  /* I love how basic java main functions are sometimes.*/
  public static void main(String[] args)
  {
    if (args.length != 1)
    {
      System.out.println("Usage: java Zork [filename]");
      return;
    }
    new Zork(args[0]); 
  }
}