cp_research.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
 
#include "../../DateTime.h"
 
#define MAX_RESEARCHLIST 32
#define MAX_TECHNOLOGIES 256    
#define MAX_TECHLINKS 16    
#define MAX_DESCRIPTIONS 8  
 
#define TECH_INVALID -1 
 
#define ANTIMATTER_ITEM_ID "antimatter"

typedef enum researchStatus_s {
    RS_NONE,
    RS_RUNNING,
    RS_PAUSED,
    RS_FINISH
} researchStatus_t;

typedef enum researchType_s {
    RS_TECH,
    RS_WEAPON,
    RS_ARMOUR,
    RS_CRAFT,
    RS_CRAFTITEM,
    RS_BUILDING,
    RS_ALIEN,
    RS_UGV,
    RS_NEWS,
    RS_LOGIC
} researchType_t;
 
typedef enum requirementType_s {
    RS_LINK_TECH,
    RS_LINK_TECH_NOT,
    RS_LINK_ITEM,
    RS_LINK_ALIEN,
    RS_LINK_ALIEN_DEAD,
    RS_LINK_ALIEN_GLOBAL,
    RS_LINK_UFO,
    RS_LINK_ANTIMATTER,
    MAX_RS_LINKTYPES
} requirementType_t;
 
typedef struct requirement_s {
    requirementType_t type; 
    char* id;               
    union typelink_t {
        const struct technology_s* tech;
        const struct objDef_s* od;
        const struct teamDef_s* td;
        const struct aircraft_s* aircraft;
    } link;
    int amount;             
    int collected;          
} requirement_t;
 
typedef struct requirements_s {
    int numLinks;           
    requirement_t links[MAX_TECHLINKS];
} requirements_t;

typedef struct markResearched_s {
    bool markOnly[MAX_CAMPAIGNS];
    char* campaign[MAX_CAMPAIGNS];
    int numDefinitions;
} markResearched_t;

typedef enum {
    TECHMAIL_PRE,           
    TECHMAIL_RESEARCHED,    
 
    TECHMAIL_MAX
} techMailType_t;

typedef struct techMail_s {
    char* from;             
    const char* to;         
    const char* subject;    
    const char* date;       
    const char* icon;       
    const char* model;      
    bool read;              
} techMail_t;
 
typedef enum {
    MAILSENT_NONE,          
    MAILSENT_PROPOSAL,      
    MAILSENT_FINISHED,      
 
    MAILSENT_MAX
} mailSentType_t;
 
typedef struct technologyDescriptions_s {
    int numDescriptions;            
    int usedDescription;            
    char* text[MAX_DESCRIPTIONS];   
    char* tech[MAX_DESCRIPTIONS];   
} technologyDescriptions_t;

typedef struct technology_s {
    char* id;                       
    int idx;                        
    char* name;                     
    technologyDescriptions_t description;       
    technologyDescriptions_t preDescription;    
    researchType_t type;            
 
    struct technology_s* redirect;  
 
    requirements_t requireAND;      
    requirements_t requireOR;       
    bool statusCollected;           
 
    char* provides;                 
 
    float overallTime, time;        
    int delay;                      
 
    researchStatus_t statusResearch;    
    char* finishedResearchEvent;    
    bool announce;                  
 
    struct base_s* base;            
    int scientists;                 
 
    char* image;                    
    char* mdl;                      
 
    bool statusResearchable;        
 
    int produceTime;                
    mailSentType_t mailSent;        
    requirements_t requireForProduction;    
 
    class DateTime preResearchedDate;   
    class DateTime researchedDate;      
 
    markResearched_t markResearched;    
 
    /* Pedia info */
    struct pediaChapter_s* upChapter;   
    struct technology_s* upPrev;        
    struct technology_s* upNext;        
 
    techMail_t mail[TECHMAIL_MAX];      
    int numTechMails;                   
 
    struct technology_s* hashNext;
    struct technology_s* hashProvidedNext;
} technology_t;
 
#define RS_Collected_(tech) ((tech)->statusCollected)
 
void RS_InitStartup(void);
void RS_ResetTechs(void);
int RS_ResearchRun(void);
void RS_ParseTechnologies(const char* name, const char** text);
bool RS_IsResearched_idx(int techIdx);
bool RS_IsResearched_ptr(const technology_t* tech);
 
technology_t* RS_GetTechForItem(const objDef_t* item);
technology_t* RS_GetTechForTeam(const teamDef_t* team);
void RS_AddObjectTechs(void);
void RS_RequiredLinksAssign(void);
void RS_InitTree(const struct campaign_s* campaign, bool load);
const char* RS_GetDescription(technologyDescriptions_t* desc);
void RS_MarkCollected(technology_t* tech) __attribute__((nonnull));
void RS_MarkResearchable(const struct base_s* base, bool init = false);
bool RS_MarkStoryLineEventResearched(const char* techID);
void RS_ResearchFinish(technology_t* tech);
void RS_StopResearch(technology_t* tech);
void RS_MarkOneResearchable(technology_t* tech);
 
void RS_AssignScientist(technology_t* tech, struct base_s* base, Employee* employee = nullptr);
void RS_RemoveScientist(technology_t* tech, Employee* employee);
void RS_RemoveFiredScientist(struct base_s* base, Employee* employee);
void RS_RemoveScientistsExceedingCapacity(struct base_s* base);
 
technology_t* RS_GetTechByID(const char* id);
technology_t* RS_GetTechByProvided(const char* idProvided);
technology_t* RS_GetTechByIDX(int tech_idx);
technology_t* RS_GetTechWithMostScientists(const struct base_s* base);
int RS_GetTechIdxByName(const char* name);
int RS_CountScientistsInBase(const struct base_s* base);
bool RS_ScriptSanityCheck(void);
 
/* UFOpaedia function - but needs technology_t */
void UP_AircraftDescription(const technology_t* t);
void UP_UGVDescription(const struct ugv_s* ugvType);
 
void RS_CheckRequirements(void);
bool RS_RequirementsMet(const technology_t* tech, const struct base_s* base);