Event.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <iostream>
#include <memory>
#include <vector>
 
#include "GDCore/Events/Instruction.h"
#include "GDCore/Events/InstructionsList.h"
#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
#include "GDCore/Project/MemoryTrackedRegistry.h"
#include "GDCore/String.h"
namespace gd {
class EventsList;
class Project;
class Layout;
class EventsCodeGenerator;
class EventsCodeGenerationContext;
class Platform;
class SerializerElement;
class Instruction;
class EventVisitor;
class ReadOnlyEventVisitor;
class VariablesContainer;
}  // namespace gd
 
namespace gd {
 
class BaseEvent;
typedef std::shared_ptr<BaseEvent> BaseEventSPtr;
 
class GD_CORE_API BaseEvent {
 public:
  BaseEvent();
  BaseEvent(const BaseEvent& other);
  BaseEvent& operator=(const BaseEvent& other);
  virtual ~BaseEvent(){};
 
  virtual gd::BaseEvent* Clone() const { return new BaseEvent(*this); }
 
 
  virtual bool IsExecutable() const { return false; };
 
  virtual bool CanHaveSubEvents() const { return false; }
 
  virtual const gd::EventsList& GetSubEvents() const { return badSubEvents; };
 
  virtual gd::EventsList& GetSubEvents() { return badSubEvents; };
 
  bool HasSubEvents() const;
 
  virtual bool CanHaveVariables() const { return false; }
 
  virtual const gd::VariablesContainer& GetVariables() const {
    return badLocalVariables;
  };
 
  virtual gd::VariablesContainer& GetVariables() {
    return badLocalVariables;
  };
 
  bool HasVariables() const;
 
  virtual gd::InstructionsList* GetInstructionList(const gd::String& label) {
    return nullptr;
  };
  virtual const gd::InstructionsList* GetInstructionList(
      const gd::String& label) const {
    return nullptr;
  };
 
  static const gd::String conditionsLabel;
  static const gd::String actionsLabel;
  static const gd::String whileConditionsLabel;
 
  virtual std::vector<gd::InstructionsList*> GetAllConditionsVectors() {
    std::vector<gd::InstructionsList*> noConditions;
    return noConditions;
  };
  virtual std::vector<const gd::InstructionsList*> GetAllConditionsVectors()
      const {
    std::vector<const gd::InstructionsList*> noConditions;
    return noConditions;
  };
 
  virtual std::vector<gd::InstructionsList*> GetAllActionsVectors() {
    std::vector<gd::InstructionsList*> noActions;
    return noActions;
  };
  virtual std::vector<const gd::InstructionsList*> GetAllActionsVectors()
      const {
    std::vector<const gd::InstructionsList*> noActions;
    return noActions;
  };
 
  virtual std::vector<gd::String> GetAllSearchableStrings() const {
    std::vector<gd::String> noSearchableStrings;
    return noSearchableStrings;
  };
 
  virtual bool ReplaceAllSearchableStrings(
      std::vector<gd::String> newSearchableString) {
    return false;
  };
 
  virtual std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> >
  GetAllExpressionsWithMetadata() {
    std::vector<std::pair<gd::Expression*, gd::ParameterMetadata> > noExpr;
    return noExpr;
  };
  virtual std::vector<
      std::pair<const gd::Expression*, const gd::ParameterMetadata> >
  GetAllExpressionsWithMetadata() const {
    std::vector<std::pair<const gd::Expression*, const gd::ParameterMetadata> >
        noExpr;
    return noExpr;
  };
 
 
  virtual gd::String GenerateEventCode(
      gd::EventsCodeGenerator& codeGenerator,
      gd::EventsCodeGenerationContext& context);
 
  virtual void Preprocess(gd::EventsCodeGenerator& codeGenerator,
                          gd::EventsList& eventList,
                          std::size_t indexOfTheEventInThisList);
 
  void PreprocessAsyncActions(const gd::Platform& platform);
 
  virtual bool MustBePreprocessed() { return false; }
 
 
  virtual void SerializeTo(SerializerElement& element) const {};
 
  virtual void UnserializeFrom(gd::Project& project,
                               const SerializerElement& element){};
 
  virtual bool AcceptVisitor(gd::EventVisitor& eventVisitor);
  virtual void AcceptVisitor(gd::ReadOnlyEventVisitor& eventVisitor) const;
 
 
  const gd::String& GetType() const { return type; };
 
  void SetType(gd::String type_) { type = type_; };
 
  void SetDisabled(bool disable = true) { disabled = disable; }
 
  bool IsDisabled() const { return disabled; }
 
  void SetFolded(bool fold = true) { folded = fold; }
 
  bool IsFolded() const { return folded; }
 
  void SetAiGeneratedEventId(const gd::String& aiGeneratedEventId_) {
    aiGeneratedEventId = aiGeneratedEventId_;
  }
 
  const gd::String& GetAiGeneratedEventId() const {
    return aiGeneratedEventId;
  }
 
  std::weak_ptr<gd::BaseEvent>
      originalEvent;  
  signed long long
      totalTimeDuringLastSession;  
  float percentDuringLastSession;  
 
 private:
  bool folded;  
  bool disabled;    
  gd::String type;  
  gd::String aiGeneratedEventId;  
 
  static gd::EventsList badSubEvents;
  static gd::VariablesContainer badLocalVariables;
  gd::MemoryTracked _memoryTracked{this, "BaseEvent"};
};
 
BaseEventSPtr GD_CORE_API CloneRememberingOriginalEvent(BaseEventSPtr event);
 
class EmptyEvent : public BaseEvent {
 public:
  EmptyEvent() : BaseEvent(){};
  virtual ~EmptyEvent(){};
};
 
}  // namespace gd