449 lines
16 KiB
Scheme
Executable File
449 lines
16 KiB
Scheme
Executable File
// *****************************************************************************************
|
|
// *****************************************************************************************
|
|
//
|
|
// FILE NAME : RC_Rent_A_Rucus.sch
|
|
// AUTHOR : Aaron Gandaa
|
|
// DESCRIPTION : Creates a Simple Rucus with 2 teams
|
|
//
|
|
// *****************************************************************************************
|
|
// *****************************************************************************************
|
|
|
|
//----------------------
|
|
// INCLUDES
|
|
//----------------------
|
|
USING "rage_builtins.sch"
|
|
USING "globals.sch"
|
|
USING "RC_Helper_Functions.sch"
|
|
USING "rgeneral_include.sch"
|
|
|
|
//----------------------
|
|
// ENUM
|
|
//----------------------
|
|
ENUM FIGHT_SIDE
|
|
SIDE_FRIENDLY,
|
|
SIDE_FOE
|
|
ENDENUM
|
|
|
|
//----------------------
|
|
// CONSTANTS
|
|
//----------------------
|
|
CONST_INT MAX_RUCUS_PEDS 10
|
|
|
|
//----------------------
|
|
// STRUCTS
|
|
//----------------------
|
|
STRUCT FIGHT_PED
|
|
PED_INDEX pedID
|
|
BLIP_INDEX blipID
|
|
BOOL bIsFriendly = FALSE
|
|
INT iRecheckTimer = 0
|
|
ENDSTRUCT
|
|
|
|
STRUCT FIGHT_GROUP
|
|
BOOL bIsFriendly = FALSE
|
|
MODEL_NAMES pedModel
|
|
REL_GROUP_HASH relGroup
|
|
INT iAliveCounter
|
|
INT iCreateCounter
|
|
|
|
WEAPON_TYPE weapon[2]
|
|
|
|
VECTOR vCenter
|
|
FLOAT fRadius
|
|
|
|
FIGHT_PED attackPed[MAX_RUCUS_PEDS]
|
|
COMBAT_PARAMETERS combatParam
|
|
BOOL bUseCombatParams = FALSE
|
|
INT iMaxActivePeds
|
|
ENDSTRUCT
|
|
|
|
//----------------------
|
|
// VARIABLES
|
|
//----------------------
|
|
FIGHT_GROUP fightGroup[2]
|
|
ANGLED_AREA fightNoSpawnArea[8]
|
|
INT iFightSpawnAreas = 0
|
|
|
|
//----------------------
|
|
// INTERNAL FUNCTIONS
|
|
//----------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: GENERATE_PED_SPAWN_POINT_IN_DISC()
|
|
// PURPOSE: CALCULATES A SPAWN POINT GIVEN CENTER AND RADIUS
|
|
//------------------------------------------------------------------------------
|
|
FUNC BOOL GENERATE_PED_SPAWN_POINT_IN_DISC(VECTOR center, FLOAT radius, VECTOR &out)
|
|
FLOAT z
|
|
INT i
|
|
|
|
VECTOR pos = center
|
|
pos.x += GET_RANDOM_FLOAT_IN_RANGE(-radius, radius)
|
|
pos.y += GET_RANDOM_FLOAT_IN_RANGE(-radius, radius)
|
|
out = pos
|
|
|
|
/*
|
|
IF NOT GET_SAFE_COORD_FOR_PED(pos, FALSE, out)
|
|
PRINTSTRING(" COULD NOT GENERATE SAFE POINT\n")
|
|
RETURN FALSE
|
|
ENDIF
|
|
*/
|
|
|
|
// do get ground pos in point 10 meters above this one
|
|
out.z += 15
|
|
IF NOT GET_GROUND_Z_FOR_3D_COORD(out, z)
|
|
//PRINTSTRING(" COULD NOT GENERATE GROUND POINT\n")
|
|
RETURN FALSE
|
|
ENDIF
|
|
out.z = z
|
|
|
|
// check point isn't in a no spawn area
|
|
IF (iFightSpawnAreas > 0)
|
|
REPEAT iFightSpawnAreas i
|
|
IF IS_POINT_IN_ANGLED_AREA(out, fightNoSpawnArea[i].vPosition[0], fightNoSpawnArea[i].vPosition[1], fightNoSpawnArea[i].fWidth)
|
|
RETURN FALSE
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDIF
|
|
|
|
IF IS_SPHERE_VISIBLE(out, 0.5)
|
|
//IF NOT WOULD_ENTITY_BE_OCCLUDED(GET_PLAYER_MODEL(), out)
|
|
RETURN FALSE
|
|
//ENDIF
|
|
ENDIF
|
|
|
|
//PRINTSTRING(" COULD NOT GENERATE POINT\n")
|
|
RETURN TRUE
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: REPEAT_GENERATE_PED_SPAWN_POINT_IN_DISC()
|
|
// PURPOSE: TRIES MULTIPLE TIMES TO GENERATE A SPAWN POINT
|
|
//------------------------------------------------------------------------------
|
|
FUNC BOOL REPEAT_GENERATE_PED_SPAWN_POINT_IN_DISC(VECTOR center, FLOAT radius, VECTOR &out, INT tries = 5)
|
|
INT i
|
|
|
|
REPEAT tries i
|
|
IF GENERATE_PED_SPAWN_POINT_IN_DISC(center, radius, out)
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
//PRINTSTRING(" COULD NOT GENERATE REPEAT POINT\n")
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: GET_FREE_FIGHT_PED_INDEX()
|
|
// PURPOSE: GETS INDEX TO FREE PED IN A FIGHT PED ARRAY
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
FUNC BOOL GET_FREE_FIGHT_PED_INDEX(FIGHT_PED &array[], INT &out)
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(array) i
|
|
IF NOT DOES_ENTITY_EXIST(array[i].pedID)
|
|
out = i
|
|
RETURN TRUE
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
//PRINTSTRING(" COULD NOT GET FREE PED\n")
|
|
RETURN FALSE
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: UPDATE_ALIVE_FIGHT_PED_COUNTER()
|
|
// PURPOSE: UPDATES NUMBER OF ALIVE PEDS IN A FIGHT PED ARRAY
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
FUNC INT UPDATE_ALIVE_FIGHT_PED_COUNTER(FIGHT_GROUP &fg)
|
|
INT i
|
|
|
|
fg.iAliveCounter = 0
|
|
|
|
REPEAT COUNT_OF(fg.attackPed) i
|
|
IF IS_ENTITY_ALIVE(fg.attackPed[i].pedID)
|
|
fg.iAliveCounter ++
|
|
|
|
IF GET_SCRIPT_TASK_STATUS(fg.attackPed[i].pedID,SCRIPT_TASK_COMBAT_HATED_TARGETS_AROUND_PED) <> PERFORMING_TASK
|
|
REGISTER_HATED_TARGETS_AROUND_PED(fg.attackPed[i].pedID, 200.0)
|
|
fg.attackPed[i].iRecheckTimer = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(30000, 60000)
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(fg.attackPed[i].pedID, 200.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
RETURN fg.iAliveCounter
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: SETUP_FIGHT_GROUP()
|
|
// PURPOSE: SETS UP A FIGHT TO GROUP TO CONTAIN A NUMBER OF PEDS
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
PROC SETUP_FIGHT_GROUP(FIGHT_GROUP &fg, INT count, BOOL neverdie = FALSE)
|
|
INT i
|
|
INT ind
|
|
VECTOR out
|
|
FLOAT rand
|
|
|
|
IF (fg.fRadius < 5.0)
|
|
fg.fRadius = 5.0
|
|
ENDIF
|
|
|
|
REPEAT count i
|
|
IF NOT GET_FREE_FIGHT_PED_INDEX(fg.attackPed, ind)
|
|
EXIT
|
|
ENDIF
|
|
|
|
IF REPEAT_GENERATE_PED_SPAWN_POINT_IN_DISC(fg.vCenter, GET_RANDOM_FLOAT_IN_RANGE(fg.fRadius - 5.0, fg.fRadius + 5.0), out)
|
|
fg.attackPed[ind].pedID = CREATE_PED(PEDTYPE_MISSION, fg.pedModel, out)
|
|
|
|
IF IS_ENTITY_ALIVE(fg.attackPed[ind].pedID)
|
|
fg.attackPed[ind].blipID = CREATE_PED_BLIP(fg.attackPed[ind].pedID, TRUE, fg.bIsFriendly)
|
|
fg.attackPed[ind].bIsFriendly = fg.bIsFriendly
|
|
|
|
SET_PED_RELATIONSHIP_GROUP_HASH(fg.attackPed[ind].pedID, fg.relGroup)
|
|
SET_PED_RANDOM_COMPONENT_VARIATION(fg.attackPed[ind].pedID)
|
|
SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(fg.attackPed[ind].pedID, FALSE)
|
|
SET_PED_INFINITE_AMMO(fg.attackPed[ind].pedID, TRUE)
|
|
|
|
SET_PED_COMBAT_ATTRIBUTES(fg.attackPed[ind].pedID, CA_USE_COVER, TRUE)
|
|
SET_PED_FLEE_ATTRIBUTES(fg.attackPed[ind].pedID, FA_USE_COVER, TRUE)
|
|
|
|
SET_PED_INFINITE_AMMO(fg.attackPed[ind].pedID, TRUE)
|
|
|
|
IF NOT (fg.bIsFriendly)
|
|
SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(fg.attackPed[ind].pedID, player_ped_id(), <<0, 0, 0>>, 60.0, TRUE)
|
|
ENDIF
|
|
|
|
// setup combat movement
|
|
IF GET_RANDOM_FLOAT_IN_RANGE() <= 0.5
|
|
SET_PED_SPHERE_DEFENSIVE_AREA(fg.attackPed[ind].pedID, fg.vCenter, fg.fRadius)
|
|
SET_PED_COMBAT_MOVEMENT(fg.attackPed[ind].pedID, CM_DEFENSIVE )
|
|
ELSE
|
|
SET_PED_COMBAT_MOVEMENT(fg.attackPed[ind].pedID, CM_WILLADVANCE )
|
|
ENDIF
|
|
|
|
// setup combat range
|
|
rand = GET_RANDOM_FLOAT_IN_RANGE()
|
|
IF (rand < 0.33)
|
|
SET_PED_COMBAT_RANGE(fg.attackPed[ind].pedID, CR_NEAR)
|
|
ELIF (rand < 0.66)
|
|
SET_PED_COMBAT_RANGE(fg.attackPed[ind].pedID, CR_MEDIUM)
|
|
ELSE
|
|
SET_PED_COMBAT_RANGE(fg.attackPed[ind].pedID, CR_FAR)
|
|
ENDIF
|
|
|
|
IF (fg.bIsFriendly)
|
|
SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(fg.attackPed[ind].pedID, PLAYER_PED_ID(), <<0, 0, 0>>, 30.0)
|
|
ENDIF
|
|
|
|
IF GET_RANDOM_FLOAT_IN_RANGE() <= 0.5
|
|
GIVE_WEAPON_TO_PED(fg.attackPed[ind].pedID, fg.weapon[0], INFINITE_AMMO, TRUE, TRUE)
|
|
ELSE
|
|
GIVE_WEAPON_TO_PED(fg.attackPed[ind].pedID, fg.weapon[1], INFINITE_AMMO, TRUE, TRUE)
|
|
ENDIF
|
|
|
|
IF (neverdie)
|
|
SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(fg.attackPed[ind].pedID, TRUE)
|
|
ENDIF
|
|
|
|
IF (fg.bUseCombatParams)
|
|
APPLY_COMBAT_PARAMETERS_TO_PED(fg.attackPed[ind].pedID, fg.combatParam)
|
|
ENDIF
|
|
|
|
REGISTER_HATED_TARGETS_AROUND_PED(fg.attackPed[ind].pedID, 200.0)
|
|
fg.attackPed[ind].iRecheckTimer = GET_GAME_TIMER() + GET_RANDOM_INT_IN_RANGE(30000, 60000)
|
|
fg.iCreateCounter --
|
|
TASK_COMBAT_HATED_TARGETS_AROUND_PED(fg.attackPed[ind].pedID, 200.0)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: INIT_FIGHT_GROUP()
|
|
// PURPOSE: THIS INITIALIZE A FIGHT TO GROUP TO CONTAIN A NUMBER OF PEDS
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
PROC INIT_FIGHT_GROUP(FIGHT_GROUP &fg, REL_GROUP_HASH groupHash, VECTOR center, FLOAT radius, MODEL_NAMES mdl, INT iCnt, BOOL friendly = FALSE, WEAPON_TYPE wpn1 = WEAPONTYPE_PISTOL, WEAPON_TYPE wpn2 = WEAPONTYPE_PISTOL, BOOL bUseCombatParam = FALSE)
|
|
|
|
SECURE_REQUEST_AND_LOAD_MODEL(mdl)
|
|
fg.relGroup = groupHash
|
|
fg.iCreateCounter = iCnt
|
|
fg.pedModel = mdl
|
|
fg.vCenter = center
|
|
fg.fRadius = radius
|
|
fg.weapon[0] = wpn1
|
|
fg.weapon[1] = wpn2
|
|
fg.bIsFriendly = friendly
|
|
fg.iMaxActivePeds = iCnt
|
|
fg.bUseCombatParams = bUseCombatParam
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: UPDATE_FIGHT_GROUP()
|
|
// PURPOSE: THIS UPDATES THE FIGHT GROUP AND MAINTAINS COUNTER
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
PROC UPDATE_FIGHT_GROUP(FIGHT_GROUP &fg)
|
|
INT i
|
|
INT ac
|
|
REPEAT COUNT_OF(fg.attackPed) i
|
|
IF DOES_ENTITY_EXIST(fg.attackPed[i].pedID)
|
|
IF NOT IS_ENTITY_ALIVE(fg.attackPed[i].pedID)
|
|
SAFE_REMOVE_BLIP(fg.attackPed[i].blipID)
|
|
SAFE_RELEASE_PED(fg.attackPed[i].pedID)
|
|
ENDIF
|
|
ENDIF
|
|
ENDREPEAT
|
|
|
|
ac = UPDATE_ALIVE_FIGHT_PED_COUNTER(fg)
|
|
IF (fg.iCreateCounter > 0) AND (ac < fg.iMaxActivePeds)
|
|
SETUP_FIGHT_GROUP(fg, 1)
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: CLEANUP_FIGHT_GROUP()
|
|
// PURPOSE: THIS CLEANSUP THE FIGHT GROUP AND MAINTAINS COUNTER
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
PROC CLEANUP_FIGHT_GROUP(FIGHT_GROUP &fg)
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(fg.attackPed) i
|
|
SAFE_REMOVE_BLIP(fg.attackPed[i].blipID)
|
|
SAFE_RELEASE_PED(fg.attackPed[i].pedID)
|
|
ENDREPEAT
|
|
|
|
IF (fg.pedModel <> DUMMY_MODEL_FOR_SCRIPT)
|
|
SET_MODEL_AS_NO_LONGER_NEEDED(fg.pedModel)
|
|
fg.pedModel = DUMMY_MODEL_FOR_SCRIPT
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: CLEANUP_FIGHT_GROUP()
|
|
// PURPOSE: THIS CLEANSUP THE FIGHT GROUP AND MAINTAINS COUNTER
|
|
// NOTES: USED INTERNALLY
|
|
//------------------------------------------------------------------------------
|
|
PROC DELETE_FIGHT_GROUP(FIGHT_GROUP &fg)
|
|
INT i
|
|
|
|
REPEAT COUNT_OF(fg.attackPed) i
|
|
SAFE_REMOVE_BLIP(fg.attackPed[i].blipID)
|
|
SAFE_DELETE_PED(fg.attackPed[i].pedID)
|
|
ENDREPEAT
|
|
ENDPROC
|
|
|
|
//----------------------
|
|
// EXTERNAL FUNCTIONS
|
|
//----------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: ADD_FIGHT_NOSPAWN_AREA()
|
|
// PURPOSE: ADD AN ANGLED AREA IN WHICH PEOPLE CAN'T SPAWN IN
|
|
//------------------------------------------------------------------------------
|
|
PROC ADD_FIGHT_NOSPAWN_AREA(VECTOR p1, VECTOR p2, FLOAT w)
|
|
IF (iFightSpawnAreas >= COUNT_OF(fightNoSpawnArea))
|
|
SCRIPT_ASSERT("YOU'VE USED MORE THAN MAX AMOUNT OF NO SPAWN AREAS - GET AARON TO INCREASE THE AMOUNT OR USE LESS!")
|
|
ENDIF
|
|
|
|
fightNoSpawnArea[iFightSpawnAreas].vPosition[0] = p1
|
|
fightNoSpawnArea[iFightSpawnAreas].vPosition[1] = p2
|
|
fightNoSpawnArea[iFightSpawnAreas].fWidth = w
|
|
iFightSpawnAreas ++
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: SET_SIDE_MAX_ACTIVE_PEDS()
|
|
// PURPOSE: SETS THE MAX NUMBER OF PEDS ACTIVE IN A SIDE
|
|
//------------------------------------------------------------------------------
|
|
PROC SET_SIDE_MAX_ACTIVE_PEDS(FIGHT_SIDE side, INT i)
|
|
fightGroup[ENUM_TO_INT(side)].iMaxActivePeds = i
|
|
ENDPROC
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: SET_SIDE_WEAPONS()
|
|
// PURPOSE: SETS WEAPONS FOR A SIDE
|
|
//------------------------------------------------------------------------------
|
|
PROC SET_SIDE_WEAPONS(FIGHT_SIDE side, WEAPON_TYPE wpn1, WEAPON_TYPE wpn2 = WEAPONTYPE_INVALID)
|
|
fightGroup[ENUM_TO_INT(side)].weapon[0] = wpn1
|
|
IF NOT (wpn2 <> WEAPONTYPE_INVALID)
|
|
fightGroup[ENUM_TO_INT(side)].weapon[0] = wpn2
|
|
ENDIF
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: GET_SIDE_ALIVE_COUNT()
|
|
// PURPOSE: RETURNS HOW MANY ARE LEFT ON A SIDE
|
|
//------------------------------------------------------------------------------
|
|
FUNC INT GET_SIDE_ALIVE_COUNT(FIGHT_SIDE side)
|
|
RETURN fightGroup[ENUM_TO_INT(side)].iAliveCounter
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: GET_GOOD_GROUP_ALIVE_COUNT()
|
|
// PURPOSE: RETURNS HOW MANY ARE LEFT IN GOOD GROUP
|
|
//------------------------------------------------------------------------------
|
|
FUNC INT GET_GOOD_GROUP_ALIVE_COUNT()
|
|
RETURN fightGroup[0].iAliveCounter
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: GET_EVIL_GROUP_ALIVE_COUNT()
|
|
// PURPOSE: RETURNS HOW MANY ARE LEFT IN EVIL GROUP
|
|
//------------------------------------------------------------------------------
|
|
FUNC INT GET_EVIL_GROUP_ALIVE_COUNT()
|
|
RETURN fightGroup[1].iAliveCounter
|
|
ENDFUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: INIT_GOOD_FIGHT_GROUP()
|
|
// PURPOSE: SETS UPS GOOD FIGHT GROUP
|
|
// NOTES: ONLY CALL THIS ONCE
|
|
//------------------------------------------------------------------------------
|
|
PROC INIT_GOOD_FIGHT_GROUP(REL_GROUP_HASH groupHash, VECTOR center, FLOAT radius, MODEL_NAMES mdl, INT iCnt, BOOL friendly = FALSE, WEAPON_TYPE wpn1 = WEAPONTYPE_PISTOL, WEAPON_TYPE wpn2 = WEAPONTYPE_PISTOL, BOOL bUseCombatParam = FALSE)
|
|
INIT_FIGHT_GROUP(fightGroup[0], groupHash, center, radius, mdl, iCnt, friendly, wpn1, wpn2, bUseCombatParam)
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: INIT_EVIL_FIGHT_GROUP()
|
|
// PURPOSE: SETS UPS EVIL FIGHT GROUP
|
|
// NOTES: ONLY CALL THIS ONCE
|
|
//------------------------------------------------------------------------------
|
|
PROC INIT_EVIL_FIGHT_GROUP(REL_GROUP_HASH groupHash, VECTOR center, FLOAT radius, MODEL_NAMES mdl, INT iCnt, BOOL friendly = FALSE, WEAPON_TYPE wpn1 = WEAPONTYPE_PISTOL, WEAPON_TYPE wpn2 = WEAPONTYPE_PISTOL, BOOL bUseCombatParam = FALSE)
|
|
INIT_FIGHT_GROUP(fightGroup[1], groupHash, center, radius, mdl, iCnt, friendly, wpn1, wpn2, bUseCombatParam)
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: UPDATE_FIGHT_GROUPS()
|
|
// PURPOSE: UPDATES FIGHT GROUPS
|
|
//------------------------------------------------------------------------------
|
|
PROC UPDATE_FIGHT_GROUPS()
|
|
UPDATE_FIGHT_GROUP(fightGroup[0])
|
|
UPDATE_FIGHT_GROUP(fightGroup[1])
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: CLEANUP_FIGHT_GROUPS()
|
|
// PURPOSE: UPDATES FIGHT GROUPS
|
|
//------------------------------------------------------------------------------
|
|
PROC CLEANUP_FIGHT_GROUPS()
|
|
CLEANUP_FIGHT_GROUP(fightGroup[0])
|
|
CLEANUP_FIGHT_GROUP(fightGroup[1])
|
|
ENDPROC
|
|
|
|
//------------------------------------------------------------------------------
|
|
// FUNCTION: DELETE_FIGHT_GROUPS()
|
|
// PURPOSE: DELETES FIGHT GROUPS
|
|
//------------------------------------------------------------------------------
|
|
PROC DELETE_FIGHT_GROUPS()
|
|
DELETE_FIGHT_GROUP(fightGroup[0])
|
|
DELETE_FIGHT_GROUP(fightGroup[1])
|
|
ENDPROC
|
|
|