Global AB_LoadXML (xmlNode_t *parent)

this is for old saves now only

Global AB_LoadXML (xmlNode_t *parent)

this is for old saves now only

Global abstractScrollbarExtraData_t

think about switching to percent when its possible (lowPosition, hightPosition)

think about adding a "direction" property and merging v and h scrollbar

Global abstractScrollbarExtraData_t

think about switching to percent when its possible (lowPosition, hightPosition)

think about adding a "direction" property and merging v and h scrollbar

Global AC_LoadXML (xmlNode_t *parent)

Remove: Fallback for compatibility

Global actorHands_t

remove this and use the container id - not every unit must have two hands

Global AddLump (qFILE *bspfile, dBspHeader_t *header, int lumpnum, void *data, int len)

Implement this without the ftell stuff - don't write the bsp file twice

Global AI_ActorThink (Player &player, Actor *actor)

If possible targets that can shoot back (check their inventory for weapons, not for ammo) are close, go into reaction fire mode, too

Global AI_CheckUsingDoor (const Edict *ent, const Edict *door)

Finish implementation

Global AI_FighterCalcActionScore (Actor *actor, const pos3_t to, AiAction *aia)

fill z_align values

optimize this

do this decently, only penalizing the visible part of walk and penalizing much more for reaction shooters around; now it may remove some tactical options from aliens, e.g. they may now choose only the closer doors; however it's still better than going three times around soldier and only then firing at him

also add bonus for fleeing from reaction fire and a huge malus if more than 1 move under reaction

Global AI_FighterCheckShoot (const Actor *actor, const Edict *check, const fireDef_t *fd, float dist)

Check whether radius and power of fd are to to big for dist

Check whether the alien will die when shooting

Global AI_FindBestFiredef (AiAction *aia, Actor *actor, Actor *check, const Item *item, shoot_types_t shootType, int tu, float *maxDmg, int *bestTime, const fireDef_t *fdArray)

timed firedefs that bounce around should not be thrown/shoot about the whole distance

Global AI_NUMERICSERV

Move this into the configure script AI_ADDRCONFIG, AI_ALL, and AI_V4MAPPED are available since glibc 2.3.3. AI_NUMERICSERV is available since glibc 2.3.4.

Global AI_SearchDestroyableObject (const Actor *actor, const fireDef_t *fd)

This feature causes the 'aliens shoot at walls'-bug. I considered adding a visibility check, but that wouldn't prevent aliens from shooting at the breakable parts of their own ship. So I disabled it for now. Duke, 23.10.09

Global AII_CollectingItems (aircraft_t *aircraft, int won)

Simplify this logic

Global AIL_findweapons (lua_State *L)

Check if can reload the weapon with carried ammo or from the floor itself?

Global AIL_setwaypoint (lua_State *L)

A better way to handle waypoints

Global AIM_AutoEquipAircraft (aircraft_t *aircraft)

Eliminate hardcoded techs here.

Global AIM_CheckTechnologyIntoSlot (const aircraftSlot_t *slot, const technology_t *tech)

It is a generic function, we can move it into cp_mapfightequip.c

Parameters

[in]	slot	Pointer to an aircraft slot (can be base/installation too)
[in]	tech	Pointer to the technology to test

Returns: The status of the technology versus the slot

Global AIM_SelectableCraftItem (const aircraftSlot_t *slot, const technology_t *tech)

maybe this isn't working, aircraft slot type can't be an AMMO

This only works for ammo that is usable in exactly one weapon check the weap_idx array and not only the first value

Global AIM_UpdateItemDescription (bool fromList, bool fromSlot)

we should clone the text, and not using the ufopedia text

Global AIR_AircraftSelect (aircraft_t *aircraft)

This shouldn't exist. UI should use the global idx as reference

Global AIR_AircraftsNotifyUFORemoved (const aircraft_t *const ufo, bool destroyed)

this should be in a BDEF_NotifyUFORemoved callback

Global AIR_CampaignRun (const campaign_t *campaign, int dt, bool updateRadarOverlay)

check if aircraft can go to a closer base with free space

Global AIR_ChangeAircraftName_f (void)

make it not using cvar and default aircraft but get them from parameterlist

Global AIR_DeleteAircraft (aircraft_t *aircraft)

Return status of deletion for better error handling.

Global AIR_DestroyAircraft (aircraft_t *aircraft, bool killPilot=true)

Return status of deletion for better error handling.

Global AIR_DestroyAircraft (aircraft_t *aircraft, bool killPilot=true)

Return status of deletion for better error handling.

Global AIR_ForeachSorted (var, sorter, userdata, sortedlist)

Sorting need to be moved to the UI (Lua) side

Global AIR_GeoSelectAircraft_f (void)

temporary action id should be removed

Global AIR_GetAircraftFromBaseByIDXSafe (const base_t *base, int index)

Remove this! Aircraft no longer have local index per base

Global AIR_GetDestinationWhilePursuing (const aircraft_t *shooter, const aircraft_t *target, vec2_t dest)

only compute this calculation every time target changes destination, or one of the aircraft speed changes.

See also: AIR_SendAircraftPursuingUFO; UFO_SendPursuingAircraft

add EQUAL_EPSILON here?

Global AIR_PostLoadInitMissions (void)

UFO_RemoveFromGeoscape call doesn't notify other systems (aircraft, base defences, sam sites, radar) about the removal of the UFO. Destroying UFOs should get a dedicated function with all necessary notify-callbacks called

Global AIR_ShowChangeHomebaseAircraft_f (void)

Temporary callback. Need to rewrite change homebase popup also

Global aircraft_s::pos

change to vec2_t - this is long/lat

Global aircraftItemType_t

move into campaign only structure

Global aircraftParams_t

move into campaign only structure

Global aircraftProjectile_s::idx

: is this really needed?

Global aircraftProjectile_s::pos [MAX_MULTIPLE_PROJECTILES]

why vec3_t this is long/lat

Global AIRFIGHT_ExecuteActions (const campaign_t *campaign, aircraft_t *shooter, aircraft_t *target)

Implement me and display an attack popup.

This should be calculated only when target destination changes, or when aircraft speed changes.

See also: AIR_GetDestination

Global AIRFIGHT_LoadXML (xmlNode_t *parent)

0 as default might be incorrect

Global AIRFIGHT_ProbabilityToHit (const aircraft_t *shooter, const aircraft_t *target, const aircraftSlot_t *slot)

This probability should also depend on the pilot skills, when they will be implemented.

Global AlienContainment::isLifeSupported (const teamDef_t *team)

find a way that doesn't need a tech ID hardcoded

Global AM_CalculateTeamScores (autoMissionBattle_t *battle)

speaking names please

Global AM_DisplayResults (const autoMissionBattle_t *battle)

results should be set in missionResult and this code should be merged with manual mission result screen code, possibly in a new file: cp_mission_callbacks.c/h

Global AM_DoFight (autoMissionBattle_t *battle)

Drop this if and implement correct weapon/attack strength checks

Global ammoStatus_t

do we still need this?

Global autoUnit_t

add attack and defence scores

Global autoUnit_t

add attack and defence scores

Global B_AssembleMap (char *maps, size_t mapsLength, char *coords, size_t coordsLength, const base_t *base)

Search a empty field and add a alien craft there

If a building is still under construction, it will be assembled as a finished part. Otherwise we need mapparts for all the maps under construction.

Global B_BaseInit_f (void)

integrate building status tooltips from B_CheckBuildingStatusForMenu_f into this one

Global B_BuildBase_f (void)

Why is this needed? Also see bug #5401

Global B_BuildFromTemplate (base_t *base, const char *templateName, bool hire)

if there is no more space for mandatory building, remove a non mandatory one or build mandatory ones first

Global B_BuildingDestroy_f (void)

: make base destroyable by destroying entrance

