cp_campaign.h

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2025 UFO: Alien Invasion.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#pragma once
 
extern memPool_t* cp_campaignPool;
 
class Employee;
#define MAX_CAMPAIGNS   16
 
#include "../../DateTime.h"
#include "cp_cgame_callbacks.h"
#include "cp_alien_interest.h"
#include "cp_rank.h"
#include "cp_save.h"
#include "cp_parse.h"
#include "cp_event.h"
#include "cp_ufopedia.h"
#include "cp_research.h"
#include "cp_radar.h"
#include "cp_aircraft.h"
#include "cp_base.h"
#include "cp_employee.h"
#include "cp_transfer.h"
#include "cp_nation.h"
#include "cp_installation.h"
#include "cp_produce.h"
#include "cp_uforecovery.h"
#include "cp_airfight.h"
#include "cp_messageoptions.h"
#include "cp_alienbase.h"
#include "cp_market.h"
#include "cp_statistics.h"
#include "cp_component.h"
 
/* Maximum alien groups per alien team category */
#define MAX_ALIEN_GROUP_PER_CATEGORY    8
/* Maximum alien team category defined in scripts */
#define ALIENCATEGORY_MAX   64
#define MAX_PROJECTILESONGEOSCAPE 32

#define HOURS_PER_ONE_INTEREST              24

#define INITIAL_OVERALL_INTEREST            20
#define FINAL_OVERALL_INTEREST              400

#define DELAY_BETWEEN_MISSION_SPAWNING      12

#define EARLY_UFO_RUSH_INTEREST             50

#define NON_OCCURRENCE_PROBABILITY          0.75

typedef enum mapType_s {
    MAPTYPE_TERRAIN,
    MAPTYPE_CULTURE,
    MAPTYPE_POPULATION,
    MAPTYPE_NATIONS,
 
    MAPTYPE_MAX
} mapType_t;

typedef struct alienTeamGroup_s {
    int idx;            
    int categoryIdx;    
    int minInterest;    
    int maxInterest;    
    int minAlienCount;  
    int maxAlienCount;  
 
    const teamDef_t* alienTeams[MAX_TEAMS_PER_MISSION]; 
    const chrTemplate_t* alienChrTemplates[MAX_TEAMS_PER_MISSION];
    int numAlienTeams;      
} alienTeamGroup_t;

typedef struct alienTeamCategory_s {
    char id[MAX_VAR];           
    interestCategory_t missionCategories[INTERESTCATEGORY_MAX];     
    int numMissionCategories;                   
 
    linkedList_t* equipment;        
 
    alienTeamGroup_t alienTeamGroups[MAX_ALIEN_GROUP_PER_CATEGORY];     
    int numAlienTeamGroups;         
} alienTeamCategory_t;

typedef struct battleParam_s {
    struct mission_s* mission;
    alienTeamGroup_t* alienTeamGroup;   
    char* param;                
    char alienEquipment[MAX_VAR];       
    char civTeam[MAX_VAR];          
    bool day;               
    const char* zoneType;           
    int aliens, civilians;          
    struct nation_s* nation;        
    bool retriable;             
} battleParam_t;

typedef struct salary_s {
    int base[MAX_EMPL];
    int rankBonus[MAX_EMPL];
    int aircraftFactor;
    int aircraftDivisor;
    int baseUpkeep;
    float debtInterest;
} salary_t;

typedef struct campaign_s {
    int idx;                
    char id[MAX_VAR];           
    char name[MAX_VAR];         
    bool defaultCampaign;           
    int team;               
    char researched[MAX_VAR];       
    char soldierEquipment[MAX_VAR];     
    char equipment[MAX_VAR];        
    char market[MAX_VAR];           
    char asymptoticMarket[MAX_VAR];     
    const equipDef_t* marketDef;        
    const equipDef_t* asymptoticMarketDef;  
    char text[MAX_VAR];         
    char map[MAX_VAR];          
    int soldiers;               
    int scientists;             
    int workers;                
    int pilots;             
    int ugvs;               
    int credits;                
    int num;
    signed int difficulty;          
    float minhappiness;         
    int negativeCreditsUntilLost;       
    int maxAllowedXVIRateUntilLost;     
    bool visible;               
    class DateTime date;            
    int basecost;               
    char firstBaseTemplate[MAX_VAR];    
    bool finished;
    const campaignEvents_t* events;
    salary_t salaries;
    float produceRate;          
    float researchRate;         
    float healingRate;          
    float liquidationRate;          
    float componentRate;            
    int minMissions;            
    int maxMissions;            
    float ufoReductionRate;         
    float employeeRate;         
    int initialInterest;
    int alienBaseInterest;          
    linkedList_t* initialCraft;     
} campaign_t;
 
int CP_GetSalaryUpKeepBase(const salary_t* salary, const base_t* base);

typedef enum mapAction_s {
    MA_NONE,
    MA_NEWBASE,             
    MA_NEWINSTALLATION          
} mapAction_t;
 
typedef void (*missionSpawnFunction_t) (void);
typedef void (*missionResultFunction_t) (const struct missionResults_s* results);

