movers.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/>.
 *
 * Should really be called "moving actors.h"
 */

#ifndef TINSEL_MOVERS_H // prevent multiple includes
#define TINSEL_MOVERS_H

#include "tinsel/anim.h"    // for ANIM
#include "tinsel/scene.h"   // for TFTYPE
#include "tinsel/tinsel.h"

namespace Tinsel {

struct OBJECT;

enum NPS {NOT_IN, GOING_UP, GOING_DOWN, LEAVING, ENTERING};

enum IND {NO_PROB, TRY_CENTER, TRY_CORNER, TRY_NEXTCORNER};

enum DIRECTION { LEFTREEL, RIGHTREEL, FORWARD, AWAY };

#define NUM_MAINSCALES  ((TinselVersion >= 2) ? 10 : 5)
#define NUM_AUXSCALES   5
#define TOTAL_SCALES    (NUM_MAINSCALES + NUM_AUXSCALES)
#define REQ_MAIN_SCALES     10
#define REQ_TOTAL_SCALES    15

#define BOGUS_BRIGHTNESS -1

enum MOVER_TYPE { MOVER_2D, MOVER_3D };

struct MOVER {
    int     objX, objY;           /* Co-ordinates object  */

    int     targetX, targetY;
    int     ItargetX, ItargetY;     /* Intermediate destination */
    int     UtargetX, UtargetY;     /* Ultimate destination */

    HPOLYGON hIpath;    /* Intermediate path */
    HPOLYGON hUpath;    /* Ultimate path */
    HPOLYGON hCpath;    /* Current path */

    bool over;
    int walkNumber;

    IND InDifficulty;

    /* For use in 'follow nodes' polygons   */
    HPOLYGON hFnpath;
    NPS npstatus;
    int     line;

    int     Tline;                   // NEW

    // TODO: TagReelRunning may be the same as bSpecReel
    bool        bSpecReel;

    /* Used internally */
    DIRECTION   direction;      // Current reel
    int         scale;      // Current scale

    int         stepCount;      // Step count for walking reel synchronisation

    int         walkedFromX, walkedFromY;

    bool        bMoving;        // Set this to TRUE during a walk

    bool        bNoPath;
    bool        bIgPath;
    bool        bWalkReel;

    OBJECT      *actorObj;  // Actor's object
    ANIM        actorAnim;  // Actor's animation script

    SCNHANDLE   hLastFilm;  // } Used by AlterMover()
    SCNHANDLE   hPushedFilm;    // }

    int         actorID;
    int         actorToken;

    SCNHANDLE   walkReels[REQ_TOTAL_SCALES][4];
    SCNHANDLE   standReels[REQ_TOTAL_SCALES][4];
    SCNHANDLE   talkReels[REQ_TOTAL_SCALES][4];

    bool        bActive;

    int         SlowFactor; // Slow down movement while hidden

    bool        bStop;

    /* NOTE: If effect polys can overlap, this needs improving */
    bool        bInEffect;

    Common::PROCESS     *pProc;

    // Discworld 2 specific fields
    int32       zOverride;
    bool        bHidden;
    int         brightness; // Current brightness
    int         startColor;
    int         paletteLength;
    HPOLYGON    hRpath;     // Recent path

    // Noir specific fields
    MOVER_TYPE  type;
    SCNHANDLE   hModelName;
    SCNHANDLE   hTextureName;

    int         posX, posY, posZ;
    int         animSpeed;
    uint        nextIdleAnim;
};

struct MAINIT {
    int X;
    int Y;
    MOVER *pMover;
};

//---------------------------------------------------------------------------


void MoverProcessCreate(int X, int Y, int id, MOVER *pMover);


enum AR_FUNCTION { AR_NORMAL, AR_PUSHREEL, AR_POPREEL, AR_WALKREEL };

void StoreMoverPalette(MOVER *pMover, int startColor, int length);

void MoverBrightness(MOVER *pMover, int brightness);

MOVER *GetMover(int ano);
MOVER *RegisterMover(int ano);
void KillMover(MOVER *pMover);
MOVER *GetLiveMover(int index);

bool getMActorState(MOVER *psActor);
int GetMoverId(MOVER *pMover);
void SetMoverZ(MOVER *pMover, int y, uint32 zFactor);
void SetMoverZoverride(MOVER *pMover, uint32 zFactor);

void HideMover(MOVER *pMover, int sf = 0);
bool MoverHidden(MOVER *pMover);
bool MoverIs(MOVER *pMover);
bool MoverIsSWalking(MOVER *pMover);
bool MoverMoving(MOVER *pMover);
int GetWalkNumber(MOVER *pMover);
void UnHideMover(MOVER *pMover);
void DropMovers();
void PositionMover(MOVER *pMover, int x, int y);

void GetMoverPosition(MOVER *pMover, int *aniX, int *aniY);
void GetMoverMidTop(MOVER *pMover, int *aniX, int *aniY);
int GetMoverLeft(MOVER *pMover);
int GetMoverRight(MOVER *pMover);
int GetMoverTop(MOVER *pMover);
int GetMoverBottom(MOVER *pMover);

bool MoverIsInPolygon(MOVER *pMover, HPOLYGON hPoly);
void AlterMover(MOVER *pMover, SCNHANDLE film, AR_FUNCTION fn);
DIRECTION GetMoverDirection(MOVER *pMover);
int GetMoverScale(MOVER *pMover);
void SetMoverDirection(MOVER *pMover, DIRECTION dirn);
void SetMoverStanding(MOVER *pMover);
void SetMoverWalkReel(MOVER *pMover, DIRECTION reel, int scale, bool force);

MOVER *InMoverBlock(MOVER *pMover, int x, int y);

void RebootMovers();

bool IsMAinEffectPoly(int index);
void SetMoverInEffect(int index, bool tf);

void StopMover(MOVER *pMover);

/*----------------------------------------------------------------------*/

struct SAVED_MOVER {

    int     actorID;
    int     objX;
    int     objY;
    SCNHANDLE hLastfilm;

    SCNHANDLE   walkReels[REQ_TOTAL_SCALES][4];
    SCNHANDLE   standReels[REQ_TOTAL_SCALES][4];
    SCNHANDLE   talkReels[REQ_TOTAL_SCALES][4];

    bool    bActive;
    bool    bHidden;
    int     brightness;
    int     startColor;
    int     paletteLength;
};

void SaveMovers(SAVED_MOVER *sMoverInfo);
void RestoreAuxScales(SAVED_MOVER *sMoverInfo);

MOVER *NextMover(MOVER *pMover);

/*----------------------------------------------------------------------*/

enum {
    MAGICX  = -101,
    MAGICY  = -102
};

/*----------------------------------------------------------------------*/

} // End of namespace Tinsel

#endif /* TINSEL_MOVERS_H */