2476/Doxygen/unittype_8h_source.html

 /*__            ___                 ***************************************

 /   \          /   \          Copyright (c) 1996-2020 Freeciv21 and Freeciv

 \_   \        /  __/          contributors. This file is part of Freeciv21.

  _\   \      /  /__     Freeciv21 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 3 of the  License,

        |                              or (at your option) any later version.

      _/     /\                  You should have received  a copy of the GNU

     /o)  (o/\ \_                General Public License along with Freeciv21.

     \_____/ /                     If not, see https://www.gnu.org/licenses/.

       \____/        ********************************************************/

 #pragma once


 // utility

 #include "bitvector.h"

 #include "shared.h"


 // common

 #include "fc_types.h"

 #include "name_translation.h"

 #include "requirements.h"


 struct ai_type;


 /* U_LAST is a value which is guaranteed to be larger than all

  * actual Unit_type_id values. It is used as a flag value;

  * it can also be used for fixed allocations to ensure able

  * to hold full number of unit types.

  * Used in the network protocol. */

 #define U_LAST MAX_NUM_UNIT_TYPES


 /* The largest distance a ruleset can allow a unit to paradrop.

  *

  * Remember to make sure that the field type of PACKET_RULESET_UNIT's

  * paratroopers_range field can transfer the new maximum if you increase

  * it.

  *

  * The top value is reserved in case a future Freeciv21 version wants to

  * implement "no maximum range". It could be used to signal that the unit

  * can paradrop anywhere. Note that the value below it is high enough to

  * give the same effect on all maps inside the current size limits.

  * (No map side can be larger than MAP_MAX_LINEAR_SIZE)

  */

 #define UNIT_MAX_PARADROP_RANGE (65535 - 1)


 // Used in the network protocol.

 #define SPECENUM_NAME unit_class_flag_id

 #define SPECENUM_VALUE0 UCF_TERRAIN_SPEED

 #define SPECENUM_VALUE0NAME N_("?uclassflag:TerrainSpeed")

 #define SPECENUM_VALUE1 UCF_TERRAIN_DEFENSE

 #define SPECENUM_VALUE1NAME N_("?uclassflag:TerrainDefense")

 #define SPECENUM_VALUE2 UCF_DAMAGE_SLOWS

 #define SPECENUM_VALUE2NAME N_("?uclassflag:DamageSlows")

 // Can occupy enemy cities

 #define SPECENUM_VALUE3 UCF_CAN_OCCUPY_CITY

 #define SPECENUM_VALUE3NAME N_("?uclassflag:CanOccupyCity")

 #define SPECENUM_VALUE4 UCF_BUILD_ANYWHERE

 #define SPECENUM_VALUE4NAME N_("?uclassflag:BuildAnywhere")

 #define SPECENUM_VALUE5 UCF_UNREACHABLE

 #define SPECENUM_VALUE5NAME N_("?uclassflag:Unreachable")

 // Can collect ransom from barbarian leader

 #define SPECENUM_VALUE6 UCF_COLLECT_RANSOM

 #define SPECENUM_VALUE6NAME N_("?uclassflag:CollectRansom")

 // Is subject to ZOC

 #define SPECENUM_VALUE7 UCF_ZOC

 #define SPECENUM_VALUE7NAME N_("?uclassflag:ZOC")

 // Cities can still work tile when enemy unit on it

 #define SPECENUM_VALUE8 UCF_DOESNT_OCCUPY_TILE

 #define SPECENUM_VALUE8NAME N_("?uclassflag:DoesntOccupyTile")

 // Can attack against units on non-native tiles

 #define SPECENUM_VALUE9 UCF_ATTACK_NON_NATIVE

 #define SPECENUM_VALUE9NAME N_("?uclassflag:AttackNonNative")

 // Kills citizens upon successful attack against a city

 #define SPECENUM_VALUE10 UCF_KILLCITIZEN

 #define SPECENUM_VALUE10NAME N_("?uclassflag:KillCitizen")


 #define SPECENUM_VALUE11 UCF_USER_FLAG_1

 #define SPECENUM_VALUE12 UCF_USER_FLAG_2

 #define SPECENUM_VALUE13 UCF_USER_FLAG_3

 #define SPECENUM_VALUE14 UCF_USER_FLAG_4

 #define SPECENUM_VALUE15 UCF_USER_FLAG_5

 #define SPECENUM_VALUE16 UCF_USER_FLAG_6

 #define SPECENUM_VALUE17 UCF_USER_FLAG_7

 #define SPECENUM_VALUE18 UCF_USER_FLAG_8

 #define SPECENUM_VALUE19 UCF_USER_FLAG_9

 #define SPECENUM_VALUE20 UCF_USER_FLAG_10

 #define SPECENUM_VALUE21 UCF_USER_FLAG_11

 #define SPECENUM_VALUE22 UCF_USER_FLAG_12


 // keep this last

 #define SPECENUM_COUNT UCF_COUNT

 #define SPECENUM_NAMEOVERRIDE

 #define SPECENUM_BITVECTOR bv_unit_class_flags

 #include "specenum_gen.h"


 #define UCF_LAST_USER_FLAG UCF_USER_FLAG_12

 #define MAX_NUM_USER_UCLASS_FLAGS (UCF_LAST_USER_FLAG - UCF_USER_FLAG_1 + 1)


 // Used in savegame processing and clients.

 #define SPECENUM_NAME unit_move_type

 #define SPECENUM_VALUE0 UMT_LAND

 #define SPECENUM_VALUE0NAME "Land"

 #define SPECENUM_VALUE1 UMT_SEA

 #define SPECENUM_VALUE1NAME "Sea"

 #define SPECENUM_VALUE2 UMT_BOTH

 #define SPECENUM_VALUE2NAME "Both"

 #include "specenum_gen.h"


 // Used in the network protocol.

 BV_DEFINE(bv_unit_classes, UCL_LAST);


 enum hut_behavior { HUT_NORMAL, HUT_NOTHING, HUT_FRIGHTEN };


 enum move_level { MOVE_NONE, MOVE_PARTIAL, MOVE_FULL };


 struct extra_type_list;

 struct unit_class_list;


 struct unit_class {

   Unit_Class_id item_number;

   struct name_translation name;

   bool ruledit_disabled;

   enum unit_move_type move_type;

   int min_speed;   // Minimum speed after damage and effects

   int hp_loss_pct; /* Percentage of hitpoints lost each turn not in city or

                       airbase */

   int non_native_def_pct;

   enum hut_behavior hut_behavior;

   bv_unit_class_flags flags;


   QVector<QString> *helptext;


   struct {

     enum move_level land_move;

     enum move_level sea_move;

   } adv;


   struct {

     struct extra_type_list *refuel_bases;

     struct extra_type_list *native_tile_extras;

     struct extra_type_list *bonus_roads;

     struct unit_class_list *subset_movers;

   } cache;

 };


 /* Unit "special effects" flags:

  * Note this is now an enumerated type, and not power-of-two integers

  * for bits, though unit_type.flags is still a bitfield, and code

  * which uses unit_has_type_flag() without twiddling bits is unchanged.

  * (It is easier to go from i to (1<<i) than the reverse.)

  * See data/classic/units.ruleset for documentation of their effects.

  * Change the array *flag_names[] in unittype.c accordingly.

  * Used in the network protocol.

  */

 #define SPECENUM_NAME unit_type_flag_id

 // Feel free to take this.

 #define SPECENUM_VALUE0 UTYF_RESERVED_2

 #define SPECENUM_VALUE0NAME N_("Reserved 2")

 // Unit has no ZOC

 #define SPECENUM_VALUE1 UTYF_NOZOC

 #define SPECENUM_VALUE1NAME N_("?unitflag:HasNoZOC")

 #define SPECENUM_VALUE2 UTYF_IGZOC

 // TRANS: unit type flag (rarely shown): "ignore zones of control"

 #define SPECENUM_VALUE2NAME N_("?unitflag:IgZOC")

 #define SPECENUM_VALUE3 UTYF_CIVILIAN

 #define SPECENUM_VALUE3NAME N_("?unitflag:NonMil")

 #define SPECENUM_VALUE4 UTYF_IGTER

 // TRANS: unit type flag (rarely shown): "ignore terrain"

 #define SPECENUM_VALUE4NAME N_("?unitflag:IgTer")

 #define SPECENUM_VALUE5 UTYF_ONEATTACK

 #define SPECENUM_VALUE5NAME N_("?unitflag:OneAttack")

 #define SPECENUM_VALUE6 UTYF_FIELDUNIT

 #define SPECENUM_VALUE6NAME N_("?unitflag:FieldUnit")

 /* autoattack: a unit will choose to attack this unit even if defending

  * against it has better odds. */

 #define SPECENUM_VALUE7 UTYF_PROVOKING

 #define SPECENUM_VALUE7NAME N_("?unitflag:Provoking")

 // Overrides unreachable_protects server setting

 #define SPECENUM_VALUE8 UTYF_NEVER_PROTECTS

 #define SPECENUM_VALUE8NAME N_("?unitflag:NeverProtects")

 // Does not include ability to found cities

 #define SPECENUM_VALUE9 UTYF_SETTLERS

 #define SPECENUM_VALUE9NAME N_("?unitflag:Settlers")

 #define SPECENUM_VALUE10 UTYF_DIPLOMAT

 #define SPECENUM_VALUE10NAME N_("?unitflag:Diplomat")

 // Can't leave the coast

 #define SPECENUM_VALUE11 UTYF_COAST_STRICT

 #define SPECENUM_VALUE11NAME N_("?unitflag:CoastStrict")

 // Can 'refuel' at coast - meaningless if fuel value not set

 #define SPECENUM_VALUE12 UTYF_COAST

 #define SPECENUM_VALUE12NAME N_("?unitflag:Coast")

 // upkeep can switch from shield to gold

 #define SPECENUM_VALUE13 UTYF_SHIELD2GOLD

 #define SPECENUM_VALUE13NAME N_("?unitflag:Shield2Gold")

 // Strong in diplomatic battles.

 #define SPECENUM_VALUE14 UTYF_SPY

 #define SPECENUM_VALUE14NAME N_("?unitflag:Spy")

 // Cannot attack vs non-native tiles even if class can

 #define SPECENUM_VALUE15 UTYF_ONLY_NATIVE_ATTACK

 #define SPECENUM_VALUE15NAME N_("?unitflag:Only_Native_Attack")

 // Only Fundamentalist government can build these units

 #define SPECENUM_VALUE16 UTYF_FANATIC

 #define SPECENUM_VALUE16NAME N_("?unitflag:Fanatic")

 // Losing this unit means losing the game

 #define SPECENUM_VALUE17 UTYF_GAMELOSS

 #define SPECENUM_VALUE17NAME N_("?unitflag:GameLoss")

 // A player can only have one unit of this type

 #define SPECENUM_VALUE18 UTYF_UNIQUE

 #define SPECENUM_VALUE18NAME N_("?unitflag:Unique")

 /* When a transport containing this unit disappears the game will try to

  * rescue units with this flag before it tries to rescue units without

  * it. */

 #define SPECENUM_VALUE19 UTYF_EVAC_FIRST

 #define SPECENUM_VALUE19NAME N_("?unitflag:EvacuateFirst")

 // Always wins diplomatic contests

 #define SPECENUM_VALUE20 UTYF_SUPERSPY

 #define SPECENUM_VALUE20NAME N_("?unitflag:SuperSpy")

 // Has no homecity

 #define SPECENUM_VALUE21 UTYF_NOHOME

 #define SPECENUM_VALUE21NAME N_("?unitflag:NoHome")

 // Cannot increase veteran level

 #define SPECENUM_VALUE22 UTYF_NO_VETERAN

 #define SPECENUM_VALUE22NAME N_("?unitflag:NoVeteran")

 // Gets double firepower against cities

 #define SPECENUM_VALUE23 UTYF_CITYBUSTER

 #define SPECENUM_VALUE23NAME N_("?unitflag:CityBuster")

 // Unit cannot be built (barb leader etc)

 #define SPECENUM_VALUE24 UTYF_NOBUILD

 #define SPECENUM_VALUE24NAME N_("?unitflag:NoBuild")

 /* Firepower set to 1 when EFT_DEFEND_BONUS applies

  * (for example, land unit attacking city with walls) */

 #define SPECENUM_VALUE25 UTYF_BADWALLATTACKER

 #define SPECENUM_VALUE25NAME N_("?unitflag:BadWallAttacker")

 // Firepower set to 1 and attackers x2 when in city

 #define SPECENUM_VALUE26 UTYF_BADCITYDEFENDER

 #define SPECENUM_VALUE26NAME N_("?unitflag:BadCityDefender")

 // Only barbarians can build this unit

 #define SPECENUM_VALUE27 UTYF_BARBARIAN_ONLY

 #define SPECENUM_VALUE27NAME N_("?unitflag:BarbarianOnly")

 // Feel free to take this.

 #define SPECENUM_VALUE28 UTYF_RESERVED_1

 #define SPECENUM_VALUE28NAME N_("Reserved 1")

 /* Unit can't be built in scenarios where founding new cities is prevented.

  */

 #define SPECENUM_VALUE29 UTYF_NEWCITY_GAMES_ONLY

 #define SPECENUM_VALUE29NAME N_("?unitflag:NewCityGamesOnly")

 // Can escape when killstack occours

 #define SPECENUM_VALUE30 UTYF_CANESCAPE

 #define SPECENUM_VALUE30NAME N_("?unitflag:CanEscape")

 // Can kill escaping units

 #define SPECENUM_VALUE31 UTYF_CANKILLESCAPING

 #define SPECENUM_VALUE31NAME N_("?unitflag:CanKillEscaping")


 #define SPECENUM_VALUE32 UTYF_USER_FLAG_1

 #define SPECENUM_VALUE33 UTYF_USER_FLAG_2

 #define SPECENUM_VALUE34 UTYF_USER_FLAG_3

 #define SPECENUM_VALUE35 UTYF_USER_FLAG_4

 #define SPECENUM_VALUE36 UTYF_USER_FLAG_5

 #define SPECENUM_VALUE37 UTYF_USER_FLAG_6

 #define SPECENUM_VALUE38 UTYF_USER_FLAG_7

 #define SPECENUM_VALUE39 UTYF_USER_FLAG_8

 #define SPECENUM_VALUE40 UTYF_USER_FLAG_9

 #define SPECENUM_VALUE41 UTYF_USER_FLAG_10

 #define SPECENUM_VALUE42 UTYF_USER_FLAG_11

 #define SPECENUM_VALUE43 UTYF_USER_FLAG_12

 #define SPECENUM_VALUE44 UTYF_USER_FLAG_13

 #define SPECENUM_VALUE45 UTYF_USER_FLAG_14

 #define SPECENUM_VALUE46 UTYF_USER_FLAG_15

 #define SPECENUM_VALUE47 UTYF_USER_FLAG_16

 #define SPECENUM_VALUE48 UTYF_USER_FLAG_17

 #define SPECENUM_VALUE49 UTYF_USER_FLAG_18

 #define SPECENUM_VALUE50 UTYF_USER_FLAG_19

 #define SPECENUM_VALUE51 UTYF_USER_FLAG_20

 #define SPECENUM_VALUE52 UTYF_USER_FLAG_21

 #define SPECENUM_VALUE53 UTYF_USER_FLAG_22

 #define SPECENUM_VALUE54 UTYF_USER_FLAG_23

 #define SPECENUM_VALUE55 UTYF_USER_FLAG_24

 #define SPECENUM_VALUE56 UTYF_USER_FLAG_25

 #define SPECENUM_VALUE57 UTYF_USER_FLAG_26

 #define SPECENUM_VALUE58 UTYF_USER_FLAG_27

 #define SPECENUM_VALUE59 UTYF_USER_FLAG_28

 #define SPECENUM_VALUE60 UTYF_USER_FLAG_29

 #define SPECENUM_VALUE61 UTYF_USER_FLAG_30

 #define SPECENUM_VALUE62 UTYF_USER_FLAG_31

 #define SPECENUM_VALUE63 UTYF_USER_FLAG_32

 #define SPECENUM_VALUE64 UTYF_USER_FLAG_33

 #define SPECENUM_VALUE65 UTYF_USER_FLAG_34

 #define SPECENUM_VALUE66 UTYF_USER_FLAG_35

 #define SPECENUM_VALUE67 UTYF_USER_FLAG_36

 #define SPECENUM_VALUE68 UTYF_USER_FLAG_37

 #define SPECENUM_VALUE69 UTYF_USER_FLAG_38

 #define SPECENUM_VALUE70 UTYF_USER_FLAG_39

 #define SPECENUM_VALUE71 UTYF_USER_FLAG_40

 #define SPECENUM_VALUE72 UTYF_USER_FLAG_41

 #define SPECENUM_VALUE73 UTYF_USER_FLAG_42

 #define SPECENUM_VALUE74 UTYF_USER_FLAG_43

 #define SPECENUM_VALUE75 UTYF_USER_FLAG_44

 #define SPECENUM_VALUE76 UTYF_USER_FLAG_45

 // Note that first role must have value next to last flag


 #define UTYF_LAST_USER_FLAG UTYF_USER_FLAG_45

 #define MAX_NUM_USER_UNIT_FLAGS (UTYF_LAST_USER_FLAG - UTYF_USER_FLAG_1 + 1)

 #define SPECENUM_NAMEOVERRIDE

 #define SPECENUM_BITVECTOR bv_unit_type_flags

 #include "specenum_gen.h"


 /* Unit "roles": these are similar to unit flags but differ in that

    they don't represent intrinsic properties or abilities of units,

    but determine which units are used (mainly by the server or AI)

    in various circumstances, or "roles".

    Note that in some cases flags can act as roles, eg, we don't need

    a role for "settlers", because we can just use UTYF_SETTLERS.

    (Now have to consider ACTION_FOUND_CITY too)

    So we make sure flag values and role values are distinct,

    so some functions can use them interchangably.

    See data/classic/units.ruleset for documentation of their effects.

 */

 #define L_FIRST (UTYF_LAST_USER_FLAG + 1)


 #define SPECENUM_NAME unit_role_id

 // is built first when city established

 #define SPECENUM_VALUE77 L_FIRSTBUILD

 #define SPECENUM_VALUE77NAME N_("?unitflag:FirstBuild")

 // initial explorer unit

 #define SPECENUM_VALUE78 L_EXPLORER

 #define SPECENUM_VALUE78NAME N_("?unitflag:Explorer")

 // can be found in hut

 #define SPECENUM_VALUE79 L_HUT

 #define SPECENUM_VALUE79NAME N_("?unitflag:Hut")

 // can be found in hut, tech required

 #define SPECENUM_VALUE80 L_HUT_TECH

 #define SPECENUM_VALUE80NAME N_("?unitflag:HutTech")

 // is created in Partisan circumstances

 #define SPECENUM_VALUE81 L_PARTISAN

 #define SPECENUM_VALUE81NAME N_("?unitflag:Partisan")

 // ok on defense (AI)

 #define SPECENUM_VALUE82 L_DEFEND_OK

 #define SPECENUM_VALUE82NAME N_("?unitflag:DefendOk")

 // primary purpose is defense (AI)

 #define SPECENUM_VALUE83 L_DEFEND_GOOD

 #define SPECENUM_VALUE83NAME N_("?unitflag:DefendGood")

 // is useful for ferrying (AI)

 #define SPECENUM_VALUE84 L_FERRYBOAT

 #define SPECENUM_VALUE84NAME N_("?unitflag:FerryBoat")

 // barbarians unit, land only

 #define SPECENUM_VALUE85 L_BARBARIAN

 #define SPECENUM_VALUE85NAME N_("?unitflag:Barbarian")

 // barbarians unit, global tech required

 #define SPECENUM_VALUE86 L_BARBARIAN_TECH

 #define SPECENUM_VALUE86NAME N_("?unitflag:BarbarianTech")

 // barbarian boat

 #define SPECENUM_VALUE87 L_BARBARIAN_BOAT

 #define SPECENUM_VALUE87NAME N_("?unitflag:BarbarianBoat")

 // what barbarians should build

 #define SPECENUM_VALUE88 L_BARBARIAN_BUILD

 #define SPECENUM_VALUE88NAME N_("BarbarianBuild")

 // barbarians build when global tech

 #define SPECENUM_VALUE89 L_BARBARIAN_BUILD_TECH

 #define SPECENUM_VALUE89NAME N_("?unitflag:BarbarianBuildTech")

 // barbarian leader

 #define SPECENUM_VALUE90 L_BARBARIAN_LEADER

 #define SPECENUM_VALUE90NAME N_("?unitflag:BarbarianLeader")

 // sea raider unit

 #define SPECENUM_VALUE91 L_BARBARIAN_SEA

 #define SPECENUM_VALUE91NAME N_("?unitflag:BarbarianSea")

 // sea raider unit, global tech required

 #define SPECENUM_VALUE92 L_BARBARIAN_SEA_TECH

 #define SPECENUM_VALUE92NAME N_("?unitflag:BarbarianSeaTech")

 // Startunit: Cities

 #define SPECENUM_VALUE93 L_START_CITIES

 #define SPECENUM_VALUE93NAME N_("?unitflag:CitiesStartunit")

 // Startunit: Worker

 #define SPECENUM_VALUE94 L_START_WORKER

 #define SPECENUM_VALUE94NAME N_("?unitflag:WorkerStartunit")

 // Startunit: Explorer

 #define SPECENUM_VALUE95 L_START_EXPLORER

 #define SPECENUM_VALUE95NAME N_("?unitflag:ExplorerStartunit")

 // Startunit: King

 #define SPECENUM_VALUE96 L_START_KING

 #define SPECENUM_VALUE96NAME N_("?unitflag:KingStartunit")

 // Startunit: Diplomat

 #define SPECENUM_VALUE97 L_START_DIPLOMAT

 #define SPECENUM_VALUE97NAME N_("?unitflag:DiplomatStartunit")

 // Startunit: Ferryboat

 #define SPECENUM_VALUE98 L_START_FERRY

 #define SPECENUM_VALUE98NAME N_("?unitflag:FerryStartunit")

 // Startunit: DefendOk

 #define SPECENUM_VALUE99 L_START_DEFEND_OK

 #define SPECENUM_VALUE99NAME N_("?unitflag:DefendOkStartunit")

 // Startunit: DefendGood

 #define SPECENUM_VALUE100 L_START_DEFEND_GOOD

 #define SPECENUM_VALUE100NAME N_("?unitflag:DefendGoodStartunit")

 // Startunit: AttackFast

 #define SPECENUM_VALUE101 L_START_ATTACK_FAST

 #define SPECENUM_VALUE101NAME N_("?unitflag:AttackFastStartunit")

 // Startunit: AttackStrong

 #define SPECENUM_VALUE102 L_START_ATTACK_STRONG

 #define SPECENUM_VALUE102NAME N_("?unitflag:AttackStrongStartunit")

 // AI hunter type unit

 #define SPECENUM_VALUE103 L_HUNTER

 #define SPECENUM_VALUE103NAME N_("?unitflag:Hunter")

 // can improve terrain

 #define SPECENUM_VALUE104 L_SETTLERS

 #define SPECENUM_VALUE104NAME N_("?unitflag:Settlers")

 #define L_LAST (L_SETTLERS + 1)


 #include "specenum_gen.h"


 #define L_MAX 64 // Used in the network protocol.


 FC_STATIC_ASSERT(L_LAST - L_FIRST <= L_MAX, too_many_unit_roles);


 // Used in the network protocol.

 BV_DEFINE(bv_unit_type_roles, L_MAX);


 // Used in the network protocol.

 #define SPECENUM_NAME combat_bonus_type

 #define SPECENUM_VALUE0 CBONUS_DEFENSE_MULTIPLIER

 #define SPECENUM_VALUE0NAME "DefenseMultiplier"

 #define SPECENUM_VALUE1 CBONUS_DEFENSE_DIVIDER

 #define SPECENUM_VALUE1NAME "DefenseDivider"

 #define SPECENUM_VALUE2 CBONUS_FIREPOWER1

 #define SPECENUM_VALUE2NAME "Firepower1"

 #define SPECENUM_VALUE3 CBONUS_DEFENSE_MULTIPLIER_PCT

 #define SPECENUM_VALUE3NAME "DefenseMultiplierPct"

 #define SPECENUM_VALUE4 CBONUS_DEFENSE_DIVIDER_PCT

 #define SPECENUM_VALUE4NAME "DefenseDividerPct"

 #include "specenum_gen.h"


 struct combat_bonus {

   enum unit_type_flag_id flag;

   enum combat_bonus_type type;

   int value;


   // Not listed in the help text.

   bool quiet;

 };


 // get 'struct combat_bonus_list' and related functions:

 #define SPECLIST_TAG combat_bonus

 #define SPECLIST_TYPE struct combat_bonus

 #include "speclist.h"


 #define combat_bonus_list_iterate(bonuslist, pbonus)                        \

   TYPED_LIST_ITERATE(struct combat_bonus, bonuslist, pbonus)

 #define combat_bonus_list_iterate_end LIST_ITERATE_END


 BV_DEFINE(bv_unit_types, U_LAST);


 struct veteran_level {

   struct name_translation name; /* level/rank name */

   int power_fact; /* combat/work speed/diplomatic power factor (in %) */

   int move_bonus;

   int base_raise_chance; // server only

   int work_raise_chance; // server only

 };


 struct veteran_system {

   int levels;


   struct veteran_level *definitions;

 };


 struct unit_type {

   Unit_type_id item_number;

   struct name_translation name;

   bool ruledit_disabled; /* Does not really exist - hole in improvments array

                           */

   char graphic_str[MAX_LEN_NAME];

   char graphic_alt[MAX_LEN_NAME];

   char sound_move[MAX_LEN_NAME];

   char sound_move_alt[MAX_LEN_NAME];

   char sound_fight[MAX_LEN_NAME];

   char sound_fight_alt[MAX_LEN_NAME];

   int build_cost; // Use wrappers to access this.

   int pop_cost;   /* number of workers the unit contains (e.g., settlers,

                      engineers)*/

   int attack_strength;

   int defense_strength;

   int move_rate;

   int unknown_move_cost; // See utype_unknown_move_cost().


   struct advance *require_advance; // may be nullptr

   struct requirement_vector build_reqs;


   int vision_radius_sq;

   int transport_capacity;

   int hp;

   int firepower;

   struct combat_bonus_list *bonuses;


 #define U_NOT_OBSOLETED (nullptr)

   const struct unit_type *obsoleted_by;

   const struct unit_type *converted_to;

   int convert_time;

   int fuel;


   bv_unit_type_flags flags;

   bv_unit_type_roles roles;


   int happy_cost; // unhappy people in home city

   int upkeep[O_LAST];


   // Only valid for ACTION_PARADROP

   int paratroopers_range;


   // Additional values for the expanded veteran system

   struct veteran_system *veteran;


   // Values for bombardment

   int bombard_rate;


   // Values for founding cities

   int city_size;


   int city_slots;


   struct unit_class *uclass;


   bv_unit_classes cargo;


   // Can attack these classes even if they are otherwise "Unreachable"

   bv_unit_classes targets;

   /* Can load into these class transports at any location,

    * even if they are otherwise "Unreachable". */

   bv_unit_classes embarks;

   /* Can unload from these class transports at any location,

    * even if they are otherwise "Unreachable". */

   bv_unit_classes disembarks;


   enum vision_layer vlayer;


   QVector<QString> *helptext;


   struct {

     bool igwall;

     bool worker;

   } adv;


   struct {

     int max_defense_mp_pct; /* Value 0 here does not guarantee that unit

                              * never has CBONUS_DEFENSE_MULTIPLIER, it

                              * merely means that there's no POSITIVE one */

     int defense_mp_bonuses_pct[U_LAST];

   } cache;


   // Used to upgrade the ruleset format version.

   struct {

     int paratroopers_mr_req;

     int paratroopers_mr_sub;

   } rscompat_cache;


   void *ais[FREECIV_AI_MOD_LAST];

 };


 // General unit and unit type (matched) routines

 Unit_type_id utype_count();

 Unit_type_id utype_index(const struct unit_type *punittype);

 Unit_type_id utype_number(const struct unit_type *punittype);


 const struct unit_type *unit_type_get(const struct unit *punit);

 struct unit_type *utype_by_number(const Unit_type_id id);


 struct unit_type *unit_type_by_rule_name(const char *name);

 struct unit_type *unit_type_by_translated_name(const char *name);


 const char *unit_rule_name(const struct unit *punit);

 const char *utype_rule_name(const struct unit_type *punittype);


 const char *unit_name_translation(const struct unit *punit);

 const char *utype_name_translation(const struct unit_type *punittype);


 const char *utype_values_string(const struct unit_type *punittype);

 const char *utype_values_translation(const struct unit_type *punittype);


 // General unit type flag and role routines

 bool unit_has_type_flag(const struct unit *punit,

                         enum unit_type_flag_id flag);


 /**************************************************************************

   Return whether the given unit type has the flag.

 **************************************************************************/

 static inline bool utype_has_flag(const struct unit_type *punittype,

                                   int flag)

 {

   return BV_ISSET(punittype->flags, flag);

 }


 bool unit_has_type_role(const struct unit *punit, enum unit_role_id role);

 bool utype_has_role(const struct unit_type *punittype, int role);


 void user_unit_type_flags_init();

 void set_user_unit_type_flag_name(enum unit_type_flag_id id,

                                   const char *name, const char *helptxt);

 const char *unit_type_flag_helptxt(enum unit_type_flag_id id);


 bool unit_can_take_over(const struct unit *punit);

 bool utype_can_take_over(const struct unit_type *punittype);


 bool utype_can_freely_load(const struct unit_type *pcargotype,

                            const struct unit_type *ptranstype);

 bool utype_can_freely_unload(const struct unit_type *pcargotype,

                              const struct unit_type *ptranstype);


 bool utype_may_act_at_all(const struct unit_type *putype);

 bool utype_can_do_action(const struct unit_type *putype,

                          const action_id act_id);

 bool utype_can_do_action_result(const struct unit_type *putype,

                                 enum action_result result);

 bool utype_acts_hostile(const struct unit_type *putype);


 bool can_unit_act_when_ustate_is(const struct unit_type *punit_type,

                                  const enum ustate_prop prop,

                                  const bool is_there);

 bool utype_can_do_act_when_ustate(const struct unit_type *punit_type,

                                   const action_id act_id,

                                   const enum ustate_prop prop,

                                   const bool is_there);


 bool utype_can_do_act_if_tgt_citytile(const struct unit_type *punit_type,

                                       const action_id act_id,

                                       const enum citytile_type prop,

                                       const bool is_there);


 bool can_utype_do_act_if_tgt_diplrel(const struct unit_type *punit_type,

                                      const action_id act_id, const int prop,

                                      const bool is_there);


 bool utype_may_act_move_frags(const struct unit_type *punit_type,

                               const action_id act_id,

                               const int move_fragments);


 bool utype_may_act_tgt_city_tile(const struct unit_type *punit_type,

                                  const action_id act_id,

                                  const enum citytile_type prop,

                                  const bool is_there);


 bool utype_is_consumed_by_action(const struct action *paction,

                                  const struct unit_type *utype);


 bool utype_is_consumed_by_action_result(enum action_result result,

                                         const struct unit_type *utype);


 bool utype_is_moved_to_tgt_by_action(const struct action *paction,

                                      const struct unit_type *utype);


 bool utype_is_unmoved_by_action(const struct action *paction,

                                 const struct unit_type *utype);


 bool utype_pays_for_regular_move_to_tgt(const struct action *paction,

                                         const struct unit_type *utype);


 int utype_pays_mp_for_action_base(const struct action *paction,

                                   const struct unit_type *putype);


 int utype_pays_mp_for_action_estimate(const struct action *paction,

                                       const struct unit_type *putype,

                                       const struct player *act_player,

                                       const struct tile *act_tile,

                                       const struct tile *tgt_tile);


 // Functions to operate on various flag and roles.

 typedef bool (*role_unit_callback)(struct unit_type *ptype, void *data);


 void role_unit_precalcs();

 void role_unit_precalcs_free();

 int num_role_units(int role);

 struct unit_type *

 role_units_iterate_backwards(int role, role_unit_callback cb, void *data);

 struct unit_type *get_role_unit(int role, int role_index);

 struct unit_type *best_role_unit(const struct city *pcity, int role);

 struct unit_type *best_role_unit_for_player(const struct player *pplayer,

                                             int role);

 struct unit_type *first_role_unit_for_player(const struct player *pplayer,

                                              int role);

 bool role_units_translations(QString &astr, int flag, bool alts);


 // General unit class routines

 Unit_Class_id uclass_count();

 Unit_Class_id uclass_number(const struct unit_class *pclass);

 /* Optimised to be identical to uclass_number: the implementation

  * unittype.c is also semantically correct. */

 #define uclass_index(_c_) (_c_)->item_number

 #ifndef uclass_index

 Unit_Class_id uclass_index(const struct unit_class *pclass);

 #endif // uclass_index


 struct unit_class *unit_class_get(const struct unit *punit);

 struct unit_class *uclass_by_number(const Unit_Class_id id);

 #define utype_class(_t_) (_t_)->uclass

 #ifndef utype_class

 struct unit_class *utype_class(const struct unit_type *punittype);

 #endif // utype_class


 struct unit_class *unit_class_by_rule_name(const char *s);


 const char *uclass_rule_name(const struct unit_class *pclass);

 const char *uclass_name_translation(const struct unit_class *pclass);


 /**************************************************************************

   Return whether the given unit class has the flag.

 **************************************************************************/

 static inline bool uclass_has_flag(const struct unit_class *punitclass,

                                    enum unit_class_flag_id flag)

 {

   return BV_ISSET(punitclass->flags, flag);

 }


 void user_unit_class_flags_init();

 void set_user_unit_class_flag_name(enum unit_class_flag_id id,

                                    const char *name, const char *helptxt);

 const char *unit_class_flag_helptxt(enum unit_class_flag_id id);


 // Ancillary routines

 int unit_build_shield_cost(const struct city *pcity,

                            const struct unit *punit);

 int utype_build_shield_cost(const struct city *pcity,

                             const struct unit_type *punittype);

 int utype_build_shield_cost_base(const struct unit_type *punittype);

 int unit_build_shield_cost_base(const struct unit *punit);


 int utype_buy_gold_cost(const struct city *pcity,

                         const struct unit_type *punittype,

                         int shields_in_stock);


 const struct veteran_system *

 utype_veteran_system(const struct unit_type *punittype);

 int utype_veteran_levels(const struct unit_type *punittype);

 const struct veteran_level *

 utype_veteran_level(const struct unit_type *punittype, int level);

 const char *utype_veteran_name_translation(const struct unit_type *punittype,

                                            int level);

 bool utype_veteran_has_power_bonus(const struct unit_type *punittype);


 struct veteran_system *veteran_system_new(int count);

 void veteran_system_destroy(struct veteran_system *vsystem);

 void veteran_system_definition(struct veteran_system *vsystem, int level,

                                const char *vlist_name, int vlist_power,

                                int vlist_move, int vlist_raise,

                                int vlist_wraise);


 int unit_pop_value(const struct unit *punit);

 int utype_pop_value(const struct unit_type *punittype);


 enum unit_move_type utype_move_type(const struct unit_type *punittype);

 void set_unit_move_type(struct unit_class *puclass);


 // player related unit functions

 int utype_upkeep_cost(const struct unit_type *ut, struct player *pplayer,

                       Output_type_id otype);

 int utype_happy_cost(const struct unit_type *ut,

                      const struct player *pplayer);


 const struct unit_type *

 can_upgrade_unittype(const struct player *pplayer,

                      const struct unit_type *punittype);

 int unit_upgrade_price(const struct player *pplayer,

                        const struct unit_type *from,

                        const struct unit_type *to);


 bool utype_player_already_has_this_unique(const struct player *pplayer,

                                           const struct unit_type *putype);


 bool can_player_build_unit_direct(const struct player *p,

                                   const struct unit_type *punittype);

 bool can_player_build_unit_later(const struct player *p,

                                  const struct unit_type *punittype);

 bool can_player_build_unit_now(const struct player *p,

                                const struct unit_type *punittype);


 #define utype_fuel(ptype) (ptype)->fuel


 bool utype_is_cityfounder(const struct unit_type *utype);


 // Initialization and iteration

 void unit_types_init();

 void unit_types_free();

 void unit_type_flags_free();

 void unit_class_flags_free();


 struct unit_type *unit_type_array_first();

 const struct unit_type *unit_type_array_last();


 #define unit_type_iterate(_p)                                               \

   {                                                                         \

     struct unit_type *_p = unit_type_array_first();                         \

     if (nullptr != _p) {                                                    \

       for (; _p <= unit_type_array_last(); _p++) {


 #define unit_type_iterate_end                                               \

   }                                                                         \

   }                                                                         \

   }


 #define unit_type_re_active_iterate(_p)                                     \

   unit_type_iterate(_p)                                                     \

   {                                                                         \

     if (!_p->ruledit_disabled) {


 #define unit_type_re_active_iterate_end                                     \

   }                                                                         \

   }                                                                         \

   unit_type_iterate_end;


 void *utype_ai_data(const struct unit_type *ptype, const struct ai_type *ai);

 void utype_set_ai_data(struct unit_type *ptype, const struct ai_type *ai,

                        void *data);


 void unit_type_action_cache_set(struct unit_type *ptype);

 void unit_type_action_cache_init();


 // Initialization and iteration

 void unit_classes_init();

 void unit_classes_free();


 void set_unit_class_caches(struct unit_class *pclass);

 void set_unit_type_caches(struct unit_type *ptype);


 struct unit_class *unit_class_array_first();

 const struct unit_class *unit_class_array_last();


 #define unit_class_iterate(_p)                                              \

   {                                                                         \

     struct unit_class *_p = unit_class_array_first();                       \

     if (nullptr != _p) {                                                    \

       for (; _p <= unit_class_array_last(); _p++) {


 #define unit_class_iterate_end                                              \

   }                                                                         \

   }                                                                         \

   }


 #define unit_class_re_active_iterate(_p)                                    \

   unit_class_iterate(_p)                                                    \

   {                                                                         \

     if (!_p->ruledit_disabled) {


 #define unit_class_re_active_iterate_end                                    \

   }                                                                         \

   }                                                                         \

   unit_class_iterate_end;


 #define SPECLIST_TAG unit_class

 #define SPECLIST_TYPE struct unit_class

 #include "speclist.h"


 #define unit_class_list_iterate(uclass_list, pclass)                        \

   TYPED_LIST_ITERATE(struct unit_class, uclass_list, pclass)

 #define unit_class_list_iterate_end LIST_ITERATE_END


 #define SPECLIST_TAG unit_type

 #define SPECLIST_TYPE struct unit_type

 #include "speclist.h"


 #define unit_type_list_iterate(utype_list, ptype)                           \

   TYPED_LIST_ITERATE(struct unit_type, utype_list, ptype)

 #define unit_type_list_iterate_end LIST_ITERATE_END

