people.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 SLUDGE_PEOPLE_H
#define SLUDGE_PEOPLE_H

#include "common/list.h"

namespace Sludge {

struct FrozenStuffStruct;
struct LoadedSpriteBank;
struct ScreenRegion;
struct VariableStack;

class SludgeEngine;

struct AnimFrame {
    int frameNum, howMany;
    int noise;
};

#define EXTRA_FRONT         1
#define EXTRA_FIXEDSIZE     2
#define EXTRA_NOSCALE       2   // Alternative name
#define EXTRA_NOZB          4
#define EXTRA_FIXTOSCREEN   8
#define EXTRA_NOLITE        16
#define EXTRA_NOREMOVE      32
#define EXTRA_RECTANGULAR   64

struct PersonaAnimation {
    LoadedSpriteBank *theSprites;
    AnimFrame *frames;
    int numFrames;

    PersonaAnimation();
    PersonaAnimation(int num, VariableStack *&stacky);
    PersonaAnimation(PersonaAnimation *orig);
    ~PersonaAnimation();

    // Setter & getter
    int getTotalTime();

    // Save & load
    bool save(Common::WriteStream *stream);
    bool load(Common::SeekableReadStream *stream);
};

struct Persona {
    PersonaAnimation **animation;
    int numDirections;

    // Save & load
    bool save(Common::WriteStream *stream);
    bool load(Common::SeekableReadStream *stream);
};

struct OnScreenPerson {
    float x, y;
    int height, floaty, walkSpeed;
    float scale;
    int walkToX, walkToY, thisStepX, thisStepY, inPoly, walkToPoly;
    bool walking, spinning;
    struct LoadedFunction *continueAfterWalking;
    PersonaAnimation *myAnim;
    PersonaAnimation *lastUsedAnim;
    Persona *myPersona;
    int frameNum, frameTick, angle, wantAngle, angleOffset;
    bool show;
    int direction, directionWhenDoneWalking;
    struct ObjectType *thisType;
    int extra, spinSpeed;
    byte r, g, b, colourmix, transparency;

    void makeTalker();
    void makeSilent();
    void setFrames(int a);
};

typedef Common::List<OnScreenPerson *> OnScreenPersonList;

class PeopleManager {
public:
    PeopleManager(SludgeEngine *vm);
    ~PeopleManager();

    // Initialisation and creation
    bool init();
    bool addPerson(int x, int y, int objNum, Persona *p);

    // Draw to screen and to backdrop
    void drawPeople();
    void freezePeople(int, int);

    // Removalisationisms
    void kill();
    void killMostPeople();
    void removeOneCharacter(int i);

    // Things which affect or use all characters
    OnScreenPerson *findPerson(int v);
    void setScale(int16 h, int16 d);

    // Things which affect one character
    void setShown(bool h, int ob);
    void setDrawMode(int h, int ob);
    void setPersonTransparency(int ob, byte x);
    void setPersonColourise(int ob, byte r, byte g, byte b, byte colourmix);

    // Moving 'em
    void movePerson(int x, int y, int objNum);
    bool makeWalkingPerson(int x, int y, int objNum, struct LoadedFunction *func, int di);
    bool forceWalkingPerson(int x, int y, int objNum, struct LoadedFunction *func, int di);
    void jumpPerson(int x, int y, int objNum);
    void walkAllPeople();
    bool turnPersonToFace(int thisNum, int direc);
    bool stopPerson(int o);
    bool floatCharacter(int f, int objNum);
    bool setCharacterWalkSpeed(int f, int objNum);

    // Animating 'em
    void animatePerson(int obj, PersonaAnimation *);
    void animatePerson(int obj, Persona *per);
    bool setPersonExtra(int f, int newSetting);

    // Loading and saving
    bool savePeople(Common::WriteStream *stream);
    bool loadPeople(Common::SeekableReadStream *stream);

    // Freeze
    void freeze(FrozenStuffStruct *frozenStuff);
    void resotre(FrozenStuffStruct *frozenStuff);

private:
    ScreenRegion *_personRegion;
    OnScreenPersonList *_allPeople;
    int16 _scaleHorizon;
    int16 _scaleDivide;

    SludgeEngine *_vm;

    void shufflePeople();

    // OnScreenPerson manipulation
    void turnMeAngle(OnScreenPerson *thisPerson, int direc);
    void spinStep(OnScreenPerson *thisPerson);
    void rethinkAngle(OnScreenPerson *thisPerson);
    void moveAndScale(OnScreenPerson &me, float x, float y);
    void setMyDrawMode(OnScreenPerson *moveMe, int h);
    bool walkMe(OnScreenPerson *thisPerson, bool move = true);
};

} // End of namespace Sludge

#endif