summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/main.c221
-rw-r--r--src/net.c888
-rw-r--r--src/opengl.c5
-rw-r--r--src/render.c67
-rw-r--r--src/stubs.c34
5 files changed, 1176 insertions, 39 deletions
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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <SDL.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+#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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <SDL.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+#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 (dist<lptr->LightRange) {
+ intensity += WideMulNarrowDiv(lptr->LightBright,lptr->LightRange-dist,lptr->LightRange);
+ }
+ }
+ }
+ }
+ if (intensity>ONE_FIXED) intensity=ONE_FIXED;
+ else if (intensity<GlobalAmbience) intensity=GlobalAmbience;
+
+ /* KJL 20:31:39 12/1/97 - limit how dark things can be so blood doesn't go green */
+ if (intensity<10*256) intensity = 10*256;
+
+ return intensity;
+}
diff --git a/src/stubs.c b/src/stubs.c
index a134f99..756f2a9 100644
--- a/src/stubs.c
+++ b/src/stubs.c
@@ -423,13 +423,6 @@ void DrawScanlinesOverlay(float level)
fprintf(stderr, "DrawScanlinesOverlay(%f)\n", level);
}
-int LightIntensityAtPoint(VECTORCH *pointPtr)
-{
- fprintf(stderr, "LightIntensityAtPoint(%p)\n", pointPtr);
-
- return 0;
-}
-
void RenderString(char *stringPtr, int x, int y, int colour)
{
fprintf(stderr, "RenderString(%s, %d, %d, %d)\n", stringPtr, x, y, colour);
@@ -556,11 +549,6 @@ void D3D_PlayerDamagedOverlay(int intensity)
fprintf(stderr, "D3D_PlayerDamagedOverlay(%d)\n", intensity);
}
-void D3D_Particle_Output(PARTICLE *particlePtr,RENDERVERTEX *renderVerticesPtr)
-{
- fprintf(stderr, "D3D_Particle_Output(%p, %p)\n", particlePtr, renderVerticesPtr);
-}
-
void D3D_HUD_Setup()
{
fprintf(stderr, "D3D_HUD_Setup()\n");
@@ -869,28 +857,6 @@ void DoMultiplayerSpecificHud()
fprintf(stderr, "DoMultiplayerSpecificHud()\n");
}
-BOOL Current_Level_Requires_Mirror_Image()
-{
- fprintf(stderr, "Current_Level_Requires_Mirror_Image()\n");
-
- return FALSE;
-}
-
-void CreatePlayersImageInMirror()
-{
- fprintf(stderr, "CreatePlayersImageInMirror()\n");
-}
-
-void RenderPlayersImageInMirror()
-{
- fprintf(stderr, "RenderPlayersImageInMirror()\n");
-}
-
-void DeallocatePlayersMirrorImage()
-{
- fprintf(stderr, "DeallocatePlayersMirrorImage()\n");
-}
-
void AddNetMsg_AlienAIKilled(STRATEGYBLOCK *sbPtr,int death_code,int death_time, int GibbFactor,DAMAGE_PROFILE* damage)
{
fprintf(stderr, "AddNetMsg_AlienAIKilled(%p, %d, %d, %d, %p)\n", sbPtr, death_code, death_time, GibbFactor, damage);
generated by cgit v1.3 (git 2.53.0) at 2026-03-22 11:31:48 +0000