Initial commit

1 files changed, 401 insertions, 0 deletions

diff --git a/NET/worlds/scape/RectPatch.java b/NET/worlds/scape/RectPatch.java
new file mode 100644
index 0000000..6ce3473
--- /dev/null
+++ b/NET/worlds/scape/RectPatch.java
@@ -0,0 +1,401 @@
+package NET.worlds.scape;
+
+import java.awt.Color;
+import java.io.IOException;
+
+public class RectPatch extends WObject implements FloorPatch {
+   public float xDim;
+   public float yDim;
+   public float[] z = new float[]{0.0F, 0.0F, 0.0F, 0.0F};
+   public Material mat;
+   public float xTile = 1.0F;
+   public float xTileOffset = 0.0F;
+   public float yTile = 1.0F;
+   public float yTileOffset = 0.0F;
+   public Polygon[] t = new Polygon[4];
+   private static Object classCookie = new Object();
+
+   public RectPatch(float x, float y) {
+      this.setVisible(true);
+      this.setBumpable(false);
+      this.xDim = x;
+      this.yDim = y;
+      this.setMaterial(new Material(Color.gray));
+   }
+
+   public RectPatch() {
+      this.xDim = 1.0F;
+      this.yDim = 1.0F;
+      this.setMaterial(new Material(Color.gray));
+   }
+
+   @Override
+   protected void addRwChildren(WObject parent) {
+      if (this.t[0] == null) {
+         this.createAppearance();
+      }
+
+      super.addRwChildren(parent);
+   }
+
+   @Override
+   public void setVisible(boolean v) {
+      super.setVisible(v);
+      this.createAppearance();
+   }
+
+   public void setMaterial(Material m) {
+      if (this.mat != null) {
+         this.mat.detach();
+      }
+
+      this.add(m);
+      this.mat = m;
+      this.createAppearance();
+   }
+
+   public Material getMaterial() {
+      return this.mat;
+   }
+
+   @Override
+   public boolean inPatch(float x, float y) {
+      Transform inverse = this.getObjectToWorldMatrix().invert();
+      Point3Temp p = Point3Temp.make(x, y, 0.0F).times(inverse);
+      inverse.recycle();
+      x = p.x;
+      y = p.y;
+      return !(x < 0.0F) && !(x > this.xDim) && !(y < 0.0F) && !(y > this.yDim);
+   }
+
+   @Override
+   public float floorHeight(float x, float y) {
+      Transform inverse = this.getObjectToWorldMatrix().invert();
+      Point3Temp p = Point3Temp.make(x, y, 0.0F).times(inverse);
+      inverse.recycle();
+      x = p.x;
+      y = p.y;
+      float nx = x / this.xDim;
+      float ny = y / this.yDim;
+      float fx = 1.0F - nx;
+      float fy = 1.0F - ny;
+      return this.z[0] * fy * fx + this.z[1] * ny * fx + this.z[2] * ny * nx + this.z[3] * fy * nx;
+   }
+
+   @Override
+   public Point3 surfaceNormal(float x, float y) {
+      Point3 A = new Point3(this.xDim, 0.0F, this.z[1] - this.z[0]);
+      Point3Temp B = Point3Temp.make(0.0F, this.yDim, this.z[3] - this.z[0]);
+      A.cross(B);
+      A.normalize();
+      A.times(this.getObjectToWorldMatrix());
+      return A;
+   }
+
+   private void removeAppearance() {
+      for (int i = 0; i < 4; i++) {
+         if (this.t[i] != null) {
+            this.t[i].detach();
+            this.t[i] = null;
+         }
+      }
+   }
+
+   public void createAppearance() {
+      this.removeAppearance();
+      if (this.getVisible()) {
+         if (!(this.xDim <= 0.0F) && !(this.yDim <= 0.0F)) {
+            if (this.xTile <= 0.0F) {
+               this.xTile = 1.0F;
+            }
+
+            if (this.xTile > 31.0F) {
+               this.xTile = 31.0F;
+            }
+
+            if (this.yTile <= 0.0F) {
+               this.yTile = 1.0F;
+            }
+
+            if (this.yTile > 31.0F) {
+               this.yTile = 31.0F;
+            }
+
+            if (this.xTileOffset < 0.0F) {
+               this.xTileOffset = 1.0F - (float)Math.floor(this.xTileOffset) + this.xTileOffset;
+            }
+
+            if (this.yTileOffset < 0.0F) {
+               this.yTileOffset = 1.0F - (float)Math.floor(this.yTileOffset) + this.yTileOffset;
+            }
+
+            float cx = this.xDim / 2.0F;
+            float cy = this.yDim / 2.0F;
+            float cz = (this.z[0] + this.z[1] + this.z[2] + this.z[3]) / 4.0F;
+            float cU = this.xTileOffset + this.xTile / 2.0F;
+            float cV = this.yTileOffset + this.yTile / 2.0F;
+            this.t[0] = new Polygon(3, this.mat);
+            this.t[0].setVertex(0, 0.0F, 0.0F, this.z[0], this.xTileOffset, this.yTileOffset);
+            this.t[0].setVertex(1, cx, cy, cz, cU, cV);
+            this.t[0].setVertex(2, 0.0F, this.yDim, this.z[1], this.xTileOffset, this.yTileOffset + this.yTile);
+            this.add(this.t[0]);
+            this.t[1] = new Polygon(3, this.mat);
+            this.t[1].setVertex(0, 0.0F, this.yDim, this.z[1], this.xTileOffset, this.yTileOffset + this.yTile);
+            this.t[1].setVertex(1, cx, cy, cz, cU, cV);
+            this.t[1].setVertex(2, this.xDim, this.yDim, this.z[2], this.xTileOffset + this.xTile, this.yTileOffset + this.yTile);
+            this.add(this.t[1]);
+            this.t[2] = new Polygon(3, this.mat);
+            this.t[2].setVertex(0, this.xDim, this.yDim, this.z[2], this.xTileOffset + this.xTile, this.yTileOffset + this.yTile);
+            this.t[2].setVertex(1, cx, cy, cz, cU, cV);
+            this.t[2].setVertex(2, this.xDim, 0.0F, this.z[3], this.xTileOffset + this.xTile, this.yTileOffset);
+            this.add(this.t[2]);
+            this.t[3] = new Polygon(3, this.mat);
+            this.t[3].setVertex(0, this.xDim, 0.0F, this.z[3], this.xTileOffset + this.xTile, this.yTileOffset);
+            this.t[3].setVertex(1, cx, cy, cz, cU, cV);
+            this.t[3].setVertex(2, 0.0F, 0.0F, this.z[0], this.xTileOffset, this.yTileOffset);
+            this.add(this.t[3]);
+         }
+      }
+   }
+
+   public void setCornerHeight(int corner, float height) {
+      this.z[corner] = height;
+      this.createAppearance();
+   }
+
+   public void setWidth(float v) {
+      this.xDim = v;
+      this.createAppearance();
+   }
+
+   public void setLength(float v) {
+      this.yDim = v;
+      this.createAppearance();
+   }
+
+   @Override
+   public Transform spin(float x, float y, float z, float a) {
+      if (x == 0.0F && y == 0.0F) {
+         return super.spin(x, y, z, a);
+      } else {
+         System.out.println("ERROR: cannot spin floor patch out of horizontal!");
+         return this;
+      }
+   }
+
+   @Override
+   public Transform postspin(float x, float y, float z, float a) {
+      if (x == 0.0F && y == 0.0F) {
+         return super.spin(x, y, z, a);
+      } else {
+         System.out.println("ERROR: cannot spin floor patch out of horizontal!");
+         return this;
+      }
+   }
+
+   @Override
+   public Transform worldSpin(float x, float y, float z, float a) {
+      if (x == 0.0F && y == 0.0F) {
+         return super.spin(x, y, z, a);
+      } else {
+         System.out.println("ERROR: cannot spin floor patch out of horizontal!");
+         return this;
+      }
+   }
+
+   @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 = FloatPropertyEditor.make(new Property(this, index, "Length (y)"));
+            } else if (mode == 1) {
+               ret = new Float(this.yDim);
+            } else if (mode == 2) {
+               this.setLength((Float)value);
+            }
+            break;
+         case 1:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "Width (x)"));
+            } else if (mode == 1) {
+               ret = new Float(this.xDim);
+            } else if (mode == 2) {
+               this.setWidth((Float)value);
+            }
+            break;
+         case 2:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "0,0 corner"));
+            } else if (mode == 1) {
+               ret = new Float(this.z[0]);
+            } else if (mode == 2) {
+               this.setCornerHeight(0, (Float)value);
+            }
+            break;
+         case 3:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "0,y corner"));
+            } else if (mode == 1) {
+               ret = new Float(this.z[1]);
+            } else if (mode == 2) {
+               this.setCornerHeight(1, (Float)value);
+            }
+            break;
+         case 4:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "x,y corner"));
+            } else if (mode == 1) {
+               ret = new Float(this.z[2]);
+            } else if (mode == 2) {
+               this.setCornerHeight(2, (Float)value);
+            }
+            break;
+         case 5:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "x,0 corner"));
+            } else if (mode == 1) {
+               ret = new Float(this.z[3]);
+            } else if (mode == 2) {
+               this.setCornerHeight(3, (Float)value);
+            }
+            break;
+         case 6:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "# Tiles (x)"));
+            } else if (mode == 1) {
+               ret = new Float(this.xTile);
+            } else if (mode == 2) {
+               this.xTile = (Float)value;
+               this.createAppearance();
+            }
+            break;
+         case 7:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "# Tiles (y)"));
+            } else if (mode == 1) {
+               ret = new Float(this.yTile);
+            } else if (mode == 2) {
+               this.yTile = (Float)value;
+               this.createAppearance();
+            }
+            break;
+         case 8:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "Tile Offset (x)"));
+            } else if (mode == 1) {
+               ret = new Float(this.xTileOffset);
+            } else if (mode == 2) {
+               this.xTileOffset = (Float)value;
+               this.createAppearance();
+            }
+            break;
+         case 9:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "Tile Offset (y)"));
+            } else if (mode == 1) {
+               ret = new Float(this.yTileOffset);
+            } else if (mode == 2) {
+               this.yTileOffset = (Float)value;
+               this.createAppearance();
+            }
+            break;
+         case 10:
+            if (mode == 0) {
+               ret = new Property(this, index, "Material");
+            } else if (mode == 1) {
+               ret = this.mat;
+            }
+            break;
+         default:
+            ret = super.properties(index, offset + 11, mode, value);
+      }
+
+      return ret;
+   }
+
+   @Override
+   public void saveState(Saver s) throws IOException {
+      s.saveVersion(2, classCookie);
+      this.removeAppearance();
+      super.saveState(s);
+      s.saveFloat(this.xDim);
+      s.saveFloat(this.yDim);
+
+      for (int i = 0; i < 4; i++) {
+         s.saveFloat(this.z[i]);
+      }
+
+      s.saveFloat(this.xTile);
+      s.saveFloat(this.xTileOffset);
+      s.saveFloat(this.yTile);
+      s.saveFloat(this.yTileOffset);
+      s.saveMaybeNull(this.mat);
+      this.createAppearance();
+   }
+
+   @Override
+   public void restoreState(Restorer r) throws IOException, TooNewException {
+      this.restoreStateRectPatchHelper(r, classCookie);
+   }
+
+   public void restoreStateRectPatchHelper(Restorer r, Object cookie) throws IOException, TooNewException {
+      switch (r.restoreVersion(cookie)) {
+         case 0:
+            r.setOldFlag();
+            super.restoreState(r);
+            this.xDim = r.restoreFloat();
+            this.yDim = r.restoreFloat();
+
+            for (int i = 0; i < 4; i++) {
+               this.z[i] = r.restoreFloat();
+            }
+
+            this.setVisible(false);
+            break;
+         case 1:
+            r.setOldFlag();
+            super.restoreState(r);
+            this.xDim = r.restoreFloat();
+            this.yDim = r.restoreFloat();
+
+            for (int i = 0; i < 4; i++) {
+               this.z[i] = r.restoreFloat();
+            }
+
+            this.xTile = r.restoreFloat();
+            this.xTileOffset = r.restoreFloat();
+            this.yTile = r.restoreFloat();
+            this.yTileOffset = r.restoreFloat();
+            this.setMaterial(Material.restore(r));
+            r.restoreMaybeNull();
+            r.restoreMaybeNull();
+            r.restoreMaybeNull();
+            r.restoreMaybeNull();
+            break;
+         case 2:
+            super.restoreState(r);
+            this.xDim = r.restoreFloat();
+            this.yDim = r.restoreFloat();
+
+            for (int i = 0; i < 4; i++) {
+               this.z[i] = r.restoreFloat();
+            }
+
+            this.xTile = r.restoreFloat();
+            this.xTileOffset = r.restoreFloat();
+            this.yTile = r.restoreFloat();
+            this.yTileOffset = r.restoreFloat();
+            this.setMaterial(Material.restore(r));
+            break;
+         default:
+            throw new TooNewException();
+      }
+   }
+
+   @Override
+   public String toString() {
+      return super.toString() + "[" + this.xDim + "," + this.yDim + "]";
+   }
+}