Global B_BuildingOpenAfterClick_f (void)

Move it to Lua

Global B_Delete (base_t *base)

A lot more could be extracted here from B_Destroy

Global B_Destroy (base_t *base)

Destroy the base. For this we need to check all the dependencies and references. Should be only done after putting bases into a linkedList

Global B_GetBuildingTemplate (const char *buildingName)

make the returned pointer const

Global B_GetBuildingTemplateSilent (const char *buildingName)

make the returned pointer const

Global B_InitCallbacks (void)

unify the names into mn_base_*

Global B_LoadXML (xmlNode_t *parent)

save it as vec2t if needed, also it's opposite

Global B_MoveAircraftOnGeoscapeToOtherBases (const base_t *base)

this should be merged into CAP_RemoveAircraftExceedingCapacity

Pilot skills; really kill pilot in this case?

Global B_SaveXML (xmlNode_t *parent)

save it as vec2t if needed, also it's opposite

Global B_ShutdownCallbacks (void)

unify the names into mn_base_*

Global base_s::map [BASE_SIZE][BASE_SIZE]

maybe integrate BASE_INVALID_SPACE and BASE_FREE_SPACE here?

Global BREATHINGAPPARATUS_TECH

cp_research.h would be enough but it has an unresolved depenency on cp_camapign.h

Global BrushMostlyOnSide (const bspbrush_t *brush, const plane_t *plane)

Or vice versa?

Global BS_Buy_f (void)

warn if player can buy less item due to available credits?

Global BS_BuyUGV (const ugv_t *ugv, base_t *base)

Implement this correctly once we have UGV

Global BS_SellUGV (Employee *robot)

Implement this correctly once we have UGV

message - Couldn't fire employee.

Global BS_ShowInfo_f (void)

show specialized info about PHALANX aircraft

show specialized info about PHLANX UGVs

Global capturedNode

think about replacing it by a boolean. When capturedNode != nullptr => hoveredNode == capturedNode it create unneed case

Global Cbuf_InsertText (const char *text)

actually change the command buffer to do less copying

Global ccs_s::mapAction

eliminate or move into Lua UI scripts

Global cgame_import_s::r_xviAlpha

: remove me

Global cgame_import_t

define the import interface

Global cgame_import_t

define the import interface

Global CHAR_ShouldUpdateSoldierRank (const rank_t *rank, const character_t *chr)

(Zenerka 20080301) extend ranks and change calculations here.

Global CHAR_UpdateStats (const base_t *base, const aircraft_t *aircraft)

use chrScore_t to determine negative influence on soldier here, like killing too many civilians and teammates can lead to unhire and disband such soldier, or maybe rank degradation.

Global Check_InfoStartAligned (const entityDef_t *ed, const entity_t *e)

check for brush intersection as well as alignment, and move to a good position if bad.

Global checkcount

not thread safe

Global CheckMixedFaceContents (void)

at the moment only actorclip is removed if only set on less than half of the faces. there may be other contentflags that would benefit from this treatment

See also: ParseBrush

Global ChopWindingInPlace (winding_t **w, const vec3_t normal, const vec_t dist, const vec_t epsilon)

Why + 4?

Global ChopWindingInPlace (winding_t **w, const vec3_t normal, const vec_t dist, const vec_t epsilon)

Why + 4?

Global chrScoreGlobal_s::experience [SKILL_NUM_TYPES+1]

What are the mins and maxs for these values

Global chrScoreMission_s::kills [KILLED_NUM_TYPES]

use existing code

Global chrScoreMission_s::skillKills [SKILL_NUM_TYPES]

Check HEALING of others.

Global CHRSH_CharGenAbilitySkills (character_t *chr, bool multiplayer, const char *templateId="") __attribute__((nonnull))

Add modifiers for difficulty setting here!

Global CHRSH_CharGenAbilitySkills (character_t *chr, bool multiplayer, const char *templateId="") __attribute__((nonnull))

Add modifiers for difficulty setting here!

Global CIN_OGM_OpenCinematic (struct cinematic_s *cin, const char *filename)

vorbis/theora-header & init in sub-functions

"clean" error-returns ...

FIXME? can serialno be 0 in ogg? (better way to check initialized?)

support for more than one audio stream? / detect files with one stream(or without correct ones)

Global CIN_OGM_OpenCinematic (struct cinematic_s *cin, const char *filename)

vorbis/theora-header & init in sub-functions

"clean" error-returns ...

FIXME? can serialno be 0 in ogg? (better way to check initialized?)

support for more than one audio stream? / detect files with one stream(or without correct ones)

Global CL_ActorClientAction (const eventRegister_t *self, dbuffer *msg)

Hud should have a button that should be activated now

Global CL_ActorConditionalMoveCalc (le_t *le)

seems like this function is called before the TUs are set

Global CL_ActorDie (const eventRegister_t *self, dbuffer *msg)

CHRSH_IsTeamDefRobot: spawn smoke particles for robots

Global CL_ActorDoShoot (const eventRegister_t *self, dbuffer *msg)

Improve detection of left- or right animation.

See also: EV_ACTOR_SHOOT

Global CL_ActorDoThrow (const eventRegister_t *self, dbuffer *msg)

add victim support for blood and hurt sounds

Global CL_ActorMouseTrace (void)

Shouldn't we check the return value of CM_TestLineDM here - maybe we don't have to do the second Grid_Fall call at all and can save a lot of traces

Global CL_ActorStartShoot (const eventRegister_t *self, dbuffer *msg)

Improve detection of left- or right animation.

See also: EV_ACTOR_START_SHOOT

Global CL_ActorUseHeadgear_f (void)

make this a variable somewhere?

Global CL_AddActor (le_t *le, entity_t *ent)

Better value for this?

Global CL_AddUGV (le_t *le, entity_t *ent)

Global CL_BattlescapeRadarGenerateAllRelease_f (void)

allow to call UI_TimerRelease into timer callback

Global CL_BattlescapeRadarMapInFrameBuffer (int *x, int *y, int *width, int *height)

fix that function, map is not well captured

viddef.context should be removed

Global CL_ChangeSkin_f (void)

Get the skin id from the model by using the actorskin id

Or remove skins from models and convert character_t->skin to string

Global CL_ChangeSkinForWholeTeam_f (void)

What happens if a model of a team member does not have the selected skin?

Get the skin id from the model by using the actorskin id

Or remove skins from models and convert character_t->skin to string

Global CL_CharacterSkillAndScoreCvars (const character_t *chr)

: replace this cvar hell with confuncs

Global CL_EndRoundAnnounce (const eventRegister_t *self, dbuffer *msg)

Build into hud

Global CL_FinishHTTPDownload (void)

technically i shouldn't need to do this as curl will auto reuse the existing handle when you change the URL. however, the handleCount goes all weird when reusing a download slot in this way. if you can figure out why, please let me know.

Global CL_FixActorSkinIDX (int idx)

we should check somewhere there is at least 1 skin

Global CL_GetHitProbability (const le_t *actor)

The hit probability should work somewhat differently for splash damage weapons. Since splash damage weapons can deal damage even when they don't directly hit an actor, the hit probability should be defined as the predicted percentage of the maximum splash damage of the firemode, assuming the projectile explodes at the desired location. This means that a percentage should be displayed for EVERY actor in the predicted blast radius. This will likely require specialized code.

use LE_FindRadius

Global CL_GetSkillIndicator (const character_t *chr, abilityskills_t skill)

This currently always uses exactly the first two firemodes (see fmode1+fmode2) for calculation. This needs to be adapted to support less (1) or more 3+ firemodes. I think the function will even break on only one firemode .. never tested it.

i think currently also the different ammo/firedef types for each weapon (different weaponr_fd_idx and weaponr_fd_idx values) are ignored.

Global CL_GetTipOfTheDay_f (void)

