iengine.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include <memory>
#include <vector>
#include <unordered_map>
#include <unordered_set>
 
#include "global.h"
#include "signal.h"
 
namespace libscratchcpp
{
 
class IExtension;
class Broadcast;
class Block;
class Field;
class Drawable;
class Target;
class Sprite;
class Stage;
class Variable;
class List;
class Script;
class StringPtr;
class Thread;
class ITimer;
class KeyEvent;
class Monitor;
class IMonitorHandler;

class LIBSCRATCHCPP_EXPORT IEngine
{
    public:
        virtual ~IEngine() { }

        virtual void clear() = 0;

        virtual void compile() = 0;

        virtual void start() = 0;

        virtual void stop() = 0;

        virtual Thread *startScript(Block *topLevelBlock, Target *) = 0;

        virtual void broadcast(int index, Thread *sender, bool wait) = 0;

        virtual void broadcastByPtr(Broadcast *broadcast, Thread *sender, bool wait) = 0;

        virtual void startBackdropScripts(Broadcast *broadcast, Thread *sender, bool wait) = 0;

        virtual void stopScript(Thread *vm) = 0;

        virtual void stopTarget(Target *target, Thread *exceptScript) = 0;

        virtual void initClone(std::shared_ptr<Sprite> clone) = 0;

        virtual void deinitClone(std::shared_ptr<Sprite> clone) = 0;

        virtual void stopSounds() = 0;

        virtual double globalVolume() const = 0;

        virtual void setGlobalVolume(double volume) = 0;

        virtual void updateMonitors() = 0;

        virtual void step() = 0;

        virtual void run() = 0;

        virtual void runEventLoop() = 0;

        virtual void stopEventLoop() = 0;

        virtual sigslot::signal<> &aboutToRender() = 0;

        virtual sigslot::signal<Thread *> &threadAboutToStop() = 0;

        virtual sigslot::signal<> &stopped() = 0;

        virtual bool isRunning() const = 0;

        virtual double fps() const = 0;

        virtual void setFps(double fps) = 0;

        virtual bool turboModeEnabled() const = 0;

        virtual void setTurboModeEnabled(bool turboMode) = 0;

        virtual bool keyPressed(const std::string &name) const = 0;

        virtual void setKeyState(const std::string &name, bool pressed) = 0;

        virtual void setKeyState(const KeyEvent &event, bool pressed) = 0;

        virtual void setAnyKeyPressed(bool pressed) = 0;

        virtual void mouseWheelUp() = 0;

        virtual void mouseWheelDown() = 0;

        virtual double mouseX() const = 0;

        virtual void setMouseX(double x) = 0;

        virtual double mouseY() const = 0;

        virtual void setMouseY(double y) = 0;

        virtual bool mousePressed() const = 0;

        virtual void setMousePressed(bool pressed) = 0;

        virtual void clickTarget(Target *target) = 0;

        virtual const StringPtr *answer() const = 0;

        virtual unsigned int stageWidth() const = 0;

        virtual void setStageWidth(unsigned int width) = 0;

        virtual unsigned int stageHeight() const = 0;

        virtual void setStageHeight(unsigned int height) = 0;

        virtual int cloneLimit() const = 0;

        virtual void setCloneLimit(int limit) = 0;

        virtual int cloneCount() const = 0;

        virtual bool spriteFencingEnabled() const = 0;

        virtual void setSpriteFencingEnabled(bool enable) = 0;

        virtual void requestRedraw() = 0;

        virtual ITimer *timer() const = 0;

        virtual void addCompileFunction(IExtension *extension, const std::string &opcode, BlockComp f) = 0;

        virtual void addHatPredicateCompileFunction(IExtension *extension, const std::string &opcode, HatPredicateCompileFunc f) = 0;

        virtual void addMonitorNameFunction(IExtension *extension, const std::string &opcode, MonitorNameFunc f) = 0;

        virtual void addMonitorChangeFunction(IExtension *extension, const std::string &opcode, MonitorChangeFunc f) = 0;

        virtual void addHatBlock(IExtension *extension, const std::string &opcode) = 0;

        virtual const std::vector<std::shared_ptr<Broadcast>> &broadcasts() const = 0;

        virtual void setBroadcasts(const std::vector<std::shared_ptr<Broadcast>> &broadcasts) = 0;

        virtual std::shared_ptr<Broadcast> broadcastAt(int index) const = 0;

        virtual std::vector<int> findBroadcasts(const std::string &broadcastName) const = 0;

        virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
        /* Registers the given "when touching object" script. */
        virtual void addWhenTouchingObjectScript(Block *hatBlock) = 0;

        virtual void addGreenFlagScript(Block *hatBlock) = 0;

        virtual void addBroadcastScript(Block *whenReceivedBlock, Field *field, Broadcast *broadcast) = 0;

        virtual void addBackdropChangeScript(Block *hatBlock, Field *field) = 0;
 
        /* Registers the given "when I start as clone" script. */
        virtual void addCloneInitScript(Block *hatBlock) = 0;
 
        /* Registers the given "when key pressed" script. */
        virtual void addKeyPressScript(Block *hatBlock, Field *field) = 0;
 
        /* Registers the given "when this sprite/stage clicked" script. */
        virtual void addTargetClickScript(Block *hatBlock) = 0;
 
        /* Registers the given "when greater than" script. */
        virtual void addWhenGreaterThanScript(Block *hatBlock) = 0;

        virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;

        virtual void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) = 0;

        virtual Target *targetAt(int index) const = 0;

        virtual void getVisibleTargets(std::vector<Target *> &dst) const = 0;

        virtual int findTarget(const std::string &targetName) const = 0;

        virtual void moveDrawableToFront(Drawable *drawable) = 0;

        virtual void moveDrawableToBack(Drawable *drawable) = 0;

        virtual void moveDrawableForwardLayers(Drawable *drawable, int layers) = 0;

        virtual void moveDrawableBackwardLayers(Drawable *drawable, int layers) = 0;

        virtual void moveDrawableBehindOther(Drawable *drawable, Drawable *other) = 0;

        virtual Stage *stage() const = 0;

        virtual const std::vector<std::shared_ptr<Monitor>> &monitors() const = 0;

        virtual void setMonitors(const std::vector<std::shared_ptr<Monitor>> &newMonitors) = 0;

        virtual Monitor *createVariableMonitor(std::shared_ptr<Variable> var, const std::string &opcode, const std::string &varFieldName) = 0;

        virtual Monitor *createListMonitor(std::shared_ptr<List> list, const std::string &opcode, const std::string &listFieldName) = 0;

        virtual sigslot::signal<Monitor *> &monitorAdded() = 0;

        virtual sigslot::signal<Monitor *, IMonitorHandler *> &monitorRemoved() = 0;

        virtual sigslot::signal<const std::string &> &questionAsked() = 0;

        virtual sigslot::signal<> &questionAborted() = 0;

        virtual sigslot::signal<const std::string &> &questionAnswered() = 0;

        virtual const std::vector<std::string> &extensions() const = 0;

        virtual void setExtensions(const std::vector<std::string> &newExtensions) = 0;

        virtual const std::unordered_map<Block *, std::shared_ptr<Script>> &scripts() const = 0;

        virtual const std::string &userAgent() const = 0;

        virtual void setUserAgent(const std::string &agent) = 0;

        virtual const std::unordered_set<std::string> &unsupportedBlocks() const = 0;
};
 
} // namespace libscratchcpp