bool SpatialIndexManager::_AddObject(Object *newObject) { uint32 finalBucket = getGrid()->AddObject(newObject); //DLOG(info) << "SpatialIndexManager::AddObject :: Object " << newObject->getId() << " added to bucket " << finalBucket; if(finalBucket == 0xffffffff) { DLOG(info) << "SpatialIndexManager::AddObject :: Object " << newObject->getId() << " could not be added to the bucket because the bucket was invalid " << finalBucket; return false; } if(newObject->getType() == ObjType_Player) { //enforce proper handling of players!! PlayerObject* player = static_cast<PlayerObject*>(newObject); _AddObject(player); } //get all Players in range and register as necessary ObjectListType playerList; getGrid()->GetPlayerViewingRangeCellContents(finalBucket, &playerList); for(ObjectListType::iterator i = playerList.begin(); i != playerList.end(); i++) { PlayerObject* otherPlayer = static_cast<PlayerObject*>((*i)); sendCreateObject(newObject,otherPlayer, false); if((newObject->getType() == ObjType_Creature) || (newObject->getType() == ObjType_NPC)) { gContainerManager->registerPlayerToContainer(newObject, otherPlayer); } } return true; }
FloatLatchPropertyGeneralWidget::FloatLatchPropertyGeneralWidget(FloatLatch * comp, QWidget *parent, const char *name) : ComponentPropertyGeneralWidget(comp, parent, name) { QString tip; m_min = QMAX ( comp->getInputPack()->getNumberOfNotDeletableConnectors(), comp->getOutputPack()->getNumberOfNotDeletableConnectors()); m_channelsLabel = new QLabel(i18n("Channel count: "), getGrid(), "m_channelsLabel"); CHECK_PTR(m_channelsLabel); m_channels = new QSpinBox(m_min, MAX_CHANNELS, 1, getGrid(), "m_channels"); CHECK_PTR(m_channels); tip = i18n("Change count of channels here."); addToolTip(tip, m_channels, m_channelsLabel); addWhatsThis(tip, m_channels, m_channelsLabel); m_resetValueLabel = new QLabel(i18n("Reset value: "), getGrid(), "m_resetValueLabel"); CHECK_PTR(m_resetValueLabel); m_resetValue = new KSimDoubleEdit(getGrid(), "m_resetValue"); CHECK_PTR(m_resetValue); tip = i18n("Change the reset value of the component here."); addToolTip(tip, m_resetValue, m_resetValueLabel); addWhatsThis(tip, m_resetValue, m_resetValueLabel); // Setup value m_resetValue->setValue(comp->getResetValue()); m_channels->setValue(comp->getInputPack()->getConnectorCount()); }
Path MapManager::match(int gridId1, int gridId2) { if (gridId1 == gridId2 || gridId1 < 0 || gridId2 < 0) { return Path(); } Grid* g1 = getGrid(gridId1); Grid* g2 = getGrid(gridId2); if (g1 == NULL || g2 == NULL) { return Path(); } if (g1->imageId != g2->imageId) { return Path(); } if (matchLine(gridId1, gridId2)) { m_path.push_back(gridId1); m_path.push_back(gridId2); CCLog("MapManager::matchLine done"); } else if (matchTwoLine(gridId1, gridId2)) { CCLog("MapManager::matchTwoLine done"); } else if (matchThreeLine(gridId1, gridId2)) { CCLog("MapManager::matchThreeLine done"); } return m_path; }
HippoGridInfo* HippoGridManager::getCurrentGrid() const { HippoGridInfo* grid = getGrid(mCurrentGrid); if(!grid) { grid = getGrid(mDefaultGrid); } return grid ? grid : &HippoGridInfo::FALLBACK_GRIDINFO; }
static int displayLight(gfluxstruct *gp) { int polys = 0; double x,y; double z; double dx = 2.0/((double)_squares); double dy = 2.0/((double)_squares); glLoadIdentity(); glRotatef(gp->anglex,1,0,0); glRotatef(gp->angley,0,1,0); glRotatef(gp->anglez,0,0,1); userRot(gp); glScalef(1,1,(GLfloat)_waveHeight); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); for(x=-1;x<0.9999;x+=dx) { glBegin(GL_QUAD_STRIP); for(y=-1;y<=1;y+=dy) { z = getGrid(gp, x,y,gp->time); genColour(z); glColor3fv(gp->colour); glNormal3f( getGrid(gp, x+dx,y,gp->time)-getGrid(gp, x-dx,y,gp->time), getGrid(gp, x,y+dy,gp->time)-getGrid(gp, x,y-dy,gp->time), 1 ); glVertex3f(x,y,z); z = getGrid(gp, x+dx,y,gp->time); genColour(z); glColor3fv(gp->colour); glNormal3f( getGrid(gp, x+dx+dx,y,gp->time)-getGrid(gp, x,y,gp->time), getGrid(gp, x+dx,y+dy,gp->time)-getGrid(gp, x+dx,y-dy,gp->time), 1 ); glVertex3f(x+dx,y,z); polys++; } glEnd(); } if (! gp->button_down_p) { gp->time -= _speed; gp->anglex -= _rotationx; gp->angley -= _rotationy; gp->anglez -= _rotationz; } return polys; }
Scene *Resource::getScene(uint16 id) { int streamid = id; if (g_twin->getGameType() == GType_LBA2) { ++streamid; } Scene *s = new Scene(_scene->createReadStreamForIndex(streamid)); if (g_twin->getGameType() == GType_LBA) { s->setGrid(getGrid(id)); } else if (!_scenes[id]._isIsland) { s->setGrid(getGrid(_scenes[id]._id)); } s->setId(id); return s; }
//============================================================================================================== // // get the Objects in range of the player ie everything in the Object Bucket // NO players, NO creatures, NO regions // void SpatialIndexManager::getObjectsInRange(const Object* const object, ObjectSet* result_set, uint32 object_types, float range, bool cell_content) { ObjectList result_list; //see that we do not query more grids than necessary uint32_t CustomRange = range / (MAPWIDTH/GRIDWIDTH); if(CustomRange > VIEWRANGE) { CustomRange = VIEWRANGE; } if(CustomRange < 2) { CustomRange = 2; } glm::vec3 position = object->getWorldPosition(); getGrid()->GetCustomRangeCellContents(getGrid()->getCellId(position.x, position.z), CustomRange, &result_list, Bucket_Objects); std::for_each(result_list.begin(), result_list.end(), [object, position, result_set, object_types, range, cell_content] (Object* range_object) { if (range_object == object) { return; } ObjectType type = range_object->getType(); if ((range_object->getType() & object_types) == static_cast<uint32_t>(type)) { if (glm::distance(object->getWorldPosition(), range_object->getWorldPosition()) <= range) { result_set->insert(range_object); } } // if its a building, add objects of our types it contains if wished if(type == ObjType_Building && cell_content) { ObjectList cells = static_cast<BuildingObject*>(range_object)->getAllCellChilds(); std::for_each(cells.begin(), cells.end(), [=] (Object* cell) { ObjectType type = cell->getType(); if ((type & object_types) == static_cast<uint32_t>(type)) { TangibleObject* tangible = static_cast<TangibleObject*>(cell); glm::vec3 tangible_position = tangible->getWorldPosition(); if (glm::distance(tangible_position, position) <= range) { result_set->insert(tangible); } } }); } }); }
static int displayWire(gfluxstruct *gp) { int polys = 0; double x,y; double z; double dx1 = 2.0/((double)(_squares*_resolution)) - 0.00001; double dy1 = 2.0/((double)(_squares*_resolution)) - 0.00001; double dx2 = 2.0/((double)_squares) - 0.00001; double dy2 = 2.0/((double)_squares) - 0.00001; glLoadIdentity(); glRotatef(gp->anglex,1,0,0); glRotatef(gp->angley,0,1,0); glRotatef(gp->anglez,0,0,1); userRot(gp); glScalef(1,1,(GLfloat)_waveHeight); glClear(GL_COLOR_BUFFER_BIT); for(x=-1;x<=1;x+=dx2) { glBegin(GL_LINE_STRIP); for(y=-1;y<=1;y+=dy1) { z = getGrid(gp, x,y,gp->time); genColour(z); glColor3fv(gp->colour); glVertex3f(x,y,z); polys++; } glEnd(); } for(y=-1;y<=1;y+=dy2) { glBegin(GL_LINE_STRIP); for(x=-1;x<=1;x+=dx1) { z = getGrid(gp, x,y,gp->time); genColour(z); glColor3fv(gp->colour); glVertex3f(x,y,z); polys++; } glEnd(); } if (! gp->button_down_p) { gp->time -= _speed; gp->anglex -= _rotationx; gp->angley -= _rotationy; gp->anglez -= _rotationz; } return polys; }
PUBLIC void table(EdiGrid *grid, cchar *optionString) { if (grid == 0) { grid = getGrid(); } espTable(getConn(), grid, optionString); }
void HippoGridManager::setCurrentGrid(const std::string& grid) { HippoGridInfo* prevGrid = getGrid(mCurrentGrid); GridIterator it = mGridInfo.find(grid); if (it != mGridInfo.end()) { mCurrentGrid = grid; } else if (!mGridInfo.empty()) { llwarns << "Unknown grid '" << grid << "'. Setting to default grid." << llendl; mCurrentGrid = mDefaultGrid; } if(mCurrentGridChangeSignal) (*mCurrentGridChangeSignal)(getGrid(mCurrentGrid),prevGrid); }
bool MapDraw::isVisible(short x, short y) { int distFromCenter = getGrid()->distanceBetween(x, y, getCenterX(), getCenterY()); if (distFromCenter < (GRID_SIZE - 2 )) return true; else return false; /* // Come on Owen, you have their X / Y. // out of array bounds. if ((x<0) || (y < 0) || (y>=DEPTH) || (x>=WIDTH)) return false; float pos = positionY( y ); if (fabs(pos) > (GRID_SIZE-2)) return false; pos = positionX( x ); if (fabs(pos) > (GRID_SIZE-2)) return false; return true; */ }
Grid* Universe::getSouthGrid(unsigned int x, unsigned int y, unsigned int z) { int zWest = (z == 0 ? -1 : z - 1); if (zWest == -1) return NULL; else return getGrid(x, y, zWest); }
Grid* Universe::getDownGrid(unsigned int x, unsigned int y, unsigned int z) { int yWest = (y == 0 ? -1 : y - 1); if (yWest == -1) return NULL; else return getGrid(x, yWest, z); }
bool HelloWorld::canInput(CCTouch* pTouch) { Grid* pGrid = getGrid(pTouch); if(pGrid) { return !pGrid->IsStatic(); } return false; }
Grid* Universe::getNorthGrid(unsigned int x, unsigned int y, unsigned int z) { int zEast = (z == CONFIG::gridNumberZ - 1 ? -1 : z + 1); if (zEast == -1) return NULL; else return getGrid(x, y, zEast); }
Grid* Universe::getUpGrid(unsigned int x, unsigned int y, unsigned int z) { int yEast = (y == CONFIG::gridNumberY - 1 ? -1 : y + 1); if (yEast == -1) return NULL; else return getGrid(x, yEast, z); }
Grid* Universe::getWestGrid(unsigned int x, unsigned int y, unsigned int z) { int xWest = (x == 0 ? -1 : x - 1); if (xWest == -1) return NULL; else return getGrid(xWest, y, z); }
Grid* Universe::getEastGrid(unsigned int x, unsigned int y, unsigned int z) { int xEast = (x == CONFIG::gridNumberX - 1 ? -1 : x + 1); if (xEast == -1) return NULL; else return getGrid(xEast, y, z); }
void PoissonDiskSampling::objectsPosition(WorldMap* map) { float minDistance = DISTANCE; std::vector <sf::Vector2f*> activePoints; //contenner in witch we are putting ceils with points. Grid grid; float cellSize = minDistance / SQRT2; grid.resize((mapWidth / cellSize), std::vector<bool>((mapHeight / cellSize), false)); sf::Vector2f* firstPoint = randPoint(); sf::Vector2i baseGrid; baseGrid = getGrid(firstPoint, cellSize); activePoints.push_back(firstPoint); positions[baseGrid.x][baseGrid.y].push_back(firstPoint); grid[baseGrid.x][baseGrid.y] = true; while (!activePoints.empty()) { sf::Vector2f* basePoint = (*activePoints.begin()); baseGrid = getGrid(basePoint, cellSize); int z = KMAX; for (int i = 0; i < z; ++i) { sf::Vector2f* neighbour = randNeighbour(basePoint, minDistance); sf::Vector2i neighbourGrid = getGrid(neighbour, cellSize); if (neighbour->x>0 && neighbour->y > 0 && neighbour->x < mapWidth && neighbour->y < mapHeight) { if (map->getMap(neighbour->x, neighbour->y, 0)>127) { // if ok add to active, grid and objectsPosition if (checkNeighbour(neighbour, minDistance, grid, positions)) { activePoints.push_back(neighbour); grid[neighbourGrid.x][neighbourGrid.y] = true; positions[neighbourGrid.x][neighbourGrid.y].push_back(neighbour); ilosc++; } } } } // delete previous random from active activePoints.erase(activePoints.begin()); } }
void GridCommand::writeProperties(QXmlStreamWriter* writer) { AbstractCommand::writeProperties(writer); writer->writeTextElement("grid", QString::number(getGrid())); writer->writeTextElement("transitionDuration", QString::number(getTransitionDuration())); writer->writeTextElement("tween", getTween()); writer->writeTextElement("defer", (getDefer() == true) ? "true" : "false"); }
HippoGridInfo *HippoGridManager::getCurrentGrid() const { HippoGridInfo *grid = getGrid(mCurrentGrid); if (grid) { return grid; } else { return &HippoGridInfo::FALLBACK_GRIDINFO; } }
/** Function that calculates the column in which an obstacle (i.e. grid indices corresponding to a value greater than 50 (obstacle) or equal to -1 (unknown)) @param x float @param y float @return row int */ int Pathplanner::getXObstacleInPath() { // ROS_INFO("%i, %i", indices[0], indices[1]); float currentX = this->currentPose.pose.position.x; float currentY = this->currentPose.pose.position.y; float currentZ = this->currentPose.pose.orientation.z; //float currentAngle = 2 * acos(currentZ) * (180/3.14); std::vector<int> indices = getGrid(currentX, currentY); ROS_INFO("X: %f, Y: %f", currentX, currentY); int column = indices[1]; int row = indices[0]; poseUpdated = false; if(this->sweepingRight) { for(; column < this->gridLength - 1; ++column) { int row = (indices[0] - 1 < 0) ? 0 : indices[0] - 10; int endI = (indices[0] + 1 >= this->gridLength) ? this->gridLength - 1 : indices[0] + 1; for(; row < endI; row++) { if(occupancyGrid[row][column] == 100) // || occupancyGrid[row][column] == -1) { ROS_INFO("Obst Column: %i", column); ROS_INFO("Current indices: %i, %i", row, column); return column; } } } } else { for(; column >= 1; --column) { int row = (indices[0] - 1 < 0) ? 0 : indices[0] - 1; int endI = (indices[0] + 1 >= this->gridLength) ? this->gridLength - 1 : indices[0] + 1; for(; row < endI; row++) { if(occupancyGrid[row][column] == 100) //|| occupancyGrid[row][column] == -1) { ROS_INFO("Obst Column: %i", column); ROS_INFO("Current indices: %i, %i", row, column); return column; } } } } //ROS_INFO("sweeping right? %i, obstacle column: %i, indices[0]: %i, indices[1]: %i", this->sweepingRight, column, indices[0], indices[1]); }
//==================================================================================================================== // // send to all players in chatrange void SpatialIndexManager::sendToChatRange(Object* container, std::function<void (PlayerObject* const player)> callback) { //get the Objects and unregister as necessary ObjectListType player_list; getGrid()->GetChatRangeCellContents(container->getGridBucket(), &player_list); std::for_each(player_list.begin(), player_list.end(), [callback] (Object* object) { callback(static_cast<PlayerObject*>(object)); }); }
bool LLGridManager::isSystemGrid(const std::string& grid) { std::string grid_name = getGrid(grid); return ( !grid_name.empty() && mGridList.has(grid) && mGridList[grid].has(GRID_IS_SYSTEM_GRID_VALUE) && mGridList[grid][GRID_IS_SYSTEM_GRID_VALUE].asBoolean() ); }
int main() { unsigned int grid[20][20] ; getGrid(file, grid); std::cout << getMaxProduct(grid); std::cin.get(); }
bool SpatialIndexManager::_AddObject(PlayerObject *player) { uint32 finalBucket = getGrid()->AddObject(player); DLOG(info) << "SpatialIndexManager::AddObject :: Player " << player->getId() << " added to bucket " << finalBucket; //any errors ? if(finalBucket == 0xffffffff) { DLOG(info) << "SpatialIndexManager::AddObject :: Player " << player->getId() << " could not be added to the bucket because the bucket was invalid " << finalBucket; return false; } //now create it for everyone around and around for it ObjectListType playerList; getGrid()->GetViewingRangeCellContents(finalBucket, &playerList,(Bucket_Creatures|Bucket_Objects|Bucket_Players)); for(ObjectListType::iterator i = playerList.begin(); i != playerList.end(); i++) { //we just added ourselves to the grid - dont send a create to ourselves if(((*i)->getId() == player->getId())) { continue; } //the object needs to be created no matter what sendCreateObject((*i), player, false); if(((*i)->getType() == ObjType_Creature) || ((*i)->getType() == ObjType_NPC)) { gContainerManager->registerPlayerToContainer((*i), player); continue; } if((*i)->getType() == ObjType_Player) { //create us for the other player PlayerObject* otherPlayer = static_cast<PlayerObject*>(*i); sendCreateObject(player, otherPlayer, false); gContainerManager->registerPlayerToContainer(otherPlayer, player); continue; } } return true; }
void SpatialIndexManager::UpdateObject(Object *updateObject) { uint32 oldBucket = updateObject->getGridBucket(); uint32 newBucket = getGrid()->getCellId(updateObject->getWorldPosition().x, updateObject->getWorldPosition().z); // now process the spatial index update if(newBucket != oldBucket) { DLOG(info) << "ContainerManager::UpdateObject :: " << updateObject->getId() <<"normal movement from bucket" << oldBucket << " to bucket" << newBucket; // test how much we moved if only one grid proceed normally if((newBucket == (oldBucket +1)) || (newBucket == (oldBucket -1)) || (newBucket == (oldBucket + GRIDWIDTH)) || (newBucket == (oldBucket - GRIDWIDTH)) || (newBucket == (oldBucket + GRIDWIDTH +1)) || (newBucket == (oldBucket + GRIDWIDTH -1)) || (newBucket == (oldBucket - GRIDWIDTH +1)) || (newBucket == (oldBucket - GRIDWIDTH -1))) { // sets the new gridcell, updates subcells getGrid()->UpdateObject(updateObject); // remove us from the row we left _UpdateBackCells(updateObject,oldBucket); // create us for the row in which direction we moved _UpdateFrontCells(updateObject,oldBucket); } else { // we teleported destroy all and create everything new DLOG(info) << "ContainerManager::UpdateObject :: " << updateObject->getId() <<"teleportation from bucket" << oldBucket << " to bucket" << newBucket; // remove us from everything RemoveObjectFromWorld(updateObject); // sets the new gridcell, updates subcells getGrid()->AddObject(updateObject); // and add us freshly to the world _AddObject(updateObject); } } // Make sure to update any regions the object may be entering or leaving. getGrid()->updateRegions(updateObject); }
bool MapManager::matchLine(int gridId1, int gridId2) { //判断一条连线上是否能消除 m_path.clear(); Grid* g1 = getGrid(gridId1); Grid* g2 = getGrid(gridId2); if (g1 == NULL || g2 == NULL) { return false; } if (g1->row == g2->row) { return isRowEmpty(g1->row, g1->col, g2->col); } if (g1->col == g2->col) { return isColEmpty(g1->col, g1->row, g2->row); } return false; }
void gridToGrid(phys::Collision* c, phys::RigidBody *a, phys::RigidBody *b) { auto gridA = reinterpret_cast<GridShape*>(a->getShape()); auto gridB = reinterpret_cast<GridShape*>(b->getShape()); bool polyA; if (gridA->getGrid()->getWrapX() && gridB->getGrid()->getWrapX()) { return; } else if (gridA->getGrid()->getWrapX()) { polyA = false; } else if (gridB->getGrid()->getWrapX()) { polyA = true; } if (polyA) { a->setShape(&gridA->getGrid()->mPolyShape); // Use B's polygon shape gridToPolygon(c, b, a); a->setShape(gridA); // Put B's grid shape back } else { b->setShape(&gridB->getGrid()->mPolyShape); // Use B's polygon shape gridToPolygon(c, a, b); b->setShape(gridB); // Put B's grid shape back } }
std::string LLGridManager::getLoginPage(const std::string& grid) { std::string grid_login_page; std::string grid_name = getGrid(grid); if (!grid_name.empty()) { grid_login_page = mGridList[grid_name][GRID_LOGIN_PAGE_VALUE].asString(); } else { LL_WARNS("GridManager")<<"invalid grid '"<<grid<<"'"<<LL_ENDL; } return grid_login_page; }