startrek.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 STARTREK_H
#define STARTREK_H

#include "common/events.h"
#include "common/list.h"
#include "common/ptr.h"
#include "common/random.h"
#include "common/rect.h"
#include "common/scummsys.h"
#include "common/serializer.h"
#include "common/str.h"
#include "common/stream.h"
#include "common/system.h"
#include "common/util.h"

#include "gui/saveload-dialog.h"

#include "engines/engine.h"

#include "math/cosinetables.h"
#include "math/sinetables.h"

#include "startrek/action.h"
#include "startrek/awaymission.h"
#include "startrek/graphics.h"
#include "startrek/items.h"
#include "startrek/object.h"
#include "startrek/sound.h"
#include "startrek/space.h"
#include "startrek/detection.h"


using Common::SharedPtr;
using Common::String;

namespace Common {
class MacResManager;
}

namespace StarTrek {

class StarTrekEngine;
class Room;
class Console;
class Resource;

typedef String(StarTrekEngine::*TextGetterFunc)(int, uintptr, String *);

const int SAVEGAME_DESCRIPTION_LEN = 30;

struct SavegameMetadata {
    uint32 version;
    char description[SAVEGAME_DESCRIPTION_LEN + 1];

    uint32 saveDate;
    uint16 saveTime;
    byte saveTimeSecs;
    uint32 playTime;

    ::Graphics::Surface *thumbnail;

    void setSaveTimeAndDate(TimeDate time) {
        saveDate = ((time.tm_mday & 0xFF) << 24) | (((time.tm_mon + 1) & 0xFF) << 16) | ((time.tm_year + 1900) & 0xFFFF);
        saveTime = ((time.tm_hour & 0xFF) << 8) | ((time.tm_min) & 0xFF);
        saveTimeSecs = time.tm_sec & 0xFF;
    }

    int getDay() {
        return (saveDate >> 24) & 0xFF;
    }
    int getMonth() {
        return (saveDate >> 16) & 0xFF;
    }
    int getYear() {
        return saveDate & 0xFFFF;
    }
    int getHour() {
        return (saveTime >> 8) & 0xFF;
    }
    int getMinute() {
        return saveTime & 0xFF;
    }
};


const int MAX_MENUBUTTONS = 32;
const int TEXTBOX_WIDTH = 26;
const int TEXT_CHARS_PER_LINE = TEXTBOX_WIDTH - 2;
const int MAX_TEXTBOX_LINES = 12;

const int TEXT_INPUT_BUFFER_SIZE = 134;
const int MAX_TEXT_INPUT_LEN = 20;

const int MAX_BUFFERED_WALK_ACTIONS = 32;

const int MAX_BAN_FILES = 16;




enum kDebugLevels {
    kDebugSound =     1 << 0,
    kDebugGraphics =  1 << 1,
    kDebugSavegame =  1 << 2,
    kDebugSpace =     1 << 3,
    kDebugGeneral =   1 << 4
};

enum GameMode {
    GAMEMODE_START = 0,
    GAMEMODE_BRIDGE,
    GAMEMODE_AWAYMISSION,
    GAMEMODE_BEAMDOWN,
    GAMEMODE_BEAMUP
};

enum TextDisplayMode {
    TEXTDISPLAY_WAIT = 0,  // Wait for input before closing text
    TEXTDISPLAY_SUBTITLES, // Automatically continue when speech is done
    TEXTDISPLAY_NONE       // No text displayed
};

enum TextColor {
    TEXTCOLOR_GREY   = 0x88,
    TEXTCOLOR_RED    = 0xa1,
    TEXTCOLOR_YELLOW = 0xb0,
    TEXTCOLOR_BLUE   = 0xc0
};

// Keeps track of data for a list of buttons making up a menu
struct Menu {
    Sprite sprites[MAX_MENUBUTTONS];
    uint16 retvals[MAX_MENUBUTTONS];
    uint32 disabledButtons;
    uint16 numButtons;
    int16 selectedButton;
    Menu *nextMenu;
};

// Special events that can be returned by handleMenuEvents.
// (Normally it returns the "retval" of a pressed button, which is positive.)
enum MenuEvent {
    MENUEVENT_RCLICK_OFFBUTTON = -4,
    MENUEVENT_ENABLEINPUT,          // Makes buttons selectable (occurs after a delay)
    MENUEVENT_RCLICK_ONBUTTON,
    MENUEVENT_LCLICK_OFFBUTTON
};

// Buttons for standard text display
enum TextButtons {
    TEXTBUTTON_CONFIRM = 0,
    TEXTBUTTON_SCROLLUP,
    TEXTBUTTON_SCROLLDOWN,
    TEXTBUTTON_PREVCHOICE,
    TEXTBUTTON_NEXTCHOICE,
    TEXTBUTTON_SCROLLUP_ONELINE,
    TEXTBUTTON_SCROLLDOWN_ONELINE,
    TEXTBUTTON_GOTO_TOP,
    TEXTBUTTON_GOTO_BOTTOM,
    TEXTBUTTON_SPEECH_DONE // "Virtual" button?
};

// Buttons for option menu (corresponding to button indices, not button retvals, which are
// different for some reason)
enum OptionMenuButtons {
    OPTIONBUTTON_TEXT,
    OPTIONBUTTON_SAVE,
    OPTIONBUTTON_LOAD,
    OPTIONBUTTON_ENABLEMUSIC,
    OPTIONBUTTON_DISABLEMUSIC,
    OPTIONBUTTON_ENABLESFX,
    OPTIONBUTTON_DISABLESFX,
    OPTIONBUTTON_QUIT
};

enum TrekEventType {
    TREKEVENT_TICK = 0, // DOS clock changes
    TREKEVENT_LBUTTONDOWN = 1,
    TREKEVENT_MOUSEMOVE = 2,
    TREKEVENT_LBUTTONUP = 3,
    TREKEVENT_RBUTTONDOWN = 4,
    TREKEVENT_RBUTTONUP = 5,
    TREKEVENT_KEYDOWN = 6
};

struct TrekEvent {
    TrekEventType type;
    Common::KeyState kbd;
    Common::Point mouse;
    uint32 tick;
};

struct ComputerTopic {
    Common::String fileName;
    Common::String topic;
};

struct EnterpriseState {
    bool shields;
    bool weapons;
    bool underAttack;
    bool inOrbit;
    bool targetAnalysis;

