unit.h

Go to the documentation of this file.

/* Definitions relating to units in Xconq.
   Copyright (C) 1987-1989, 1991-2000 Stanley T. Shebs.
   Copyright (C) 2004-2005 Eric A. McDonald.

Xconq 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, or (at your option)
any later version.  See the file COPYING.  */

#include "parambox.h"

/* Advanced unit support. */

extern short default_size; 
extern short default_usedcells; 
extern short default_maxcells; 
extern long default_population; 

/* Forward declarations of various structs. */
struct a_unit;
struct a_unit_extras;
struct a_unit_view;

typedef struct a_unit {
    short type;                         
    int id;                             
    char *name;                         
    int number;                         
    struct a_unit_view *uview;          
    struct a_image_family *imf;         
    char *image_name;                   
    short x;                            
    short y;                            
    short z;                            
    struct a_side *side;                
    struct a_side *origside;            
    short hp;                   
    short hp2;                  
    short cp;                   
    short cxp;                  
    short morale;               
    struct a_unit *transport;   
    SideMask tracking;          
    long *supply;               
    short s_flow;               
    short s_conn;       
    short *tooling;     
    short *opinions;    
    struct a_actorstate *act;           
    struct a_plan *plan;                
    struct a_unit_extras *extras;       
    char *aihook;               
    /* Following slots are never saved. */
    struct a_unit *occupant;    
    struct a_unit *nexthere;    
    struct a_unit *prev;        
    struct a_unit *next;        
    struct a_unit *unext;       
    short prevx;                
    short prevy;                
    Obj *transport_id;          
                                /* (transport_id should be tmp array instead) */
    short flags;                
    /* (should make optional in UnitExtras?) */
    short size;                 
    short reach;                
    short usedcells;            
    short maxcells;             
    short curadvance;           
    long population;            
    short *production;          
    short cp_stash;        
    short researchdone;    
    short busy;     
    int creation_id;            
} Unit;

typedef struct a_unit_extras {
    short point_value;          
    short appear;               
    short appear_var_x;         
    short appear_var_y;         
    short disappear;            
    short priority;             
    Obj *sym;                   
    Obj *sides;                 
} UnitExtras;

typedef struct a_unit_view {
    short observer;             
    short type;                 
    short siden;                
    char *name;                 
    struct a_image_family *imf; 
    char *image_name;           
    short size;                 
    short x;                    
    short y;                    
    short complete;     
    short date;         
    int id;             
    struct a_unit *unit;            
    struct a_unit_view *transport;  
    struct a_unit_view *occupant;   
    struct a_unit_view *nexthere;   
    struct a_unit_view *nextinhash; 
    struct a_unit_view *vnext;      
} UnitView;

/* Unit parameter box. */
struct ParamBoxUnit : public ParamBox {
    Unit *unit;
    ParamBoxUnit() { pboxtype = PBOX_TYPE_UNIT; unit = NULL; }
};

/* "Unit at" parameter box. */
struct ParamBoxUnitAt : public ParamBoxUnit {
    int x, y;
    ParamBoxUnitAt() : ParamBoxUnit() {
        pboxtype = PBOX_TYPE_UNIT_AT;
        x = -1;  y = -1;
    }
};

/* Unit-unit parameter box. */
struct ParamBoxUnitUnit : public ParamBox {
    Unit *unit1, *unit2;
    ParamBoxUnitUnit() { 
        pboxtype = PBOX_TYPE_UNIT_UNIT;
        unit1 = NULL;
        unit2 = NULL;
    }
};

/* Unit-side parameter box. */
struct ParamBoxUnitSide : public ParamBoxUnit {
    Side *side;
    ParamBoxUnitSide() : ParamBoxUnit() {
        pboxtype = PBOX_TYPE_UNIT_SIDE;
        side = NULL;
    }
};

/* SeerNode is an useful struct for tracking who sees clearly,
   and who doesn't. */

typedef struct a_seer_node {
    Unit *seer;
    int mistakes;
} SeerNode;

/* Parameter boxen related to seers. */

