scummvm/engines/trecision/pathfinding3d.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 TRECISION_PATHFINDING_H
#define TRECISION_PATHFINDING_H

#include "trecision/struct.h"
#include "common/serializer.h"

namespace Trecision {

struct SSortPan {
	int _num;
	float _min;
};

struct SPathNode {
	float _x, _z;
	float _dist;
	int16 _oldPanel;
	int16 _curPanel;

	void clear() {
		_x = _z = 0.0f;
		_dist = 0.0f;
		_oldPanel = 0;
		_curPanel = 0;
	}
};

struct SPan {
	float _x1, _z1;
	float _x2, _z2;
	float _h;
	int _flags;
	int16 _nearPanel1;
	int16 _nearPanel2;
	int8 _col1;
	int8 _col2;

	void clear() {
		_x1 = _z1 = 0.0f;
		_x2 = _z2 = 0.0f;
		_h = 0.0f;
		_flags = 0;
		_nearPanel1 = _nearPanel2 = 0;
		_col1 = _col2 = 0;
	}
};

struct SStep {
	float _px, _pz;
	float _dx, _dz;
	float _theta;
	int _curAction;
	int _curFrame;
	int16 _curPanel;

	void clear() {
		_px = _pz = 0.0f;
		_dx = _dz = 0.0f;
		_theta = 0.0f;
		_curAction = 0;
		_curFrame = 0;
		_curPanel = 0;
	}
};

class TrecisionEngine;

class PathFinding3D {
	TrecisionEngine *_vm;

	SPathNode _pathNode[MAXPATHNODES];
	float _invP[3][3];
	int _numPathNodes;
	float _x3d, _y3d, _z3d;
	float _curX, _curZ;
	float _lookX, _lookZ;
	int32 _panelNum;
	int16 _oldPanel;
	int _actorPos;
	int _forcedActorPos;

	bool pointInside(int pan, float x, float z) const;
	void sortPanel();
	void pointOut();
	void invPointProject(int x, int y);
	bool intersectLinePanel(SPan *p, float x, float y, float z);
	bool intersectLineFloor(float x, float y, float z);
	bool intersectLineLine(float xa, float ya, float xb, float yb, float xc, float yc, float xd, float yd);
	void findShortPath();
	float evalPath(int a, float destX, float destZ, int nearP);
	void lookAt(float x, float z);
	void buildFramelist();
	void displayPath();
	bool findAttachedPanel(int16 srcPanel, int16 destPanel);
	void sortPath();

public:
	PathFinding3D(TrecisionEngine *vm);
	~PathFinding3D();

	int _curStep;
	int _lastStep;
	int16 _curPanel;
	int _numSortPanel;

	int8 _characterGoToPosition;
	bool _characterInMovement;
	SSortPan _sortPan[32];
	SStep _step[MAXSTEP];
	SPan _panel[MAXPANELSINROOM];

	void findPath();
	void setPosition(int num);
	void goToPosition(int num);
	int nextStep();
	void initSortPan();
	void read3D(Common::SeekableReadStreamEndian *ff);
	void reset(uint16 idx, float px, float pz, float theta);
	void whereIs(int px, int py);
	void actorOrder();
	void syncGameStream(Common::Serializer &ser);
	int getActorPos() const { return _actorPos; }
	void setForcedActorPos(int actorPos) { _forcedActorPos = actorPos; }
};

} // End of namespace Trecision
#endif