//Nathan Viniconis //CSE293 //Database class.. Handles all info.. import java.io.*; import java.net.*; import java.util.*; import java.lang.reflect.*; //***************PLAYER****************** //boolean SeeIfLoginMatches(String Pname, String Ppass) //boolean SetPlayerToRoom(String Pname, String RoomID) //boolean SetPlayerToRoom(String Pname, String RoomID, int x, int y) //String GetPlayersRoom(String PName) //boolean IsPlayerLoggedIn(String Pname) //void removePlayer(String Pname) //void addUserInfo(String Pname, String userIP) //String GetAllIPs() //String getAllPlayers() //String getRoomPlayers(String RoomID) //String getPlayerStats(String Pname) //boolean SetAllPlayersStats(String Pname,String Stats) //boolean ChangeAStat(String Pname, int stat, long value) //void MakeGod(String Pname) //void MakePlayer(String Pname) //void AddItemToPlayer(String Pname,String ObjectID) //String getItemsHeld(String Pname) //boolean RemoveItemFromPlayer(String Pname, String ObjectID) //boolean MovePlayerTo(String Pname, int x, int y, int rot) //String GetImageInforForPlayers(String RoomID) //String GetPlayersBarRoomID() //long GetMoneyOnPlayer(String Pname) //String getDeadPlayers() //***************CHAT********************** //Vector getNewChat(int cG, String Pname,int cP, String RoomID,int cR) //void addRoomChat(String RoomID, String message) //void addGlobalChat(String chatIN) //boolean addPlayerChat(String Pname, String message) //int getRoomChatSize(String RoomID) //int getPlayerChatSize(String Pname) //int getGlobalChatSize() //***************ROOM************************* //boolean SeeIfRoomExists(String RoomID) //String GetWorld() //String GetAllRoomsForSteve() //String GetItemsInRoom(String RoomID) //String GetItemsInRoom(String RoomID, int type) //0 for structure, 1 for normal items.. //boolean RemoveItem(String RoomID,String ObjectID) //boolean RemoveItem(String RoomID,String ObjectID, int x, int y) //boolean AddItem(String RoomID, String ObjectID) //boolean AddItem(String RoomID, String ObjectID, int x, int y, int pos, int type) //**************MONSTER********************** //boolean AddMonster(int type) //boolean RemoveMonster(String RoomID) //String getMItemsHeld(int uid) //String getRoomMonsters(String RoomID) //String GetAllMonsters() //void attackPlayers(String AllMonsters) //void MoveAllCreatures() //String GetMonstersBarRoomID() //String GetMonstersUIDBarRoomID() //boolean SeeIfMonsterAlive(int uid) //boolean SeeIfMonsterDead(int uid) //long getMonsterExp(int uid) //void SetMaxCreatures(int num) //boolean SeeIfNeedsMoreCreatures() //boolean KillMonster(String uID) //boolean SeeIfNeedsMoreCreatures() //String getDeadMonsters() //boolean ChangeMonsterStat(int uID,int stat,long value) //String getMonsterStats(String Mname) //String GetMonstersInRoom(String RoomID) //String GetMonstersInRoomWrot(String RoomID) public class DataBase { Canvas canvas; private Lock ChatLock = new Lock(); private Lock PlayerLock = new Lock(); private Lock RoomLock = new Lock(); private Lock MonsterLock = new Lock(); //************** ROOM LOCK ************************* //Used as a holder for raw rooms read by ReadFromFile private Vector initialROOMvector = new Vector(); //Holds a printable version of the world with astriks's private String World = new String(); //Holds all the current rooms. all manipulations happen here private Vector workingROOMvector = new Vector(); //*********************************************** private ReadFromFile readFromFile; //************** PLAYER LOCK ************************ //Holds all the players that have previously created accounts private Vector AllPlayerVector = new Vector(); //Holds all players currently in the world private Vector workingPlayerVector = new Vector(); //List of the IP's of the Users.. private Vector workingIPvector = new Vector(); //*************************************************** private ReadFromFile readFromFile2; //************** Chat LOCK ************************* //Holds all the chat for the game... should free up mem at some point private Vector workingChatVector = new Vector(); //************************************************** //************** Monster LOCK ********************** //Holds all of the monsters in the game.. private Vector AllMonsterVector = new Vector(); //Holds all of the monsters currently active... private Vector workingMonsterVector = new Vector(); private int MaxCreatures = 0; //max creatures private int NumMon = 0; //current creatures private int TallyMon = 0; //tally of creatures(for unique ID) //************************************************** private ReadFromFile readFromFile3; //******************************************************* //Initializes the rooms from the file Fname(from TheMain) DataBase(String Fname,String Fname2,String Fname3) { System.out.println("Initializing Database"); //reading in the 2 files... world and player files readFromFile = new ReadFromFile(Fname,0); readFromFile2 = new ReadFromFile(Fname2,1); readFromFile3 = new ReadFromFile(Fname3,2); //store the "everyone" vectors into some temp variables.. initialROOMvector = readFromFile.GetROOMs(); AllPlayerVector = readFromFile2.GetPlayers(); AllMonsterVector = readFromFile3.GetMonsters(); //Initializes a 10x10 array.. 0-99... 0-9 on the first line.. 10-19 on second.. etc.. //ROOMarray.newInstance(ROOM iamaroom,100); initializeVector(); finalizeVector(); SetPrintableWorld(); } public void SetCanvas(Canvas CanvasIN) { canvas = CanvasIN; } //***************************************************************************** //*********************MONSTER FUNCTIONS*************************************** //***************************************************************************** //******************************************************** //Gets the Items Held by the monster //******************************************* //Gets all the objects a player is holding... public String getMItemsHeld(int uid) { int PlayerPos = 0; int count = 0; boolean found = false; String AllItems = new String(); MonsterLock.lock(); while(count < workingMonsterVector.size() && found == false ) { if( ((Monsters)workingMonsterVector.elementAt(count)).GetUID() == uid) { PlayerPos = count; found = true; } count++; } //Add the item to the player.. AllItems = ((Monsters)workingMonsterVector.elementAt(PlayerPos)).getItems(); MonsterLock.releaseLock(); return(AllItems); } //********************************************************* //Gets all the players currently in the selected room in name|name2|name3 format public String getRoomMonsters(String RoomID) { int count = 0; boolean found = false; String roomMonsters = new String(); MonsterLock.lock(); while(count < workingMonsterVector.size()) { if( (((Monsters)workingMonsterVector.elementAt(count)).GetRoom()).equals(RoomID)) { roomMonsters = roomMonsters + (((Monsters)workingMonsterVector.elementAt(count)).getName()) + "*"; roomMonsters = roomMonsters + (((Monsters)workingMonsterVector.elementAt(count)).GetUID()) + "|"; } count++; } MonsterLock.releaseLock(); return(roomMonsters); } //********************************************************* public String GetAllMonsters() { //First get a list of all the RoomID|x|y|str from the monsters.. String Final = new String(); String cRoom = new String(); String CX = new String(); String CY = new String(); String Str = new String(); long str = 0; int cX = 0; int cY = 0; int count = 0; MonsterLock.lock(); //for each monster.. while(count < workingMonsterVector.size()) { cRoom = ((Monsters)workingMonsterVector.elementAt(count)).GetRoom(); cX = ((Monsters)workingMonsterVector.elementAt(count)).GetX(); cY = ((Monsters)workingMonsterVector.elementAt(count)).GetY(); str = ((Monsters)workingMonsterVector.elementAt(count)).GetAStat(2); Str = Long.toString(str); CX = Integer.toString(cX); CY = Integer.toString(cY); Final = Final + "|" + cRoom + "|" + cX + "|" + cY + "|" + str + "|"; count++; } MonsterLock.releaseLock(); return(Final); } //dataBase.attackPlayers(AllMonsters); //*************************************************************8 public void attackPlayers(String AllMonsters) { //********************************************** //*********** ATTACK RADIUS ******************** //********************************************** int ATTACKRADIUS = 2; int ATKMOD = 3; //lower = more damage.. 1 = 1to1 with str.. Vector VMonsters = new Vector(); Monsters monster = new Monsters(); StringTokenizer breakUP = new StringTokenizer(AllMonsters, "| "); String cToken = new String(); //all the RoomID|x|y|str from the monsters.. while(breakUP.hasMoreTokens()) { monster = new Monsters(); cToken = breakUP.nextToken(); monster.SetRoom(cToken); if(breakUP.hasMoreTokens()) { cToken = breakUP.nextToken(); monster.SetX(Integer.parseInt(cToken)); } if(breakUP.hasMoreTokens()) { cToken = breakUP.nextToken(); monster.SetY(Integer.parseInt(cToken)); } if(breakUP.hasMoreTokens()) { cToken = breakUP.nextToken(); monster.ChangeAStat(2,Long.parseLong(cToken)); } VMonsters.add(monster); } //for each player.. determine if they are next to a monster int count = 0; int i = 0; String cRoom = new String(); int cX = 0; int cY = 0; int pX = 0; int pY = 0; long cStr = 0; Random rand = new Random(); int HPtoLose = 0; int damage = 0; //Attack the player that is close to a m onster..... PlayerLock.lock(); while(count < workingPlayerVector.size()) { i = 0; while(i MAXX) { nX = MAXX; } if(nY < MINY) { nY = MINY; } else if(nY > MAXY) { nY = MAXY; } ((Monsters)workingMonsterVector.elementAt(count)).SetX(nX); ((Monsters)workingMonsterVector.elementAt(count)).SetY(nY); ((Monsters)workingMonsterVector.elementAt(count)).SetROT(dir); count++; } MonsterLock.releaseLock(); } //******************************************************** public String GetMonstersBarRoomID() { String Final = new String(); String cName = new String(); String cRoom = new String(); int count = 0; MonsterLock.lock(); while(count < workingMonsterVector.size()) { cName = ((Monsters)workingMonsterVector.elementAt(count)).getName(); cRoom = ((Monsters)workingMonsterVector.elementAt(count)).GetRoom(); Final = Final + "|" + cName + "|" + cRoom; count++; } MonsterLock.releaseLock(); return(Final); } //******************************************************** public String GetMonstersUIDBarRoomID() { String Final = new String(); String cName = new String(); String cRoom = new String(); String uID = new String(); int count = 0; MonsterLock.lock(); while(count < workingMonsterVector.size()) { cName = ((Monsters)workingMonsterVector.elementAt(count)).getName(); cRoom = ((Monsters)workingMonsterVector.elementAt(count)).GetRoom(); uID = ((Monsters)workingMonsterVector.elementAt(count)).GetUIDS(); Final = Final + "|" + cName + "|" + uID + "|" + cRoom; count++; } MonsterLock.releaseLock(); return(Final); } //*****************************************************88 public boolean SeeIfMonsterAlive(int uid) { int count = 0; long life; boolean found = false; int Mpos = 0; boolean alive = false; MonsterLock.lock(); while(count < workingMonsterVector.size()) { if(((Monsters)workingMonsterVector.elementAt(count)).GetUID() == uid) { found = true; Mpos = count; } count++; } if(found) { life = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetAStat(0); if(life > 0) { alive = true; } } MonsterLock.releaseLock(); return(alive); } //*****************************************************88 public boolean SeeIfMonsterDead(int uid) { int count = 0; long life; boolean found = false; boolean killed = false; int Mpos = 0; MonsterLock.lock(); while(count < workingMonsterVector.size()) { if(((Monsters)workingMonsterVector.elementAt(count)).GetUID() == uid) { found = true; Mpos = count; } count++; } if(found) { life = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetAStat(0); if(life < 1) { killed = true; } } MonsterLock.releaseLock(); return(killed); } //*****************************************************88 public long getMonsterExp(int uid) { int count = 0; long exp =0; boolean found = false; int Mpos = 0; MonsterLock.lock(); while(count < workingMonsterVector.size()) { if(((Monsters)workingMonsterVector.elementAt(count)).GetUID() == uid) { found = true; Mpos = count; } count++; } if(found) { exp = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetAStat(11); } MonsterLock.releaseLock(); return(exp); } //***************************************************** //Sets the max # of creatures available.. public void SetMaxCreatures(int num) { MaxCreatures = num; } //***************************************************** //Increments the number of CurrentCreatures private void AnotherCreature() { NumMon++; } //******************************************************8 //Decrements the number of Current Creatures private void BiBiCreature() { NumMon--; } //************************************************* //Sees if more can be added public boolean SeeIfNeedsMoreCreatures() { if(NumMon < MaxCreatures) { return(true); } else{ return(false); } } //***************************************** //Returns the current # of creatures.. //****************************************************** //Kills a monster... public boolean KillMonster(String uID) { int count = 0; boolean found = false; int Mpos = 0; String Item = new String(); int itemx = 0; int itemy = 0; int x=0; int y=0; int pos = 0; Random rand = new Random(); String ItemsToDrop = new String(); String RoomID = new String(); MonsterLock.lock(); while(count < workingMonsterVector.size() && !found) { if( ((Monsters)workingMonsterVector.elementAt(count)).GetUIDS().equals(uID)) { Mpos = count; found = true; } count++; } //drop the creatures items on the ground... if(found) { ItemsToDrop = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetMonsterItems(); x = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetX(); y = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetY(); RoomID = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetRoom(); } StringTokenizer BreakUP = new StringTokenizer(ItemsToDrop, " |"); //remove the happy monster.. if(found) { workingMonsterVector.remove(Mpos); BiBiCreature(); } MonsterLock.releaseLock(); if(found) { while(BreakUP.hasMoreTokens()) { //add the items to the ground.. Item = BreakUP.nextToken(); //Do at a X,Y.. itemx = x + rand.nextInt(3); itemy = y + rand.nextInt(3); pos = rand.nextInt(4); AddItem(RoomID,Item,itemx,itemy,pos,1); } } return(found); } //****************************************************** //Returns all the dead monsters.. public String getDeadMonsters() { int count = 0; String DeadMonsters = new String(); MonsterLock.lock(); while(count < workingMonsterVector.size()) { if( ((Monsters)workingMonsterVector.elementAt(count)).GetAStat(0) < 1) { DeadMonsters = DeadMonsters + "|" + ((Monsters)workingMonsterVector.elementAt(count)).GetUIDS(); } count++; } MonsterLock.releaseLock(); return(DeadMonsters); } //********************************************************* public boolean ChangeMonsterStat(int uID,int stat,long value) { int Mpos = 0; int count = 0; boolean found = false; //Get position of player.. MonsterLock.lock(); while(count < workingMonsterVector.size() && !found) { if( ((Monsters)workingMonsterVector.elementAt(count)).GetUID() == uID) { found = true; Mpos = count; } count++; } if(found) { ((Monsters)workingMonsterVector.elementAt(Mpos)).ChangeAStat(stat, value); } MonsterLock.releaseLock(); return(found); } //******************************************************* //Returns a Monsters current stats.. public String getMonsterStats(String Mname) { int Mpos = 0; int count = 0; boolean found = false; String ToSend = new String(); //Get position of player.. MonsterLock.lock(); while(count < workingMonsterVector.size() && !found) { if( ((Monsters)workingMonsterVector.elementAt(count)).getName().equals(Mname)) { found = true; Mpos = count; } count++; } if(found) { ToSend = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetAllStats(); } MonsterLock.releaseLock(); return(ToSend); } //******************************************************* //Returns a Monsters current stats.. public String getMonsterStats(int Mname) { int Mpos = 0; int count = 0; boolean found = false; String ToSend = new String(); //Get position of player.. MonsterLock.lock(); while(count < workingMonsterVector.size() && !found) { if( ((Monsters)workingMonsterVector.elementAt(count)).GetUID()==Mname) { found = true; Mpos = count; } count++; } if(found) { ToSend = ((Monsters)workingMonsterVector.elementAt(Mpos)).GetAllStats(); } MonsterLock.releaseLock(); return(ToSend); } //*********************************************************** //Used to get the monster data for a particular room public String GetMonstersInRoom(String RoomID) { int count = 0; boolean found = false; String roomMonsters = new String(); MonsterLock.lock(); while(count < workingMonsterVector.size()) { if( (((Monsters)workingMonsterVector.elementAt(count)).GetRoom()).equals(RoomID) ) { roomMonsters = roomMonsters + ((Monsters)workingMonsterVector.elementAt(count)).GetFormatedInfo(); } count++; } MonsterLock.releaseLock(); return(roomMonsters); } //*********************************************************** //Used to get the monster data for a particular room public String GetMonstersInRoomWrot(String RoomID) { int count = 0; boolean found = false; String roomMonsters = new String(); MonsterLock.lock(); while(count < workingMonsterVector.size()) { if( (((Monsters)workingMonsterVector.elementAt(count)).GetRoom()).equals(RoomID) ) { roomMonsters = roomMonsters + ((Monsters)workingMonsterVector.elementAt(count)).GetFormatedInfo(); roomMonsters = roomMonsters + ((Monsters)workingMonsterVector.elementAt(count)).GetROT() + "|"; } count++; } MonsterLock.releaseLock(); return(roomMonsters); } //************************************************************* //Used to add a monster of type 'type' to a randomly assigned room public boolean AddMonster(int type) { Monsters monster = new Monsters(); //Extract the monster from the vector.. Random ToMoveOrNot = new Random(); MonsterLock.lock(); if(type < AllMonsterVector.size()) { monster.SetAllStats(((Monsters)AllMonsterVector.elementAt(type)).GetAllStatsQ()); monster.setName(((Monsters)AllMonsterVector.elementAt(type)).getName()); } else { System.out.println("Error Adding Monster of type " + type); } //Make sure references are destroyed.. // AllMonsterVector = new Vector(); // AllMonsterVector = readFromFile3.GetMonsters(); //Set the room of the monster.. Random rand = new Random(); int x = rand.nextInt(4); int y = rand.nextInt(5); x++; y++; String RoomID = new String(); RoomID = "00" + Integer.toString(x); RoomID = RoomID + "-00" + Integer.toString(y); while(!SeeIfRoomExists(RoomID)) { x = rand.nextInt(4); y = rand.nextInt(5); x++;y++; RoomID = "00" + Integer.toString(x); RoomID = RoomID + "-00" + Integer.toString(y); } monster.SetRoom(RoomID); //Set the X and Y coords for the monster.. x = rand.nextInt(32) - 16; y = rand.nextInt(32) - 16; monster.SetX(x); monster.SetY(y); //Set his unique ID monster.SetUID(TallyMon); System.out.println("Monster #" + TallyMon + " Set to " + RoomID); TallyMon++; workingMonsterVector.add(monster); AnotherCreature(); MonsterLock.releaseLock(); return(true); } //***************************************************************************** //*********************PLAYER FUNCTIONS**************************************** //***************************************************************************** //************************************************************ //Regens all players in the game by some hp public void RegenPlayersHP() { int count = 0; long STA = 0; long REGEN = 0; long HP = 0; long MAXHP = 0; PlayerLock.lock(); while( count < AllPlayerVector.size()) { HP = ((Players)AllPlayerVector.elementAt(count)).GetAStat(0); MAXHP = ((Players)AllPlayerVector.elementAt(count)).GetAStat(1); STA = ((Players)AllPlayerVector.elementAt(count)).GetAStat(3); //Get amount to raise life by.. REGEN = REGEN + (long)(STA/30); //Raise by that amount.. if(HP < MAXHP) { if(REGEN + HP > MAXHP ) { REGEN = MAXHP - HP; } ((Players)AllPlayerVector.elementAt(count)).ChangeAStat(0,REGEN); } count++; } PlayerLock.releaseLock(); } //************************************************************ //Lowers over the cap HP.. public void LowerOverCapHP() { int count = 0; long STA = 0; long HP = 0; long MAXHP = 0; int REGEN = 0; PlayerLock.lock(); while( count < AllPlayerVector.size()) { STA = ((Players)AllPlayerVector.elementAt(count)).GetAStat(3); HP = ((Players)AllPlayerVector.elementAt(count)).GetAStat(0); MAXHP = ((Players)AllPlayerVector.elementAt(count)).GetAStat(1); //Get amount to raise life by.. if(HP > MAXHP) { REGEN--; //Lower by that amount.. ((Players)AllPlayerVector.elementAt(count)).ChangeAStat(0,REGEN); } count++; } PlayerLock.releaseLock(); } //Checks to see wether or not the user is registered in the game public boolean SeeIfLoginMatches(String Pname, String Ppass) { String cLine = new String(); //The current String being read StringTokenizer breakUP; boolean found = false; int count = 0; int pPos = 0; //Lock the PlayerVector + Find the position of Pname and put it in pPos PlayerLock.lock(); while( count < AllPlayerVector.size()) { //Make sure the player exists and his name = his password.. if( ((Players)AllPlayerVector.elementAt(count)).getName().equals(Pname) && ((Players)AllPlayerVector.elementAt(count)).getPass().equals(Ppass)) { //Make sure he's not already logged in if(!IsPlayerLoggedIn(Pname)) { found = true; pPos = count; } } count++; } //Add this user to the workingVector if(found) { workingPlayerVector.add( ((Players)AllPlayerVector.elementAt(pPos)) ); } PlayerLock.releaseLock(); return(found); } //******************************************************** //Changes a room a particular player is in... // by changing the RoomID variable in the players vector public boolean SetPlayerToRoom(String Pname, String RoomID) { int count = 0; int Ppos = 0; boolean found = false; //Find the position of the player, and set his room.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { //Set this players room to whatever room he is in ((Players)workingPlayerVector.elementAt(Ppos)).SetRoom(RoomID); } PlayerLock.releaseLock(); //If was successfully changed... if(found) { return(true); } else { return(false); } } //******************************************************** //Changes a room a particular player is in... // by changing the RoomID variable in the players vector public boolean SetPlayerToRoom(String Pname, String RoomID, int x, int y) { int count = 0; int Ppos = 0; boolean found = false; //Find the position of the player, and set his room.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } //Set this players room to whatever room he is in if(found) { ((Players)workingPlayerVector.elementAt(Ppos)).SetRoom(RoomID); ((Players)workingPlayerVector.elementAt(Ppos)).SetX(x); ((Players)workingPlayerVector.elementAt(Ppos)).SetY(y); } PlayerLock.releaseLock(); //If was successfully changed... if(found) { return(true); } else { return(false); } } //******************************************************* //returns the ID of the room a peticular players is in.. public String GetPlayersRoom(String PName) { int Ppos = 0; int count = 0; boolean found = false; String TheID = new String(); PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(PName)) { found = true; Ppos = count; } count++; } //if player was found, set the room he's in to TheID... if(found) { TheID = ((Players)workingPlayerVector.elementAt(Ppos)).GetRoom(); } else { TheID = "999-999"; } PlayerLock.releaseLock(); return(TheID); } //***************************************************** //Has to be used in a PlayerLock setting... private boolean IsPlayerLoggedIn(String Pname) { boolean found = false; int count = 0; //See if any of the logged in players have that particular name while( count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; } count++; } return(found); } //***************************************************** //Has to be used in a PlayerLock setting... public boolean IsPlayerLoggedin(String Pname) { boolean found = false; PlayerLock.lock(); int count = 0; //See if any of the logged in players have that particular name while( count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; } count++; } PlayerLock.releaseLock(); return(found); } //******************************************************* //Used to remove a player from the working vector.. public void removePlayer(String Pname) { boolean found = false; int count = 0; //Hone in on and DESTROY the pitiful player who's leaving this realm PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; workingPlayerVector.remove(count); } count++; } PlayerLock.releaseLock(); } //*********************************************************** //Adds this users IP and type to the assorted list of connections... public void addUserInfo(String Pname, String userIP) { int Ppos = 0; int count = 0; boolean found = false; PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } //if player was found, give him his IP and shit... if(found) { ((Players)workingPlayerVector.elementAt(Ppos)).setIP(userIP); } PlayerLock.releaseLock(); } //*********************************************************** //Returns a string of all the IP's of connected people... public String GetAllIPs() { int count = 0; String allIPs = new String(); String temp = new String(); //go through all the people, extracting all the IP information.. PlayerLock.lock(); while(count < workingPlayerVector.size()) { temp = temp.concat ( ((Players)workingPlayerVector.elementAt(count)).getIP() ).concat("\n"); count++; } PlayerLock.releaseLock(); return(temp); } //****************************************************** //Gets all the players currently active.. in name|name2|name3 format public String getAllPlayers() { int count = 0; String allPlayers = new String(); //Find every name of every player in the WORLD PlayerLock.lock(); while(count < workingPlayerVector.size()) { if( (((Players)workingPlayerVector.elementAt(count)).GetTypeString()).equals("P")) { allPlayers = allPlayers.concat( ((Players)workingPlayerVector.elementAt(count)).getName()).concat("|"); } count++; } PlayerLock.releaseLock(); return(allPlayers); } //********************************************************* //Gets all the players currently in the selected room in name|name2|name3 format public String getRoomPlayers(String RoomID) { int count = 0; boolean found = false; String roomPlayers = new String(); PlayerLock.lock(); while(count < workingPlayerVector.size()) { if( (((Players)workingPlayerVector.elementAt(count)).GetRoom()).equals(RoomID) && (((Players)workingPlayerVector.elementAt(count)).GetTypeString()).equals("P") ) { roomPlayers = roomPlayers.concat( ((Players)workingPlayerVector.elementAt(count)).getName()).concat("|"); } count++; } PlayerLock.releaseLock(); return(roomPlayers); } //******************************************************* //Returns a players current stats.. public String getPlayerStats(String Pname) { int Ppos = 0; int count = 0; boolean found = false; String ToSend = new String(); //Get position of player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { ToSend = ((Players)workingPlayerVector.elementAt(Ppos)).GetAllStats(); } PlayerLock.releaseLock(); return(ToSend); } //************************************************************ //returns the numerical equiv to the money on the player.. public long GetMoneyOnPlayer(String Pname) { int Ppos = 0; int count = 0; boolean found = false; long ToSend = 0; //Get position of player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { ToSend = ((Players)workingPlayerVector.elementAt(Ppos)).GetMoney(); } PlayerLock.releaseLock(); return(ToSend); } // RemoveMoney(PlayerName, price); //************************************************************ //returns the numerical equiv to the money on the player.. public boolean RemoveMoney(String Pname, long price) { int Ppos = 0; int count = 0; boolean found = false; long cMoney = 0; long Final = 0; String ToSend = new String("0"); boolean success = false; //Get position of player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { success = ((Players)workingPlayerVector.elementAt(Ppos)).RemoveMoney(price); } PlayerLock.releaseLock(); return(success); } //******************************************************** //Sets the stats for a certain player... public boolean SetAllPlayersStats(String Pname,String Stats) { //hp|maxhp|str|sta|dex|cha|IQ|wis|shin|guk|don|exp int cStat = 0; int count = 0; int Ppos = 0; boolean found = false; StringTokenizer BreakUP = new StringTokenizer(Stats, " |"); PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } String cToken = new String(); int cValue = 0; //If the player is found... then set all the stats.. if(found) { while(BreakUP.hasMoreTokens() && cStat < 12) { cToken = BreakUP.nextToken(); cValue = Integer.parseInt(cToken); ((Players)workingPlayerVector.elementAt(Ppos)).SetAStat(cStat, cValue); cStat++; } } PlayerLock.releaseLock(); return(found); } //*********************************************************** //Changes a particular stat by a delta.. public boolean ChangeAStat(String Pname, int stat, long value) { int Ppos = 0; int count = 0; boolean found = false; //Get position of player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { ((Players)workingPlayerVector.elementAt(Ppos)).ChangeAStat(stat, value); } PlayerLock.releaseLock(); return(found); } //******************************************************* //Sets the god as a god... public void MakeGod(String Pname) { int Ppos = 0; int count = 0; boolean found = false; //Get position of player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { ((Players)workingPlayerVector.elementAt(Ppos)).SetTypeString("G"); } PlayerLock.releaseLock(); } //******************************************************* //Sets the god as a god... public void MakePlayer(String Pname) { int Ppos = 0; int count = 0; boolean found = false; //Get position of player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { found = true; Ppos = count; } count++; } if(found) { ((Players)workingPlayerVector.elementAt(Ppos)).SetTypeString("P"); } PlayerLock.releaseLock(); } //********************************************* //Adds an object to a player... public void AddItemToPlayer(String Pname,String ObjectID) { int count = 0; int PlayerPos = 0; boolean found = false; int ret; //Finds the position of the player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && found == false ) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { PlayerPos = count; found = true; } count++; } //Add the item to the player.. ((Players)workingPlayerVector.elementAt(PlayerPos)).addItem(ObjectID); PlayerLock.releaseLock(); } //******************************************* //Gets all the objects a player is holding... public String getItemsHeld(String Pname) { int PlayerPos = 0; int count = 0; boolean found = false; String AllItems = new String(); PlayerLock.lock(); while(count < workingPlayerVector.size() && found == false ) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { PlayerPos = count; found = true; } count++; } //Add the item to the player.. AllItems = ((Players)workingPlayerVector.elementAt(PlayerPos)).getItems(); PlayerLock.releaseLock(); return(AllItems); } //******************************************* public boolean RemoveItemFromPlayer(String Pname, String ObjectID) { int PlayerPos = 0; int count = 0; boolean found = false; boolean removed = false; PlayerLock.lock(); while(count < workingPlayerVector.size() && found == false ) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { PlayerPos = count; found = true; } count++; } if(found) { removed = ((Players)workingPlayerVector.elementAt(PlayerPos)).removeItem(ObjectID); } PlayerLock.releaseLock(); return(removed); } //************************************************* public boolean MovePlayerTo(String Pname, int x, int y, int rot) { int PlayerPos = 0; int count = 0; boolean found = false; boolean moved = false; PlayerLock.lock(); while(count < workingPlayerVector.size() && found == false ) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { PlayerPos = count; found = true; } count++; } if(found) { moved = ((Players)workingPlayerVector.elementAt(PlayerPos)).SetXY(x,y); ((Players)workingPlayerVector.elementAt(PlayerPos)).SetROT(rot); } PlayerLock.releaseLock(); return(moved); } //*********************************************************** //PlayerName|ObjID|X|Y|ROT| public String GetImageInforForPlayers(String RoomID) { String Final = new String(); int count = 0; PlayerLock.lock(); while(count < workingPlayerVector.size()) { if( RoomID.equals(((Players)workingPlayerVector.elementAt(count)).GetRoom()) && (((Players)workingPlayerVector.elementAt(count)).GetTypeString()).equals("P") ) { Final = Final + ((Players)workingPlayerVector.elementAt(count)).getName(); Final = Final + "|" + ((Players)workingPlayerVector.elementAt(count)).getObjID(); Final = Final + "|" + ((Players)workingPlayerVector.elementAt(count)).GetX(); Final = Final + "|" + ((Players)workingPlayerVector.elementAt(count)).GetY(); Final = Final + "|" + ((Players)workingPlayerVector.elementAt(count)).GetROT(); Final = Final + "|"; } count++; } PlayerLock.releaseLock(); return(Final); } public String GetPlayersBarRoomID() { String Final = new String(); String cName = new String(); String cRoom = new String(); int count = 0; PlayerLock.lock(); while(count < workingPlayerVector.size()) { cName = ((Players)workingPlayerVector.elementAt(count)).getName(); cRoom = ((Players)workingPlayerVector.elementAt(count)).GetRoom(); Final = Final + "|" + cName + "|" + cRoom; count++; } PlayerLock.releaseLock(); return(Final); } public String getDeadPlayers() { int count = 0; String DeadPeople = new String(); PlayerLock.lock(); while(count < workingPlayerVector.size()) { if( ((Players)workingPlayerVector.elementAt(count)).GetAStat(0) < 1) { DeadPeople = DeadPeople + "|" + ((Players)workingPlayerVector.elementAt(count)).getName(); DeadPeople = DeadPeople + "|" + ((Players)workingPlayerVector.elementAt(count)).GetX(); DeadPeople = DeadPeople + "|" + ((Players)workingPlayerVector.elementAt(count)).GetY(); DeadPeople = DeadPeople + "|" + ((Players)workingPlayerVector.elementAt(count)).GetRoom(); } count++; } PlayerLock.releaseLock(); return(DeadPeople); } //***************************************************************************** //*********************CHAT FUNCTIONS****************************************** //***************************************************************************** //workingPlayerVector.ChatText holds chat TO the parent of the class... //workingROOMvector.ChatText holds chat for the entire ROOM //workingChatVector contains all of the global cht for the world //***************************************************** //Get Chat from all three areas.. workingROOMvector workingPlayerVector and // workingChatVector from int int int // to send to cPlayer in the cROOM; -*-int int int-*- global player room public Vector getNewChat(int cG, String Pname,int cP, String RoomID,int cR) { int start; //will be the start position of each segment.. int count = 0; int cPos = 0; int tcG = 0; int tcP = 0; int tcR = 0; //Will hold the final result of the chat Vector Final4Chat = new Vector(); //current line and current Chat Segment String cLine = new String(); Vector cChat = new Vector(); boolean found = false; //*******GLOBAL************ start = cG; //Get all the chat infom from start on... ChatLock.lock(); while(start < workingChatVector.size()) { cLine = (String)workingChatVector.elementAt(start); //append to cChat... this will hold chat temporarily... cChat.add(cLine); start++; } ChatLock.releaseLock(); //Update size.. tcG = cChat.size(); //add to final vector to send off... count = 0; while(count < cChat.size()) { Final4Chat.add( (String)cChat.elementAt(count)); count++; } //****** PLAYER ******* start = cP; count = 0; cPos = 0; cChat = new Vector(); found = false; //Find the position of the player in question... and GET HIS CHAT PlayerLock.lock(); while(count < workingPlayerVector.size() && !found) { //Find which Player is being dealt with if(Pname.equals( ((Players)workingPlayerVector.elementAt(count)).getName())) { cPos = count; found = true; cChat = ((Players)workingPlayerVector.elementAt(count)).chatGetTextFrom(start); } //cPos now has position of player count++; } PlayerLock.releaseLock(); //Update the pointer... tcP = cChat.size(); //add to final vector to send off... count = 0; while(count < cChat.size()) { Final4Chat.add( (String)cChat.elementAt(count)); count++; } //******* ROOM ********* start = cR; count = 0; cPos = 0; cChat = new Vector(); RoomLock.lock(); while(count < workingROOMvector.size()) { //Find which Player is being dealt with if(RoomID.equals( ((ROOM)workingROOMvector.elementAt(count)).getID())) { cPos = count; cChat = ((ROOM)workingROOMvector.elementAt(count)).chatGetTextFrom(start); } //cPos now has position of player count++; } RoomLock.releaseLock(); //Update pointer tcR = cChat.size(); //add to final vector to send off count = 0; while(count < cChat.size()) { Final4Chat.add( (String)cChat.elementAt(count)); count++; } //*************** //Now cChat holds all the new chatting information for this request.. //Last value in vector is a string containing (cG, cP, cR); String UpdateValues = new String(); UpdateValues = UpdateValues.concat(Integer.toString(tcG)).concat("|"); UpdateValues = UpdateValues.concat(Integer.toString(tcP)).concat("|"); UpdateValues = UpdateValues.concat(Integer.toString(tcR)).concat("|"); Final4Chat.add(UpdateValues); //returns the new chat lines from all the places return(Final4Chat); } //***************************************************** // Adds a line of chat to a particular room.. public void addRoomChat(String RoomID, String message) { int count = 0; int RoomPos = -1; boolean found = false; //Find the position of the room.. RoomLock.lock(); while(count < workingROOMvector.size() && found == false ) { if( ((ROOM)workingROOMvector.elementAt(count)).getID().equals(RoomID)) { RoomPos = count; found = true; } count++; } //Add line of chat to particular room if(found) { ((ROOM)workingROOMvector.elementAt(RoomPos)).AddRoomChat(message); } else { //Else, give the user a warning.. System.out.println("(in DB) ROOM DOESN'T EXIST roomid = " +RoomID); } RoomLock.releaseLock(); } //******************************************** //Adds chat to the working chat vector public void addGlobalChat(String chatIN) { String chat = chatIN; //If the chat line is > 3,add to total global chat.. ChatLock.lock(); if(chat.length() > 3) { workingChatVector.add(chat); } ChatLock.releaseLock(); } //********************************************* //Adds chat to a particular player... kept in Players class... public boolean addPlayerChat(String Pname, String message) { int count = 0; boolean found = false; int PlayerPos = -1; //Find the position of the player... PlayerLock.lock(); while(count < workingPlayerVector.size() && found == false) { if( (((Players)workingPlayerVector.elementAt(count)).getName()).equals(Pname)) { PlayerPos = count; found = true; } count++; } //Add line of chat to particular room if(found) { //appending the chat... ((Players)workingPlayerVector.elementAt(PlayerPos)).AddPlayerChat(message); } PlayerLock.releaseLock(); return(found); } //*************************************************** //Returns the amount of chat in a particular room public int getRoomChatSize(String RoomID) { int count = 0; int RoomPos = 0; boolean found = false; int ret; //Find the position of the room.. RoomLock.lock(); while(count < workingROOMvector.size() && found == false ) { if( ((ROOM)workingROOMvector.elementAt(count)).getID().equals(RoomID)) { RoomPos = count; found = true; } count++; } //Add that text to the particular room ret = ((ROOM)workingROOMvector.elementAt(RoomPos)).GetChatVectorSize(); RoomLock.releaseLock(); return(ret); } //************************************************ //Returns the amount of chat in the player class.. public int getPlayerChatSize(String Pname) { int count = 0; int PlayerPos = 0; boolean found = false; int ret; //Finds the position of the player.. PlayerLock.lock(); while(count < workingPlayerVector.size() && found == false ) { if( ((Players)workingPlayerVector.elementAt(count)).getName().equals(Pname)) { PlayerPos = count; found = true; } count++; } //Gets the size of the chat.. ret = ((Players)workingPlayerVector.elementAt(PlayerPos)).GetChatVectorSize(); PlayerLock.releaseLock(); //returns the int representing the # of lines of chat in the player class return(ret); } //**************************************** //Returns the amount of chat in the workingChatVector (GLOBAL chat) public int getGlobalChatSize() { return( workingChatVector.size()); } //***************************************************************************** //*********************ROOM FUNCTIONS****************************************** //***************************************************************************** //*************************************************8 //Checks to see if a specific ROOM is in the working vector public boolean SeeIfRoomExists(String RoomID) { int count = 0; boolean found = false; //"locks" the thread so noone else can read RoomLock.lock(); while(count < workingROOMvector.size() && found == false) { if( ((ROOM)workingROOMvector.elementAt(count)).getID().equals(RoomID)) { found = true; } count++; } RoomLock.releaseLock(); return(found); } //*************************************************** //Returns the printable World in string format public String GetWorld() { return(World); } //***************************************************** //Returns the whole list of rooms as a vector public String GetAllRoomsForSteve() { String ToSend = new String(); int X, Y; int count = 0; RoomLock.lock(); //Go through workingRoomvector, extracting all of the neccessary room info in // ROOMID|DIRECTIONS|X|Y| while(count < workingROOMvector.size()) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood())) { ToSend = ToSend.concat( ((ROOM)workingROOMvector.elementAt(count)).getID()); ToSend = ToSend.concat("|"); ToSend = ToSend.concat( ((ROOM)workingROOMvector.elementAt(count)).getDirections()); ToSend = ToSend.concat("|"); X = ((ROOM)workingROOMvector.elementAt(count)).getX(); Y = ((ROOM)workingROOMvector.elementAt(count)).getY(); ToSend = ToSend.concat(Integer.toString(X)); ToSend = ToSend.concat("|"); ToSend = ToSend.concat(Integer.toString(Y)); ToSend = ToSend.concat("|"); } count++; } RoomLock.releaseLock(); return(ToSend); } //*********************************************************** //Returns a list of all the items in a room in ItemID|X|Y|pos|ItemID... format public String GetItemsInRoom(String RoomID) { String ToSend = new String(); String FormattedtoSend = new String(); boolean found = false; int count = 0; RoomLock.lock(); //Go through workingRoomvector, extracting all of the neccessary room info in // ROOMID|DIRECTIONS|X|Y| while(count < workingROOMvector.size() && !found) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) && (((ROOM)workingROOMvector.elementAt(count)).getID()).equals(RoomID)) { found = true; ToSend = ((ROOM)workingROOMvector.elementAt(count)).getObjects(); FormattedtoSend = deleteTypeInfo(ToSend); //System.out.println("FormattedtoSend " + FormattedtoSend); } count++; } RoomLock.releaseLock(); return(FormattedtoSend); } //*********************************************************** //Returns a list of all the items in a room in ItemID|X|Y|pos|ItemID... format public String GetItemsInRoom(String RoomID, int type) { String ToSend = new String(); String FormattedtoSend = new String(); boolean found = false; int count = 0; RoomLock.lock(); //Go through workingRoomvector, extracting all of the neccessary room info in // ROOMID|DIRECTIONS|X|Y| while(count < workingROOMvector.size() && !found) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) && (((ROOM)workingROOMvector.elementAt(count)).getID()).equals(RoomID)) { found = true; ToSend = ((ROOM)workingROOMvector.elementAt(count)).getObjects(); FormattedtoSend = deleteTypeInfo(ToSend, type); } count++; } RoomLock.releaseLock(); return(FormattedtoSend); } //**************************************************** //Removes an item from a room.. if a item is found... else.. returns a false.. public boolean RemoveItem(String RoomID,String ObjectID) { boolean ItemRemoved = false; int Rpos = 0; boolean roomFound = false; boolean itemFound = false; int count = 0; //Get the position of the ROOM.. RoomLock.lock(); //Go through workingRoomvector, extracting all of the neccessary room info in // ROOMID|DIRECTIONS|X|Y| while(count < workingROOMvector.size() && !roomFound) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) && (((ROOM)workingROOMvector.elementAt(count)).getID()).equals(RoomID)) { roomFound = true; Rpos = count; } count++; } //now the the position of the room is stored in Rpos.. see if the requested // item is in the room presently.. itemFound = SeeIfObjectIsInRoom(RoomID,ObjectID); //Now if the item was in the room.. and the room wsa found.. remove the item from the room.. if(roomFound && itemFound) { ItemRemoved = ((ROOM)workingROOMvector.elementAt(Rpos)).removeItem(ObjectID); } RoomLock.releaseLock(); return(ItemRemoved); } //**************************************************** //Removes an item from a room.. if a item is found... else.. returns a false.. public boolean RemoveItem(String RoomID,String ObjectID, int x, int y) { boolean ItemRemoved = false; int Rpos = 0; boolean roomFound = false; boolean itemFound = false; int count = 0; String X = new String(); String Y = new String(); X = Integer.toString(x); Y = Integer.toString(y); //Get the position of the ROOM.. RoomLock.lock(); //Go through workingRoomvector, extracting all of the neccessary room info in // ROOMID|DIRECTIONS|X|Y| while(count < workingROOMvector.size() && !roomFound) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) && (((ROOM)workingROOMvector.elementAt(count)).getID()).equals(RoomID)) { roomFound = true; Rpos = count; } count++; } //now the the position of the room is stored in Rpos.. see if the requested // item is in the room presently.. itemFound = SeeIfObjectIsInRoom(RoomID,ObjectID); //Now if the item was in the room.. and the room wsa found.. remove the item from the room.. if(roomFound && itemFound) { ItemRemoved = ((ROOM)workingROOMvector.elementAt(Rpos)).removeItem(ObjectID, x, y); } RoomLock.releaseLock(); return(ItemRemoved); } //***************************************************** public boolean AddItem(String RoomID, String ObjectID) { int x = 0; int y = 0; int pos = 0; int count = 0; boolean roomFound = false; int Rpos = 0; RoomLock.lock(); while(count < workingROOMvector.size() && !roomFound) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) && (((ROOM)workingROOMvector.elementAt(count)).getID()).equals(RoomID)) { roomFound = true; Rpos = count; } count++; } ((ROOM)workingROOMvector.elementAt(Rpos)).AddItem(ObjectID,x,y,pos, 1); RoomLock.releaseLock(); return(true); } //***************************************************** public boolean AddItem(String RoomID, String ObjectID, int x, int y, int pos, int type) { int count = 0; boolean roomFound = false; int Rpos = 0; RoomLock.lock(); while(count < workingROOMvector.size() && !roomFound) { if( ( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) && (((ROOM)workingROOMvector.elementAt(count)).getID()).equals(RoomID)) { roomFound = true; Rpos = count; } count++; } if(roomFound) { ((ROOM)workingROOMvector.elementAt(Rpos)).AddItem(ObjectID,x,y,pos, type); } else { } RoomLock.releaseLock(); return(true); } //*************************************************************************** //PRIVATE FUNCTIONS GO HERE************************************************** //*************************************************************************** //*************************************************** //This method initializes the Vector to hold all the info.. It sets it to 100 capacity and // structurarly inserts all the rooms created by whatshisface... private void initializeVector() { ROOM tROOM; int count = 0; while(count < 100) { //The default construtor for the rooms... tROOM = new ROOM("999-999","I AM SHIT","I LOVE SEX"); tROOM.SetRoom(false); workingROOMvector.add(tROOM); count++; } } //********************************************** //This method inserts the created rooms into the correct places in the working vector private void finalizeVector() { int count = 0; ROOM tROOM; //X Y and Position of the ROOM int X; int Y; int PosXY; //Places all the ROOMs in initialROOMvector into their proper locations // in workingROOMvector... set up in a 10x10 grid.. while(count < initialROOMvector.size()) { tROOM = (ROOM)initialROOMvector.elementAt(count); //X and Y positions for the current room X = tROOM.getX(); Y = tROOM.getY(); //Position in the vector of ROOMs.. PosXY = (Y*10)+X; if(((ROOM)workingROOMvector.elementAt(PosXY)).SeeIfGood() == false) { workingROOMvector.set(PosXY,tROOM); } else{ System.out.println("DUPLICATE ENTRY AT "+ PosXY); System.out.println("The ROOMID is" + tROOM.getID()); System.out.println("The ROOMID in the vector is " + ((ROOM)workingROOMvector.elementAt(count)).getID()); } count++; } } //******************************************************** //Puts the world in a String format easily readable etc // X....XX....X // XXXXXX XXXXX // ...X.X..X..X format private void SetPrintableWorld() { int count = 0; while(count < workingROOMvector.size()) { if(count%10==0) { World = World.concat("\n"); } if( ((ROOM)workingROOMvector.elementAt(count)).SeeIfGood()) { World = World.concat("X"); } else World = World.concat("."); count++; } } //Checks to see if a specific object is in the room private boolean SeeIfObjectIsInRoom(String RoomID, String ObjectID) { int count = 0; boolean found = false; while(count < workingROOMvector.size()&& !found) { if( ((ROOM)workingROOMvector.elementAt(count)).getID().equals(RoomID)) { if ( ((ROOM)workingROOMvector.elementAt(count)).IsObjectIn(ObjectID) ) { found = true; } } count++; } return(found); } //**************************************************** //Puts the string into ItemID|X|Y|Rotation format... from.. // ItemID|X|Y|Rotation|Type private String deleteTypeInfo(String ToSend) { String cToken = new String(); String Final = new String(); // System.out.println(ToSend); StringTokenizer BreakUP = new StringTokenizer(ToSend, "| "); while(BreakUP.hasMoreTokens()) { //ItemID cToken = BreakUP.nextToken(); Final = Final.concat("|").concat(cToken); //X cToken = BreakUP.nextToken(); Final = Final.concat("|").concat(cToken); //Y // System.out.println(cToken + " "); cToken = BreakUP.nextToken(); Final = Final.concat("|").concat(cToken); //Rotation // System.out.println(cToken + " "); cToken = BreakUP.nextToken(); Final = Final.concat("|").concat(cToken); //Other thing // System.out.println(cToken + " "); if(BreakUP.hasMoreTokens()) { cToken = BreakUP.nextToken(); } //NOT ADDING THIS PUPPY!!! HAH } return(Final); } //**************************************************** //Puts the string into ItemID|X|Y|Rotation format... from.. // ItemID|X|Y|Rotation|Type private String deleteTypeInfo(String ToSend, int type) { String c1 = new String(); String c2 = new String(); String c3 = new String(); String c4 = new String(); String c5 = new String(); int TypeToMatch = 0; String Final = new String(); // System.out.println(ToSend); StringTokenizer BreakUP = new StringTokenizer(ToSend, "| "); while(BreakUP.hasMoreTokens()) { //ItemID c1 = BreakUP.nextToken(); //X c2 = BreakUP.nextToken(); //Y c3 = BreakUP.nextToken(); //Rotation c4 = BreakUP.nextToken(); //Other thing if(BreakUP.hasMoreTokens()) { c5 = BreakUP.nextToken(); TypeToMatch = Integer.parseInt(c5); if(type == TypeToMatch) { Final = Final + "|" + c1 + "|"+ c2 + "|"+ c3 + "|"+ c4; } } } return(Final); } }