struct ParamBoxUnitSideSeers : public ParamBoxUnitSide {
    SeerNode *seers;
    ParamBoxUnitSideSeers() : ParamBoxUnitSide () {
        pboxtype = PBOX_TYPE_UNIT_SIDE_SEERS;
        seers = NULL;
    }
    virtual ~ParamBoxUnitSideSeers() { seers = NULL; }
};

struct ParamBoxUnitUnitSeers : public ParamBoxUnitUnit {
    SeerNode *seers;
    ParamBoxUnitUnitSeers() : ParamBoxUnitUnit () {
        pboxtype = PBOX_TYPE_UNIT_UNIT_SEERS;
        seers = NULL;
    }
    virtual ~ParamBoxUnitUnitSeers() { seers = NULL; }
};

/* The global linked list of all unit views. */

extern UnitView *viewlist;

/* Some convenient macros. */


#define for_all_units(v)  \
    for (v = unitlist; v != NULL; v = v->unext)

#define for_all_side_units(s,v) \
    for (v = (s)->unithead->next; v != (s)->unithead; v = v->next)

#define for_all_occupants(u1,v) \
  for (v = (u1)->occupant; v != NULL; v = v->nexthere)

#define for_all_occs_with_occs(u,var)  \
  for ((var) = (u)->occupant; \
       (var) != NULL && (var) != (u)->nexthere; \
         (var) = ((var)->occupant != NULL ? \
                        (var)->occupant : \
                      ((var)->nexthere != NULL ? \
                        (var)->nexthere : \
                      ((var)->transport != NULL && \
                        (var)->transport->nexthere != NULL ? \
                        (var)->transport->nexthere : \
                      ((var)->transport != NULL && \
                        (var)->transport->transport != NULL && \
                        (var)->transport->transport->nexthere != NULL ? \
                        (var)->transport->transport->nexthere : NULL)))))

#define is_unit(unit) ((unit) != NULL && is_unit_type((unit)->type))

#define alive(unit) ((unit)->hp > 0)

#define indep(unit) ((unit)->side == indepside)

#define completed(unit) \
  ((unit)->cp >= u_cp((unit)->type))

#define unit_alt(unit) (((unit)->z & 1) == 0 ? ((unit)->z >> 1) : 0)

#define unit_conn(unit) (((unit)->z & 1) == 1 ? ((unit)->z >> 1) : NONTTYPE)

#define in_play(unit) \
  (is_unit(unit) && alive(unit) && inside_area((unit)->x, (unit)->y))

#define is_active(unit) (in_play(unit) && completed(unit))

#define is_located_at(unit,x,y) (in_play(unit) && (unit)->x == wrapx(x) && (unit)->y == (y))

#define was_located_at(unit,x,y) (is_unit(unit) && (unit)->prevx == wrapx(x) && (unit)->prevy == (y))

#define side_tracking_unit(side,unit) (side_in_set((side), (unit)->tracking))

#define unit_opinion(unit,side)  \
  ((unit)->opinions != NULL ? x_opinion((unit)->opinions[side_number(side)]) : 0)

#define unit_courage(unit,side)  \
  ((unit)->opinions != NULL ? x_courage((unit)->opinions[side_number(side)]) : 0)

#define x_opinion(val) (((val) & 0xff) - 128)

#define x_courage(val) (((val) >> 8) & 0xff)

#define s_opinion(val,val2) (((val) & ~0xff) | (val2 + 128))

#define s_courage(val,val2) (((val) & ~0xff00) | (val2 << 8))

/* These return a percentage value. */

#define supply_inflow(unit) ((unit)->s_flow / 163)

#define supply_connectedness(unit) ((unit)->s_conn / 254)

/* (could use bit fields in struct I suppose...) */

#define DETONATE_FLAG_BIT 0

#define was_detonated(unit) ((unit)->flags & (1 << DETONATE_FLAG_BIT))

#define set_was_detonated(unit, v) \
  ((v) ? ((unit)->flags |= 1 << DETONATE_FLAG_BIT) \
   : ((unit)->flags &= ~(1 << DETONATE_FLAG_BIT)))

#define unit_point_value(unit) ((unit)->extras ? (unit)->extras->point_value : -1)