bitvector.h

BV_ISSET
bool BV_ISSET(const BV &bv, int bit)
Definition: bitvector.h:37

QVector< QString >

fc_types.h

Unit_Class_id
int Unit_Class_id
Definition: fc_types.h:333

action_id
int action_id
Definition: fc_types.h:306

MAX_LEN_NAME
#define MAX_LEN_NAME
Definition: fc_types.h:61

Unit_type_id
int Unit_type_id
Definition: fc_types.h:299

O_LAST
@ O_LAST
Definition: fc_types.h:91

UCL_LAST
#define UCL_LAST
Definition: fc_types.h:332

Output_type_id
enum output_type_id Output_type_id
Definition: fc_types.h:295

name
const char * name
Definition: inputfile.cpp:118

name_translation.h

requirements.h

level
struct setting_list * level[OLEVELS_NUM]
Definition: settings.cpp:167

shared.h

speclist.h

action
Definition: actions.h:305

advance
Definition: tech.h:113

ai_type
Definition: ai.h:42

city
Definition: city.h:291

combat_bonus
Definition: unittype.h:431

combat_bonus::value
int value
Definition: unittype.h:434

combat_bonus::flag
enum unit_type_flag_id flag
Definition: unittype.h:432

combat_bonus::quiet
bool quiet
Definition: unittype.h:437

