TEST(CoreTests, VolumeOutOfBounds) { Volume<char> * image = new Volume<char>(10,10, 10); // Getters EXPECT_THROW(image->get(-1), OutOfBoundsException); EXPECT_THROW(image->get(10*10*10), OutOfBoundsException); EXPECT_THROW(image->get(-4, 4, 2), OutOfBoundsException); EXPECT_THROW(image->get(-1,-10, 0), OutOfBoundsException); EXPECT_THROW(image->get(10, 0, 0), OutOfBoundsException); EXPECT_THROW(image->get(2, 1, -1), OutOfBoundsException); EXPECT_THROW(image->get(int3(-1, 4, 0)), OutOfBoundsException); EXPECT_THROW(image->get(int3(0, 200, 2)), OutOfBoundsException); EXPECT_THROW(image->get(Region(11, 11, 1)), OutOfBoundsException); // Setters EXPECT_THROW(image->set(-1,1), OutOfBoundsException); EXPECT_THROW(image->set(10*10*10,1), OutOfBoundsException); EXPECT_THROW(image->set(-4, 4, 2,1), OutOfBoundsException); EXPECT_THROW(image->set(-1,-10, 0,1), OutOfBoundsException); EXPECT_THROW(image->set(10, 0, 0,1), OutOfBoundsException); EXPECT_THROW(image->set(2, 1, -1,1), OutOfBoundsException); EXPECT_THROW(image->set(int3(-1, 4, 0),1), OutOfBoundsException); EXPECT_THROW(image->set(int3(0, 200, 2),1), OutOfBoundsException); EXPECT_THROW(image->set(Region(11, 11, 1),1), OutOfBoundsException); }
void ComputeMipsSize( int32_t width, int32_t heigth, int32_t depth, std::vector<int3> & outMipsSize) { outMipsSize.clear(); int32_t x = std::max<int32_t>(1, width); int32_t y = std::max<int32_t>(1, heigth); int32_t z = std::max<int32_t>(1, depth); // Mip 0 outMipsSize.push_back(int3(x, y, z)); // Loop until x=y=z=1 while ((x != 1) || (y != 1) || (z != 1)) { x = std::max<int32_t>(1, x >> 1); y = std::max<int32_t>(1, y >> 1); z = std::max<int32_t>(1, z >> 1); outMipsSize.push_back(int3(x, y, z)); } }
void View::drawGrid(Renderer2D &out) const { if(!m_is_visible) return; const int2 tile_map_size = m_tile_map.dimensions(); int2 p[4] = { screenToWorld(m_view_pos + int2(0, 0)), screenToWorld(m_view_pos + int2(0, m_view_size.y)), screenToWorld(m_view_pos + int2(m_view_size.x, m_view_size.y)), screenToWorld(m_view_pos + int2(m_view_size.x, 0)) }; int2 offset = screenToWorld(worldToScreen(int3(0, m_height, 0))); for(int n = 0; n < 4; n++) p[n] -= offset; int2 tmin = min(min(p[0], p[1]), min(p[2], p[3])); int2 tmax = max(max(p[0], p[1]), max(p[2], p[3])); IRect box(max(tmin, int2(0, 0)), min(tmax, tile_map_size)); Color color(255, 255, 255, 64); for(int x = box.min.x - box.min.x % m_cell_size; x <= box.max.x; x += m_cell_size) drawLine(out, int3(x, m_height, box.min.y), int3(x, m_height, box.max.y), color); for(int y = box.min.y - box.min.y % m_cell_size; y <= box.max.y; y += m_cell_size) drawLine(out, int3(box.min.x, m_height, y), int3(box.max.x, m_height, y), color); }
void CPrivilagedInfoCallback::getAllTiles (std::unordered_set<int3, ShashInt3> &tiles, boost::optional<PlayerColor> Player/*=uninit*/, int level, int surface ) const { if(!!Player && *Player >= PlayerColor::PLAYER_LIMIT) { logGlobal->errorStream() << "Illegal call to getAllTiles !"; return; } bool water = surface == 0 || surface == 2, land = surface == 0 || surface == 1; std::vector<int> floors; if(level == -1) { for(int b = 0; b < (gs->map->twoLevel ? 2 : 1); ++b) { floors.push_back(b); } } else floors.push_back(level); for (auto zd : floors) { for (int xd = 0; xd < gs->map->width; xd++) { for (int yd = 0; yd < gs->map->height; yd++) { if ((getTile (int3 (xd,yd,zd))->terType == ETerrainType::WATER && water) || (getTile (int3 (xd,yd,zd))->terType != ETerrainType::WATER && land)) tiles.insert(int3(xd,yd,zd)); } } } }
void fn00401090(Eq_4 * fs) { fs->dw0000 = fp - 0x00000004; int3(); int3(); return; }
void CPrivilagedInfoCallback::getAllTiles (boost::unordered_set<int3, ShashInt3> &tiles, int Player/*=-1*/, int level, int surface ) const { if(Player >= GameConstants::PLAYER_LIMIT) { tlog1 << "Illegal call to getAllTiles !\n"; return; } bool water = surface == 0 || surface == 2, land = surface == 0 || surface == 1; std::vector<int> floors; if(level == -1) { for(int b = 0; b < (gs->map->twoLevel ? 2 : 1); ++b) { floors.push_back(b); } } else floors.push_back(level); for (std::vector<int>::const_iterator i = floors.begin(); i!= floors.end(); i++) { register int zd = *i; for (int xd = 0; xd < gs->map->width; xd++) { for (int yd = 0; yd < gs->map->height; yd++) { if ((getTile (int3 (xd,yd,zd))->terType == 8 && water) || (getTile (int3 (xd,yd,zd))->terType != 8 && land)) tiles.insert(int3(xd,yd,zd)); } } } }
void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, int player/*=-1*/, int mode/*=0*/ ) const { if(player >= GameConstants::PLAYER_LIMIT) { tlog1 << "Illegal call to getTilesInRange!\n"; return; } if (radious == -1) //reveal entire map getAllTiles (tiles, player, -1, 0); else { const TeamState * team = gs->getPlayerTeam(player); for (int xd = std::max<int>(pos.x - radious , 0); xd <= std::min<int>(pos.x + radious, gs->map->width - 1); xd++) { for (int yd = std::max<int>(pos.y - radious, 0); yd <= std::min<int>(pos.y + radious, gs->map->height - 1); yd++) { double distance = pos.dist2d(int3(xd,yd,pos.z)) - 0.5; if(distance <= radious) { if(player < 0 || (mode == 1 && team->fogOfWarMap[xd][yd][pos.z]==0) || (mode == -1 && team->fogOfWarMap[xd][yd][pos.z]==1) ) tiles.insert(int3(xd,yd,pos.z)); } } } } }
bool BOTechTreeNode::Initialize(float2 p_pos, int2 p_size, std::string p_tooltip) { m_isActive = false; m_isAdjacentActive = false; m_hoveringOver = false; m_layer = 0; m_price = 0; m_effect = 0; m_icon = BOTextureManager::GetTexture(TEXTTINACTIVE); m_active = BOTextureManager::GetTexture(TEXTTCHOSEN); m_inactive = BOTextureManager::GetTexture(TEXTTINACTIVE); m_adjacentActive = BOTextureManager::GetTexture(TEXTTADJACENTACTIVE); m_highlighted = BOTextureManager::GetTexture(TEXTTHIGHLIGHTED); // Tooltip m_tooltipHeading.Initialize(float2(0, 0), "Heading", int3(255, 255, 255), 40, 0); m_tooltipText.Initialize(float2(0,0), " ", int3(255, 255, 255), 30, 0); int2 windowBounds = BOGraphicInterface::GetWindowSize(); m_tooltipFrame.Initialize(float2(0,0), int2(310,210), BOTextureManager::GetTexture(TEXTTTOLTIPFRAME)); int2 framesSize = m_tooltipFrame.GetSize(); m_tooltipFrame.SetPosition(float2(windowBounds.x - 50 - framesSize.x*0.5f, framesSize.y*0.5f +50)); //priceText m_priceText.Initialize(float2(0, 0), " ", int3(255, 255, 255), 25, 0); return BOObject::Initialize(p_pos, p_size, m_inactive); }
void NaviHeightmap::update(const vector<IBox> &walkable, const vector<IBox> &blockers) { m_level_count = 0; m_data.clear(); PodArray<IBox> bboxes(walkable.size()); for(int n = 0; n < bboxes.size(); n++) { IBox bbox = walkable[n]; bboxes[n] = { vmax(bbox.min(), int3(0, 0, 0)), vmin(bbox.max(), int3(m_size.x, 255, m_size.y))}; } std::sort(bboxes.data(), bboxes.end(), [](const IBox &a, const IBox &b) { return a.y() == b.y()? a.x() == b.x()? a.z() < b.z() : a.x() < b.x() : a.y() < b.y(); } ); for(int n = 0; n < bboxes.size(); n++) { const IBox &bbox = bboxes[n]; int min_y = bbox.y(), max_y = bbox.ey(); for(int z = 0; z < bbox.depth(); z++) for(int x = 0; x < bbox.width(); x++) { int level = 0; int px = x + bbox.x(); int pz = z + bbox.z(); while(level < m_level_count) { int value = m_data[index(px, pz, level)]; if(value == invalid_value || value >= min_y - 4) break; level++; } if(level == m_level_count) { if(level == max_levels) continue; addLevel(); } m_data[index(px, pz, level)] = max_y; } } for(int n = 0; n < (int)blockers.size(); n++) { IBox blocker( vmax(blockers[n].min(), int3(0, 0, 0)), vmin(blockers[n].max(), int3(m_size.x, 255, m_size.y))); u8 min_y = max(0, blocker.y() - 4), max_y = blocker.ey(); for(int z = 0; z < blocker.depth(); z++) for(int x = 0; x < blocker.width(); x++) { int level = 0; int px = x + blocker.x(); int pz = z + blocker.z(); while(level < m_level_count) { u8 &value = m_data[index(px, pz, level++)]; if(value >= min_y && value <= max_y) value = invalid_value; } } } }
int3 __CGsampler1DARRAY_state::size(int1 lod) { lod += trueBaseLevel; if (lod <= effectiveMaxLevel) { return int3(image[lod].borderlessSize.xy, 0); } else { return int3(0); } }
int3 CMap::guardingCreaturePosition (int3 pos) const { const int3 originalPos = pos; // Give monster at position priority. if (!isInTheMap(pos)) return int3(-1, -1, -1); const TerrainTile &posTile = getTile(pos); if (posTile.visitable) { for (CGObjectInstance* obj : posTile.visitableObjects) { if(obj->blockVisit) { if (obj->ID == Obj::MONSTER) // Monster return pos; else return int3(-1, -1, -1); //blockvis objects are not guarded by neighbouring creatures } } } // See if there are any monsters adjacent. bool water = posTile.isWater(); pos -= int3(1, 1, 0); // Start with top left. for (int dx = 0; dx < 3; dx++) { for (int dy = 0; dy < 3; dy++) { if (isInTheMap(pos)) { const auto & tile = getTile(pos); if (tile.visitable && (tile.isWater() == water)) { for (CGObjectInstance* obj : tile.visitableObjects) { if (obj->ID == Obj::MONSTER && checkForVisitableDir(pos, &posTile, originalPos)) // Monster being able to attack investigated tile { return pos; } } } } pos.y++; } pos.y -= 3; pos.x++; } return int3(-1, -1, -1); }
void CButton::showAll(SDL_Surface * to) { CIntObject::showAll(to); #ifdef VCMI_SDL1 if (borderColor && borderColor->unused == 0) CSDL_Ext::drawBorder(to, pos.x-1, pos.y-1, pos.w+2, pos.h+2, int3(borderColor->r, borderColor->g, borderColor->b)); #else if (borderColor && borderColor->a == 0) CSDL_Ext::drawBorder(to, pos.x-1, pos.y-1, pos.w+2, pos.h+2, int3(borderColor->r, borderColor->g, borderColor->b)); #endif // 0 }
bool CMap::isCoastalTile(const int3 & pos) const { //todo: refactoring: extract neighbor tile iterator and use it in GameState static const int3 dirs[] = { int3(0,1,0),int3(0,-1,0),int3(-1,0,0),int3(+1,0,0), int3(1,1,0),int3(-1,1,0),int3(1,-1,0),int3(-1,-1,0) }; if(!isInTheMap(pos)) { logGlobal->errorStream() << "Coastal check outside of map :"<<pos; return false; } if(isWaterTile(pos)) return false; for (auto & dir : dirs) { const int3 hlp = pos + dir; if(!isInTheMap(hlp)) continue; const TerrainTile &hlpt = getTile(hlp); if(hlpt.isWater()) return true; } return false; }
void CAdventureMapButton::showAll(SDL_Surface * to) { CIntObject::showAll(to); if (borderEnabled && borderColor.unused == 0) CSDL_Ext::drawBorder(to, pos.x-1, pos.y-1, pos.w+2, pos.h+2, int3(borderColor.r, borderColor.g, borderColor.b)); }
void fn004010AA(Eq_24 * fs) { fs->dw0000 = fp - 0x00000004; globals->dw401000 = globals->dw401000 & 0xFFFFFFFD; int3(); return; }
void CMinimapInstance::drawScaled(int level) { int3 mapSizes = LOCPLINT->cb->getMapSize(); //size of one map tile on our minimap double stepX = double(pos.w) / mapSizes.x; double stepY = double(pos.h) / mapSizes.y; double currY = 0; for (int y=0; y<mapSizes.y; y++, currY += stepY) { double currX = 0; for (int x=0; x<mapSizes.x; x++, currX += stepX) { const SDL_Color &color = getTileColor(int3(x,y,level)); //coordinates of rectangle on minimap representing this tile // begin - first to blit, end - first NOT to blit int xBegin = currX; int yBegin = currY; int xEnd = currX + stepX; int yEnd = currY + stepY; for (int y=yBegin; y<yEnd; y++) { Uint8 *ptr = (Uint8*)minimap->pixels + y * minimap->pitch + xBegin * minimap->format->BytesPerPixel; for (int x=xBegin; x<xEnd; x++) ColorPutter<4, 1>::PutColor(ptr, color); } } } }
word64 fn00000001400012BC(word32 edx, word64 rdi, word64 r13, selector gs, word64 qwArg08, word64 qwArg10) { if (fn0000000140001600(0x01, edx, r13) == 0x00) { word64 rcx_362; byte bl_363; fn0000000140001974(0x07, qwLoc04, qwArg00, qwArg04, qwArg0C, out rcx_362, out bl_363); int3(); } Mem23[fp - 0x14 + 0x00:byte] = 0x00; word32 eax_25 = fn00000001400015C4(gs); word64 rax_28 = DPB(rax, eax_25, 0); byte bl_29 = (byte) eax_25; word32 ecx_33 = Mem23[0x00000001400035B0 + 0x00:word32]; if (ecx_33 == 0x01) { ecx_33 = 0x07; word64 rcx_355; rax_28 = DPB(rax, fn0000000140001974(0x07, qwLoc04, qwArg00, qwArg04, qwArg0C, out rcx_355, out bl_29), 0); } word64 rax_233; if (ecx_33 == 0x00) { Mem331[0x00000001400035B0 + 0x00:word32] = 0x01; word64 rax_334 = DPB(rax_28, _initterm_e(0x00000001400021B8, 0x00000001400021D0), 0); if (_initterm_e(0x00000001400021B8, 0x00000001400021D0) != 0x00) { rax_233 = DPB(rax_28, 0xFF, 0); return rax_233; } _initterm(0x00000001400021A0, 0x00000001400021B0); Mem344[0x00000001400035B0 + 0x00:word32] = 0x02; }
static void TestCatalog(skiatest::Reporter* reporter) { SkPDFCatalog catalog((SkPDFDocument::Flags)0); SkAutoTUnref<SkPDFInt> int1(new SkPDFInt(1)); SkAutoTUnref<SkPDFInt> int2(new SkPDFInt(2)); SkAutoTUnref<SkPDFInt> int3(new SkPDFInt(3)); int1.get()->ref(); SkAutoTUnref<SkPDFInt> int1Again(int1.get()); catalog.addObject(int1.get(), false); catalog.addObject(int2.get(), false); catalog.addObject(int3.get(), false); REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int1.get()) == 3); REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int2.get()) == 3); REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int3.get()) == 3); SkDynamicMemoryWStream buffer; catalog.emitObjectNumber(&buffer, int1.get()); catalog.emitObjectNumber(&buffer, int2.get()); catalog.emitObjectNumber(&buffer, int3.get()); catalog.emitObjectNumber(&buffer, int1Again.get()); char expectedResult[] = "1 02 03 01 0"; REPORTER_ASSERT(reporter, stream_equals(buffer, 0, expectedResult, strlen(expectedResult))); }
void foreach_tile_pos(std::function<void(const int3& pos)> foo) { for(int i = 0; i < cb->getMapSize().x; i++) for(int j = 0; j < cb->getMapSize().y; j++) for(int k = 0; k < cb->getMapSize().z; k++) foo(int3(i,j,k)); }
void CPrivilagedInfoCallback::getTilesInRange( std::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, boost::optional<PlayerColor> player/*=uninit*/, int mode/*=0*/, bool patrolDistance/*=false*/) const { if(!!player && *player >= PlayerColor::PLAYER_LIMIT) { logGlobal->errorStream() << "Illegal call to getTilesInRange!"; return; } if (radious == -1) //reveal entire map getAllTiles (tiles, player, -1, 0); else { const TeamState * team = !player ? nullptr : gs->getPlayerTeam(*player); for (int xd = std::max<int>(pos.x - radious , 0); xd <= std::min<int>(pos.x + radious, gs->map->width - 1); xd++) { for (int yd = std::max<int>(pos.y - radious, 0); yd <= std::min<int>(pos.y + radious, gs->map->height - 1); yd++) { int3 tilePos(xd,yd,pos.z); double distance; if(patrolDistance) distance = pos.mandist2d(tilePos); else distance = pos.dist2d(tilePos) - 0.5; if(distance <= radious) { if(!player || (mode == 1 && team->fogOfWarMap[xd][yd][pos.z]==0) || (mode == -1 && team->fogOfWarMap[xd][yd][pos.z]==1) ) tiles.insert(int3(xd,yd,pos.z)); } } } } }
void run() { // Code from // http://llvm.org/svn/llvm-project/libcxx/trunk/test/utilities/intseq/intseq.general/integer_seq.pass.cpp // Make a couple of sequences using int3 = std::make_integer_sequence<int, 3>; // generates int: 0,1,2 using size7 = std::make_integer_sequence<size_t, 7>; // generates size_t: 0,1,2,3,4,5,6 using size4 = std::make_index_sequence<4>; // generates size_t: 0,1,2,3 using size2 = std::index_sequence_for<int, size_t>; // generates size_t: 0,1 using intmix = std::integer_sequence<int, 9, 8, 7, 2>; // generates int: 9,8,7,2 using sizemix = std::index_sequence<1, 1, 2, 3, 5>; // generates size_t: 1,1,2,3,5 // Make sure they're what we expect static_assert ( std::is_same <int3::value_type, int>::value, "int3 type wrong" ); static_assert ( int3::static_size == 3, "int3 size wrong" ); static_assert ( std::is_same <size7::value_type, size_t>::value, "size7 type wrong" ); static_assert ( size7::static_size == 7, "size7 size wrong" ); static_assert ( std::is_same <size4::value_type, size_t>::value, "size4 type wrong" ); static_assert ( size4::static_size == 4, "size4 size wrong" ); static_assert ( std::is_same <size2::value_type, size_t>::value, "size2 type wrong" ); static_assert ( size2::static_size == 2, "size2 size wrong" ); static_assert ( std::is_same <intmix::value_type, int>::value, "intmix type wrong" ); static_assert ( intmix::static_size == 4, "intmix size wrong" ); static_assert ( std::is_same <sizemix::value_type, size_t>::value, "sizemix type wrong" ); static_assert ( sizemix::static_size == 5, "sizemix size wrong" ); auto tup = std::make_tuple ( 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ); // Use them auto t3 = extract ( tup, int3() ); static_assert ( std::tuple_size<decltype(t3)>::value == int3::static_size, "t3 size wrong"); expect ( t3 == std::make_tuple ( 10, 11, 12 )); auto t7 = extract ( tup, size7 ()); static_assert ( std::tuple_size<decltype(t7)>::value == size7::static_size, "t7 size wrong"); expect ( t7 == std::make_tuple ( 10, 11, 12, 13, 14, 15, 16 )); auto t4 = extract ( tup, size4 ()); static_assert ( std::tuple_size<decltype(t4)>::value == size4::static_size, "t4 size wrong"); expect ( t4 == std::make_tuple ( 10, 11, 12, 13 )); auto t2 = extract ( tup, size2 ()); static_assert ( std::tuple_size<decltype(t2)>::value == size2::static_size, "t2 size wrong"); expect ( t2 == std::make_tuple ( 10, 11 )); auto tintmix = extract ( tup, intmix ()); static_assert ( std::tuple_size<decltype(tintmix)>::value == intmix::static_size, "tintmix size wrong"); expect ( tintmix == std::make_tuple ( 19, 18, 17, 12 )); auto tsizemix = extract ( tup, sizemix ()); static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::static_size, "tsizemix size wrong"); expect ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 )); pass(); }
bool BOState::Initialize(float2 p_position, int2 p_size, float2 p_menuPosition, std::string p_name, SDL_Texture* p_sprite) { m_name = p_name; m_position = p_position; m_screenSize = p_size; m_buttonList.empty(); BOPublisher::AddSubscriber(this); // Load background. if (!m_background.Initialize(p_position, p_size, p_sprite)) { std::cout << "Failed to load background for " << m_name << "!" << std::endl; return false; } // Load the menu bars first edge. BOObject firstEdge; if (!firstEdge.Initialize(float2(p_menuPosition.x + 2.5f, p_menuPosition.y + 35), int2(5, 70), BOTextureManager::GetTexture(TEXMENUEDGE))) { std::cout << "Failed to load first edge of menu" << m_name << "!" << std::endl; return false; } m_menuBar.push_back(firstEdge); // Load the menu bar. BOObject menuBar; if (!menuBar.Initialize(float2(p_menuPosition.x + 125, p_menuPosition.y + 35), int2(240, 70), BOTextureManager::GetTexture(TEXMENUBAR))) { std::cout << "Failed to load last edge of menu" << m_name << "!" << std::endl; return false; } m_menuBar.push_back(menuBar); // Load the last edge of the menu bars. BOObject lastEdge; if (!lastEdge.Initialize(float2(p_menuPosition.x + 247.5f, p_menuPosition.y + 35), int2(5, 70), BOTextureManager::GetTexture(TEXMENUEDGE))) { std::cout << "Failed to load last edge of menu" << m_name << "!" << std::endl; return false; } m_menuBar.push_back(lastEdge); // Load menu text if (!m_menuText.Initialize(float2(0,0), m_name, int3(255, 255, 255), 72, 0)) { std::cout << "Failed to create menu text in " << m_name << "!" << std::endl; return false; } // Calculate menu text position int2 tempSize = m_menuText.GetSize(); float2 tempPos = float2(25.0f + p_menuPosition.x + tempSize.x / 2, 13 + p_menuPosition.y + tempSize.y / 2); m_menuText.SetPosition(tempPos); return true; }
int main() { #if _LIBCPP_STD_VER > 11 // Make a couple of sequences using int3 = std::make_integer_sequence<int, 3>; // generates int: 0,1,2 using size7 = std::make_integer_sequence<size_t, 7>; // generates size_t: 0,1,2,3,4,5,6 using size4 = std::make_index_sequence<4>; // generates size_t: 0,1,2,3 using size2 = std::index_sequence_for<int, size_t>; // generates size_t: 0,1 using intmix = std::integer_sequence<int, 9, 8, 7, 2>; // generates int: 9,8,7,2 using sizemix = std::index_sequence<1, 1, 2, 3, 5>; // generates size_t: 1,1,2,3,5 // Make sure they're what we expect static_assert ( std::is_same<int3::value_type, int>::value, "int3 type wrong" ); static_assert ( int3::size () == 3, "int3 size wrong" ); static_assert ( std::is_same<size7::value_type, size_t>::value, "size7 type wrong" ); static_assert ( size7::size () == 7, "size7 size wrong" ); static_assert ( std::is_same<size4::value_type, size_t>::value, "size4 type wrong" ); static_assert ( size4::size () == 4, "size4 size wrong" ); static_assert ( std::is_same<size2::value_type, size_t>::value, "size2 type wrong" ); static_assert ( size2::size () == 2, "size2 size wrong" ); static_assert ( std::is_same<intmix::value_type, int>::value, "intmix type wrong" ); static_assert ( intmix::size () == 4, "intmix size wrong" ); static_assert ( std::is_same<sizemix::value_type, size_t>::value, "sizemix type wrong" ); static_assert ( sizemix::size () == 5, "sizemix size wrong" ); auto tup = std::make_tuple ( 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ); // Use them auto t3 = extract ( tup, int3() ); static_assert ( std::tuple_size<decltype(t3)>::value == int3::size (), "t3 size wrong"); assert ( t3 == std::make_tuple ( 10, 11, 12 )); auto t7 = extract ( tup, size7 ()); static_assert ( std::tuple_size<decltype(t7)>::value == size7::size (), "t7 size wrong"); assert ( t7 == std::make_tuple ( 10, 11, 12, 13, 14, 15, 16 )); auto t4 = extract ( tup, size4 ()); static_assert ( std::tuple_size<decltype(t4)>::value == size4::size (), "t4 size wrong"); assert ( t4 == std::make_tuple ( 10, 11, 12, 13 )); auto t2 = extract ( tup, size2 ()); static_assert ( std::tuple_size<decltype(t2)>::value == size2::size (), "t2 size wrong"); assert ( t2 == std::make_tuple ( 10, 11 )); auto tintmix = extract ( tup, intmix ()); static_assert ( std::tuple_size<decltype(tintmix)>::value == intmix::size (), "tintmix size wrong"); assert ( tintmix == std::make_tuple ( 19, 18, 17, 12 )); auto tsizemix = extract ( tup, sizemix ()); static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::size (), "tsizemix size wrong"); assert ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 )); #endif // _LIBCPP_STD_VER > 11 }
bool BOTechTreeManager::Initialize(int2 p_windowDimension) { m_windowSize = p_windowDimension; m_grid = BOTextureManager::GetTexture(TEXTTHIGHLIGHTED); int2 m_Size = int2(100, 100); float2 midScreen = float2(m_windowSize.x * 0.5f, m_windowSize.y * 0.5f + 150); // To save computation int diameter = 7; // Original is 7 float xOffset = m_Size.x * 0.85f; float yOffset = m_Size.y*0.5f; for (unsigned int y = diameter - 3, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x - x * xOffset, midScreen.y - (y + 4) * yOffset), m_Size, " "); } for (unsigned int y = diameter - 2, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x + xOffset - x * xOffset, midScreen.y + yOffset - (y + 3) * yOffset), m_Size, " "); } for (unsigned int y = diameter - 1, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x + xOffset * 2 - x * xOffset, midScreen.y + yOffset * 3 - (y + 3) * yOffset), m_Size, " "); } for (unsigned int y = diameter, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x + xOffset * 3 - x * xOffset, midScreen.y + yOffset * 5 - (y + 3) * yOffset), m_Size, " "); } for (unsigned int y = diameter - 1, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x + xOffset * 3 - x * xOffset, midScreen.y + yOffset * 6 - (y + 3) * yOffset), m_Size, " "); } for (unsigned int y = diameter - 2, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x + xOffset * 3 - x * xOffset, midScreen.y + yOffset * 7 - (y + 3) * yOffset), m_Size, " "); } for (unsigned int y = diameter - 3, x = 0; y != 0; y--, x++) { BOTechTreeNode* newNode = CreateNode(float2(midScreen.x + xOffset * 3 - x * xOffset, midScreen.y + yOffset * 8 - (y + 3) * yOffset), m_Size, " "); } MapNodes(); SetLPE(); m_resetButton.Initialize(float2(m_windowSize.x-300.0f, m_windowSize.y-125.0f), int2(250, 75), BOTextureManager::GetTexture(TEXMENUBUTTON), "RESET", TECHTREERESET, ""); // Tech Points m_techPointsText.Initialize(float2(0,0), "ERROR", int3(255, 255, 255), 50, 0); float2 resetPos = m_resetButton.GetPosition(); int2 resetSize = m_resetButton.GetSize(); int2 textSize = m_techPointsText.GetSize(); m_techPointsText.SetPosition(float2(resetPos.x - textSize.x*0.5f - 50.0f, resetPos.y + resetSize.y*0.5f)); m_maxTechPoints = 0; m_techPointsLeft = 0; BOPublisher::AddSubscriber(this); return true; }
void CSelectableComponent::showAll(SDL_Surface * to) { CComponent::showAll(to); if(selected) { CSDL_Ext::drawBorder(to, Rect::around(image->pos), int3(239,215,123)); } }
void CGHeroInstance::getOutOffsets(std::vector<int3> &offsets) const { offsets = { int3(0,1,0), int3(0,-1,0), int3(-1,0,0), int3(+1,0,0), int3(1,1,0), int3(-1,1,0), int3(1,-1,0), int3(-1,-1,0) }; }
const IBox View::computeCursor(const int2 &start, const int2 &end, const int3 &bbox, int height, int offset) const { float2 height_off = worldToScreen(int3(0, height, 0)); int3 gbox(cellSize(), 1, cellSize()); int3 start_pos = asXZ((int2)( screenToWorld(float2(start + pos()) - height_off) + float2(0.5f, 0.5f))); int3 end_pos = asXZ((int2)( screenToWorld(float2(end + pos()) - height_off) + float2(0.5f, 0.5f))); start_pos.y = end_pos.y = height + offset; { int apos1 = start_pos.x % gbox.x; int apos2 = apos1 - gbox.x + bbox.x; start_pos.x -= apos1 < gbox.x - apos1 || bbox.x >= gbox.x? apos1 : apos2; } { int apos1 = start_pos.z % gbox.z; int apos2 = apos1 - gbox.z + bbox.z; start_pos.z -= apos1 < gbox.z - apos1 || bbox.z >= gbox.z? apos1 : apos2; } if(end == start) end_pos = start_pos; int3 dir(end_pos.x >= start_pos.x? 1 : -1, 1, end_pos.z >= start_pos.z? 1 : -1); int3 size(abs(end_pos.x - start_pos.x), 1, abs(end_pos.z - start_pos.z)); size += bbox - int3(1, 1, 1); size.x -= size.x % bbox.x; size.z -= size.z % bbox.z; size = max(bbox, size); if(dir.x < 0) start_pos.x += bbox.x; if(dir.z < 0) start_pos.z += bbox.z; end_pos = start_pos + dir * size; if(start_pos.x > end_pos.x) swap(start_pos.x, end_pos.x); if(start_pos.z > end_pos.z) swap(start_pos.z, end_pos.z); int2 dims = m_tile_map.dimensions(); start_pos = asXZY(clamp(start_pos.xz(), int2(0, 0), dims), start_pos.y); end_pos = asXZY(clamp( end_pos.xz(), int2(0, 0), dims), end_pos.y); return IBox(start_pos, end_pos); }
void BOTechTreeNode::SetToolTip(std::string p_toolTip, std::string p_heading) { int2 windowBounds = BOGraphicInterface::GetWindowSize(); float2 tooltipPos = m_tooltipFrame.GetPosition(); m_tooltipHeading.SetText(p_heading, int3(255, 255, 255), 0); int2 headingSize = m_tooltipHeading.GetSize(); m_tooltipHeading.SetPosition(float2(tooltipPos.x, headingSize.y*0.5f + 60.0f)); m_tooltipText.SetText(p_toolTip, int3(255, 255, 255), 290); int2 textSize = m_tooltipText.GetSize(); m_tooltipText.SetPosition(float2(windowBounds.x - textSize.x*0.5f -60.0f, textSize.y*0.5f + 60.0f + headingSize.y)); m_priceText.SetText(std::to_string(m_price), int3(255, 255, 255), 290); m_priceText.SetPosition(float2(m_position.x + 25,m_position.y + 25)); }
void foreach_tile_pos(CCallback * cbp, std::function<void(CCallback * cbp, const int3& pos)> foo) { int3 mapSize = cbp->getMapSize(); for(int i = 0; i < mapSize.x; i++) for(int j = 0; j < mapSize.y; j++) for(int k = 0; k < mapSize.z; k++) foo(cbp, int3(i,j,k)); }
void __CGsampler1DARRAY_state::initImages() { // Just width dimension supports border. const int3 borderSupport = int3(1, 0, 0); for (int level=0; level<maxLevels; level++) { image[level].initImage(texTarget, level, borderSupport); } }