cp_base.h

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 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.

*/

#ifndef CLIENT_CL_BASEMANGEMENT_H
#define CLIENT_CL_BASEMANGEMENT_H

#include "cp_aliencont.h"

#define MAX_BASES 8

#define MAX_BUILDINGS       32
#define MAX_BASETEMPLATES   5

#define MAX_BATTERY_DAMAGE  50
#define MAX_BASE_DAMAGE     100
#define MAX_BASE_SLOT       4

#define BASEMAP_SIZE_X      778.0
#define BASEMAP_SIZE_Y      672.0

/* see MAX_TILESTRINGS */
#define BASE_SIZE       5
#define MAX_BASEBUILDINGS   BASE_SIZE * BASE_SIZE

#define MAX_EMPLOYEES_IN_BUILDING 64

#define MAX_BLOCKEDFIELDS   4
#define MIN_BLOCKEDFIELDS   1

#define BASE_TILE_SIZE 512
#define BASE_TILE_UNITS (BASE_TILE_SIZE / UNIT_SIZE)
#define BASE_MAX_WORLDLEVEL 6

#define B_GetBaseIDX(base) ((ptrdiff_t)((base) - ccs.bases))
#define B_GetBuildingIDX(base, building) ((ptrdiff_t)((building) - ccs.buildings[base->idx]))

#define B_BuildingSetUsed(usedArray, buildingIDX) { (usedArray)[buildingIDX] = qtrue; }

#define B_BuildingGetUsed(usedArray, buildingIDX) ((usedArray)[buildingIDX])

typedef enum {
    BASE_NOT_USED,
    BASE_UNDER_ATTACK,  
    BASE_WORKING,       
    BASE_DESTROYED      
} baseStatus_t;

typedef enum {
    BA_NONE,
    BA_NEWBUILDING,     
    BA_MAX
} baseAction_t;

typedef enum {
    B_STATUS_NOT_SET,           
    B_STATUS_UNDER_CONSTRUCTION,    
    B_STATUS_CONSTRUCTION_FINISHED, 
    /* and building needs workers */
    B_STATUS_WORKING,           
    B_STATUS_DOWN               
} buildingStatus_t;

typedef enum {
    B_MISC,         
    B_LAB,          
    B_QUARTERS,     
    B_STORAGE,      
    B_WORKSHOP,     
    B_HOSPITAL,     
    B_HANGAR,       
    B_ALIEN_CONTAINMENT,    
    B_SMALL_HANGAR,     
    B_POWER,        
    B_COMMAND,      
    B_ANTIMATTER,       
    B_ENTRANCE,     
    B_DEFENCE_MISSILE,      
    B_DEFENCE_LASER,        
    B_RADAR,            
    MAX_BUILDING_TYPE
} buildingType_t;

typedef enum {
    CAP_ALIENS,     
    CAP_AIRCRAFT_SMALL, 
    CAP_AIRCRAFT_BIG,   
    CAP_EMPLOYEES,      
    CAP_ITEMS,      
    CAP_LABSPACE,       
    CAP_WORKSPACE,      
    CAP_ANTIMATTER,     
    MAX_CAP
} baseCapacities_t;

typedef struct cap_maxcur_s {
    int max;        
    int cur;        
} capacities_t;

typedef struct building_s {
    int idx;                
    struct building_s *tpl; 
    struct base_s *base;    
    char *id;
    char *name;         
    char *image, *mapPart, *pedia;

    char *needs;        
    int fixCosts, varCosts;

    float level;

    int timeStart, buildTime;

    buildingStatus_t buildingStatus;    
    qboolean visible;   
    char onConstruct[MAX_VAR];
    char onAttack[MAX_VAR];
    char onDestroy[MAX_VAR];

    int maxCount;       
    vec2_t pos;         
    qboolean mandatory;

    int maxEmployees;

    buildingType_t buildingType;    
    technology_t *tech;             
    struct building_s *dependsBuilding; 
    int capacity;       
} building_t;

typedef struct baseBuildingTile_s {
    building_t *building;   
    qboolean    blocked;    
    /* These are only used for baseTemplates: */
    int posX;   
    int posY;   
} baseBuildingTile_t;

typedef struct baseWeapon_s {
    /* int idx; */
    aircraftSlot_t slot;    
    aircraft_t *target;     
    qboolean autofire;      
} baseWeapon_t;

typedef struct base_s {
    int idx;                    
    char name[MAX_VAR];         
    baseBuildingTile_t map[BASE_SIZE][BASE_SIZE];   
    qboolean founded;   
    vec3_t pos;     
    qboolean hasBuilding[MAX_BUILDING_TYPE];

    linkedList_t *aircraft;
    aircraft_t *aircraftCurrent;        
    baseStatus_t baseStatus; 
    float alienInterest;    
    struct radar_s radar;

    aliensCont_t alienscont[MAX_ALIENCONT_CAP]; 
    capacities_t capacities[MAX_CAP];       
    equipDef_t storage; 
    inventory_t bEquipment; 
    baseWeapon_t batteries[MAX_BASE_SLOT];  
    int numBatteries;
    baseWeapon_t lasers[MAX_BASE_SLOT];     
    int numLasers;

    qboolean selected;      
    building_t *buildingCurrent; 
} base_t;

typedef struct baseTemplate_s {
    char* id;           
    baseBuildingTile_t buildings[MAX_BASEBUILDINGS]; 
    int numBuildings;       
} baseTemplate_t;

