void CApp::OnMouseMove(int mX, int mY, int relX, int relY, bool Left,bool Right,bool Middle) { if (Left) { if(!(mX < TileWindow.Width && mY < TileWindow.Height)) { if(InBounds(mX, mY)) { GetTile( mX, mY); Map->SetTile(tile, newTileID, newTypeID); } } } if (Right) { if(!(mX < TileWindow.Width && mY < TileWindow.Height)) { if(InBounds(mX, mY)) { if( ((mX - CCamera::CameraControl.GetX()) < MAP_WIDTH*TILE_SIZE*CArea::AreaControl.areaWidth) && ((mY - CCamera::CameraControl.GetY()) < MAP_HEIGHT*TILE_SIZE*CArea::AreaControl.areaHeight) && ((mYold - CCamera::CameraControl.GetY()) < MAP_HEIGHT*TILE_SIZE*CArea::AreaControl.areaHeight) && ((mXold - CCamera::CameraControl.GetX()) < MAP_WIDTH*TILE_SIZE*CArea::AreaControl.areaWidth)) { // draws tiles but doesn't erase when you go too far GetTile( mX, mYold); Map->SetTile(tile, newTileID, newTypeID); GetTile(mXold, mY); Map->SetTile(tile, newTileID, newTypeID); } } } } }
void PathNode::DebugDraw(Label* aLabel, Rect* aRect) { #if DEBUG //Draw the rect, the color represent which list the path node is in aRect->SetLocalPosition(GetTile()->GetCenter(false)); aRect->SetSize(GetTile()->GetSize(), GetTile()->GetSize()); aRect->Draw(); //Draw the F score stringstream ss; ss << GetScoreF(); aLabel->SetText(ss.str()); aLabel->SetAnchorPoint(0.0f, 1.0f); aLabel->SetLocalPosition(vec2(GetTile()->GetLocalX(), GetTile()->GetLocalY() + GetTile()->GetSize())); aLabel->Draw(); //Draw the S score ss.str(""); ss << GetScoreG(); aLabel->SetText(ss.str()); aLabel->SetAnchorPoint(0.0f, 0.0f); aLabel->SetLocalPosition(vec2(GetTile()->GetLocalX(), GetTile()->GetLocalY())); aLabel->Draw(); //Draw the H score ss.str(""); ss << GetScoreH(); aLabel->SetText(ss.str()); aLabel->SetAnchorPoint(1.0f, 0.0f); aLabel->SetLocalPosition(vec2(GetTile()->GetLocalX() + GetTile()->GetSize(), GetTile()->GetLocalY())); aLabel->Draw(); #endif }
int CCollision::IntersectAir(vec2 Pos0, vec2 Pos1, vec2 *pOutCollision, vec2 *pOutBeforeCollision) { float d = distance(Pos0, Pos1); vec2 Last = Pos0; for(float f = 0; f < d; f++) { float a = f/d; vec2 Pos = mix(Pos0, Pos1, a); if(IsSolid(round_to_int(Pos.x), round_to_int(Pos.y)) || (!GetTile(round_to_int(Pos.x), round_to_int(Pos.y)) && !GetFTile(round_to_int(Pos.x), round_to_int(Pos.y)))) { if(pOutCollision) *pOutCollision = Pos; if(pOutBeforeCollision) *pOutBeforeCollision = Last; if(!GetTile(round_to_int(Pos.x), round_to_int(Pos.y)) && !GetFTile(round_to_int(Pos.x), round_to_int(Pos.y))) return -1; else if (!GetTile(round_to_int(Pos.x), round_to_int(Pos.y))) return GetTile(round_to_int(Pos.x), round_to_int(Pos.y)); else return GetFTile(round_to_int(Pos.x), round_to_int(Pos.y)); } Last = Pos; } if(pOutCollision) *pOutCollision = Pos1; if(pOutBeforeCollision) *pOutBeforeCollision = Pos1; return 0; }
/* Generate a tile type for the specific tile based on surrounding tiles height. */ TerrainTest::tiletype TerrainTest::GetTileType(int x, int y) { tile* t = GetTile(x, y); if (!t) return TILE_INVALID; //Get height values of surrounding tiles int n = -1, s = -1, e = -1, w = -1, se = -1, sw = -1, ne = -1, nw = -1; int c = t->height; tile* t2; t2 = GetTile(x, y-1); if (t2) n = t2->height; t2 = GetTile(x, y+1); if (t2) s = t2->height; t2 = GetTile(x-1, y); if (t2) w = t2->height; t2 = GetTile(x+1, y); if (t2) e = t2->height; t2 = GetTile(x-1, y-1); if (t2) nw = t2->height; t2 = GetTile(x+1, y-1); if (t2) ne = t2->height; t2 = GetTile(x-1, y+1); if (t2) sw = t2->height; t2 = GetTile(x+1, y+1); if (t2) se = t2->height; //Use surrounding heights to determine our own type if (e == c && w == c && n >= c && s < c && s != -1) return TILE_SOUTHEDGE; if (w >= c && e < c && e != -1 && n == c && s == c) return TILE_EASTEDGE; if (e >= c && w < c && w != -1 && n == c && s == c) return TILE_WESTEDGE; if (e == c && w == c && s >= c && n < c && n != -1) return TILE_NORTHEDGE; if (e < c && n < c && e != -1 && n != -1 && s >= c && w >= c) return TILE_NEEDGE; if (w < c && n < c && w != -1 && n != -1 && s >= c && e >= c) return TILE_NWEDGE; if (e < c && s < c && e != -1 && s != -1 && n >= c && w >= c) return TILE_SEEDGE; if (w < c && s < c && w != -1 && s != -1 && n >= c && e >= c) return TILE_SWEDGE; //Fix diagonals if (n == c && e == c && ne < c && ne != -1) return TILE_SWBEND; if (n == c && w == c && nw < c && nw != -1) return TILE_SEBEND; if (s == c && e == c && se < c && se != -1) return TILE_NWBEND; if (s == c && w == c && sw < c && sw != -1) return TILE_NEBEND; return TILE_INVALID; }
int checkMapCollision(int x, int y, int testX, int testY){ testY -= 1; if(GetTile(30,((x+testX)/8), ((y+testY)/8)) == 0){ return 1; } if(GetTile(30, ((x+testX)/8), ((y+testY)/8)) >= 21 && GetTile(30, ((x+testX)/8), ((y+testY)/8)) <= 25){ return 1; } if(GetTile(30, ((x+testX)/8), ((y+testY)/8)) >= 16 && GetTile(30, ((x+testX)/8), ((y+testY)/8)) <= 20){ return 2; } return 0; }
void Map::ShipOccupy(int x, int y, Direction dir, Ship* ship) { int deltaX = 0; int deltaY = 0; switch (dir) { case DIR_UP: deltaY = 1; break; case DIR_DOWN: deltaY = -1; break; case DIR_LEFT: deltaX = -1; break; case DIR_RIGHT: deltaX = 1; break; } for (int i = 0; i < ship->GetSize(); ++i) { Tile* tile = GetTile(x, y); _ASSERT(tile != nullptr); tile->SetOccupiedShip(ship); x += deltaX; y += deltaY; } }
// Create a whole 'frame' from VP8 (+ alpha) or lossless. static int SynthesizeFrame(const WebPDemuxer* const dmux, const Frame* const first_frame, int tile_num, WebPIterator* const iter) { const uint8_t* const mem_buf = dmux->mem_.buf_; int num_tiles; size_t payload_size = 0; const Frame* const tile = GetTile(first_frame, tile_num, &num_tiles); const uint8_t* const payload = GetFramePayload(mem_buf, tile, &payload_size); if (payload == NULL) return 0; iter->frame_num_ = first_frame->frame_num_; iter->num_frames_ = dmux->num_frames_; iter->tile_num_ = tile_num; iter->num_tiles_ = num_tiles; iter->x_offset_ = tile->x_offset_; iter->y_offset_ = tile->y_offset_; iter->width_ = tile->width_; iter->height_ = tile->height_; iter->duration_ = tile->duration_; iter->complete_ = tile->complete_; iter->tile_.bytes_ = payload; iter->tile_.size_ = payload_size; // TODO(jzern): adjust offsets for 'TILE's embedded in 'FRM 's return 1; }
void TERRAIN::CalculateAlphaMaps() { Progress("Creating Alpha Map", 0.0f); //Clear old alpha maps if(m_pAlphaMap != NULL) m_pAlphaMap->Release(); //Create new alpha map D3DXCreateTexture(m_pDevice, 128, 128, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pAlphaMap); //Lock the texture D3DLOCKED_RECT sRect; m_pAlphaMap->LockRect(0, &sRect, NULL, NULL); BYTE *bytes = (BYTE*)sRect.pBits; memset(bytes, 0, 128*sRect.Pitch); //Clear texture to black for(int i=0;i<(int)m_diffuseMaps.size();i++) for(int y=0;y<sRect.Pitch / 4;y++) for(int x=0;x<sRect.Pitch / 4;x++) { int terrain_x = (int)(m_size.x * (x / (float)(sRect.Pitch / 4.0f))); int terrain_y = (int)(m_size.y * (y / (float)(sRect.Pitch / 4.0f))); MAPTILE *tile = GetTile(terrain_x, terrain_y); if(tile != NULL && tile->m_type == i) bytes[y * sRect.Pitch + x * 4 + i] = 255; } //Unlock the texture m_pAlphaMap->UnlockRect(0); //D3DXSaveTextureToFile("alpha.bmp", D3DXIFF_BMP, m_pAlphaMap, NULL); }
void TileGroup::SetValue(type::Value &value, oid_t tuple_id, oid_t column_id) { PL_ASSERT(tuple_id < GetNextTupleSlot()); oid_t tile_column_id, tile_offset; LocateTileAndColumn(column_id, tile_offset, tile_column_id); GetTile(tile_offset)->SetValue(value, tuple_id, tile_column_id); }
peloton::VarlenPool *TileGroup::GetTilePool(const oid_t tile_id) const { Tile *tile = GetTile(tile_id); if (tile != nullptr) return tile->GetPool(); return nullptr; }
bool Layer::DrawTileToVertexArrays(VertexVector* vertices, unsigned int x, unsigned int y) const { int tileX = x, tileY = y; if (IsWidthTiled) { //this stuff can probably be optimized a bit by checking at some higher level? if (tileX >= RealWidth) tileX %= RealWidth; else while (tileX < 0) tileX += RealWidth; } else if (tileX < 0 || tileX >= RealWidth) return false; if (IsHeightTiled) { if (tileY >= Height) tileY %= Height; else while (tileY < 0) tileY += Height; } else if (tileY < 0 || tileY >= Height) return false; const Tile tile = GetTile(tileX, tileY); if (tile.ID == 0) return false; quad tileQuad(LevelPtr->QuadsPerTile, tile); tileQuad.positionPositionAt(x * TILEWIDTH, y * TILEHEIGHT); tileQuad.appendTo(vertices[tileQuad.TextureID]); return tile.ID >= LevelPtr->AnimOffset; }
/** * Grab next slot (thread-safe) and fill in the tuple * * Returns slot where inserted (INVALID_ID if not inserted) */ void TileGroup::CopyTuple(const Tuple *tuple, const oid_t &tuple_slot_id) { LOG_TRACE("Tile Group Id :: %u status :: %u out of %u slots ", tile_group_id, tuple_slot_id, num_tuple_slots); oid_t tile_column_count; oid_t column_itr = 0; for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) { const catalog::Schema &schema = tile_schemas[tile_itr]; tile_column_count = schema.GetColumnCount(); storage::Tile *tile = GetTile(tile_itr); PL_ASSERT(tile); char *tile_tuple_location = tile->GetTupleLocation(tuple_slot_id); PL_ASSERT(tile_tuple_location); // NOTE:: Only a tuple wrapper storage::Tuple tile_tuple(&schema, tile_tuple_location); for (oid_t tile_column_itr = 0; tile_column_itr < tile_column_count; tile_column_itr++) { tile_tuple.SetValue(tile_column_itr, tuple->GetValue(column_itr), tile->GetPool()); column_itr++; } } }
/// \brief /// Accesses tile by height sample indices inside this sector. Indices must be in valid range inline VSectorTile *GetTileAtSampleIndices(int x,int y) const { x/=m_Config.m_iHeightSamplesPerTile[0]; y/=m_Config.m_iHeightSamplesPerTile[1]; // the height samples must be in range, but clamp at max edge because of extra overlapping values return GetTile(hkvMath::Min(x,m_Config.m_iTilesPerSector[0]-1),hkvMath::Min(y,m_Config.m_iTilesPerSector[1]-1)); }
cTile* cTileMapLineIt::Next() { GetTile(); mbUpdated = false; return mpTile; }
/* void TerrainTest::_recalculateType(int x, int y) { tile* t = GetTile(x, y); tile* t2; if (t) t->type = type; if (t->type == TILE_NORTHEDGE) { } } */ void TerrainTest::Repair() { tiletype type; tile* t; //fix invalid types for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { _repairTile(x, y); } } //set types for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { t = GetTile(x, y); type = GetTileType(x, y); if (t) t->type = type; } } //after all types are set, go again and reload /* for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { _recalculateType(x, y); } }*/ }
void Map::Draw(Gdiplus::Graphics* g) { Vector3i northWestTile = mMapViewport->GetNorthWestTileCoordinate(); Vector3i southEastTile = mMapViewport->GetSouthEastTileCoordinate(); Vector2i origin = mMapViewport->GetTileOrigin(northWestTile); int xTileCount = southEastTile.GetX() - northWestTile.GetX() + 1; int yTileCount = southEastTile.GetY() - northWestTile.GetY() + 1; int tileCount = xTileCount*yTileCount; for(int i = 0; i<xTileCount; i++) { for(int j = 0; j<yTileCount; j++) { Vector3i coord(northWestTile.GetX() + i, northWestTile.GetY() + j, mMapViewport->GetZoom()); Tile* tile = GetTile(coord); if(!tile->IsLoaded()) { tile->SignalReady += [this](Tile* tile) { std::lock_guard<std::mutex> lock(signal_mutex); SignalNewTile.emit(); }; continue; } Gdiplus::Image* im = tile->GetImage(); if(im) g->DrawImage(im, origin.GetX() + i*mMapSource->GetTileSize(), origin.GetY() + j*mMapSource->GetTileSize()); } } }
void SetupForegroundLayer() { s16 tilepositionx = PIXEL_TO_TILE(-scrollData.scrollx_vdp) - 1; // divide by 8 s16 tilepositiony = PIXEL_TO_TILE(scrollData.scrolly_vdp) - 1; // // compute start and end tiles s16 starttilex = tilepositionx; s16 endtilex = (tilepositionx + TILE_UPDATE_AREA_WIDTH); s16 starttiley = tilepositiony; s16 endtiley = (tilepositiony + TILE_UPDATE_AREA_HEIGHT); s16 loop = 0; s16 innerLoop = 0; u16 tileNumber = 0; u16 arrayStart = 0; const u16 tileBaseValue = TILE_ATTR_FULL(PAL3, 0, 0, 0, 0) + foregroundLoadedTileInfo.startIndex; for (loop = starttiley; loop <= endtiley; loop++) { arrayStart = loop * levelData.foreground->width; for (innerLoop = starttilex; innerLoop <= endtilex; innerLoop++) { tileNumber = ARRAY_ITEM_VALUE(levelData.foreground->tilemap, arrayStart + innerLoop); tileNumber = GetTile(tileNumber, tileBaseValue); VDP_setTileMapXY(APLAN, tileNumber, innerLoop & 63, loop & 63); } } }
std::pair<int,int> Level::GetSpawnPoint ( const std::string& entrance_tag ) { int startx, starty; int entrance_exists = FindTileWithTag (entrance_tag, startx, starty); if ( entrance_exists ) { return std::make_pair ( startx, starty ); } // If we get this far, it's probably the town (but it could be a malcreated dungeon with no entrance). // Find a clear spot, anywhere will do. for ( int x = 1; x < sizex; x++ ) { for ( int y = 1; y < sizey; y++ ) { LevelTile& tile = GetTile ( x, y ); if ( tile.tile->HasOneFlag ( FLAG_BLOCKS_MOVEMENT ) ) continue; Mobile* mob = GetFirstMobileAt ( x, y ); if ( mob ) continue; return std::make_pair ( x, y ); } } std::cerr << "Unable to find a player spawn point\n"; exit ( 1 ); }
bool CCollision::IsTileSolid(int x, int y) const { int Col = GetTile(x, y); if(Col&COLFLAG_SOLID) return true; if(!(Col&COLFLAG_TL3)) { if(Col&COLFLAG_RED && Col&COLFLAG_BLUE) { if(Col&COLFLAG_APPEAR) return (Techlevel[0] >= 2 || Techlevel[1] >= 2); else return (Techlevel[0] < 2 && Techlevel[1] < 2); } } else { if(Col&COLFLAG_RED && Col&COLFLAG_BLUE) { if(Col&COLFLAG_APPEAR) return (Techlevel[0] == 3 || Techlevel[1] == 3); else return (Techlevel[0] < 3 && Techlevel[1] < 3); } } if(Col & COLFLAG_APPEAR) return (Col&COLFLAG_RED && !(Col&COLFLAG_TL3) && Techlevel[0] >= 2) || (Col&COLFLAG_RED && Col&COLFLAG_TL3 && Techlevel[0] == 3) || (Col&COLFLAG_BLUE && !(Col&COLFLAG_TL3) && Techlevel[1] >= 2) || (Col&COLFLAG_BLUE && Col&COLFLAG_TL3 && Techlevel[1] == 3); else return (Col&COLFLAG_RED && !(Col&COLFLAG_TL3) && Techlevel[0] < 2) || (Col&COLFLAG_RED && Col&COLFLAG_TL3 && Techlevel[0] < 3) || (Col&COLFLAG_BLUE && !(Col&COLFLAG_TL3) && Techlevel[1] < 2) || (Col&COLFLAG_BLUE && Col&COLFLAG_TL3 && Techlevel[1] < 3); }
void TiledGroundMap::SetTile(int x, int y, const std::string& texture, int rotate, bool mirror) { Tile* tile = GetTile(x, y); tile->texture = texture; tile->rotate = rotate; tile->mirror = mirror; }
/** * Apply the column delta on the rollback segment to the given tuple */ void TileGroup::ApplyRollbackSegment(char *rb_seg, const oid_t &tuple_slot_id) { auto seg_col_count = storage::RollbackSegmentPool::GetColCount(rb_seg); auto table_schema = GetAbstractTable()->GetSchema(); for (size_t idx = 0; idx < seg_col_count; ++idx) { auto col_id = storage::RollbackSegmentPool::GetIdOffsetPair(rb_seg, idx)->col_id; Value col_value = storage::RollbackSegmentPool::GetValue(rb_seg, table_schema, idx); // Get target tile auto tile_id = GetTileIdFromColumnId(col_id); PL_ASSERT(tile_id < GetTileCount()); storage::Tile *tile = GetTile(tile_id); PL_ASSERT(tile); // Get tile schema auto &tile_schema = tile_schemas[tile_id]; // Get a tuple wrapper char *tile_tuple_location = tile->GetTupleLocation(tuple_slot_id); PL_ASSERT(tile_tuple_location); storage::Tuple tile_tuple(&tile_schema, tile_tuple_location); // Write the value to tuple auto tile_col_idx = GetTileColumnId(col_id); tile_tuple.SetValue(tile_col_idx, col_value, tile->GetPool()); } }
void cShoot::CanShoot(int *map, cBicho &Player) { int x,y; GetTile(&x,&y); if(map[x+(y*SCENE_WIDTH)] != 0) active = false; else active = true; if(active) { if(GetState() == STATE_SHOOT_LEFT || GetState() == STATE_LOOKLEFT || GetState() == STATE_WALKLEFT ) { active = !(Player.CollidesMapWall(map,false)); if(map[(x+1)+y*SCENE_WIDTH] != 0) active = false; if(map[(x+2)+y*SCENE_WIDTH] != 0) active = false; } else if(GetState() == STATE_LOOKDOWN||GetState() == STATE_WALKDOWN) { active = !(Player.CollidesTopBot(map,false)); if(map[x+((y+1)*SCENE_WIDTH)] != 0) active = false; } else if(GetState() == STATE_LOOKUP||GetState() == STATE_LOOKUP) { active = !(Player.CollidesTopBot(map,true)); } else if(GetState() == STATE_SHOOT_RIGHT || GetState() == STATE_LOOKRIGHT || GetState() == STATE_WALKRIGHT ) { active = !(Player.CollidesMapWall(map,true)); if(map[(x+1)+y*SCENE_WIDTH] != 0) active = false; } else if(GetState() == STATE_DUPLEFT) { active = !(Player.CollidesWall(map,false)); } } }
TerrainTile* TerrainHolder::GetTile(float x, float y) { int32 tx = (int32)(32 - (x / TERRAIN_TILE_SIZE)); int32 ty = (int32)(32 - (y / TERRAIN_TILE_SIZE)); return GetTile(tx, ty); }
void UTerrainManager::DiscoverCave(int32 x, int32 y) { if (IsOutOfBounds(x, y)) return; ATile* t = GetTile(x, y); if (!t->IsVisible) { t->IsVisible = true; DiscoverCave(x - 1, y); DiscoverCave(x + 1, y); DiscoverCave(x, y - 1); DiscoverCave(x, y + 1); DiscoverCave(x - 1, y + 1); DiscoverCave(x + 1, y + 1); DiscoverCave(x + 1, y - 1); DiscoverCave(x - 1, y - 1); } if (t->IsWall()) { if (UpdateWallAtTile(t)) CollapseTile(t); } else { t->GetStaticMeshComponent()->SetStaticMesh(t->GroundMesh); t->GetStaticMeshComponent()->SetMaterial(0, this->BiomeMaterials[t->TextureIndex()]); } }
bool CCollision::IsTileSolid(int x, int y, bool nocoll) { //H-Client if (nocoll && m_pMineTeeTiles) { if (((GetMineTeeBlockAt(x,y) >= BLOCK_UNDEF48 && GetMineTeeBlockAt(x,y) <= BLOCK_BED) || GetMineTeeBlockAt(x,y) == BLOCK_RSETA || GetMineTeeBlockAt(x,y) == BLOCK_BSETA) || GetMineTeeBlockAt(x,y) == BLOCK_TARTA1 || GetMineTeeBlockAt(x,y) == BLOCK_TARTA2) { int Nx = clamp(x/32, 0, m_Width-1); int Ny = clamp(y/32, 0, m_Height-1); Nx *= 32; Ny *= 32; if (y >= Ny+16.0f) return 1; return 0; } else if (m_pMineTeeTiles && (GetMineTeeBlockAt(x,y) == BLOCK_AZUCAR || GetMineTeeBlockAt(x,y) == BLOCK_ROSAR || GetMineTeeBlockAt(x,y) == BLOCK_ROSAY || (GetMineTeeBlockAt(x,y) >= BLOCK_SEED1 && GetMineTeeBlockAt(x,y) <= BLOCK_SEED8) || GetMineTeeBlockAt(x,y) == BLOCK_SETAR1 || GetMineTeeBlockAt(x,y) == BLOCK_SETAR2)) return 0; } return GetTile(x, y)&COLFLAG_SOLID; }
void SeedBag::Use() { auto currentLandmark = GameState::Get().GetCurrentLandmark(); auto positionX = Player::Get().GetPositionX(); auto positionY = Player::Get().GetPositionY(); auto tile = currentLandmark->GetTile(positionX, positionY); if (tile.TileType != TileType::Tilled) { GameState::Get().AddLogMessage("The ground here is not tilled!"); return; } auto prop = currentLandmark->GetProp(positionX, positionY); if (prop != nullptr) { GameState::Get().AddLogMessage("There is already something here."); return; } if (this->NumberOfSeeds <= 0) { GameState::Get().AddLogMessage("There are no more seeds in this bag."); return; } this->NumberOfSeeds--; auto crop = PlantedCrop::Construct(Crop::FromCropType(this->CropType), CropGrowthType::Seedling); currentLandmark->AddProp(positionX, positionY, crop); auto cropName = Crop::FromCropType(this->CropType).Name; bool startsWithVowel = cropName.find_first_of("aAeEiIoOuU") == 0; GameState::Get().AddLogMessageFmt("You plant %s %s.", startsWithVowel ? "an" : "a", cropName.c_str()); }
void Plantable::Plant(ItemPtr sourceItem) { auto x = Player::Get().GetPositionX(); auto y = Player::Get().GetPositionY(); auto currentLandmark = GameState::Get().GetCurrentLandmark(); auto currentTile = currentLandmark->GetTile(x, y); if (currentTile.TileType != TileType::Tilled) { GameState::Get().AddLogMessage("You can only plant on tilled land!"); return; } auto item = currentLandmark->GetItem(x, y); if (item != nullptr) { GameState::Get().AddLogMessageFmt("Cannot plant, %s is on the ground here.", item->GetName().c_str()); return; } auto crop = GameState::Get().GetItemFromItemDatabase(this->Crop); crop->SetCount(1); currentLandmark->AddItem(x, y, crop); auto growableInterface = crop->GetInterface<Growable>(ItemInterfaceType::Growable); if (growableInterface != nullptr) { growableInterface->StartGrowing(crop); } sourceItem->RemoveOne(); }
void Display() { SDL_Rect t_pos; t_pos.w = TILE_SIZE; t_pos.h = TILE_SIZE; for(t_pos.x = 0; t_pos.x < w*TILE_SIZE; t_pos.x+=TILE_SIZE) { for(t_pos.y = 0; t_pos.y < h*TILE_SIZE; t_pos.y+=TILE_SIZE) { if(GetTile(t_pos.x/TILE_SIZE,t_pos.y/TILE_SIZE).wall) { SDL_BlitSurface(i_wall,NULL,screen,&t_pos); } else { SDL_BlitSurface(i_grass,NULL,screen,&t_pos); } } } //display players for(int i = 0; i < players.size(); i++) { SDL_BlitSurface(i_player,NULL,screen,&players[i]->GetScreenPos()); } SDL_Flip(screen); }
CStr8 CTerrain::GetMovementClass(ssize_t i, ssize_t j) const { CMiniPatch* tile = GetTile(i, j); if (tile && tile->GetTextureEntry()) return tile->GetTextureEntry()->GetProperties().GetMovementClass(); return "default"; }
type::AbstractPool *TileGroup::GetTilePool(const oid_t tile_id) const { Tile *tile = GetTile(tile_id); if (tile != nullptr) { return tile->GetPool(); } return nullptr; }