void AbstractCell::rotateClockwise() { Directions newdirs = None; if (m_cables & Up) newdirs = Directions(newdirs | Right); if (m_cables & Right) newdirs = Directions(newdirs | Down); if (m_cables & Down) newdirs = Directions(newdirs | Left); if (m_cables & Left) newdirs = Directions(newdirs | Up); m_cables = newdirs; m_hasBeenMoved = true; }
std::list<MatrixCoord> dumbPath(Matrix<Cell> &matrix, const MatrixCoord &start, const MatrixCoord &end) { std::list<MatrixCoord> path; MatrixCoord matrixSize = matrix.size(); Matrix<Directions> directionsMatrix(matrixSize); Directions alldir(1,1,1,1); MatrixCoord currentDir = alldir.dir[rand()%4]; for (int i=0; i<matrixSize.x; ++i) { for (int j=0; j<matrixSize.y; ++j) { MatrixCoord ij(i, j); directionsMatrix[ij] = Directions(matrix[ij].up, matrix[ij].down, matrix[ij].right, matrix[ij].left); } } // directionsMatrix has, in each coord, the possible directionsMatrix from that coord path.clear(); MatrixCoord currentCoord = start; while (!(currentCoord == end)) { // at each arrived coord path.push_back(currentCoord); // add it as arrived(stuff here only gets added(never removed), it makes the full back-and-forth trace) std::random_shuffle(directionsMatrix[currentCoord].dir.begin(), directionsMatrix[currentCoord].dir.end()); // get a coord from this one currentCoord += directionsMatrix[currentCoord].dir.back(); } path.push_back(currentCoord); return path; }
std::vector<vgl_point_2d<double> > ScannerImage(const vector<vgl_point_3d<double> > &Points, const vgl_point_3d<double> &ScannerLocation) { std::vector<vgl_point_3d<double> > Intersections(Points.size()); //get all directions std::vector<vgl_vector_3d<double> > Directions(Points.size()); for(unsigned int i = 0; i < Points.size(); i++) { Directions[i] = Points[i] - ScannerLocation; } vgl_vector_3d<double> ProjectionPlaneNormal = VXLHelpers::normalize(AverageDirection(Directions)); vgl_point_3d<double> ProjectionPlanePoint = ScannerLocation + ProjectionPlaneNormal; //find the 3d coords of the points projected on the plane for(unsigned int i = 0; i < Points.size(); i++) { vgl_line_3d_2_points<double> Line(ScannerLocation, Points[i]); //vgl_plane_3d<double> Plane(ScannerForward, ScannerLocation + ScannerForward); vgl_plane_3d<double> Plane(ProjectionPlaneNormal, ProjectionPlanePoint); vgl_point_3d<double> Intersection = vgl_intersection(Line, Plane); Intersections[i] = Intersection; } vgl_vector_3d<double> b = VXLHelpers::normalize(Intersections[0] - ProjectionPlanePoint); //WriteAxisFile(vgl_point_3d<double> (0,0,0), cross_product(ProjectionPlaneNormal, b), b, ProjectionPlaneNormal, "BeforeAxis.vtp"); vnl_double_3x3 R = FindAligningRotation(cross_product(ProjectionPlaneNormal, b), b, ProjectionPlaneNormal); /* //write out axes after transformation vnl_double_3 a1 = vnl_inverse(R) * vgl_vector_to_vnl_vector(cross_product(ProjectionPlaneNormal, b)); vnl_double_3 a2 = vnl_inverse(R) * vgl_vector_to_vnl_vector(b); vnl_double_3 a3 = vnl_inverse(R) * vgl_vector_to_vnl_vector(ProjectionPlaneNormal); WriteAxisFile(vgl_point_3d<double> (0,0,0), vnl_vector_to_vgl_vector(a1), vnl_vector_to_vgl_vector(a2), vnl_vector_to_vgl_vector(a3), "AfterAxis.vtp"); */ std::vector<vgl_point_2d<double> > Points2d(Points.size()); for(unsigned int i = 0; i < Points.size(); i++) { vnl_double_3 temp = vnl_inverse(R) * VXLHelpers::vgl_point_to_vnl_vector(Intersections[i]); Points2d[i] = vgl_point_2d<double> (temp(0), temp(1)); } return Points2d; }
std::list<MatrixCoord> randomDFSPath(Matrix<Cell> &matrix, const MatrixCoord &start, const MatrixCoord &end) { std::list<MatrixCoord> path; MatrixCoord matrixSize = matrix.size(); Matrix<Directions> directionsMatrix(matrixSize); for (int i=0; i<matrixSize.x; ++i) { for (int j=0; j<matrixSize.y; ++j) { MatrixCoord ij(i, j); directionsMatrix[ij] = Directions(matrix[ij].up, matrix[ij].down, matrix[ij].right, matrix[ij].left); } } // directionsMatrix has, in each coord, the possible directionsMatrix from that coord path.clear(); std::list<MatrixCoord> coordStack; MatrixCoord currentCoord = start; while (!(currentCoord == end)) { // at each arrived coord path.push_back(currentCoord); // add it as arrived(stuff here only gets added(never removed), it makes the full back-and-forth trace) // every coord I arrive must be added here if (directionsMatrix[currentCoord].dir.size() > 0) { std::random_shuffle(directionsMatrix[currentCoord].dir.begin(), directionsMatrix[currentCoord].dir.end()); // get a coord from this one MatrixCoord modifier = directionsMatrix[currentCoord].dir.back(); directionsMatrix[currentCoord].dir.pop_back(); // erase the pointer from currentCoord to currentCoord+modifier const MatrixCoord modified = currentCoord + modifier; // just an alias to the next coordinate I will visit directionsMatrix[modified].dir.erase(std::find(directionsMatrix[modified].dir.begin(), directionsMatrix[modified].dir.end(), -modifier)); // erase the pointer to the current currentCoord from(currentCoord+modifier) coordStack.push_back(currentCoord); // add it to the stack, so that if I get to a dead end, I can get back currentCoord = modified; } else { currentCoord = coordStack.back(); // dead end, just get back to last one coordStack.pop_back(); } // std::cout << path << std::endl; } path.push_back(currentCoord); return path; }
// adds a random direction and moves on (if possible) void AbstractGrid::addRandomCable(QList<uint>& list) { int cell = list.first(); // find all the cells surrounding list.first() // (0 when cells don't exist) int ucell = uCell(cell); // up int rcell = rCell(cell); // right int dcell = dCell(cell); // down int lcell = lCell(cell); // left QMap<Directions, int> freeCells; // of those cells map the ones that are free if (ucell != NO_CELL && m_cells[ucell]->cables() == None) { freeCells[Up] = ucell; } if (rcell != NO_CELL && m_cells[rcell]->cables() == None) { freeCells[Right] = rcell; } if (dcell != NO_CELL && m_cells[dcell]->cables() == None) { freeCells[Down] = dcell; } if (lcell != NO_CELL && m_cells[lcell]->cables() == None) { freeCells[Left] = lcell; } if (freeCells.isEmpty()) return; // no free cells left QMap<Directions, int>::ConstIterator it = freeCells.constBegin(); // move the iterator to a random direction connecting to a free cell for (int i = qrand() % freeCells.count(); i > 0; --i) ++it; // add the cable in the direction of cell Directions newCables = Directions(m_cells[cell]->cables() | it.key()); m_cells[cell]->setCables(newCables); // add a cable in the opposite direction, on the free cell m_cells[it.value()]->setCables(invertDirection(it.key())); // append the cell that was free to the list list.append(it.value()); }
void Explosion::create(int _id) { if(id[_id] == -1) return; Explosion *newExplosion = nullptr; checkTile(ptr, id[_id], LayerType::LAYER_EXPLOSIONS, &Explosion::explosion); if(checkTile(ptr, id[_id], LayerType::LAYER_STONES, &Explosion::stone) || checkTile(ptr, id[_id], LayerType::LAYER_BOMBS, &Explosion::bomb)) newExplosion = new Explosion(ptr, id[_id], delay + Constants::Explosion::DELAY, position[_id], explosionLength - 1, Directions::none); else if(!checkTile(ptr, id[_id], LayerType::LAYER_BLOCKS, &Explosion::block)) newExplosion = new Explosion(ptr, id[_id], delay + Constants::Explosion::DELAY, position[_id], explosionLength - 1, Directions(_id)); if(newExplosion != nullptr) ptr->world[ id[_id] ].insert( std::make_pair(LayerType::LAYER_EXPLOSIONS, newExplosion) ); }