combat_bonus::type
enum combat_bonus_type type
Definition: unittype.h:433

name_translation
Definition: name_translation.h:23

player
Definition: player.h:231

tile
Definition: tile.h:42

unit_class
Definition: unittype.h:120

unit_class::cache
struct unit_class::@81 cache

unit_class::item_number
Unit_Class_id item_number
Definition: unittype.h:121

unit_class::hp_loss_pct
int hp_loss_pct
Definition: unittype.h:126

unit_class::move_type
enum unit_move_type move_type
Definition: unittype.h:124

unit_class::non_native_def_pct
int non_native_def_pct
Definition: unittype.h:128

unit_class::adv
struct unit_class::@80 adv

unit_class::sea_move
enum move_level sea_move
Definition: unittype.h:136

unit_class::subset_movers
struct unit_class_list * subset_movers
Definition: unittype.h:143

unit_class::native_tile_extras
struct extra_type_list * native_tile_extras
Definition: unittype.h:141

unit_class::min_speed
int min_speed
Definition: unittype.h:125

unit_class::hut_behavior
enum hut_behavior hut_behavior
Definition: unittype.h:129

unit_class::bonus_roads
struct extra_type_list * bonus_roads
Definition: unittype.h:142

unit_class::helptext
QVector< QString > * helptext
Definition: unittype.h:132

