script.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program 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, either version 3 of the License, or
 * (at your option) any later version.

 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef ASYLUM_RESOURCES_SCRIPT_H
#define ASYLUM_RESOURCES_SCRIPT_H

#include "common/array.h"
#include "common/func.h"
#include "common/serializer.h"
#include "common/stack.h"
#include "common/stream.h"

#include "asylum/shared.h"

namespace Asylum {

#define MAX_ACTION_COMMANDS 161

#define DECLARE_OPCODE(name) \
    void Op##name(ScriptEntry *cmd)

#define IMPLEMENT_OPCODE(name) \
    void ScriptManager::Op##name(ScriptEntry *cmd) { \
    if (!_currentScript) error("[" #name "] No current script set"); \
    if (!_currentQueueEntry) error("[" #name "] Invalid current queue entry"); \
    if (!cmd) error("[" #name "] Invalid command parameter");

#define END_OPCODE }


#define ADD_OPCODE(name) { \
    Opcode *func = new Opcode(#name, new Common::Functor1Mem<ScriptEntry *, void, ScriptManager>(this, &ScriptManager::Op##name)); \
    _opcodes.push_back(func); \
}

class Actor;
class AsylumEngine;
class Scene;

struct ActionArea : public Common::Serializable {
    char  name[52];
    int32 id;
    int32 field01;
    int32 field02;
    int32 field_40;
    int32 field_44;
    int32 flags;
    int32 scriptIndex;
    int32 scriptIndex2;
    int32 actionType;    
    int32 flagNums[10];
    int32 field_7C;
    uint32 polygonIndex;
    ResourceId walkingSounds[4];
    ResourceId paletteResourceId;
    int32 paths[5];
    int32 volume;

    ActionArea() {
        memset(&name, 0, sizeof(name));
        id = 0;
        field01 = 0;
        field02 = 0;
        field_40 = 0;
        field_44 = 0;
        flags = 0;
        scriptIndex = 0;
        scriptIndex2 = 0;
        actionType = 0;
        memset(&flagNums, 0, sizeof(flagNums));
        field_7C = 0;
        polygonIndex = 0;
        memset(&walkingSounds, 0, sizeof(walkingSounds));
        paletteResourceId = kResourceNone;
        memset(&paths, 0, sizeof(paths));
        volume = 0;
    }

    void load(Common::SeekableReadStream *stream);

    Common::String toString() {
        Common::String output;

        output += Common::String::format("Action %d: %s\n", id, name);
        output += Common::String::format("           flags=%d      scriptIndex=%d      scriptIndex2=%d   type=%d\n", flags, scriptIndex, scriptIndex2, actionType);
        output += Common::String::format("           sound=%d      polygon=%d          palette=%d        volume=%d\n", walkingSounds[2], polygonIndex, paletteResourceId, volume);
        output += Common::String::format("           field01=%d    field02=%d          field40=%d        field44=%d\n", field01, field02, field_40, field_44);
        output += Common::String::format("           field7C=%d    field84=%d          field88=%d        field90=%d\n", field_7C, walkingSounds[0], walkingSounds[1], walkingSounds[3]);

        return output;
    }

    // Serializable
    void saveLoadWithSerializer(Common::Serializer &s);
};

class ScriptManager : public Common::Serializable {
public:
    ScriptManager(AsylumEngine *engine);
    virtual ~ScriptManager();

    void load(Common::SeekableReadStream *stream);

    bool process();

    void resetAll();

    void reset(uint32 count = 0);

    void queueScript(int32 scriptIndex, ActorIndex actorIndex);

    bool isInQueue(int32 scriptIndex) const;

    void removeFromQueue(uint32 entryIndex);

    void resetQueue();

    // Serializable
    void saveLoadWithSerializer(Common::Serializer &s);
    void saveQueue(Common::Serializer &s);

private:
    enum ObjectTransparency {
        kObjectEnableType0,
        kObjectEnableType1,
        kObjectTransparencyOpaque
    };

    // Script Queue
    struct ScriptQueueEntry : public Common::Serializable {
        int32 scriptIndex;
        int32 currentLine;
        ActorIndex actorIndex;
        uint32 next;
        uint32 prev;

        ScriptQueueEntry() {
            reset();
        }

        void reset() {
            scriptIndex = -1;
            currentLine = 0;
            actorIndex = 0;
            next = 0;
            prev = 0;
        }

        void saveLoadWithSerializer(Common::Serializer &s) {
            s.syncAsSint32LE(scriptIndex);
            s.syncAsSint32LE(currentLine);
            s.syncAsUint32LE(actorIndex);
            s.syncAsUint32LE(next);
            s.syncAsUint32LE(prev);
        }
    };

    struct ScriptQueue : public Common::Serializable {
        ScriptQueueEntry entries[10];
        uint32 first;
        uint32 last;

        ScriptQueue() {
            reset();
        }

        void reset() {
            for (uint32 i = 0; i < ARRAYSIZE(entries); i++)
                entries[i].reset();

            first = 0;
            last = 0;
        }

        void saveLoadWithSerializer(Common::Serializer &s) {
            for (uint32 i = 0; i < ARRAYSIZE(entries); i++)
                entries[i].saveLoadWithSerializer(s);

            s.syncAsUint32LE(first);
            s.syncAsUint32LE(last);
        }
    };

    // Scripts
    struct ScriptEntry : public Common::Serializable {
        int32 numLines; // Only set on the first line of each script
        OpcodeType opcode;
        int32 param1;
        int32 param2;
        int32 param3;
        int32 param4;
        int32 param5;
        int32 param6;
        int32 param7;
        int32 param8;
        int32 param9;

        ScriptEntry() {
            numLines = 0;
            opcode = kOpcodeReturn;
            param1 = 0;
            param2 = 0;
            param3 = 0;
            param4 = 0;
            param5 = 0;
            param6 = 0;
            param7 = 0;
            param8 = 0;
            param9 = 0;
        }

        void saveLoadWithSerializer(Common::Serializer &s) {
            s.syncAsSint32LE(numLines);
            s.syncAsSint32LE(opcode);
            s.syncAsSint32LE(param1);
            s.syncAsSint32LE(param2);
            s.syncAsSint32LE(param3);
            s.syncAsSint32LE(param4);
            s.syncAsSint32LE(param5);
            s.syncAsSint32LE(param6);
            s.syncAsSint32LE(param7);
            s.syncAsSint32LE(param8);
            s.syncAsSint32LE(param9);
        }
    };

    struct Script : public Common::Serializable {
        ScriptEntry commands[MAX_ACTION_COMMANDS];
        int32       field_1BAC;
        int32       field_1BB0;
        int32       counter;

        Script() {
            field_1BAC = 0;
            field_1BB0 = 0;
            counter = 0;
        }

        void saveLoadWithSerializer(Common::Serializer &s) {
            for (int32 i = 0; i < ARRAYSIZE(commands); i++)
                commands[i].saveLoadWithSerializer(s);

            s.syncAsSint32LE(field_1BAC);
            s.syncAsSint32LE(field_1BB0);
            s.syncAsSint32LE(counter);
        }
    };

    // Opcodes
    typedef Common::Functor1<ScriptEntry *, void> OpcodeFunctor;

    struct Opcode {
        const char    *name;
        OpcodeFunctor *func;

        Opcode(const char *opcodeName, OpcodeFunctor *functor) {
            name = opcodeName;
            func = functor;
        }

        ~Opcode() {
            delete func;
        }
    };

    // Engine
    AsylumEngine *_vm;

    // Script queue and data
    ScriptQueue _queue;
    Common::Array<Opcode *>         _opcodes;
    Common::Array<Script>           _scripts;

    bool              _done;
    bool              _exit;
    bool              _processNextEntry;
    ScriptEntry      *_lastProcessedCmd; // DEBUGGING
    Script           *_currentScript;
    ScriptQueueEntry *_currentQueueEntry;

    void patchScriptData();

    // Opcode helper functions
    void enableObject(ScriptEntry *cmd, ObjectTransparency type);
    void setActionFlag(ScriptEntry *cmd, ActionType flag); //|
    void clearActionFlag(ScriptEntry *cmd, ActionType flag); //&
    void jumpIfActionFlag(ScriptEntry *cmd, ActionType flag);
    void setNextLine(int32 line);

    // Opcode functions
    DECLARE_OPCODE(Return);
    DECLARE_OPCODE(SetGameFlag);
    DECLARE_OPCODE(ClearGameFlag);
    DECLARE_OPCODE(ToggleGameFlag);
    DECLARE_OPCODE(JumpIfGameFlag);
    DECLARE_OPCODE(HideCursor);
    DECLARE_OPCODE(ShowCursor);
    DECLARE_OPCODE(PlayAnimation);
    DECLARE_OPCODE(MoveScenePosition);
    DECLARE_OPCODE(HideActor);
    DECLARE_OPCODE(ShowActor);
    DECLARE_OPCODE(SetActorPosition);
    DECLARE_OPCODE(SetSceneMotionStatus);
    DECLARE_OPCODE(DisableActor);
    DECLARE_OPCODE(EnableActor);
    DECLARE_OPCODE(EnableObjects);
    DECLARE_OPCODE(RemoveObject);
    DECLARE_OPCODE(JumpActorSpeech);
    DECLARE_OPCODE(JumpAndSetDirection);
    DECLARE_OPCODE(JumpIfActorCoordinates);
    DECLARE_OPCODE(Nop);
    DECLARE_OPCODE(ResetAnimation);
    DECLARE_OPCODE(DisableObject);
    DECLARE_OPCODE(JumpIfSoundPlayingAndPlaySound);
    DECLARE_OPCODE(JumpIfActionFind);
    DECLARE_OPCODE(SetActionFind);
    DECLARE_OPCODE(ClearActionFind);
    DECLARE_OPCODE(JumpIfActionGrab);
    DECLARE_OPCODE(SetActionGrab);
    DECLARE_OPCODE(ClearActionGrab);
    DECLARE_OPCODE(JumpIfActionTalk);
    DECLARE_OPCODE(SetActionTalk);
    DECLARE_OPCODE(ClearActionTalk);
    DECLARE_OPCODE(AddToInventory);
    DECLARE_OPCODE(RemoveFromInventory);
    DECLARE_OPCODE(JumpIfInventoryOmits);
    DECLARE_OPCODE(RunEncounter);
    DECLARE_OPCODE(JumpIfAction16);
    DECLARE_OPCODE(SetAction16);
    DECLARE_OPCODE(ClearAction16);
    DECLARE_OPCODE(SelectInventoryItem);
    DECLARE_OPCODE(JumpIfInventoryItemNotSelected);
    DECLARE_OPCODE(ChangeScene);
    DECLARE_OPCODE(Interact);
    DECLARE_OPCODE(PlayMovie);
    DECLARE_OPCODE(StopAllObjectsSounds);
    DECLARE_OPCODE(StopProcessing);
    DECLARE_OPCODE(ResumeProcessing);
    DECLARE_OPCODE(ResetSceneRect);
    DECLARE_OPCODE(ChangeMusicById);
    DECLARE_OPCODE(StopMusic);
    DECLARE_OPCODE(IncrementParam1);
    DECLARE_OPCODE(SetVolume);
    DECLARE_OPCODE(Jump);
    DECLARE_OPCODE(RunPuzzle);
    DECLARE_OPCODE(JumpIfAction8);
    DECLARE_OPCODE(SetAction8);
    DECLARE_OPCODE(ClearAction8);
    DECLARE_OPCODE(CreatePalette);
    DECLARE_OPCODE(IncrementParam2);
    DECLARE_OPCODE(WaitUntilFramePlayed);
    DECLARE_OPCODE(UpdateWideScreen);
    DECLARE_OPCODE(JumpIfActor);
    DECLARE_OPCODE(PlaySpeechScene);
    DECLARE_OPCODE(PlaySpeech);
    DECLARE_OPCODE(PlaySpeechScene2);
    DECLARE_OPCODE(MoveScenePositionFromActor);
    DECLARE_OPCODE(PaletteFade);
    DECLARE_OPCODE(QueuePaletteFade);
    DECLARE_OPCODE(PlaySoundUpdateObject);
    DECLARE_OPCODE(ActorFaceTarget);
    DECLARE_OPCODE(HideMatteBars);
    DECLARE_OPCODE(ShowMatteBars);
    DECLARE_OPCODE(JumpIfSoundPlaying);
    DECLARE_OPCODE(ChangePlayer);
    DECLARE_OPCODE(ChangeActorStatus);
    DECLARE_OPCODE(StopSound);
    DECLARE_OPCODE(JumpRandom);
    DECLARE_OPCODE(ClearScreen);
    DECLARE_OPCODE(Quit);
    DECLARE_OPCODE(JumpObjectFrame);
    DECLARE_OPCODE(DeleteGraphics);
    DECLARE_OPCODE(SetActorField944);
    DECLARE_OPCODE(SetScriptField1BB0);
    DECLARE_OPCODE(OnScriptField1BB0);
    DECLARE_OPCODE(WalkToActor);
    DECLARE_OPCODE(SetResourcePalette);
    DECLARE_OPCODE(SetObjectFrameIndexAndFlags);
    DECLARE_OPCODE(SetObjectFlags);
    DECLARE_OPCODE(SetActorActionIndex2);
    DECLARE_OPCODE(UpdateTransparency);
    DECLARE_OPCODE(QueueScript);
    DECLARE_OPCODE(ProcessActor);
    DECLARE_OPCODE(ClearActorFields);
    DECLARE_OPCODE(SetObjectLastFrameIndex);
    DECLARE_OPCODE(SetActionAreaFlags);
    DECLARE_OPCODE(MorphActor);
    DECLARE_OPCODE(ShowMenu);
    DECLARE_OPCODE(UpdateGlobalFlags);

    friend class Console;
}; // end of class ActionList

} // end of namespace Asylum

#endif // ASYLUM_RESOURCES_SCRIPT_H