typedef struct ccs_s {
    equipDef_t eMission;                    
    market_t eMarket;                   
 
    linkedList_t* missions;                 
 
    battleParam_t battleParameters;             
 
    int lastInterestIncreaseDelay;              
    int overallInterest;                    
    int interest[INTERESTCATEGORY_MAX];         
    int lastMissionSpawnedDelay;                
 
    int credits;                        
    int civiliansKilled;                    
    int aliensKilled;                   
    class DateTime date;                    
    bool startXVI;                      
    float timer;
    float frametime;
 
    struct {
        struct mission_s* selectedMission;          
        aircraft_t* selectedAircraft;           
        aircraft_t* selectedUFO;            
        aircraft_t* interceptAircraft;          
        aircraft_t* missionAircraft;            
    } geoscape;
 
    /* == misc == */
    mapAction_t mapAction;                  
    vec2_t newBasePos;                  
 
    /* how fast the game is running */
    int gameTimeScale;
    int gameLapse;
 
    /* already paid in this month? */
    bool paid;
 
    /* == employees == */
    /* A list of all phalanx employees (soldiers, scientists, workers, etc...) */
    linkedList_t* employees[MAX_EMPL];
 
    /* == technologies == */
    /* A list of all research-topics resp. the research-tree. */
    technology_t technologies[MAX_TECHNOLOGIES];
    int numTechnologies;
 
    /* == bases == */
    /* A list of _all_ bases ... even unbuilt ones. */
    base_t bases[MAX_BASES];
    int numBases;
 
    /* a list of all templates for building bases */
    baseTemplate_t baseTemplates[MAX_BASETEMPLATES];
    int numBaseTemplates;
 
    /* == aircraft == */
    linkedList_t* aircraft;
 
    /* == Alien bases == */
    linkedList_t* alienBases;
 
    /* == Nations == */
    linkedList_t* nations;
    int numNations;
 
    /* == Cities == */
    linkedList_t* cities;
    int numCities;
 
    /* Projectiles on geoscape (during fights) */
    aircraftProjectile_t projectiles[MAX_PROJECTILESONGEOSCAPE];
    int numProjectiles;
 
    /* == Transfers == */
    linkedList_t* transfers;
 
    /* UFO components. */
    components_t components[MAX_ASSEMBLIES];
    int numComponents;
 
    /* == stored UFOs == */
    linkedList_t* storedUFOs;
 
    /* Alien Team Package used during battle */
    alienTeamCategory_t alienCategories[ALIENCATEGORY_MAX];     
    int numAlienCategories;                     
 
    /* == ufopedia == */
    /* A list of all UFOpaedia chapters. */
    pediaChapter_t upChapters[MAX_PEDIACHAPTERS];
    /* Total number of UFOpaedia chapters */
    int numChapters;
    int numUnreadMails; 
 
    eventMail_t eventMails[MAX_EVENTMAILS]; 
    int numEventMails;  
 
    campaignEvents_t campaignEvents[MAX_CAMPAIGNS];         
    int numCampaignEventDefinitions;                
 
    campaignTriggerEvent_t campaignTriggerEvents[MAX_CAMPAIGN_TRIGGER_EVENTS];
    int numCampaignTriggerEvents;
 
    /* == buildings in bases == */
    /* A list of all possible unique buildings. */
    building_t buildingTemplates[MAX_BUILDINGS];
    int numBuildingTemplates;
    /*  A list of the building-list per base. (new buildings in a base get copied from buildingTypes) */
    building_t buildings[MAX_BASES][MAX_BUILDINGS];
    /* Total number of buildings per base. */
    int numBuildings[MAX_BASES];
 
    /* == installations == */
    /* A template for each possible installation with configurable values */
    installationTemplate_t installationTemplates[MAX_INSTALLATION_TEMPLATES];
    int numInstallationTemplates;
 
    /* A list of _all_ installations */
    linkedList_t* installations;
 
    /* UFOs on geoscape */
    aircraft_t ufos[MAX_UFOONGEOSCAPE];
    int numUFOs;    
 
    /* message categories */
    msgCategory_t messageCategories[MAX_MESSAGECATEGORIES];
    int numMsgCategories;
 
    /* entries for message categories */
    msgCategoryEntry_t msgCategoryEntries[NT_NUM_NOTIFYTYPE + MAX_MESSAGECATEGORIES];
    int numMsgCategoryEntries;
 
    /* == Ranks == */
    /* Global list of all ranks defined in medals.ufo. */
    rank_t ranks[MAX_RANKS];
    /* The number of entries in the list above. */
    int numRanks;
 
    /* cache for techdef technologies */
    technology_t* teamDefTechs[MAX_TEAMDEFS];
 
    /* cache for item technologies */
    technology_t* objDefTechs[MAX_OBJDEFS];
 
    campaign_t* curCampaign;            
    stats_t campaignStats;
 
    campaign_t campaigns[MAX_CAMPAIGNS];
    int numCampaigns;
 
    aircraft_t aircraftTemplates[MAX_AIRCRAFT];     
    int numAircraftTemplates;       
 
    missionSpawnFunction_t missionSpawnCallback;
    missionResultFunction_t missionResultCallback;
 
    linkedList_t* updateCharacters;
} ccs_t;
 
typedef struct {
    int x, y;
} screenPoint_t;
 
extern ccs_t ccs;
extern const int DETECTION_INTERVAL;
extern cvar_t* cp_missiontest;
 
#define MAX_CREDITS 10000000
 
#include "../cgame.h"
extern const cgame_import_t* cgi;
 
/* Campaign functions */
void CP_InitStartup(void);
campaign_t* CP_GetCampaign(const char* name);
void CP_CampaignInit(campaign_t* campaign, bool load);
void CP_ParseCampaignData(void);
void CP_ReadCampaignData(const campaign_t* campaign);
bool CP_IsRunning(void);
 
void CP_CampaignRun(campaign_t* campaign, float secondsSinceLastFrame);
void CP_CheckLostCondition(const campaign_t* campaign);
void CP_EndCampaign(bool won);
 
void CP_Shutdown(void);
void CP_ResetCampaignData(void);
 
void CP_StartSelectedMission(void);
 
/* Credits management */
bool CP_CheckCredits (int costs);
void CP_UpdateCredits(int credits);
 
bool CP_OnGeoscape(void);