    EnterpriseState() {
        shields = false;
        weapons = false;
        underAttack = false;
        inOrbit = false;
        targetAnalysis = false;
    }
};

class Graphics;
class IWFile;
class Sound;

class StarTrekEngine : public ::Engine {
protected:
    // startrek.cpp
public:
    StarTrekEngine(OSystem *syst, const StarTrekGameDescription *gamedesc);
    ~StarTrekEngine() override;

    friend class Console;

    Common::Error run() override;
    Common::Error runGameMode(int mode, bool resume);

    // Transporter room
    void runTransportSequence(const Common::String &name);

    // Bridge
    void initBridge(bool b);
    void loadBridge();
    void loadBridgeActors();
    void cleanupBridge();
    void runBridge();
    void setBridgeMouseCursor();
    void playBridgeSequence(int sequenceId);
    void handleBridgeEvents();
    void handleBridgeComputer();
    void showMissionPerformance(int score, int missionScoreTextId, int missionId);

    int _bridgeSequenceToLoad;

private:
    Common::String getSpeechSampleForNumber(int number);
    void showTextboxBridge(int talker, int textId);
    void showTextboxBridge(int talker, Common::String text);
    void showBridgeScreenTalkerWithMessage(int textId, Common::String talkerHeader, Common::String talkerId, bool removeTalker = true);
    void showBridgeScreenTalkerWithMessages(Common::String texts[], Common::String talkerHeader, Common::String talkerId, bool removeTalker = true);
    void showMissionStartEnterpriseFlyby(Common::String sequence, Common::String name);
    void startBattle(Common::String enemyShip);
    void wrongDestinationRandomEncounter();
    void bridgeCrewAction(int crewId);
    void contactTargetAction();
    void orbitPlanetSequence(int sequenceId);
    void negotiateWithElasiCereth();
    void hailTheMasada();

    int16 _targetPlanet;
    int16 _currentPlanet;
    int _currentScreenTalker;
    bool _gameIsPaused;
    bool _hailedTarget;
    int _deadMasadaPrisoners;
    bool _beamDownAllowed;
    int _missionEndFlag;
    int16 _randomEncounterType; // 1: Klingon, 2: Romulan, 3: Elasi
    int16 _lastMissionId;
    int16 _missionPoints[7];

public:
    void playMovie(Common::String filename);
    void playMovieMac(Common::String filename);

    uint16 getRandomWord();

    // awaymission.cpp
    void initAwayMission();
    void runAwayMission();
    void cleanupAwayMission();
    void loadRoom(const Common::String &missionName, int roomIndex);
    void initAwayCrewPositions(int warpEntryIndex);
    void handleAwayMissionEvents();
    void awayMissionLeftClick();
    void awayMissionSelectAction(bool openActionMenu);
    void awayMissionUseObject(int16 clickedObject);
    void awayMissionGetLookOrTalk(int16 clickedObject);
    void unloadRoom();
    int loadActorAnimWithRoomScaling(int actorIndex, const Common::String &animName, int16 x, int16 y);
    Fixed8 getActorScaleAtPosition(int16 y);
    void addAction(const Action &action);
    void addAction(int8 type, byte b1, byte b2, byte b3);
    void handleAwayMissionAction();

