demonkenny/monstermod-redo-repo-copy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reworked configs to use a more elegant key->value format.

Browse Source
This commit is contained in:
Julian
2020-02-27 19:30:02 -03:00
parent cc33d0efeb
commit b22f0d1e89
3 changed files with 324 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
src/dlls/dllapi.cpp
View File

@@ -1,5 +1,9 @@
//
// botman's monster - MetaMOD plugin
// Monster Mod is a modification based on Botman's original "Monster" plugin.
// The "forgotten" modification was made by Rick90.
// This is an attempt to recreate the plugin so it does not become lost again.
//
// Recreated by Giegue.
//
// dllapi.cpp
//
@@ -101,20 +105,23 @@ DLL_DECALLIST gDecals[] = {
monster_type_t monster_types[]=
{
"agrunt", FALSE,
"apache", FALSE,
"barney", FALSE,
"bigmomma", FALSE,
"bullsquid", FALSE,
"controller", FALSE,
"hassassin", FALSE,
"headcrab", FALSE,
"hgrunt", FALSE,
"houndeye", FALSE,
"islave", FALSE,
"scientist", FALSE,
"snark", FALSE,
"zombie", FALSE,
// These are just names. But to keep it consistent
// with the new KVD format, ensure these are exactly
// like an actual, entity classname.
"monster_alien_grunt", FALSE,
"monster_apache", FALSE,
"monster_barney", FALSE,
"monster_bigmomma", FALSE,
"monster_bullsquid", FALSE,
"monster_alien_controller", FALSE,
"monster_hassassin", FALSE,
"monster_headcrab", FALSE,
"monster_human_grunt", FALSE,
"monster_houndeye", FALSE,
"monster_alien_slave", FALSE,
"monster_scientist", FALSE,
"monster_snark", FALSE,
"monster_zombie", FALSE,
"", FALSE
};
@@ -320,7 +327,7 @@ void check_monster_dead(void)
}
bool spawn_monster(int monster_type, Vector origin, float angle, int respawn_index)
bool spawn_monster(int monster_type, Vector origin, Vector angles, int respawn_index)
{
int monster_index;
edict_t *monster_pent;
@@ -399,8 +406,12 @@ bool spawn_monster(int monster_type, Vector origin, float angle, int respawn_ind
monsters[monster_index].monster_index = (*g_engfuncs.pfnIndexOfEdict)(monster_pent);
monster_pent->v.origin = origin;
monster_pent->v.angles.y = angle;
monster_pent->v.angles = angles;
// Since the entity is now linked to the class above,
// it's pev->classname should be, theorically, safe to edit.
// The pev->classname is set in the monster's Spawn() function.
//monster_pent->v.classname = MAKE_STRING("monster_zombie");
monsters[monster_index].pMonster->Spawn();
monster_pent->v.spawnflags = SF_MONSTER_FADECORPSE;
@@ -412,10 +423,9 @@ bool spawn_monster(int monster_type, Vector origin, float angle, int respawn_ind
void check_respawn(void)
{
int type_index;
int monster_type;
Vector origin;
float angle;
Vector angles;
if (!monster_spawn->value)
return; // monster_spawn is turned off, retry again later
@@ -427,20 +437,13 @@ void check_respawn(void)
{
monster_spawnpoint[index].need_to_respawn = FALSE;
type_index = RANDOM_LONG(0, monster_spawnpoint[index].monster_count-1);
monster_type = monster_spawnpoint[index].monster[type_index];
monster_type = monster_spawnpoint[index].monster;
origin = monster_spawnpoint[index].origin;
angle = monster_spawnpoint[index].angle_min;
angles = monster_spawnpoint[index].angles;
if (angle != monster_spawnpoint[index].angle_max)
{
angle = RANDOM_FLOAT(angle, monster_spawnpoint[index].angle_max);
}
if (spawn_monster(monster_type, origin, angle, index))
if (spawn_monster(monster_type, origin, angles, index))
{
// spawn_monster failed, retry again after delay...
monster_spawnpoint[index].need_to_respawn = TRUE;
@@ -573,7 +576,7 @@ void MonsterCommand(void)
Vector origin = pPlayer->v.origin;
Vector view_angle = pPlayer->v.v_angle;
Vector v_src, v_dest;
float monster_angle;
Vector monster_angle;
// try to determine the best place to spawn the monster...
@@ -596,11 +599,11 @@ void MonsterCommand(void)
if (tr.flFraction < 1.0) // hit something?
{
monster_angle = view_angle.y + 180.0f; // face the player
if (monster_angle > 360)
monster_angle -= 360;
if (monster_angle < 0)
monster_angle += 360;
monster_angle.y = view_angle.y + 180.0f; // face the player
if (monster_angle.y > 360)
monster_angle.y -= 360;
if (monster_angle.y < 0)
monster_angle.y += 360;
spawn_monster(monster_type, v_src, monster_angle, -1);
@@ -624,11 +627,11 @@ void MonsterCommand(void)
if (tr.flFraction < 1.0) // hit something?
{
monster_angle = view_angle.y - 135.0f; // face the player
if (monster_angle > 360)
monster_angle -= 360;
if (monster_angle < 0)
monster_angle += 360;
monster_angle.y = view_angle.y - 135.0f; // face the player
if (monster_angle.y > 360)
monster_angle.y -= 360;
if (monster_angle.y < 0)
monster_angle.y += 360;
spawn_monster(monster_type, v_src, monster_angle, -1);
@@ -652,11 +655,11 @@ void MonsterCommand(void)
if (tr.flFraction < 1.0) // hit something?
{
monster_angle = view_angle.y + 135.0f; // face the player
if (monster_angle > 360)
monster_angle -= 360;
if (monster_angle < 0)
monster_angle += 360;
monster_angle.y = view_angle.y + 135.0f; // face the player
if (monster_angle.y > 360)
monster_angle.y -= 360;
if (monster_angle.y < 0)
monster_angle.y += 360;
spawn_monster(monster_type, v_src, monster_angle, -1);
@@ -679,11 +682,11 @@ void MonsterCommand(void)
if (tr.flFraction < 1.0) // hit something?
{
monster_angle = view_angle.y + 90.0f; // face the player
if (monster_angle > 360)
monster_angle -= 360;
if (monster_angle < 0)
monster_angle += 360;
monster_angle.y = view_angle.y + 90.0f; // face the player
if (monster_angle.y > 360)
monster_angle.y -= 360;
if (monster_angle.y < 0)
monster_angle.y += 360;
spawn_monster(monster_type, v_src, monster_angle, -1);
@@ -706,11 +709,11 @@ void MonsterCommand(void)
if (tr.flFraction < 1.0) // hit something?
{
monster_angle = view_angle.y - 90.0f; // face the player
if (monster_angle > 360)
monster_angle -= 360;
if (monster_angle < 0)
monster_angle += 360;
monster_angle.y = view_angle.y - 90.0f; // face the player
if (monster_angle.y > 360)
monster_angle.y -= 360;
if (monster_angle.y < 0)
monster_angle.y += 360;
spawn_monster(monster_type, v_src, monster_angle, -1);
@@ -733,11 +736,11 @@ void MonsterCommand(void)
if (tr.flFraction < 1.0) // hit something?
{
monster_angle = view_angle.y; // face the player
if (monster_angle > 360)
monster_angle -= 360;
if (monster_angle < 0)
monster_angle += 360;
monster_angle.y = view_angle.y; // face the player
if (monster_angle.y > 360)
monster_angle.y -= 360;
if (monster_angle.y < 0)
monster_angle.y += 360;
spawn_monster(monster_type, v_src, monster_angle, -1);
@@ -850,9 +853,14 @@ void mmDispatchThink( edict_t *pent )
RETURN_META(MRES_IGNORED);
}
// HACKHACK -- this is a hack to keep the node graph entity from "touching" things (like triggers)
// while it builds the graph
BOOL gTouchDisabled = FALSE;
void mmDispatchTouch( edict_t *pentTouched, edict_t *pentOther )
{
if (gTouchDisabled)
RETURN_META(MRES_SUPERCEDE);
for (int index=0; index < monster_ents_used; index++)
{
if ((pentTouched != NULL) && (pentTouched == monsters[index].monster_pent))

308
src/dlls/monster_config.cpp
View File

@@ -35,8 +35,7 @@ bool get_input(FILE *fp, char *input)
continue; // skip any null lines
// remove any trailing newline, carriage return or whitespace...
while ((line[len-1] == '\n') || (line[len-1] == '\r') ||
isspace(line[len-1]))
while ((line[len-1] == '\n') || (line[len-1] == '\r') || isspace(line[len-1]))
{
line[len-1] = 0;
len--;
@@ -63,246 +62,155 @@ bool get_input(FILE *fp, char *input)
return FALSE; // no input found
}
bool scan_monster_cfg(FILE *fp)
struct pKVD
{
char key[33];
char value[33];
};
void scan_monster_cfg(FILE *fp)
{
// Let's make a full rework of this. -Giegue
char input[1024];
bool origin, angle, delay, angle_min, angle_max, monster;
float x, y, z;
while (get_input(fp, input))
{
if (monster_spawn_count == MAX_MONSTERS)
continue; // skip if max monster spawn count reached
if (input[0] == '{')
{
origin = angle = delay = angle_min = angle_max = monster = FALSE;
monster_spawnpoint[monster_spawn_count].monster_count = 0;
// Proper start, initialize entity creation
// Temporary variables to store entity data
pKVD *data = (pKVD*)malloc(32*sizeof(*data)); // Entities should not have more than 32 keyvalues
int kvd_index = 0;
while (get_input(fp, input))
{
// It's the end of the entity structure?
if (input[0] == '}')
break;
{
// Done. Let's process the keyvalues.
for (int i = 0; i < kvd_index; i++)
{
float x, y, z;
// Any unknown keyvalue is ignored.
// Any duplicate keyvalue is overwritten.
if (strncmp(input, "origin/", 7) == 0)
if (strcmp(data[i].key, "origin") == 0)
{
if (origin)
if (sscanf(data[i].value, "%f %f %f", &x, &y, &z) != 3)
{
//META_CONS("[MONSTER] ERROR: origin found twice: %s", input);
LOG_MESSAGE(PLID, "ERROR: origin found twice: %s", input);
return TRUE; // error
LOG_MESSAGE(PLID, "ERROR: invalid origin: %s", input); // print conflictive line
// reset origin to g_vecZero
LOG_MESSAGE(PLID, "ERROR: entity will spawn at 0 0 0");
x = y = z = 0;
}
if (sscanf(&input[7], "%f %f %f", &x, &y, &z) != 3)
{
//META_CONS("[MONSTER] ERROR: invalid origin: %s", input);
LOG_MESSAGE(PLID, "ERROR: invalid origin: %s", input);
return TRUE; // error
}
origin = TRUE;
monster_spawnpoint[monster_spawn_count].origin[0] = x;
monster_spawnpoint[monster_spawn_count].origin[1] = y;
monster_spawnpoint[monster_spawn_count].origin[2] = z;
}
else if (strncmp(input, "delay/", 6) == 0)
else if (strcmp(data[i].key, "delay") == 0)
{
if (delay)
// ToDo: Remove this keyvalue.
// Monsters spawned directly should not respawn.
if (sscanf(data[i].value, "%f", &x) != 1)
{
//META_CONS("[MONSTER] ERROR: delay found twice: %s", input);
LOG_MESSAGE(PLID, "ERROR: delay found twice: %s", input);
return TRUE; // error
LOG_MESSAGE(PLID, "ERROR: invalid delay: %s", input); // print conflictive line
// default to 30 seconds
LOG_MESSAGE(PLID, "ERROR: entity respawn frequency will be set to 30 seconds");
x = 30;
}
if (sscanf(&input[6], "%f", &x) != 1)
{
//META_CONS("[MONSTER] ERROR: invalid delay: %s", input);
LOG_MESSAGE(PLID, "ERROR: invalid delay: %s", input);
return TRUE; // error
}
delay = TRUE;
monster_spawnpoint[monster_spawn_count].delay = x;
}
else if (strncmp(input, "angle/", 6) == 0)
else if (strcmp(data[i].key, "angles") == 0)
{
if (angle)
if (sscanf(data[i].value, "%f %f %f", &x, &y, &z) != 3)
{
//META_CONS("[MONSTER] ERROR: angle found twice: %s", input);
LOG_MESSAGE(PLID, "ERROR: angle found twice: %s", input);
return TRUE; // error
}
if (angle_min || angle_max)
{
//META_CONS("[MONSTER] ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
LOG_MESSAGE(PLID, "ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
return TRUE; // error
}
if (sscanf(&input[6], "%f", &x) != 1)
{
//META_CONS("[MONSTER] ERROR: invalid angle: %s", input);
LOG_MESSAGE(PLID, "ERROR: invalid angle: %s", input);
return TRUE; // error
}
angle = TRUE;
monster_spawnpoint[monster_spawn_count].angle_min = x;
monster_spawnpoint[monster_spawn_count].angle_max = x;
}
else if (strncmp(input, "angle_min/", 10) == 0)
{
if (angle_min)
{
//META_CONS("[MONSTER] ERROR: angle_min found twice: %s", input);
LOG_MESSAGE(PLID, "ERROR: angle_min found twice: %s", input);
return TRUE; // error
}
if (angle)
{
//META_CONS("[MONSTER] ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
LOG_MESSAGE(PLID, "ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
return TRUE; // error
}
if (sscanf(&input[10], "%f", &x) != 1)
{
//META_CONS("[MONSTER] ERROR: invalid angle_min: %s", input);
LOG_MESSAGE(PLID, "ERROR: invalid angle_min: %s", input);
return TRUE; // error
}
angle_min = TRUE;
monster_spawnpoint[monster_spawn_count].angle_min = x;
}
else if (strncmp(input, "angle_max/", 10) == 0)
{
if (angle_max)
{
//META_CONS("[MONSTER] ERROR: angle_max found twice: %s", input);
LOG_MESSAGE(PLID, "ERROR: angle_max found twice: %s", input);
return TRUE; // error
}
if (angle)
{
//META_CONS("[MONSTER] ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
LOG_MESSAGE(PLID, "ERROR: you can't specify angle AND angle_min or angle_max: %s", input);
return TRUE; // error
}
if (sscanf(&input[10], "%f", &x) != 1)
{
//META_CONS("[MONSTER] ERROR: invalid angle_max: %s", input);
LOG_MESSAGE(PLID, "ERROR: invalid angle_max: %s", input);
return TRUE; // error
}
angle_max = TRUE;
monster_spawnpoint[monster_spawn_count].angle_max = x;
}
else if (strncmp(input, "monster/", 8) == 0)
{
int index;
int count = monster_spawnpoint[monster_spawn_count].monster_count;
if (count < MAX_MONSTER_COUNT)
{
for (index=0; monster_types[index].name[0]; index++)
{
if (strcmp(&input[8], monster_types[index].name) == 0)
{
monster_spawnpoint[monster_spawn_count].monster[count] = index;
monster_spawnpoint[monster_spawn_count].monster_count++;
LOG_MESSAGE(PLID, "ERROR: invalid angles: %s", input); // print conflictive line
monster_types[index].need_to_precache = TRUE;
// reset angles to g_vecZero
LOG_MESSAGE(PLID, "ERROR: entity angles will be set to 0 0 0");
x = y = z = 0;
}
monster_spawnpoint[monster_spawn_count].angles[0] = x;
monster_spawnpoint[monster_spawn_count].angles[1] = y;
monster_spawnpoint[monster_spawn_count].angles[2] = z;
}
else if (strcmp(data[i].key, "classname") == 0)
{
int mIndex;
for (mIndex = 0; monster_types[mIndex].name[0]; mIndex++)
{
if (strcmp(data[i].value, monster_types[mIndex].name) == 0)
{
monster_spawnpoint[monster_spawn_count].monster = mIndex;
monster_types[mIndex].need_to_precache = TRUE;
break;
}
}
if (monster_types[index].name[0] == 0)
if (monster_types[mIndex].name[0] == 0)
{
//META_CONS("[MONSTER] ERROR: invalid monster name: %s", input);
LOG_MESSAGE(PLID, "ERROR: invalid monster name: %s", input);
return TRUE;
LOG_MESSAGE(PLID, "ERROR: unknown classname: %s", input); // print conflictive line
LOG_MESSAGE(PLID, "ERROR: nothing will spawn here!");
}
}
monster = TRUE;
}
else
{
//META_CONS("[MONSTER] ERROR: unknown command: %s", input);
LOG_MESSAGE(PLID, "ERROR: unknown command: %s", input);
return TRUE; // error occurred
}
}
// check for all necessary fields here...
if (!origin)
{
//META_CONS("[MONSTER] ERROR: you didn't specify an origin!");
LOG_MESSAGE(PLID, "ERROR: you didn't specify an origin!");
return TRUE;
}
if (angle_min && !angle_max)
{
//META_CONS("[MONSTER] ERROR: you specified angle_min but didn't specify angle_max!");
LOG_MESSAGE(PLID, "ERROR: you specified angle_min but didn't specify angle_max!");
return TRUE;
}
if (angle_max && !angle_min)
{
//META_CONS("[MONSTER] ERROR: you specified angle_max but didn't specify angle_min!");
LOG_MESSAGE(PLID, "ERROR: you specified angle_max but didn't specify angle_min!");
return TRUE;
}
if (!monster)
{
//META_CONS("[MONSTER] ERROR: No monster key found!");
LOG_MESSAGE(PLID, "ERROR: No monster key found!");
return TRUE;
}
if (!delay)
monster_spawnpoint[monster_spawn_count].delay = 30; // 30 second default delay
if (monster_spawnpoint[monster_spawn_count].delay < 1)
monster_spawnpoint[monster_spawn_count].delay = 1; // no negative or zero delay
if (!angle && !angle_min && !angle_max) // no angle specified, use 0-359 as default
{
monster_spawnpoint[monster_spawn_count].angle_min = 0;
monster_spawnpoint[monster_spawn_count].angle_max = 359;
}
if (monster_spawnpoint[monster_spawn_count].angle_min < 0)
monster_spawnpoint[monster_spawn_count].angle_min = 0; // no negative angles
if (monster_spawnpoint[monster_spawn_count].angle_max > 359)
monster_spawnpoint[monster_spawn_count].angle_max = 359; // no angle > 359 degrees
monster_spawnpoint[monster_spawn_count].respawn_time = gpGlobals->time + RANDOM_FLOAT(10.0, 20.0);
// Init monster
monster_spawnpoint[monster_spawn_count].respawn_time = gpGlobals->time + 0.1; // spawn (nearly) right away
monster_spawnpoint[monster_spawn_count].need_to_respawn = TRUE;
// Log on? Print all the entities that were added
if (dllapi_log->value)
{
char name_monsters[256];
LOG_MESSAGE(PLID, "Added monster spawn at: %7.2f %7.2f %7.2f",
monster_spawnpoint[monster_spawn_count].origin.x,
monster_spawnpoint[monster_spawn_count].origin.y,
monster_spawnpoint[monster_spawn_count].origin.z);
LOG_MESSAGE(PLID, " with delay = %7.2f, angle_min = %7.2f, angle_max = %7.2f",
monster_spawnpoint[monster_spawn_count].delay,
monster_spawnpoint[monster_spawn_count].angle_min,
monster_spawnpoint[monster_spawn_count].angle_max);
name_monsters[0] = 0;
for (int i = 0; i < monster_spawnpoint[monster_spawn_count].monster_count; i++)
{
strcat(name_monsters, monster_types[monster_spawnpoint[monster_spawn_count].monster[i]].name);
strcat(name_monsters, " ");
}
LOG_MESSAGE(PLID, " monsters = %s", name_monsters);
// Classname only, or we will flood the server!
// No, I'm not making this idiotproof. Classname should be the last KVD entry on an entity!
LOG_CONSOLE(PLID, "[DEBUG] Added entity: %s", data[kvd_index-1].value);
}
monster_spawn_count++;
free( data );
break;
}
// Bruteforce to remove quotes
char parse[66] = {0};
int skip = 0;
for (int i = 0; i < strlen(input); i++)
{
if (input[i] == '"')
{
skip++;
continue;
}
parse[i-skip] = input[i];
}
parse[strlen(parse)] = '\0';
// Copy all keyvalues to the tempvar
// Key
char *copy = strtok(parse, " ");
strcpy(data[kvd_index].key, copy);
// Value
copy = strtok(NULL, " ");
strcpy(data[kvd_index].value, "");
while (copy != NULL)
{
// If the value is a vector, append necessary whitespaces
strcat(data[kvd_index].value, copy);
copy = strtok(NULL, " ");
if (copy != NULL)
strcat(data[kvd_index].value, " ");
}
// Next KVD
kvd_index++;
}
}
}
}
return FALSE;
}
bool process_monster_cfg(void)
void process_monster_cfg(void)
{
char game_dir[256];
char filename[256];
@@ -337,15 +245,15 @@ bool process_monster_cfg(void)
//META_CONS("[MONSTER] ERROR: Could not open \"%s\"!", filename);
LOG_MESSAGE(PLID, "ERROR: Could not open \"%s\" file!", filename);
return TRUE; // return bad status
return;
}
status = scan_monster_cfg(fp);
scan_monster_cfg(fp);
fclose(fp);
}
return status;
return;
}

8
src/dlls/monster_plugin.h
View File

@@ -28,15 +28,11 @@ typedef struct
extern monster_t monsters[MAX_MONSTER_ENTS];
#define MAX_MONSTER_COUNT 20
typedef struct {
Vector origin;
float angle_min, angle_max;
Vector angles;
float delay;
unsigned char monster[MAX_MONSTER_COUNT];
int monster_count;
unsigned char monster;
float respawn_time;
bool need_to_respawn;
} monster_spawnpoint_t;