story.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#include "stdafx.h"
#include "story_base.h"
#include "core/pool_func.hpp"
#include "command_func.h"
#include "company_base.h"
#include "company_func.h"
#include "string_func.h"
#include "timer/timer_game_calendar.h"
#include "tile_map.h"
#include "goal_type.h"
#include "goal_base.h"
#include "window_func.h"
#include "gui.h"
#include "vehicle_base.h"
#include "game/game.hpp"
#include "script/api/script_story_page.hpp"
#include "script/api/script_event_types.hpp"
#include "story_cmd.h"
 
#include "safeguards.h"
 
 
uint32_t _story_page_element_next_sort_value;
uint32_t _story_page_next_sort_value;
 
StoryPageElementPool _story_page_element_pool("StoryPageElement");
StoryPagePool _story_page_pool("StoryPage");
INSTANTIATE_POOL_METHODS(StoryPageElement)
INSTANTIATE_POOL_METHODS(StoryPage)
 
 
static bool VerifyElementContentParameters(StoryPageID page_id, StoryPageElementType type, TileIndex tile, uint32_t reference, const std::string &text)
{
  StoryPageButtonData button_data{ reference };
 
  switch (type) {
    case SPET_TEXT:
      if (text.empty()) return false;
      break;
    case SPET_LOCATION:
      if (text.empty()) return false;
      if (!IsValidTile(tile)) return false;
      break;
    case SPET_GOAL:
      if (!Goal::IsValidID((GoalID)reference)) return false;
      /* Reject company specific goals on global pages */
      if (StoryPage::Get(page_id)->company == INVALID_COMPANY && Goal::Get((GoalID)reference)->company != INVALID_COMPANY) return false;
      break;
    case SPET_BUTTON_PUSH:
      if (!button_data.ValidateColour()) return false;
      if (!button_data.ValidateFlags()) return false;
      return true;
    case SPET_BUTTON_TILE:
      if (!button_data.ValidateColour()) return false;
      if (!button_data.ValidateFlags()) return false;
      if (!button_data.ValidateCursor()) return false;
      return true;
    case SPET_BUTTON_VEHICLE:
      if (!button_data.ValidateColour()) return false;
      if (!button_data.ValidateFlags()) return false;
      if (!button_data.ValidateCursor()) return false;
      if (!button_data.ValidateVehicleType()) return false;
      return true;
    default:
      return false;
  }
 
  return true;
}
 
static void UpdateElement(StoryPageElement &pe, TileIndex tile, uint32_t reference, const std::string &text)
{
  switch (pe.type) {
    case SPET_TEXT:
      pe.text = text;
      break;
    case SPET_LOCATION:
      pe.text = text;
      pe.referenced_id = tile.base();
      break;
    case SPET_GOAL:
      pe.referenced_id = (GoalID)reference;
      break;
    case SPET_BUTTON_PUSH:
    case SPET_BUTTON_TILE:
    case SPET_BUTTON_VEHICLE:
      pe.text = text;
      pe.referenced_id = reference;
      break;
    default: NOT_REACHED();
  }
}
 
void StoryPageButtonData::SetColour(Colours button_colour)
{
  assert(button_colour < COLOUR_END);
  SB(this->referenced_id, 0, 8, button_colour);
}
 
void StoryPageButtonData::SetFlags(StoryPageButtonFlags flags)
{
  SB(this->referenced_id, 24, 8, flags);
}
 
void StoryPageButtonData::SetCursor(StoryPageButtonCursor cursor)
{
  assert(cursor < SPBC_END);
  SB(this->referenced_id, 8, 8, cursor);
}
 
void StoryPageButtonData::SetVehicleType(VehicleType vehtype)
{
  assert(vehtype == VEH_INVALID || vehtype < VEH_COMPANY_END);
  SB(this->referenced_id, 16, 8, vehtype);
}
 
Colours StoryPageButtonData::GetColour() const
{
  Colours colour = static_cast<Colours>(GB(this->referenced_id, 0, 8));
  if (!IsValidColours(colour)) return INVALID_COLOUR;
  return colour;
}
 
StoryPageButtonFlags StoryPageButtonData::GetFlags() const
{
  return (StoryPageButtonFlags)GB(this->referenced_id, 24, 8);
}
 
StoryPageButtonCursor StoryPageButtonData::GetCursor() const
{
  StoryPageButtonCursor cursor = (StoryPageButtonCursor)GB(this->referenced_id, 8, 8);
  if (!IsValidStoryPageButtonCursor(cursor)) return INVALID_SPBC;
  return cursor;
}
 
VehicleType StoryPageButtonData::GetVehicleType() const
{
  return (VehicleType)GB(this->referenced_id, 16, 8);
}
 