unit_class::refuel_bases
struct extra_type_list * refuel_bases
Definition: unittype.h:140

unit_class::name
struct name_translation name
Definition: unittype.h:122

unit_class::flags
bv_unit_class_flags flags
Definition: unittype.h:130

unit_class::ruledit_disabled
bool ruledit_disabled
Definition: unittype.h:123

unit_class::land_move
enum move_level land_move
Definition: unittype.h:135

unit_type
Definition: unittype.h:465

unit_type::transport_capacity
int transport_capacity
Definition: unittype.h:488

unit_type::uclass
struct unit_class * uclass
Definition: unittype.h:519

unit_type::pop_cost
int pop_cost
Definition: unittype.h:477

unit_type::adv
struct unit_type::@82 adv

unit_type::ais
void * ais[FREECIV_AI_MOD_LAST]
Definition: unittype.h:554

unit_type::build_reqs
struct requirement_vector build_reqs
Definition: unittype.h:485

unit_type::item_number
Unit_type_id item_number
Definition: unittype.h:466

unit_type::defense_strength
int defense_strength
Definition: unittype.h:480

unit_type::cargo
bv_unit_classes cargo
Definition: unittype.h:521

unit_type::rscompat_cache
struct unit_type::@84 rscompat_cache

unit_type::firepower
int firepower
Definition: unittype.h:490

