PositionList removeShortest(const PositionList &positions)
{
PositionList result;
PositionList::const_iterator shortest;
int shortestSoFar = 0;
bool firstTime = true;
for (PositionList::const_iterator positionsIterator = positions.begin(); positionsIterator != positions.end(); ++positionsIterator)
{
if (firstTime)
{
shortestSoFar = ((positionsIterator->x * positionsIterator->x) + (positionsIterator->y * positionsIterator->y));
shortest = positionsIterator;
firstTime = false;
}
else
{
if (((positionsIterator->x * positionsIterator->x) + (positionsIterator->y * positionsIterator->y)) < shortestSoFar)
{
shortestSoFar = ((positionsIterator->x * positionsIterator->x) + (positionsIterator->y * positionsIterator->y));
shortest = positionsIterator;
}
}
}
for (PositionList::const_iterator positionsIterator = positions.begin(); positionsIterator != positions.end(); ++positionsIterator)
{
if (positionsIterator != shortest)
{
result.push_back(*positionsIterator);
}
}
return result;
}
PositionList limitDirections(const PositionList &positions)
{
PositionList result;
int lastX = 0;
int lastY = 0;
bool firstTime = true;
for (PositionList::const_iterator positionsIterator = positions.begin(); positionsIterator != positions.end(); ++positionsIterator)
{
if (firstTime)
{
lastX = positionsIterator->x;
lastY = positionsIterator->y;
firstTime = false;
}
else
{
int dx = (positionsIterator->x - lastX);
int dy = (positionsIterator->y - lastY);
if (dy > 0)
{
if ((dx > dy) || (-dx > dy))
{
dy = 0;
}
else
{
dx = 0;
}
}
else
{
if ((dx > -dy) || (-dx > -dy))
{
dy = 0;
}
else
{
dx = 0;
}
}
result.push_back(Position(dx, dy));
lastX = positionsIterator->x;
lastY = positionsIterator->y;
}
}
return result;
}
static PositionList LatLongDepthList_ml2cpp(value pointList)
/********************************************************/
{
PositionList toReturn;
CAMLlocal1(head);
while ( pointList != Val_emptylist )
{
head = Field(pointList, 0); /* accessing the head */
toReturn.push_back(LatLongDepth_ml2cpp(head));
pointList = Field(pointList, 1); /* point to the tail for next loop */
}
return(toReturn);
}
void RobotDecoder::initRecordAndCuePositions() {
PositionList recordSizes;
_videoSizes.reserve(_numFramesTotal);
_recordPositions.reserve(_numFramesTotal);
recordSizes.reserve(_numFramesTotal);
switch(_version) {
case 5: // 16-bit sizes and positions
for (int i = 0; i < _numFramesTotal; ++i) {
_videoSizes.push_back(_stream->readUint16());
}
for (int i = 0; i < _numFramesTotal; ++i) {
recordSizes.push_back(_stream->readUint16());
}
break;
case 6: // 32-bit sizes and positions
for (int i = 0; i < _numFramesTotal; ++i) {
_videoSizes.push_back(_stream->readSint32());
}
for (int i = 0; i < _numFramesTotal; ++i) {
recordSizes.push_back(_stream->readSint32());
}
break;
default:
error("Unknown Robot version %d", _version);
}
for (int i = 0; i < kCueListSize; ++i) {
_cueTimes[i] = _stream->readSint32();
}
for (int i = 0; i < kCueListSize; ++i) {
_cueValues[i] = _stream->readUint16();
}
Common::copy(_cueTimes, _cueTimes + kCueListSize, _masterCueTimes);
int bytesRemaining = (_stream->pos() - _fileOffset) % kRobotFrameSize;
if (bytesRemaining != 0) {
_stream->seek(kRobotFrameSize - bytesRemaining, SEEK_CUR);
}
int position = _stream->pos();
_recordPositions.push_back(position);
for (int i = 0; i < _numFramesTotal - 1; ++i) {
position += recordSizes[i];
_recordPositions.push_back(position);
}
}
PositionList simplify(const PositionList &positions)
{
PositionList result;
int lastDx = 0;
int lastDy = 0;
bool firstTime = true;
for (PositionList::const_iterator positionsIterator = positions.begin(); positionsIterator != positions.end(); ++positionsIterator)
{
if (firstTime)
{
lastDx = positionsIterator->x;
lastDy = positionsIterator->y;
firstTime = false;
}
else
{
bool joined = false;
if ((lastDx > 0 && positionsIterator->x > 0) || (lastDx < 0 && positionsIterator->x < 0))
{
lastDx += positionsIterator->x;
joined = true;
}
if ((lastDy > 0 && positionsIterator->y > 0) || (lastDy < 0 && positionsIterator->y < 0))
{
lastDy += positionsIterator->y;
joined = true;
}
if (!joined)
{
result.push_back(Position(lastDx, lastDy));
lastDx = positionsIterator->x;
lastDy = positionsIterator->y;
}
}
}
if (lastDx != 0 || lastDy != 0)
{
result.push_back(Position(lastDx, lastDy));
}
return result;
}
int calculateLength(const PositionList &positions)
{
int result = 0;
for (PositionList::const_iterator positionsIterator = positions.begin(); positionsIterator != positions.end(); ++positionsIterator)
{
if (positionsIterator->x > 0)
{
result += positionsIterator->x;
}
else if (positionsIterator->x < 0)
{
result -= positionsIterator->x;
}
else if (positionsIterator->y > 0)
{
result += positionsIterator->y;
}
else
{
result -= positionsIterator->y;
}
}
return result;
}
PositionScanner::PositionList PositionScannerImpl::GetPositions() const
{
PositionList posList;
for(Array2D::LineByLineWalker walker(GetGrid().GetSize()) ;
!walker.IsAtEnd() ;
++walker)
{
if (!GetGrid().GetSquare(walker.GetPosition()).IsBlack())
{
posList.push_back(walker.GetPosition());
}
}
return posList;
}
bool PositionList::operator==(const PositionList & list) {
const PositionList::Node * curr = mHead;
const PositionList::Node * inner = list.head();
while ( curr != 0) {
while (inner !=0) {
if (*curr->pos != *inner->pos)
return false;
inner = inner->next();
}
inner = list.head();
curr = curr->next();
}
return true;
}
void LinkedBinaryTree<T>::preorder(Node* v, PositionList& pl) const {
pl.push_back(Position(v));
if (v->left != NULL)
preorder(v->left, pl);
if (v->right != NULL)
preorder(v->right, pl);
}
static CAMLprim value LatLongDepthList_cpp2ml(const PositionList& pointList)
/********************************************************/
{
CAMLparam0();
CAMLlocal2(cli, cons);
cli = Val_emptylist;
for(int c = (pointList.size()-1); c >= 0; c--) //Need to traverse backwards to get correct order
{
SPosition current = pointList.at(c);
cons = caml_alloc(2,0);
Store_field(cons, 0, LatLongDepth_cpp2ml(current)); //head
Store_field(cons, 1, cli); //tail
cli = cons;
}
CAMLreturn(cli);
}
void calculateCoverageCpu2(const PositionList& cpuTransmitters,
const PositionList& cpuReceivers,
CoverageList& cpuCoverages)
{
int numBuckets = BucketsPerAxis * BucketsPerAxis;
// Copy input positions to device memory
std::vector<Position> cudaTempTransmitters = cpuTransmitters;
std::vector<Position> cudaTempReceivers = cpuReceivers;
// Allocate device memory for sorted arrays
std::vector<Position> cudaTransmitters;
cudaTransmitters.resize(cpuTransmitters.size());
std::vector<Bucket> cudaTransmitterBuckets;
cudaTransmitterBuckets.resize(numBuckets);
std::vector<Position> cudaReceivers;
cudaReceivers.resize(cpuReceivers.size());
std::vector<Bucket> cudaReceiverBuckets;
cudaReceiverBuckets.resize(numBuckets);
// Sort transmitters and receivers into buckets
sortPositionsIntoBuckets(cudaTempTransmitters, cudaTransmitters, cudaTransmitterBuckets);
sortPositionsIntoBuckets(cudaTempReceivers, cudaReceivers, cudaReceiverBuckets);
// Perform signal strength computation
std::vector<uint> cudaCoverages;
cudaCoverages.resize(cpuTransmitters.size());
for (uint transmitterBucketIndexY = 0; transmitterBucketIndexY < BucketsPerAxis; ++transmitterBucketIndexY)
for (uint transmitterBucketIndexX = 0; transmitterBucketIndexX < BucketsPerAxis; ++transmitterBucketIndexX)
calculateCoverageCpu2Bucket(&cudaTransmitters[0], &cudaTransmitterBuckets[0],
&cudaReceivers[0], &cudaReceiverBuckets[0], &cudaCoverages[0],
transmitterBucketIndexX, transmitterBucketIndexY);
// Copy results back to host memory
cpuCoverages = cudaCoverages;
}
void RtBroker::getBrokerPositionList(int const posStateQuery, BrkLib::BrokerSession &session, PositionList &posList)
{
posList.clear();
if (posStateQuery & QUERY_OPEN)
engine_m.getPositionHolder().queryOpenPositions(posList);
if (posStateQuery & QUERY_HISTORY)
engine_m.getPositionHolder().queryHistoryPositions(posList);
}
/****************************************************************************
* operator= and copyConstructor utility function *
****************************************************************************/
void bst::rec_positions( Node * u , int mode , PositionList & pl ) const
{
if(u->left == NULL && u->right == NULL)
{
return;
}
if(mode == PREORDER)
{
pl.push_back(Position(u));
}
rec_positions(u->left, mode, pl);
if (mode == INORDER)
{
pl.push_back(Position(u));
}
rec_positions(u->right, mode, pl);
if(mode == POSTORDER)
{
pl.push_back(Position(u));
}
}
int Recognizer::recognizeGesture()
{
PositionList directions = simplify(limitDirections(d->positions));
const double minimumLength = (calculateLength(directions) * d->minimumMatch);
while (!directions.empty() && calculateLength(directions) > minimumLength)
{
for (unsigned int i = 0; i < d->gestures.size(); ++i)
{
if (d->gestures[i].size() == directions.size())
{
bool match = true;
PositionList::const_iterator positionsIterator = directions.begin();
for (ActionList::const_iterator directionsIterator = d->gestures[i].begin(); directionsIterator != d->gestures[i].end() && match; ++directionsIterator, ++positionsIterator)
{
switch (*directionsIterator)
{
case MoveUpMouseAction:
if (positionsIterator->y >= 0)
{
match = false;
}
break;
case MoveDownMouseAction:
if (positionsIterator->y <= 0)
{
match = false;
}
break;
case MoveLeftMouseAction:
if (positionsIterator->x >= 0)
{
match = false;
}
break;
case MoveRightMouseAction:
if (positionsIterator->x <= 0)
{
match = false;
}
break;
case MoveHorizontallyMouseAction:
if (positionsIterator->x == 0)
{
match = false;
}
break;
case MoveVerticallyMouseAction:
if (positionsIterator->y == 0)
{
match = false;
}
break;
default:
match = false;
break;
}
}
if (match)
{
return (int) i;
}
}
}
directions = simplify(removeShortest(directions));
}
return -1;
}
void CopyBuffer::cut(Editor& editor, int floor)
{
if(editor.selection.size() == 0) {
gui.SetStatusText(wxT("No tiles to cut."));
return;
}
clear();
tiles = newd BaseMap();
int tile_count = 0;
int item_count = 0;
copyPos = Position(0xFFFF, 0xFFFF, floor);
BatchAction* batch = editor.actionQueue->createBatch(ACTION_CUT_TILES);
Action* action = editor.actionQueue->createAction(batch);
PositionList tilestoborder;
for(TileVector::iterator it = editor.selection.begin(); it != editor.selection.end(); ++it) {
tile_count++;
Tile* tile = *it;
Tile* newtile = tile->deepCopy(editor.map);
Tile* copied_tile = tiles->allocator(tile->getLocation());
if(tile->ground && tile->ground->isSelected()) {
copied_tile->house_id = newtile->house_id;
newtile->house_id = 0;
copied_tile->setMapFlags(tile->getMapFlags());
newtile->setMapFlags(TILESTATE_NONE);
}
ItemVector tile_selection = newtile->popSelectedItems();
for(ItemVector::iterator iit = tile_selection.begin(); iit != tile_selection.end(); ++iit) {
item_count++;
// Add items to copybuffer
copied_tile->addItem(*iit);
}
if(newtile->creature && newtile->creature->isSelected()) {
copied_tile->creature = newtile->creature;
newtile->creature = nullptr;
}
if(newtile->spawn && newtile->spawn->isSelected()) {
copied_tile->spawn = newtile->spawn;
newtile->spawn = nullptr;
}
tiles->setTile(copied_tile->getPosition(), copied_tile);
if(copied_tile->getX() < copyPos.x) {
copyPos.x = copied_tile->getX();
}
if(copied_tile->getY() < copyPos.y) {
copyPos.y = copied_tile->getY();
}
if(settings.getInteger(Config::USE_AUTOMAGIC)) {
for(int y = -1; y <= 1; y++)
for(int x = -1; x <= 1; x++)
tilestoborder.push_back(Position(tile->getX() + x, tile->getY() + y, tile->getZ()));
}
action->addChange(newd Change(newtile));
}
batch->addAndCommitAction(action);
// Remove duplicates
tilestoborder.sort();
tilestoborder.unique();
if(settings.getInteger(Config::USE_AUTOMAGIC)) {
action = editor.actionQueue->createAction(batch);
for(PositionList::iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
TileLocation* location = editor.map.createTileL(*it);
if(location->get()) {
Tile* new_tile = location->get()->deepCopy(editor.map);
new_tile->borderize(&editor.map);
new_tile->wallize(&editor.map);
action->addChange(newd Change(new_tile));
} else {
Tile* new_tile = editor.map.allocator(location);
new_tile->borderize(&editor.map);
if(new_tile->size()) {
action->addChange(newd Change(new_tile));
} else {
delete new_tile;
}
}
}
batch->addAndCommitAction(action);
}
editor.addBatch(batch);
std::stringstream ss;
ss << "Cut out " << tile_count << " tile" << (tile_count > 1 ? "s" : "") << " (" << item_count << " item" << (item_count > 1? "s" : "") << ")";
gui.SetStatusText(wxstr(ss.str()));
}
