/* $Id$ */
/** @file industry.h */
# ifndef INDUSTRY_H
# define INDUSTRY_H
# include "oldpool.h"
# include "core/random_func.hpp"
# include "newgrf_storage.h"
# include "cargo_type.h"
# include "economy_type.h"
# include "map_type.h"
# include "slope_type.h"
# include "date_type.h"
# include "town_type.h"
# include "industry_type.h"
# include "newgrf_string_type.h"
enum {
INVALID_INDUSTRY = 0xFFFF ,
NEW_INDUSTRYOFFSET = 37 , ///< original number of industries
NUM_INDUSTRYTYPES = 64 , ///< total number of industries, new and old
INDUSTRYTILE_NOANIM = 0xFF , ///< flag to mark industry tiles as having no animation
NEW_INDUSTRYTILEOFFSET = 175 , ///< original number of tiles
INVALID_INDUSTRYTYPE = NUM_INDUSTRYTYPES , ///< one above amount is considered invalid
NUM_INDUSTRYTILES = 512 , ///< total number of industry tiles, new and old
INVALID_INDUSTRYTILE = NUM_INDUSTRYTILES , ///< one above amount is considered invalid
INDUSTRY_COMPLETED = 3 , ///< final stage of industry construction.
} ;
enum {
CLEAN_RANDOMSOUNDS , ///< Free the dynamically allocated sounds table
CLEAN_TILELSAYOUT , ///< Free the dynamically allocated tile layout structure
} ;
enum IndustryLifeType {
INDUSTRYLIFE_BLACK_HOLE = 0 , ///< Like power plants and banks
INDUSTRYLIFE_EXTRACTIVE = 1 < < 0 , ///< Like mines
INDUSTRYLIFE_ORGANIC = 1 < < 1 , ///< Like forests
INDUSTRYLIFE_PROCESSING = 1 < < 2 , ///< Like factories
} ;
/* Procedures that can be run to check whether an industry may
* build at location the given to the procedure */
enum CheckProc {
CHECK_NOTHING ,
CHECK_FOREST ,
CHECK_REFINERY ,
CHECK_FARM ,
CHECK_PLANTATION ,
CHECK_WATER ,
CHECK_LUMBERMILL ,
CHECK_BUBBLEGEN ,
CHECK_OIL_RIG ,
CHECK_END ,
} ;
/** How was the industry created */
enum IndustryConstructionType {
ICT_UNKNOWN , ///< in previous game version or without newindustries activated
ICT_NORMAL_GAMEPLAY , ///< either by user or random creation proccess
ICT_MAP_GENERATION , ///< during random map creation
ICT_SCENARIO_EDITOR ///< while scenarion edition
} ;
enum IndustryBehaviour {
INDUSTRYBEH_NONE = 0 ,
INDUSTRYBEH_PLANT_FIELDS = 1 < < 0 , ///< periodically plants fileds around itself (temp and artic farms)
INDUSTRYBEH_CUT_TREES = 1 < < 1 , ///< cuts trees and produce first output cargo from them (lumber mill)
INDUSTRYBEH_BUILT_ONWATER = 1 < < 2 , ///< is built on water (oil rig)
INDUSTRYBEH_TOWN1200_MORE = 1 < < 3 , ///< can only be built in towns larger then 1200 inhabitants (temperate bank)
INDUSTRYBEH_ONLY_INTOWN = 1 < < 4 , ///< can only be built in towns (arctic/tropic banks, water tower)
INDUSTRYBEH_ONLY_NEARTOWN = 1 < < 5 , ///< is always built near towns (toy shop)
INDUSTRYBEH_PLANT_ON_BUILT = 1 < < 6 , ///< Fields are planted around when built (all farms)
INDUSTRYBEH_DONT_INCR_PROD = 1 < < 7 , ///< do not increase production (oil wells) in the temperate climate
INDUSTRYBEH_BEFORE_1950 = 1 < < 8 , ///< can only be built before 1950 (oil wells)
INDUSTRYBEH_AFTER_1960 = 1 < < 9 , ///< can only be built after 1960 (oil rigs)
INDUSTRYBEH_AI_AIRSHIP_ROUTES = 1 < < 10 , ///< ai will attempt to establish air/ship routes to this industry (oil rig)
INDUSTRYBEH_AIRPLANE_ATTACKS = 1 < < 11 , ///< can be exploded by a military airplane (oil refinery)
INDUSTRYBEH_CHOPPER_ATTACKS = 1 < < 12 , ///< can be exploded by a military helicopter (factory)
INDUSTRYBEH_CAN_SUBSIDENCE = 1 < < 13 , ///< can cause a subsidence (coal mine, shaft that collapses)
/* The following flags are only used for newindustries and do no represent any normal behaviour */
INDUSTRYBEH_PROD_MULTI_HNDLING = 1 < < 14 , ///< Automatic production multiplier handling
INDUSTRYBEH_PRODCALLBACK_RANDOM = 1 < < 15 , ///< Production callback needs random bits in var 10
INDUSTRYBEH_NOBUILT_MAPCREATION = 1 < < 16 , ///< Do not force one instance of this type to appear on map generation
INDUSTRYBEH_CANCLOSE_LASTINSTANCE = 1 < < 17 , ///< Allow closing down the last instance of this type
} ;
DECLARE_ENUM_AS_BIT_SET ( IndustryBehaviour ) ;
DECLARE_OLD_POOL ( Industry , Industry , 3 , 8000 )
/**
* Defines the internal data of a functionnal industry
*/
struct Industry : PoolItem < Industry , IndustryID , & _Industry_pool > {
typedef PersistentStorageArray < uint32 , 16 > PersistentStorage ;
TileIndex xy ; ///< coordinates of the primary tile the industry is built one
byte width ;
byte height ;
const Town * town ; ///< Nearest town
CargoID produced_cargo [ 2 ] ; ///< 2 production cargo slots
uint16 produced_cargo_waiting [ 2 ] ; ///< amount of cargo produced per cargo
uint16 incoming_cargo_waiting [ 3 ] ; ///< incoming cargo waiting to be processed
byte production_rate [ 2 ] ; ///< production rate for each cargo
byte prod_level ; ///< general production level
CargoID accepts_cargo [ 3 ] ; ///< 3 input cargo slots
uint16 this_month_production [ 2 ] ; ///< stats of this month's production per cargo
uint16 this_month_transported [ 2 ] ; ///< stats of this month's transport per cargo
byte last_month_pct_transported [ 2 ] ; ///< percentage transported per cargo in the last full month
uint16 last_month_production [ 2 ] ; ///< total units produced per cargo in the last full month
uint16 last_month_transported [ 2 ] ; ///< total units transported per cargo in the last full month
uint16 counter ; ///< used for animation and/or production (if available cargo)
IndustryType type ; ///< type of industry.
OwnerByte owner ; ///< owner of the industry. Which SHOULD always be (imho) OWNER_NONE
byte random_color ; ///< randomized colour of the industry, for display purpose
Year last_prod_year ; ///< last year of production
byte was_cargo_delivered ; ///< flag that indicate this has been the closest industry chosen for cargo delivery by a station. see DeliverGoodsToIndustry
OwnerByte founder ; ///< Founder of the industry
Date construction_date ; ///< Date of the construction of the industry
uint8 construction_type ; ///< Way the industry was constructed (@see IndustryConstructionType)
Date last_cargo_accepted_at ; ///< Last day cargo was accepted by this industry
byte selected_layout ; ///< Which tile layout was used when creating the industry
byte random_triggers ; ///< Triggers for the random
uint16 random ; ///< Random value used for randomisation of all kinds of things
PersistentStorage psa ; ///< Persistent storage for NewGRF industries.
Industry ( TileIndex tile = 0 ) : xy ( tile ) { }
~ Industry ( ) ;
inline bool IsValid ( ) const { return this - > xy ! = 0 ; }
} ;
struct IndustryTileTable {
TileIndexDiffC ti ;
IndustryGfx gfx ;
} ;
/** Data related to the handling of grf files. Common to both industry and industry tile */
struct GRFFileProps {
uint16 subst_id ;
uint16 local_id ; ///< id defined by the grf file for this industry
struct SpriteGroup * spritegroup ; ///< pointer to the different sprites of the industry
const struct GRFFile * grffile ; ///< grf file that introduced this industry
uint16 override ; ///< id of the entity been replaced by
} ;
/**
* Defines the data structure for constructing industry .
*/
struct IndustrySpec {
const IndustryTileTable * const * table ; ///< List of the tiles composing the industry
byte num_table ; ///< Number of elements in the table
uint8 cost_multiplier ; ///< Base construction cost multiplier.
uint32 removal_cost_multiplier ; ///< Base removal cost multiplier.
uint16 raw_industry_cost_multiplier ; ///< Multiplier for the raw industries cost
uint32 prospecting_chance ; ///< Chance prospecting succeeds
IndustryType conflicting [ 3 ] ; ///< Industries this industry cannot be close to
byte check_proc ; ///< Index to a procedure to check for conflicting circumstances
CargoID produced_cargo [ 2 ] ;
byte production_rate [ 2 ] ;
byte minimal_cargo ; ///< minimum amount of cargo transported to the stations
///< If the waiting cargo is less than this number, no cargo is moved to it
CargoID accepts_cargo [ 3 ] ; ///< 3 accepted cargos
uint16 input_cargo_multiplier [ 3 ] [ 2 ] ; ///< Input cargo multipliers (multiply amount of incoming cargo for the produced cargos)
IndustryLifeType life_type ; ///< This is also known as Industry production flag, in newgrf specs
byte climate_availability ; ///< Bitmask, giving landscape enums as bit position
IndustryBehaviour behaviour ; ///< How this industry will behave, and how others entities can use it
byte map_colour ; ///< colour used for the small map
GRFMappedStringID name ; ///< Displayed name of the industry
GRFMappedStringID new_industry_text ; ///< Message appearing when the industry is built
GRFMappedStringID closure_text ; ///< Message appearing when the industry closes
GRFMappedStringID production_up_text ; ///< Message appearing when the industry's production is increasing
GRFMappedStringID production_down_text ; ///< Message appearing when the industry's production is decreasing
GRFMappedStringID station_name ; ///< Default name for nearby station
byte appear_ingame [ NUM_LANDSCAPE ] ; ///< Probability of appearance in game
byte appear_creation [ NUM_LANDSCAPE ] ; ///< Probability of appearance during map creation
uint8 number_of_sounds ; ///< Number of sounds available in the sounds array
const uint8 * random_sounds ; ///< array of random sounds.
/* Newgrf data */
uint16 callback_flags ; ///< Flags telling which grf callback is set
uint8 cleanup_flag ; ///< flags indicating which data should be freed upon cleaning up
bool enabled ; ///< entity still avaible (by default true).newgrf can disable it, though
struct GRFFileProps grf_prop ; ///< properties related the the grf file
/**
* Is an industry with the spec a raw industry ?
* @ return true if it should be handled as a raw industry
*/
bool IsRawIndustry ( ) const ;
/**
* Get the cost for constructing this industry
* @ return the cost ( inflation corrected etc )
*/
Money GetConstructionCost ( ) const ;
/**
* Get the cost for removing this industry
* Take note that the cost will always be zero for non - grf industries .
* Only if the grf author did specified a cost will it be applicable .
* @ return the cost ( inflation corrected etc )
*/
Money GetRemovalCost ( ) const ;
} ;
/**
* Defines the data structure of each indivudual tile of an industry .
*/
struct IndustryTileSpec {
CargoID accepts_cargo [ 3 ] ; ///< Cargo accepted by this tile
uint8 acceptance [ 3 ] ; ///< Level of aceptance per cargo type
Slope slopes_refused ; ///< slope pattern on which this tile cannot be built
byte anim_production ; ///< Animation frame to start when goods are produced
byte anim_next ; ///< Next frame in an animation
bool anim_state ; ///< When true, the tile has to be drawn using the animation
///< state instead of the construction state
/* Newgrf data */
uint8 callback_flags ; ///< Flags telling which grf callback is set
uint16 animation_info ; ///< Information about the animation (is it looping, how many loops etc)
uint8 animation_speed ; ///< The speed of the animation
uint8 animation_triggers ; ///< When to start the animation
uint8 animation_special_flags ; ///< Extra flags to influence the animation
bool enabled ; ///< entity still avaible (by default true).newgrf can disable it, though
struct GRFFileProps grf_prop ;
} ;
/* industry_cmd.cpp*/
const IndustrySpec * GetIndustrySpec ( IndustryType thistype ) ; ///< Array of industries data
const IndustryTileSpec * GetIndustryTileSpec ( IndustryGfx gfx ) ; ///< Array of industry tiles data
void ResetIndustries ( ) ;
void PlantRandomFarmField ( const Industry * i ) ;
/* writable arrays of specs */
extern IndustrySpec _industry_specs [ NUM_INDUSTRYTYPES ] ;
extern IndustryTileSpec _industry_tile_specs [ NUM_INDUSTRYTILES ] ;
static inline IndustryGfx GetTranslatedIndustryTileID ( IndustryGfx gfx )
{
/* the 0xFF should be GFX_WATERTILE_SPECIALCHECK but for reasons of include mess,
* we ' ll simplify the writing .
* Basically , the first test is required since the GFX_WATERTILE_SPECIALCHECK value
* will never be assigned as a tile index and is only required in order to do some
* tests while building the industry ( as in WATER REQUIRED */
if ( gfx ! = 0xFF ) {
assert ( gfx < INVALID_INDUSTRYTILE ) ;
const IndustryTileSpec * it = & _industry_tile_specs [ gfx ] ;
return it - > grf_prop . override = = INVALID_INDUSTRYTILE ? gfx : it - > grf_prop . override ;
} else {
return gfx ;
}
}
/* smallmap_gui.cpp */
void BuildIndustriesLegend ( ) ;
/**
* Check if an Industry exists whithin the pool of industries
* @ param index of the desired industry
* @ return true if it is inside the pool
*/
static inline bool IsValidIndustryID ( IndustryID index )
{
return index < GetIndustryPoolSize ( ) & & GetIndustry ( index ) - > IsValid ( ) ;
}
static inline IndustryID GetMaxIndustryIndex ( )
{
/* TODO - This isn't the real content of the function, but
* with the new pool - system this will be replaced with one that
* _really_ returns the highest index . Now it just returns
* the next safe value we are sure about everything is below .
*/
return GetIndustryPoolSize ( ) - 1 ;
}
extern int _total_industries ; // general counter
extern uint16 _industry_counts [ NUM_INDUSTRYTYPES ] ; // Number of industries per type ingame
static inline uint GetNumIndustries ( )
{
return _total_industries ;
}
/** Increment the count of industries for this type
* @ param type IndustryType to increment
* @ pre type < INVALID_INDUSTRYTYPE */
static inline void IncIndustryTypeCount ( IndustryType type )
{
assert ( type < INVALID_INDUSTRYTYPE ) ;
_industry_counts [ type ] + + ;
_total_industries + + ;
}
/** Decrement the count of industries for this type
* @ param type IndustryType to decrement
* @ pre type < INVALID_INDUSTRYTYPE */
static inline void DecIndustryTypeCount ( IndustryType type )
{
assert ( type < INVALID_INDUSTRYTYPE ) ;
_industry_counts [ type ] - - ;
_total_industries - - ;
}
/** get the count of industries for this type
* @ param type IndustryType to query
* @ pre type < INVALID_INDUSTRYTYPE */
static inline uint8 GetIndustryTypeCount ( IndustryType type )
{
assert ( type < INVALID_INDUSTRYTYPE ) ;
return min ( _industry_counts [ type ] , 0xFF ) ; // callback expects only a byte, so cut it
}
/** Resets both the total_industries and the _industry_counts
* This way , we centralize all counts activities */
static inline void ResetIndustryCounts ( )
{
_total_industries = 0 ;
memset ( & _industry_counts , 0 , sizeof ( _industry_counts ) ) ;
}
/**
* Return a random valid industry .
*/
static inline Industry * GetRandomIndustry ( )
{
int num = RandomRange ( GetNumIndustries ( ) ) ;
IndustryID index = INVALID_INDUSTRY ;
if ( GetNumIndustries ( ) = = 0 ) return NULL ;
while ( num > = 0 ) {
num - - ;
index + + ;
/* Make sure we have a valid industry */
while ( ! IsValidIndustryID ( index ) ) {
index + + ;
assert ( index < = GetMaxIndustryIndex ( ) ) ;
}
}
return GetIndustry ( index ) ;
}
# define FOR_ALL_INDUSTRIES_FROM(i, start) for (i = GetIndustry(start); i != NULL; i = (i->index + 1U < GetIndustryPoolSize()) ? GetIndustry(i->index + 1U) : NULL) if (i->IsValid())
# define FOR_ALL_INDUSTRIES(i) FOR_ALL_INDUSTRIES_FROM(i, 0)
extern const Industry * * _industry_sort ;
extern bool _industry_sort_dirty ;
static const uint8 IT_INVALID = 255 ;
# endif /* INDUSTRY_H */