void B_UpdateBaseData(void);
int B_CheckBuildingConstruction(building_t *b, base_t* base);
float B_GetMaxBuildingLevel(const base_t* base, const buildingType_t type);
void B_ParseBuildings(const char *name, const char **text, qboolean link);
void B_ParseBaseTemplate(const char *name, const char **text);
void B_BaseResetStatus(base_t* const base);
building_t *B_GetBuildingInBaseByType(const base_t* base, buildingType_t type, qboolean onlyWorking);
building_t *B_GetBuildingTemplate(const char *buildingName);
const baseTemplate_t *B_GetBaseTemplate(const char *baseTemplateName);
buildingType_t B_GetBuildingTypeByBuildingID(const char *buildingID);

extern vec2_t newBasePos;

void B_InitStartup(void);

/* base functions */
void B_NewBases(void);
void B_SetUpBase(base_t* base, vec2_t pos);
base_t* B_GetBaseByIDX(int baseIdx);
base_t* B_GetFoundedBaseByIDX(int baseIdx);
void B_SelectBase(const base_t *base);
void B_UpdateBaseCount(void);
int B_GetFoundedBaseCount(void);
void B_Destroy(base_t *base);

base_t *B_GetFirstUnfoundedBase(void);
base_t *B_GetCurrentSelectedBase(void);
void B_SetCurrentSelectedBase(const base_t *base);

qboolean B_AssembleMap(const base_t *base);

/* building functions */
buildingType_t B_GetBuildingTypeByCapacity(baseCapacities_t cap);

building_t* B_GetNextBuilding(const base_t *base, building_t *lastBuilding);
building_t* B_GetNextBuildingByType(const base_t *base, building_t *lastBuilding, buildingType_t buildingType);
void B_BuildingStatus(const base_t* base, const building_t* building);
qboolean B_CheckBuildingTypeStatus(const base_t* const base, buildingType_t type, buildingStatus_t status, int *cnt);
qboolean B_GetBuildingStatus(const base_t* const base, const buildingType_t type);
void B_SetBuildingStatus(base_t* const base, const buildingType_t type, qboolean newStatus);
qboolean B_CheckBuildingDependencesStatus(const base_t* const base, const building_t* building);

building_t* B_SetBuildingByClick(base_t *base, const building_t const *buildingTemplate, int row, int col);
void B_MarkBuildingDestroy(base_t* base, building_t* building);
qboolean B_BuildingDestroy(base_t* base, building_t* building);

building_t *B_GetFreeBuildingType(buildingType_t type);
int B_GetNumberOfBuildingsInBaseByTemplate(const base_t *base, const building_t *type);
int B_GetNumberOfBuildingsInBaseByBuildingType(const base_t *base, const buildingType_t type);

void B_BuildingOpenAfterClick(const base_t *base, const building_t *building);
void B_ResetBuildingCurrent(base_t* base);

/* storage functions */
qboolean B_ItemIsStoredInBaseStorage(const objDef_t *obj);
qboolean B_BaseHasItem(const base_t *base, const objDef_t *item);
int B_ItemInBase(const objDef_t *item, const base_t *base);

int B_AddToStorage(base_t* base, const objDef_t *obj, int amount);

/* aircraft functions */
void B_AircraftReturnedToHomeBase(aircraft_t* aircraft);
void B_DumpAircraftToHomeBase(aircraft_t *aircraft);

/* capacity functions */
void B_UpdateBaseCapacities(baseCapacities_t cap, base_t *base);
qboolean B_UpdateStorageAndCapacity(base_t* base, const objDef_t *obj, int amount, qboolean reset, qboolean ignorecap);
baseCapacities_t B_GetCapacityFromBuildingType(buildingType_t type);
void B_ResetAllStatusAndCapacities(base_t *base, qboolean firstEnable);
void B_UpdateStorageCap(base_t *base);

void B_RemoveAircraftExceedingCapacity(base_t* base, buildingType_t buildingType);
void B_RemoveItemsExceedingCapacity(base_t *base);
void B_RemoveAntimatterExceedingCapacity(base_t *base);

int B_FreeCapacity(const base_t *base, baseCapacities_t cap);

/* menu functions */
void B_BaseMenuInit(const base_t *base);
void B_DrawBuilding(base_t* base, building_t* building);

/* antimatter */
int B_AntimatterInBase(const base_t *base);
void B_ManageAntimatter(base_t *base, int amount, qboolean add);

/* savesystem */
void B_SaveBaseSlotsXML(const baseWeapon_t *weapons, const int numWeapons, mxml_node_t *p);
int B_LoadBaseSlotsXML(baseWeapon_t* weapons, int numWeapons, mxml_node_t *p);
qboolean B_SaveStorageXML(mxml_node_t *parent, const equipDef_t equip);
qboolean B_LoadStorageXML(mxml_node_t *parent, equipDef_t *equip);

/* other */
qboolean B_ScriptSanityCheck(void);
int B_GetInstallationLimit(void);

/* functions that checks whether the buttons in the base menu are useable */
qboolean BS_BuySellAllowed(const base_t* base);
qboolean AIR_AircraftAllowed(const base_t* base);
qboolean RS_ResearchAllowed(const base_t* base);
qboolean PR_ProductionAllowed(const base_t* base);
qboolean E_HireAllowed(const base_t* base);
qboolean AC_ContainmentAllowed(const base_t* base);
qboolean HOS_HospitalAllowed(const base_t* base);

#endif /* CLIENT_CP_BASE_H */