/**
* @brief unittest to check well formed empty list
*/
TEST_F(ParserTest, ParserListOkEmpty)
{
const char* string = " ( \n ) ()";
const char* cursor = string;
linkedList_t* list;
ASSERT_TRUE(Com_ParseList(&cursor, &list)) << "List parsing failed";
ASSERT_EQ(LIST_Count(list), 0);
ASSERT_TRUE(Com_ParseList(&cursor, &list)) << "List parsing failed";
ASSERT_EQ(LIST_Count(list), 0);
}
/**
* @brief Update the building-list.
* @sa B_BuildingInit_f
*/
static void B_BuildingInit (base_t* base)
{
int i;
linkedList_t *buildingList = NULL;
/* maybe someone call this command before the bases are parsed?? */
if (!base)
return;
for (i = 0; i < ccs.numBuildingTemplates; i++) {
building_t *tpl = &ccs.buildingTemplates[i];
/* make an entry in list for this building */
if (tpl->mapPart) {
const int numSameBuildings = B_GetNumberOfBuildingsInBaseByTemplate(base, tpl);
if (tpl->maxCount >= 0 && tpl->maxCount <= numSameBuildings)
continue;
/* skip if limit of BASE_SIZE*BASE_SIZE exceeded */
if (numSameBuildings >= BASE_SIZE * BASE_SIZE)
continue;
/* if the building is researched add it to the list */
if (RS_IsResearched_ptr(tpl->tech))
B_BuildingAddToList(&buildingList, tpl);
}
}
if (base->buildingCurrent)
B_DrawBuilding(base->buildingCurrent);
else
cgi->UI_ExecuteConfunc("mn_buildings_reset");
buildingNumber = LIST_Count(buildingList);
cgi->UI_RegisterLinkedListText(TEXT_BUILDINGS, buildingList);
}
static void GAME_UpdateActiveTeamList (void)
{
const int teamSize = LIST_Count(chrDisplayList);
OBJZERO(characterActive);
for (int i = 0; i < teamSize; i++)
characterActive[i] = true;
}
/**
* @brief Handles the list of constructable buildings.
* @param[in] buildingList list of buildings to upate
* @param[in] building Add this building to the construction list
* @note Called everytime a building was constructed and thus maybe other buildings
* get available. The content is updated everytime B_BuildingInit is called
* (i.e everytime the buildings-list is displayed/updated)
*/
static void B_BuildingAddToList (linkedList_t **buildingList, building_t *building)
{
int count;
assert(building);
assert(building->name);
count = LIST_Count(*buildingList);
LIST_AddPointer(buildingList, _(building->name));
buildingConstructionList[count] = building->tpl;
}
void UI_ExecuteEventActionsEx (uiNode_t* source, const uiAction_t* firstAction, linkedList_t *params)
{
uiCallContext_t context;
OBJZERO(context);
context.source = source;
context.useCmdParam = false;
context.params = params;
context.paramNumber = LIST_Count(params);
UI_ExecuteActions(firstAction, &context);
}
static void testLinkedList (void)
{
linkedList_t *list = NULL;
const char* data = "SomeDataForTheLinkedList";
const size_t length = strlen(data);
linkedList_t *entry;
const linkedList_t *entry2;
const char *returnedData;
entry = LIST_Add(&list, (const byte*)data, length);
CU_ASSERT_EQUAL(LIST_Count(list), 1);
CU_ASSERT_TRUE(entry != NULL);
returnedData = (const char *)LIST_GetByIdx(list, 0);
CU_ASSERT_TRUE(returnedData != NULL);
entry2 = LIST_ContainsString(list, returnedData);
CU_ASSERT_TRUE(entry2 != NULL);
CU_ASSERT_EQUAL((const void*)entry2->data, (const void*)returnedData);
CU_ASSERT_STRING_EQUAL(entry2->data, returnedData);
LIST_RemoveEntry(&list, entry);
CU_ASSERT_EQUAL(LIST_Count(list), 0);
}
int Server_LoadWorld_FromArguments(struct Server * server, int argc, char* argv[])
{
for(int i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-world") == 0)
{
Server_LoadWorld(server, argv[i + 1]);
}
}
printf("Loaded %d world(s)\n", LIST_Count(server->worlds));
return 1;
}
/**
* @brief unittest to check well formed list
*/
TEST_F(ParserTest, ParserListOk)
{
const char* string = " ( aaa \n \"bbb\" \t ccc \n \n ) ";
const char* cursor = string;
linkedList_t* list;
ASSERT_TRUE(Com_ParseList(&cursor, &list)) << "List parsing failed";
ASSERT_EQ(LIST_Count(list), 3);
ASSERT_STREQ(static_cast<const char*>(list->data), "aaa");
ASSERT_STREQ(static_cast<const char*>(list->next->data), "bbb");
ASSERT_STREQ(static_cast<const char*>(list->next->next->data), "ccc");
LIST_Delete(&list);
}
/**
* @brief Return a list of hired employees in the given base of a given type
* @param[in] base Which base the employee should be searched in. If NULL is given employees in all bases will be listed.
* @param[in] type Which employee type to search for.
* @param[out] hiredEmployees Linked list of hired employees in the base.
* @return Number of hired employees in the base that are currently not on a transfer. Or @c -1 in case of an error.
*/
int E_GetHiredEmployees (const base_t* const base, employeeType_t type, linkedList_t **hiredEmployees)
{
employee_t *employee;
if (type >= MAX_EMPL) {
Com_Printf("E_GetHiredEmployees: Unknown EmployeeType: %i\n", type);
*hiredEmployees = NULL;
return -1;
}
LIST_Delete(hiredEmployees);
E_Foreach(type, employee) {
if (!E_IsHired(employee))
continue;
if (!employee->transfer && (!base || E_IsInBase(employee, base))) {
LIST_AddPointer(hiredEmployees, employee);
}
}
if (hiredEmployees == NULL)
return 0;
return LIST_Count(*hiredEmployees);
}
/**
* @brief Get number of installations
*/
int INS_GetCount (void)
{
return LIST_Count(ccs.installations);
}
/**
* @brief Start Base Attack.
* @note Base attack mission -- Stage 2
*/
void CP_BaseAttackStartMission (mission_t *mission)
{
base_t *base = mission->data.base;
linkedList_t *hiredSoldiersInBase = NULL;
employee_t *employee;
assert(base);
mission->stage = STAGE_BASE_ATTACK;
CP_MissionDisableTimeLimit(mission);
if (mission->ufo) {
/* ufo becomes invisible on geoscape, but don't remove it from ufo global array (may reappear)*/
CP_UFORemoveFromGeoscape(mission, qfalse);
}
/* we always need at least one command centre in the base - because the
* phalanx soldiers have their starting positions here.
* There should also always be an entrance - the aliens start there
* but we don't need to check that as entrance can't be destroyed */
if (!B_GetNumberOfBuildingsInBaseByBuildingType(base, B_COMMAND)) {
/** @todo handle command centre properly */
Com_DPrintf(DEBUG_CLIENT, "CP_BaseAttackStartMission: Base '%s' has no Command Center: it can't defend itself. Destroy base.\n", base->name);
CP_BaseAttackMissionDestroyBase(mission);
return;
}
base->baseStatus = BASE_UNDER_ATTACK;
ccs.campaignStats.basesAttacked++;
#if 0
/** @todo implement onattack: add it to basemanagement.ufo and implement functions */
if (base->onAttack[0] != '\0')
/* execute next frame */
Cbuf_AddText(va("%s %i", base->onAttack, base->id));
#endif
MAP_SelectMission(mission);
mission->active = qtrue;
ccs.mapAction = MA_BASEATTACK;
Com_DPrintf(DEBUG_CLIENT, "Base attack: %s at %.0f:%.0f\n", mission->id, mission->pos[0], mission->pos[1]);
/** @todo EMPL_ROBOT */
E_GetHiredEmployees(base, EMPL_SOLDIER, &hiredSoldiersInBase);
/* Fill the fake aircraft */
OBJZERO(baseAttackFakeAircraft);
baseAttackFakeAircraft.homebase = base;
/* needed for transfer of alien corpses */
VectorCopy(base->pos, baseAttackFakeAircraft.pos);
#if 0
/** @todo active this once more than 8 soldiers are working */
/* needed to spawn soldiers on map */
baseAttackFakeAircraft.maxTeamSize = LIST_Count(hiredSoldiersInBase);
#else
baseAttackFakeAircraft.maxTeamSize = MAX_ACTIVETEAM;
#endif
if (!hiredSoldiersInBase) {
Com_DPrintf(DEBUG_CLIENT, "CP_BaseAttackStartMission: Base '%s' has no soldiers: it can't defend itself. Destroy base.\n", base->name);
CP_BaseAttackMissionDestroyBase(mission);
return;
}
LIST_Foreach(hiredSoldiersInBase, employee_t, employee) {
if (E_IsAwayFromBase(employee))
continue;
AIR_AddToAircraftTeam(&baseAttackFakeAircraft, employee);
}
if (AIR_GetTeamSize(&baseAttackFakeAircraft) == 0) {
Com_DPrintf(DEBUG_CLIENT, "CP_BaseAttackStartMission: Base '%s' has no soldiers at home: it can't defend itself. Destroy base.\n", base->name);
CP_BaseAttackMissionDestroyBase(mission);
return;
}
#if 0
/** @todo active this once more than 8 soldiers are working */
/* all soldiers in the base should get used */
baseAttackFakeAircraft.maxTeamSize = AIR_GetTeamSize(&baseAttackFakeAircraft);
#endif
LIST_Delete(&hiredSoldiersInBase);
base->aircraftCurrent = &baseAttackFakeAircraft;
MAP_SetMissionAircraft(&baseAttackFakeAircraft);
/** @todo remove me - this is not needed because we are using the base->aircraftCurrent
* pointer for resolving the aircraft - only CL_GameAutoGo needs this */
MAP_SetInterceptorAircraft(&baseAttackFakeAircraft); /* needed for updating soldier stats sa CL_UpdateCharacterStats*/
B_SetCurrentSelectedBase(base); /* needed for equipment menu */
Com_sprintf(popupText, sizeof(popupText), _("Base '%s' is under attack! What to do ?"), base->name);
UI_RegisterText(TEXT_POPUP, popupText);
CL_GameTimeStop();
UI_PushWindow("popup_baseattack", NULL, NULL);
}
/**
* @brief Returns number of employees of a type
* @param[in] type Employeetype to check
*/
int E_CountByType (employeeType_t type)
{
return LIST_Count(ccs.employees[type]);
}