not his role, remove it when its possible

Global CL_HudRadarDown_f (void)

only call/register it when we are on the battlescape

Global CL_HudRadarUp_f (void)

only call/register it when we are on the battlescape

Global CL_InvAddTime (const struct eventRegister_s *self, dbuffer *msg, eventTiming_t *eventTiming)

but if the dying actor didn't have any item in its inventory this event won't be sent, the next unrelated EV_INV_ADD event might be badly scheduled

Global CL_ParticleFunction (ptl_t *p, ptlCmd_t *cmd)

make the children boolean configurable

Global CL_ParticleLoadArt (ptlArt_t *a)

Support the frame data from ptlArt_t for models, too

Global CL_PopupInterceptClick_f (void)

are these newlines really needed? at least the first should be handled by the menu code

Global CL_PrecacheCharacterModels (float alreadyLoadedPercent)

Does not precache armoured models

Global CL_SetRatioFilter_f (void)

We should check the ratio list and remove matched resolutions, here it is a hack

Global CL_Shutdown (void)

this is a callback from Sys_Quit and Com_Error. It would be better to run quit through here before the final handoff to the sys code.

See also: Sys_Quit; CL_Init

Global CL_SoundEvent (const eventRegister_t *self, dbuffer *msg)

render

Global CL_StartHTTPDownload (dlqueue_t *entry, dlhandle_t *dl)

use the FS_OpenFile function here

Global CL_TargetingGrenade (const pos3_t fromPos, actorSizeEnum_t fromActorSize, const pos3_t toPos)

character strength should be used here, too the stronger the character, the further the throw

Global CL_TargetingStraight (const pos3_t fromPos, actorSizeEnum_t fromActorSize, const pos3_t toPos)

is this really needed for straight targetting? - for grenades, yes, but not for straight no? cl_worldlevel->integer should be enough here

Global clientBattleScape_s::numMapParticles

make this private to the particle code

Global ClumpOrder (const void *a, const void *b)

Morton order comparison to improve clusterization after sorting (beware the black magic)

Global CM_GetVisibility (const mapTiles_t *mapTiles, const pos3_t position)

implement me

Global CM_HintedTransformedBoxTrace (MapTile &tile, const Line &traceLine, const AABB &traceBox, const int headnode, const int brushmask, const int brushrejects, const vec3_t origin, const vec3_t angles, const vec3_t rmaShift, const float fraction)

figure out how to do this with existing angles

Global CM_HintedTransformedBoxTrace (MapTile &tile, const Line &traceLine, const AABB &traceBox, const int headnode, const int brushmask, const int brushrejects, const vec3_t origin, const vec3_t angles, const vec3_t rmaShift, const float fraction)

figure out how to do this with existing angles

Global Cmd_ExecuteString (const char *text,...)

lookupnoadd the token to speed search?

Global Cmd_GetCommandDesc (const char *command)

- search alias, too

Global Cmd_GetCommandDesc (const char *command)

- search alias, too

Global CMod_LoadLighting (MapTile &tile, const byte *base, const lump_t *lump)

Implement this

Global CMod_LoadRouting (MapTile &tile, mapData_t *mapData, const byte *base, const char *name, const lump_t *lump, const int sX, const int sY, const int sZ)

TEST z-level routing

this eats a lot of memory - load directory into mapData->map

Global colorDefault

it may be nice to vectorise that

Global Com_GetRandomMapAssemblyNameForCrashedCraft (const char *craftID)

implement this in a better way

Global Com_GrenadeTarget (const vec3_t from, const vec3_t at, float speed, bool launched, bool rolled, vec3_t v0)

refactor and move me

Com_GrenadeTarget() is called from CL_TargetingGrenade() with speed param as (fireDef_s) fd->range (gi.GrenadeTarget, too), while it is being used here for speed calculations - a bug or just misleading documentation?

See also: CL_TargetingGrenade

Global Com_ParseValue (void *base, const char *token, valueTypes_t type, int ofs, size_t size, size_t *writtenBytes)

This function has much in common with Com_SetValue. Refactor them !

Global COMP_ParseComponents (const char *name, const char **text)

Set item links to NONE if needed

Global CON_FlushIn (void)

relevant?

Global ConstructLevelNodes_r (const int levelnum, const AABB &partBox, int entityNum)

better algo to chose a split position - could force all splits to make continuous grid, for example

Global CP_AddCampaignCallbackCommands (void)

callbacks should be registered on menu push (what about sideeffects for commands that are called from different menus?)

See also: CP_AddCampaignCommands; CP_RemoveCampaignCallbackCommands

Global CP_AddRadarCoverage (const vec2_t pos, float innerRadius, float outerRadius, bool source)

add EQUAL_EPSILON here?

Global CP_AddWeaponAmmo (equipDef_t *ed, Item *item)

We may want to change this to use the type->ammo[] info.

on return from a mission with no clips left and one weapon half-loaded wielded by soldier and one empty in equip, on the first opening of equip, the empty weapon will be in soldier hands, the half-full in equip; this should be the other way around.

We may want to change this to use the type->ammo[] info.

File cp_airfight.cpp

Somehow i need to know which alien race was in the ufo we shoot down I need this info for spawning the crash site

See also: CP_CreateBattleParameters

Global CP_AttackUFOCarrier_f (void)

until we have the carrier mission fully implemented, this is the campaign end

Global CP_BaseAttackPrepareBattle (mission_t *mission)

remove me - this is not needed because we are using the base->aircraftCurrent pointer for resolving the aircraft - only Autocombat needs this

Global CP_BaseAttackStartMission (struct mission_s *mission)

handle command centre properly

Global CP_BaseAttackStartMission (struct mission_s *mission)

handle command centre properly

Global CP_BuildBaseGovernmentLeave (const campaign_t *campaign, mission_t *mission)

when the mission is created, we should select a position where nation exists, otherwise subverting a government is meaningless

Global CP_CheckLostCondition (const campaign_t *campaign)

Should we make the campaign lost when a player loses all his bases? until he has set up a base again, the aliens might have invaded the whole world ;) - i mean, removing the credits check here.

Global CP_CreateCivilianTeam (const mission_t *mission, battleParam_t *param)

There should always be a nation, no? Otherwise the mission was placed wrong.

Global CP_EndRescueMission (struct mission_s *mission, aircraft_t *aircraft, bool won)

it should be dumped to the cargo loot of the dropship done the rescue mission not the base directly

Global CP_EndRescueMission (struct mission_s *mission, aircraft_t *aircraft, bool won)

it should be dumped to the cargo loot of the dropship done the rescue mission not the base directly

Global CP_GetRandomPosOnGeoscapeWithParameters (vec2_t pos, const linkedList_t *terrainTypes, const linkedList_t *cultureTypes, const linkedList_t *populationTypes, const linkedList_t *nations)

- cache the counted hits

add EQUAL_EPSILON here?

Global CP_HandleNationData (float minHappiness, mission_t *mis, const nation_t *affectedNation, const missionResults_t *results, bool won)

Scoring should eventually be expanded to include such elements as infected humans and mission objectives other than xenocide.

HACK: This should be handled properly, i.e. civilians should only factor into the scoring if the mission objective is actually to save civilians.

The score for aliens should be dependent on the mission objective. In a mission that has a special objective, the amount of killed aliens should only serve to increase the score, not reduce the penalty.

Global CP_HarvestMissionGo (struct mission_s *mission)

Remove me when CP_XVIMissionGo will be implemented This function should take a location close to an XVI infection point see gameplay proposal on wiki

Global CP_HarvestMissionGo (struct mission_s *mission)

Remove me when CP_XVIMissionGo will be implemented This function should take a location close to an XVI infection point see gameplay proposal on wiki

Global CP_InitStartup (void)

remove me and move all the included stuff to proper places