bool StoryPageButtonData::ValidateColour() const
{
  return GB(this->referenced_id, 0, 8) < COLOUR_END;
}
 
bool StoryPageButtonData::ValidateFlags() const
{
  uint8_t flags = GB(this->referenced_id, 24, 8);
  /* Don't allow float left and right together */
  if ((flags & SPBF_FLOAT_LEFT) && (flags & SPBF_FLOAT_RIGHT)) return false;
  /* Don't allow undefined flags */
  if (flags & ~(SPBF_FLOAT_LEFT | SPBF_FLOAT_RIGHT)) return false;
  return true;
}
 
bool StoryPageButtonData::ValidateCursor() const
{
  return GB(this->referenced_id, 8, 8) < SPBC_END;
}
 
bool StoryPageButtonData::ValidateVehicleType() const
{
  uint8_t vehtype = GB(this->referenced_id, 16, 8);
  return vehtype == VEH_INVALID || vehtype < VEH_COMPANY_END;
}
 
std::tuple<CommandCost, StoryPageID> CmdCreateStoryPage(DoCommandFlag flags, CompanyID company, const std::string &text)
{
  if (!StoryPage::CanAllocateItem()) return { CMD_ERROR, INVALID_STORY_PAGE };
 
  if (_current_company != OWNER_DEITY) return { CMD_ERROR, INVALID_STORY_PAGE };
  if (company != INVALID_COMPANY && !Company::IsValidID(company)) return { CMD_ERROR, INVALID_STORY_PAGE };
 
  if (flags & DC_EXEC) {
    if (_story_page_pool.items == 0) {
      /* Initialize the next sort value variable. */
      _story_page_next_sort_value = 0;
    }
 
    StoryPage *s = new StoryPage();
    s->sort_value = _story_page_next_sort_value;
    s->date = TimerGameCalendar::date;
    s->company = company;
    s->title = text;
 
    InvalidateWindowClassesData(WC_STORY_BOOK, -1);
    if (StoryPage::GetNumItems() == 1) InvalidateWindowData(WC_MAIN_TOOLBAR, 0);
 
    _story_page_next_sort_value++;
    return { CommandCost(), s->index };
  }
 
  return { CommandCost(), INVALID_STORY_PAGE };
}
 
std::tuple<CommandCost, StoryPageElementID> CmdCreateStoryPageElement(DoCommandFlag flags, TileIndex tile, StoryPageID page_id, StoryPageElementType type, uint32_t reference, const std::string &text)
{
  if (!StoryPageElement::CanAllocateItem()) return { CMD_ERROR, INVALID_STORY_PAGE_ELEMENT };
 
  /* Allow at most 128 elements per page. */
  uint16_t element_count = 0;
  for (StoryPageElement *iter : StoryPageElement::Iterate()) {
    if (iter->page == page_id) element_count++;
  }
  if (element_count >= 128) return { CMD_ERROR, INVALID_STORY_PAGE_ELEMENT };
 
  if (_current_company != OWNER_DEITY) return { CMD_ERROR, INVALID_STORY_PAGE_ELEMENT };
  if (!StoryPage::IsValidID(page_id)) return { CMD_ERROR, INVALID_STORY_PAGE_ELEMENT };
  if (!VerifyElementContentParameters(page_id, type, tile, reference, text)) return { CMD_ERROR, INVALID_STORY_PAGE_ELEMENT };
 
 
  if (flags & DC_EXEC) {
    if (_story_page_element_pool.items == 0) {
      /* Initialize the next sort value variable. */
      _story_page_element_next_sort_value = 0;
    }
 
    StoryPageElement *pe = new StoryPageElement();
    pe->sort_value = _story_page_element_next_sort_value;
    pe->type = type;
    pe->page = page_id;
    UpdateElement(*pe, tile, reference, text);
 
    InvalidateWindowClassesData(WC_STORY_BOOK, page_id);
 
    _story_page_element_next_sort_value++;
    return { CommandCost(), pe->index };
  }
 
  return { CommandCost(), INVALID_STORY_PAGE_ELEMENT };
}
 
CommandCost CmdUpdateStoryPageElement(DoCommandFlag flags, TileIndex tile, StoryPageElementID page_element_id, uint32_t reference, const std::string &text)
{
  if (_current_company != OWNER_DEITY) return CMD_ERROR;
  if (!StoryPageElement::IsValidID(page_element_id)) return CMD_ERROR;
 
  StoryPageElement *pe = StoryPageElement::Get(page_element_id);
  StoryPageID page_id = pe->page;
  StoryPageElementType type = pe->type;
 
  if (!VerifyElementContentParameters(page_id, type, tile, reference, text)) return CMD_ERROR;
 
  if (flags & DC_EXEC) {
    UpdateElement(*pe, tile, reference, text);
    InvalidateWindowClassesData(WC_STORY_BOOK, pe->page);
  }
 
  return CommandCost();
}
 