unit_type::helptext
QVector< QString > * helptext
Definition: unittype.h:534

unit_type::paratroopers_range
int paratroopers_range
Definition: unittype.h:506

unit_type::graphic_alt
char graphic_alt[MAX_LEN_NAME]
Definition: unittype.h:471

unit_type::worker
bool worker
Definition: unittype.h:538

unit_type::sound_move_alt
char sound_move_alt[MAX_LEN_NAME]
Definition: unittype.h:473

unit_type::build_cost
int build_cost
Definition: unittype.h:476

unit_type::convert_time
int convert_time
Definition: unittype.h:496

unit_type::city_size
int city_size
Definition: unittype.h:515

unit_type::veteran
struct veteran_system * veteran
Definition: unittype.h:509

unit_type::obsoleted_by
const struct unit_type * obsoleted_by
Definition: unittype.h:494

unit_type::vision_radius_sq
int vision_radius_sq
Definition: unittype.h:487

unit_type::move_rate
int move_rate
Definition: unittype.h:481

unit_type::targets
bv_unit_classes targets
Definition: unittype.h:524

unit_type::vlayer
enum vision_layer vlayer
Definition: unittype.h:532

unit_type::require_advance
struct advance * require_advance
Definition: unittype.h:484

unit_type::cache
struct unit_type::@83 cache