File cp_messageoptions_callbacks.cpp

Remove direct access to nodes

Global CP_MissionEnd (const campaign_t *campaign, mission_t *mission, const battleParam_t *battleParameters, bool won)

replace HP check with some CHRSH->IsDead() function

Global CP_OnGeoscape (void)

This relies on scripted content. Should work other way!

File cp_overlay.cpp

update the alpha values for radar like the ones for the xvi map - it's much faster like this

Global CP_ParseResearchableCampaignStates (const campaign_t *campaign, const char *name, const char **text, bool researchable)

Mark unresearchable

Global CP_RemoveCampaignCallbackCommands (void)

callbacks should be removed on menu pop (what about sideeffects for commands that are called from different menus?)

See also: CP_AddCampaignCommands; CP_RemoveCampaignCallbackCommands

File cp_research.cpp

comment on used global variables.

Global CP_SecondConvert (int second)

Abstract the code into an extra function (DateConvertSeconds?) see also CP_DateConvertLong

Global CP_Shutdown (void)

Where does this belong?

Global CP_SpawnRescueMission (aircraft_t *aircraft, aircraft_t *ufo)

Don't spawn rescue mission every time! It should depend on pilot's manoeuvring (piloting) skill

don't "kill" everyone - this should depend on luck and a little bit on the skills

find out what to do in this case

File cp_transfer.cpp

Remove direct access to nodes

File cp_ufopedia.cpp

Split the mail code into cl_mailclient.c/h

Remove direct access to nodes

Global CP_UFORemoveFromGeoscape (mission_t *mission, bool destroyed)

remove me once the ufo list is a linked list

Global craftItem

move into campaign only structure

Global craftItem

move into campaign only structure

Global csi_s::alienTeams [MAX_TEAMS_PER_MISSION]

this does not belong here - this is only static data that is shared

Global csi_s::damStunGas

Maybe even make a differentiation between aliens/humans here?

Global currentTransferType

move this into Lua UI

Global Cvar_InfoValidate (const char *s)

This allows for Cvar identifier names containing spaces. This is probably unwanted so best to extent the check with whitespace.

Global dataExtraData_s::number

Add it again when "string" from uiNode_t is removed / or property "string" from abstract node char* string;

Global dateLong_s::hour

check what number-range this gives)

Global defaultMaterial

load this from file, will make tweaking the game much easier

Global do_accept (SOCKET sock)

close stream?

Global Door_Use (Edict *door, Edict *activator)

Check if the door can be opened or closed - there should not be anything in the way (e.g. an actor)

Global E_EmployeeList_f (void)

replace magic numbers - use confuncs

Global E_GetEmployeeType (const char *type)

use cgi->Com_ConstInt*

Global E_HireEmployee (base_t *base, Employee *employee)

handle EMPL_ROBOT capacities here?

shouldn't we link CID_EQUIP here already to the base inventory equip container?

Global E_InitialEmployees (const campaign_t *campaign)

don't use hardcoded UGV ids

Global ED_ParseField (const char *key, const char *value, Edict *ent)

This (maxteams) should also be handled server side - currently this is only done client side

Global Edict::isOpponent (const Actor *actor) const

Should we really know if the other actor is controlled by the other team (STATE_XVI)? aliens would of course know if an actor is infected (becomes part of the hive mind), but humans?

Global Employee::unhire ()

handle EMPL_ROBOT capacities here?

Global entityNum

userdata for ProcessLevel thread

Global FS_CopyFile (const char *fromOSPath, const char *toOSPath)

Allow copy of pk3 file content

Global FS_GetMaps (bool reset)

paths are normalized here?

Global G_ActorDieOrStun (Actor *actor, Edict *attacker)

Discuss whether stunned actor should really drop everything to floor. Maybe it should drop only what he has in hands? Stunned actor can wake later during mission.

Global G_ActorDoTurn (Edict *ent, byte dir)

If performing an action, ensure the actor is facing the direction needed to perform the action if needed (climbing ladders).

Global G_ActorFall (Edict *ent)

Handle cases where the grid position the actor would fall to is occupied by another actor already.

Global G_ActorInvMove (Actor *actor, const invDef_t *from, Item *fItem, const invDef_t *to, int tx, int ty, bool checkaction)

what if we don't have enough TUs after subtracting the reserved ones?

Global G_ActorInvMove (Actor *actor, const invDef_t *from, Item *fItem, const invDef_t *to, int tx, int ty, bool checkaction)

what if we don't have enough TUs after subtracting the reserved ones?

Global G_ActorRevitalise (Actor *actor)

have a look at the morale value of the actor and maybe get into rage or panic?

Global G_ClientAssignDefaultActorValues (Actor *actor)

for now, heal fully upon entering mission

Global G_ClientConnect (Player *player, char *userinfo, size_t userinfoSize)

Check if the teamnum preference has already reached maxsoldiers and reject connection if so

Returns: false if the connection is refused, true otherwise

Global G_ClientMove (const Player &player, int visTeam, Actor *actor, const pos3_t to)

Handle dazed via trigger_hurt

Global G_ClientShoot (const Player &player, Actor *actor, const pos3_t at, shoot_types_t shootType, fireDefIndex_t firemode, shot_mock_t *mock, bool allowReaction, int z_align)

check for direct shot / splash damage shot?

This really needs an overhaul.And it might get dumped completely when Feature Request "[1814158] Extended shot-definitions in firedef" https://sourceforge.net/tracker/?func=detail&atid=805245&aid=1814158&group_id=157793 gets implemented.

Global G_ClientUseEdict (const Player &player, Actor *actor, Edict *door)

Do we have to change the trigger position here, too? I don't think this is really needed.

See also: CL_ActorUse; G_UseEdict

Global G_ClientUseEdict (const Player &player, Actor *actor, Edict *door)

Do we have to change the trigger position here, too? I don't think this is really needed.

See also: CL_ActorUse; G_UseEdict

Global G_Damage (Edict *target, const fireDef_t *fd, int damage, Actor *attacker, shot_mock_t *mock, const vec3_t impact)

there should be a possible protection, too

Global G_FireAffectedSurface (const cBspSurface_t *surface, const fireDef_t *fd)

Such function should check notonly fire - it should be generic function to check surface vulnerability for given damagetype.

Global G_GetPlayerForTeam (int team)

What if there are multiple players for a team (multiplayer coop match)

Global G_GetTeam (Player &player)

Check whether there are enough free spawnpoints in all cases

Global G_MatchEndCheck (void)

count from 0 to get the civilians for objectives

< 2 does not work when we count civilians

Global G_MissionTouch (Edict *self, Edict *activator)

use level.nextmap to spawn another map when every living actor has touched the mission trigger

Note: Don't set a client action here - otherwise the movement event might be corrupted

Global G_ShootSingle (Actor *ent, const fireDef_t *fd, const vec3_t from, const pos3_t at, int mask, const Item *weapon, shot_mock_t *mock, int z_align, int i, shoot_types_t shootType, vec3_t impact)

reduce even more if the wall was hit far away and not close by the shooting actor

Global G_SpawnFieldGroup (const entity_type_t fieldtype, const vec3_t vec, const char *particle, int rounds, int damage, vec_t radius)

Does '2 rounds' mean: created in player's turn, last through the aliens turn, vanish before the 2nd player's turn ??

Parameters

[in]	damage	The damage dealt by the field
[in]	radius	The max distance of a cell from the center to get a particle

Global G_SpawnSmokeField (const vec3_t vec, const char *particle, int rounds, int damage, vec_t radius)

Does '2 rounds' mean: created in player's turn, last through the aliens turn, vanish before the 2nd player's turn ??

Parameters

[in]	damage	The amount of damage this field will cause when touched by an actor.
[in]	radius	The max distance of a cell from the center to get a particle