CommandCost CmdSetStoryPageTitle(DoCommandFlag flags, StoryPageID page_id, const std::string &text)
{
  if (_current_company != OWNER_DEITY) return CMD_ERROR;
  if (!StoryPage::IsValidID(page_id)) return CMD_ERROR;
 
  if (flags & DC_EXEC) {
    StoryPage *p = StoryPage::Get(page_id);
    p->title = text;
 
    InvalidateWindowClassesData(WC_STORY_BOOK, page_id);
  }
 
  return CommandCost();
}
 
CommandCost CmdSetStoryPageDate(DoCommandFlag flags, StoryPageID page_id, TimerGameCalendar::Date date)
{
  if (_current_company != OWNER_DEITY) return CMD_ERROR;
  if (!StoryPage::IsValidID(page_id)) return CMD_ERROR;
 
  if (flags & DC_EXEC) {
    StoryPage *p = StoryPage::Get(page_id);
    p->date = date;
 
    InvalidateWindowClassesData(WC_STORY_BOOK, page_id);
  }
 
  return CommandCost();
}
 
CommandCost CmdShowStoryPage(DoCommandFlag flags, StoryPageID page_id)
{
  if (_current_company != OWNER_DEITY) return CMD_ERROR;
  if (!StoryPage::IsValidID(page_id)) return CMD_ERROR;
 
  if (flags & DC_EXEC) {
    StoryPage *g = StoryPage::Get(page_id);
    if ((g->company != INVALID_COMPANY && g->company == _local_company) || (g->company == INVALID_COMPANY && Company::IsValidID(_local_company))) ShowStoryBook(_local_company, page_id, true);
  }
 
  return CommandCost();
}
CommandCost CmdRemoveStoryPage(DoCommandFlag flags, StoryPageID page_id)
{
  if (_current_company != OWNER_DEITY) return CMD_ERROR;
  if (!StoryPage::IsValidID(page_id)) return CMD_ERROR;
 
  if (flags & DC_EXEC) {
    StoryPage *p = StoryPage::Get(page_id);
 
    for (StoryPageElement *pe : StoryPageElement::Iterate()) {
      if (pe->page == p->index) {
        delete pe;
      }
    }
 
    delete p;
 
    InvalidateWindowClassesData(WC_STORY_BOOK, -1);
    if (StoryPage::GetNumItems() == 0) InvalidateWindowData(WC_MAIN_TOOLBAR, 0);
  }
 
  return CommandCost();
}
 
CommandCost CmdRemoveStoryPageElement(DoCommandFlag flags, StoryPageElementID page_element_id)
{
  if (_current_company != OWNER_DEITY) return CMD_ERROR;
  if (!StoryPageElement::IsValidID(page_element_id)) return CMD_ERROR;
 
  if (flags & DC_EXEC) {
    StoryPageElement *pe = StoryPageElement::Get(page_element_id);
    StoryPageID page_id = pe->page;
 
    delete pe;
 
    InvalidateWindowClassesData(WC_STORY_BOOK, page_id);
  }
 
  return CommandCost();
}
 
CommandCost CmdStoryPageButton(DoCommandFlag flags, TileIndex tile, StoryPageElementID page_element_id, VehicleID reference)
{
  if (!StoryPageElement::IsValidID(page_element_id)) return CMD_ERROR;
  const StoryPageElement *const pe = StoryPageElement::Get(page_element_id);
 
  /* Check the player belongs to the company that owns the page. */
  const StoryPage *const sp = StoryPage::Get(pe->page);
  if (sp->company != INVALID_COMPANY && sp->company != _current_company) return CMD_ERROR;
 
  switch (pe->type) {
    case SPET_BUTTON_PUSH:
      /* No validation required */
      if (flags & DC_EXEC) Game::NewEvent(new ScriptEventStoryPageButtonClick(_current_company, pe->page, page_element_id));
      break;
    case SPET_BUTTON_TILE:
      if (!IsValidTile(tile)) return CMD_ERROR;
      if (flags & DC_EXEC) Game::NewEvent(new ScriptEventStoryPageTileSelect(_current_company, pe->page, page_element_id, tile));
      break;
    case SPET_BUTTON_VEHICLE:
      if (!Vehicle::IsValidID(reference)) return CMD_ERROR;
      if (flags & DC_EXEC) Game::NewEvent(new ScriptEventStoryPageVehicleSelect(_current_company, pe->page, page_element_id, reference));
      break;
    default:
      /* Invalid page element type, not a button. */
      return CMD_ERROR;
  }
 
  return CommandCost();
}