script_instance.hpp

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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef SCRIPT_INSTANCE_HPP
#define SCRIPT_INSTANCE_HPP
 
#include <variant>
#include <squirrel.h>
#include "script_suspend.hpp"
#include "script_log_types.hpp"
 
#include "../command_type.h"
#include "../company_type.h"
#include "../fileio_type.h"
 
static const uint SQUIRREL_MAX_DEPTH = 25; 

class ScriptInstance {
private:
  enum SQSaveLoadType : uint8_t {
    SQSL_INT             = 0x00, 
    SQSL_STRING          = 0x01, 
    SQSL_ARRAY           = 0x02, 
    SQSL_TABLE           = 0x03, 
    SQSL_BOOL            = 0x04, 
    SQSL_NULL            = 0x05, 
    SQSL_INSTANCE        = 0x06, 
    SQSL_ARRAY_TABLE_END = 0xFF, 
  };
 
public:
  friend class ScriptObject;
  friend class ScriptController;
 
  typedef std::variant<SQInteger, std::string, SQBool, SQSaveLoadType> ScriptDataVariant;
  typedef std::list<ScriptDataVariant> ScriptData;

  ScriptInstance(std::string_view api_name);
  virtual ~ScriptInstance();

  void Initialize(const std::string &main_script, const std::string &instance_name, CompanyID company);

  virtual int GetSetting(const std::string &name) = 0;

  virtual class ScriptInfo *FindLibrary(const std::string &library, int version) = 0;

  void Continue();

  void GameLoop();

  void CollectGarbage();

  class ScriptStorage &GetStorage();

  ScriptLogTypes::LogData &GetLogData();

  static void DoCommandReturn(ScriptInstance &instance);

  static void DoCommandReturnVehicleID(ScriptInstance &instance);

  static void DoCommandReturnSignID(ScriptInstance &instance);

  static void DoCommandReturnGroupID(ScriptInstance &instance);

  static void DoCommandReturnGoalID(ScriptInstance &instance);

  static void DoCommandReturnStoryPageID(ScriptInstance &instance);

  static void DoCommandReturnStoryPageElementID(ScriptInstance &instance);

  static void DoCommandReturnLeagueTableID(ScriptInstance &instance);

  static void DoCommandReturnLeagueTableElementID(ScriptInstance &instance);

  class ScriptController &GetController()
  {
    assert(this->controller != nullptr);
    return *this->controller;
  }

  inline bool IsDead() const { return this->is_dead; }

  inline bool IsAlive() const { return !this->IsDead() && !this->in_shutdown; }

  void Save();

  static void SaveEmpty();

  static ScriptData *Load(int version);

  void LoadOnStack(ScriptData *data);

  static void LoadEmpty();

  void Pause();

  bool IsPaused();

  void Unpause();

  SQInteger GetOpsTillSuspend();

  bool DoCommandCallback(const CommandCost &result, const CommandDataBuffer &data, CommandDataBuffer result_data, Commands cmd);

  void InsertEvent(class ScriptEvent *event);

  bool IsSleeping() { return this->suspend != 0; }
 
  size_t GetAllocatedMemory() const;

  inline bool InShutdown() const { return this->in_shutdown; }

  void ReleaseSQObject(HSQOBJECT *obj);
 
protected:
  std::unique_ptr<class Squirrel> engine; 
  std::string api_version{}; 

  virtual void RegisterAPI();

  bool LoadCompatibilityScripts(Subdirectory dir, std::span<const std::string_view> api_versions);

  virtual void Died();

  virtual CommandCallbackData *GetDoCommandCallback() = 0;

  virtual void LoadDummyScript() = 0;
 
private:
  std::unique_ptr<class ScriptStorage> storage; 
  std::unique_ptr<class ScriptController> controller; 
  std::unique_ptr<SQObject> instance; 
 
  bool is_started = false; 
  bool is_dead = false; 
  bool is_save_data_on_stack = false; 
  int suspend = 0; 
  bool is_paused = false; 
  bool in_shutdown = false; 
  Script_SuspendCallbackProc *callback = nullptr; 
  size_t last_allocated_memory = 0; 

  bool CallLoad();

  bool LoadCompatibilityScript(std::string_view api_version, Subdirectory dir);

  static bool SaveObject(HSQUIRRELVM vm, SQInteger index, int max_depth, bool test);

  static bool LoadObjects(ScriptData *data);
 
  static bool LoadObjects(HSQUIRRELVM vm, ScriptData *data);
};
 
#endif /* SCRIPT_INSTANCE_HPP */