Global G_SplashDamage (Actor *ent, const fireDef_t *fd, vec3_t impact, shot_mock_t *mock, const trace_t *tr)

splash might also hit other surfaces and the trace doesn't handle that

Global G_TreatActor (Actor *target, const fireDef_t *const fd, const int heal, const int healerTeam)

According to specs it should only be possible to use the medikit to keep an alien sedated when 'live alien' is researched, is it possible to find if a tech is researched here?

Global G_UpdateStunState (int team)

Make this depend on the character-attributes.

Global GAME_CP_Drop (void)

maybe create a savegame?

Global GAME_EndRoundAnnounce (int playerNum, int team)

do we need the team number here? isn't the playernum enough to get the team?

Global GAME_GetImportData (const cgameType_t *t)

add a wrapper here that stores the cgame command and removes them on shutdown automatically

add a wrapper here that stores the cgame cvars and removes them on shutdown automatically

Global GAME_LoadCharacter (xmlNode_t *p, character_t *chr)

Fallback compatibility code for older saves

Global GAME_MP_CompleteNetworkAddress (const char *partial, const char **match)

Extend this for all the servers on the server browser list

Global GAME_MP_InitStartup (void)

make equipment configurable for multiplayer

Global GAME_MP_ParseTeamInfoMessage (dbuffer *msg)

warning must not be into the player list. if we see this we are the first player that would be connected to the server

Global GAME_MP_StartServer_f (void)

implement different ufo and dropship support for multiplayer, too (see skirmish)

Global GAME_SaveItem (xmlNode_t *p, const Item *item, containerIndex_t container, int x, int y)

: is there any case when amount != 1 for soldier inventory item?

Global GAME_SK_Start_f (void)

make the teamdef configurable

Global GEO_AngleOfPath3D (const vec2_t start, const vec2_t end, vec3_t direction, vec3_t ortVector)

Save the value angle instead of direction: we don't need a vector here, we could just compare angle to current angle.

Global GEO_Click (const uiNode_t *node, int x, int y, const vec2_t pos)

make this a function in cp_base.c - B_BuildBaseAtPos

Global GEO_DrawMapOnePhalanxAircraft (const uiNode_t *node, aircraft_t *aircraft, bool oneUFOVisible)

: check why path.numPoints can be sometime equal to -1

we should only show healthbar if the aircraft is fighting but it's a slow algo

Global GEO_DrawMarkers (const uiNode_t *node)

we should only show healthbar if aircraft is fighting but it's a slow algo

Global GEO_GetColor (const vec2_t pos, mapType_t type, bool *coast)

add EQUAL_EPSILON here?

Global GEO_NotifyUFORemoved (const aircraft_t *ufo, bool destroyed)

convert to linked list

Global GET_ACC (ab, sk, pn)

Skill-influence needs some balancing.

Global GL_READ_FRAMEBUFFER_EXT

update SDL to version that includes these

Global Grid_Fall (const Routing &routing, const actorSizeEnum_t actorSize, const pos3_t pos)

if an actor can fly, then set this to true.

Global HashVec (const vec3_t vec)

Fix this to support the full bsp level bounds

Global HUD_CheckCLHud (cvar_t *cvar)

check for multiple base classes

Global HUD_DisplayActions_f (void)

we can extend it with short cut equip action, more reload, action on the map (like open doors)...

Global HUD_DisplayImpossibleReaction (const le_t *actor)

at the moment of writing, this should be impossible: reaction should be disabled whenever the actor loses its reaction weapon.

Global HUD_ExecuteAction_f (void)

extend it to open doors or things like that

Global HUD_GetLeftHandWeapon (const le_t *actor, containerIndex_t *container)

remove me

Global HUD_PopupFiremodeReservation (const le_t *le, bool popupReload)

use components and confuncs here

Global HUD_SetWeaponButton (buttonTypes_t button, weaponButtonState_t state)

This should be a confunc which also sets the tooltips

Global HUD_ShotReserve_f (void)

do this on the server

Global HUD_UsableReactionTUs (const le_t *le)

Maybe only return "reaction" value if reaction-state is active? The value should be 0, but one never knows :)

Global humanAircraftType_t

doesn't belong here, but AIRCRAFTTYPE_MAX is needed for the equipment definitions

Global IMAGE_WIDTH

Replace magic number 64 by some script definition

Global Info_ValueForKey (const char *s, const char *key)

Not thread safe

Global INS_FillTypes_f (void)

Move this out from installations code

Global INV_GetFilterFromItem (const objDef_t *obj)

need to implement everything

Global INV_ItemDescription (const objDef_t *od)

Do we need to add checks for od->isDummy here somewhere?

is there ammo with no firedefs?

Global INV_ItemMatchesFilter (const objDef_t *obj, const itemFilterTypes_t filterType)

Should we handle FILTER_AIRCRAFT here as well?

I guess we should search for components matching this item here.

Global Inventory::_getNextCont (const Container *prev) const

: convert into iterator

Global Inventory::canHoldItem (const invDef_t *container, const objDef_t *od, const int x, const int y, const Item *ignoredItem) const

aren't both (equip and floor) temp container?

Global Inventory::findSpace (const invDef_t *container, const Item *item, int *const px, int *const py, const Item *ignoredItem) const

optimize for single containers

Global Inventory::getContainer2 (const containerIndex_t idx) const

this should return a reference - can't be null

Global Inventory::getEquipContainer () const

this should return a reference - can't be null

Global Inventory::getFloorContainer () const

this should return a reference - can't be null

Global Inventory::getHolsterContainer () const

this should return a reference - can't be null

Global Inventory::getLeftHandContainer () const

this should return a reference - can't be null

Global Inventory::getNextCont (const Container *prev, bool inclTemp=false) const

convert into iterator

Global Inventory::getRightHandContainer () const

this should return a reference - can't be null

Global InventoryInterface::moveInInventory (Inventory *const inv, const invDef_t *from, Item *item, const invDef_t *to, int tx, int ty, int *TU, Item **icp)

change the other code to browse through these things.

Global InventoryInterface::removeFromInventory (Inventory *const inv, const invDef_t *container, Item *fItem) __attribute__((warn_unused_result))

the problem here is, that in case of a move inside the same container the item don't just get updated x and y values but it is tried to remove one of the items => crap - maybe we have to change the inventory move function to check for this case of move and only update the x and y coordinates instead of calling the add and remove functions

Global Irc_Client_CmdRplEndofnames (const char *params, const char *trailing)

Implement me

Global Irc_GetExternalIP (const char *externalIP, void *userdata)

Maybe somehow check the version of the client with ctcp VERSION and only send to those, that are connected with ufoai and have a correct version

Global Irc_Logic_Frame (void)

do this without disconnect, connect

Global Irc_Proto_Enqueue (const char *msg, size_t msg_len)

strip high bits - or unprintable chars

Global Irc_Proto_ProcessServerMsg (const irc_server_msg_t *msg)

Skip non printable chars here

Global Key_Console (int key, int unicode)

use isprint here?

Global Key_KeynumToString (int keynum)

handle quote special (general escape sequence?)

See also: Key_StringToKeynum

use isprint here?

Global keyBindings [K_KEY_SIZE]

To support international keyboards nicely, we will need full support for binding to either

a unicode value, however achieved
a key
modifier + key with a priority system to decide which to try first. This will mean that cleverly-hidden punctuation keys will still have their expected effect, even if they have to be pressed as Shift-AltGr-7 or something. At the same time, it allows key combinations to be bound regardless of what their translated meaning is, so that for example Shift-4 can do something with the 4th agent regardless of which punctuation symbol is above the 4.

Global LE_AddProjectile (const fireDef_t *fd, int flags, const vec3_t muzzle, const vec3_t impact, int normal, le_t *leVictim)

Special particles for stun attack (mind you that there is electrical and gas/chemical stunning)?

