mirror-games/glest-source
1
0
Fork 0
mirror of https://github.com/glest/glest-source.git synced 2025-08-12 11:24:00 +02:00
Code Issues Projects Releases Wiki Activity

- removed pathfinder from GAE and all references

Browse Source
This commit is contained in:
Mark Vejvoda
2012-09-22 21:39:13 +00:00
parent 871b6c4a6e
commit 8e88b36723
30 changed files with 2 additions and 5952 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
source/shared_lib/include/util/heap.h
View File

@@ -1,119 +0,0 @@
// ==============================================================
// This file is part of the Glest Advanced Engine
//
// Copyright (C) 2010 James McCulloch <silnarm at gmail>
//
// You can redistribute this code 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
// ==============================================================
#ifndef _MIN_HEAP_INCLUDED_
#define _MIN_HEAP_INCLUDED_
#include <cassert>
namespace Shared { namespace Util {
/** 'Nodes' nead to implement this implicit interface:
struct SomeNode {
void setHeapIndex(int ndx); // typically, { heap_ndx = ndx; }
int getHeapIndex() const; // typically, { return heap_ndx; }
bool operator<(const SomeNode &that) const;
};
*/
/** (Min) Heap, supporting node 'index awareness'.
* stores pointers to Nodes, user needs to supply the actual nodes, preferably in single block
* of memory, and preferably with as compact a node structure as is possible (to the point that the
* int 'heap_ndx' should be a bitfield using as few bits as you can get away with).
*/
template<typename Node> class MinHeap {
private:
Node** data;
int counter;
int capacity;
public:
/** Construct MinHeap with a given capacity */
MinHeap(int capacity = 1024) : counter(0), capacity(capacity) {
data = new Node*[capacity];
}
~MinHeap() {
delete [] data;
}
/** add a new node to the min heap */
bool insert(Node *node) {
if (counter == capacity) {
return false;
}
data[counter] = node;
data[counter]->setHeapIndex(counter);
promoteNode(counter++);
return true;
}
/** pop the best node off the min heap */
Node* extract() {
assert(counter);
Node *res = data[0];
if (--counter) {
data[0] = data[counter];
data[0]->setHeapIndex(0);
demoteNode();
}
return res;
}
/** indicate a node has had its key decreased */
void promote(Node *node) {
assert(data[node->getHeapIndex()] == node);
promoteNode(node->getHeapIndex());
}
int size() const { return counter; }
void clear() { counter = 0; }
bool empty() const { return !counter; }
private:
inline int parent(int ndx) const { return (ndx - 1) / 2; }
inline int left(int ndx) const { return (ndx * 2) + 1; }
void promoteNode(int ndx) {
assert(ndx >= 0 && ndx < counter);
while (ndx > 0 && *data[ndx] < *data[parent(ndx)]) {
Node *tmp = data[parent(ndx)];
data[parent(ndx)] = data[ndx];
data[ndx] = tmp;
data[ndx]->setHeapIndex(ndx);
ndx = parent(ndx);
data[ndx]->setHeapIndex(ndx);
}
}
void demoteNode(int ndx = 0) {
assert(counter);
while (true) {
int cndx = left(ndx); // child index
int sndx = ndx; // smallest (priority) of data[ndx] and any children
if (cndx < counter && *data[cndx] < *data[ndx]) sndx = cndx;
if (++cndx < counter && *data[cndx] < *data[sndx]) sndx = cndx;
if (sndx == ndx) return;
Node *tmp = data[sndx];
data[sndx] = data[ndx];
data[ndx] = tmp;
data[ndx]->setHeapIndex(ndx);
ndx = sndx;
data[ndx]->setHeapIndex(ndx);
}
}
};
}} // end namespace Shared::Util
#endif // _MIN_HEAP_INCLUDED_

83
source/shared_lib/include/util/line.h
View File

@@ -1,83 +0,0 @@
// ==============================================================
// This file is part of the Glest Advanced Engine
//
// Copyright (C) 2010 James McCulloch <silnarm at gmail>
//
// You can redistribute this code 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
// ==============================================================
#ifndef _LINE_ALGORITHM_INCLUDED_
#define _LINE_ALGORITHM_INCLUDED_
#include <cassert>
namespace Shared { namespace Util {
/** midpoint line algorithm, 'Visit' specifies the 'pixel visit' function, *
* and must take two int params (x & y co-ords) */
template<typename VisitFunc> void line(int x0, int y0, int x1, int y1, VisitFunc visitor) {
bool mirror_x, mirror_y;
int pivot_x, pivot_y;
if (x0 > x1) {
mirror_x = true;
pivot_x = x0;
x1 = (x0 << 1) - x1;
} else {
mirror_x = false;
}
if (y0 > y1) {
mirror_y = true;
pivot_y = y0;
y1 = (y0 << 1) - y1;
} else {
mirror_y = false;
}
// Visit(x,y) => Visit(mirror_x ? (pivot_x << 1) - x : x, mirror_y ? (pivot_y << 1) - y : y);
assert(y0 <= y1 && x0 <= x1);
int dx = x1 - x0,
dy = y1 - y0;
int x = x0,
y = y0;
if (dx == 0) {
while (y <= y1) {
visitor(mirror_x ? (pivot_x << 1) - x : x, mirror_y ? (pivot_y << 1) - y : y);
++y;
}
} else if (dy == 0) {
while (x <= x1) {
visitor(mirror_x ? (pivot_x << 1) - x : x, mirror_y ? (pivot_y << 1) - y : y);
++x;
}
} else if (dy > dx) {
int d = 2 * dx - dy;
int incrS = 2 * dx;
int incrSE = 2 * (dx - dy);
do {
visitor(mirror_x ? (pivot_x << 1) - x : x, mirror_y ? (pivot_y << 1) - y : y);
if (d <= 0) {
d += incrS; ++y;
} else {
d += incrSE; ++x; ++y;
}
} while (y <= y1);
} else {
int d = 2 * dy - dx;
int incrE = 2 * dy;
int incrSE = 2 * (dy - dx);
do {
visitor(mirror_x ? (pivot_x << 1) - x : x, mirror_y ? (pivot_y << 1) - y : y);
if (d <= 0) {
d += incrE; ++x;
} else {
d += incrSE; ++x; ++y;
}
} while (x <= x1);
}
}
}} // end namespace Shared::Util
#endif // !def _LINE_ALGORITHM_INCLUDED_