From 7280cb788e1009012eec73fbec334a4fe412d019 Mon Sep 17 00:00:00 2001 From: danij Date: Thu, 19 Apr 2012 04:46:33 +0100 Subject: [PATCH] Refactor: All map coordinates are now represented as double floating-point Part 3 of 6 - libdoom --- doomsday/plugins/jdoom/include/d_config.h | 2 +- doomsday/plugins/jdoom/include/d_player.h | 10 +- doomsday/plugins/jdoom/include/p_mobj.h | 47 +-- doomsday/plugins/jdoom/include/p_spec.h | 8 +- doomsday/plugins/jdoom/include/r_defs.h | 2 +- doomsday/plugins/jdoom/include/st_stuff.h | 4 +- doomsday/plugins/jdoom/src/d_api.c | 6 +- doomsday/plugins/jdoom/src/d_console.c | 2 +- doomsday/plugins/jdoom/src/m_cheat.c | 14 +- doomsday/plugins/jdoom/src/p_enemy.c | 344 +++++++++++----------- doomsday/plugins/jdoom/src/p_inter.c | 28 +- doomsday/plugins/jdoom/src/p_maputl.c | 34 +-- doomsday/plugins/jdoom/src/p_mobj.c | 242 +++++++-------- doomsday/plugins/jdoom/src/p_oldsvg.c | 23 +- doomsday/plugins/jdoom/src/p_pspr.c | 61 ++-- doomsday/plugins/jdoom/src/p_sound.c | 2 +- doomsday/plugins/jdoom/src/p_spec.c | 10 +- doomsday/plugins/jdoom/src/p_telept.c | 95 +++--- doomsday/plugins/jdoom/src/st_stuff.c | 17 +- 19 files changed, 450 insertions(+), 501 deletions(-) diff --git a/doomsday/plugins/jdoom/include/d_config.h b/doomsday/plugins/jdoom/include/d_config.h index 183ae358c2..d41d27cd22 100644 --- a/doomsday/plugins/jdoom/include/d_config.h +++ b/doomsday/plugins/jdoom/include/d_config.h @@ -157,7 +157,7 @@ typedef struct jdoom_config_s { byte anyBossDeath; byte monstersStuckInDoors; byte avoidDropoffs; - byte moveBlock; // Dont handle large negative movement in P_TryMove. + byte moveBlock; // Dont handle large negative movement in P_TryMoveXY. byte wallRunNorthOnly; // If handle large make exception for wallrunning byte zombiesCanExit; // Zombie players can exit levels. byte fallOff; // Objects fall under their own weight. diff --git a/doomsday/plugins/jdoom/include/d_player.h b/doomsday/plugins/jdoom/include/d_player.h index 40bfb8630e..8b2371f81c 100644 --- a/doomsday/plugins/jdoom/include/d_player.h +++ b/doomsday/plugins/jdoom/include/d_player.h @@ -106,11 +106,11 @@ typedef struct player_s { boolean centering; // The player's view pitch is centering back to zero. int update, startSpot; - float viewOffset[3]; // Relative to position of the player mobj. - float viewZ; // Focal origin above r.z. - float viewHeight; // Base height above floor for viewZ. - float viewHeightDelta; - float bob; // Bounded/scaled total momentum. + coord_t viewOffset[3]; // Relative to position of the player mobj. + coord_t viewZ; // Focal origin above r.z. + coord_t viewHeight; // Base height above floor for viewZ. + coord_t viewHeightDelta; + coord_t bob; // Bounded/scaled total momentum. // Target view to a mobj (NULL=disabled): mobj_t* viewLock; // $democam diff --git a/doomsday/plugins/jdoom/include/p_mobj.h b/doomsday/plugins/jdoom/include/p_mobj.h index 8fb04fe5c8..25cd951a23 100644 --- a/doomsday/plugins/jdoom/include/p_mobj.h +++ b/doomsday/plugins/jdoom/include/p_mobj.h @@ -34,21 +34,22 @@ # error "Using jDoom headers without __JDOOM__" #endif +#include "dd_types.h" #include "d_think.h" #include "p_terraintype.h" #include "doomdata.h" #include "info.h" #include "tables.h" -#define NOMOM_THRESHOLD (0.00000001f) // (integer) 0 -#define DROPOFFMOM_THRESHOLD (0.25f) // FRACUNIT/4 +#define NOMOM_THRESHOLD (0.0001) // (integer) 0 +#define DROPOFFMOM_THRESHOLD (0.25) // FRACUNIT/4 #define MAXMOM (30) // 30*FRACUNIT #define MAXMOMSTEP (15) // 30*FRACUNIT/2 -#define FRICTION_LOW (0.97265625f) // 0xf900 -#define FRICTION_FLY (0.91796875f) // 0xeb00 -#define FRICTION_NORMAL (0.90625000f) // 0xe800 -#define FRICTION_HIGH (0.41992187f) // 0xd700/2 +#define FRICTION_LOW (0.97265625) // 0xf900 +#define FRICTION_FLY (0.91796875) // 0xeb00 +#define FRICTION_NORMAL (0.90625000) // 0xe800 +#define FRICTION_HIGH (0.41992187) // 0xd700/2 /** * Mobj flags @@ -187,33 +188,33 @@ typedef struct mobj_s { // Thing being chased/attacked (or NULL), // also the originator for missiles. - struct mobj_s *target; + struct mobj_s* target; // If >0, the target will be chased // no matter what (even if shot) int threshold; int intFlags; // internal flags - float dropOffZ; // $dropoff_fix + coord_t dropOffZ; // $dropoff_fix short gear; // used in torque simulation boolean wallRun; // true = last move was the result of a wallrun // Additional info record for player avatars only. // Only valid if type == MT_PLAYER - struct player_s *player; + struct player_s* player; // Player number last looked for. int lastLook; // For nightmare/multiplayer respawn. struct { - float pos[3]; + coord_t origin[3]; angle_t angle; int flags; // MSF_* flags } spawnSpot; // Thing being chased/attacked for tracers. - struct mobj_s *tracer; + struct mobj_s* tracer; int turnTime; // $visangle-facetarget int corpseTics; // $vanish: how long has this been dead? @@ -226,20 +227,20 @@ typedef struct polyobj_s { // Doom-specific data: } Polyobj; -mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, - angle_t angle, int spawnFlags); -mobj_t* P_SpawnMobj3fv(mobjtype_t type, const float pos[3], - angle_t angle, int spawnFlags); +mobj_t* P_SpawnMobjXYZ(mobjtype_t type, coord_t x, coord_t y, coord_t z, angle_t angle, int spawnFlags); +mobj_t* P_SpawnMobj(mobjtype_t type, coord_t const pos[3], angle_t angle, int spawnFlags); -mobj_t* P_SpawnCustomPuff(mobjtype_t type, float x, float y, float z, - angle_t angle); -mobj_t* P_SpawnMissile(mobjtype_t type, mobj_t* source, mobj_t* dest); -void P_SpawnPuff(float x, float y, float z, angle_t angle); -void P_SpawnBlood(float x, float y, float z, int damage, - angle_t angle); -mobj_t* P_SpawnTeleFog(float x, float y, angle_t angle); +mobj_t* P_SpawnCustomPuff(mobjtype_t type, coord_t x, coord_t y, coord_t z, angle_t angle); +mobj_t* P_SpawnMissile(mobjtype_t type, mobj_t* source, mobj_t* dest); + +void P_SpawnPuff(coord_t x, coord_t y, coord_t z, angle_t angle); + +void P_SpawnBlood(coord_t x, coord_t y, coord_t z, int damage, angle_t angle); + +mobj_t* P_SpawnTeleFog(coord_t x, coord_t y, angle_t angle); const terraintype_t* P_MobjGetFloorTerrainType(mobj_t* mo); -float P_MobjGetFriction(mobj_t *mo); + +coord_t P_MobjGetFriction(mobj_t* mo); #endif diff --git a/doomsday/plugins/jdoom/include/p_spec.h b/doomsday/plugins/jdoom/include/p_spec.h index 805f7682af..5c3cf56527 100644 --- a/doomsday/plugins/jdoom/include/p_spec.h +++ b/doomsday/plugins/jdoom/include/p_spec.h @@ -72,12 +72,12 @@ typedef enum { pastdest } result_e; -result_e T_MovePlane(Sector* sector, float speed, float dest, - int crush, int floorOrCeiling, int direction); +result_e T_MovePlane(Sector* sector, float speed, coord_t dest, int crush, + int floorOrCeiling, int direction); -int EV_BuildStairs(LineDef* line, stair_e type); +int EV_BuildStairs(LineDef* line, stair_e type); -boolean P_UseSpecialLine2(mobj_t* mo, LineDef* line, int side); +boolean P_UseSpecialLine2(mobj_t* mo, LineDef* line, int side); #endif diff --git a/doomsday/plugins/jdoom/include/r_defs.h b/doomsday/plugins/jdoom/include/r_defs.h index 22c81e5941..ef1e0f8cfb 100644 --- a/doomsday/plugins/jdoom/include/r_defs.h +++ b/doomsday/plugins/jdoom/include/r_defs.h @@ -62,7 +62,7 @@ typedef struct xsector_s { byte seqType; // NOT USED ATM struct { - float origHeight; + coord_t origHeight; } planes[2]; // {floor, ceiling} float origLight; diff --git a/doomsday/plugins/jdoom/include/st_stuff.h b/doomsday/plugins/jdoom/include/st_stuff.h index 403fe7a3d2..5ec1c5b634 100644 --- a/doomsday/plugins/jdoom/include/st_stuff.h +++ b/doomsday/plugins/jdoom/include/st_stuff.h @@ -118,9 +118,9 @@ float ST_AutomapOpacity(int player); boolean ST_AutomapObscures2(int player, const RectRaw* region); boolean ST_AutomapObscures(int player, int x, int y, int width, int height); -int ST_AutomapAddPoint(int player, float x, float y, float z); +int ST_AutomapAddPoint(int player, coord_t x, coord_t y, coord_t z); void ST_AutomapClearPoints(int player); -boolean ST_AutomapPointOrigin(int player, int point, float* x, float* y, float* z); +boolean ST_AutomapPointOrigin(int player, int point, coord_t* x, coord_t* y, coord_t* z); void ST_SetAutomapCameraRotation(int player, boolean on); diff --git a/doomsday/plugins/jdoom/src/d_api.c b/doomsday/plugins/jdoom/src/d_api.c index f0dea5b4c5..b573f21196 100644 --- a/doomsday/plugins/jdoom/src/d_api.c +++ b/doomsday/plugins/jdoom/src/d_api.c @@ -234,9 +234,9 @@ game_export_t* GetGameAPI(game_import_t* imports) gx.Responder = G_Responder; gx.EndFrame = D_EndFrame; gx.MobjThinker = P_MobjThinker; - gx.MobjFriction = (float (*)(void *)) P_MobjGetFriction; - gx.MobjCheckPosition3f = P_CheckPosition3f; - gx.MobjTryMove3f = P_TryMove3f; + gx.MobjFriction = (coord_t (*)(void *)) P_MobjGetFriction; + gx.MobjCheckPositionXYZ = P_CheckPositionXYZ; + gx.MobjTryMoveXYZ = P_TryMoveXYZ; gx.SectorHeightChangeNotification = P_HandleSectorHeightChange; gx.UpdateState = G_UpdateState; gx.GetInteger = D_GetInteger; diff --git a/doomsday/plugins/jdoom/src/d_console.c b/doomsday/plugins/jdoom/src/d_console.c index d5fdd282d6..933f1cb4ed 100644 --- a/doomsday/plugins/jdoom/src/d_console.c +++ b/doomsday/plugins/jdoom/src/d_console.c @@ -87,7 +87,7 @@ cvartemplate_t gameCVars[] = { // Items {"server-game-nobfg", 0, CVT_BYTE, &cfg.noNetBFG, 0, 1}, #if 0 - {"server-game-coop-nothing", 0, CVT_BYTE, &cfg.noCoopAnything, 0, 1}, // not implemented atm, see P_SpawnMobj3f + {"server-game-coop-nothing", 0, CVT_BYTE, &cfg.noCoopAnything, 0, 1}, // not implemented atm, see P_SpawnMobjXYZ #endif {"server-game-coop-respawn-items", 0, CVT_BYTE, &cfg.coopRespawnItems, 0, 1}, diff --git a/doomsday/plugins/jdoom/src/m_cheat.c b/doomsday/plugins/jdoom/src/m_cheat.c index 19900c4998..1799ef05ed 100644 --- a/doomsday/plugins/jdoom/src/m_cheat.c +++ b/doomsday/plugins/jdoom/src/m_cheat.c @@ -521,9 +521,9 @@ int Cht_MyPosFunc(const int* args, int player) sprintf(buf, "ang=0x%x;x,y,z=(%g,%g,%g)", players[CONSOLEPLAYER].plr->mo->angle, - players[CONSOLEPLAYER].plr->mo->pos[VX], - players[CONSOLEPLAYER].plr->mo->pos[VY], - players[CONSOLEPLAYER].plr->mo->pos[VZ]); + players[CONSOLEPLAYER].plr->mo->origin[VX], + players[CONSOLEPLAYER].plr->mo->origin[VY], + players[CONSOLEPLAYER].plr->mo->origin[VZ]); P_SetMessage(plr, buf, false); return true; } @@ -541,8 +541,8 @@ static void printDebugInfo(player_t* plr) mapUri = G_ComposeMapUri(gameEpisode, gameMap); mapPath = Uri_ToString(mapUri); sprintf(textBuffer, "MAP [%s] X:%g Y:%g Z:%g", - Str_Text(mapPath), plr->plr->mo->pos[VX], plr->plr->mo->pos[VY], - plr->plr->mo->pos[VZ]); + Str_Text(mapPath), plr->plr->mo->origin[VX], plr->plr->mo->origin[VY], + plr->plr->mo->origin[VZ]); P_SetMessage(plr, textBuffer, false); Str_Delete(mapPath); Uri_Delete(mapUri); @@ -554,13 +554,13 @@ static void printDebugInfo(player_t* plr) uri = Materials_ComposeUri(P_GetIntp(sub, DMU_FLOOR_MATERIAL)); path = Uri_ToString(uri); - Con_Message(" FloorZ:%g Material:%s\n", P_GetFloatp(sub, DMU_FLOOR_HEIGHT), Str_Text(path)); + Con_Message(" FloorZ:%g Material:%s\n", P_GetDoublep(sub, DMU_FLOOR_HEIGHT), Str_Text(path)); Str_Delete(path); Uri_Delete(uri); uri = Materials_ComposeUri(P_GetIntp(sub, DMU_CEILING_MATERIAL)); path = Uri_ToString(uri); - Con_Message(" CeilingZ:%g Material:%s\n", P_GetFloatp(sub, DMU_CEILING_HEIGHT), Str_Text(path)); + Con_Message(" CeilingZ:%g Material:%s\n", P_GetDoublep(sub, DMU_CEILING_HEIGHT), Str_Text(path)); Str_Delete(path); Uri_Delete(uri); diff --git a/doomsday/plugins/jdoom/src/p_enemy.c b/doomsday/plugins/jdoom/src/p_enemy.c index ff4724c5f2..858de8ce54 100644 --- a/doomsday/plugins/jdoom/src/p_enemy.c +++ b/doomsday/plugins/jdoom/src/p_enemy.c @@ -71,15 +71,15 @@ braindata_t brain; // Global state of boss brain. // PRIVATE DATA DEFINITIONS ------------------------------------------------ -static mobj_t *corpseHit; -static mobj_t *vileObj; -static float vileTry[3]; +static mobj_t* corpseHit; +static mobj_t* vileObj; +static coord_t vileTry[3]; -static float dropoffDelta[2], floorZ; +static coord_t dropoffDelta[2], floorZ; // Eight directional movement speeds. -#define MOVESPEED_DIAGONAL (0.71716309f) -static const float dirSpeed[8][2] = +#define MOVESPEED_DIAGONAL (0.71716309) +static const coord_t dirSpeed[8][2] = { {1, 0}, {MOVESPEED_DIAGONAL, MOVESPEED_DIAGONAL}, @@ -98,27 +98,29 @@ static const float dirSpeed[8][2] = * If a monster yells at a player, it will alert other monsters to the * player's whereabouts. */ -void P_NoiseAlert(mobj_t *target, mobj_t *emitter) +void P_NoiseAlert(mobj_t* target, mobj_t* emitter) { VALIDCOUNT++; P_RecursiveSound(target, P_GetPtrp(emitter->bspLeaf, DMU_SECTOR), 0); } -static boolean checkMeleeRange(mobj_t *actor) +static boolean checkMeleeRange(mobj_t* actor) { - mobj_t *pl; - float dist, range; + mobj_t* pl; + coord_t dist, range; if(!actor->target) return false; pl = actor->target; - dist = P_ApproxDistance(pl->pos[VX] - actor->pos[VX], - pl->pos[VY] - actor->pos[VY]); + dist = M_ApproxDistance(pl->origin[VX] - actor->origin[VX], + pl->origin[VY] - actor->origin[VY]); + if(!cfg.netNoMaxZMonsterMeleeAttack) - { // Account for Z height difference. - if(pl->pos[VZ] > actor->pos[VZ] + actor->height || - pl->pos[VZ] + pl->height < actor->pos[VZ]) + { + // Account for Z height difference. + if(pl->origin[VZ] > actor->origin[VZ] + actor->height || + pl->origin[VZ] + pl->height < actor->origin[VZ]) return false; } @@ -132,9 +134,9 @@ static boolean checkMeleeRange(mobj_t *actor) return true; } -static boolean checkMissileRange(mobj_t *actor) +static boolean checkMissileRange(mobj_t* actor) { - float dist; + coord_t dist; if(!P_CheckSight(actor, actor->target)) return false; @@ -149,9 +151,8 @@ static boolean checkMissileRange(mobj_t *actor) if(actor->reactionTime) return false; // Do not attack yet. - dist = - P_ApproxDistance(actor->pos[VX] - actor->target->pos[VX], - actor->pos[VY] - actor->target->pos[VY]) - 64; + dist = M_ApproxDistance(actor->origin[VX] - actor->target->origin[VX], + actor->origin[VY] - actor->target->origin[VY]) - 64; if(P_GetState(actor->type, SN_MELEE) == S_NULL) dist -= 128; // No melee attack, so fire more. @@ -181,7 +182,7 @@ static boolean checkMissileRange(mobj_t *actor) if(actor->type == MT_CYBORG && dist > 160) dist = 160; - if((float) P_Random() < dist) + if((coord_t) P_Random() < dist) return false; return true; @@ -194,7 +195,7 @@ static boolean checkMissileRange(mobj_t *actor) */ static boolean moveMobj(mobj_t* actor, boolean dropoff) { - float pos[3], step[3]; + coord_t pos[3], step[3]; LineDef* ld; boolean good; @@ -206,19 +207,19 @@ static boolean moveMobj(mobj_t* actor, boolean dropoff) step[VX] = actor->info->speed * dirSpeed[actor->moveDir][MX]; step[VY] = actor->info->speed * dirSpeed[actor->moveDir][MY]; - pos[VX] = actor->pos[VX] + step[VX]; - pos[VY] = actor->pos[VY] + step[VY]; + pos[VX] = actor->origin[VX] + step[VX]; + pos[VY] = actor->origin[VY] + step[VY]; // $dropoff_fix - if(!P_TryMove(actor, pos[VX], pos[VY], dropoff, false)) + if(!P_TryMoveXY(actor, pos[VX], pos[VY], dropoff, false)) { // Float up and down to the contacted floor height. if((actor->flags & MF_FLOAT) && floatOk) { - if(actor->pos[VZ] < tmFloorZ) - actor->pos[VZ] += FLOATSPEED; + if(actor->origin[VZ] < tmFloorZ) + actor->origin[VZ] += FLOATSPEED; else - actor->pos[VZ] -= FLOATSPEED; + actor->origin[VZ] -= FLOATSPEED; // What if we just floated into another mobj?? actor->flags |= MF_INFLOAT; @@ -270,10 +271,10 @@ static boolean moveMobj(mobj_t* actor, boolean dropoff) // $dropoff_fix: fall more slowly, under gravity, if fellDown==true if(!(actor->flags & MF_FLOAT) && !fellDown) { - if(actor->pos[VZ] > actor->floorZ) + if(actor->origin[VZ] > actor->floorZ) P_HitFloor(actor); - actor->pos[VZ] = actor->floorZ; + actor->origin[VZ] = actor->floorZ; } return true; @@ -297,17 +298,17 @@ static boolean tryMoveMobj(mobj_t *actor) return true; } -static void doNewChaseDir(mobj_t *actor, float deltaX, float deltaY) +static void doNewChaseDir(mobj_t *actor, coord_t deltaX, coord_t deltaY) { - dirtype_t xdir, ydir, tdir; - dirtype_t olddir = actor->moveDir; - dirtype_t turnaround = olddir; + dirtype_t xdir, ydir, tdir; + dirtype_t olddir = actor->moveDir; + dirtype_t turnaround = olddir; if(turnaround != DI_NODIR) // Find reverse direction. turnaround ^= 4; - xdir = (deltaX > 10 ? DI_EAST : deltaX < -10 ? DI_WEST : DI_NODIR); - ydir = (deltaY < -10 ? DI_SOUTH : deltaY > 10 ? DI_NORTH : DI_NODIR); + xdir = (deltaX > 10 ? DI_EAST : deltaX < -10 ? DI_WEST : DI_NODIR); + ydir = (deltaY < -10 ? DI_SOUTH : deltaY > 10 ? DI_NORTH : DI_NODIR); // Try direct route. if(xdir != DI_NODIR && ydir != DI_NODIR && @@ -363,13 +364,13 @@ static void doNewChaseDir(mobj_t *actor, float deltaX, float deltaY) * * In Doom, they were never allowed to hang over dropoffs, and would remain * stuck if involuntarily forced over one. This logic, combined with - * p_map.c::P_TryMove(), allows monsters to free themselves without making + * p_map.c::P_TryMoveXY(), allows monsters to free themselves without making * them tend to hang over dropoffs. */ static int PIT_AvoidDropoff(LineDef* line, void* data) { Sector* backsector = P_GetPtrp(line, DMU_BACK_SECTOR); - AABoxf* aaBox = P_GetPtrp(line, DMU_BOUNDING_BOX); + AABoxd* aaBox = P_GetPtrp(line, DMU_BOUNDING_BOX); if(backsector && // Linedef must be contacted @@ -377,28 +378,27 @@ static int PIT_AvoidDropoff(LineDef* line, void* data) tmBox.maxX > aaBox->minX && tmBox.minY < aaBox->maxY && tmBox.maxY > aaBox->minY && - P_BoxOnLineSide(&tmBox, line) == -1) + !LineDef_BoxOnSide(line, &tmBox)) { - Sector* frontsector = P_GetPtrp(line, DMU_FRONT_SECTOR); - float front = P_GetFloatp(frontsector, DMU_FLOOR_HEIGHT); - float back = P_GetFloatp(backsector, DMU_FLOOR_HEIGHT); - float d1[2]; - angle_t angle; + Sector* frontsector = P_GetPtrp(line, DMU_FRONT_SECTOR); + coord_t front = P_GetDoublep(frontsector, DMU_FLOOR_HEIGHT); + coord_t back = P_GetDoublep(backsector, DMU_FLOOR_HEIGHT); + coord_t d1[2]; + angle_t angle; - P_GetFloatpv(line, DMU_DXY, d1); + P_GetDoublepv(line, DMU_DXY, d1); // The monster must contact one of the two floors, and the other // must be a tall drop off (more than 24). if(back == floorZ && front < floorZ - 24) { - angle = R_PointToAngle2(0, 0, d1[0], d1[1]); // Front side drop off. + angle = M_PointXYToAngle2(0, 0, d1[0], d1[1]); // Front side drop off. } else { if(front == floorZ && back < floorZ - 24) - angle = R_PointToAngle2(d1[0], d1[1], 0, 0); // Back side drop off. - else - return false; + angle = M_PointXYToAngle2(d1[0], d1[1], 0, 0); // Back side drop off. + return false; } // Move away from drop off at a standard speed. @@ -413,9 +413,9 @@ static int PIT_AvoidDropoff(LineDef* line, void* data) /** * Driver for above. */ -static boolean avoidDropoff(mobj_t *actor) +static boolean avoidDropoff(mobj_t* actor) { - floorZ = actor->pos[VZ]; // Remember floor height. + floorZ = actor->origin[VZ]; // Remember floor height. dropoffDelta[VX] = dropoffDelta[VY] = 0; @@ -428,14 +428,14 @@ static boolean avoidDropoff(mobj_t *actor) return !(FEQUAL(dropoffDelta[VX], 0) || FEQUAL(dropoffDelta[VY], 0)); } -static void newChaseDir(mobj_t *actor) +static void newChaseDir(mobj_t* actor) { - mobj_t *target = actor->target; - float deltaX = target->pos[VX] - actor->pos[VX]; - float deltaY = target->pos[VY] - actor->pos[VY]; + mobj_t* target = actor->target; + coord_t deltaX = target->origin[VX] - actor->origin[VX]; + coord_t deltaY = target->origin[VY] - actor->origin[VY]; if(actor->floorZ - actor->dropOffZ > 24 && - actor->pos[VZ] <= actor->floorZ && + actor->origin[VZ] <= actor->floorZ && !(actor->flags & (MF_DROPOFF | MF_FLOAT)) && !cfg.avoidDropoffs && avoidDropoff(actor)) { @@ -703,22 +703,19 @@ void C_DECL A_FaceTarget(mobj_t *actor) actor->turnTime = true; // $visangle-facetarget actor->flags &= ~MF_AMBUSH; - actor->angle = - R_PointToAngle2(actor->pos[VX], actor->pos[VY], - actor->target->pos[VX], actor->target->pos[VY]); + actor->angle = M_PointToAngle2(actor->origin, actor->target->origin); if(actor->target->flags & MF_SHADOW) actor->angle += (P_Random() - P_Random()) << 21; } -void C_DECL A_PosAttack(mobj_t *actor) +void C_DECL A_PosAttack(mobj_t* actor) { - int damage; - angle_t angle; - float slope; + int damage; + angle_t angle; + float slope; - if(!actor->target) - return; + if(!actor->target) return; A_FaceTarget(actor); angle = actor->angle; @@ -730,14 +727,13 @@ void C_DECL A_PosAttack(mobj_t *actor) P_LineAttack(actor, angle, MISSILERANGE, slope, damage); } -void C_DECL A_SPosAttack(mobj_t *actor) +void C_DECL A_SPosAttack(mobj_t* actor) { - int i, damage; - angle_t angle, bangle; - float slope; + int i, damage; + angle_t angle, bangle; + float slope; - if(!actor->target) - return; + if(!actor->target) return; S_StartSound(SFX_SHOTGN, actor); A_FaceTarget(actor); @@ -896,42 +892,40 @@ void C_DECL A_BruisAttack(mobj_t *actor) P_SpawnMissile(MT_BRUISERSHOT, actor, actor->target); } -void C_DECL A_SkelMissile(mobj_t *actor) +void C_DECL A_SkelMissile(mobj_t* actor) { - mobj_t *mo; + mobj_t* mo; - if(!actor->target) - return; + if(!actor->target) return; A_FaceTarget(actor); mo = P_SpawnMissile(MT_TRACER, actor, actor->target); if(mo) { - mo->pos[VX] += mo->mom[MX]; - mo->pos[VY] += mo->mom[MY]; + mo->origin[VX] += mo->mom[MX]; + mo->origin[VY] += mo->mom[MY]; mo->tracer = actor->target; } } void C_DECL A_Tracer(mobj_t* actor) { - uint an; - angle_t angle; - float dist; - float slope; - mobj_t* dest, *th; + uint an; + angle_t angle; + coord_t dist; + float slope; + mobj_t* dest, *th; - if((int) GAMETIC & 3) - return; + if((int) GAMETIC & 3) return; // Spawn a puff of smoke behind the rocket. - P_SpawnCustomPuff(MT_ROCKETPUFF, actor->pos[VX], - actor->pos[VY], - actor->pos[VZ], actor->angle + ANG180); + P_SpawnCustomPuff(MT_ROCKETPUFF, actor->origin[VX], + actor->origin[VY], + actor->origin[VZ], actor->angle + ANG180); - if((th = P_SpawnMobj3f(MT_SMOKE, actor->pos[VX] - actor->mom[MX], - actor->pos[VY] - actor->mom[MY], actor->pos[VZ], + if((th = P_SpawnMobjXYZ(MT_SMOKE, actor->origin[VX] - actor->mom[MX], + actor->origin[VY] - actor->mom[MY], actor->origin[VZ], actor->angle + ANG180, 0))) { th->mom[MZ] = FIX2FLT(FRACUNIT); @@ -947,8 +941,7 @@ void C_DECL A_Tracer(mobj_t* actor) return; // Change angle. - angle = R_PointToAngle2(actor->pos[VX], actor->pos[VY], - dest->pos[VX], dest->pos[VY]); + angle = M_PointToAngle2(actor->origin, dest->origin); if(angle != actor->angle) { @@ -971,13 +964,13 @@ void C_DECL A_Tracer(mobj_t* actor) actor->mom[MY] = actor->info->speed * FIX2FLT(finesine[an]); // Change slope. - dist = P_ApproxDistance(dest->pos[VX] - actor->pos[VX], - dest->pos[VY] - actor->pos[VY]); + dist = M_ApproxDistance(dest->origin[VX] - actor->origin[VX], + dest->origin[VY] - actor->origin[VY]); dist /= actor->info->speed; if(dist < 1) dist = 1; - slope = (dest->pos[VZ] + 40 - actor->pos[VZ]) / dist; + slope = (dest->origin[VZ] + 40 - actor->origin[VZ]) / dist; if(slope < actor->mom[MZ]) actor->mom[MZ] -= FIX2FLT(FRACUNIT / 8); @@ -985,21 +978,19 @@ void C_DECL A_Tracer(mobj_t* actor) actor->mom[MZ] += FIX2FLT(FRACUNIT / 8); } -void C_DECL A_SkelWhoosh(mobj_t *actor) +void C_DECL A_SkelWhoosh(mobj_t* actor) { - if(!actor->target) - return; + if(!actor->target) return; A_FaceTarget(actor); S_StartSound(SFX_SKESWG, actor); } -void C_DECL A_SkelFist(mobj_t *actor) +void C_DECL A_SkelFist(mobj_t* actor) { - int damage; + int damage; - if(!actor->target) - return; + if(!actor->target) return; A_FaceTarget(actor); if(checkMeleeRange(actor)) @@ -1013,10 +1004,10 @@ void C_DECL A_SkelFist(mobj_t *actor) /** * Detect a corpse that could be raised. */ -int PIT_VileCheck(mobj_t *thing, void *data) +int PIT_VileCheck(mobj_t* thing, void* data) { - float maxdist; - boolean check; + coord_t maxdist; + boolean check; if(!(thing->flags & MF_CORPSE)) return false; // Not a monster. @@ -1029,8 +1020,8 @@ int PIT_VileCheck(mobj_t *thing, void *data) maxdist = thing->info->radius + MOBJINFO[MT_VILE].radius; - if(fabs(thing->pos[VX] - vileTry[VX]) > maxdist || - fabs(thing->pos[VY] - vileTry[VY]) > maxdist) + if(fabs(thing->origin[VX] - vileTry[VX]) > maxdist || + fabs(thing->origin[VY] - vileTry[VY]) > maxdist) return false; // Not actually touching. corpseHit = thing; @@ -1041,12 +1032,12 @@ int PIT_VileCheck(mobj_t *thing, void *data) if(cfg.raiseGhosts) { corpseHit->height *= 2*2; - check = P_CheckPosition2f(corpseHit, corpseHit->pos[VX], corpseHit->pos[VY]); + check = P_CheckPositionXY(corpseHit, corpseHit->origin[VX], corpseHit->origin[VY]); corpseHit->height /= 2*2; } else { - float radius, height; + coord_t radius, height; height = corpseHit->height; // Save temporarily. radius = corpseHit->radius; // Save temporarily. @@ -1054,7 +1045,7 @@ int PIT_VileCheck(mobj_t *thing, void *data) corpseHit->radius = corpseHit->info->radius; corpseHit->flags |= MF_SOLID; - check = P_CheckPosition2f(corpseHit, corpseHit->pos[VX], corpseHit->pos[VY]); + check = P_CheckPositionXY(corpseHit, corpseHit->origin[VX], corpseHit->origin[VY]); corpseHit->height = height; // Restore. corpseHit->radius = radius; // Restore. @@ -1075,13 +1066,13 @@ void C_DECL A_VileChase(mobj_t *actor) { mobjinfo_t* info; mobj_t* temp; - AABoxf box; + AABoxd box; if(actor->moveDir != DI_NODIR) { // Check for corpses to raise. - vileTry[VX] = actor->pos[VX] + actor->info->speed * dirSpeed[actor->moveDir][VX]; - vileTry[VY] = actor->pos[VY] + actor->info->speed * dirSpeed[actor->moveDir][VY]; + vileTry[VX] = actor->origin[VX] + actor->info->speed * dirSpeed[actor->moveDir][VX]; + vileTry[VY] = actor->origin[VY] + actor->info->speed * dirSpeed[actor->moveDir][VY]; box.minX = vileTry[VX] - MAXRADIUS * 2; box.minY = vileTry[VY] - MAXRADIUS * 2; @@ -1134,13 +1125,13 @@ void C_DECL A_VileStart(mobj_t *actor) S_StartSound(SFX_VILATK, actor); } -void C_DECL A_StartFire(mobj_t *actor) +void C_DECL A_StartFire(mobj_t* actor) { S_StartSound(SFX_FLAMST, actor); A_Fire(actor); } -void C_DECL A_FireCrackle(mobj_t *actor) +void C_DECL A_FireCrackle(mobj_t* actor) { S_StartSound(SFX_FLAME, actor); A_Fire(actor); @@ -1149,26 +1140,24 @@ void C_DECL A_FireCrackle(mobj_t *actor) /** * Keep fire in front of player unless out of sight. */ -void C_DECL A_Fire(mobj_t *actor) +void C_DECL A_Fire(mobj_t* actor) { - mobj_t *dest; - uint an; + mobj_t* dest; + uint an; dest = actor->tracer; - if(!dest) - return; + if(!dest) return; // Don't move it if the vile lost sight. - if(!P_CheckSight(actor->target, dest)) - return; + if(!P_CheckSight(actor->target, dest)) return; an = dest->angle >> ANGLETOFINESHIFT; - P_MobjUnsetPosition(actor); - memcpy(actor->pos, dest->pos, sizeof(actor->pos)); - actor->pos[VX] += 24 * FIX2FLT(finecosine[an]); - actor->pos[VY] += 24 * FIX2FLT(finesine[an]); - P_MobjSetPosition(actor); + P_MobjUnsetOrigin(actor); + memcpy(actor->origin, dest->origin, sizeof(actor->origin)); + actor->origin[VX] += 24 * FIX2FLT(finecosine[an]); + actor->origin[VY] += 24 * FIX2FLT(finesine[an]); + P_MobjSetOrigin(actor); } /** @@ -1176,15 +1165,14 @@ void C_DECL A_Fire(mobj_t *actor) */ void C_DECL A_VileTarget(mobj_t* actor) { - mobj_t* fog; + mobj_t* fog; - if(!actor->target) - return; + if(!actor->target) return; A_FaceTarget(actor); - if((fog = P_SpawnMobj3fv(MT_FIRE, actor->target->pos, - actor->target->angle + ANG180, 0))) + if((fog = P_SpawnMobj(MT_FIRE, actor->target->origin, + actor->target->angle + ANG180, 0))) { actor->tracer = fog; fog->target = actor; @@ -1195,16 +1183,14 @@ void C_DECL A_VileTarget(mobj_t* actor) void C_DECL A_VileAttack(mobj_t* actor) { - mobj_t* fire; - uint an; + mobj_t* fire; + uint an; - if(!actor->target) - return; + if(!actor->target) return; A_FaceTarget(actor); - if(!P_CheckSight(actor, actor->target)) - return; + if(!P_CheckSight(actor, actor->target)) return; S_StartSound(SFX_BAREXP, actor); P_DamageMobj(actor->target, actor, actor, 20, false); @@ -1218,8 +1204,8 @@ void C_DECL A_VileAttack(mobj_t* actor) return; // Move the fire between the Vile and the player. - fire->pos[VX] = actor->target->pos[VX] - 24 * FIX2FLT(finecosine[an]); - fire->pos[VY] = actor->target->pos[VY] - 24 * FIX2FLT(finesine[an]); + fire->origin[VX] = actor->target->origin[VX] - 24 * FIX2FLT(finecosine[an]); + fire->origin[VY] = actor->target->origin[VY] - 24 * FIX2FLT(finesine[an]); P_RadiusAttack(fire, actor, 70, 69); } @@ -1301,14 +1287,13 @@ void C_DECL A_FatAttack3(mobj_t *actor) /** * LostSoul Attack: Fly at the player like a missile. */ -void C_DECL A_SkullAttack(mobj_t *actor) +void C_DECL A_SkullAttack(mobj_t* actor) { - mobj_t *dest; - uint an; - float dist; + mobj_t* dest; + uint an; + coord_t dist; - if(!actor->target) - return; + if(!actor->target) return; dest = actor->target; actor->flags |= MF_SKULLFLY; @@ -1320,14 +1305,13 @@ void C_DECL A_SkullAttack(mobj_t *actor) actor->mom[MX] = SKULLSPEED * FIX2FLT(finecosine[an]); actor->mom[MY] = SKULLSPEED * FIX2FLT(finesine[an]); - dist = P_ApproxDistance(dest->pos[VX] - actor->pos[VX], - dest->pos[VY] - actor->pos[VY]); + dist = M_ApproxDistance(dest->origin[VX] - actor->origin[VX], + dest->origin[VY] - actor->origin[VY]); dist /= SKULLSPEED; if(dist < 1) dist = 1; - actor->mom[MZ] = - (dest->pos[VZ] + (dest->height / 2) - actor->pos[VZ]) / dist; + actor->mom[MZ] = (dest->origin[VZ] + (dest->height / 2) - actor->origin[VZ]) / dist; } /** @@ -1335,14 +1319,15 @@ void C_DECL A_SkullAttack(mobj_t *actor) */ void C_DECL A_PainShootSkull(mobj_t* actor, angle_t angle) { - float pos[3]; - mobj_t* newmobj; - uint an; - float prestep; - Sector* sec; + coord_t pos[3]; + mobj_t* newmobj; + uint an; + coord_t prestep; + Sector* sec; if(cfg.maxSkulls) - { // Limit the number of MT_SKULL's we should spawn. + { + // Limit the number of MT_SKULL's we should spawn. countmobjoftypeparams_t params; // Count total number currently on the map. @@ -1359,7 +1344,7 @@ void C_DECL A_PainShootSkull(mobj_t* actor, angle_t angle) prestep = 4 + 3 * ((actor->info->radius + MOBJINFO[MT_SKULL].radius) / 2); - memcpy(pos, actor->pos, sizeof(pos)); + memcpy(pos, actor->origin, sizeof(pos)); pos[VX] += prestep * FIX2FLT(finecosine[an]); pos[VY] += prestep * FIX2FLT(finesine[an]); pos[VZ] += 8; @@ -1376,16 +1361,15 @@ void C_DECL A_PainShootSkull(mobj_t* actor, angle_t angle) if(P_CheckSides(actor, pos[VX], pos[VY])) return; - if(!(newmobj = P_SpawnMobj3fv(MT_SKULL, pos, angle, 0))) + if(!(newmobj = P_SpawnMobj(MT_SKULL, pos, angle, 0))) return; sec = P_GetPtrp(newmobj->bspLeaf, DMU_SECTOR); // Check to see if the new Lost Soul's z value is above the // ceiling of its new sector, or below the floor. If so, kill it. - if((newmobj->pos[VZ] > - (P_GetFloatp(sec, DMU_CEILING_HEIGHT) - newmobj->height)) || - (newmobj->pos[VZ] < P_GetFloatp(sec, DMU_FLOOR_HEIGHT))) + if((newmobj->origin[VZ] > (P_GetDoublep(sec, DMU_CEILING_HEIGHT) - newmobj->height)) || + (newmobj->origin[VZ] < P_GetDoublep(sec, DMU_FLOOR_HEIGHT))) { // Kill it immediately. P_DamageMobj(newmobj, actor, actor, 10000, false); @@ -1394,12 +1378,12 @@ void C_DECL A_PainShootSkull(mobj_t* actor, angle_t angle) } else { // Use the original DOOM method. - if(!(newmobj = P_SpawnMobj3fv(MT_SKULL, pos, angle, 0))) + if(!(newmobj = P_SpawnMobj(MT_SKULL, pos, angle, 0))) return; } // Check for movements, $dropoff_fix. - if(!P_TryMove(newmobj, newmobj->pos[VX], newmobj->pos[VY], false, false)) + if(!P_TryMoveXY(newmobj, newmobj->origin[VX], newmobj->origin[VY], false, false)) { // Kill it immediately. P_DamageMobj(newmobj, actor, actor, 10000, false); @@ -1751,18 +1735,18 @@ void C_DECL A_BrainPain(mobj_t* mo) void C_DECL A_BrainScream(mobj_t* mo) { - float pos[3]; + coord_t pos[3]; - pos[VY] = mo->pos[VY] - 320; + pos[VY] = mo->origin[VY] - 320; - for(pos[VX] = mo->pos[VX] - 196; pos[VX] < mo->pos[VX] + 320; + for(pos[VX] = mo->origin[VX] - 196; pos[VX] < mo->origin[VX] + 320; pos[VX] += 8) { - mobj_t* th; + mobj_t* th; pos[VZ] = 128 + (P_Random() * 2); - if((th = P_SpawnMobj3fv(MT_ROCKET, pos, P_Random() << 24, 0))) + if((th = P_SpawnMobj(MT_ROCKET, pos, P_Random() << 24, 0))) { th->mom[MZ] = FIX2FLT(P_Random() * 512); @@ -1779,14 +1763,14 @@ void C_DECL A_BrainScream(mobj_t* mo) void C_DECL A_BrainExplode(mobj_t* mo) { - float pos[3]; - mobj_t* th; + coord_t pos[3]; + mobj_t* th; - pos[VX] = mo->pos[VX] + FIX2FLT((P_Random() - P_Random()) * 2048); - pos[VY] = mo->pos[VY]; + pos[VX] = mo->origin[VX] + FIX2FLT((P_Random() - P_Random()) * 2048); + pos[VY] = mo->origin[VY]; pos[VZ] = 128 + (P_Random() * 2); - if((th = P_SpawnMobj3fv(MT_ROCKET, pos, P_Random() << 24, 0))) + if((th = P_SpawnMobj(MT_ROCKET, pos, P_Random() << 24, 0))) { th->mom[MZ] = FIX2FLT(P_Random() * 512); @@ -1798,15 +1782,15 @@ void C_DECL A_BrainExplode(mobj_t* mo) } } -void C_DECL A_BrainDie(mobj_t *mo) +void C_DECL A_BrainDie(mobj_t* mo) { G_LeaveMap(G_GetMapNumber(gameEpisode, gameMap), 0, false); } -void C_DECL A_BrainSpit(mobj_t *mo) +void C_DECL A_BrainSpit(mobj_t* mo) { - mobj_t *targ; - mobj_t *newmobj; + mobj_t* targ; + mobj_t* newmobj; if(!brain.numTargets) return; // Ignore if no targets. @@ -1825,7 +1809,7 @@ void C_DECL A_BrainSpit(mobj_t *mo) { newmobj->target = targ; newmobj->reactionTime = - ((targ->pos[VY] - mo->pos[VY]) / newmobj->mom[MY]) / newmobj->state->tics; + ((targ->origin[VY] - mo->origin[VY]) / newmobj->mom[MY]) / newmobj->state->tics; } S_StartSound(SFX_BOSPIT, NULL); @@ -1854,7 +1838,7 @@ void C_DECL A_SpawnFly(mobj_t *mo) targ = mo->target; // First spawn teleport fog. - if((fog = P_SpawnMobj3fv(MT_SPAWNFIRE, targ->pos, targ->angle + ANG180, 0))) + if((fog = P_SpawnMobj(MT_SPAWNFIRE, targ->origin, targ->angle + ANG180, 0))) S_StartSound(SFX_TELEPT, fog); // Randomly select monster to spawn. @@ -1884,13 +1868,13 @@ void C_DECL A_SpawnFly(mobj_t *mo) else type = MT_BRUISER; - if((newmobj = P_SpawnMobj3fv(type, targ->pos, P_Random() << 24, 0))) + if((newmobj = P_SpawnMobj(type, targ->origin, P_Random() << 24, 0))) { if(Mobj_LookForPlayers(newmobj, true)) P_MobjChangeState(newmobj, P_GetState(newmobj->type, SN_SEE)); // Telefrag anything in this spot. - P_TeleportMove(newmobj, newmobj->pos[VX], newmobj->pos[VY], false); + P_TeleportMove(newmobj, newmobj->origin[VX], newmobj->origin[VY], false); } // Remove self (i.e., cube). diff --git a/doomsday/plugins/jdoom/src/p_inter.c b/doomsday/plugins/jdoom/src/p_inter.c index 8bd154af26..467ed462cb 100644 --- a/doomsday/plugins/jdoom/src/p_inter.c +++ b/doomsday/plugins/jdoom/src/p_inter.c @@ -299,7 +299,7 @@ boolean P_GivePower(player_t* player, int power) player->powers[power] = 1; player->plr->mo->flags2 |= MF2_FLY; player->plr->mo->flags |= MF_NOGRAVITY; - if(player->plr->mo->pos[VZ] <= player->plr->mo->floorZ) + if(player->plr->mo->origin[VZ] <= player->plr->mo->floorZ) { player->flyHeight = 10; // Thrust the player in the air a bit. player->plr->mo->flags |= DDPF_FIXMOM; @@ -343,7 +343,7 @@ boolean P_TakePower(player_t* player, int power) player->update |= PSF_POWERS; if(player->powers[PT_FLIGHT]) { - if(plrmo->pos[VZ] != plrmo->floorZ && cfg.lookSpring) + if(plrmo->origin[VZ] != plrmo->floorZ && cfg.lookSpring) { player->centering = true; } @@ -835,11 +835,11 @@ static boolean giveItem(player_t* plr, itemtype_t item, boolean dropped) void P_TouchSpecialMobj(mobj_t* special, mobj_t* toucher) { - player_t* player; - float delta; - itemtype_t item; + player_t* player; + coord_t delta; + itemtype_t item; - delta = special->pos[VZ] - toucher->pos[VZ]; + delta = special->origin[VZ] - toucher->origin[VZ]; if(delta > toucher->height || delta < -8) { // Out of reach. return; @@ -982,9 +982,9 @@ void P_KillMobj(mobj_t *source, mobj_t *target, boolean stomping) // 3D sprites. angle = P_Random() << 24; an = angle >> ANGLETOFINESHIFT; - if((mo = P_SpawnMobj3f(item, target->pos[VX] + 3 * FIX2FLT(finecosine[an]), - target->pos[VY] + 3 * FIX2FLT(finesine[an]), - 0, angle, MSF_Z_FLOOR))) + if((mo = P_SpawnMobjXYZ(item, target->origin[VX] + 3 * FIX2FLT(finecosine[an]), + target->origin[VY] + 3 * FIX2FLT(finesine[an]), + 0, angle, MSF_Z_FLOOR))) mo->flags |= MF_DROPPED; // Special versions of items. } @@ -1083,17 +1083,15 @@ int P_DamageMobj2(mobj_t* target, mobj_t* inflictor, mobj_t* source, source->player->readyWeapon != WT_EIGHTH) && !(inflictor->flags2 & MF2_NODMGTHRUST)) { - uint an; - float thrust; - - angle = R_PointToAngle2(inflictor->pos[VX], inflictor->pos[VY], - target->pos[VX], target->pos[VY]); + uint an; + coord_t thrust; + angle = M_PointToAngle2(inflictor->origin, target->origin); thrust = FIX2FLT(damage * (FRACUNIT>>3) * 100 / target->info->mass); // Make fall forwards sometimes. if(damage < 40 && damage > target->health && - target->pos[VZ] - inflictor->pos[VZ] > 64 && (P_Random() & 1)) + target->origin[VZ] - inflictor->origin[VZ] > 64 && (P_Random() & 1)) { angle += ANG180; thrust *= 4; diff --git a/doomsday/plugins/jdoom/src/p_maputl.c b/doomsday/plugins/jdoom/src/p_maputl.c index 9a4ace37ec..25607804ec 100644 --- a/doomsday/plugins/jdoom/src/p_maputl.c +++ b/doomsday/plugins/jdoom/src/p_maputl.c @@ -67,40 +67,40 @@ * If more than one linedef is contacted, the effects are cumulative, so * balancing is possible. */ -static int PIT_ApplyTorque(LineDef* ld, void* data) +static int PIT_ApplyTorque(LineDef* ld, void* parameters) { - mobj_t* mo = tmThing; - float dist; - Sector* frontsec, *backsec; - float ffloor, bfloor; - float d1[2], vtx[2]; + mobj_t* mo = tmThing; + coord_t dist; + Sector* frontsec, *backsec; + coord_t ffloor, bfloor; + coord_t d1[2], vtx[2]; if(tmThing->player) return false; // Skip players! if(!(frontsec = P_GetPtrp(ld, DMU_FRONT_SECTOR)) || - !(backsec = P_GetPtrp(ld, DMU_BACK_SECTOR))) + !(backsec = P_GetPtrp(ld, DMU_BACK_SECTOR))) return false; // Shouldn't ever happen. - ffloor = P_GetFloatp(frontsec, DMU_FLOOR_HEIGHT); - bfloor = P_GetFloatp(backsec, DMU_FLOOR_HEIGHT); - P_GetFloatpv(ld, DMU_DXY, d1); - P_GetFloatpv(P_GetPtrp(ld, DMU_VERTEX0), DMU_XY, vtx); + ffloor = P_GetDoublep(frontsec, DMU_FLOOR_HEIGHT); + bfloor = P_GetDoublep(backsec, DMU_FLOOR_HEIGHT); + P_GetDoublepv(ld, DMU_DXY, d1); + P_GetDoublepv(P_GetPtrp(ld, DMU_VERTEX0), DMU_XY, vtx); // Lever-arm: - dist = +d1[0] * mo->pos[VY] - d1[1] * mo->pos[VX] - - d1[0] * vtx[VY] + d1[1] * vtx[VX]; + dist = +d1[0] * mo->origin[VY] - d1[1] * mo->origin[VX] - + d1[0] * vtx[VY] + d1[1] * vtx[VX]; - if((dist < 0 && ffloor < mo->pos[VZ] && bfloor >= mo->pos[VZ]) || - (dist >= 0 && bfloor < mo->pos[VZ] && ffloor >= mo->pos[VZ])) + if((dist < 0 && ffloor < mo->origin[VZ] && bfloor >= mo->origin[VZ]) || + (dist >= 0 && bfloor < mo->origin[VZ] && ffloor >= mo->origin[VZ])) { // At this point, we know that the object straddles a two-sided // linedef, and that the object's center of mass is above-ground. - float x = fabs(d1[0]), y = fabs(d1[1]); + coord_t x = fabs(d1[0]), y = fabs(d1[1]); if(y > x) { - float tmp = x; + coord_t tmp = x; x = y; y = tmp; } diff --git a/doomsday/plugins/jdoom/src/p_mobj.c b/doomsday/plugins/jdoom/src/p_mobj.c index 63043aaeb4..696142eef2 100644 --- a/doomsday/plugins/jdoom/src/p_mobj.c +++ b/doomsday/plugins/jdoom/src/p_mobj.c @@ -143,9 +143,9 @@ void P_FloorBounceMissile(mobj_t *mo) /** * @return The ground friction factor for the mobj. */ -float P_MobjGetFriction(mobj_t *mo) +coord_t P_MobjGetFriction(mobj_t *mo) { - if((mo->flags2 & MF2_FLY) && !(mo->pos[VZ] <= mo->floorZ) && !mo->onMobj) + if((mo->flags2 & MF2_FLY) && !(mo->origin[VZ] <= mo->floorZ) && !mo->onMobj) { return FRICTION_FLY; } @@ -158,17 +158,19 @@ static __inline boolean isInWalkState(player_t* pl) return pl->plr->mo->state - STATES - PCLASS_INFO(pl->class_)->runState < 4; } -static float getFriction(mobj_t* mo) +static coord_t getFriction(mobj_t* mo) { - if((mo->flags2 & MF2_FLY) && !(mo->pos[VZ] <= mo->floorZ) && + if((mo->flags2 & MF2_FLY) && !(mo->origin[VZ] <= mo->floorZ) && !mo->onMobj) - { // Airborne friction. + { + // Airborne friction. return FRICTION_FLY; } #if __JHERETIC__ if(P_ToXSector(P_GetPtrp(mo->bspLeaf, DMU_SECTOR))->special == 15) - { // Friction_Low + { + // Friction_Low return FRICTION_LOW; } #endif @@ -178,7 +180,7 @@ static float getFriction(mobj_t* mo) void P_MobjMoveXY(mobj_t* mo) { - float pos[3], mom[3]; + coord_t pos[3], mom[3]; player_t* player; boolean largeNegative; @@ -190,7 +192,8 @@ void P_MobjMoveXY(mobj_t* mo) INRANGE_OF(mo->mom[MY], 0, NOMOM_THRESHOLD)) { if(mo->flags & MF_SKULLFLY) - { // The skull slammed into something. + { + // The skull slammed into something. mo->flags &= ~MF_SKULLFLY; mo->mom[MX] = mo->mom[MY] = mo->mom[MZ] = 0; @@ -225,15 +228,15 @@ void P_MobjMoveXY(mobj_t* mo) if(largeNegative || mom[MX] > MAXMOMSTEP || mom[MY] > MAXMOMSTEP) { - pos[VX] = mo->pos[VX] + mom[MX] / 2; - pos[VY] = mo->pos[VY] + mom[MY] / 2; + pos[VX] = mo->origin[VX] + mom[MX] / 2; + pos[VY] = mo->origin[VY] + mom[MY] / 2; mom[MX] /= 2; mom[MY] /= 2; } else { - pos[VX] = mo->pos[VX] + mom[MX]; - pos[VY] = mo->pos[VY] + mom[MY]; + pos[VX] = mo->origin[VX] + mom[MX]; + pos[VY] = mo->origin[VY] + mom[MY]; mom[MX] = mom[MY] = 0; } @@ -242,24 +245,26 @@ void P_MobjMoveXY(mobj_t* mo) mo->wallRun = false; // $dropoff_fix. - if(!P_TryMove(mo, pos[VX], pos[VY], true, false)) - { // Blocked move. + if(!P_TryMoveXY(mo, pos[VX], pos[VY], true, false)) + { + // Blocked move. if(mo->flags2 & MF2_SLIDE) - { // Try to slide along it. + { + // Try to slide along it. P_SlideMove(mo); } else if(mo->flags & MF_MISSILE) { Sector* backSec; - //// kludge: Prevent missiles exploding against the sky. + /// @kludge Prevent missiles exploding against the sky. if(ceilingLine && (backSec = P_GetPtrp(ceilingLine, DMU_BACK_SECTOR))) { material_t* mat = P_GetPtrp(backSec, DMU_CEILING_MATERIAL); if((P_GetIntp(mat, DMU_FLAGS) & MATF_SKYMASK) && - mo->pos[VZ] > P_GetFloatp(backSec, DMU_CEILING_HEIGHT)) + mo->origin[VZ] > P_GetDoublep(backSec, DMU_CEILING_HEIGHT)) { P_MobjRemove(mo, false); return; @@ -272,13 +277,13 @@ void P_MobjMoveXY(mobj_t* mo) material_t* mat = P_GetPtrp(backSec, DMU_FLOOR_MATERIAL); if((P_GetIntp(mat, DMU_FLAGS) & MATF_SKYMASK) && - mo->pos[VZ] < P_GetFloatp(backSec, DMU_FLOOR_HEIGHT)) + mo->origin[VZ] < P_GetDoublep(backSec, DMU_FLOOR_HEIGHT)) { P_MobjRemove(mo, false); return; } } - //// kludge end. + // kludge end. P_ExplodeMissile(mo); } @@ -295,18 +300,16 @@ void P_MobjMoveXY(mobj_t* mo) } /* -static int PIT_Splash(Sector *sector, void *data) +static int PIT_Splash(Sector* sector, void* parameters) { - mobj_t *mo = data; - float floorHeight; - - floorHeight = P_GetFloatp(sector, DMU_FLOOR_HEIGHT); + mobj_t* mo = (mobj_t*)parameters; + coord_t floorHeight = P_GetDoublep(sector, DMU_FLOOR_HEIGHT); // Is the mobj touching the floor of this sector? - if(mo->pos[VZ] < floorHeight && - mo->pos[VZ] + mo->height / 2 > floorHeight) + if(mo->origin[VZ] < floorHeight && + mo->origin[VZ] + mo->height / 2 > floorHeight) { - //// \todo Play a sound, spawn a generator, etc. + /// @todo Play a sound, spawn a generator, etc. } // Continue checking. @@ -321,32 +324,32 @@ void P_HitFloor(mobj_t* mo) void P_MobjMoveZ(mobj_t* mo) { - float gravity, targetZ, floorZ, ceilingZ; + coord_t gravity, targetZ, floorZ, ceilingZ; // $democam: cameramen get special z movement. if(P_CameraZMovement(mo)) return; - targetZ = mo->pos[VZ] + mo->mom[MZ]; - floorZ = (mo->onMobj? mo->onMobj->pos[VZ] + mo->onMobj->height : mo->floorZ); + targetZ = mo->origin[VZ] + mo->mom[MZ]; + floorZ = (mo->onMobj? mo->onMobj->origin[VZ] + mo->onMobj->height : mo->floorZ); ceilingZ = mo->ceilingZ; gravity = XS_Gravity(P_GetPtrp(mo->bspLeaf, DMU_SECTOR)); if((mo->flags2 & MF2_FLY) && mo->player && - mo->onMobj && mo->pos[VZ] > mo->onMobj->pos[VZ] + mo->onMobj->height) + mo->onMobj && mo->origin[VZ] > mo->onMobj->origin[VZ] + mo->onMobj->height) mo->onMobj = NULL; // We were on a mobj, we are NOT now. if(!((mo->flags ^ MF_FLOAT) & (MF_FLOAT | MF_SKULLFLY | MF_INFLOAT)) && mo->target && !P_MobjIsCamera(mo->target)) { - float dist, delta; + coord_t dist, delta; // Float down towards target if too close. - dist = P_ApproxDistance(mo->pos[VX] - mo->target->pos[VX], - mo->pos[VY] - mo->target->pos[VY]); + dist = M_ApproxDistance(mo->origin[VX] - mo->target->origin[VX], + mo->origin[VY] - mo->target->origin[VY]); - delta = (mo->target->pos[VZ] + mo->target->height / 2) - - (mo->pos[VZ] + mo->height / 2); + delta = (mo->target->origin[VZ] + mo->target->height / 2) - + (mo->origin[VZ] + mo->height / 2); // Don't go INTO the target. if(!(dist < mo->radius + mo->target->radius && @@ -366,7 +369,7 @@ void P_MobjMoveZ(mobj_t* mo) } // Do some fly-bobbing. - if(mo->player && (mo->flags2 & MF2_FLY) && mo->pos[VZ] > floorZ && + if(mo->player && (mo->flags2 & MF2_FLY) && mo->origin[VZ] > floorZ && (mapTime & 2)) { targetZ += FIX2FLT(finesine[(FINEANGLES / 20 * mapTime >> 2) & FINEMASK]); @@ -442,7 +445,7 @@ void P_MobjMoveZ(mobj_t* mo) if(!((mo->flags ^ MF_MISSILE) & (MF_MISSILE | MF_NOCLIP))) { - mo->pos[VZ] = targetZ; + mo->origin[VZ] = targetZ; if((mo->flags2 & MF2_FLOORBOUNCE) && !mo->onMobj) { @@ -461,14 +464,14 @@ void P_MobjMoveZ(mobj_t* mo) // $voodoodolls: Check for smooth step up unless a voodoo doll. if(mo->player && mo->player->plr->mo == mo && - mo->pos[VZ] < mo->floorZ) + mo->origin[VZ] < mo->floorZ) { - mo->player->viewHeight -= (mo->floorZ - mo->pos[VZ]); + mo->player->viewHeight -= (mo->floorZ - mo->origin[VZ]); mo->player->viewHeightDelta = (cfg.plrViewHeight - mo->player->viewHeight) / 8; } - mo->pos[VZ] = floorZ; + mo->origin[VZ] = floorZ; if(mo->flags & MF_SKULLFLY) { // The skull slammed into something. @@ -498,7 +501,7 @@ void P_MobjMoveZ(mobj_t* mo) if(mo->mom[MZ] > 0) mo->mom[MZ] = 0; - mo->pos[VZ] = mo->ceilingZ - mo->height; + mo->origin[VZ] = mo->ceilingZ - mo->height; if(mo->flags & MF_SKULLFLY) { // The skull slammed into something. @@ -538,47 +541,47 @@ void P_MobjMoveZ(mobj_t* mo) else mo->mom[MZ] -= gravity; } - mo->pos[VZ] = targetZ; + mo->origin[VZ] = targetZ; } } } -void P_NightmareRespawn(mobj_t* mobj) +void P_NightmareRespawn(mobj_t* corpse) { - mobj_t* mo; + mobj_t* mo; // Something is occupying it's position? - if(!P_CheckPosition2f(mobj, mobj->spawnSpot.pos[VX], - mobj->spawnSpot.pos[VY])) + if(!P_CheckPositionXY(corpse, corpse->spawnSpot.origin[VX], + corpse->spawnSpot.origin[VY])) return; // No respwan. - if((mo = P_SpawnMobj3fv(mobj->type, mobj->spawnSpot.pos, - mobj->spawnSpot.angle, mobj->spawnSpot.flags))) + if((mo = P_SpawnMobj(corpse->type, corpse->spawnSpot.origin, + corpse->spawnSpot.angle, + corpse->spawnSpot.flags))) { mo->reactionTime = 18; // Spawn a teleport fog at old spot. - if((mo = P_SpawnMobj3f(MT_TFOG, mobj->pos[VX], mobj->pos[VY], 0, - mobj->angle, MSF_Z_FLOOR))) + if((mo = P_SpawnMobjXYZ(MT_TFOG, corpse->origin[VX], corpse->origin[VY], 0, + corpse->angle, MSF_Z_FLOOR))) S_StartSound(SFX_TELEPT, mo); // Spawn a teleport fog at the new spot. - if((mo = P_SpawnMobj3fv(MT_TFOG, mobj->spawnSpot.pos, - mobj->spawnSpot.angle, - mobj->spawnSpot.flags))) + if((mo = P_SpawnMobj(MT_TFOG, corpse->spawnSpot.origin, + corpse->spawnSpot.angle, + corpse->spawnSpot.flags))) S_StartSound(SFX_TELEPT, mo); } // Remove the old monster. - P_MobjRemove(mobj, true); + P_MobjRemove(corpse, true); } void P_MobjThinker(mobj_t* mo) { - float floorZ; + coord_t floorZ; - if(!mo) - return; // Wha? + if(!mo) return; // Wha? if(IS_CLIENT && !ClMobj_IsValid(mo)) return; // We should not touch this right now. @@ -596,13 +599,11 @@ void P_MobjThinker(mobj_t* mo) if(mo->type == MT_LIGHTSOURCE) { if(mo->moveDir > 0) - mo->pos[VZ] = - P_GetFloatp(mo->bspLeaf, DMU_FLOOR_HEIGHT); + mo->origin[VZ] = P_GetDoublep(mo->bspLeaf, DMU_FLOOR_HEIGHT); else - mo->pos[VZ] = - P_GetFloatp(mo->bspLeaf, DMU_CEILING_HEIGHT); + mo->origin[VZ] = P_GetDoublep(mo->bspLeaf, DMU_CEILING_HEIGHT); - mo->pos[VZ] += FIX2FLT(mo->moveDir); + mo->origin[VZ] += FIX2FLT(mo->moveDir); return; } #endif @@ -614,17 +615,18 @@ void P_MobjThinker(mobj_t* mo) { P_MobjMoveXY(mo); - //// \fixme decent NOP/NULL/Nil function pointer please. + /// @fixme decent NOP/NULL/Nil function pointer please. if(mo->thinker.function == NOPFUNC) return; // Mobj was removed. } - floorZ = (mo->onMobj? mo->onMobj->pos[VZ] + mo->onMobj->height : mo->floorZ); + floorZ = (mo->onMobj? mo->onMobj->origin[VZ] + mo->onMobj->height : mo->floorZ); if(mo->flags2 & MF2_FLOATBOB) - { // Floating item bobbing motion. + { + // Floating item bobbing motion. // Keep it on the floor. - mo->pos[VZ] = floorZ; + mo->origin[VZ] = floorZ; #if __JHERETIC__ // Negative floorclip raises the mo off the floor. mo->floorClip = -mo->special1; @@ -637,7 +639,7 @@ void P_MobjThinker(mobj_t* mo) mo->floorClip = -MAX_BOB_OFFSET; } } - else if(mo->pos[VZ] != floorZ || + else if(mo->origin[VZ] != floorZ || !INRANGE_OF(mo->mom[MZ], 0, NOMOM_THRESHOLD)) { P_MobjMoveZ(mo); @@ -654,7 +656,7 @@ void P_MobjThinker(mobj_t* mo) // Objects fall off ledges if they are hanging off. Slightly push // off of ledge if hanging more than halfway off. - if(mo->pos[VZ] > mo->dropOffZ && // Only objects contacting dropoff. + if(mo->origin[VZ] > mo->dropOffZ && // Only objects contacting dropoff. !(mo->flags & MF_NOGRAVITY) && !(mo->flags2 & MF2_FLOATBOB) && cfg.fallOff) { @@ -669,8 +671,8 @@ void P_MobjThinker(mobj_t* mo) if(cfg.slidingCorpses) { - if(((mo->flags & MF_CORPSE)? mo->pos[VZ] > mo->dropOffZ : - mo->pos[VZ] - mo->dropOffZ > 24) && // Only objects contacting drop off + if(((mo->flags & MF_CORPSE)? mo->origin[VZ] > mo->dropOffZ : + mo->origin[VZ] - mo->dropOffZ > 24) && // Only objects contacting drop off !(mo->flags & MF_NOGRAVITY)) // Only objects which fall. { P_ApplyTorque(mo); // Apply torque. @@ -741,13 +743,13 @@ void P_MobjThinker(mobj_t* mo) /** * Spawns a mobj of "type" at the specified position. */ -mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, - angle_t angle, int spawnFlags) +mobj_t* P_SpawnMobjXYZ(mobjtype_t type, coord_t x, coord_t y, coord_t z, angle_t angle, + int spawnFlags) { - mobj_t* mo; - mobjinfo_t* info; - float space; - int ddflags = 0; + mobj_t* mo; + mobjinfo_t* info; + coord_t space; + int ddflags = 0; info = &MOBJINFO[type]; @@ -808,8 +810,8 @@ mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, if(info->flags2 & MF2_DONTDRAW) ddflags |= DDMF_DONTDRAW; - mo = P_MobjCreate(P_MobjThinker, x, y, z, angle, info->radius, - info->height, ddflags); + mo = P_MobjCreateXYZ(P_MobjThinker, x, y, z, angle, info->radius, + info->height, ddflags); mo->type = type; mo->info = info; mo->flags = info->flags; @@ -832,15 +834,15 @@ mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, // Must link before setting state (ID assigned for the mo). P_MobjSetState(mo, P_GetState(mo->type, SN_SPAWN)); - P_MobjSetPosition(mo); + P_MobjSetOrigin(mo); - mo->floorZ = P_GetFloatp(mo->bspLeaf, DMU_FLOOR_HEIGHT); + mo->floorZ = P_GetDoublep(mo->bspLeaf, DMU_FLOOR_HEIGHT); mo->dropOffZ = mo->floorZ; - mo->ceilingZ = P_GetFloatp(mo->bspLeaf, DMU_CEILING_HEIGHT); + mo->ceilingZ = P_GetDoublep(mo->bspLeaf, DMU_CEILING_HEIGHT); if((spawnFlags & MSF_Z_CEIL) || (info->flags & MF_SPAWNCEILING)) { - mo->pos[VZ] = mo->ceilingZ - mo->info->height - z; + mo->origin[VZ] = mo->ceilingZ - mo->info->height - z; } else if((spawnFlags & MSF_Z_RANDOM) || (info->flags2 & MF2_SPAWNFLOAT)) { @@ -848,16 +850,16 @@ mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, if(space > 48) { space -= 40; - mo->pos[VZ] = ((space * P_Random()) / 256) + mo->floorZ + 40; + mo->origin[VZ] = ((space * P_Random()) / 256) + mo->floorZ + 40; } else { - mo->pos[VZ] = mo->floorZ; + mo->origin[VZ] = mo->floorZ; } } else if(spawnFlags & MSF_Z_FLOOR) { - mo->pos[VZ] = mo->floorZ + z; + mo->origin[VZ] = mo->floorZ + z; } if(spawnFlags & MSF_DEAF) @@ -865,7 +867,7 @@ mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, mo->floorClip = 0; if((mo->flags2 & MF2_FLOORCLIP) && - mo->pos[VZ] == P_GetFloatp(mo->bspLeaf, DMU_FLOOR_HEIGHT)) + FEQUAL(mo->origin[VZ], P_GetDoublep(mo->bspLeaf, DMU_FLOOR_HEIGHT))) { const terraintype_t* tt = P_MobjGetFloorTerrainType(mo); @@ -879,25 +881,23 @@ mobj_t* P_SpawnMobj3f(mobjtype_t type, float x, float y, float z, P_BrainAddTarget(mo); // Copy spawn attributes to the new mobj. - mo->spawnSpot.pos[VX] = x; - mo->spawnSpot.pos[VY] = y; - mo->spawnSpot.pos[VZ] = z; + mo->spawnSpot.origin[VX] = x; + mo->spawnSpot.origin[VY] = y; + mo->spawnSpot.origin[VZ] = z; mo->spawnSpot.angle = angle; mo->spawnSpot.flags = spawnFlags; return mo; } -mobj_t* P_SpawnMobj3fv(mobjtype_t type, const float pos[3], angle_t angle, - int spawnFlags) +mobj_t* P_SpawnMobj(mobjtype_t type, coord_t const pos[3], angle_t angle, int spawnFlags) { - return P_SpawnMobj3f(type, pos[VX], pos[VY], pos[VZ], angle, spawnFlags); + return P_SpawnMobjXYZ(type, pos[VX], pos[VY], pos[VZ], angle, spawnFlags); } -mobj_t* P_SpawnCustomPuff(mobjtype_t type, float x, float y, float z, - angle_t angle) +mobj_t* P_SpawnCustomPuff(mobjtype_t type, coord_t x, coord_t y, coord_t z, angle_t angle) { - mobj_t* mo; + mobj_t* mo; // Clients do not spawn puffs. if(IS_CLIENT) @@ -905,7 +905,7 @@ mobj_t* P_SpawnCustomPuff(mobjtype_t type, float x, float y, float z, z += FIX2FLT((P_Random() - P_Random()) << 10); - if((mo = P_SpawnMobj3f(type, x, y, z, angle, 0))) + if((mo = P_SpawnMobjXYZ(type, x, y, z, angle, 0))) { mo->mom[MZ] = FIX2FLT(FRACUNIT); mo->tics -= P_Random() & 3; @@ -918,9 +918,9 @@ mobj_t* P_SpawnCustomPuff(mobjtype_t type, float x, float y, float z, return mo; } -void P_SpawnPuff(float x, float y, float z, angle_t angle) +void P_SpawnPuff(coord_t x, coord_t y, coord_t z, angle_t angle) { - mobj_t* th; + mobj_t* th; if((th = P_SpawnCustomPuff(MT_PUFF, x, y, z, angle))) { @@ -930,12 +930,12 @@ void P_SpawnPuff(float x, float y, float z, angle_t angle) } } -void P_SpawnBlood(float x, float y, float z, int damage, angle_t angle) +void P_SpawnBlood(coord_t x, coord_t y, coord_t z, int damage, angle_t angle) { - mobj_t* th; + mobj_t* th; z += FIX2FLT((P_Random() - P_Random()) << 10); - if((th = P_SpawnMobj3f(MT_BLOOD, x, y, z, angle, 0))) + if((th = P_SpawnMobjXYZ(MT_BLOOD, x, y, z, angle, 0))) { th->mom[MZ] = 2; th->tics -= P_Random() & 3; @@ -958,7 +958,7 @@ void P_SpawnBlood(float x, float y, float z, int damage, angle_t angle) * @return @c true, if the missile is at a valid location else * @c false */ -boolean P_CheckMissileSpawn(mobj_t *th) +boolean P_CheckMissileSpawn(mobj_t* th) { th->tics -= P_Random() & 3; if(th->tics < 1) @@ -966,11 +966,11 @@ boolean P_CheckMissileSpawn(mobj_t *th) // Move forward slightly so an angle can be computed if it explodes // immediately. - th->pos[VX] += th->mom[MX] / 2; - th->pos[VY] += th->mom[MY] / 2; - th->pos[VZ] += th->mom[MZ] / 2; + th->origin[VX] += th->mom[MX] / 2; + th->origin[VY] += th->mom[MY] / 2; + th->origin[VZ] += th->mom[MZ] / 2; - if(!P_TryMove(th, th->pos[VX], th->pos[VY], false, false)) + if(!P_TryMoveXY(th, th->origin[VX], th->origin[VY], false, false)) { P_ExplodeMissile(th); return false; @@ -992,15 +992,15 @@ boolean P_CheckMissileSpawn(mobj_t *th) */ mobj_t* P_SpawnMissile(mobjtype_t type, mobj_t* source, mobj_t* dest) { - float pos[3]; - mobj_t* th = 0; - unsigned int an; - angle_t angle = 0; - float dist = 0; - float slope = 0; - float spawnZOff = 0; + coord_t pos[3]; + mobj_t* th = 0; + unsigned int an; + angle_t angle = 0; + coord_t dist = 0; + float slope = 0; + coord_t spawnZOff = 0; - memcpy(pos, source->pos, sizeof(pos)); + memcpy(pos, source->origin, sizeof(pos)); if(source->player) { @@ -1051,14 +1051,14 @@ mobj_t* P_SpawnMissile(mobjtype_t type, mobj_t* source, mobj_t* dest) if(!source->player) { - angle = R_PointToAngle2(pos[VX], pos[VY], dest->pos[VX], dest->pos[VY]); + angle = M_PointToAngle2(pos, dest->origin); // Fuzzy player. if(dest->flags & MF_SHADOW) angle += (P_Random() - P_Random()) << 20; } - if(!(th = P_SpawnMobj3fv(type, pos, angle, 0))) + if(!(th = P_SpawnMobj(type, pos, angle, 0))) return NULL; if(th->info->seeSound) @@ -1078,16 +1078,16 @@ mobj_t* P_SpawnMissile(mobjtype_t type, mobj_t* source, mobj_t* dest) } else { - dist = P_ApproxDistance(dest->pos[VX] - pos[VX], - dest->pos[VY] - pos[VY]); + dist = M_ApproxDistance(dest->origin[VX] - pos[VX], + dest->origin[VY] - pos[VY]); dist /= th->info->speed; if(dist < 1) dist = 1; - th->mom[MZ] = (dest->pos[VZ] - source->pos[VZ]) / dist; + th->mom[MZ] = (dest->origin[VZ] - source->origin[VZ]) / dist; } // Make sure the speed is right (in 3D). - dist = P_ApproxDistance(P_ApproxDistance(th->mom[MX], th->mom[MY]), + dist = M_ApproxDistance(M_ApproxDistance(th->mom[MX], th->mom[MY]), th->mom[MZ]); if(dist < 1) dist = 1; diff --git a/doomsday/plugins/jdoom/src/p_oldsvg.c b/doomsday/plugins/jdoom/src/p_oldsvg.c index e8caae6e0b..39da3fb1e8 100644 --- a/doomsday/plugins/jdoom/src/p_oldsvg.c +++ b/doomsday/plugins/jdoom/src/p_oldsvg.c @@ -257,7 +257,7 @@ static void SV_ReadMobj(void) /** * We now have all the information we need to create the mobj. */ - mo = P_MobjCreate(P_MobjThinker, pos[VX], pos[VY], pos[VZ], angle, + mo = P_MobjCreateXYZ(P_MobjThinker, pos[VX], pos[VY], pos[VZ], angle, radius, height, ddflags); mo->sprite = sprite; @@ -306,9 +306,9 @@ static void SV_ReadMobj(void) mo->lastLook = SV_ReadLong(); // For nightmare respawn. - mo->spawnSpot.pos[VX] = (float) SV_ReadShort(); - mo->spawnSpot.pos[VY] = (float) SV_ReadShort(); - mo->spawnSpot.pos[VZ] = 0; // Initialize with "something". + mo->spawnSpot.origin[VX] = (float) SV_ReadShort(); + mo->spawnSpot.origin[VY] = (float) SV_ReadShort(); + mo->spawnSpot.origin[VZ] = 0; // Initialize with "something". mo->spawnSpot.angle = (angle_t) (ANG45 * ((int)SV_ReadShort() / 45)); /* mo->spawnSpot.type = (int) */ SV_ReadShort(); @@ -337,14 +337,14 @@ static void SV_ReadMobj(void) //mo->dPlayer->clAngle = mo->angle; /* $unifiedangles */ mo->dPlayer->lookDir = 0; /* $unifiedangles */ } - P_MobjSetPosition(mo); - mo->floorZ = P_GetFloatp(mo->bspLeaf, DMU_FLOOR_HEIGHT); - mo->ceilingZ = P_GetFloatp(mo->bspLeaf, DMU_CEILING_HEIGHT); + P_MobjSetOrigin(mo); + mo->floorZ = P_GetDoublep(mo->bspLeaf, DMU_FLOOR_HEIGHT); + mo->ceilingZ = P_GetDoublep(mo->bspLeaf, DMU_CEILING_HEIGHT); } void P_v19_UnArchivePlayers(void) { - int i, j; + int i, j; for(i = 0; i < 4; ++i) { @@ -388,8 +388,8 @@ void P_v19_UnArchiveWorld(void) sec = P_ToPtr(DMU_SECTOR, i); xsec = P_ToXSector(sec); - P_SetFloatp(sec, DMU_FLOOR_HEIGHT, (float) (*get++)); - P_SetFloatp(sec, DMU_CEILING_HEIGHT, (float) (*get++)); + P_SetDoublep(sec, DMU_FLOOR_HEIGHT, (coord_t) (*get++)); + P_SetDoublep(sec, DMU_CEILING_HEIGHT, (coord_t) (*get++)); P_SetPtrp(sec, DMU_FLOOR_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, *get++))); P_SetPtrp(sec, DMU_CEILING_MATERIAL, P_ToPtr(DMU_MATERIAL, DD_MaterialForTextureUniqueId(TN_FLATS, *get++))); @@ -414,8 +414,7 @@ void P_v19_UnArchiveWorld(void) { SideDef* sdef = P_GetPtrp(line, (j? DMU_SIDEDEF1:DMU_SIDEDEF0)); - if(!sdef) - continue; + if(!sdef) continue; matOffset[VX] = (float) (*get++); matOffset[VY] = (float) (*get++); diff --git a/doomsday/plugins/jdoom/src/p_pspr.c b/doomsday/plugins/jdoom/src/p_pspr.c index 157e3291b2..198d939132 100644 --- a/doomsday/plugins/jdoom/src/p_pspr.c +++ b/doomsday/plugins/jdoom/src/p_pspr.c @@ -360,22 +360,22 @@ void C_DECL A_Raise(player_t *player, pspdef_t *psp) P_SetPsprite(player, ps_weapon, newstate); } -void C_DECL A_GunFlash(player_t *player, pspdef_t *psp) +void C_DECL A_GunFlash(player_t* player, pspdef_t* psp) { P_MobjChangeState(player->plr->mo, PCLASS_INFO(player->class_)->attackEndState); P_SetPsprite(player, ps_flash, weaponInfo[player->readyWeapon][player->class_].mode[0].states[WSN_FLASH]); } -void C_DECL A_Punch(player_t *player, pspdef_t *psp) +void C_DECL A_Punch(player_t* player, pspdef_t* psp) { - angle_t angle; - int damage; - float slope; + angle_t angle; + int damage; + float slope; P_ShotAmmo(player); player->update |= PSF_AMMO; - if(IS_CLIENT) - return; + + if(IS_CLIENT) return; damage = (float) (P_Random() % 10 + 1) * 2; @@ -392,20 +392,16 @@ void C_DECL A_Punch(player_t *player, pspdef_t *psp) { S_StartSound(SFX_PUNCH, player->plr->mo); - player->plr->mo->angle = - R_PointToAngle2(player->plr->mo->pos[VX], - player->plr->mo->pos[VY], - lineTarget->pos[VX], - lineTarget->pos[VY]); + player->plr->mo->angle = M_PointToAngle2(player->plr->mo->origin, lineTarget->origin); player->plr->flags |= DDPF_FIXANGLES; } } -void C_DECL A_Saw(player_t *player, pspdef_t *psp) +void C_DECL A_Saw(player_t* player, pspdef_t* psp) { - angle_t angle; - int damage; - float slope; + angle_t angle; + int damage; + float slope; P_ShotAmmo(player); player->update |= PSF_AMMO; @@ -426,12 +422,10 @@ void C_DECL A_Saw(player_t *player, pspdef_t *psp) S_StartSoundEx(SFX_SAWHIT, player->plr->mo); - if(IS_CLIENT) - return; + if(IS_CLIENT) return; // Turn to face target. - angle = R_PointToAngle2(player->plr->mo->pos[VX], player->plr->mo->pos[VY], - lineTarget->pos[VX], lineTarget->pos[VY]); + angle = M_PointToAngle2(player->plr->mo->origin, lineTarget->origin); if(angle - player->plr->mo->angle > ANG180) { if(angle - player->plr->mo->angle < -ANG90 / 20) @@ -449,12 +443,12 @@ void C_DECL A_Saw(player_t *player, pspdef_t *psp) player->plr->mo->flags |= MF_JUSTATTACKED; } -void C_DECL A_FireMissile(player_t *player, pspdef_t *psp) +void C_DECL A_FireMissile(player_t* player, pspdef_t* psp) { P_ShotAmmo(player); player->update |= PSF_AMMO; - if(IS_CLIENT) - return; + + if(IS_CLIENT) return; P_SpawnMissile(MT_ROCKET, player->plr->mo, NULL); } @@ -463,8 +457,8 @@ void C_DECL A_FireBFG(player_t *player, pspdef_t *psp) { P_ShotAmmo(player); player->update |= PSF_AMMO; - if(IS_CLIENT) - return; + + if(IS_CLIENT) return; P_SpawnMissile(MT_BFG, player->plr->mo, NULL); } @@ -663,10 +657,10 @@ void C_DECL A_Light2(player_t *player, pspdef_t *psp) /** * Spawn a BFG explosion on every monster in view. */ -void C_DECL A_BFGSpray(mobj_t *mo) +void C_DECL A_BFGSpray(mobj_t* mo) { - int i, j, damage; - angle_t angle; + int i, j, damage; + angle_t angle; // Offset angles from its attack angle. for(i = 0; i < 40; ++i) @@ -676,13 +670,12 @@ void C_DECL A_BFGSpray(mobj_t *mo) // mo->target is the originator (player) of the missile. P_AimLineAttack(mo->target, angle, 16 * 64); - if(!lineTarget) - continue; + if(!lineTarget) continue; - P_SpawnMobj3f(MT_EXTRABFG, - lineTarget->pos[VX], lineTarget->pos[VY], - lineTarget->pos[VZ] + lineTarget->height / 2, - angle + ANG180, 0); + P_SpawnMobjXYZ(MT_EXTRABFG, + lineTarget->origin[VX], lineTarget->origin[VY], + lineTarget->origin[VZ] + lineTarget->height / 2, + angle + ANG180, 0); damage = 0; for(j = 0; j < 15; ++j) diff --git a/doomsday/plugins/jdoom/src/p_sound.c b/doomsday/plugins/jdoom/src/p_sound.c index 90508c3335..d3a9b4c214 100644 --- a/doomsday/plugins/jdoom/src/p_sound.c +++ b/doomsday/plugins/jdoom/src/p_sound.c @@ -83,7 +83,7 @@ void S_SectorSound(Sector* sec, sectorsoundorigin_t origin, int id) { mobj_t* centerOrigin, *floorOrigin, *ceilingOrigin; - centerOrigin = (mobj_t*) P_GetPtrp(sec, DMU_ORIGIN); + centerOrigin = (mobj_t*) P_GetPtrp(sec, DMU_BASE); floorOrigin = (mobj_t*) P_GetPtrp(sec, DMU_FLOOR_ORIGIN); ceilingOrigin = (mobj_t*) P_GetPtrp(sec, DMU_CEILING_ORIGIN); diff --git a/doomsday/plugins/jdoom/src/p_spec.c b/doomsday/plugins/jdoom/src/p_spec.c index 7ecfabe946..193670173d 100644 --- a/doomsday/plugins/jdoom/src/p_spec.c +++ b/doomsday/plugins/jdoom/src/p_spec.c @@ -799,7 +799,7 @@ void P_PlayerInSpecialSector(player_t* player) if(IS_CLIENT) return; // Falling, not all the way down yet? - if(player->plr->mo->pos[VZ] != P_GetFloatp(sector, DMU_FLOOR_HEIGHT)) + if(!FEQUAL(player->plr->mo->origin[VZ], P_GetDoublep(sector, DMU_FLOOR_HEIGHT))) return; // Has hitten ground. @@ -866,8 +866,8 @@ void P_PlayerInSpecialSector(player_t* player) */ void P_UpdateSpecials(void) { - LineDef* line; - SideDef* side; + LineDef* line; + SideDef* side; // Extended lines and sectors. XG_Ticker(); @@ -875,13 +875,13 @@ void P_UpdateSpecials(void) // Animate line specials. if(IterList_Size(linespecials)) { - float x, offset; + float x, offset; IterList_SetIteratorDirection(linespecials, ITERLIST_BACKWARD); IterList_RewindIterator(linespecials); while((line = IterList_MoveIterator(linespecials)) != NULL) { - xline_t *xline = P_ToXLine(line); + xline_t* xline = P_ToXLine(line); switch(xline->special) { diff --git a/doomsday/plugins/jdoom/src/p_telept.c b/doomsday/plugins/jdoom/src/p_telept.c index d7c4a5b2f2..7cb565a3e6 100644 --- a/doomsday/plugins/jdoom/src/p_telept.c +++ b/doomsday/plugins/jdoom/src/p_telept.c @@ -1,4 +1,4 @@ -/**\file +/**\file p_telept.c *\section License * License: GPL * Online License Link: http://www.gnu.org/licenses/gpl.html @@ -23,12 +23,6 @@ * Boston, MA 02110-1301 USA */ -/** - * p_telept.c: - */ - -// HEADER FILES ------------------------------------------------------------ - #include "jdoom.h" #include "dmu_lib.h" @@ -37,39 +31,21 @@ #include "p_mapspec.h" #include "p_terraintype.h" -// MACROS ------------------------------------------------------------------ - -// TYPES ------------------------------------------------------------------- - -// EXTERNAL FUNCTION PROTOTYPES -------------------------------------------- - -// PUBLIC FUNCTION PROTOTYPES ---------------------------------------------- - -// PRIVATE FUNCTION PROTOTYPES --------------------------------------------- - -// EXTERNAL DATA DECLARATIONS ---------------------------------------------- - -// PUBLIC DATA DEFINITIONS ------------------------------------------------- - -// PRIVATE DATA DEFINITIONS ------------------------------------------------ - -// CODE -------------------------------------------------------------------- - -mobj_t* P_SpawnTeleFog(float x, float y, angle_t angle) +mobj_t* P_SpawnTeleFog(coord_t x, coord_t y, angle_t angle) { - return P_SpawnMobj3f(MT_TFOG, x, y, 0, angle, MSF_Z_FLOOR); + return P_SpawnMobjXYZ(MT_TFOG, x, y, 0, angle, MSF_Z_FLOOR); } typedef struct { - Sector* sec; - mobjtype_t type; - mobj_t* foundMobj; + Sector* sec; + mobjtype_t type; + mobj_t* foundMobj; } findmobjparams_t; static int findMobj(thinker_t* th, void* context) { - findmobjparams_t* params = (findmobjparams_t*) context; - mobj_t* mo = (mobj_t *) th; + findmobjparams_t* params = (findmobjparams_t*) context; + mobj_t* mo = (mobj_t *) th; // Must be of the correct type? if(params->type >= 0 && params->type != mo->type) @@ -87,13 +63,11 @@ static int findMobj(thinker_t* th, void* context) static mobj_t* getTeleportDestination(short tag) { - iterlist_t* list; - - list = P_GetSectorIterListForTag(tag, false); + iterlist_t* list = P_GetSectorIterListForTag(tag, false); if(list) { - Sector* sec = NULL; - findmobjparams_t params; + Sector* sec = NULL; + findmobjparams_t params; params.type = MT_TELEPORTMAN; params.foundMobj = NULL; @@ -130,36 +104,37 @@ int EV_Teleport(LineDef* line, int side, mobj_t* mo, boolean spawnFog) return 0; if((dest = getTeleportDestination(P_ToXLine(line)->tag)) != NULL) - { // A suitable destination has been found. - mobj_t* fog; - uint an; - float oldPos[3]; - float aboveFloor; - angle_t oldAngle; - - memcpy(oldPos, mo->pos, sizeof(mo->pos)); + { + // A suitable destination has been found. + mobj_t* fog; + coord_t oldPos[3]; + coord_t aboveFloor; + angle_t oldAngle; + uint an; + + memcpy(oldPos, mo->origin, sizeof(mo->origin)); oldAngle = mo->angle; - aboveFloor = mo->pos[VZ] - mo->floorZ; + aboveFloor = mo->origin[VZ] - mo->floorZ; - if(!P_TeleportMove(mo, dest->pos[VX], dest->pos[VY], false)) + if(!P_TeleportMove(mo, dest->origin[VX], dest->origin[VY], false)) return 0; // In Final Doom things teleported to their destination but the // height wasn't set to the floor. if(gameMode != GM_DOOM2_TNT && gameMode != GM_DOOM2_PLUT) - mo->pos[VZ] = mo->floorZ; + mo->origin[VZ] = mo->floorZ; if(spawnFog) { // Spawn teleport fog at source and destination. - if((fog = P_SpawnMobj3fv(MT_TFOG, oldPos, oldAngle + ANG180, 0))) + if((fog = P_SpawnMobj(MT_TFOG, oldPos, oldAngle + ANG180, 0))) S_StartSound(SFX_TELEPT, fog); an = dest->angle >> ANGLETOFINESHIFT; - if((fog = P_SpawnMobj3f(MT_TFOG, - dest->pos[VX] + 20 * FIX2FLT(finecosine[an]), - dest->pos[VY] + 20 * FIX2FLT(finesine[an]), - mo->pos[VZ], dest->angle + ANG180, 0))) + if((fog = P_SpawnMobjXYZ(MT_TFOG, + dest->origin[VX] + 20 * FIX2FLT(finecosine[an]), + dest->origin[VY] + 20 * FIX2FLT(finesine[an]), + mo->origin[VZ], dest->angle + ANG180, 0))) { // Emit sound, where? S_StartSound(SFX_TELEPT, fog); @@ -171,7 +146,7 @@ int EV_Teleport(LineDef* line, int side, mobj_t* mo, boolean spawnFog) { mo->floorClip = 0; - if(mo->pos[VZ] == P_GetFloatp(mo->bspLeaf, DMU_FLOOR_HEIGHT)) + if(FEQUAL(mo->origin[VZ], P_GetDoublep(mo->bspLeaf, DMU_FLOOR_HEIGHT))) { const terraintype_t* tt = P_MobjGetFloorTerrainType(mo); @@ -190,10 +165,10 @@ int EV_Teleport(LineDef* line, int side, mobj_t* mo, boolean spawnFog) mo->reactionTime = 18; // Don't move for a bit. if(mo->player->powers[PT_FLIGHT] && aboveFloor > 0) { - mo->pos[VZ] = mo->floorZ + aboveFloor; - if(mo->pos[VZ] + mo->height > mo->ceilingZ) + mo->origin[VZ] = mo->floorZ + aboveFloor; + if(mo->origin[VZ] + mo->height > mo->ceilingZ) { - mo->pos[VZ] = mo->ceilingZ - mo->height; + mo->origin[VZ] = mo->ceilingZ - mo->height; } } else @@ -201,14 +176,14 @@ int EV_Teleport(LineDef* line, int side, mobj_t* mo, boolean spawnFog) //mo->dPlayer->clLookDir = 0; /* $unifiedangles */ mo->dPlayer->lookDir = 0; } - mo->player->viewHeight = (float) cfg.plrViewHeight; + mo->player->viewHeight = (coord_t) cfg.plrViewHeight; mo->player->viewHeightDelta = 0; - mo->player->viewZ = mo->pos[VZ] + mo->player->viewHeight; + mo->player->viewZ = mo->origin[VZ] + mo->player->viewHeight; mo->player->viewOffset[VX] = mo->player->viewOffset[VY] = mo->player->viewOffset[VZ] = 0; mo->player->bob = 0; //mo->dPlayer->clAngle = mo->angle; /* $unifiedangles */ - mo->dPlayer->flags |= DDPF_FIXANGLES | DDPF_FIXPOS | DDPF_FIXMOM; + mo->dPlayer->flags |= DDPF_FIXANGLES | DDPF_FIXORIGIN | DDPF_FIXMOM; #ifdef _DEBUG Con_Message("EV_Teleport: Player %p set FIX flags.\n", mo->dPlayer); #endif diff --git a/doomsday/plugins/jdoom/src/st_stuff.c b/doomsday/plugins/jdoom/src/st_stuff.c index 296e2f1a69..128f805b1a 100644 --- a/doomsday/plugins/jdoom/src/st_stuff.c +++ b/doomsday/plugins/jdoom/src/st_stuff.c @@ -627,8 +627,7 @@ void Face_Ticker(uiwidget_t* obj, timespan_t ticLength) } else { - badGuyAngle = R_PointToAngle2(plr->plr->mo->pos[VX], plr->plr->mo->pos[VY], - plr->attacker->pos[VX], plr->attacker->pos[VY]); + badGuyAngle = M_PointToAngle2(plr->plr->mo->origin, plr->attacker->origin); if(badGuyAngle > plr->plr->mo->angle) { @@ -2812,10 +2811,10 @@ static void initAutomapForCurrentMap(uiwidget_t* obj) UIAutomap_Reset(obj); UIAutomap_SetMinScale(obj, 2 * PLAYERRADIUS); - UIAutomap_SetWorldBounds(obj, *((float*) DD_GetVariable(DD_MAP_MIN_X)), - *((float*) DD_GetVariable(DD_MAP_MAX_X)), - *((float*) DD_GetVariable(DD_MAP_MIN_Y)), - *((float*) DD_GetVariable(DD_MAP_MAX_Y))); + UIAutomap_SetWorldBounds(obj, *((coord_t*) DD_GetVariable(DD_MAP_MIN_X)), + *((coord_t*) DD_GetVariable(DD_MAP_MAX_X)), + *((coord_t*) DD_GetVariable(DD_MAP_MIN_Y)), + *((coord_t*) DD_GetVariable(DD_MAP_MAX_Y))); mcfg = UIAutomap_Config(obj); @@ -2842,7 +2841,7 @@ static void initAutomapForCurrentMap(uiwidget_t* obj) followMobj = UIAutomap_FollowMobj(obj); if(followMobj) { - UIAutomap_SetCameraOrigin(obj, followMobj->pos[VX], followMobj->pos[VY]); + UIAutomap_SetCameraOrigin(obj, followMobj->origin[VX], followMobj->origin[VY]); } if(IS_NETGAME) @@ -3226,7 +3225,7 @@ void ST_AutomapClearPoints(int player) /** * Adds a marker at the specified X/Y location. */ -int ST_AutomapAddPoint(int player, float x, float y, float z) +int ST_AutomapAddPoint(int player, coord_t x, coord_t y, coord_t z) { static char buffer[20]; uiwidget_t* obj = ST_UIAutomapForPlayer(player); @@ -3245,7 +3244,7 @@ int ST_AutomapAddPoint(int player, float x, float y, float z) return newPoint; } -boolean ST_AutomapPointOrigin(int player, int point, float* x, float* y, float* z) +boolean ST_AutomapPointOrigin(int player, int point, coord_t* x, coord_t* y, coord_t* z) { uiwidget_t* obj = ST_UIAutomapForPlayer(player); if(!obj) return false;