    void checkTouchedLoadingZone(int16 x, int16 y);
    void updateAwayMissionTimers();
    bool isPositionSolid(int16 x, int16 y);
    void loadRoomIndex(int roomIndex, int spawnIndex);

    Room *getRoom();

    // intro.cpp
private:
    void playIntro();
    void showCreditsScreen(R3 *creditsBuffer, int index, bool deletePrevious = true);
    void initIntroR3ObjectToMove(R3 *r3, int16 srcAngle, int16 srcDepth, int16 destAngle, int16 destDepth, int16 ticks);
    void loadSubtitleSprite(int index, Sprite *sprite);

    // space.cpp (pseudo-3d)
    void initStarfieldPosition();
    void initStarfield(int16 x, int16 y, int16 width, int16 height, int16 arg8);
    void addR3(R3 *r3);
    void delR3(R3 *r3);
    void clearStarfieldPixels();
    void drawStarfield();
    void updateStarfieldAndShips(bool arg0);
    R3 *sub_19f24(R3 *r3);
    void drawR3Shape(R3 *r3);
    bool sub_1c022(R3 *r3);

    Point3 constructPoint3ForStarfield(int16 x, int16 y, int16 z);
    Point3 matrixMult(const Matrix &weight, const Point3 &point);
    Point3 matrixMult(const Point3 &point, const Matrix &weight);
    int32 scaleSpacePosition(int32 x, int32 z);

    Matrix initMatrix();
    Matrix initSpeedMatrixForXZMovement(Angle angle, const Matrix &matrix);


    // actors.cpp (handles actors and animations)
public:
    void initActors();
    int loadActorAnim(int actorIndex, const Common::String &animName, int16 x, int16 y, Fixed8 scale);
    void loadBanFile(const Common::String &name);
    bool actorWalkToPosition(int actorIndex, const Common::String &animFile, int16 srcX, int16 srcY, int16 destX, int16 destY);
    void updateActorAnimations();

    void renderBanBelowSprites();
    void renderBan(byte *screenPixels, byte *bgPixels, int banFileIndex);
    void renderBanAboveSprites();
    void removeActorFromScreen(int actorIndex);
    void removeDrawnActorsFromScreen();
    void drawActorToScreen(Actor *actor, const Common::String &animName, int16 x, int16 y, Fixed8 scale, bool addSprite);
    void releaseAnim(Actor *actor);
    void initStandAnim(int actorIndex);
    void updateActorPositionWhileWalking(Actor *actor, int16 x, int16 y);
    void chooseActorDirectionForWalking(Actor *actor, int16 srcX, int16 srcY, int16 destX, int16 destY);
    bool directPathExists(int16 srcX, int16 srcY, int16 destX, int16 destY);

    int findObjectAt(int x, int y);
    int findObjectAt(Common::Point p) {
        return findObjectAt(p.x, p.y);
    }
    Bitmap *loadAnimationFrame(const Common::String &filename, Fixed8 scale);

    int selectObjectForUseAction();
    Common::String getCrewmanAnimFilename(int actorIndex, const Common::String &basename);
    void updateMouseBitmap();
    bool walkActiveObjectToHotspot();
    bool isObjectUnusable(int objectIndex, int action);
    void updateCrewmanGetupTimers();
    void showInventoryIcons(bool showItem);
    void hideInventoryIcons();
    int showInventoryMenu(int x, int y, bool restoreMouse);
    void initStarfieldSprite(Sprite *sprite, Bitmap *bitmap, const Common::Rect &rect);
    Bitmap *scaleBitmap(Bitmap *bitmap, Fixed8 scale);
    void scaleBitmapRow(byte *src, byte *dest, uint16 origWidth, uint16 scaledWidth);

    // events.cpp
public:
    void pollEvents(bool queueEvents = true);
    void waitForNextTick(bool queueEvents = true);
    void initializeEventsAndMouse();
    bool getNextEvent(TrekEvent *e, bool poll = true);
    void removeNextEvent();
    bool popNextEvent(TrekEvent *e, bool poll = true);
    void addEventToQueue(const TrekEvent &e);

    Common::EventManager *getEventMan() {
        return _eventMan;
    }

private:
    Common::List<TrekEvent> _eventQueue;
    bool _mouseMoveEventInQueue;
    bool _tickEventInQueue;
    uint32 _frameStartMillis;


