Initial commit

1 files changed, 188 insertions, 0 deletions

diff --git a/NET/worlds/scape/RollingAttribute.java b/NET/worlds/scape/RollingAttribute.java
new file mode 100644
index 0000000..5293818
--- /dev/null
+++ b/NET/worlds/scape/RollingAttribute.java
@@ -0,0 +1,188 @@
+package NET.worlds.scape;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+public class RollingAttribute extends Attribute {
+   RollBehavior rb = new RollBehavior();
+   public float initialKickVel = 200.0F;
+   private Point3 kp = new Point3();
+   private float kv = 0.0F;
+   private Point3 kd = new Point3();
+   private static Object classCookie = new Object();
+
+   public RollingAttribute(int attrID) {
+      super(attrID);
+      this.rb.linearDamp = 0.95F;
+      this.rb.rollFactor = 1.0F;
+      this.rb.setNotifyAttribute(this);
+   }
+
+   public RollingAttribute() {
+      this.rb.linearDamp = 0.8F;
+      this.rb.setNotifyAttribute(this);
+   }
+
+   public void set(Point3Temp p, float v, Point3Temp d) {
+      if (this.kp.x != p.x || this.kp.y != p.y || this.kp.x != p.z) {
+         this.kp.x = p.x;
+         this.kp.y = p.y;
+         this.kp.z = p.z;
+         this.kv = v;
+         this.kd.x = d.x;
+         this.kd.y = d.y;
+         this.kd.z = d.z;
+         ((WObject)this.getOwner().getOwner()).moveTo(this.kp);
+         this.rb.linearVel = this.kv;
+         this.rb.setDir(this.kd);
+         this.noteChange();
+      }
+   }
+
+   public void notifyStopped() {
+      WObject ball = (WObject)((Sharer)this.getOwner()).getOwner();
+      Point3Temp pos = ball.getPosition();
+      this.set(pos, 0.0F, Point3Temp.make(0.0F, 0.0F, 0.0F));
+   }
+
+   public void get(Point3Temp p, float v, Point3Temp d) {
+      p.x = this.kp.x;
+      p.y = this.kp.y;
+      p.z = this.kp.z;
+      v = this.kv;
+      d.x = this.kd.x;
+      d.y = this.kd.y;
+      d.z = this.kd.z;
+   }
+
+   @Override
+   protected void noteAddingTo(SuperRoot owner) {
+      WObject parent = (WObject)owner.getOwner();
+      parent.addHandler(this.rb);
+   }
+
+   public boolean handle(BumpEventTemp b) {
+      if (b.target == b.receiver && !(this.rb.linearVel > 0.0F)) {
+         if (this.rb.linearVel == 0.0F) {
+            Point3Temp pos = b.target.getWorldPosition();
+            WObject kicker = (WObject)b.source;
+            float alpha = kicker.getYaw();
+            Point3Temp kpos = kicker.getWorldPosition();
+            double dx = kpos.x - pos.x;
+            double dy = kpos.y - pos.y;
+            Math.atan2(dx, dy);
+            float kickang = (float)((360.0F - alpha + 90.0F) * Math.PI / 180.0);
+            Point3Temp kickdir = Point3Temp.make((float)Math.cos(kickang), (float)Math.sin(kickang), 0.0F);
+            pos.x = pos.x + kickdir.x;
+            pos.y = pos.y + kickdir.y;
+            this.set(pos, this.initialKickVel, kickdir);
+         }
+      } else {
+         if (b.target instanceof Camera) {
+            double dx = this.rb.dir.x;
+            double dy = this.rb.dir.y;
+            Math.atan2(dx, dy);
+            double theta = dy + 60.0 * Math.random() - 30.0;
+            double var12 = dx * Math.cos(theta * Math.PI / 180.0);
+            dy = dx * Math.sin(theta * Math.PI / 180.0);
+            this.rb.dir.x = (float)var12;
+            this.rb.dir.y = (float)dy;
+         }
+
+         this.rb.processBumpEvent(b);
+         if (b.target instanceof Camera || b.source instanceof Camera) {
+            Point3Temp pos = ((WObject)((Sharer)this.getOwner()).getOwner()).getWorldPosition();
+            this.set(pos, this.rb.linearVel, this.rb.dir);
+         }
+      }
+
+      return true;
+   }
+
+   @Override
+   public void generateNetData(DataOutputStream s) throws IOException {
+      s.writeFloat(this.kp.x);
+      s.writeFloat(this.kp.y);
+      s.writeFloat(this.kp.z);
+      s.writeFloat(this.kv);
+      s.writeFloat(this.kd.x);
+      s.writeFloat(this.kd.y);
+      s.writeFloat(this.kd.z);
+   }
+
+   @Override
+   public void setFromNetData(DataInputStream ds, int len) throws IOException {
+      Point3Temp pos = Point3Temp.make();
+      float vel = 0.0F;
+      Point3Temp dir = Point3Temp.make();
+      pos.x = ds.readFloat();
+      pos.y = ds.readFloat();
+      pos.z = ds.readFloat();
+      vel = ds.readFloat();
+      dir.x = ds.readFloat();
+      dir.y = ds.readFloat();
+      dir.z = ds.readFloat();
+      this.set(pos, vel, dir);
+   }
+
+   @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, "Roll Factor"));
+            } else if (mode == 1) {
+               ret = new Float(this.rb.rollFactor);
+            } else if (mode == 2) {
+               this.rb.rollFactor = (Float)value;
+            }
+            break;
+         case 1:
+            if (mode == 0) {
+               ret = FloatPropertyEditor.make(new Property(this, index, "Initial Kick Velocity"));
+            } else if (mode == 1) {
+               ret = new Float(this.initialKickVel);
+            } else if (mode == 2) {
+               this.initialKickVel = (Float)value;
+            }
+            break;
+         default:
+            ret = super.properties(index, offset + 2, mode, value);
+      }
+
+      return ret;
+   }
+
+   @Override
+   public void saveState(Saver s) throws IOException {
+      s.saveVersion(1, classCookie);
+      super.saveState(s);
+      s.saveFloat(this.initialKickVel);
+      s.saveFloat(this.rb.rollFactor);
+   }
+
+   @Override
+   public void restoreState(Restorer r) throws IOException, TooNewException {
+      switch (r.restoreVersion(classCookie)) {
+         case 0:
+            super.restoreState(r);
+            this.initialKickVel = r.restoreFloat();
+            float threshold = r.restoreFloat();
+            break;
+         case 1:
+            super.restoreState(r);
+            this.initialKickVel = r.restoreFloat();
+            this.rb.rollFactor = r.restoreFloat();
+            break;
+         default:
+            throw new TooNewException();
+      }
+   }
+
+   @Override
+   public String toString() {
+      return super.toString() + " [From " + this.kp + " with velocity " + this.kv + " toward " + this.kd + "] ";
+   }
+}