mirror of
https://github.com/blendogames/thirtyflightsofloving.git
synced 2024-11-15 00:41:21 +00:00
561 lines
11 KiB
C
561 lines
11 KiB
C
#if defined(_DEBUG) && defined(_Z_TESTMODE)
|
|
|
|
#include "g_local.h"
|
|
|
|
void Weapon_Generic (edict_t *ent,
|
|
int FRAME_ACTIVATE_LAST,
|
|
int FRAME_FIRE_LAST,
|
|
int FRAME_IDLE_LAST,
|
|
int FRAME_DEACTIVATE_LAST,
|
|
int *pause_frames,
|
|
int *fire_frames,
|
|
void (*fire)(edict_t *ent));
|
|
void P_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result);
|
|
|
|
|
|
static char testItem_className[256];
|
|
static char testItem_gModel[256];
|
|
static char testItem_icon[256];
|
|
static char testItem_name[256];
|
|
static char testItem_aminationFramesStr[4096];
|
|
static int testItem_aminationFrames[100];
|
|
static vec3_t testItem_Size[2];
|
|
|
|
|
|
gitem_t *testItem;
|
|
edict_t *testItemDroped = NULL;
|
|
int animUpto;
|
|
qboolean testitemOriginMove = false;
|
|
float animSpeed = 1.0;
|
|
|
|
|
|
|
|
|
|
float lineSize = 100.0f;
|
|
|
|
void Weapon_LineDraw_Fire (edict_t *ent);
|
|
|
|
void Weapon_LineDraw_Think (edict_t *ent)
|
|
{
|
|
Weapon_LineDraw_Fire (ent->owner);
|
|
ent->owner->client->ps.gunframe--;
|
|
}
|
|
|
|
|
|
void Weapon_LineDraw_Fire (edict_t *ent)
|
|
{
|
|
edict_t *beam;
|
|
vec3_t start;
|
|
vec3_t forward, right;
|
|
vec3_t offset;
|
|
|
|
AngleVectors (ent->client->v_angle, forward, right, NULL);
|
|
|
|
VectorSet(offset, 0, 7, ent->viewheight - 8);
|
|
P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
|
|
|
|
if(!ent->client->lineDraw)
|
|
{
|
|
beam = ent->client->lineDraw = G_Spawn();
|
|
|
|
beam->classname = "DrawLine";
|
|
|
|
beam->flags |= FL_DONTSETOLDORIGIN;
|
|
|
|
beam->owner = ent;
|
|
|
|
beam->movetype = MOVETYPE_NONE;
|
|
beam->solid = SOLID_NOT;
|
|
beam->s.renderfx |= RF_BEAM|RF_TRANSLUCENT;
|
|
beam->s.modelindex = 1; // must be non-zero
|
|
|
|
VectorSet (beam->mins, -8, -8, -8);
|
|
VectorSet (beam->maxs, 8, 8, 8);
|
|
|
|
beam->s.frame = 2;
|
|
beam->s.skinnum = 0xf3f3f1f1;
|
|
|
|
beam->think = Weapon_LineDraw_Think;
|
|
beam->nextthink = level.time + (FRAMETIME * 2);
|
|
}
|
|
else
|
|
{
|
|
beam = ent->client->lineDraw;
|
|
}
|
|
|
|
VectorCopy (start, beam->s.origin);
|
|
VectorMA (start, lineSize, forward, beam->s.old_origin);
|
|
|
|
gi.linkentity (beam);
|
|
ent->client->ps.gunframe++;
|
|
}
|
|
|
|
|
|
|
|
void Weapon_LineDraw (edict_t *ent)
|
|
{
|
|
static int pause_frames[] = {19, 32, 0};
|
|
static int fire_frames[] = {5, 0};
|
|
|
|
Weapon_Generic (ent, 4, 8, 52, 55, pause_frames, fire_frames, Weapon_LineDraw_Fire);
|
|
}
|
|
|
|
|
|
|
|
static char testWeap_className[256];
|
|
static char testWeap_gModel[256];
|
|
static char testWeap_vModel[256];
|
|
static char testWeap_icon[256];
|
|
static char testWeap_name[256];
|
|
static char testWeap_aminationFrames[512];
|
|
static char testWeap_idleFrames[512];
|
|
static char testWeap_fireFrames[512];
|
|
static int testWeap_FRAME_ACTIVATE_LAST;
|
|
static int testWeap_FRAME_FIRE_LAST;
|
|
static int testWeap_FRAME_IDLE_LAST;
|
|
static int testWeap_FRAME_DEACTIVATE_LAST;
|
|
static int testWeap_pause_frames[20];
|
|
static int testWeap_fire_frames[20];
|
|
|
|
|
|
gitem_t *testWeapon;
|
|
|
|
|
|
void convertToNumbers(char *frames, int *arrayFrames)
|
|
{
|
|
int num = 0;
|
|
char *bp, *sp;
|
|
|
|
sp = bp = frames;
|
|
|
|
while(1)
|
|
{
|
|
while(*bp != ',' && *bp != (char)NULL)
|
|
{
|
|
bp++;
|
|
}
|
|
|
|
arrayFrames[num] = atoi(sp);
|
|
|
|
num++;
|
|
|
|
if(*bp == (char)NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
sp = bp + 1;
|
|
|
|
while(*sp == ' ')
|
|
{
|
|
sp++;
|
|
}
|
|
|
|
bp = sp;
|
|
}
|
|
|
|
arrayFrames[num] = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
void convertToVector(char *vecStr, vec3_t *size)
|
|
{
|
|
int num = 0;
|
|
char *bp, *sp;
|
|
|
|
sp = bp = vecStr;
|
|
|
|
while(1)
|
|
{
|
|
while(*bp != ',' && *bp != (char)NULL)
|
|
{
|
|
bp++;
|
|
}
|
|
|
|
(*size)[num] = atof(sp);
|
|
|
|
num++;
|
|
|
|
if(num > 2)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(*bp == (char)NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
sp = bp + 1;
|
|
|
|
while(*sp == ' ')
|
|
{
|
|
sp++;
|
|
}
|
|
|
|
bp = sp;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void InitTestWeapon(void)
|
|
{
|
|
FILE *wCfgFile;
|
|
char fname[256];
|
|
|
|
testWeapon = FindItemByClassname ("weapon_test");
|
|
if(!testWeapon)
|
|
{
|
|
return;
|
|
}
|
|
|
|
strcpy(fname, gamedir->string);
|
|
strcat(fname, "/testweapon.cfg");
|
|
|
|
wCfgFile = fopen(fname, "rt");
|
|
if(!wCfgFile)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!fgets(testWeap_className, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testWeap_className[strlen(testWeap_className) - 1] = 0;
|
|
|
|
if(!fgets(testWeap_gModel, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testWeap_gModel[strlen(testWeap_gModel) - 1] = 0;
|
|
|
|
if(!fgets(testWeap_vModel, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testWeap_vModel[strlen(testWeap_vModel) - 1] = 0;
|
|
|
|
if(!fgets(testWeap_icon, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testWeap_icon[strlen(testWeap_icon) - 1] = 0;
|
|
|
|
if(!fgets(testWeap_name, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testWeap_name[strlen(testWeap_name) - 1] = 0;
|
|
|
|
if(!fgets(testWeap_aminationFrames, 512, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
if(!fgets(testWeap_idleFrames, 512, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
if(!fgets(testWeap_fireFrames, 512, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
fclose(wCfgFile);
|
|
|
|
|
|
sscanf(testWeap_aminationFrames, "%d,%d,%d,%d", &testWeap_FRAME_ACTIVATE_LAST, &testWeap_FRAME_FIRE_LAST, &testWeap_FRAME_IDLE_LAST, &testWeap_FRAME_DEACTIVATE_LAST);
|
|
|
|
convertToNumbers(testWeap_idleFrames, testWeap_pause_frames);
|
|
convertToNumbers(testWeap_fireFrames, testWeap_fire_frames);
|
|
|
|
testWeapon->classname = testWeap_className;
|
|
testWeapon->world_model = testWeap_gModel;
|
|
testWeapon->view_model = testWeap_vModel;
|
|
testWeapon->icon = testWeap_icon;
|
|
testWeapon->pickup_name = testWeap_name;
|
|
}
|
|
|
|
|
|
void Weapon_Test_Fire (edict_t *ent)
|
|
{
|
|
gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/blastf1a.wav"), 1, ATTN_NORM, 0);
|
|
ent->client->ps.gunframe++;
|
|
}
|
|
|
|
|
|
|
|
void Weapon_Test (edict_t *ent)
|
|
{
|
|
Weapon_Generic (ent, testWeap_FRAME_ACTIVATE_LAST,
|
|
testWeap_FRAME_FIRE_LAST, testWeap_FRAME_IDLE_LAST,
|
|
testWeap_FRAME_DEACTIVATE_LAST,
|
|
testWeap_pause_frames, testWeap_fire_frames, Weapon_Test_Fire);
|
|
}
|
|
|
|
|
|
/*static*/ void testitem_think (edict_t *ent)
|
|
{
|
|
if(testItem_aminationFrames[animUpto])
|
|
{
|
|
ent->s.frame++;
|
|
if(ent->s.frame >= testItem_aminationFrames[animUpto])
|
|
{
|
|
if(animUpto)
|
|
{
|
|
ent->s.frame = testItem_aminationFrames[animUpto - 1];
|
|
}
|
|
else
|
|
{
|
|
ent->s.frame = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
ent->nextthink = level.time + (FRAMETIME * animSpeed);
|
|
}
|
|
|
|
|
|
void Cmd_TestItem (edict_t *ent)
|
|
{
|
|
char *cmd;
|
|
|
|
cmd = gi.argv(1);
|
|
|
|
if (Q_stricmp (cmd, "animnext") == 0)
|
|
{
|
|
if(testItem_aminationFrames[animUpto] && testItem_aminationFrames[animUpto + 1])
|
|
{
|
|
animUpto++;
|
|
|
|
gi.cprintf (ent, PRINT_HIGH, "Animation %d set\n", animUpto);
|
|
}
|
|
}
|
|
else if (Q_stricmp (cmd, "animprev") == 0)
|
|
{
|
|
if(animUpto && testItem_aminationFrames[animUpto - 1])
|
|
{
|
|
animUpto--;
|
|
|
|
gi.cprintf (ent, PRINT_HIGH, "Animation %d set\n", animUpto);
|
|
}
|
|
}
|
|
else if (Q_stricmp (cmd, "animspeed") == 0)
|
|
{
|
|
float as = atof(gi.argv(2));
|
|
|
|
if(as < 1.0)
|
|
{
|
|
gi.cprintf (ent, PRINT_HIGH, "AnimSpeed must be greater than or equal to 1\n");
|
|
return;
|
|
}
|
|
|
|
animSpeed = as;
|
|
}
|
|
else if (Q_stricmp (cmd, "movestart") == 0)
|
|
{
|
|
if(testItemDroped)
|
|
{
|
|
testitemOriginMove = true;
|
|
gi.cprintf (ent, PRINT_HIGH, "testitem move start\n");
|
|
}
|
|
}
|
|
else if (Q_stricmp (cmd, "moveend") == 0)
|
|
{
|
|
if(testItemDroped)
|
|
{
|
|
testitemOriginMove = false;
|
|
gi.cprintf (ent, PRINT_HIGH, "testitem move end\n");
|
|
}
|
|
}
|
|
else if (Q_stricmp (cmd, "rotatestart") == 0)
|
|
{
|
|
if(testItemDroped)
|
|
{
|
|
testItemDroped->s.effects = EF_ROTATE;
|
|
gi.cprintf (ent, PRINT_HIGH, "Rotate On\n");
|
|
}
|
|
}
|
|
else if (Q_stricmp (cmd, "rotateend") == 0)
|
|
{
|
|
if(testItemDroped)
|
|
{
|
|
testItemDroped->s.effects = 0;
|
|
gi.cprintf (ent, PRINT_HIGH, "Rotate Off\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gi.cprintf (ent, PRINT_HIGH, "Bad testitem command\n");
|
|
}
|
|
}
|
|
|
|
|
|
void InitTestItem(void)
|
|
{
|
|
FILE *wCfgFile;
|
|
char fname[256];
|
|
|
|
testItem = FindItemByClassname ("item_test");
|
|
if(!testItem)
|
|
{
|
|
return;
|
|
}
|
|
|
|
strcpy(fname, gamedir->string);
|
|
strcat(fname, "/testitem.cfg");
|
|
|
|
wCfgFile = fopen(fname, "rt");
|
|
if(!wCfgFile)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!fgets(testItem_className, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testItem_className[strlen(testItem_className) - 1] = 0;
|
|
|
|
if(!fgets(testItem_gModel, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testItem_gModel[strlen(testItem_gModel) - 1] = 0;
|
|
|
|
if(!fgets(testItem_icon, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testItem_icon[strlen(testItem_icon) - 1] = 0;
|
|
|
|
if(!fgets(testItem_name, 256, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
testItem_name[strlen(testItem_name) - 1] = 0;
|
|
|
|
if(!fgets(testItem_aminationFramesStr, 4096, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
convertToNumbers(testItem_aminationFramesStr, testItem_aminationFrames);
|
|
|
|
|
|
if(!fgets(testItem_aminationFramesStr, 4096, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
convertToVector(testItem_aminationFramesStr, &(testItem_Size[0]));
|
|
|
|
if(!fgets(testItem_aminationFramesStr, 4096, wCfgFile))
|
|
{
|
|
fclose(wCfgFile);
|
|
return;
|
|
}
|
|
|
|
convertToVector(testItem_aminationFramesStr, &(testItem_Size[1]));
|
|
|
|
testItem->classname = testItem_className;
|
|
testItem->world_model = testItem_gModel;
|
|
testItem->view_model = testItem_gModel;
|
|
testItem->icon = testItem_icon;
|
|
testItem->pickup_name = testItem_name;
|
|
}
|
|
|
|
|
|
|
|
|
|
qboolean Pickup_TestItem (edict_t *ent, edict_t *other)
|
|
{
|
|
other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
|
|
|
|
return true;
|
|
}
|
|
|
|
void drop_temp_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf);
|
|
|
|
void Drop_TestItem (edict_t *ent, gitem_t *item)
|
|
{
|
|
vec3_t forward, right;
|
|
vec3_t offset;
|
|
|
|
testitemOriginMove = false;
|
|
|
|
testItemDroped = G_Spawn();
|
|
|
|
testItemDroped->classname = item->classname;
|
|
testItemDroped->item = item;
|
|
testItemDroped->spawnflags = DROPPED_ITEM;
|
|
testItemDroped->s.effects = item->world_model_flags;
|
|
testItemDroped->s.renderfx = RF_GLOW;
|
|
VectorCopy(testItem_Size[0], testItemDroped->mins);
|
|
VectorCopy(testItem_Size[1], testItemDroped->maxs);
|
|
gi.setmodel (testItemDroped, testItemDroped->item->world_model);
|
|
testItemDroped->s.skinnum = 0;
|
|
testItemDroped->solid = SOLID_TRIGGER;
|
|
testItemDroped->movetype = MOVETYPE_TOSS;
|
|
testItemDroped->touch = drop_temp_touch;
|
|
testItemDroped->owner = ent;
|
|
|
|
if (ent->client)
|
|
{
|
|
trace_t trace;
|
|
|
|
AngleVectors (ent->client->v_angle, forward, right, NULL);
|
|
VectorSet(offset, 24, 0, -16);
|
|
G_ProjectSource (ent->s.origin, offset, forward, right, testItemDroped->s.origin);
|
|
trace = gi.trace (ent->s.origin, testItemDroped->mins, testItemDroped->maxs,
|
|
testItemDroped->s.origin, ent, CONTENTS_SOLID);
|
|
VectorCopy (trace.endpos, testItemDroped->s.origin);
|
|
}
|
|
else
|
|
{
|
|
AngleVectors (ent->s.angles, forward, right, NULL);
|
|
VectorCopy (ent->s.origin, testItemDroped->s.origin);
|
|
}
|
|
|
|
VectorScale (forward, 100, testItemDroped->velocity);
|
|
testItemDroped->velocity[2] = 300;
|
|
|
|
testItemDroped->think = testitem_think;
|
|
testItemDroped->nextthink = level.time + 1;
|
|
|
|
gi.linkentity (testItemDroped);
|
|
|
|
ent->client->pers.inventory[ITEM_INDEX(item)]--;
|
|
ValidateSelectedItem (ent);
|
|
}
|
|
|
|
|
|
#endif
|