1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/********************************************************************
*
*	File:		gfCJigsawMinigameComponent.h
*
*	Purpose:	Identification of JIG entities.
*
*********************************************************************/

#ifndef gfCJigsawMinigameComponenthdr
#define gfCJigsawMinigameComponenthdr

#include <fsCore/fsPoint.h>
#include <fsCore/src/fsCUniqueId.h>

#include "../gfIMinigameComponent.h"
#include "../gfIMinigameHintable.h"
#include "../gfCDrawOrderStateComponent.h"

#include "gfCJigsawDeckComponent.h"
#include "gfComponents/components/gfCGhostSpriteComponent.h"

class gfIStencil;
class fsCBrush;
class gfCDrawOrderControllerComponent;
class gfCJigsawDeckComponent;
class gfCJigsawLogicComponent;


class gfCJigsawMinigameComponent : public gfIMinigameComponent, public gfIMinigameHintable
{
	friend class gfCJigsawCluster;
	friend class gfCDrawOrderControllerComponent;
	friend class fsCComponentFactory;
	friend class gfCJigsawComponentCutter;
	friend class gfCDrawOrderStateComponent;

public:

	static const fsCUniqueId mToggleEdgesMsg;
	static const fsCUniqueId mJigssawDroppedPieceMsg;
	static const fsStr mStartSuffix;
	static const fsCUniqueId mTypeId;
	static const fsStr mEntityPrefix;

	static void edgePiecesOnlyToggle();

	void hintPieceAndHomeSlot();

	fsBool isHintableGet() const override;
	fsBool hintDo() override;

	void gameLogicSet(gfCJigsawLogicComponent* const pParentLogic);
	fsBool activePickAndPlaceStartPiece() const;
	void unlink();
	void link(fsCEntity* pParent);
	void posSet(fsPoint const& pPos);

	void bordersRegister(fsS32 pTop, fsS32 pBottom);

	void cut(std::shared_ptr<fsCBrush> pTexture, gfIStencil* pStencil);

protected:

	static fsS32 mHomePositionThreshold;

	void listenersRegisterDo() override;
	void listenersDeregisterDo() override;
	fsBool messageProcessDo(const fsCUniqueId& pMessageType,
	                        const fsIMessageDispatcher::sMessageParameters& pParam) override;

	void onTap(const fsPoint& pTapPos) override;
	void onDragStart(const fsPoint& pStartPos) override;
	void onDragMove(const fsPoint& pCurrPos) override;
	void onDragEnd(const fsPoint& pEndPos) override;

	void serialiseDo() override;
	void deserialiseDo() override;

	void resetDo() override;
	void initialiseDo(const fsCVariableTable& pVars) override;
	void skipDo() override;

	fsBool acceptingInputGet() const override;

	static fsIComponent* create(fsCEntity* pParent);

	gfCJigsawMinigameComponent(fsCEntity* pParent);
	virtual ~gfCJigsawMinigameComponent();<--- Destructor in derived class

private:

	void droppedPiece();

	gfCDrawOrderControllerComponent* const drawOrderGet() const;
	gfCJigsawDeckComponent* const deckGet() const;

	void positionRelativeTo(gfCJigsawMinigameComponent* const pPiece) const;

	void pieceDrop();

	void drawOrderUpdate();
	void relink();

	void moveHome();

	void staticsReset();

	static void homePositionRangesGet();

	void moveBegin(const fsPoint& pNewDragPos);
	void move(const fsPoint& pNewDragPos);

	fsCEntity* const moveEntityGet() const;
	void startEntitiesLocate();

	void homePositonModify(const fsPoint& pAdjustment, fsBool pFirstTime);
	void shadowCreate();
	void shadowDestroy();

	void positionRegulate(fsPoint& pDragPos) const;

	void randomPositionSet(const fsCVariableTable& pVars);
	void randomRotationSet(const fsCVariableTable& pVars);

	void angleRotate();
	void angleSet(fsBool pPosSetRelativeToRoot);
	void positionUpdateFromDrag(const fsPoint& pDragPos);
	void completionFinalise(fsBool pShowCompletion);
	void completionFinalise();
	fsBool homePositionWithinLimits();

	void playSFX(const fsStr& pName) const;

	static gfCJigsawMinigameComponent* const namedSiblingsGet(const fsStr& pName);
	static std::vector<gfCJigsawMinigameComponent*> siblingssGet();

	fsPoint mPrevDragPos;

	fsS32 mNumRotSteps;
	fsS32 mCurrRotStep;

	fsBool mInHomePosition;

	fsCEntity* mShadowEntity;
	fsCEntity* mStartPair;

	fsBool mCutFromStencil;

	gfCJigsawMinigameComponent* mNextInCluster;
	gfCJigsawMinigameComponent* mPrevInCluster;

	gfCJigsawLogicComponent* mGameLogic;

	gfCGhostSpriteComponent* mGhostSprite;
	gfCGhostSpriteComponent* mOtherGhost;
	
	static fsS32 mBorderTop;
	static fsS32 mBorderBottom;
	static fsPoint mMaxPos;
	static fsPoint mMinPos;
	static fsPoint mBaseSize;
	static fsBool mClusteringEnabled;

	class CHomePosition
	{
	public:

		CHomePosition();

		fsPoint get() const;
		fsPoint originalHomeGet() const;
		void set(const fsPoint& pPos);
		void offsetSet(const fsPoint& pPos);
		const fsPoint& offsetGet() const;

	private:

		fsPoint mAdjustment;
		fsPoint mPos;
	} mHomePosition;
};

#endif