unit_type::paratroopers_mr_sub
int paratroopers_mr_sub
Definition: unittype.h:551

unit_type::bombard_rate
int bombard_rate
Definition: unittype.h:512

unit_type::graphic_str
char graphic_str[MAX_LEN_NAME]
Definition: unittype.h:470

unit_type::city_slots
int city_slots
Definition: unittype.h:517

unit_type::sound_move
char sound_move[MAX_LEN_NAME]
Definition: unittype.h:472

unit_type::hp
int hp
Definition: unittype.h:489

unit_type::paratroopers_mr_req
int paratroopers_mr_req
Definition: unittype.h:550

unit_type::sound_fight_alt
char sound_fight_alt[MAX_LEN_NAME]
Definition: unittype.h:475

unit_type::igwall
bool igwall
Definition: unittype.h:537

unit_type::name
struct name_translation name
Definition: unittype.h:467

unit_type::fuel
int fuel
Definition: unittype.h:497

unit_type::roles
bv_unit_type_roles roles
Definition: unittype.h:500

unit_type::unknown_move_cost
int unknown_move_cost
Definition: unittype.h:482

unit_type::upkeep
int upkeep[O_LAST]
Definition: unittype.h:503

unit_type::disembarks
bv_unit_classes disembarks
Definition: unittype.h:530

unit_type::converted_to
const struct unit_type * converted_to
Definition: unittype.h:495

unit_type::max_defense_mp_pct
int max_defense_mp_pct
Definition: unittype.h:542

unit_type::flags
bv_unit_type_flags flags
Definition: unittype.h:499

unit_type::ruledit_disabled
bool ruledit_disabled
Definition: unittype.h:468

unit_type::sound_fight
char sound_fight[MAX_LEN_NAME]
Definition: unittype.h:474

unit_type::embarks
bv_unit_classes embarks
Definition: unittype.h:527

unit_type::attack_strength
int attack_strength
Definition: unittype.h:479

unit_type::happy_cost
int happy_cost
Definition: unittype.h:502

unit_type::defense_mp_bonuses_pct
int defense_mp_bonuses_pct[U_LAST]
Definition: unittype.h:545

unit_type::bonuses
struct combat_bonus_list * bonuses
Definition: unittype.h:491

unit
Definition: unit.h:134

veteran_level
Definition: unittype.h:451

veteran_level::power_fact
int power_fact
Definition: unittype.h:453

veteran_level::base_raise_chance
int base_raise_chance
Definition: unittype.h:455

veteran_level::name
struct name_translation name
Definition: unittype.h:452

veteran_level::move_bonus
int move_bonus
Definition: unittype.h:454

veteran_level::work_raise_chance
int work_raise_chance
Definition: unittype.h:456

veteran_system
Definition: unittype.h:459

veteran_system::definitions
struct veteran_level * definitions
Definition: unittype.h:462

veteran_system::levels
int levels
Definition: unittype.h:460

utype_may_act_tgt_city_tile
bool utype_may_act_tgt_city_tile(const struct unit_type *punit_type, const action_id act_id, const enum citytile_type prop, const bool is_there)
Return TRUE iff the given (action enabler controlled) action may be performed by a unit of the given ...
Definition: unittype.cpp:870

utype_buy_gold_cost
int utype_buy_gold_cost(const struct city *pcity, const struct unit_type *punittype, int shields_in_stock)
Returns the amount of gold it takes to rush this unit.
Definition: unittype.cpp:1193

can_unit_act_when_ustate_is
bool can_unit_act_when_ustate_is(const struct unit_type *punit_type, const enum ustate_prop prop, const bool is_there)
Return TRUE iff there exists an (action enabler controlled) action that a unit of the type punit_type...
Definition: unittype.cpp:733

unit_class_array_last
const struct unit_class * unit_class_array_last()
Return the last item of unit_classes.
Definition: unittype.cpp:2090

unit_rule_name
const char * unit_rule_name(const struct unit *punit)
Return the (untranslated) rule name of the unit.
Definition: unittype.cpp:1283

set_unit_class_caches
void set_unit_class_caches(struct unit_class *pclass)
Set caches for unit class.
Definition: unittype.cpp:2349

unit_type_get
const struct unit_type * unit_type_get(const struct unit *punit)
Return the unit type for this unit.
Definition: unittype.cpp:114

best_role_unit
struct unit_type * best_role_unit(const struct city *pcity, int role)
Return "best" unit this city can build, with given role/flag.
Definition: unittype.cpp:1920

utype_pop_value
int utype_pop_value(const struct unit_type *punittype)
How much city shrinks when it builds unit of this type.
Definition: unittype.cpp:1231

BV_DEFINE
BV_DEFINE(bv_unit_classes, UCL_LAST)

uclass_name_translation
const char * uclass_name_translation(const struct unit_class *pclass)
Return the (translated) name of the unit class.
Definition: unittype.cpp:1324

uclass_has_flag
static bool uclass_has_flag(const struct unit_class *punitclass, enum unit_class_flag_id flag)
Definition: unittype.h:704

utype_pays_mp_for_action_base
int utype_pays_mp_for_action_base(const struct action *paction, const struct unit_type *putype)
Returns the amount of movement points successfully performing the specified action will consume in th...
Definition: unittype.cpp:1083

utype_by_number
struct unit_type * utype_by_number(const Unit_type_id id)
Return a pointer for the unit type struct for the given unit type id.
Definition: unittype.cpp:103

utype_can_freely_unload
bool utype_can_freely_unload(const struct unit_type *pcargotype, const struct unit_type *ptranstype)
Return TRUE iff the given cargo type has no restrictions on when it can unload from the given transpo...
Definition: unittype.cpp:239

utype_pays_for_regular_move_to_tgt
bool utype_pays_for_regular_move_to_tgt(const struct action *paction, const struct unit_type *utype)
Returns TRUE iff successfully performing the specified action always will cost the actor unit of the ...
Definition: unittype.cpp:1052

utype_class
#define utype_class(_t_)
Definition: unittype.h:691

utype_values_translation
const char * utype_values_translation(const struct unit_type *punittype)
Return string with translated unit name and list of its values.
Definition: unittype.cpp:1310

