scummvm/engines/sludge/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