src/script/api/script_story_page.cpp

   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 script_story_page.cpp Implementation of ScriptStoryPage. */
   9
  10 #include "../../stdafx.h"
  11 #include "script_story_page.hpp"
  12 #include "script_error.hpp"
  13 #include "script_industry.hpp"
  14 #include "script_map.hpp"
  15 #include "script_town.hpp"
  16 #include "script_goal.hpp"
  17 #include "../script_instance.hpp"
  18 #include "../../story_base.h"
  19 #include "../../goal_base.h"
  20 #include "../../string_func.h"
  21 #include "../../tile_map.h"
  22 #include "../../story_cmd.h"
  23
  24 #include "../../safeguards.h"
  25
  26 static inline bool StoryPageElementTypeRequiresText(StoryPageElementType type)
  27 {
  28         return type == SPET_TEXT || type == SPET_LOCATION || type == SPET_BUTTON_PUSH || type == SPET_BUTTON_TILE || type == SPET_BUTTON_VEHICLE;
  29 }
  30
  31 /* static */ bool ScriptStoryPage::IsValidStoryPage(StoryPageID story_page_id)
  32 {
  33         return ::StoryPage::IsValidID(story_page_id);
  34 }
  35
  36 /* static */ bool ScriptStoryPage::IsValidStoryPageElement(StoryPageElementID story_page_element_id)
  37 {
  38         return ::StoryPageElement::IsValidID(story_page_element_id);
  39 }
  40
  41 /* static */ bool ScriptStoryPage::IsValidStoryPageElementType(StoryPageElementType type)
  42 {
  43         return type == SPET_TEXT || type == SPET_LOCATION || type == SPET_GOAL || type == SPET_BUTTON_PUSH || type == SPET_BUTTON_TILE || type == SPET_BUTTON_VEHICLE;
  44 }
  45
  46 /* static */ ScriptStoryPage::StoryPageID ScriptStoryPage::New(ScriptCompany::CompanyID company, Text *title)
  47 {
  48         CCountedPtr<Text> counter(title);
  49
  50         EnforceDeityMode(STORY_PAGE_INVALID);
  51         EnforcePrecondition(STORY_PAGE_INVALID, company == ScriptCompany::COMPANY_INVALID || ScriptCompany::ResolveCompanyID(company) != ScriptCompany::COMPANY_INVALID);
  52
  53         uint8_t c = company;
  54         if (company == ScriptCompany::COMPANY_INVALID) c = INVALID_COMPANY;
  55
  56         if (!ScriptObject::Command<CMD_CREATE_STORY_PAGE>::Do(&ScriptInstance::DoCommandReturnStoryPageID,
  57                 (::CompanyID)c, title != nullptr ? title->GetEncodedText() : std::string{})) return STORY_PAGE_INVALID;
  58
  59         /* In case of test-mode, we return StoryPageID 0 */
  60         return (ScriptStoryPage::StoryPageID)0;
  61 }
  62
  63 /* static */ ScriptStoryPage::StoryPageElementID ScriptStoryPage::NewElement(StoryPageID story_page_id, StoryPageElementType type, SQInteger reference, Text *text)
  64 {
  65         CCountedPtr<Text> counter(text);
  66
  67         ::StoryPageElementType btype = static_cast<::StoryPageElementType>(type);
  68
  69         EnforceDeityMode(STORY_PAGE_ELEMENT_INVALID);
  70         EnforcePrecondition(STORY_PAGE_ELEMENT_INVALID, IsValidStoryPage(story_page_id));
  71         EnforcePrecondition(STORY_PAGE_ELEMENT_INVALID, IsValidStoryPageElementType(type));
  72         std::string encoded_text;
  73         if (StoryPageElementTypeRequiresText(btype)) {
  74                 EnforcePrecondition(STORY_PAGE_ELEMENT_INVALID, text != nullptr);
  75                 encoded_text = text->GetEncodedText();
  76                 EnforcePreconditionEncodedText(STORY_PAGE_ELEMENT_INVALID, encoded_text);
  77         }
  78         EnforcePrecondition(STORY_PAGE_ELEMENT_INVALID, type != SPET_LOCATION || ::IsValidTile((::TileIndex)reference));
  79         EnforcePrecondition(STORY_PAGE_ELEMENT_INVALID, type != SPET_GOAL || ScriptGoal::IsValidGoal((ScriptGoal::GoalID)reference));
  80         EnforcePrecondition(STORY_PAGE_ELEMENT_INVALID, type != SPET_GOAL || !(StoryPage::Get(story_page_id)->company == INVALID_COMPANY && Goal::Get(reference)->company != INVALID_COMPANY));
  81
  82         uint32_t refid = 0;
  83         TileIndex reftile = 0;
  84         switch (type) {
  85                 case SPET_LOCATION:
  86                         reftile = reference;
  87                         break;
  88                 case SPET_GOAL:
  89                 case SPET_BUTTON_PUSH:
  90                 case SPET_BUTTON_TILE:
  91                 case SPET_BUTTON_VEHICLE:
  92                         refid = reference;
  93                         break;
  94                 case SPET_TEXT:
  95                         break;
  96                 default:
  97                         NOT_REACHED();
  98         }
  99
 100         if (!ScriptObject::Command<CMD_CREATE_STORY_PAGE_ELEMENT>::Do(&ScriptInstance::DoCommandReturnStoryPageElementID,
 101                         reftile,
 102                         (::StoryPageID)story_page_id, (::StoryPageElementType)type,
 103                         refid,
 104                         encoded_text)) return STORY_PAGE_ELEMENT_INVALID;
 105
 106         /* In case of test-mode, we return StoryPageElementID 0 */
 107         return (ScriptStoryPage::StoryPageElementID)0;
 108 }
 109
 110 /* static */ bool ScriptStoryPage::UpdateElement(StoryPageElementID story_page_element_id, SQInteger reference, Text *text)
 111 {
 112         CCountedPtr<Text> counter(text);
 113
 114         EnforceDeityMode(false);
 115         EnforcePrecondition(false, IsValidStoryPageElement(story_page_element_id));
 116
 117         const StoryPageElement *pe = StoryPageElement::Get(story_page_element_id);
 118         const StoryPage *p = StoryPage::Get(pe->page);
 119         ::StoryPageElementType type = pe->type;
 120
 121         std::string encoded_text;
 122         if (StoryPageElementTypeRequiresText(type)) {
 123                 EnforcePrecondition(false, text != nullptr);
 124                 encoded_text = text->GetEncodedText();
 125                 EnforcePreconditionEncodedText(false, encoded_text);
 126         }
 127         EnforcePrecondition(false, type != ::SPET_LOCATION || ::IsValidTile((::TileIndex)reference));
 128         EnforcePrecondition(false, type != ::SPET_GOAL || ScriptGoal::IsValidGoal((ScriptGoal::GoalID)reference));
 129         EnforcePrecondition(false, type != ::SPET_GOAL || !(p->company == INVALID_COMPANY && Goal::Get(reference)->company != INVALID_COMPANY));
 130
 131         uint32_t refid = 0;
 132         TileIndex reftile = 0;
 133         switch (type) {
 134                 case ::SPET_LOCATION:
 135                         reftile = reference;
 136                         break;
 137                 case ::SPET_GOAL:
 138                 case ::SPET_BUTTON_PUSH:
 139                 case ::SPET_BUTTON_TILE:
 140                 case ::SPET_BUTTON_VEHICLE:
 141                         refid = reference;
 142                         break;
 143                 case ::SPET_TEXT:
 144                         break;
 145                 default:
 146                         NOT_REACHED();
 147         }
 148
 149         return ScriptObject::Command<CMD_UPDATE_STORY_PAGE_ELEMENT>::Do(reftile, story_page_element_id, refid, encoded_text);
 150 }
 151
 152 /* static */ SQInteger ScriptStoryPage::GetPageSortValue(StoryPageID story_page_id)
 153 {
 154         EnforcePrecondition(false, IsValidStoryPage(story_page_id));
 155
 156         return StoryPage::Get(story_page_id)->sort_value;
 157 }
 158
 159 /* static */ SQInteger ScriptStoryPage::GetPageElementSortValue(StoryPageElementID story_page_element_id)
 160 {
 161         EnforcePrecondition(false, IsValidStoryPageElement(story_page_element_id));
 162
 163         return StoryPageElement::Get(story_page_element_id)->sort_value;
 164 }
 165
 166 /* static */ bool ScriptStoryPage::SetTitle(StoryPageID story_page_id, Text *title)
 167 {
 168         CCountedPtr<Text> counter(title);
 169
 170         EnforcePrecondition(false, IsValidStoryPage(story_page_id));
 171         EnforceDeityMode(false);
 172
 173         return ScriptObject::Command<CMD_SET_STORY_PAGE_TITLE>::Do(story_page_id, title != nullptr ? title->GetEncodedText() : std::string{});
 174 }
 175
 176 /* static */ ScriptCompany::CompanyID ScriptStoryPage::GetCompany(StoryPageID story_page_id)
 177 {
 178         EnforcePrecondition(ScriptCompany::COMPANY_INVALID, IsValidStoryPage(story_page_id));
 179
 180         CompanyID c = StoryPage::Get(story_page_id)->company;
 181         ScriptCompany::CompanyID company = c == INVALID_COMPANY ? ScriptCompany::COMPANY_INVALID : (ScriptCompany::CompanyID)c;
 182
 183         return company;
 184 }
 185
 186 /* static */ ScriptDate::Date ScriptStoryPage::GetDate(StoryPageID story_page_id)
 187 {
 188         EnforcePrecondition(ScriptDate::DATE_INVALID, IsValidStoryPage(story_page_id));
 189         EnforceDeityMode(ScriptDate::DATE_INVALID);
 190
 191         return (ScriptDate::Date)StoryPage::Get(story_page_id)->date.base();
 192 }
 193
 194 /* static */ bool ScriptStoryPage::SetDate(StoryPageID story_page_id, ScriptDate::Date date)
 195 {
 196         EnforcePrecondition(false, IsValidStoryPage(story_page_id));
 197         EnforceDeityMode(false);
 198
 199         return ScriptObject::Command<CMD_SET_STORY_PAGE_DATE>::Do(story_page_id, date);
 200 }
 201
 202
 203 /* static */ bool ScriptStoryPage::Show(StoryPageID story_page_id)
 204 {
 205         EnforcePrecondition(false, IsValidStoryPage(story_page_id));
 206         EnforceDeityMode(false);
 207
 208         return ScriptObject::Command<CMD_SHOW_STORY_PAGE>::Do(story_page_id);
 209 }
 210
 211 /* static */ bool ScriptStoryPage::Remove(StoryPageID story_page_id)
 212 {
 213         EnforceDeityMode(false);
 214         EnforcePrecondition(false, IsValidStoryPage(story_page_id));
 215
 216         return ScriptObject::Command<CMD_REMOVE_STORY_PAGE>::Do(story_page_id);
 217 }
 218
 219 /* static */ bool ScriptStoryPage::RemoveElement(StoryPageElementID story_page_element_id)
 220 {
 221         EnforceDeityMode(false);
 222         EnforcePrecondition(false, IsValidStoryPageElement(story_page_element_id));
 223
 224         return ScriptObject::Command<CMD_REMOVE_STORY_PAGE_ELEMENT>::Do(story_page_element_id);
 225 }
 226
 227 /* static */ bool ScriptStoryPage::IsValidStoryPageButtonColour(StoryPageButtonColour colour)
 228 {
 229         return ::IsValidColours((::Colours)colour);
 230 }
 231
 232 /* static */ bool ScriptStoryPage::IsValidStoryPageButtonFlags(StoryPageButtonFlags flags)
 233 {
 234         /* Don't allow float left and right together */
 235         if ((flags & SPBF_FLOAT_LEFT) && (flags & SPBF_FLOAT_RIGHT)) return false;
 236         /* Don't allow undefined flags */
 237         if (flags & ~(SPBF_FLOAT_LEFT | SPBF_FLOAT_RIGHT)) return false;
 238         return true;
 239 }
 240
 241 /* static */ bool ScriptStoryPage::IsValidStoryPageButtonCursor(StoryPageButtonCursor cursor)
 242 {
 243         return ::IsValidStoryPageButtonCursor((::StoryPageButtonCursor)cursor);
 244 }
 245
 246 /* static */ ScriptStoryPage::StoryPageButtonFormatting ScriptStoryPage::MakePushButtonReference(StoryPageButtonColour colour, StoryPageButtonFlags flags)
 247 {
 248         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonColour(colour));
 249         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonFlags(flags));
 250
 251         StoryPageButtonData data;
 252         data.SetColour((::Colours)colour);
 253         data.SetFlags((::StoryPageButtonFlags)flags);
 254         if (!data.ValidateColour()) return UINT32_MAX;
 255         if (!data.ValidateFlags()) return UINT32_MAX;
 256         return data.referenced_id;
 257 }
 258
 259 /* static */ ScriptStoryPage::StoryPageButtonFormatting ScriptStoryPage::MakeTileButtonReference(StoryPageButtonColour colour, StoryPageButtonFlags flags, StoryPageButtonCursor cursor)
 260 {
 261         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonColour(colour));
 262         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonFlags(flags));
 263         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonCursor(cursor));
 264
 265         StoryPageButtonData data;
 266         data.SetColour((::Colours)colour);
 267         data.SetFlags((::StoryPageButtonFlags)flags);
 268         data.SetCursor((::StoryPageButtonCursor)cursor);
 269         if (!data.ValidateColour()) return UINT32_MAX;
 270         if (!data.ValidateFlags()) return UINT32_MAX;
 271         if (!data.ValidateCursor()) return UINT32_MAX;
 272         return data.referenced_id;
 273 }
 274
 275 /* static */ ScriptStoryPage::StoryPageButtonFormatting ScriptStoryPage::MakeVehicleButtonReference(StoryPageButtonColour colour, StoryPageButtonFlags flags, StoryPageButtonCursor cursor, ScriptVehicle::VehicleType vehtype)
 276 {
 277         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonColour(colour));
 278         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonFlags(flags));
 279         EnforcePrecondition(UINT32_MAX, IsValidStoryPageButtonCursor(cursor));
 280         EnforcePrecondition(UINT32_MAX, vehtype == ScriptVehicle::VT_INVALID || vehtype == ScriptVehicle::VT_RAIL || vehtype == ScriptVehicle::VT_ROAD || vehtype == ScriptVehicle::VT_WATER || vehtype == ScriptVehicle::VT_AIR);
 281
 282         StoryPageButtonData data;
 283         data.SetColour((::Colours)colour);
 284         data.SetFlags((::StoryPageButtonFlags)flags);
 285         data.SetCursor((::StoryPageButtonCursor)cursor);
 286         data.SetVehicleType((::VehicleType)vehtype);
 287         if (!data.ValidateColour()) return UINT32_MAX;
 288         if (!data.ValidateFlags()) return UINT32_MAX;
 289         if (!data.ValidateCursor()) return UINT32_MAX;
 290         if (!data.ValidateVehicleType()) return UINT32_MAX;
 291         return data.referenced_id;
 292 }