unit_build_shield_cost
int unit_build_shield_cost(const struct city *pcity, const struct unit *punit)
Returns the number of shields it takes to build this unit.
Definition: unittype.cpp:1176

unit_class_flag_helptxt
const char * unit_class_flag_helptxt(enum unit_class_flag_id id)
Return the (untranslated) help text of the user unit class flag.
Definition: unittype.cpp:1534

L_FIRST
#define L_FIRST
Definition: unittype.h:319

unit_type_array_first
struct unit_type * unit_type_array_first()
Return the first item of unit_types.
Definition: unittype.cpp:52

utype_is_moved_to_tgt_by_action
bool utype_is_moved_to_tgt_by_action(const struct action *paction, const struct unit_type *utype)
Returns TRUE iff successfully performing the specified action always will move the actor unit of the ...
Definition: unittype.cpp:969

unit_type_array_last
const struct unit_type * unit_type_array_last()
Return the last item of unit_types.
Definition: unittype.cpp:63

utype_upkeep_cost
int utype_upkeep_cost(const struct unit_type *ut, struct player *pplayer, Output_type_id otype)
Returns the upkeep of a unit of this type under the given government.
Definition: unittype.cpp:123

utype_move_type
enum unit_move_type utype_move_type(const struct unit_type *punittype)
Return move type of the unit type.
Definition: unittype.cpp:1247

utype_rule_name
const char * utype_rule_name(const struct unit_type *punittype)
Return the (untranslated) rule name of the unit type.
Definition: unittype.cpp:1274

best_role_unit_for_player
struct unit_type * best_role_unit_for_player(const struct player *pplayer, int role)
Return "best" unit the player can build, with given role/flag.
Definition: unittype.cpp:1950

hut_behavior
hut_behavior
Definition: unittype.h:113

HUT_FRIGHTEN
@ HUT_FRIGHTEN
Definition: unittype.h:113

HUT_NOTHING
@ HUT_NOTHING
Definition: unittype.h:113

HUT_NORMAL
@ HUT_NORMAL
Definition: unittype.h:113

utype_is_cityfounder
bool utype_is_cityfounder(const struct unit_type *utype)
Is cityfounder type.
Definition: unittype.cpp:2549

can_upgrade_unittype
const struct unit_type * can_upgrade_unittype(const struct player *pplayer, const struct unit_type *punittype)
Return whether this player can upgrade this unit type (to any other unit type).
Definition: unittype.cpp:1379

unit_classes_init
void unit_classes_init()
Initialize unit_class structures.
Definition: unittype.cpp:2159

unit_class_flags_free
void unit_class_flags_free()
Frees the memory associated with all unit class flags.
Definition: unittype.cpp:2067

utype_has_role
bool utype_has_role(const struct unit_type *punittype, int role)
Return whether the given unit type has the role.
Definition: unittype.cpp:186

set_unit_move_type
void set_unit_move_type(struct unit_class *puclass)
Set move_type for unit class.
Definition: unittype.cpp:2504

utype_build_shield_cost
int utype_build_shield_cost(const struct city *pcity, const struct unit_type *punittype)
Returns the number of shields it takes to build this unit type.
Definition: unittype.cpp:1141

move_level
move_level
Definition: unittype.h:115

MOVE_PARTIAL
@ MOVE_PARTIAL
Definition: unittype.h:115

MOVE_FULL
@ MOVE_FULL
Definition: unittype.h:115

MOVE_NONE
@ MOVE_NONE
Definition: unittype.h:115

utype_count
Unit_type_id utype_count()
Return the number of unit types.
Definition: unittype.cpp:74

utype_build_shield_cost_base
int utype_build_shield_cost_base(const struct unit_type *punittype)
Returns the number of shields this unit type represents.
Definition: unittype.cpp:1168

set_unit_type_caches
void set_unit_type_caches(struct unit_type *ptype)
Set caches for unit types.
Definition: unittype.cpp:2408

unit_type_flag_helptxt
const char * unit_type_flag_helptxt(enum unit_type_flag_id id)
Return the (untranslated) helptxt of the user unit flag.
Definition: unittype.cpp:1589

utype_may_act_move_frags
bool utype_may_act_move_frags(const struct unit_type *punit_type, const action_id act_id, const int move_fragments)
Return TRUE iff the given (action enabler controlled) action may be performed by a unit of the given ...
Definition: unittype.cpp:804

utype_is_consumed_by_action_result
bool utype_is_consumed_by_action_result(enum action_result result, const struct unit_type *utype)
Returns TRUE iff performing an action with the specified action result will consume an actor unit of ...
Definition: unittype.cpp:947

user_unit_class_flags_init
void user_unit_class_flags_init()
Initialize user unit class flags.
Definition: unittype.cpp:1481

num_role_units
int num_role_units(int role)
How many unit types have specified role/flag.
Definition: unittype.cpp:1866

utype_player_already_has_this_unique
bool utype_player_already_has_this_unique(const struct player *pplayer, const struct unit_type *putype)
Returns TRUE iff the unit type is unique and the player already has one.
Definition: unittype.cpp:1599

utype_has_flag
static bool utype_has_flag(const struct unit_type *punittype, int flag)
Definition: unittype.h:584

utype_may_act_at_all
bool utype_may_act_at_all(const struct unit_type *putype)
Return TRUE iff units of this type can do actions controlled by generalized (ruleset defined) action ...
Definition: unittype.cpp:374

unit_build_shield_cost_base
int unit_build_shield_cost_base(const struct unit *punit)
Returns the number of shields this unit represents.
Definition: unittype.cpp:1185

unit_class_by_rule_name
struct unit_class * unit_class_by_rule_name(const char *s)
Returns the unit class that has the given (untranslated) rule name.
Definition: unittype.cpp:1463

veteran_system_new
struct veteran_system * veteran_system_new(int count)
Allocate new veteran system structure with given veteran level count.
Definition: unittype.cpp:2281

utype_can_freely_load
bool utype_can_freely_load(const struct unit_type *pcargotype, const struct unit_type *ptranstype)
Return TRUE iff the given cargo type has no restrictions on when it can load onto the given transport...
Definition: unittype.cpp:227

unit_classes_free
void unit_classes_free()
Free resources allocated for unit classes.
Definition: unittype.cpp:2179

veteran_system_definition
void veteran_system_definition(struct veteran_system *vsystem, int level, const char *vlist_name, int vlist_power, int vlist_move, int vlist_raise, int vlist_wraise)
Fill veteran level in given veteran system with given information.
Definition: unittype.cpp:2310

uclass_count
Unit_Class_id uclass_count()
Return the unit_class count.
Definition: unittype.cpp:2101

L_LAST
#define L_LAST
Definition: unittype.h:406

unit_class_get
struct unit_class * unit_class_get(const struct unit *punit)
Returns unit class pointer for a unit.
Definition: unittype.cpp:2151

unit_type_flags_free
void unit_type_flags_free()
Frees the memory associated with all unit type flags.
Definition: unittype.cpp:2055

utype_values_string
const char * utype_values_string(const struct unit_type *punittype)
Return string describing unit type values.
Definition: unittype.cpp:1292

role_unit_callback
bool(* role_unit_callback)(struct unit_type *ptype, void *data)
Definition: unittype.h:664

can_player_build_unit_direct
bool can_player_build_unit_direct(const struct player *p, const struct unit_type *punittype)
Whether player can build given unit somewhere, ignoring whether unit is obsolete and assuming the pla...
Definition: unittype.cpp:1628

role_unit_precalcs_free
void role_unit_precalcs_free()
Free memory allocated by role_unit_precalcs().
Definition: unittype.cpp:1823

utype_veteran_levels
int utype_veteran_levels(const struct unit_type *punittype)
Return veteran levels of the given unit type.
Definition: unittype.cpp:2254

utype_can_do_act_when_ustate
bool utype_can_do_act_when_ustate(const struct unit_type *punit_type, const action_id act_id, const enum ustate_prop prop, const bool is_there)
Return TRUE iff the unit type can do the specified (action enabler controlled) action while its unit ...
Definition: unittype.cpp:746

veteran_system_destroy
void veteran_system_destroy(struct veteran_system *vsystem)
Free veteran system.
Definition: unittype.cpp:2298

utype_can_do_action_result
bool utype_can_do_action_result(const struct unit_type *putype, enum action_result result)
Return TRUE iff units of the given type can do any enabler controlled action with the specified actio...
Definition: unittype.cpp:402

unit_has_type_role
bool unit_has_type_role(const struct unit *punit, enum unit_role_id role)
Return whether the unit has the given role.
Definition: unittype.cpp:195

