Moved Stars45 to StarsEx

1 files changed, 204 insertions, 0 deletions

diff --git a/StarsEx/Physical.h b/StarsEx/Physical.h
new file mode 100644
index 0000000..b9a9be5
--- /dev/null
+++ b/StarsEx/Physical.h
@@ -0,0 +1,204 @@
+/*  Starshatter: The Open Source Project
+    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
+    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
+    Copyright (c) 1997-2006, Destroyer Studios LLC.
+
+    AUTHOR:       John DiCamillo
+
+
+    OVERVIEW
+    ========
+    Abstract Physical Object
+*/
+
+#ifndef Physical_h
+#define Physical_h
+
+#include "Types.h"
+#include "Geometry.h"
+#include "Camera.h"
+
+// +--------------------------------------------------------------------+
+
+class Director;
+class Graphic;
+class Light;
+
+// +--------------------------------------------------------------------+
+
+class Physical
+{
+public:
+    static const char* TYPENAME() { return "Physical"; }
+
+    Physical();
+    Physical(const char* n, int t=0);
+    virtual ~Physical();
+
+    int operator == (const Physical& p) const { return id == p.id; }
+
+    // Integration Loop Control:
+    static void       SetSubFrameLength(double seconds) { sub_frame = seconds; }
+    static double     GetSubFrameLength()               { return sub_frame;    }
+
+    // operations
+    virtual void      ExecFrame(double seconds);
+    virtual void      AeroFrame(double seconds);
+    virtual void      ArcadeFrame(double seconds);
+
+    virtual void      AngularFrame(double seconds);
+    virtual void      LinearFrame(double seconds);
+
+    virtual void      CalcFlightPath();
+
+    virtual void      MoveTo(const Point& new_loc);
+    virtual void      TranslateBy(const Point& ref);
+    virtual void      ApplyForce(const Point& force);
+    virtual void      ApplyTorque(const Point& torque);
+    virtual void      SetThrust(double t);
+    virtual void      SetTransX(double t);
+    virtual void      SetTransY(double t);
+    virtual void      SetTransZ(double t);
+    virtual void      SetHeading(double r, double p, double y);
+    virtual void      LookAt(const Point& dst);
+    virtual void      ApplyRoll(double roll_acc);
+    virtual void      ApplyPitch(double pitch_acc);
+    virtual void      ApplyYaw(double yaw_acc);
+
+    virtual int       CollidesWith(Physical& o);
+    static  void      ElasticCollision(Physical& a, Physical& b);
+    static  void      InelasticCollision(Physical& a, Physical& b);
+    static  void      SemiElasticCollision(Physical& a, Physical& b);
+    virtual void      InflictDamage(double damage, int type = 0);
+
+    // accessors:
+    int               Identity()  const { return id;         }
+    int               Type()      const { return obj_type;   }
+    const char*       Name()      const { return name;       }
+
+    Point             Location()  const { return cam.Pos();  }
+    Point             Heading()   const { return cam.vpn();  }
+    Point             LiftLine()  const { return cam.vup();  }
+    Point             BeamLine()  const { return cam.vrt();  }
+    Point             Velocity()  const { return velocity + arcade_velocity; }
+    Point             Acceleration()
+    const { return accel;      }
+    double            Thrust()    const { return thrust;     }
+    double            TransX()    const { return trans_x;    }
+    double            TransY()    const { return trans_y;    }
+    double            TransZ()    const { return trans_z;    }
+    double            Drag()      const { return drag;       }
+
+    double            Roll()      const { return roll;       }
+    double            Pitch()     const { return pitch;      }
+    double            Yaw()       const { return yaw;        }
+    Point             Rotation()  const { return Point(dp,dr,dy); }
+
+    double            Alpha()     const { return alpha;      }
+
+    double            FlightPathYawAngle()    const { return flight_path_yaw;     }
+    double            FlightPathPitchAngle()  const { return flight_path_pitch;   }
+
+    double            Radius()    const { return radius;     }
+    double            Mass()      const { return mass;       }
+    double            Integrity() const { return integrity;  }
+    double            Life()      const { return life;       }
+
+    double            Shake()     const { return shake;      }
+    const Point&      Vibration() const { return vibration;  }
+
+    const Camera&     Cam()       const { return cam;        }
+    Graphic*          Rep()       const { return rep;        }
+    Light*            LightSrc()  const { return light;      }
+
+    Director*         GetDirector() const { return dir;      }
+
+    // mutators:
+    virtual void      SetAngularRates(double  r, double  p, double  y);
+    virtual void      GetAngularRates(double& r, double& p, double& y);
+    virtual void      SetAngularDrag(double  r, double  p, double  y);
+    virtual void      GetAngularDrag(double& r, double& p, double& y);
+    virtual void      GetAngularThrust(double& r, double& p, double& y);
+    virtual void      SetVelocity(const Point& v) { velocity = v; }
+    virtual void      SetAbsoluteOrientation(double roll, double pitch, double yaw);
+    virtual void      CloneCam(const Camera& cam);
+    virtual void      SetDrag(double d) { drag = (float) d; }
+
+    virtual void      SetPrimary(const Point& loc, double mass);
+    virtual void      SetGravity(double g);
+    virtual void      SetBaseDensity(double d);
+
+    virtual double    GetBaseDensity()  const { return Do; }
+    virtual double    GetDensity()      const;
+
+    enum { NAMELEN = 48 };
+
+protected:
+    static int        id_key;
+
+    // identification:
+    int               id;
+    int               obj_type;
+    char              name[NAMELEN];
+
+    // position, velocity, and acceleration:
+    Camera            cam;
+    Point             velocity;
+    Point             arcade_velocity;
+    Point             accel;
+    float             thrust;
+    float             trans_x;
+    float             trans_y;
+    float             trans_z;
+    float             drag;
+
+    // attitude and angular velocity:
+    float             roll,   pitch,  yaw;
+    float             dr,     dp,     dy;
+    float             dr_acc, dp_acc, dy_acc;
+    float             dr_drg, dp_drg, dy_drg;
+
+    float             flight_path_yaw;
+    float             flight_path_pitch;
+
+    // gravitation:
+    Point             primary_loc;
+    double            primary_mass;
+
+    // aerodynamics:
+    float             g_accel;    // acceleration due to gravity (constant)
+    float             Do;         // atmospheric density at sea level
+    float             CL;         // base coefficient of lift
+    float             CD;         // base coefficient of drag
+    float             alpha;      // current angle of attack (radians)
+    float             stall;      // stall angle of attack (radians)
+    bool              lat_thrust; // lateral thrusters enabled in aero mode?
+    bool              straight;
+
+    // vibration:
+    float             shake;
+    Point             vibration;
+
+    // scale factors for ApplyXxx():
+    float             roll_rate, pitch_rate, yaw_rate;
+
+    // physical properties:
+    double            life;
+    float             radius;
+    float             mass;
+    float             integrity;
+
+    // graphic representation:
+    Graphic*          rep;
+    Light*            light;
+
+    // AI or human controller:
+    Director*         dir;        // null implies an autonomous object
+
+    static double sub_frame;
+};
+
+// +--------------------------------------------------------------------+
+
+#endif  // Physical_h
+