Initial commit

1 files changed, 1157 insertions, 0 deletions

diff --git a/NET/worlds/scape/World.java b/NET/worlds/scape/World.java
new file mode 100644
index 0000000..87b7ca4
--- /dev/null
+++ b/NET/worlds/scape/World.java
@@ -0,0 +1,1157 @@
+package NET.worlds.scape;
+
+import NET.worlds.console.AdBanner;
+import NET.worlds.console.Console;
+import NET.worlds.console.Gamma;
+import NET.worlds.console.Main;
+import NET.worlds.console.WorldsMarkPart;
+import NET.worlds.core.Hashtable;
+import NET.worlds.core.IniFile;
+import NET.worlds.core.Std;
+import NET.worlds.network.Galaxy;
+import NET.worlds.network.NetUpdate;
+import NET.worlds.network.URL;
+import NET.worlds.network.WorldServer;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.Enumeration;
+import java.util.Vector;
+
+public class World extends SuperRoot implements URLSelf, LoadedURLSelf, IncrementalRestorer {
+   static WorldRedirector redir = new WorldRedirector(URL.make(Gamma.getHome() + "redir.txt"));
+   private static boolean cloistered = false;
+   private static boolean cloisteredSet = false;
+   private String adCubeBaseURL = null;
+   private boolean hasClickableAdCube = false;
+   private boolean adCubeFormatIsGif = false;
+   private String defaultAdCubeURL = IniFile.override().getIniString("defaultAdCubeURL", "http://www.worlds.com/");
+   private boolean hasBeenEdited = false;
+   private String defaultRoomName = "";
+   protected Hashtable roomHash = new Hashtable();
+   protected Vector<Object> roomList = new Vector<Object>();
+   Vector<Object> eventHandlers;
+   private static boolean[] didTouch = new boolean[1];
+   private static int lastGeneratedFrameEvents;
+   private int renderStamp;
+   private int timeoutAge = 15000;
+   private int nextRoomCheck = 0;
+   private static Hashtable worldHash = new Hashtable();
+   private static Vector<World> worldList = new Vector<World>();
+   private boolean registerable = false;
+   private static Object classCookie = new Object();
+   private static final int INIT = 0;
+   private static final int RESTOREROOMS = 1;
+   private static final int ADDROOMS = 2;
+   private static final int LOADCONSOLE = 3;
+   private static final int DONE = -1;
+   private Enumeration<Room> tmpenum;
+   protected Console console = null;
+   String loadErr;
+   static URL defaultServerURL = URL.make("worldserver://www.3dcd.com:6650/");
+   private URL worldServerURL;
+   private URL desiredWorldServerURL = defaultServerURL;
+   private boolean isCourtesyVIP;
+   private boolean isForceHuman = false;
+   private boolean hasAdBanner = false;
+   private int adBannerWidth = 474;
+   private int adBannerHeight = 65;
+   private String adBannerURL = "$SCRIPTSERVERgetad.pl?s=$SERIALNUM";
+   private static AdBanner theAdBanner = null;
+   private boolean isMultiuser;
+
+   World() {
+   }
+
+   @Override
+   public World getWorld() {
+      return this;
+   }
+
+   public static void load(URL url, LoadedURLSelf callback, boolean force) {
+      if (Gamma.loadProgress != null) {
+         Gamma.loadProgress.setMessage("Loading world files...");
+         Gamma.loadProgress.advance();
+      }
+
+      if (url.toString().indexOf("UserHomeWorld") != -1) {
+         String homeWorld = WorldsMarkPart.getFirstSystemMarkURL();
+         if (homeWorld != null) {
+            int poundIdx = homeWorld.indexOf("#");
+            if (poundIdx != -1) {
+               homeWorld = homeWorld.substring(0, poundIdx);
+            }
+
+            url = URL.make(homeWorld);
+         }
+      }
+
+      File f = new File(url.unalias());
+      if (!f.exists()) {
+         url = redir.get(url);
+      }
+
+      if (isProscribed(url, force)) {
+         callback.loadedURLSelf(null, url, "Can't autoload WorldsStore");
+      } else {
+         World w = (World)worldHash.get(url);
+         if (w != null) {
+            w.incRef();
+            callback.loadedURLSelf(w, url, null);
+         } else {
+            URLSelfLoader.load(url, callback, true);
+         }
+      }
+   }
+
+   public static void load(URL url, LoadedURLSelf callback) {
+      load(url, callback, false);
+   }
+
+   public static boolean isCloistered() {
+      if (!cloisteredSet) {
+         URL homeDir = URL.make("home:" + WorldsMarkPart.getFirstWorld());
+         cloistered = new File(homeDir.unalias() + "/cloistered").exists();
+         cloisteredSet = true;
+      }
+
+      return cloistered;
+   }
+
+   public static URL getHomeStore() {
+      URL storeinf = URL.make("home:" + WorldsMarkPart.getFirstWorld() + "/store.inf");
+      URL homeStore = URL.make("home:PolyGram/polygramdlb.world");
+      File sf = new File(storeinf.unalias());
+      if (!sf.exists() || !sf.isFile()) {
+         sf = new File(URL.make("home:PolyGram/store.inf").unalias());
+         if (!sf.exists() || !sf.isFile()) {
+            return homeStore;
+         }
+      }
+
+      try {
+         BufferedReader rdr = new BufferedReader(new FileReader(sf));
+         String s = rdr.readLine();
+         rdr.close();
+         homeStore = new URL(s);
+      } catch (IOException var5) {
+      }
+
+      return homeStore;
+   }
+
+   public static boolean isWorldsStoreProscribed() {
+      return isCloistered() && IniFile.gamma().getIniInt("WorldsStoreProscribed", 1) != 0;
+   }
+
+   public static boolean isProscribed(URL url, boolean forceLoad) {
+      return !forceLoad && !WorldValidator.allow(url.toString());
+   }
+
+   public boolean isHomeWorld() {
+      URL url = this.getSourceURL();
+      if (url != null) {
+         URL homeURL = URL.make("home:" + WorldsMarkPart.getFirstWorld());
+         if (url.unalias().startsWith(homeURL.unalias() + "/")) {
+            return true;
+         }
+      }
+
+      return false;
+   }
+
+   public void setEdited(boolean state) {
+      if (state != this.hasBeenEdited) {
+         this.hasBeenEdited = state;
+         worldListChanged();
+      }
+   }
+
+   @Override
+   public void markEdited() {
+      this.setEdited(true);
+   }
+
+   public String getAdCubeBaseURL() {
+      if (this.adCubeBaseURL == null) {
+         String worldURL = this.getSourceURL().toString();
+         if (worldURL.lastIndexOf("/") == -1) {
+            return "ads/ad";
+         } else {
+            worldURL = worldURL.substring(0, worldURL.lastIndexOf("/"));
+            WorldServer w = Pilot.getActive().getServer();
+            if (w != null && w.getGalaxy().getOnline()) {
+               String adserverURL = NetUpdate.getUpgradeServerURL();
+               if (adserverURL != null) {
+                  int i1 = worldURL.lastIndexOf("/");
+                  int i2 = worldURL.lastIndexOf(":");
+                  i1 = i1 > i2 ? i1 : i2;
+                  if (i1 > -1) {
+                     worldURL = worldURL.substring(i1 + 1);
+                  }
+
+                  return adserverURL + worldURL + "/ads/ad";
+               }
+            }
+
+            return worldURL + "/ads/ad";
+         }
+      } else {
+         return this.adCubeBaseURL;
+      }
+   }
+
+   public void setAdCubeBaseURL(String s) {
+      this.adCubeBaseURL = new String(s);
+   }
+
+   public boolean getHasClickableAdCube() {
+      return this.hasClickableAdCube;
+   }
+
+   public void setHasClickableAdCube(boolean b) {
+      this.hasClickableAdCube = b;
+   }
+
+   public boolean getAdCubeFormatIsGif() {
+      return this.adCubeFormatIsGif;
+   }
+
+   public void setAdCubeFormatIsGif(boolean b) {
+      this.adCubeFormatIsGif = b;
+   }
+
+   public String getDefaultAdCubeURL() {
+      return this.defaultAdCubeURL;
+   }
+
+   public void setDefaultAdCubeURL(String s) {
+      this.defaultAdCubeURL = new String(s);
+   }
+
+   public boolean getEdited() {
+      return this.hasBeenEdited;
+   }
+
+   private static void worldListChanged() {
+      if (Gamma.getShaper() != null) {
+         Gamma.getShaper().worldListChange();
+      }
+   }
+
+   @Override
+   public void getChildren(DeepEnumeration d) {
+      d.addChildEnumeration(this.getRooms());
+      if (this.eventHandlers != null) {
+         d.addChildVector(this.eventHandlers);
+      }
+   }
+
+   public Room getRoom(String roomName) {
+      if (roomName.indexOf("UserHomeRoom") != -1) {
+         roomName = this.getDefaultRoomName();
+      }
+
+      return (Room)this.roomHash.get(roomName);
+   }
+
+   public String getDefaultRoomName() {
+      if (this.getRoom(this.defaultRoomName) == null) {
+         if (this.roomList.isEmpty()) {
+            this.defaultRoomName = "";
+         } else {
+            this.defaultRoomName = ((Room)this.roomList.elementAt(0)).getName();
+         }
+      }
+
+      return this.defaultRoomName;
+   }
+
+   public void setDefaultRoomName(String name) {
+      this.defaultRoomName = name;
+   }
+
+   public void addRoom(Room room) {
+      String name = room.getName();
+      int roomNum = 1;
+
+      while (this.getRoom(name) != null) {
+         name = "Room" + roomNum++;
+      }
+
+      room.setName(name);
+      this.roomHash.put(name, room);
+      this.roomList.addElement(room);
+      this.add(room);
+      URL sourceURL = this.getSourceURL();
+      if (sourceURL != null && worldHash.containsKey(sourceURL)) {
+         room.register();
+      }
+   }
+
+   public void renameRoom(String oldName, String newName, Room room) {
+      if (oldName != null) {
+         assert this.roomHash.get(oldName) == room;
+
+         this.roomHash.remove(oldName);
+      } else {
+         assert !this.roomList.removeElement(room);
+
+         this.roomList.addElement(room);
+      }
+
+      assert newName != null;
+
+      assert room.getName().equals(newName);
+
+      this.roomHash.put(newName, room);
+   }
+
+   public void removeRoom(Room room) {
+      this.roomHash.remove(this.roomHash.getKey(room));
+      this.roomList.removeElement(room);
+   }
+
+   public Enumeration<Object> getRooms() {
+      return this.roomList.elements();
+   }
+
+   public static Room findRoomByName(String name) {
+      Enumeration<World> we = worldList.elements();
+
+      while (we.hasMoreElements()) {
+         World w = we.nextElement();
+         Enumeration<Object> re = w.getRooms();
+
+         while (re.hasMoreElements()) {
+            Room r = (Room)re.nextElement();
+            if (r.toString().equals(name)) {
+               return r;
+            }
+         }
+      }
+
+      return null;
+   }
+
+   public void invokeActions(String actLabel) {
+      Enumeration<Object> en = this.getDeepOwned();
+
+      while (en.hasMoreElements()) {
+         Object obj = en.nextElement();
+         if (obj instanceof WObject) {
+            ((WObject)obj).doAction(actLabel, null);
+         }
+      }
+   }
+
+   public boolean deliver(FrameEvent event) {
+      if (this.eventHandlers != null) {
+         if (Main.profile != 0) {
+            int i = this.eventHandlers.size();
+
+            while (--i >= 0) {
+               FrameHandler fh = (FrameHandler)this.eventHandlers.elementAt(i);
+               int start = Std.getRealTime();
+               long startBytes = Runtime.getRuntime().freeMemory();
+               event.retargetAndDeliver(fh, null);
+               int dur = Std.getRealTime() - start;
+               long used = Runtime.getRuntime().freeMemory() - startBytes;
+               if (dur > Main.profile) {
+                  System.out.println("Took " + dur + "ms and " + used + " bytes to call world eventHandler " + fh);
+               }
+            }
+         } else {
+            int i = this.eventHandlers.size();
+
+            while (--i >= 0) {
+               event.retargetAndDeliver((FrameHandler)this.eventHandlers.elementAt(i), null);
+            }
+         }
+      }
+
+      return true;
+   }
+
+   public static void generateFrameEvents(FrameEvent f) {
+      didTouch[0] = false;
+      int now = Std.getFastTime();
+      int i = worldList.size();
+
+      while (--i >= 0) {
+         World w = worldList.elementAt(i);
+         if (!w.discardIfOld(didTouch)) {
+            w.deliver(f);
+         }
+      }
+
+      if (Pilot.getActiveWorld() != null) {
+         lastGeneratedFrameEvents = now;
+      }
+   }
+
+   public Enumeration<Object> getHandlers() {
+      return this.eventHandlers == null ? new Vector<Object>().elements() : this.eventHandlers.elements();
+   }
+
+   public boolean hasHandler(SuperRoot h) {
+      return this.eventHandlers != null && this.eventHandlers.indexOf(h) != -1;
+   }
+
+   public World addHandler(SuperRoot h) {
+      if (!(h instanceof FrameHandler)) {
+         Object[] arguments = new Object[]{new String(h.getName())};
+         Console.println(MessageFormat.format(Console.message("FrameHandler"), arguments));
+         return this;
+      } else {
+         if (this.eventHandlers == null) {
+            this.eventHandlers = new Vector<Object>();
+         }
+
+         this.eventHandlers.addElement(h);
+         this.add(h);
+         return this;
+      }
+   }
+
+   public void removeHandler(SuperRoot h) {
+      if (this.eventHandlers.contains(h)) {
+         h.detach();
+         this.eventHandlers.removeElement(h);
+         if (this.eventHandlers.size() == 0) {
+            this.eventHandlers = null;
+         }
+      }
+   }
+
+   @Override
+   public void incRef() {
+      this.renderStamp = Std.getFastTime();
+   }
+
+   @Override
+   public void decRef() {
+   }
+
+   private void touchAdjacentRooms(boolean[] didTouch) {
+      if (!didTouch[0]) {
+         didTouch[0] = true;
+         Room r = Pilot.getActiveRoom();
+         if (r != null) {
+            Vector<Portal> portals = r.getOutgoingPortals();
+            int i = portals.size();
+
+            while (--i >= 0) {
+               Room farr = portals.elementAt(i).farSideRoom();
+               if (farr != null) {
+                  farr.noteRef();
+               }
+            }
+         }
+      }
+   }
+
+   boolean discardIfOld(boolean[] didTouch) {
+      int now = Std.getFastTime();
+      if (now < this.nextRoomCheck) {
+         return false;
+      } else {
+         this.nextRoomCheck = now + 5000 + (int)(3000.0 * Math.random());
+         this.touchAdjacentRooms(didTouch);
+         int i = this.roomList.size();
+
+         while (--i >= 0) {
+            ((Room)this.roomList.elementAt(i)).discardIfOld();
+         }
+
+         if (this.hasBeenEdited) {
+            return false;
+         } else {
+            i = now - this.renderStamp;
+            if (i > this.timeoutAge && this.renderStamp < lastGeneratedFrameEvents && i > this.timeoutAge) {
+               this.discard();
+               return true;
+            } else {
+               return false;
+            }
+         }
+      }
+   }
+
+   @Override
+   public void discard() {
+      URL url = this.getSourceURL();
+      synchronized (worldHash) {
+         worldHash.remove(url);
+         worldList.removeElement(this);
+      }
+
+      worldListChanged();
+      URLSelfLoader.unload(this);
+      if (this.eventHandlers != null) {
+         int i = this.eventHandlers.size();
+
+         while (--i >= 0) {
+            this.removeHandler((SuperRoot)this.eventHandlers.elementAt(i));
+         }
+      }
+
+      assert this.eventHandlers == null;
+
+      this.discardRooms();
+      if (this.console != null) {
+         this.console.decRef();
+      }
+
+      this.console = null;
+      System.gc();
+      System.runFinalization();
+   }
+
+   private void discardRooms() {
+      while (!this.roomList.isEmpty()) {
+         Room r = (Room)this.roomList.elementAt(0);
+         r.discard();
+      }
+   }
+
+   @Override
+   protected void finalize() {
+      this.discardRooms();
+      super.finalize();
+   }
+
+   private void markInitialized() {
+      if (this.getSourceURL() != null) {
+         this.register();
+      } else {
+         this.registerable = true;
+      }
+   }
+
+   private void register() {
+      URL url = this.getSourceURL();
+      synchronized (worldHash) {
+         assert !worldHash.containsKey(url);
+
+         worldHash.put(url, this);
+         worldList.addElement(this);
+      }
+
+      worldListChanged();
+      this.registerable = false;
+      int i = this.roomList.size();
+
+      while (--i >= 0) {
+         ((Room)this.roomList.elementAt(i)).register();
+      }
+   }
+
+   @Override
+   public void setSourceURL(URL url) {
+      super.setSourceURL(url);
+      if (this.registerable) {
+         this.register();
+      }
+   }
+
+   @Override
+   public Object properties(int index, int offset, int mode, Object value) throws NoSuchPropertyException {
+      Object ret = null;
+      switch (index - offset) {
+         case 0:
+            if (mode == 0) {
+               ret = StringPropertyEditor.make(new Property(this, index, "Default Room Name"));
+            } else if (mode == 1) {
+               ret = this.getDefaultRoomName();
+            } else if (mode == 2) {
+               String name = (String)value;
+               if (this.getRoom(name) == null) {
+                  Console.println(name + Console.message("No-room-named"));
+               } else {
+                  this.setDefaultRoomName(name);
+               }
+            }
+            break;
+         case 1:
+            if (mode == 0) {
+               ret = BooleanPropertyEditor.make(new Property(this, index, "Multiuser"), "No", "Yes");
+            } else if (mode == 1) {
+               ret = new Boolean(this.getMultiuser());
+            } else if (mode == 2) {
+               this.setMultiuser((Boolean)value);
+            }
+            break;
+         case 2:
+            if (mode == 0) {
+               ret = new Property(this, index, "Console");
+            } else if (mode == 1) {
+               ret = this.console;
+            }
+            break;
+         case 3:
+            if (mode == 0) {
+               ret = PropAdder.make(new VectorProperty(this, index, "Rooms"));
+            } else if (mode == 1) {
+               ret = VectorProperty.toVector(this.roomHash);
+            } else if (mode == 4) {
+               ((Room)value).detach();
+            } else if (mode == 3) {
+               if (!(value instanceof Room)) {
+                  throw new Error("Can only add Rooms to a World.");
+               }
+
+               this.addRoom((Room)value);
+            } else if (mode == 5 && value instanceof Room) {
+               ret = value;
+            }
+            break;
+         case 4:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "Time-out Age (seconds)"));
+            } else if (mode == 1) {
+               ret = new Float(this.timeoutAge / 1000.0F);
+            } else if (mode == 2) {
+               this.timeoutAge = Math.round((Float)value * 1000.0F);
+            }
+            break;
+         case 5:
+            if (mode == 0) {
+               ret = PropAdder.make(new VectorProperty(this, index, "Running Actions (delete to stop)"));
+            } else if (mode == 1) {
+               if (this.eventHandlers != null) {
+                  ret = this.eventHandlers.clone();
+               }
+            } else if (mode == 4) {
+               this.removeHandler((SuperRoot)value);
+            }
+            break;
+         case 6:
+            if (mode == 0) {
+               ret = URLPropertyEditor.make(new Property(this, index, "Server URL"), "console");
+            } else if (mode == 1) {
+               ret = this.desiredWorldServerURL;
+               if (ret != null) {
+                  String u = this.desiredWorldServerURL.unalias();
+                  if (u.startsWith("worldserver://")) {
+                     ret = URL.make(u + "default.console");
+                  }
+               }
+            } else if (mode == 2) {
+               URL url = (URL)value;
+               if (url != null) {
+                  String u = url.unalias();
+                  int len = u.length();
+                  if (u.startsWith("worldserver://")) {
+                     if (!url.endsWith("/default.console") || len < 31) {
+                        Console.println(Console.message("server-URL") + "default.console");
+                        break;
+                     }
+
+                     u = u.substring(14, len - 16);
+                  }
+
+                  url = Console.makeServerURL(u);
+               }
+
+               this.setWorldServerURL(url);
+            }
+            break;
+         case 7:
+            if (mode == 0) {
+               ret = BooleanPropertyEditor.make(new Property(this, index, "Courtesy VIP"), "No", "Yes");
+            } else if (mode == 1) {
+               ret = new Boolean(this.getCourtesyVIP());
+            } else if (mode == 2) {
+               this.setCourtesyVIP((Boolean)value);
+            }
+            break;
+         case 8:
+            if (mode == 0) {
+               ret = BooleanPropertyEditor.make(new Property(this, index, "Force Human"), "No", "Yes");
+            } else if (mode == 1) {
+               ret = new Boolean(this.getForceHuman());
+            } else if (mode == 2) {
+               this.setForceHuman((Boolean)value);
+            }
+            break;
+         case 9:
+            if (mode == 0) {
+               ret = BooleanPropertyEditor.make(new Property(this, index, "Has Ad Banner"), "No", "Yes");
+            } else if (mode == 1) {
+               ret = new Boolean(this.getHasAdBanner());
+            } else if (mode == 2) {
+               this.setHasAdBanner((Boolean)value);
+               this.setupAdBanner();
+            }
+            break;
+         case 10:
+            if (mode == 0) {
+               ret = IntegerPropertyEditor.make(new Property(this, index, "Banner Width"));
+            } else if (mode == 1) {
+               ret = new Integer(this.getBannerWidth());
+            } else if (mode == 2) {
+               this.setBannerWidth((Integer)value);
+               this.setupAdBanner();
+            }
+            break;
+         case 11:
+            if (mode == 0) {
+               ret = IntegerPropertyEditor.make(new Property(this, index, "Banner Height"));
+            } else if (mode == 1) {
+               ret = new Integer(this.getBannerHeight());
+            } else if (mode == 2) {
+               this.setBannerHeight((Integer)value);
+               this.setupAdBanner();
+            }
+            break;
+         case 12:
+            if (mode == 0) {
+               ret = StringPropertyEditor.make(new Property(this, index, "Ad Banner URL"));
+            } else if (mode == 1) {
+               ret = this.getBannerURL();
+            } else if (mode == 2) {
+               String name = (String)value;
+               this.setBannerURL(name);
+            }
+            break;
+         case 13:
+            if (mode == 0) {
+               ret = BooleanPropertyEditor.make(new Property(this, index, "Has Clickable Ad Cube"), "No", "Yes");
+            } else if (mode == 1) {
+               ret = new Boolean(this.getHasClickableAdCube());
+            } else if (mode == 2) {
+               this.setHasClickableAdCube((Boolean)value);
+            }
+            break;
+         case 14:
+            if (mode == 0) {
+               ret = BooleanPropertyEditor.make(new Property(this, index, "Ad Cube image format"), "CMP", "GIF");
+            } else if (mode == 1) {
+               ret = new Boolean(this.getAdCubeFormatIsGif());
+            } else if (mode == 2) {
+               this.setAdCubeFormatIsGif((Boolean)value);
+            }
+            break;
+         case 15:
+            if (mode == 0) {
+               ret = StringPropertyEditor.make(new Property(this, index, "Ad cube base URL"));
+            } else if (mode == 1) {
+               ret = this.getAdCubeBaseURL();
+            } else if (mode == 2) {
+               String name = (String)value;
+               this.setAdCubeBaseURL(name);
+            }
+            break;
+         case 16:
+            if (mode == 0) {
+               ret = StringPropertyEditor.make(new Property(this, index, "Ad cube default click URL"));
+            } else if (mode == 1) {
+               ret = this.getDefaultAdCubeURL();
+            } else if (mode == 2) {
+               String name = (String)value;
+               this.setDefaultAdCubeURL(name);
+            }
+            break;
+         default:
+            ret = super.properties(index, offset + 17, mode, value);
+      }
+
+      return ret;
+   }
+
+   @Override
+   public void saveState(Saver s) throws IOException {
+      s.saveVersion(13, classCookie);
+      super.saveState(s);
+      s.saveString(this.defaultRoomName);
+      URL.save(s, this.desiredWorldServerURL);
+      s.saveInt(this.timeoutAge);
+      s.saveBoolean(this.getMultiuser());
+      s.saveBoolean(this.getCourtesyVIP());
+      s.saveBoolean(this.getForceHuman());
+      s.saveBoolean(this.getHasAdBanner());
+      s.saveInt(this.getBannerWidth());
+      s.saveInt(this.getBannerHeight());
+      s.saveString(this.getBannerURL());
+      s.saveBoolean(this.getHasClickableAdCube());
+      s.saveBoolean(this.getAdCubeFormatIsGif());
+      s.saveString(this.getAdCubeBaseURL());
+      s.saveString(this.getDefaultAdCubeURL());
+      s.save(this.roomHash);
+   }
+
+   @Override
+   public void restoreState(Restorer r) throws IOException, TooNewException {
+      URLSelfLoader.immediateLoad(this, r);
+   }
+
+   private void restoreOldURL(Restorer r) throws IOException {
+      String s = r.restoreString();
+      URL url;
+      if (s == null || s.equals("UNSHARED")) {
+         url = null;
+      } else if (!s.endsWith(".console")) {
+         url = Console.makeServerURL(s);
+      } else {
+         url = URL.restore(r, s, null);
+      }
+
+      if (url == null) {
+         url = defaultServerURL;
+      } else {
+         this.setMultiuser(true);
+      }
+
+      this.setWorldServerURL(url);
+   }
+
+   public int restorePreRooms(Restorer r) throws IOException, TooNewException {
+      int version = r.restoreVersion(classCookie);
+      switch (version) {
+         case 0:
+            r.setOldFlag();
+            this.setName(r.restoreString());
+            this.defaultRoomName = r.restoreString();
+            this.restoreOldURL(r);
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 1:
+         case 3:
+            r.setOldFlag();
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            this.restoreOldURL(r);
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 2:
+            r.setOldFlag();
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            this.restoreOldURL(r);
+            r.restoreString();
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 4:
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            this.restoreOldURL(r);
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 5:
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            this.restoreOldURL(r);
+            this.timeoutAge = r.restoreInt();
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 6:
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            this.restoreOldURL(r);
+            this.timeoutAge = r.restoreInt();
+            r.restoreBoolean();
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 7:
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            URL url = URL.restore(r);
+            if (url == null) {
+               url = defaultServerURL;
+            } else {
+               this.setMultiuser(true);
+            }
+
+            this.setWorldServerURL(url);
+            this.timeoutAge = r.restoreInt();
+            r.restoreBoolean();
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         case 8:
+         case 9:
+         case 10:
+         case 11:
+         case 12:
+         case 13:
+            super.restoreState(r);
+            this.defaultRoomName = r.restoreString();
+            this.setWorldServerURL(URL.restore(r));
+            this.timeoutAge = r.restoreInt();
+            this.setMultiuser(r.restoreBoolean());
+            if (version > 9) {
+               this.setCourtesyVIP(r.restoreBoolean());
+            }
+
+            if (version > 10) {
+               this.setForceHuman(r.restoreBoolean());
+            }
+
+            if (version > 11) {
+               this.setHasAdBanner(r.restoreBoolean());
+               this.setBannerWidth(r.restoreInt());
+               this.setBannerHeight(r.restoreInt());
+               this.setBannerURL(r.restoreString());
+            }
+
+            if (version > 12) {
+               this.setHasClickableAdCube(r.restoreBoolean());
+               this.setAdCubeFormatIsGif(r.restoreBoolean());
+               this.setAdCubeBaseURL(r.restoreString());
+               this.setDefaultAdCubeURL(r.restoreString());
+            }
+
+            this.roomHash = (Hashtable)r.restore(false);
+            break;
+         default:
+            throw new TooNewException();
+      }
+
+      Enumeration<Room> e = this.roomHash.elements();
+
+      while (e.hasMoreElements()) {
+         this.roomList.addElement(e.nextElement());
+      }
+
+      if (version < 9 && this.timeoutAge == 60000) {
+         this.timeoutAge = 15000;
+      }
+
+      return version;
+   }
+
+   @Override
+   public Object clone() {
+      World newWorld = (World)super.clone();
+      int worldNum = 1;
+
+      String newname;
+      URL key;
+      do {
+         newname = "World" + worldNum++;
+         key = URL.make("session:" + newname + ".world");
+      } while (worldHash.containsKey(key));
+
+      newWorld.setName(newname);
+      newWorld.setSourceURL(key);
+      return newWorld;
+   }
+
+   @Override
+   public int incRestore(int state, Restorer r, URLSelfLoader p) throws Exception {
+      switch (state) {
+         case 0:
+            p.itemp2 = this.restorePreRooms(r);
+            p.itemp1 = this.roomHash.restoreCount(r);
+         case 1:
+            if (--p.itemp1 >= 0) {
+               this.roomHash.restoreEntry(r);
+               return 1;
+            } else {
+               if (p.itemp2 == 4) {
+                  this.timeoutAge = r.restoreInt();
+                  if (this.timeoutAge == 900000 || this.timeoutAge == 60000) {
+                     this.timeoutAge = 15000;
+                  }
+               }
+
+               if (r.version() < 3) {
+                  return -1;
+               }
+            }
+         case 2:
+         case 3:
+            return this.finishRestore(state, r.version() != Saver.version() || r.oldFlag(), p.getURL());
+         default:
+            assert false;
+
+            return -1;
+      }
+   }
+
+   public int finishRestore(int state, boolean oldFlag, URL url) throws Exception {
+      switch (state) {
+         case 0:
+         case 1:
+            this.tmpenum = this.roomHash.elements();
+            this.roomHash = new Hashtable();
+         case 2:
+            if (this.tmpenum.hasMoreElements()) {
+               Room rm = this.tmpenum.nextElement();
+               this.addRoom(rm);
+               return 2;
+            } else {
+               this.tmpenum = null;
+            }
+         case 3:
+            if (this.console == null && this.loadErr == null) {
+               return 3;
+            } else {
+               if (this.loadErr != null) {
+                  throw new IOException(this.loadErr);
+               }
+
+               this.markInitialized();
+               return -1;
+            }
+         default:
+            assert false;
+
+            return -1;
+      }
+   }
+
+   @Override
+   public void postRestore(int version) {
+      super.postRestore(version);
+      if (version <= 2) {
+         int state = 0;
+
+         try {
+            while ((state = this.finishRestore(state, true, URL.make("error:This file"))) != -1) {
+            }
+         } catch (Exception var4) {
+            var4.printStackTrace(System.out);
+
+            assert false;
+         }
+      }
+   }
+
+   public Console getConsole() {
+      return this.console;
+   }
+
+   @Override
+   public void loadedURLSelf(URLSelf o, URL url, String err) {
+      if (err == null && o instanceof Console) {
+         Console oldConsole = this.console;
+         this.console = (Console)o;
+         if (oldConsole != null) {
+            Galaxy oldGalaxy = oldConsole.getGalaxy();
+            Galaxy galaxy = this.console.getGalaxy();
+
+            assert oldGalaxy != null;
+
+            assert galaxy != null;
+
+            if (oldGalaxy != galaxy) {
+               oldGalaxy.forceObjectRereg();
+            }
+
+            oldConsole.decRef();
+         }
+
+         this.worldServerURL = url;
+         if (Pilot.getActive() != null && Pilot.getActive().getWorld() == this) {
+            Pilot.changeActiveRoom(Pilot.getActive().getRoom());
+         }
+      } else {
+         if (err == null) {
+            Object[] arguments = new Object[]{new String("" + url)};
+            Console.println(MessageFormat.format(Console.message("no-world"), arguments));
+            o.decRef();
+         }
+
+         Console.println(Console.message("cant-load") + err);
+         Console.load(null, this);
+      }
+   }
+
+   public boolean getCourtesyVIP() {
+      return this.isCourtesyVIP;
+   }
+
+   private void setCourtesyVIP(boolean b) {
+      this.isCourtesyVIP = b;
+   }
+
+   public boolean getForceHuman() {
+      return this.isForceHuman;
+   }
+
+   private void setForceHuman(boolean b) {
+      this.isForceHuman = b;
+   }
+
+   public boolean getHasAdBanner() {
+      return this.hasAdBanner;
+   }
+
+   public void setHasAdBanner(boolean b) {
+      this.hasAdBanner = b;
+   }
+
+   public int getBannerWidth() {
+      return this.adBannerWidth;
+   }
+
+   public void setBannerWidth(int i) {
+      this.adBannerWidth = i;
+   }
+
+   public int getBannerHeight() {
+      return this.adBannerHeight;
+   }
+
+   public void setBannerHeight(int i) {
+      this.adBannerHeight = i;
+   }
+
+   public String getBannerURL() {
+      return this.adBannerURL;
+   }
+
+   public void setBannerURL(String s) {
+      this.adBannerURL = s;
+   }
+
+   public void setupAdBanner() {
+      if (theAdBanner != null) {
+         theAdBanner.detach();
+         theAdBanner = null;
+      }
+
+      if (this.hasAdBanner) {
+         theAdBanner = new AdBanner(this.adBannerWidth, this.adBannerHeight, this.adBannerURL);
+      }
+   }
+
+   private boolean getMultiuser() {
+      return this.isMultiuser;
+   }
+
+   private void setMultiuser(boolean b) {
+      this.isMultiuser = b;
+      this.setWorldServerURL(this.desiredWorldServerURL);
+   }
+
+   public World setWorldServerURL(URL s) {
+      this.desiredWorldServerURL = s;
+      String i = s.getInternal();
+      if (i.startsWith("worldserver://www.3dcd.com") && NetUpdate.overrideWorldServer != null) {
+         i = i.substring(26);
+         if (i.startsWith(":") && NetUpdate.overrideWorldServer.indexOf(58, 13) >= 0) {
+            int j = 1;
+
+            while (j < i.length() && Character.isDigit(i.charAt(j))) {
+               j++;
+            }
+
+            i = i.substring(j);
+         }
+
+         s = URL.make(NetUpdate.overrideWorldServer + i);
+      }
+
+      this.loadErr = null;
+      Console.load(this.isMultiuser ? s : null, this);
+      return this;
+   }
+
+   public static Enumeration<World> getWorlds() {
+      return worldList.elements();
+   }
+}