    // textbox.cpp
public:
    const char *getNextTextLine(const char *text, char *line, int lineWidth);
    void drawTextLineToBitmap(const char *text, int textLen, int x, int y, Bitmap *bitmap);

    Common::String centerTextboxHeader(Common::String headerText);
    void getTextboxHeader(Common::String *headerTextOutput, Common::String speakerText, int choiceIndex);
    Common::String readTextFromRdf(int choiceIndex, uintptr data, Common::String *headerTextOutput);

    void showTextbox(Common::String headerText, const Common::String &mainText, int xoffset, int yoffset, byte textColor, int maxTextLines); // TODO: better name. (return type?)

    Common::String skipTextAudioPrompt(const Common::String &str);
    Common::String playTextAudio(const Common::String &str);

    int showText(TextGetterFunc textGetter, uintptr var, int xoffset, int yoffset, int textColor, bool loopChoices, int maxTextLines, bool rclickCancelsChoice);

    int getNumTextboxLines(const Common::String &str);
    Common::String putTextIntoLines(const Common::String &text);

    TextBitmap *initTextSprite(int *xoffsetPtr, int *yoffsetPtr, byte textColor, int numTextLines, bool withHeader, Sprite *sprite);
    void drawMainText(TextBitmap *bitmap, int numTextLines, int numTextboxLines, const Common::String &text, bool withHeader);

    Common::String readLineFormattedText(TextGetterFunc textGetter, uintptr var, int choiceIndex, TextBitmap *textBitmap, int numTextboxLines, int *numLines);

    Common::String readTextFromArray(int choiceIndex, uintptr data, Common::String *headerTextOutput);
    String readTextFromArrayWithChoices(int choiceIndex, uintptr data, Common::String *headerTextOutput);
    Common::String readTextFromFoundComputerTopics(int choiceIndex, uintptr data, Common::String *headerTextOutput);

    Common::String showCodeInputBox();
    Common::String showComputerInputBox();
    void redrawTextInput();
    void addCharToTextInputBuffer(char c);
    Common::String showTextInputBox(int16 arg0, int16 arg2, const Common::String &headerText);
    void initTextInputSprite(int16 arg0, int16 arg2, const Common::String &headerText);
    void cleanupTextInputSprite();

private:
    char _textInputBuffer[TEXT_INPUT_BUFFER_SIZE];
    int16 _textInputCursorPos;
    char _textInputCursorChar;
    Sprite _textInputSprite;

    // menu.cpp
public:
    int getMenuButtonAt(Sprite *sprites, int numSprites, int x, int y);
    void chooseMousePositionFromSprites(Sprite *sprites, int numSprites, int spriteIndex, int mode);
    void drawMenuButtonOutline(Bitmap *bitmap, byte color);
    void showOptionsMenu(int x, int y);
    void showBridgeMenu(Common::String menu, int x, int y);
    void handleBridgeMenu(int menuEvent);
    void showStarMap();
    void orbitPlanet();
    void captainsLog();

    int showActionMenu();
    void loadMenuButtons(String mnuFilename, int xpos, int ypos);
    void setVisibleMenuButtons(uint32 bits);
    void disableMenuButtons(uint32 bits);
    void enableMenuButtons(uint32 bits);
    int handleMenuEvents(uint32 ticksUntilClickingEnabled, bool inTextbox);
    void unloadMenuButtons();

    void chooseMouseBitmapForAction(int action, bool withRedOutline);
    void showQuitGamePrompt(int x, int y);
    void showGameOverMenu();
    void showTextConfigurationMenu(bool fromOptionMenu);

    int loadTextDisplayMode();
    void saveTextDisplayMode(int value);

    void showRepublicMap(int16 arg0, int16 turbolift);
    int getRepublicMapAreaAtMouse();
    int getRepublicMapAreaOrFailure(int16 turbolift);


private:
    int16 _textDisplayMode;
    uint32 _textboxVar2;
    uint16 _textboxVar6;
    bool _textboxHasMultipleChoices;
    Menu *_activeMenu;
    // Saved value of StarTrekEngine::_keyboardControlsMouse when menus are up
    bool _keyboardControlsMouseOutsideMenu;

    // saveload.cpp
public:
    bool showSaveMenu();
    bool showLoadMenu();

    bool saveGame(int slot, Common::String desc);
    bool loadGame(int slot);

    bool saveOrLoadGameData(Common::SeekableReadStream *in, Common::WriteStream *out, SavegameMetadata *meta);

    Common::String getSavegameFilename(int slotId) const;