Global LE_PlaySoundFileAndParticleForSurface (le_t *le, const char *textureName)

use the Grid_Fall method (ACTOR_SIZE_NORMAL) to ensure, that the particle is drawn at the ground (if needed - maybe the origin is already ground aligned)

Global LE_Unlock (le_t *le)

If the event loop ever becomes multithreaded, this should be a real mutex lock.

Global LEAFNODE

replace this with CONTENTS_NODE?

Global LET_HiddenMove (le_t *le)

Is there something we should do here?

Global LET_Projectile (le_t *le)

Special particles for stun attack (mind you that there is electrical and gas/chemical stunning)?

Global LET_RotateDoor (le_t *le, int speed)

lerp the rotation

Global lineChartExtraData_t

add info about axes min-max...

Global lineChartExtraData_t

add info about axes min-max...

Global LINEHEIGHT

use the font height?

Global LIST_Add (linkedList_t **list, void const *data, size_t length)

Optimize this to not allocate memory for every entry - but use a hunk

Global LIST_Add (linkedList_t **list, void const *data, size_t length)

Optimize this to not allocate memory for every entry - but use a hunk

Global LIST_AddPointer (linkedList_t **listDest, void *data)

Optimize this to not allocate memory for every entry - but use a hunk

Global LIST_AddString (linkedList_t **list, const char *data)

Optimize this to not allocate memory for every entry - but use a hunk

Global LIST_AddString (linkedList_t **list, const char *data)

Optimize this to not allocate memory for every entry - but use a hunk

Global LIST_PrependString (linkedList_t **listDest, const char *data)

Optimize this to not allocate memory for every entry - but use a hunk

Global listBlock_t

This block list code is broken in terms of filename order To see the bug reduce the FL_BLOCKSIZE to 1024 and verify the order of the filenames FS_NextScriptHeader gives you - you will see that the last files will be in reversed order

Global listBlock_t

This block list code is broken in terms of filename order To see the bug reduce the FL_BLOCKSIZE to 1024 and verify the order of the filenames FS_NextScriptHeader gives you - you will see that the last files will be in reversed order

Global LM_AddToSceneOrder (bool parents)

what if the tagent is not rendered due to different level flags?

Global M_Change_f (void)

Make the music a scriptable list

Global main (int argc, char **argv)

see https://sourceforge.net/tracker/?func=detail&aid=2993773&group_id=157793&atid=805242

Global mapData_s::reroute [ACTOR_MAX_SIZE][PATHFINDING_WIDTH][PATHFINDING_WIDTH]

not threadsafe

Global markResearched_t

MAX_CAMPAIGNS is not defined unless cp_campaign.h is included before

Global markResearched_t

MAX_CAMPAIGNS is not defined unless cp_campaign.h is included before

Global messageStack

implement this on a per-node basis

Global MIN_TILE_SIZE

take this datum from the correct place

Global MIS_GeoSelectMission_f (void)

Move this popup from cp_popup and rebuild

Global MIS_GetModel (const mission_t *mission)

we have two different alienbase models

Global MSO_LoadXML (xmlNode_t *parent)

(menu) check why this message is not shown anywhere in logs

Global MSO_LoadXML (xmlNode_t *parent)

(menu) check why this message is not shown anywhere in logs

Global MSO_Toggle_f (void)

move this into scripts

Global MSO_UpdateVisibleButtons (void)

move this into scripts

Global NAT_BackupMonthlyData (void)

other stuff to back up?

Global NAT_HandleBudget (const campaign_t *campaign)

This is very redundant with STATS_Update_f. Investigate and clean up.

Global NAT_SetHappiness (const float minhappiness, nation_t *nation, const float happiness)

need to more specific message

Global nationInfo_t

Maybe we should also move the "funding" stuff (see nation_t) in here? It is static right now though so i see no reason to do that yet.

Global nationInfo_t

Maybe we should also move the "funding" stuff (see nation_t) in here? It is static right now though so i see no reason to do that yet.

Global NET_Connect (const char *node, const char *service, stream_onclose_func *onclose)

What about a timeout

Global NET_DatagramBroadcast (struct datagram_socket *s, const char *buf, int len, int port)

This is only sending on the first available device, what if we have several devices?

Global node_s::area

not used, remove it when we change the bsp version the next time

Global OF ((unzFile file, unz_file_info *pfile_info, unz_file_info_internal *pfile_info_internal, char *szFileName, uLong fileNameBufferSize, void *extraField, uLong extraFieldBufferSize, char *szComment, uLong commentBufferSize))

Describe parameters and the two headers.

Global ogmCinematic_t::videoStreamIsXvid

atm there isn't really a check for this (all "video" streams are handled as xvid, because xvid support more than one "subtype")

Global pcmdData [MAX_PCMD_DATA]

check pcmdData overflow

Global PLAYER2x2_WIDTH

may need some tweaks.

Global PR_ProductionDecrease_f (void)

add (confirmaton) popup in case storage cannot take all the items we add back to it

Global PR_ProductionIncrease_f (void)

-) need to popup something like: "You need the following items in order to produce more of ITEM: x of ITEM, x of ITEM, etc..." This info should also be displayed in the item-info. -) can can (if possible) change the 'amount' to a vlalue that can be produced (i.e. the maximum amount possible).

this popup hides any previous popup, like popup created in PR_QueueNew

Global PR_ProductionListClick_f (void)

left click on spacer should either delete current selection or do nothing, not update visible selection but show old info

Global PR_ResetUFODisassembly (production_t *prod)

remove this and make the ufo const

Global PR_SaveXML (xmlNode_t *parent)

this should not be the base index

Global PR_SaveXML (xmlNode_t *parent)

this should not be the base index

Global PR_SetUFODisassembly (production_t *prod)

remove this and make the ufo const

Global PrecalcNormalsAndTangents (const char *filename)

currently md2 models only have one mesh - for md3 files this would get overwritten for each mesh

Global ProcessLevel (unsigned int levelnum)

Check what happens if two threads do the memcpy

Global PruneNodes_r (node_t *node)

free stuff

File q_shared.h

Apparently included by every file - unnecessary?

Global Q_strcasecmp (a, b)

is this still the case in most recent mingw versions?

Global Qcommon_Init (int argc, char **argv)

This line wants to be removed

Global R_AddLight (const vec3_t origin, float radius, const vec3_t color)

- integrate the particle-based lights into the new dynamic light system

Global R_AddLightToEntity (const vec_t *pos, lighting_t *ltng, const light_t *light, const float distSqr)

- the updating of the per-entity list of nearest lights doesn't necessarily need to be updated before every frame; if the list is a few frames (or even a few seconds) out of date, it would still probably look just fine. Ideally, this updating could be done in the background by a separate, low-priority thread that constantly looped through all the entities and updated their light lists, while the high-priority rendering thread just used the most up to date version available.

will caching VectorDistSqr() results improve the rendering speed?

Global R_CleanupDepthBuffer (int x, int y, int width, int height)

can we fix bigZ with a value come from glGet?

Global R_CreateFramebuffer (int width, int height, int ntextures, bool depth, bool halfFloat, unsigned int *filters)

also check if we are running on older (SM2.0) hardware, which doesn't support antialiased MRT

Global R_Draw3DGlobe (const vec2_t pos, const vec2_t size, int day, int second, const vec3_t rotate, float zoom, const char *map, bool disableSolarRender, float ambient, bool overlayNation, bool overlayXVI, bool overlayRadar, image_t *r_xviTexture, image_t *r_radarTexture, bool renderNationGlow)

render atmosphere glow even when postprocessing is disabled

Replace this magic number with some speaking constant

Global R_DrawAliasModel (entity_t *e)

this breaks the encapsulation - don't call CL_* functions from within the renderer code

Global R_DrawAliasModelBuffer (entity_t *e)

