path: root/engines/m4/rails.cpp

/* 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

/*
	TODO:
		- rewrite functions (GetShortestPath etc.)
*/

#include "graphics/primitives.h"
#include "common/list.h"
#include "common/rect.h"
#include "common/util.h"

#include "m4/rails.h"
#include "m4/m4.h"

namespace M4 {

#define TOP_EDGE	1 << 0
#define LEFT_EDGE	1 << 1
#define BOTTOM_EDGE	1 << 2
#define RIGHT_EDGE	1 << 3


Rails::Rails() {
}


Rails::~Rails() {
	clearRails();
}


void Rails::clearRails() {
	uint32 i;
	Common::List<NoWalkRect *>::iterator j;
	RailNode *tempNode;

	for (i = 0; i < _nodes.size(); i++) {
		tempNode = _nodes[i];
		_nodes.remove_at(i);
		delete tempNode;
	}

	for (i = 0; i < _edges.size(); i++) {
		_edges.remove_at(i);
	}

	for (j = _noWalkRects.begin(); j != _noWalkRects.end(); ++j)
		delete (*j);
	_noWalkRects.clear();
}

static void checkPoint(int x, int y, int color, void *data) {
	IsWalkableData *isWalkableData = (IsWalkableData*)data;
	if (!isWalkableData->result)
		return;
	else {
	   M4Surface *codes = isWalkableData->codes;
	   if (x >= 0 && x < codes->width() && y >= 0 && y < codes->height()) {
			isWalkableData->result = !((*((uint8*)codes->getBasePtr(x, y))) & 0x10);
		} else {
			isWalkableData->result = false;
		}
	}
}

bool Rails::isLineWalkable(int x0, int y0, int x1, int y1) {
	IsWalkableData isWalkableData;
	isWalkableData.codes = _walkCodes;
	isWalkableData.result = true;
	Graphics::drawLine(x0, y0, x1, y1, 0, &checkPoint, &isWalkableData);
	return isWalkableData.result;
}

uint8 Rails::getDepth(const Common::Point &pt) {
	// TODO: Check based on sceneResources
	const byte *b = _walkCodes->getBasePtr(pt.x, pt.y);
	return *b & 0xf;
}

// helper function
uint8 getEndCode(int32 x, int32 y, Common::Rect rect) {
	uint8 endCode = 0;
	endCode = (x < rect.left) ? LEFT_EDGE : endCode;
	endCode = (x > rect.right) ? RIGHT_EDGE : endCode;
	endCode = (y < rect.top) ? endCode | TOP_EDGE : endCode;
	endCode = (y > rect.bottom) ? endCode | BOTTOM_EDGE : endCode;
	return endCode;
}

bool Rails::lineCrossesRect(int32 x1, int32 y1, int32 x2, int32 y2, Common::Rect rect) {
	int32 mX, mY;
	int32 pX1 = x1, pX2 = x2, pY1 = y1, pY2 = y2;
	uint8 endCode1, endCode2, midCode;

	if (rect.left > rect.right || rect.top > rect.bottom)
		return false;

	// Cohen-Sutherland line clipping algorithm

	endCode1 = getEndCode(pX1, pY1, rect);
	endCode2 = getEndCode(pX2, pY2, rect);

	if (!endCode1 || !endCode2)	// if both endcodes are zero
		return true;	// point is inside the rectangle, therefore the line intersects

	while (true) {
		if (endCode1 & endCode2)	// if both endcodes have a common bitset
			return false;	// line is completely off one edge

		// calculate midpoint
		mX = (pX1 + pX2)>>1;
		mY = (pY1 + pY2)>>1;

		// avoid round-off error: make sure that the midpoint isn't the same as one of the
		// two endpoints
		if (((mX == pX1) && (mY == pY1)) || ((mX == pX2) && (mY == pY2)))
			return false;

		midCode = getEndCode(mX, mY, rect);

		if (!midCode) {
			return true;
		} else if (midCode & endCode1) {
			// the midCode and an end point form a line segment completely off one edge, so
			// remove that half of the line segment
			pX1 = mX;
			pY1 = mY;
			endCode1 = midCode;
		} else {
			pX2 = mX;
			pY2 = mY;
			endCode2 = midCode;
		}
	}
}


bool Rails::linePassesThroughRect(int32 x1, int32 y1, int32 x2, int32 y2) {
	if (_noWalkRects.empty())
		return false;

	bool intersected = false;
	Common::List<NoWalkRect *>::iterator i;

	for (i = _noWalkRects.begin(); i != _noWalkRects.end(); ++i) {
		intersected = lineCrossesRect(x1, y1, x2, y2, Common::Rect((*i)->x1, (*i)->y1, (*i)->x2, (*i)->y2));
		if (intersected)
			break;
	}

	return intersected;
}

long SqrtF16(long n) {
	uint32 r = 0, s;
	uint32 v = (uint32)n;

	for (int i = 15; i >= 0; --i) {
		s = r + (1L << i * 2);
		r >>= 1;
		if (s <= v) {
			v -= s;
			r |= (1L << i * 2);
		}
	}

	return (long)r;
}

void Rails::createEdge(int32 node1, int32 node2) {
	uint32		index;
	int32		x1, y1, x2, y2;
	bool		valid;
	long		deltaX, deltaY, distance;

	if ((node1 < 0) || (node1 >= MAXRAILNODES) || (node2 < 0) || (node2 >= MAXRAILNODES))
		return;

	if (node1 == node2)
		return;

	if (node2 < node1)
		SWAP(node1, node2);		// ensure node1 < node2

	// Find the table entry i.e. tableWidth * node1 + node2 and then subtract
	// n(n+1)/2, since only the upper triangle of the table is stored
	index = (MAXRAILNODES-1) * node1 + node2 - 1 - (node1*(node1+1)>>1);
	if (index > _edges.size() - 1)
		_edges.resize(index + 1);
	_edges.insert_at(index, 0);
	valid = true;

	if (_nodes.size() <= (uint32)node1 || _nodes.size() <= (uint32)node2)
		return;

	x1 = _nodes[node1]->x;
	y1 = _nodes[node1]->y;
	x2 = _nodes[node2]->x;
	y2 = _nodes[node2]->y;

	// Make sure that the algorithm is symmetric
	if (x2 < x1) {
		SWAP(x1, x2);
		SWAP(y1, y2);
	}

	valid = isLineWalkable(_nodes[node1]->x, _nodes[node1]->y,
		_nodes[node2]->x, _nodes[node2]->y);
	debugCN(kDebugCore, "test code says: %d\n", valid);

	// Check if the line passes through a forbidden rectangle
	if (valid) {
		if (linePassesThroughRect(x1, y1, x2, y2)) {
			valid = false;
		}
	}

	if (valid) {
		deltaX = ABS(((long)(x2 - x1)) << 16);
		deltaY = ABS(((long)(y2 - y1)) << 16);
		if ((deltaX >= 0x800000) || (deltaY >= 0x800000)) {
			deltaX >>= 16;
			deltaY >>= 16;
			distance = (long)(SqrtF16(deltaX * deltaX + deltaY * deltaY) << 16);
		} else {
			distance = SqrtF16(FixedMul(deltaX, deltaX) + FixedMul(deltaY, deltaY)) << 8;
		}
		_edges.insert_at(index, (int16*)(distance >> 16));
	}

	debugCN(kDebugCore, "node1 = %d, node2 = %d, valid = %d\n", node1, node2, valid);

}


void Rails::restoreNodeEdges(int32 nodeID) {
	for (int32 i = 0; i < MAXRAILNODES; i++) {
		createEdge(i, nodeID);
	}
}

void Rails::restoreEdgeList() {
	int32 j;
	for (int32 i = 0; i < MAXRAILNODES; i++) {
		for (j = i + 1; j < MAXRAILNODES; j++) {
			createEdge(i, j);
		}
	}
}

int32 Rails::addRailNode(int32 x, int32 y, bool restoreEdges) {
	uint32 i = _nodes.size();
	if (i >= MAXRAILNODES)
		return -1;

	RailNode *newNode = new RailNode();
	newNode->nodeID = i;
	newNode->x = x;
	newNode->y = y;
	_nodes.insert_at(i, newNode);
	if (restoreEdges) {
		for (uint32 j=0; j<_nodes.size(); j++)
			createEdge(i, j);
	}
	return i;
}

bool Rails::removeRailNode(int32 nodeID, bool restoreEdges) {
	if (nodeID < 0 || nodeID >= MAXRAILNODES)
		return false;

	if (_nodes.empty() || _edges.empty())
		return false;

	RailNode *tempNode = _nodes[nodeID];
	_nodes.remove_at(nodeID);
	delete tempNode;

	if (restoreEdges) {
		restoreNodeEdges(nodeID);
	}
	return true;
}

int16 Rails::getEdgeLength(int32 node1, int32 node2) {
	int32		index;
	if (_edges.empty() || node1 == node2)
		return 0;
	if (node2 < node1)
		SWAP(node1, node2);
	// Find the table entry i.e. tableWidth * node1 + node2 and then subtract
	// n(n+1)/2, since only the upper triangle of the table is stored
	index = (MAXRAILNODES-1)*node1 + node2 - 1 - (node1*(node1+1)>>1);
	return *_edges[index];
}

void Rails::disposePath(RailNode *pathStart) {
	RailNode *tempNode = pathStart;
	while (tempNode) {
		pathStart = pathStart->shortPath;
		delete tempNode;
		tempNode = pathStart;
	}
}

/*
static RailNode* duplicatePath(RailNode *pathStart) {
	RailNode *newNode = NULL;
	RailNode *firstNode = NULL;
	RailNode *prevNode = NULL;
	// A valid path is assumed
	RailNode *pathNode = pathStart;

	while (pathNode) {
		newNode = new RailNode();
		newNode->x = pathNode->x;
		newNode->y = pathNode->y;
		newNode->shortPath = NULL;

		if (!firstNode)
			firstNode = newNode;
		else
			prevNode->shortPath = newNode;

		prevNode = newNode;
		// Get the next node
		pathNode = pathNode->shortPath;
	}

	return firstNode;
}
*/

bool Rails::getShortestPath(int32 origID, int32 destID, RailNode **shortPath) {
	// TODO
	return true;
}

} // End of namespace M4