    // detection.cpp
public:
    const StarTrekGameDescription *_gameDescription;
    uint32 getFeatures() const;
    Common::Platform getPlatform() const;
    uint8 getGameType() const;
    Common::Language getLanguage() const;

    // _screenName = _missionName + _roomIndex
    Common::String getScreenName() const {
        return _missionName + (char)(_roomIndex + '0');
    }

    // Variables
public:
    int _gameMode;
    int _lastGameMode;
    bool _resetGameMode;

    // NOTE: this has a different meaning than the original game. When non-empty, a new
    // room load is triggered, as opposed to original behaviour where this was only read
    // when "loadRoom" was called.
    Common::String _missionToLoad;
    int _roomIndexToLoad;
    int _spawnIndexToLoad;

    Common::String _missionName;
    int _roomIndex;
    Common::MemoryReadStreamEndian *_mapFile;
    Fixed16 _playerActorScale;

    // Queue of "actions" (ie. next frame, clicked on object) for away mission or bridge
    Common::Queue<Action> _actionQueue;

    AwayMission _awayMission;
    bool _warpHotspotsActive;
    int16 _activeWarpHotspot;
    int16 _activeDoorWarpHotspot;
    int16 _lookActionBitmapIndex;

    Item _itemList[NUM_OBJECTS];

    Actor _actorList[NUM_ACTORS];
    Actor *const _kirkActor;
    Actor *const _spockActor;
    Actor *const _mccoyActor;
    Actor *const _redshirtActor;

    // ".BAN" files provide extra miscellaneous animations in the room, ie. flashing
    // pixels on computer consoles, or fireflies in front of the screen.
    Common::MemoryReadStreamEndian *_banFiles[MAX_BAN_FILES];
    uint16 _banFileOffsets[MAX_BAN_FILES];

    Sprite _inventoryIconSprite;
    Sprite _itemIconSprite;

    // Certain hotspots store a position value where objects must walk to before
    // interacting with them. After calling "findObjectAt", these values are updated.
    bool _objectHasWalkPosition;
    Common::Point _objectWalkPosition;

    // Actions to perform after a crewman finishes walking to a position.
    // Room-specific code can specify that a specific action of type
    // "ACTION_FINISHED_WALKING" occurs after moving a crewman somewhere.
    Action _actionOnWalkCompletion[MAX_BUFFERED_WALK_ACTIONS];
    bool _actionOnWalkCompletionInUse[MAX_BUFFERED_WALK_ACTIONS];

    // _clockTicks is based on DOS interrupt 1A, AH=0; read system clock counter.
    // Updates 18.206 times every second.
    uint32 _clockTicks;
    uint32 _frameIndex;
    uint32 _roomFrameCounter; // Resets to 0 on loading a room

    bool _musicEnabled;
    bool _sfxEnabled;
    uint16 _word_467a6;
    uint16 _musicWorking;
    bool _sfxWorking;
    bool _finishedPlayingSpeech;

    bool _mouseControllingShip;

    // TODO: make this work.
    // When false, the keyboard generally acts in a more specific way (ie. move mouse
    // between items in a menu).
    bool _keyboardControlsMouse;

    bool _inQuitGameMenu;
    bool _showSubtitles;

    byte _byte_45b3c;

    // Pseudo-3D / starfield stuff
    Sprite _starfieldSprite;
    Star _starList[NUM_STARS];
    Point3 _starfieldPosition;
    int32 _starfieldPointDivisor;
    int16 _starfieldXVar1, _starfieldYVar1;
    int16 _starfieldXVar2, _starfieldYVar2;
    Common::Rect _starfieldRect;
    R3 _enterpriseR3;
    R3 *_r3List[NUM_SPACE_OBJECTS];
    R3 *_orderedR3List[NUM_SPACE_OBJECTS];
    Matrix _starPositionMatrix;
    Matrix _someMatrix;
    float _flt_50898;

    Graphics *_gfx;
    Sound *_sound;
    IWFile *_iwFile;
    Resource *_resource;

    EnterpriseState _enterpriseState;

private:
    int leftClickEvent();
    int rightClickEvent();
    int mouseMoveEvent();
    int lookupNextAction(const int *lookupArray, int action);
    void loadBridgeComputerTopics();
    void bridgeLeftClick();

    Common::RandomSource _randomSource;
    Math::SineTable _sineTable;
    Math::CosineTable _cosineTable;
    Room *_room;
    Common::List<ComputerTopic> _computerTopics;
};

// Static function
bool saveOrLoadMetadata(Common::SeekableReadStream *in, Common::WriteStream *out, SavegameMetadata *meta);

} // End of namespace StarTrek

#endif