#define unit_appear_turn(unit) ((unit)->extras ? (unit)->extras->appear : -1)

#define unit_appear_var_x(unit) ((unit)->extras ? (unit)->extras->appear_var_x : -1)

#define unit_appear_var_y(unit) ((unit)->extras ? (unit)->extras->appear_var_y : -1)

#define unit_disappear_turn(unit) ((unit)->extras ? (unit)->extras->disappear : -1)

#define unit_extra_priority(unit) ((unit)->extras ? (unit)->extras->priority : -1)

#define unit_symbol(unit) ((unit)->extras ? (unit)->extras->sym : lispnil)

#define unit_sides(unit) ((unit)->extras ? (unit)->extras->sides : lispnil)

#define unit_doctrine(unit)  \
  ((unit)->side->udoctrine[(unit)->type])

#define construction_run_doctrine(unit,u2) \
  (unit_doctrine(unit)->construction_run[u2])

#define unit_side_treasury(unit) \
  ((unit)->side->treasury)

/* A sortable vector of units, generally useful. */

enum sortkeys {
    bynothing,                  
    bytype,                     
    byname,                     
    byactorder,         
    bylocation,                 
    byside,                     
    numsortkeytypes     
};

#define MAXSORTKEYS 5

typedef struct a_unitvectorentry {
    Unit *unit;         
    int flag;           
} UnitVectorEntry;

typedef struct a_unitvector {
    int size;                               
    int numunits;                           
    enum sortkeys sortkeys[MAXSORTKEYS];    
    UnitVectorEntry units[1];               
} UnitVector;

/* \note (should check args?) */
#define unit_in_vector(uvec,ix) ((uvec)->units[ix].unit)

#undef  DEF_ACTION
#define DEF_ACTION(name,CODE,args,prepfn,netprepfn,dofn,checkfn,argdecl,doc) CODE,

typedef enum actiontype {

#include "action.def"

    NUMACTIONTYPES

} ActionType;

typedef struct a_actiondefn {
    ActionType typecode;        
    char *name;                 
    char *argtypes;             
} ActionDefn;

#define MAXACTIONARGS 4

typedef struct a_action {
    ActionType type;            
    int args[MAXACTIONARGS];    
    int actee;                  
    struct a_action *next;      
} Action;

typedef struct a_actorstate {
    short initacp;              
    short acp;                  
    short actualmoves;          
    Action nextaction;          
} ActorState;

#define valid(x) ((x) == A_ANY_OK)

#define has_pending_action(unit)  \
  ((unit)->act && (unit)->act->nextaction.type != ACTION_NONE)

#define acp_indep(unit) u_acp_independent((unit)->type)

#define has_acp_left(unit) \
  ((unit)->act && ((0 < (unit)->act->acp) || acp_indep(unit)))

/* What is the maximum amount of ACP an unit type can have? */
#define type_acp_max(u) ((u_acp_max(u) >= 0) ? u_acp_max(u) : u_acp(u)) 

/* All the definitions that govern planning. */

#undef  DEF_GOAL
#define DEF_GOAL(name,dname,GOALTYPE,args) GOALTYPE,

enum goaltype {

#include "goal.def"

    g_t_dummy
};
typedef enum goaltype GoalType;

typedef struct a_goaldefn {
    char *name;             
    char *display_name;     
    char *argtypes;         
} GoalDefn;

/* The goal structure proper. */

#define MAXGOALARGS 5

typedef struct a_goal {
    GoalType type;              
    short tf;                   
    Side *side;                 
    short args[MAXGOALARGS];    
} Goal;

#undef  DEF_TASK
#define DEF_TASK(name,dname,CODE,argtypes,dofn,createfn,setfn,netsetfn,pushfn,netpushfn,argdecl) CODE,

typedef enum a_tasktype {

#include "task.def"

    NUMTASKTYPES
} TaskType;

typedef enum a_taskoutcome {
  TASK_UNKNOWN,         
  TASK_FAILED,          
  TASK_IS_INCOMPLETE,   
  TASK_PREPPED_ACTION,  
  TASK_IS_COMPLETE      
} TaskOutcome;

#define MAXTASKARGS 6

