From d19a2069c6d51b6e8aaf3f47742316e4808db49f Mon Sep 17 00:00:00 2001 From: Steven Fuller Date: Thu, 9 Aug 2001 22:34:20 +0000 Subject: [PATCH] Implemented keyboard input. Copied some functions from pldnet and d3d_render (now the player image shows in the mirror). --- Makefile | 2 +- src/main.c | 221 ++++++++++++- src/net.c | 888 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/opengl.c | 5 +- src/render.c | 67 ++++ src/stubs.c | 34 -- 6 files changed, 1177 insertions(+), 40 deletions(-) create mode 100644 src/net.c create mode 100644 src/render.c diff --git a/Makefile b/Makefile index cedb221..f89342e 100644 --- a/Makefile +++ b/Makefile @@ -10,7 +10,7 @@ LDLIBS += -L/usr/X11R6/lib -lX11 -lXext -lGL `sdl-config --libs` AFLAGS = -g -Iinclude/ -w+macro-params -w+orphan-labels -w+number-overflow -ROOT = main.c math.asm mathline.c opengl.c stubs.c stubs2.cpp winapi.c afont.c frustum.c kshape.c map.c maths.c md5.c mem3dc.c mem3dcpp.cpp module.c morph.c object.c shpanim.c sphere.c tables.c vdb.c version.c +ROOT = main.c mathline.c math.asm net.c render.c opengl.c winapi.c stubs.c stubs2.cpp afont.c frustum.c kshape.c map.c maths.c md5.c mem3dc.c mem3dcpp.cpp module.c morph.c object.c shpanim.c sphere.c tables.c vdb.c version.c AVP = ai_sight.c avpview.c bh_agun.c bh_ais.c bh_alien.c bh_binsw.c bh_cable.c bh_corpse.c bh_deathvol.c bh_debri.c bh_dummy.c bh_fan.c bh_far.c bh_fhug.c bh_gener.c bh_ldoor.c bh_lift.c bh_light.c bh_lnksw.c bh_ltfx.c bh_marin.c bh_mission.c bh_near.c bh_pargen.c bh_plachier.c bh_plift.c bh_pred.c bh_queen.c bh_rubberduck.c bh_selfdest.c bh_snds.c bh_spcl.c bh_swdor.c bh_track.c bh_types.c bh_videoscreen.c bh_waypt.c bh_weap.c bh_xeno.c bonusabilities.c cconvars.cpp cdtrackselection.cpp cheatmodes.c comp_map.c comp_shp.c consolelog.cpp davehook.cpp deaths.c decal.c detaillevels.c dynamics.c dynblock.c equipmnt.c equiputl.cpp extents.c game.c game_statistics.c gamecmds.cpp gameflow.c gamevars.cpp hmodel.c hud.c inventry.c language.c lighting.c load_shp.c los.c maps.c mempool.c messagehistory.c missions.cpp movement.c paintball.c particle.c pfarlocs.c pheromon.c player.c pmove.c psnd.c psndproj.c pvisible.c savegame.c scream.cpp secstats.c sfx.c stratdef.c targeting.c track.c triggers.c weapons.c SHAPES = cube.c SUPPORT = consbind.cpp consbtch.cpp coordstr.cpp daemon.cpp r2base.cpp r2pos666.cpp reflist.cpp refobj.cpp scstring.cpp strtab.cpp strutil.c trig666.cpp wrapstr.cpp diff --git a/src/main.c b/src/main.c index 7288619..1bf390b 100644 --- a/src/main.c +++ b/src/main.c @@ -75,9 +75,81 @@ static int KeySymToKey(int keysym) switch(keysym) { case SDLK_ESCAPE: return KEY_ESCAPE; - case SDLK_RETURN: - return KEY_CR; + case SDLK_0: + return KEY_0; + case SDLK_1: + return KEY_1; + case SDLK_2: + return KEY_2; + case SDLK_3: + return KEY_3; + case SDLK_4: + return KEY_4; + case SDLK_5: + return KEY_5; + case SDLK_6: + return KEY_6; + case SDLK_7: + return KEY_7; + case SDLK_8: + return KEY_8; + case SDLK_9: + return KEY_9; + + case SDLK_a: + return KEY_A; + case SDLK_b: + return KEY_B; + case SDLK_c: + return KEY_C; + case SDLK_d: + return KEY_D; + case SDLK_e: + return KEY_E; + case SDLK_f: + return KEY_F; + case SDLK_g: + return KEY_G; + case SDLK_h: + return KEY_H; + case SDLK_i: + return KEY_I; + case SDLK_j: + return KEY_J; + case SDLK_k: + return KEY_K; + case SDLK_l: + return KEY_L; + case SDLK_m: + return KEY_M; + case SDLK_n: + return KEY_N; + case SDLK_o: + return KEY_O; + case SDLK_p: + return KEY_P; + case SDLK_q: + return KEY_Q; + case SDLK_r: + return KEY_R; + case SDLK_s: + return KEY_S; + case SDLK_t: + return KEY_T; + case SDLK_u: + return KEY_U; + case SDLK_v: + return KEY_V; + case SDLK_w: + return KEY_W; + case SDLK_x: + return KEY_X; + case SDLK_y: + return KEY_Y; + case SDLK_z: + return KEY_Z; + case SDLK_LEFT: return KEY_LEFT; case SDLK_RIGHT: @@ -85,7 +157,138 @@ static int KeySymToKey(int keysym) case SDLK_UP: return KEY_UP; case SDLK_DOWN: - return KEY_DOWN; + return KEY_DOWN; + case SDLK_RETURN: + return KEY_CR; + case SDLK_TAB: + return KEY_TAB; + case SDLK_INSERT: + return KEY_INS; + case SDLK_DELETE: + return KEY_DEL; + case SDLK_END: + return KEY_END; + case SDLK_HOME: + return KEY_HOME; + case SDLK_PAGEUP: + return KEY_PAGEUP; + case SDLK_PAGEDOWN: + return KEY_PAGEDOWN; + case SDLK_BACKSPACE: + return KEY_BACKSPACE; + case SDLK_COMMA: + return KEY_COMMA; + case SDLK_PERIOD: + return KEY_FSTOP; /* fstop? */ + case SDLK_SPACE: + return KEY_SPACE; + + case SDLK_LSHIFT: + return KEY_LEFTSHIFT; + case SDLK_RSHIFT: + return KEY_RIGHTSHIFT; + case SDLK_LALT: + return KEY_LEFTALT; + case SDLK_RALT: + return KEY_RIGHTALT; + case SDLK_LCTRL: + return KEY_LEFTCTRL; + case SDLK_RCTRL: + return KEY_RIGHTCTRL; + + case SDLK_CAPSLOCK: + return KEY_CAPS; + case SDLK_NUMLOCK: + return KEY_NUMLOCK; + case SDLK_SCROLLOCK: + return KEY_SCROLLOK; + + case SDLK_KP0: + return KEY_NUMPAD0; + case SDLK_KP1: + return KEY_NUMPAD1; + case SDLK_KP2: + return KEY_NUMPAD2; + case SDLK_KP3: + return KEY_NUMPAD3; + case SDLK_KP4: + return KEY_NUMPAD4; + case SDLK_KP5: + return KEY_NUMPAD5; + case SDLK_KP6: + return KEY_NUMPAD6; + case SDLK_KP7: + return KEY_NUMPAD7; + case SDLK_KP8: + return KEY_NUMPAD8; + case SDLK_KP9: + return KEY_NUMPAD9; + case SDLK_KP_MINUS: + return KEY_NUMPADSUB; + case SDLK_KP_PLUS: + return KEY_NUMPADADD; + case SDLK_KP_PERIOD: + return KEY_NUMPADDEL; + case SDLK_KP_ENTER: + return KEY_NUMPADENTER; + case SDLK_KP_DIVIDE: + return KEY_NUMPADDIVIDE; + case SDLK_KP_MULTIPLY: + return KEY_NUMPADMULTIPLY; + + case SDLK_LEFTBRACKET: + return KEY_LBRACKET; + case SDLK_RIGHTBRACKET: + return KEY_RBRACKET; + case SDLK_SEMICOLON: + return KEY_SEMICOLON; + case SDLK_QUOTE: + return KEY_APOSTROPHE; + case SDLK_BACKQUOTE: + return KEY_GRAVE; + case SDLK_BACKSLASH: + return KEY_BACKSLASH; + case SDLK_SLASH: + return KEY_SLASH; +/* case SDLK_ + return KEY_CAPITAL; */ + case SDLK_MINUS: + return KEY_MINUS; + case SDLK_EQUALS: + return KEY_EQUALS; + case SDLK_LSUPER: + return KEY_LWIN; + case SDLK_RSUPER: + return KEY_RWIN; +/* case SDLK_ + return KEY_APPS; */ + + case SDLK_F1: + return KEY_F1; + case SDLK_F2: + return KEY_F2; + case SDLK_F3: + return KEY_F3; + case SDLK_F4: + return KEY_F4; + case SDLK_F5: + return KEY_F5; + case SDLK_F6: + return KEY_F6; + case SDLK_F7: + return KEY_F7; + case SDLK_F8: + return KEY_F8; + case SDLK_F9: + return KEY_F9; + case SDLK_F10: + return KEY_F10; + case SDLK_F11: + return KEY_F11; + case SDLK_F12: + return KEY_F12; + +/* finish foreign keys */ default: return -1; @@ -196,8 +399,17 @@ int main(int argc, char *argv[]) /* InitOptionsMenu(); NOT YET */ +// LoadDefaultPrimaryConfigs(); /* load the configs! yes! */ + MarineInputPrimaryConfig = DefaultMarineInputPrimaryConfig; + PredatorInputPrimaryConfig = DefaultPredatorInputPrimaryConfig; + AlienInputPrimaryConfig = DefaultAlienInputPrimaryConfig; + MarineInputSecondaryConfig = DefaultMarineInputSecondaryConfig; + PredatorInputSecondaryConfig = DefaultPredatorInputSecondaryConfig; + AlienInputSecondaryConfig = DefaultAlienInputSecondaryConfig; + LoadKeyConfiguration(); + SoundSys_Start(); CDDA_Start(); @@ -210,7 +422,8 @@ int main(int argc, char *argv[]) LoadSounds("PLAYER"); AvP.CurrentEnv = AvP.StartingEnv = 0; /* are these even used? */ - SetLevelToLoad(AVP_ENVIRONMENT_INVASION); /* because the menus aren't implemented */ +// SetLevelToLoad(AVP_ENVIRONMENT_INVASION); /* because the menus aren't implemented */ + SetLevelToLoad(AVP_ENVIRONMENT_DERELICT); /* starting marine level */ // while(AvP_MainMenus()) { diff --git a/src/net.c b/src/net.c new file mode 100644 index 0000000..22d5bd6 --- /dev/null +++ b/src/net.c @@ -0,0 +1,888 @@ +#include +#include +#include + +#include +#include +#include + +#include "fixer.h" + +#include "3dc.h" +#include "platform.h" +#include "inline.h" +#include "gamedef.h" +#include "module.h" +#include "stratdef.h" +#include "projfont.h" +#include "krender.h" +#include "kshape.h" +#include "prototyp.h" +#include "d3d_hud.h" +#include "bh_types.h" +#include "equipmnt.h" +#include "bh_marin.h" +#include "bh_alien.h" +#include "pldghost.h" + +#define UseLocalAssert Yes +#include "ourasert.h" + +DISPLAYBLOCK PlayersMirrorImage; +STRATEGYBLOCK PlayersMirrorImageSB; +NETGHOSTDATABLOCK PlayersMirrorGhost; +DYNAMICSBLOCK PlayersMirrorDynBlock; + +extern int LastHand; + +/* support function for addnetmsg_playerstate() */ +static int MyPlayerHasAMuzzleFlash(STRATEGYBLOCK *sbPtr) +{ + PLAYER_WEAPON_DATA *weaponPtr; + TEMPLATE_WEAPON_DATA *twPtr; + PLAYER_STATUS *playerStatusPtr = (PLAYER_STATUS *)(Player->ObStrategyBlock->SBdataptr); + LOCALASSERT(playerStatusPtr); + + weaponPtr = &(playerStatusPtr->WeaponSlot[playerStatusPtr->SelectedWeaponSlot]); + twPtr = &TemplateWeapon[weaponPtr->WeaponIDNumber]; + + /* first check if we are displaying a muzle flash ourselves */ + if(twPtr->MuzzleFlashShapeName == NULL) return 0; + if(twPtr->PrimaryIsMeleeWeapon) return 0; + + if (weaponPtr->WeaponIDNumber==WEAPON_TWO_PISTOLS) { + if (weaponPtr->CurrentState == WEAPONSTATE_FIRING_PRIMARY) { + if (LastHand) { + return 2; + } else { + return 1; + } + } else if (weaponPtr->CurrentState == WEAPONSTATE_FIRING_SECONDARY) { + if (LastHand) { + return 2; + } else { + return 1; + } + return 0; + } + } + + if (weaponPtr->WeaponIDNumber==WEAPON_MARINE_PISTOL) { + if ((weaponPtr->CurrentState==WEAPONSTATE_FIRING_PRIMARY) + ||(weaponPtr->CurrentState==WEAPONSTATE_FIRING_SECONDARY)) { + //ReleasePrintDebuggingText("Pistol Muzzle Flash 1\n"); + return 1; + } else { + //ReleasePrintDebuggingText("Pistol Muzzle Flash 0\n"); + return 0; + } + } + + if (weaponPtr->CurrentState != WEAPONSTATE_FIRING_PRIMARY) { + return 0; + } + + /* even if we are displaying our own muzzle flash, we don't neccessarily want it to + be visible to other players (because it looks stupid) */ + if((weaponPtr->WeaponIDNumber==WEAPON_PULSERIFLE)|| + (weaponPtr->WeaponIDNumber==WEAPON_MARINE_PISTOL)|| + (weaponPtr->WeaponIDNumber==WEAPON_AUTOSHOTGUN)|| + (weaponPtr->WeaponIDNumber==WEAPON_SMARTGUN)|| + (weaponPtr->WeaponIDNumber==WEAPON_MINIGUN)|| + (weaponPtr->WeaponIDNumber==WEAPON_FRISBEE_LAUNCHER)|| + (weaponPtr->WeaponIDNumber==WEAPON_PRED_PISTOL)|| + (weaponPtr->WeaponIDNumber==WEAPON_PRED_RIFLE)) + { + /* if we get this far, we want to display a muzzle flash */ + return 1; + } + return 0; +} + +/* Patrick 11/7/97 ---------------------------------------------- +Functions for determining our sequence for player update messages +-----------------------------------------------------------------*/ + +static MARINE_SEQUENCE GetMyMarineSequence(void) +{ + int playerIsMoving = 0; + int playerIsFiring = 0; + int playerIsCrouching = 0; + int playerIsAlive = 0; + int playerIsJumping = 0; + int usingCloseAttackWeapon; + extern int StaffAttack; + + /* sort out what state we're in */ + if(PlayerStatusPtr->IsAlive) playerIsAlive = 1; + else playerIsAlive = 0; + + if (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Backward) { + playerIsMoving=-1; + } else if((PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Forward)|| + (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepLeft)|| + (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepRight)) { + playerIsMoving = 1; + } else { + playerIsMoving = 0; + } + + if ( (Player->ObStrategyBlock->DynPtr->Position.vx==Player->ObStrategyBlock->DynPtr->PrevPosition.vx) + && (Player->ObStrategyBlock->DynPtr->Position.vy==Player->ObStrategyBlock->DynPtr->PrevPosition.vy) + && (Player->ObStrategyBlock->DynPtr->Position.vz==Player->ObStrategyBlock->DynPtr->PrevPosition.vz) ) { + /* Actually not moving - overruled! */ + playerIsMoving=0; + } + + if(PlayerStatusPtr->ShapeState!=PMph_Standing) + { + playerIsCrouching = 1; + } + else + { + playerIsCrouching = 0; + } + + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)|| + (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY)) { + playerIsFiring = 1; + } else { + if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_MARINE_PISTOL) { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_SECONDARY)|| + (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_SECONDARY)) { + playerIsFiring = 1; + } else { + playerIsFiring = 0; + } + } else { + playerIsFiring = 0; + } + } + + if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_CUDGEL) + usingCloseAttackWeapon = 1; + else usingCloseAttackWeapon = 0; + + /* Fix cudgel. */ + if (usingCloseAttackWeapon) { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_SECONDARY)|| + (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_SECONDARY)) { + playerIsFiring = 1; + } + } + + /* KJL 14:27:14 10/29/97 - deal with jumping & falling */ + { + DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr; + if (!dynPtr->IsInContactWithFloor && (dynPtr->TimeNotInContactWithFloor==0)) + playerIsJumping=1; + } + + /* and deduce the sequence */ + if(playerIsAlive==0) + { + if(playerIsCrouching) { + return MSQ_CrouchDie; + } else { + return MSQ_StandDieFront; + } + } + + if(playerIsJumping) { + return MSQ_Jump; + } + + /* Put this in here... no running cudgel attacks yet. */ + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with cudgel case! */ + if (StaffAttack>=0) { + return(MSQ_BaseOfCudgelAttacks+StaffAttack); + } + } + + if(playerIsCrouching) + { + if(playerIsMoving>0) { + return MSQ_Crawl; + } else if (playerIsMoving<0) { + return MSQ_Crawl_Backwards; + } else { + return MSQ_Crouch; + } + } + + if(playerIsMoving>0) + { + if(playerIsFiring) { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_TWO_PISTOLS) + &&(LastHand)) { + return MSQ_RunningFireSecondary; + } else { + return MSQ_RunningFire; + } + } else { + return MSQ_Walk; + } + } else if (playerIsMoving<0) { + if(playerIsFiring) { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_TWO_PISTOLS) + &&(LastHand)) { + return MSQ_RunningFireSecondary_Backwards; + } else { + return MSQ_RunningFire_Backwards; + } + } else { + return MSQ_Walk_Backwards; + } + } + + if(playerIsFiring) { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_TWO_PISTOLS) + &&(LastHand)) { + return MSQ_StandingFireSecondary; + } else { + return MSQ_StandingFire; + } + } else { + if (PlayerStatusPtr->tauntTimer!=0) { + return MSQ_Taunt; + } else { + return MSQ_Stand; + } + } +} + +static ALIEN_SEQUENCE GetMyAlienSequence(void) +{ + extern STRATEGYBLOCK *Biting; + extern int Bit; + int playerIsMoving = 0; + int playerIsFiring = 0; + int playerIsCrouching = 0; + int playerIsAlive = 0; + int playerIsJumping = 0; + + /* sort out what state we're in */ + if(PlayerStatusPtr->IsAlive) playerIsAlive = 1; + else playerIsAlive = 0; + + if (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Backward) { + playerIsMoving =-1; + } else if ((PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Forward)|| + (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepLeft)|| + (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepRight)) { + playerIsMoving = 1; + } else { + playerIsMoving = 0; + } + + if ( (Player->ObStrategyBlock->DynPtr->Position.vx==Player->ObStrategyBlock->DynPtr->PrevPosition.vx) + && (Player->ObStrategyBlock->DynPtr->Position.vy==Player->ObStrategyBlock->DynPtr->PrevPosition.vy) + && (Player->ObStrategyBlock->DynPtr->Position.vz==Player->ObStrategyBlock->DynPtr->PrevPosition.vz) ) { + /* Actually not moving - overruled! */ + playerIsMoving=0; + } + + if(PlayerStatusPtr->ShapeState!=PMph_Standing) playerIsCrouching = 1; + else playerIsCrouching = 0; + + /* ChrisF 20/4/98: playerIsFiring now specifies alien weapon behaviour. */ + //if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)|| + // (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY)) + // playerIsFiring = 1; + //else playerIsFiring = 0; + // + //if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber!=WEAPON_ALIEN_SPIT) { + // usingCloseAttackWeapon = 1; + //} else { + // usingCloseAttackWeapon = 0; + //} + + switch(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState) { + case (WEAPONSTATE_FIRING_PRIMARY): + if(Biting) { + playerIsFiring=4; //Eat. + } else { + playerIsFiring=1; //Claw. + } + break; + case (WEAPONSTATE_FIRING_SECONDARY): + playerIsFiring=2; //Tail Poise. + break; + case (WEAPONSTATE_RECOIL_SECONDARY): + playerIsFiring=3; //Tail Strike. + break; + default: + playerIsFiring=0; //Nothing. + break; + } + + + /* KJL 14:27:14 10/29/97 - deal with jumping & falling */ + { + DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr; + if (!dynPtr->IsInContactWithFloor && (dynPtr->TimeNotInContactWithFloor==0)) + playerIsJumping=1; + } + + /* and deduce the sequence */ + if(playerIsAlive==0) + { + return ASQ_Stand; /* kind of irrelevant really */ + } + + if(playerIsJumping) /* TODO: consider jump & crouch */ + { + switch(playerIsFiring) { + case 1: + return ASQ_Pounce; + break; + case 2: + return ASQ_JumpingTailPoise; + break; + case 3: + return ASQ_JumpingTailStrike; + break; + case 4: + /* What the hell? */ + return ASQ_Eat; + break; + default: + return ASQ_Jump; + break; + } + } + + if(playerIsCrouching) + { + if(playerIsMoving>0) + { + switch(playerIsFiring) { + case 1: + return ASQ_CrawlingAttack_Claw; + break; + case 2: + return ASQ_CrawlingTailPoise; + break; + case 3: + return ASQ_CrawlingTailStrike; + break; + case 4: + /* What the hell? */ + return ASQ_CrouchEat; + break; + default: + if(Player->ObStrategyBlock->DynPtr->OrientMat.mat22>50000) + return ASQ_Scamper; + else + return ASQ_Crawl; + break; + } + } else if(playerIsMoving<0) { + switch(playerIsFiring) { + case 1: + return ASQ_CrawlingAttack_Claw_Backwards; + break; + case 2: + return ASQ_CrawlingTailPoise_Backwards; + break; + case 3: + return ASQ_CrawlingTailStrike_Backwards; + break; + case 4: + /* What the hell? */ + return ASQ_CrouchEat; + break; + default: + if(Player->ObStrategyBlock->DynPtr->OrientMat.mat22>50000) + return ASQ_Scamper_Backwards; + else + return ASQ_Crawl_Backwards; + break; + } + } + + switch(playerIsFiring) { + case 1: + return ASQ_CrouchedAttack_Claw; + break; + case 2: + return ASQ_CrouchedTailPoise; + break; + case 3: + return ASQ_CrouchedTailStrike; + break; + case 4: + return ASQ_Eat; + break; + default: + return ASQ_Crouch; + break; + } + } + + if(playerIsMoving>0) + { + switch(playerIsFiring) { + case 1: + return ASQ_RunningAttack_Claw; + break; + case 2: + return ASQ_RunningTailPoise; + break; + case 3: + return ASQ_RunningTailStrike; + break; + case 4: + /* What the hell? */ + return ASQ_Eat; + break; + default: + return ASQ_Run; + break; + } + } else if(playerIsMoving<0) { + switch(playerIsFiring) { + case 1: + return ASQ_RunningAttack_Claw_Backwards; + break; + case 2: + return ASQ_RunningTailPoise_Backwards; + break; + case 3: + return ASQ_RunningTailStrike_Backwards; + break; + case 4: + /* What the hell? */ + return ASQ_Eat; + break; + default: + return ASQ_Run_Backwards; + break; + } + } + + switch(playerIsFiring) { + case 1: + return ASQ_StandingAttack_Claw; + break; + case 2: + return ASQ_StandingTailPoise; + break; + case 3: + return ASQ_StandingTailStrike; + break; + case 4: + return ASQ_Eat; + break; + default: + if (PlayerStatusPtr->tauntTimer!=0) { + /* Second lowest priority ever. */ + return ASQ_Taunt; + } else { + return ASQ_Stand; + } + break; + } + +} + +static PREDATOR_SEQUENCE GetMyPredatorSequence(void) +{ + int playerIsMoving = 0; + int playerIsFiring = 0; + int playerIsCrouching = 0; + int playerIsAlive = 0; + int playerIsJumping = 0; + int usingCloseAttackWeapon; + extern int StaffAttack; + + /* sort out what state we're in */ + if(PlayerStatusPtr->IsAlive) playerIsAlive = 1; + else playerIsAlive = 0; + + if (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Backward) { + playerIsMoving=-1; + } else if((PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Forward)|| + (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepLeft)|| + (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepRight)) { + playerIsMoving = 1; + } else { + playerIsMoving = 0; + } + + if ( (Player->ObStrategyBlock->DynPtr->Position.vx==Player->ObStrategyBlock->DynPtr->PrevPosition.vx) + && (Player->ObStrategyBlock->DynPtr->Position.vy==Player->ObStrategyBlock->DynPtr->PrevPosition.vy) + && (Player->ObStrategyBlock->DynPtr->Position.vz==Player->ObStrategyBlock->DynPtr->PrevPosition.vz) ) { + /* Actually not moving - overruled! */ + playerIsMoving=0; + } + + if(PlayerStatusPtr->ShapeState!=PMph_Standing) playerIsCrouching = 1; + else playerIsCrouching = 0; + + playerIsFiring = 0; + + if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_SHOULDERCANNON) + { + //the shoulder cannon is fired during recoil (I think) + if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY) + { + playerIsFiring = 1; + } + } + else if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_WRISTBLADE) + { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)|| + (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY) || + (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_SECONDARY)) + { + if(StaffAttack!=-1) + { + playerIsFiring = 1; + } + } + } + else + { + if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)|| + (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY)) + { + playerIsFiring = 1; + } + } + + if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_WRISTBLADE) + usingCloseAttackWeapon = 3; + else if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_DISC) + usingCloseAttackWeapon = 1; + else if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_STAFF) + usingCloseAttackWeapon = 2; + else usingCloseAttackWeapon = 0; + + /* KJL 14:27:14 10/29/97 - deal with jumping & falling */ + { + DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr; + if (!dynPtr->IsInContactWithFloor && (dynPtr->TimeNotInContactWithFloor==0)) + playerIsJumping=1; + } + + /* and deduce the sequence */ + if(playerIsAlive==0) + { + if(playerIsCrouching) { + return PredSQ_CrouchDie; + } else { + return PredSQ_StandDie; + } + } + + if(playerIsJumping) { + return(PredSQ_Jump); + } + + if(playerIsCrouching) + { + if(playerIsMoving>0) + { + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with staff case! */ + if (usingCloseAttackWeapon==2) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfStaffAttacks+StaffAttack); + } + } else if (usingCloseAttackWeapon==3) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfWristbladeAttacks+StaffAttack); + } + } + return PredSQ_CrawlingSwipe; + } else { + return PredSQ_Crawl; + } + } else if (playerIsMoving<0) { + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with staff case! */ + if (usingCloseAttackWeapon==2) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfStaffAttacks+StaffAttack); + } + } else if (usingCloseAttackWeapon==3) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfWristbladeAttacks+StaffAttack); + } + } + return PredSQ_CrawlingSwipe_Backwards; + } else { + return PredSQ_Crawl_Backwards; + } + } + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with staff case! */ + if (usingCloseAttackWeapon==2) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfStaffAttacks+StaffAttack); + } + } else if (usingCloseAttackWeapon==3) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfWristbladeAttacks+StaffAttack); + } + } + return PredSQ_CrouchedSwipe; + } else { + return PredSQ_Crouch; + } + } + + if(playerIsMoving>0) + { + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with staff case! */ + if (usingCloseAttackWeapon==2) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfStaffAttacks+StaffAttack); + } + } else if (usingCloseAttackWeapon==3) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfWristbladeAttacks+StaffAttack); + } + } + return PredSQ_RunningSwipe; + } else { + return PredSQ_Run; + } + } else if (playerIsMoving<0) { + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with staff case! */ + if (usingCloseAttackWeapon==2) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfStaffAttacks+StaffAttack); + } + } else if (usingCloseAttackWeapon==3) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfWristbladeAttacks+StaffAttack); + } + } + return PredSQ_RunningSwipe_Backwards; + } else { + return PredSQ_Run_Backwards; + } + } + + if(playerIsFiring&&usingCloseAttackWeapon) { + /* Deal with staff case! */ + if (usingCloseAttackWeapon==2) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfStaffAttacks+StaffAttack); + } + } else if (usingCloseAttackWeapon==3) { + if (StaffAttack>=0) { + return(PredSQ_BaseOfWristbladeAttacks+StaffAttack); + } + } + return PredSQ_StandingSwipe; + } else { + if (PlayerStatusPtr->tauntTimer!=0) { + return PredSQ_Taunt; + } else { + return PredSQ_Stand; + } + } +} + +BOOL Current_Level_Requires_Mirror_Image() +{ + extern char LevelName[]; + if ( (!stricmp(LevelName,"e3demo")) || (!stricmp(LevelName,"e3demosp")) || (!stricmp(LevelName,"derelict")) ) + { + return TRUE; + } + return FALSE; +} + + +void CreatePlayersImageInMirror(void) +{ + AVP_BEHAVIOUR_TYPE type; + STRATEGYBLOCK *sbPtr = &PlayersMirrorImageSB; + NETGHOSTDATABLOCK *ghostData = &PlayersMirrorGhost; + PlayersMirrorImage.ObStrategyBlock = sbPtr; + + sbPtr->SBdptr = &PlayersMirrorImage; + + sbPtr->SBdataptr = (void *)ghostData; + sbPtr->DynPtr = &PlayersMirrorDynBlock; + + switch(AvP.PlayerType) + { + case(I_Marine): + { + type = I_BehaviourMarinePlayer; + break; + } + case(I_Predator): + { + type = I_BehaviourPredatorPlayer; + break; + } + case(I_Alien): + { + type = I_BehaviourAlienPlayer; + break; + } + } + ghostData->type = type; + ghostData->IOType=IOT_Non; + ghostData->subtype=0; + ghostData->myGunFlash = NULL; + ghostData->SoundHandle = SOUND_NOACTIVEINDEX; + ghostData->currentAnimSequence = 0; + ghostData->CloakingEffectiveness = 0; + ghostData->IgnitionHandshaking = 0; + ghostData->soundStartFlag = 0; + + if(AvP.Network == I_No_Network) + { + ghostData->playerId=0; + } + else + { +// ghostData->playerId=AVPDPNetID; + fprintf(stderr, "CreatePlayersImageInMirror: ghostData->playerId=AVPDPNetID\n"); + } + + /* set the shape */ + + switch(type) + { + case I_BehaviourMarinePlayer: + { + CreateMarineHModel(ghostData,WEAPON_PULSERIFLE); + break; + } + case I_BehaviourAlienPlayer: + { + CreateAlienHModel(ghostData); + break; + } + case I_BehaviourPredatorPlayer: + { + CreatePredatorHModel(ghostData,WEAPON_PRED_WRISTBLADE); + break; + } + default: + break; + } + + sbPtr->SBdptr->HModelControlBlock=&ghostData->HModelController; + ProveHModel(sbPtr->SBdptr->HModelControlBlock,sbPtr->SBdptr); +} + +void DeallocatePlayersMirrorImage() +{ +#if MIRRORING_ON + if(Current_Level_Requires_Mirror_Image()) + { + Dispel_HModel(&PlayersMirrorGhost.HModelController); + } +#endif +} + +void RenderPlayersImageInMirror(void) +{ + STRATEGYBLOCK *sbPtr = &PlayersMirrorImageSB; + NETGHOSTDATABLOCK *ghostData = &PlayersMirrorGhost; + + int sequence; + int weapon; + int firingPrimary; + int firingSecondary; + + switch(AvP.PlayerType) + { + case I_Marine: + { + sequence = (unsigned char)GetMyMarineSequence(); + //check for change of charcter type + if(ghostData->type!=I_BehaviourMarinePlayer) + { + ghostData->type=I_BehaviourMarinePlayer; + //settings currentweapon to -1 will forec the hmodel to be updated + ghostData->CurrentWeapon=-1; + } + + break; + } + case I_Predator: + { + sequence = (unsigned char)GetMyPredatorSequence(); + //check for change of charcter type + if(ghostData->type!=I_BehaviourPredatorPlayer) + { + ghostData->type=I_BehaviourPredatorPlayer; + //settings currentweapon to -1 will forec the hmodel to be updated + ghostData->CurrentWeapon=-1; + } + break; + } + case I_Alien: + { + sequence = (unsigned char)GetMyAlienSequence(); + //check for change of charcter type + if(ghostData->type!=I_BehaviourAlienPlayer) + { + ghostData->type=I_BehaviourAlienPlayer; + //setting currentweapon to -1 will force the hmodel to be updated + ghostData->CurrentWeapon=-1; + } + break; + } + default: + { + LOCALASSERT(1==0); + break; + } + } + /* my current weapon id, and whether I am firing it... */ + { + PLAYER_WEAPON_DATA *weaponPtr; + PLAYER_STATUS *playerStatusPtr = (PLAYER_STATUS *)(Player->ObStrategyBlock->SBdataptr); + LOCALASSERT(playerStatusPtr); + weaponPtr = &(playerStatusPtr->WeaponSlot[playerStatusPtr->SelectedWeaponSlot]); + weapon = (signed char)(weaponPtr->WeaponIDNumber); + + if((weaponPtr->CurrentState==WEAPONSTATE_FIRING_PRIMARY)&&(playerStatusPtr->IsAlive)) + firingPrimary = 1; + else firingPrimary = 0; + if((weaponPtr->CurrentState==WEAPONSTATE_FIRING_SECONDARY)&&(playerStatusPtr->IsAlive)) + firingSecondary = 1; + else firingSecondary = 0; + } + +// if(!(((!(messagePtr->IAmAlive)))&&(netGameData.playerData[playerIndex].characterType==NGCT_Alien))) + { + { + PLAYER_STATUS *playerStatusPtr= (PLAYER_STATUS *) (Player->ObStrategyBlock->SBdataptr); + HandleWeaponElevation(sbPtr,playerStatusPtr->ViewPanX,weapon); + + UpdateGhost(sbPtr,&(Player->ObStrategyBlock->DynPtr->Position),&(Player->ObStrategyBlock->DynPtr->OrientEuler),sequence,AreTwoPistolsInTertiaryFire()); + + + MaintainGhostCloakingStatus(sbPtr,(int)playerStatusPtr->cloakOn); + } + } + { + extern VIEWDESCRIPTORBLOCK *Global_VDB_Ptr; + DISPLAYBLOCK *dPtr = &PlayersMirrorImage; + dPtr->ObWorld = PlayersMirrorDynBlock.Position; + dPtr->ObMat = PlayersMirrorDynBlock.OrientMat; + ReflectObject(dPtr); + + PlayersMirrorImage.ObStrategyBlock = 0; + + AddShape(dPtr,Global_VDB_Ptr); + PlayersMirrorImage.ObStrategyBlock = &PlayersMirrorImageSB; + + } + HandleGhostGunFlashEffect(sbPtr,MyPlayerHasAMuzzleFlash(sbPtr)); +} diff --git a/src/opengl.c b/src/opengl.c index 20b8fa6..ea3855d 100644 --- a/src/opengl.c +++ b/src/opengl.c @@ -13,7 +13,6 @@ #include "module.h" #include "stratdef.h" #include "projfont.h" -#include "savegame.h" #include "krender.h" #include "kshape.h" #include "prototyp.h" @@ -101,3 +100,7 @@ switch(RenderPolygon.TranslucencyMode) CurrTextureHandle = TextureHandle; #endif } + +void D3D_Particle_Output(PARTICLE *particlePtr, RENDERVERTEX *renderVerticesPtr) +{ +} diff --git a/src/render.c b/src/render.c new file mode 100644 index 0000000..8ffd801 --- /dev/null +++ b/src/render.c @@ -0,0 +1,67 @@ +#include +#include +#include + +#include +#include +#include + +#include "fixer.h" + +#include "3dc.h" +#include "platform.h" +#include "inline.h" +#include "gamedef.h" +#include "module.h" +#include "stratdef.h" +#include "projfont.h" +#include "krender.h" +#include "kshape.h" +#include "prototyp.h" +#include "d3d_hud.h" +#include "bh_types.h" +#include "equipmnt.h" +#include "pldghost.h" + +#define UseLocalAssert Yes +#include "ourasert.h" + +extern DISPLAYBLOCK *ActiveBlockList[]; +extern int NumActiveBlocks; +extern int GlobalAmbience; + +int LightIntensityAtPoint(VECTORCH *pointPtr) +{ + int intensity = 0; + int i, j; + + DISPLAYBLOCK **activeBlockListPtr = ActiveBlockList; + for(i = NumActiveBlocks; i != 0; i--) { + DISPLAYBLOCK *dispPtr = *activeBlockListPtr++; + + if (dispPtr->ObNumLights) { + for(j = 0; j < dispPtr->ObNumLights; j++) { + LIGHTBLOCK *lptr = dispPtr->ObLights[j]; + VECTORCH disp = lptr->LightWorld; + int dist; + + disp.vx -= pointPtr->vx; + disp.vy -= pointPtr->vy; + disp.vz -= pointPtr->vz; + + dist = Approximate3dMagnitude(&disp); + + if (distLightRange) { + intensity += WideMulNarrowDiv(lptr->LightBright,lptr->LightRange-dist,lptr->LightRange); + } + } + } + } + if (intensity>ONE_FIXED) intensity=ONE_FIXED; + else if (intensity