diff options
Diffstat (limited to '')
| -rwxr-xr-x | include/game.h | 302 |
1 files changed, 237 insertions, 65 deletions
diff --git a/include/game.h b/include/game.h index 8afb80b..f907004 100755 --- a/include/game.h +++ b/include/game.h @@ -1635,72 +1635,244 @@ public: class dStageActor_c; // forward declaration
+
+enum SensorFlags {
+ SENSOR_POINT = 0,
+ SENSOR_LINE = 1,
+
+ SENSOR_TYPE_MASK = 1,
+ SENSOR_2 = 2, // has not shown up yet...?
+ SENSOR_IGNORE_SIMPLE_COLL = 4,
+ SENSOR_8 = 8, // can enter pipe?
+ SENSOR_10 = 0x10, // Related to ice
+ SENSOR_20 = 0x20, // related to ice, too
+ SENSOR_40 = 0x40, // checked by simplecollider
+ SENSOR_80 = 0x80, // checked by simplecollider
+ SENSOR_100 = 0x100, // checked by simplecollider
+ SENSOR_200 = 0x200, // checked by simplecollider
+ SENSOR_400 = 0x400, // checked by simplecollider
+ SENSOR_800 = 0x800, // checked by simplecollider
+ SENSOR_NO_QUICKSAND = 0x1000,
+ SENSOR_2000 = 0x2000, // something to do with fences maybe?
+ SENSOR_BREAK_BLOCK = 0x4000,
+ SENSOR_8000 = 0x8000, // used
+ SENSOR_10000 = 0x10000, // used
+ SENSOR_COIN_1 = 0x20000,
+ SENSOR_COIN_2 = 0x40000,
+ SENSOR_COIN_OUTLINE = 0x80000,
+ SENSOR_ACTIVATE_QUESTION = 0x100000,
+ SENSOR_ACTIVATE_DONUTS = 0x200000,
+ SENSOR_HIT_BRICK = 0x400000,
+ SENSOR_BREAK_BRICK = 0x800000,
+ SENSOR_HIT_OR_BREAK_BRICK = 0xC00000,
+ SENSOR_1000000 = 0x1000000, // has not shown up yet...?
+ SENSOR_2000000 = 0x2000000, // corresponds to SCF_400?
+ SENSOR_4000000 = 0x4000000, // something related to hitting blocks
+ SENSOR_8000000 = 0x8000000, // corresponds to SCF_20?
+ SENSOR_10000000 = 0x10000000, // used
+ SENSOR_20000000 = 0x20000000, // used
+ SENSOR_40000000 = 0x40000000, // used
+ SENSOR_80000000 = 0x80000000, // used
+};
+
+// Output is split into...
+// Above :
+// FC000000: 11111100000000000000000000000000
+// Below :
+// 3FFE000: 11111111111110000000000000
+// 1FE000: 111111110000000000000
+// 18000: 11000000000000000
+// Adjacent:
+// 1FFF: 1111111111111
+
+enum SensorOutputFlags {
+ CSOUT_ABOVE_ALL = 0xFC000000,
+ CSOUT_BELOW_ALL = 0x3FFE000,
+ CSOUT_ADJACENT_ALL = 0x1FFF,
+};
+
+// 0x8000 : Has object from Class 2DC?
+// 0x4000 : Has slope from Class 2DC?
+
+struct hLine_s {
+ float x1, x2, y;
+};
+struct vLine_s {
+ float x, y1, y2;
+};
+
+struct pointSensor_s;
+struct lineSensor_s;
+struct sensorBase_s {
+ u32 flags;
+ inline pointSensor_s *asPoint() const {
+ return (pointSensor_s*)this;
+ }
+ inline lineSensor_s *asLine() const {
+ return (lineSensor_s*)this;
+ }
+};
+struct pointSensor_s : sensorBase_s {
+ inline pointSensor_s() { }
+ inline pointSensor_s(s32 _x, s32 _y) {
+ x = _x; y = _y;
+ }
+ inline pointSensor_s(u32 _flags, s32 _x, s32 _y) {
+ flags = _flags | SENSOR_POINT;
+ x = _x; y = _y;
+ }
+ s32 x, y;
+};
+struct lineSensor_s : sensorBase_s {
+ inline lineSensor_s() { }
+ inline lineSensor_s(s32 _a, s32 _b, s32 _d) {
+ flags = SENSOR_LINE;
+ lineA = _a; lineB = _b;
+ distanceFromCenter = _d;
+ }
+ inline lineSensor_s(u32 _flags, s32 _a, s32 _b, s32 _d) {
+ flags = _flags | SENSOR_LINE;
+ lineA = _a; lineB = _b;
+ distanceFromCenter = _d;
+ }
+ s32 lineA, lineB, distanceFromCenter;
+};
+
class collisionMgr_c {
-public:
- collisionMgr_c();
- virtual ~collisionMgr_c();
-
- //FIXME params and returns and add more
- void Clear1();
- void Clear2();
- void Init(dStageActor_c*,const u8*,const u8*,const u8*);
-
- void Clear3();
- bool CollidedWithTile();
- int SomethingSemiImportant(u32);
- u32 execute();
-
- u32 s_8006FA40(void *);
- u32 s_80070760();
- bool s_800707E0();
-
- dStageActor_c* owner;
- void* struct1_ptr;
- void* struct2_ptr;
- void* some_ptr;
- Vec3* parent_pos_ptr;
- Vec3* parent_last_pos_ptr;
- Vec3* parent_speed_ptr;
- Vec3 someVelocityThing;
- float xDeltaMaybe;
- float yDeltaMaybe;
- u8 _34[24]; //FIXME
- float someFloat;
- void* class2DC_ptr; //FIXME
- void* another_ptr;
- void* ptr_to_ptr_to_underneath_actor;
- u8 _5C[44]; //FIXME
- u32 bitfield_for_checks;
- u32 bitfield_backup;
- u32 _90, _94;
- u8 which_player_of_parent;
- u8 which_controller;
- u16 _9A, _9C;
- u8 _9E[2]; //FIXME
- u32 another_bitfield;
- u8 _A4;
- u8 _A5[3]; //FIXME
- u32 yet_another_bitfield;
- u8 _AC;
- u8 _AD[3]; //FIXME
- u32 directional_bitfields[2]; // left right
- u8 flagsB8;
- u8 flagsB9;
- u8 _BA[2]; //FIXME
- u8 _BC, _BD;
- u16 _BE;
- u8 _C0, _C1;
- u16 _C2;
- u8 _C4[4]; //FIXME
- u16 _C8;
- u8 _CA[22]; //FIXME
- u8 _E0, _E1, _E2;
- u8 _E3; //FIXME
- u8 _E4, _E5;
- u8 _E6[2]; //FIXME
- u32 current_layer_ptr;
- u8 current_layer;
- u8 _ED[3]; //FIXME
+ public:
+ collisionMgr_c();
+ virtual ~collisionMgr_c();
+
+ dStageActor_c *owner;
+ sensorBase_s *pBelowInfo, *pAboveInfo, *pAdjacentInfo;
+
+ VEC3 *pPos, *pLastPos, *pSpeed;
+ VEC3 specialSpeedOffset;
+ float xDeltaMaybe, yDeltaMaybe;
+ float _34, _38;
+ u32 _3C, _40, _44, _48;
+ float initialXAsSetByJumpDai;
+ /*dClass2DC_c*/void *pClass2DC;
+ u32 _54;
+ Physics *sCollBelow;
+ Physics *sCollAbove;
+ Physics *sCollAdjacentLast, *sCollAdjacent[2];
+ collisionMgr_c *_6C, *_70, *_74;
+ collisionMgr_c *_78[2];
+ Physics *_80[2];
+ u32 outputMaybe;
+ u32 _8C;
+ u32 someStoredBehaviourFlags, someStoredProps;
+ char whichPlayerOfParent____;
+ char whichController____;
+ u16 _9A, _9C;
+ u32 tileBelowProps;
+ u8 tileBelowSubType, lastTileBelowSubType;
+ u32 tileAboveProps;
+ u8 tileAboveSubType, lastTileAboveSubType;
+ u32 adjacentTileProps[2];
+ u8 adjacentTileSubType[2];
+ u8 _BA, _BB;
+ u8 _BC; // &8 makes able to enter mini pipes?
+ u8 currentSlopeType;
+ s16 currentSlopeAngle;
+ u8 currentFlippedSlopeType;
+ s16 currentFlippedSlopeAngle;
+ u32 _C4;
+ u16 currentAdjacentSlopeAngle;
+ u32 currentFenceType; // 0=null 1=ladder 2=fence
+ Physics *_D0;
+ float _D4;
+ float _D8;
+ float _DC;
+ u8 touchedSpikeFlag;
+ s8 maxTouchedSpikeType;
+ u8 currentSlopeDirection, _E3, onGround_maybe, chainlinkMode;
+ u8 *pLayerID;
+ u8 layer;
+ bool enteredPipeIsMini;
+
+ // Setup
+ void clear1();
+ void clear2();
+ void init(dStageActor_c *owner, const sensorBase_s *belowInfo, const sensorBase_s *aboveInfo, const sensorBase_s *adjacentInfo);
+
+ u32 calculateBelowCollision();
+ u32 calculateAboveCollision(u32 value);
+ u32 calculateAdjacentCollision(float *pFloat=0);
+
+ bool setBelowSubType(u32 magic); // maybe not public?
+
+ u8 getBelowSubType();
+ u8 getAboveSubType();
+ u8 getAdjacentSubType(int direction);
+
+ int returnSomethingBasedOnSlopeAngle();
+ bool doesSlopeGoUp();
+
+ int getSlopeYDirectionForXDirection(int direction);
+ int getSlopeYDirectionForXDirection(int direction, int slopeType);
+ s16 getAngleOfSlopeInDirection(int direction);
+ s16 getAngleOfSlopeWithXSpeed(float xSpeed);
+ s16 getAngleOfSlopeInDirection2(int thing);
+ s16 getAngleOfFlippedSlopeInDirection(int thing);
+ s16 getAngleOfFlippedSlopeInDirection2(int thing);
+
+ static bool checkPositionForTileOrSColl(float x, float y, u8 layer, u32 unk, u32 mask);
+ static int getPartialBlockExistenceAtPos(float x, float y, u8 layer);
+ static bool isPartialBlockOrBlockSolidAtPos(float x, float y, u8 layer);
+ static u32 getTileBehaviour1At(float x, float y, u8 layer);
+ static u32 getTileBehaviour2At(float x, float y, u8 layer);
+ static u32 getTileBehaviour1At(u16 x, u16 y, u8 layer);
+ static u32 getTileBehaviour2At(u16 x, u16 y, u8 layer);
+
+ u8 getOwnerStageActorType() const;
+ u32 returnOutputAnd18000() const;
+ bool isOnTopOfTile() const;
+
+ u32 s_80071210(dStageActor_c *player);
+ bool tryToEnterPipeBelow(VEC3 *pOutVec, int *pOutEntranceID);
+ bool tryToEnterPipeAbove(VEC3 *pOutVec, int *pOutEntranceID);
+ bool tryToEnterAdjacentPipe(VEC3 *pOutVec, int unk, int *pOutEntranceID, float fp1, float fp2);
+ u32 detectFence(lineSensor_s *info);
+ bool detectClimbingPole(lineSensor_s *info);
+
+ bool s_80072440(VEC2 *v2one, VEC2 *v2two, float *pOutFloat);
+ bool s_800728C0(VEC2 *vecParam, float *pOutFloat);
+
+ u32 calculateBelowCollisionWithSmokeEffect();
+
+ u32 calculateAdjacentCollisionAlternate(float *pFloat=0);
+
+ static void setupEverything(int wrapType);
+
+ bool getBelowSensorHLine(hLine_s *outLine);
+ bool getAboveSensorHLine(hLine_s *outLine);
+ bool getAdjacentSensorVLine(vLine_s *outLine, int direction);
+
+ void s_800731E0(Physics *sColl, VEC3 *somePos);
+
+ void clearStoredSColls();
+ void s_80075090();
+ bool s_800751C0(Physics *sColl, collisionMgr_c *what);
+ collisionMgr_c *s_80075230(Physics *sColl);
+
+ static int checkPositionForLiquids(float x, float y, int layer, float *unkDestFloat = 0);
+ static int s_80075560(float x, float y, int layer, float *destFloat);
+ static bool s_80075750(VEC2 *pVec);
+ static bool s_80075780(s16 *pAngle);
+
+ enum SlopeTypes {
+ SLOPE_EDGE = 10,
+ SLOPE_TYPE_COUNT = 19
+ };
+ struct slopeParams_s {
+ float basePos, colHeight;
+ };
+ static const slopeParams_s slopeParams[SLOPE_TYPE_COUNT];
+ static const slopeParams_s flippedSlopeParams[SLOPE_TYPE_COUNT];
+ static const u8 slopeKinds[SLOPE_TYPE_COUNT];
+ static const u8 slopeDirections[SLOPE_TYPE_COUNT];
};
class BasicCollider {
|