typedef struct a_task {
    TaskType type;              
    int args[MAXTASKARGS];      
    short execnum;              
    short retrynum;             
    struct a_task *next;        
} Task;

typedef struct a_taskdefn {
    char *name;                 
    char *display_name; 
    char *argtypes;             
    TaskOutcome (*exec)(Unit *unit, Task *task); 
} TaskDefn;

#define is_task_type(x) (between(0, (x), NUMTASKTYPES - 1))

#undef  DEF_PLAN
#define DEF_PLAN(name,CODE) CODE,

typedef enum plantype {

#include "plan.def"

    NUMPLANTYPES
} PlanType;

typedef struct a_plan {
    PlanType type;                              
    short creation_turn;                        
    short initial_turn;                         
    short final_turn;                           
    short asleep;                                       
    short reserve;                                      
    short delayed;                                      
    short waitingfortasks;                      
    short aicontrol;                            
    short supply_alarm;                         
    short supply_is_low;                        
    short waitingfortransport;          
    struct a_goal *maingoal;                    
    struct a_goal *formation;                   
    struct a_task *tasks;                       
    /* Not saved/restored. (little value, some trouble to do) */
    struct a_unit *funit;                       
    Action lastaction;                          
    short lastresult;                           
    Task last_task;                             
    TaskOutcome last_task_outcome;      
    short execs_this_turn;                      
} Plan;

#define for_all_tasks(plan,task)  \
  for (task = (plan)->tasks; task != NULL; task = task->next)

#define ai_controlled(unit)  \
  ((unit)->plan && (unit)->plan->aicontrol && side_has_ai(unit->side))

/* Global unit variables. */

extern Unit *unitlist;
extern Unit *tmpunit;

extern int numunits;
extern int numliveunits;

extern enum sortkeys tmpsortkeys[];


/* \brief Action definition array. */
extern ActionDefn actiondefns[];

extern GoalDefn goaldefns[];

extern TaskDefn taskdefns[];

extern char *plantypenames[];

/* Declarations of unit-related functions that do not change the kernel state. 
Those that actually do something have been moved to kernel.h. */

/* Testable conditions etc. */