role_units_translations
bool role_units_translations(QString &astr, int flag, bool alts)
Return a string with all the names of units with this flag.
Definition: unittype.cpp:1343

FC_STATIC_ASSERT
FC_STATIC_ASSERT(L_LAST - L_FIRST<=L_MAX, too_many_unit_roles)

utype_veteran_system
const struct veteran_system * utype_veteran_system(const struct unit_type *punittype)
Return veteran system used for this unit type.
Definition: unittype.cpp:2208

unit_has_type_flag
bool unit_has_type_flag(const struct unit *punit, enum unit_type_flag_id flag)
Return whether the unit has the given flag.
Definition: unittype.cpp:176

unit_can_take_over
bool unit_can_take_over(const struct unit *punit)
Return whether the unit can take over enemy cities.
Definition: unittype.cpp:203

unit_type_by_translated_name
struct unit_type * unit_type_by_translated_name(const char *name)
Returns the unit type that has the given (translated) name.
Definition: unittype.cpp:1427

role_unit_precalcs
void role_unit_precalcs()
Initialize; it is safe to call this multiple times (e.g., if units have changed due to rulesets in cl...
Definition: unittype.cpp:1838

unit_type_action_cache_set
void unit_type_action_cache_set(struct unit_type *ptype)
Cache if any action may be possible for a unit of the type putype given the property tested for.
Definition: unittype.cpp:710

utype_name_translation
const char * utype_name_translation(const struct unit_type *punittype)
Return the (translated) name of the unit type.
Definition: unittype.cpp:1256

unit_types_init
void unit_types_init()
Inialize unit-type structures.
Definition: unittype.cpp:2001

user_unit_type_flags_init
void user_unit_type_flags_init()
Initialize user unit type flags.
Definition: unittype.cpp:1544

uclass_by_number
struct unit_class * uclass_by_number(const Unit_Class_id id)
Returns unit class pointer for an ID value.
Definition: unittype.cpp:2129

utype_pays_mp_for_action_estimate
int utype_pays_mp_for_action_estimate(const struct action *paction, const struct unit_type *putype, const struct player *act_player, const struct tile *act_tile, const struct tile *tgt_tile)
Returns an estimate of the amount of movement points successfully performing the specified action wil...
Definition: unittype.cpp:1104

utype_is_consumed_by_action
bool utype_is_consumed_by_action(const struct action *paction, const struct unit_type *utype)
Returns TRUE iff performing the specified action will consume an actor unit of the specified type.
Definition: unittype.cpp:936

unit_type_by_rule_name
struct unit_type * unit_type_by_rule_name(const char *name)
Returns the unit type that has the given (untranslated) rule name.
Definition: unittype.cpp:1444

U_LAST
#define U_LAST
Definition: unittype.h:31

utype_number
Unit_type_id utype_number(const struct unit_type *punittype)
Return the unit type index.
Definition: unittype.cpp:91

utype_veteran_has_power_bonus
bool utype_veteran_has_power_bonus(const struct unit_type *punittype)
Return whether this unit type's veteran system, if any, confers a power factor bonus at any level (it...
Definition: unittype.cpp:2267

uclass_index
#define uclass_index(_c_)
Definition: unittype.h:684

get_role_unit
struct unit_type * get_role_unit(int role, int role_index)
Return index-th unit with specified role/flag.
Definition: unittype.cpp:1900

utype_index
Unit_type_id utype_index(const struct unit_type *punittype)
Return the unit type index.
Definition: unittype.cpp:82

L_MAX
#define L_MAX
Definition: unittype.h:410

utype_can_take_over
bool utype_can_take_over(const struct unit_type *punittype)
Return whether the unit type can take over enemy cities.
Definition: unittype.cpp:215

utype_set_ai_data
void utype_set_ai_data(struct unit_type *ptype, const struct ai_type *ai, void *data)
Attach ai data to unit type.
Definition: unittype.cpp:2340

unit_class_array_first
struct unit_class * unit_class_array_first()
Return the first item of unit_classes.
Definition: unittype.cpp:2079

set_user_unit_class_flag_name
void set_user_unit_class_flag_name(enum unit_class_flag_id id, const char *name, const char *helptxt)
Sets user defined name for unit class flag.
Definition: unittype.cpp:1493

uclass_rule_name
const char * uclass_rule_name(const struct unit_class *pclass)
Return the (untranslated) rule name of the unit class.
Definition: unittype.cpp:1333

unit_name_translation
const char * unit_name_translation(const struct unit *punit)
Return the (translated) name of the unit.
Definition: unittype.cpp:1265

can_player_build_unit_later
bool can_player_build_unit_later(const struct player *p, const struct unit_type *punittype)
Whether player can eventually build given unit somewhere – ie, returns TRUE if unit is available with...
Definition: unittype.cpp:1761

unit_pop_value
int unit_pop_value(const struct unit *punit)
How much population is put to building this unit.
Definition: unittype.cpp:1239

utype_veteran_name_translation
const char * utype_veteran_name_translation(const struct unit_type *punittype, int level)
Return translated name of the given veteran level.
Definition: unittype.cpp:2239

uclass_number
Unit_Class_id uclass_number(const struct unit_class *pclass)
Return the unit_class index.
Definition: unittype.cpp:2120

can_player_build_unit_now
bool can_player_build_unit_now(const struct player *p, const struct unit_type *punittype)
Whether player can build given unit somewhere; returns FALSE if unit is obsolete.
Definition: unittype.cpp:1742

unit_types_free
void unit_types_free()
Frees the memory associated with all unit types.
Definition: unittype.cpp:2041

utype_is_unmoved_by_action
bool utype_is_unmoved_by_action(const struct action *paction, const struct unit_type *utype)
Returns TRUE iff successfully performing the specified action never will move the actor unit from its...
Definition: unittype.cpp:1009

utype_acts_hostile
bool utype_acts_hostile(const struct unit_type *putype)
Return TRUE iff units of this type can do hostile actions controlled by generalized (ruleset defined)...
Definition: unittype.cpp:432

utype_can_do_act_if_tgt_citytile
bool utype_can_do_act_if_tgt_citytile(const struct unit_type *punit_type, const action_id act_id, const enum citytile_type prop, const bool is_there)
Returns TRUE iff the unit type can do the specified (action enabler controlled) action while its targ...
Definition: unittype.cpp:763

first_role_unit_for_player
struct unit_type * first_role_unit_for_player(const struct player *pplayer, int role)
Return first unit the player can build, with given role/flag.
Definition: unittype.cpp:1976

unit_type_action_cache_init
void unit_type_action_cache_init()
Cache what unit types may be allowed do what actions, both at all and when certain properties are tru...
Definition: unittype.cpp:722

can_utype_do_act_if_tgt_diplrel
bool can_utype_do_act_if_tgt_diplrel(const struct unit_type *punit_type, const action_id act_id, const int prop, const bool is_there)
Return TRUE iff the given (action enabler controlled) action can be performed by a unit of the given ...
Definition: unittype.cpp:784

role_units_iterate_backwards
struct unit_type * role_units_iterate_backwards(int role, role_unit_callback cb, void *data)
Iterate over all the role units and feed them to callback, starting from the last one.
Definition: unittype.cpp:1883

utype_can_do_action
bool utype_can_do_action(const struct unit_type *putype, const action_id act_id)
Return TRUE iff units of the given type can do the specified generalized (ruleset defined) action ena...
Definition: unittype.cpp:386

set_user_unit_type_flag_name
void set_user_unit_type_flag_name(enum unit_type_flag_id id, const char *name, const char *helptxt)
Sets user defined name for unit flag.
Definition: unittype.cpp:1556

utype_veteran_level
const struct veteran_level * utype_veteran_level(const struct unit_type *punittype, int level)
Return veteran level properties of given unit in given veterancy level.
Definition: unittype.cpp:2224

utype_happy_cost
int utype_happy_cost(const struct unit_type *ut, const struct player *pplayer)
Return the "happy cost" (the number of citizens who are discontented) for this unit.
Definition: unittype.cpp:167

utype_ai_data
void * utype_ai_data(const struct unit_type *ptype, const struct ai_type *ai)
Return pointer to ai data of given unit type and ai type.
Definition: unittype.cpp:2332

unit_upgrade_price
int unit_upgrade_price(const struct player *pplayer, const struct unit_type *from, const struct unit_type *to)
Return the cost (gold) of upgrading a single unit of the specified type to the new type.
Definition: unittype.cpp:1407