what about the origin of a tagged model here?

Global R_DrawBox (const entity_t *e)

fill one array

Global R_DrawBuffers (unsigned int n)

introduce enum or speaking constants for the buffer numbers that are drawn here and elsewhere

Global R_DrawBuffers (unsigned int n)

introduce enum or speaking constants for the buffer numbers that are drawn here and elsewhere

Global R_DrawEntityEffects (void)

use default_texcoords

Global R_DrawFill (int x, int y, int w, int h, const vec4_t color)

this shouldn't be here, but only called once at the end of the frame but this is needed here because a) we don't want them to get rendered on top of the console and b) the ui stuff relies on the order of these renderings

Global R_DrawFlareSurfaces (const mBspSurfaces_t *surfs, glElementIndex_t *indexPtr)

better GL state handling

Global R_DrawFloor (const entity_t *e)

use default_texcoords

Global R_DrawMaterialSurfaces (const mBspSurfaces_t *surfs, glElementIndex_t *indexPtr)

- integrate BSP lighting with model lighting

Global R_DrawQuad (void)

use default_texcoords

Global R_DrawSurfaces (const mBspSurfaces_t *surfs, glElementIndex_t *indexPtr)

integrate it better with R_SetSurfaceState - maybe cache somewhere in the mBspSurface_t ?

Global R_EnableGlowMap (const image_t *image)

Is the following condition correct or not? Either fix it or write the comment why it should be done that way

Global R_EnableModelLights (const light_t **lights, int numLights, bool inShadow, bool enable)

is it a good idea?

assert?

Global R_FillArrayData (mAliasModel_t *mod, mAliasMesh_t *mesh, float backlerp, int framenum, int oldframenum, bool prerender)

damn slow - optimize this

Global R_FindImage (const char *pname, imagetype_t type)

should also check the mipmapping

Global R_FindModel (const char *name)

this case should be useless, do we ever use extension?

Global R_FontAnalyze (const char *name, const char *path, int renderStyle, int size)

Check whether font is already loaded

Global R_FontDrawString (const char *fontId, align_t align, int x, int y, int absX, int maxWidth, int lineHeight, const char *c, int boxHeight, int scrollPos, int *curLine, longlines_t method)

This could be replaced with a set of much simpler interfaces.

Global R_FontFindFit (const font_t *font, char *text, int maxlen, int maxWidth, int *widthp)

Smart breaking of Chinese text

Global R_FontMakeChunks (const font_t *f, const char *text, int maxWidth, longlines_t method, int *lines, bool *aborted)

check for infinite recursion here

Global R_GenerateGrass ()

sometimes rounding error makes it to plant an extra clump which may overrun the vertex array, thus causing problems with OpenGL driver, should be fixed

Global R_LoadActorSkinsFromModel (mAliasMesh_t *outMesh, image_t *defaultSkin)

should we add warning here?

Global R_LoadBspVertexArrays (model_t *mod)

Don't use the buffers from r_state here - they might overflow

Decrease MAX_GL_ARRAY_LENGTH to 32768 again when this is fixed

Global R_LoadImageData (const char *name, const byte *pic, int width, int height, imagetype_t type)

Instead of this hack, unit tests' build should link to the dummy GL driver

Global R_LoadSurfacesArrays_ (model_t *mod)

only one allocation should be used here - allocate the whole array with one Mem_PoolAlloc call

Global R_ModelAutoScale (const vec2_t boxSize, modelInfo_t *mi, vec3_t scale, vec3_t center)

Take the rotation info from modelInfo_t into account

Global R_ModLoadAliasMD2MeshUnindexed (model_t *mod, const dMD2Model_t *md2, int bufSize, bool loadNormals)

Should we check skin image versus this size?

Global R_ModLoadAliasMD3Model (struct model_s *mod, byte *buffer, int bufSize)

the tag loading is broken - the order is different in the md3 file

Global R_ModLoadAliasMD3Model (struct model_s *mod, byte *buffer, int bufSize)

the tag loading is broken - the order is different in the md3 file

Global R_ModReloadSurfacesArrays (void)

fix this for threaded renderer mode

Global R_PlantGrass (Clump &clump)

use UNIT_SIZE and co defines here

Global R_RecursiveWorldNode (const mBspNode_t *node, int tile)

avoid being too precise, it's a waste of CPU time; possibly, granularity of 256x256x256 should be enough

Global R_RenderBspRRefs (drawSurfaceFunc drawFunc, surfaceArrayType_t surfType)

make it work again; also reimplement r_showbox 2

Global R_ResetArrayState (void)

proper logic for unbinding buffers

Global R_RunThread (void *p)

- update per-model dynamic light list sorting here

Global R_SetSurfaceStageState (const mBspSurface_t *surf, const materialStage_t *stage)

WTF? surely it was supposed to use the specular color

Global R_StageLighting (const mBspSurface_t *surf, const materialStage_t *stage)

fix it and enable it back for r_materials 1

Global R_StageVertex (const mBspSurface_t *surf, const materialStage_t *stage, const vec3_t in, vec3_t out)

implement this

Global R_UpdateLightList (entity_t *ent)

bad implementation – copying light pointers every frame is a very wrong idea

Replace this hack with something more legit (hack can cause bizarre stencil shadows if enabled)

what if origin is NOT inside aabb? then this estimate will not be conservative enough

clear caches when r_dynamic_lights cvar is changed OR always keep maximal # of static lights in the cache

Hack to avoid dropships being shadowed by lightclips placed at them. Should be removed once correct global illumination model is done

Global R_UpdateWeather (const char *cvarName, const char *oldValue, const char *newValue, void *data)

Some better way?

Global R_UseFramebuffer (const r_framebuffer_t *buf)

buf != &screenBuffer

Global RADAR_DeactivateRadarOverlay (void)

Is aircraft->radar cleared for crashed aircraft?

Global RandomMapAssemblyTest::testAssembly (const char *source, const unsigned int numRuns, const char *mapTheme, const char *mapAssembly)

the assemble thread sets a different seed

Global reservedTokens []

Use dichotomic search

Global RS_InitTree (const campaign_t *campaign, bool load)

Add a function to reset ALL research-stati to RS_NONE; -> to be called after start of a new game.

See also: CP_CampaignInit

Implement me

Global RS_LoadXML (xmlNode_t *parent)

this should be handled by the mail system

Global RS_MarkResearched (technology_t *tech, const base_t *base)

Base shouldn't be needed here - check RS_MarkResearchable() for that.

See also: RS_ResearchRun

Global RS_ParseTechnologies (const char *name, const char **text)

use cgi->Com_RegisterConstInt();

Global RS_RequirementsMet (const technology_t *tech, const base_t *base)

Add support for the "delay" value.

Global RS_ResearchRun (void)

Needs to check on the exact time that elapsed since the last check of the status.

See also: RS_MarkResearched

Returns: The amout of new researched technologies

Global RS_SaveXML (xmlNode_t *parent)

this should be handled by the mail system

Global RS_ScriptSanityCheck (void)

error++; Crafts still give errors - are there any definitions missing?

Global RT_AllCellsBelowAreFilled (const Routing &routing, const int actorSize, const pos3_t pos)

see CL_ActorMoveMouse

Global RunEffectForImplant (const fireDef_t &fd, character_t &chr, const implant_t &implant, const objDef_t &od, const itemEffect_t &effect)

perform tests

Global RunStrengthenImplant (character_t &chr, const implant_t &implant, const objDef_t &od)

perform tests

Global S_Init (void)

implement the volume change for already loaded sample chunks

Global SampleNormal (const lightinfo_t *l, const vec3_t pos, vec3_t normal)

Implement it (just clones the normal of nearest vertex for now)

Global SAVE_TRANSFER_ITEM

Remove: Fallback records for compatibility.