extern int side_owns_occupant_of_unit(Side *side, Unit *unit);
extern int side_owns_viewer_in_unit(Side *side, Unit *unit);
extern int type_can_occupy_cell(int u, int x, int y);
extern int side_thinks_type_can_occupy_cell(Side *side, int u, int x, int y);
extern int type_can_occupy_empty_cell(int u, int x, int y);
extern int type_can_occupy_terrain(int u, int t);
extern int can_occupy_cell_without(Unit *unit, int x, int y, Unit *unit3);
extern int type_can_occupy_cell_without(int u, int x, int y, Unit *unit3);
extern int side_can_put_type_at(Side *side, int u, int x, int y);
extern int side_can_put_type_at_without(Side *side, int u, int x, int y, Unit *unit);
extern int side_thinks_it_can_put_type_at(Side *side, int u, int x, int y);
extern int side_thinks_it_can_put_type_at_without(Side *side, int u, int x, int y, Unit *unit);
extern int can_occupy(Unit *unit, Unit *transport);
extern int type_can_occupy(int u, Unit *transport);
extern int side_thinks_type_can_occupy(Side *side, int u, UnitView *transport);
extern int type_can_occupy_without(int u, Unit *transport, Unit *unit);
extern int side_thinks_type_can_occupy_without(int u, UnitView *transport, Unit *unit);
extern int type_can_occupy_empty_type(int u, int u2);
extern int type_can_have_occs(int u);
extern int new_unit_allowed_on_side(int u, Side *side);
extern int unit_allowed_on_side(Unit *unit, Side *side);
extern int num_sides_allowed(int u);
extern int type_allowed_on_side(int u, Side *side);
extern int type_ever_available(int u, Side *side);
extern int unit_trusts_unit(Unit *unit1, Unit *unit2);
extern int type_survives_in_cell(int u, int nx, int ny);
extern int type_survives_in_terrain(int u, int t);
extern int can_build(Unit *unit);
extern int type_can_build(int u, Side *side);
extern int can_move(Unit *unit);
extern int can_extract_at(Unit *unit, int x, int y, int *mp);
extern int can_load_at(Unit *unit, int x, int y, int *mp);
extern int can_develop(Unit *unit);
extern int type_can_develop(int u);
extern int can_change_type(Unit *unit);
extern int can_change_type_to(Unit *unit, int u2);
extern int could_change_type(int u);
extern int could_change_type_to(int u, int u2);
#define could_auto_upgrade_to(u,u2) ((u2) == u_auto_upgrade_to(u))
extern int can_disband(Unit *unit);
extern int type_can_disband(int u);
extern int side_can_disband(Side *side, Unit *unit);
extern int can_add_terrain(Unit *unit);
extern int type_can_add_terrain(int u);
extern int can_remove_terrain(Unit *unit);
extern int type_can_remove_terrain(int u);
extern int can_build_attackers(Side *side, int u);
extern int can_build_defenders(Side *side, int u);
extern int can_build_explorers(Side *side, int u);
extern int can_build_colonizers(Side *side, int u);
extern int can_build_facilities(Side *side, int u);
extern int can_build_or_help(Unit *unit);
extern int can_research(Unit *unit);
extern int can_produce(Unit *unit);
extern int total_production(Unit *unit, int m);
extern int base_production(Unit *unit, int m);
extern int total_consumption(Unit *unit, int m);
extern int base_consumption(Unit *unit, int m);
extern int survival_time(Unit *unit);
extern int will_not_move(Unit *unit);
extern int needs_material_to_move(Unit *unit, int m);
extern int needs_material_to_survive(Unit *unit, int m);
extern int operating_range_best(int u);
extern int operating_range_worst(int u);
extern int real_operating_range_best(Unit *unit);
extern int real_operating_range_worst(Unit *unit);
extern int can_build_type(Unit *unit, int u2);
extern int can_develop_or_build_type(Unit *unit, int u2);
extern int unit_can_build_type_at(Unit *unit, int u2, int x, int y);
extern int unit_can_build_type(Unit *unit, int u2);
extern int type_can_build_type(int u, Side *side, int u2);

extern Unit *incomplete_build_target(Unit *unit);

#if 0
extern int moves_till_low_supplies(Unit *unit);
extern int num_occupants(Unit *unit);
extern int num_units_at(int x, int y);
#endif

extern int see_chance(int u, int u2, int dist);
extern int see_chance(Unit *seer, Unit *tosee);

/* Unit names and designations. */

extern char *unit_desig(Unit *unit);
extern char *unit_desig_no_loc(Unit *unit);
extern char *utype_name_n(int u, int n);
extern char *shortest_unique_name(int u);
extern char *shortest_generic_name(int u);
extern char *actorstate_desig(struct a_actorstate *as);

/* Unit locators. */

extern Unit *find_unit(int n);
extern Unit *find_unit_dead_or_alive(int n);
extern Unit *find_unit_by_name(char *nm);
extern Unit *find_unit_by_number(int nb);
extern Unit *find_unit_by_symbol(Obj *sym);

/* Unit vector manipulating functions. Declared here rather than in kernel.h 
since they also are used in the interfaces. */

extern UnitVector *make_unit_vector(int initsize);
extern void clear_unit_vector(UnitVector *vec);
extern UnitVector *add_unit_to_vector(UnitVector *vec, Unit *unit, int flag);
extern void remove_unit_from_vector(UnitVector *vec, Unit *unit, int pos);
extern void sort_unit_vector(UnitVector *vec);

/* Used in mknames.c. */

extern void sort_units(int byidonly);

/* Turn init code - does not really belong here. */

extern void check_all_units(void);

#undef  DEF_ACTION
#define DEF_ACTION(name,code,args,prepfn,netprepfn,dofn,CHECKFN,ARGDECL,doc)  \
  extern int CHECKFN ARGDECL;

#include "action.def"

#undef  DEF_TASK
#define DEF_TASK(name,dname,code,argtypes,dofn,CREATEFN,setfn,netsetfn,pushfn,netpushfn,ARGDECL)  \
  extern Task *CREATEFN ARGDECL;

#include "task.def"

---