src/story_base.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD 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, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file story_base.h %StoryPage base class. */
   9
  10 #ifndef STORY_BASE_H
  11 #define STORY_BASE_H
  12
  13 #include "company_type.h"
  14 #include "story_type.h"
  15 #include "date_type.h"
  16 #include "gfx_type.h"
  17 #include "vehicle_type.h"
  18 #include "core/pool_type.hpp"
  19
  20 typedef Pool<StoryPageElement, StoryPageElementID, 64, 64000> StoryPageElementPool;
  21 typedef Pool<StoryPage, StoryPageID, 64, 64000> StoryPagePool;
  22 extern StoryPageElementPool _story_page_element_pool;
  23 extern StoryPagePool _story_page_pool;
  24 extern uint32 _story_page_element_next_sort_value;
  25 extern uint32 _story_page_next_sort_value;
  26
  27 /*
  28  * Each story page element is one of these types.
  29  */
  30 enum StoryPageElementType : byte {
  31         SPET_TEXT = 0,       ///< A text element.
  32         SPET_LOCATION,       ///< An element that references a tile along with a one-line text.
  33         SPET_GOAL,           ///< An element that references a goal.
  34         SPET_BUTTON_PUSH,    ///< A push button that triggers an immediate event.
  35         SPET_BUTTON_TILE,    ///< A button that allows the player to select a tile, and triggers an event with the tile.
  36         SPET_BUTTON_VEHICLE, ///< A button that allows the player to select a vehicle, and triggers an event wih the vehicle.
  37         SPET_END,
  38         INVALID_SPET = 0xFF,
  39 };
  40
  41 /** Define basic enum properties */
  42 template <> struct EnumPropsT<StoryPageElementType> : MakeEnumPropsT<StoryPageElementType, byte, SPET_TEXT, SPET_END, INVALID_SPET, 8> {};
  43
  44 /** Flags available for buttons */
  45 enum StoryPageButtonFlags : byte {
  46         SPBF_NONE        = 0,
  47         SPBF_FLOAT_LEFT  = 1 << 0,
  48         SPBF_FLOAT_RIGHT = 1 << 1,
  49 };
  50 DECLARE_ENUM_AS_BIT_SET(StoryPageButtonFlags)
  51
  52 /** Mouse cursors usable by story page buttons. */
  53 enum StoryPageButtonCursor : byte {
  54         SPBC_MOUSE,
  55         SPBC_ZZZ,
  56         SPBC_BUOY,
  57         SPBC_QUERY,
  58         SPBC_HQ,
  59         SPBC_SHIP_DEPOT,
  60         SPBC_SIGN,
  61         SPBC_TREE,
  62         SPBC_BUY_LAND,
  63         SPBC_LEVEL_LAND,
  64         SPBC_TOWN,
  65         SPBC_INDUSTRY,
  66         SPBC_ROCKY_AREA,
  67         SPBC_DESERT,
  68         SPBC_TRANSMITTER,
  69         SPBC_AIRPORT,
  70         SPBC_DOCK,
  71         SPBC_CANAL,
  72         SPBC_LOCK,
  73         SPBC_RIVER,
  74         SPBC_AQUEDUCT,
  75         SPBC_BRIDGE,
  76         SPBC_RAIL_STATION,
  77         SPBC_TUNNEL_RAIL,
  78         SPBC_TUNNEL_ELRAIL,
  79         SPBC_TUNNEL_MONO,
  80         SPBC_TUNNEL_MAGLEV,
  81         SPBC_AUTORAIL,
  82         SPBC_AUTOELRAIL,
  83         SPBC_AUTOMONO,
  84         SPBC_AUTOMAGLEV,
  85         SPBC_WAYPOINT,
  86         SPBC_RAIL_DEPOT,
  87         SPBC_ELRAIL_DEPOT,
  88         SPBC_MONO_DEPOT,
  89         SPBC_MAGLEV_DEPOT,
  90         SPBC_CONVERT_RAIL,
  91         SPBC_CONVERT_ELRAIL,
  92         SPBC_CONVERT_MONO,
  93         SPBC_CONVERT_MAGLEV,
  94         SPBC_AUTOROAD,
  95         SPBC_AUTOTRAM,
  96         SPBC_ROAD_DEPOT,
  97         SPBC_BUS_STATION,
  98         SPBC_TRUCK_STATION,
  99         SPBC_ROAD_TUNNEL,
 100         SPBC_CLONE_TRAIN,
 101         SPBC_CLONE_ROADVEH,
 102         SPBC_CLONE_SHIP,
 103         SPBC_CLONE_AIRPLANE,
 104         SPBC_DEMOLISH,
 105         SPBC_LOWERLAND,
 106         SPBC_RAISELAND,
 107         SPBC_PICKSTATION,
 108         SPBC_BUILDSIGNALS,
 109         SPBC_END,
 110         INVALID_SPBC = 0xFF
 111 };
 112
 113 /** Define basic enum properties */
 114 template <> struct EnumPropsT<StoryPageButtonCursor> : MakeEnumPropsT<StoryPageButtonCursor, byte, SPBC_MOUSE, SPBC_END, INVALID_SPBC, 8> {};
 115
 116 /** Helper to construct packed "id" values for button-type StoryPageElement */
 117 struct StoryPageButtonData {
 118         uint32 referenced_id;
 119
 120         void SetColour(Colours button_colour);
 121         void SetFlags(StoryPageButtonFlags flags);
 122         void SetCursor(StoryPageButtonCursor cursor);
 123         void SetVehicleType(VehicleType vehtype);
 124         Colours GetColour() const;
 125         StoryPageButtonFlags GetFlags() const;
 126         StoryPageButtonCursor GetCursor() const;
 127         VehicleType GetVehicleType() const;
 128         bool ValidateColour() const;
 129         bool ValidateFlags() const;
 130         bool ValidateCursor() const;
 131         bool ValidateVehicleType() const;
 132 };
 133
 134 /**
 135  * Struct about story page elements.
 136  * Each StoryPage is composed of one or more page elements that provide
 137  * page content. Each element only contain one type of content.
 138  **/
 139 struct StoryPageElement : StoryPageElementPool::PoolItem<&_story_page_element_pool> {
 140         uint32 sort_value;         ///< A number that increases for every created story page element. Used for sorting. The id of a story page element is the pool index.
 141         StoryPageID page;          ///< Id of the page which the page element belongs to
 142         StoryPageElementType type; ///< Type of page element
 143
 144         uint32 referenced_id;      ///< Id of referenced object (location, goal etc.)
 145         char *text;                ///< Static content text of page element
 146
 147         /**
 148          * We need an (empty) constructor so struct isn't zeroed (as C++ standard states)
 149          */
 150         inline StoryPageElement() { }
 151
 152         /**
 153          * (Empty) destructor has to be defined else operator delete might be called with nullptr parameter
 154          */
 155         inline ~StoryPageElement() { free(this->text); }
 156 };
 157
 158 /** Struct about stories, current and completed */
 159 struct StoryPage : StoryPagePool::PoolItem<&_story_page_pool> {
 160         uint32 sort_value;   ///< A number that increases for every created story page. Used for sorting. The id of a story page is the pool index.
 161         Date date;           ///< Date when the page was created.
 162         CompanyID company;   ///< StoryPage is for a specific company; INVALID_COMPANY if it is global
 163
 164         char *title;         ///< Title of story page
 165
 166         /**
 167          * We need an (empty) constructor so struct isn't zeroed (as C++ standard states)
 168          */
 169         inline StoryPage() { }
 170
 171         /**
 172          * (Empty) destructor has to be defined else operator delete might be called with nullptr parameter
 173          */
 174         inline ~StoryPage()
 175         {
 176                 if (!this->CleaningPool()) {
 177                         for (StoryPageElement *spe : StoryPageElement::Iterate()) {
 178                                 if (spe->page == this->index) delete spe;
 179                         }
 180                 }
 181                 free(this->title);
 182         }
 183 };
 184
 185 #endif /* STORY_BASE_H */
 186