Global SCR_Init (void)

remove me - but this was an archive cvar once

File scriplib.cpp

Remove this and use parse.c

Global SEQ_Render2D (sequenceContext_t *context, bool backgroundObjects)

We need this check - but this does not work

use this for some nice line spacing

Global SEQ_Render3D (sequenceContext_t *context)

Models are not at the right position (relative to the node position). Maybe R_SetupFrustum erase matrix. Not a trivialous task.

Global sequences [MAX_SEQUENCES]

move it to cls?

Global shot_mock_s::self

incorrect actor facing or shotOrg, or bug in trace code?

Global SKILL_AWARD_SCALE

make these scripted in campaign definitions maybe

Global SL_BSPSlice (const TR_TILE_TYPE *model, float thickness, int scale, bool singleFile, bool multipleContour)

remove these values once the mins/maxs calculation works

Global SL_SliceTheWorld (const TR_TILE_TYPE *tile, const vec3_t mins, const vec3_t maxs, float stepsize, int scale, bool singleFile, bool multipleContour)

handle content flags

Global SP_civilian_target (Edict *ent)

These waypoints should be placeable by the human player (e.g. spawn a special particle on the waypoint) to direct the civilians to a special location

Global SP_misc_model (Edict *ent)

is fieldsize and forbidden list update really needed here?

Global SP_player_start (Edict *ent)

Wrong place here

Global SP_worldspawn (const localEntityParse_t *entData)

- make sun position/color vary based on local time at location?

Parse fog from worldspawn config

Global SplitBrush (const bspbrush_t *brush, uint16_t planenum, bspbrush_t **front, bspbrush_t **back)

Print brush and entnum either of the brush that was splitted or the plane that was used as splitplane

Print brush and entnum either of the brush that was split or the plane that was used as splitplane

Print brush and entnum either of the brush that was splitted or the plane that was used as splitplane

Global STANDARD_3D_ZOOM

these are currently duplicated - remove this defines here

Global STAT_GetExpenses_f (void)

should have something like CP_GetCurrentCampaign

Global STATS_Update_f (void)

This is very redundant with NAT_HandleBudget Investigate and clean up.

Global Step::checkWalkingDirections (const pathing_t *path)

falling_height should be replaced with an arbitrary max falling height based on the actor.

actor_stepup_height should be replaced with an arbitrary max stepup height based on the actor.

Global Step::flier

flier should return true if the actor can fly.

Global Step::hasLadderSupport

has_ladder_support should return true if 1) There is a ladder in the new cell in the specified direction or 2) There is a ladder in any direction in the cell below the new cell and no ladder in the new cell itself.

Global Step::hasLadderToClimb

has_ladder_climb should return true if 1) There is a ladder in the new cell in the specified direction.

Global Step::init ()

actor_height is currently the fixed height of a 1x1 actor. This needs to be adjusted to the actor's actual height.

Global StringToFilter (const char *s, ipfilter_t *f)

find out if this printf is needed. Passing nullptr as a player would have crashed anyway.

Global STRUCT_MEMORY_ALIGN

Remove it and use something from compiler

File sv_clientstub.cpp

Calls to functions not required by the dedicated server should be surrounded by the DEDICATED_ONLY macro.

Global SV_MapcycleAdd (const char *mapName, bool day, const char *gameType)

check for maps and valid gametypes here

See also: SV_MapcycleClear

Global SV_ModLoadObjModel (sv_model_t *mod, const byte *buffer, int bufferLength)

implement me

Global SV_ParallelSearch (MapInfo *map)

Maybe we also need to reduce the timeout value a bit every time it succeeds?

Global SV_Trace (const Line &traceLine, const AABB &box, const edict_t *passedict, int contentmask)

There is more than one world in case of a map assembly - use clip.trace.mapTile to get the correct one

Global Sys_TTYConsoleShow (void)

need to position the cursor if needed?

Global Sys_TTYDeleteCharacter (void)

there may be a way to find out if '\b' alone would work though

Global teammask_t

make this a byte

Global technology_s::delay

Number in days the system should wait until the tech is available for research. Starting from the first time all other dependencies have been fulfilled and counting only if a day has passed and they still are met.

Global technologyDescriptions_s::usedDescription

Check if we should set this in the function that updates the research_proposals? Currently it's only in RS_GetDescription.

Global TEST_F (CampaignTest, testAircraftHandling)

we should not assume that initial base has aircraft. It's a campaign parameter

Global TEST_F (UILevel2Test, RuntimeError)

when it is possible, we should check error message but ATM we only check it dont crash

Global TEST_F (UILevel2Test, InheritedConfunc)

extend the text with inherited confunc from window (and not only from component)

Global TEST_F (CampaignTest, testCampaignDateHandling)

fix magic number

Global TEST_F (UILevel2Test, Binding)

unfortunately we can't use "bindui" or "press" commands in tests.

Global TEST_F (RendererTest, CharacterAnimationFiles)

remove this hack - but ugvs are just not ready yet

remove this hack - alientank is just not ready yet

Global TEST_F (CampaignTest, testNation)

implement a check here

Global TEST_F (ParserTest, ParserCommonType)

V_POS

V_VECTOR

V_COLOR

V_STRING

V_TRANSLATION_STRING

V_LONGSTRING

Global TEST_F (GameTest, Shooting)

equip the soldier

set the input variables – gi.ReadFormat(format, &pos, &i, &firemode, &from);

do the shot – G_ClientShoot(player, ent, pos, i, firemode, &mock, true, from);

implement the test here - e.g. extend shot_mock_t

Global TEST_F (CampaignTest, testMarket)

implement a check here

Global TEST_ParseScript (const char *scriptName)

move it somewhere

Global Touch_Breakable (Edict *self, Edict *activator)

check that the actor is standing upon the breakable

Global Touch_HurtTrigger (Edict *self, Edict *activator)

Handle dazed via trigger_hurt

Global tr

move this into ccs_t or somewhere else

Global TR_BoxTrace (boxtrace_t &traceData, const Line &traceLine, const AABB &traceBox, const int headnode, const float fraction)

Would Interpolating traceData.end to traceData.fraction and passing traceData.fraction instead of 1.0 make this faster?

Global TR_CargoList (void)

implement UGV transfers

Global TR_ClipBoxToBrush (boxtrace_t *traceData, cBspBrush_t *brush, TR_LEAF_TYPE *leaf)

special case for axial

Global TR_FillEmployees (const base_t *srcBase, const base_t *destBase)

implement UGV transfers

Global TR_List_f (void)

: add ugv listing when they're implemented

Global TR_TestBoxInBrush (boxtrace_t *traceData, cBspBrush_t *brush)

special case for axial

Global TR_TransferEnd (transfer_t *transfer)

what if source base is lost? we won't be able to unhire transferred employees.

Global UFO_CampaignCheckEvents (void)

present a popup with possible orders like: return to base, attack the ufo, try to flee the rockets

See also: UFO_SearchAircraftTarget

Global UFO_GeoSelectUFO_f (void)

Move this popup from cp_popup and rebuild

Global UFO_SearchAircraftTarget (const campaign_t *campaign, aircraft_t *ufo, float maxDetectionRange=MAX_DETECTING_RANGE)

present a popup with possible orders like: return to base, attack the ufo, try to flee the rockets

Global UI_AbstractOption_GetFirstOption (uiNode_t *node)

check versionId and update cached data, and fire events

Global UI_AbstractOption_SortOptions (uiNode_t *node)

the sort option should do it itself

Global UI_AddListener (uiNode_t *node, const value_t *property, uiNode_t const *functionNode)

It is a hack, we should remove that

Global UI_AddListener (uiNode_t *node, const value_t *property, uiNode_t const *functionNode)

It is a hack, we should remove that

Global UI_AllocNode (const char *name, const char *type, bool isDynamic)