void Dlg_AchievementsReporter::SetupColumns() { // Remove all columns, while (ListView_DeleteColumn(m_hList, 0)) {} // Remove all data. ListView_DeleteAllItems(m_hList); auto limit{ static_cast<int>(col_num) }; for (auto i = 0; i < limit; i++) { auto sStr{ std::string{col_names.at(to_unsigned(i))} }; // you can't do it directly // would be easier with delegates... // Probably should be made in to a class from repetition LV_COLUMN col { LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM | LVCF_FMT, LVCFMT_LEFT | LVCFMT_FIXED_WIDTH, col_sizes.at(to_unsigned(i)), sStr.data(), 255, i }; if (i == limit - 1) //If the last element: fill to the end col.fmt |= LVCFMT_FILL; ListView_InsertColumn(m_hList, i, &col); } }
void FullbrightMaterialComponent::onParams(const CaffUtil::Param ¶ms) { // RGB { const std::array<float, 4> rgba = params["rgba"].asFloat4({m_rgba.r, m_rgba.g, m_rgba.b, m_rgba.a}); enum { R = 0, G, B, A, }; m_rgba.r = rgba.at(R); m_rgba.g = rgba.at(G); m_rgba.b = rgba.at(B); m_rgba.a = rgba.at(A); } // Lookup textureName. { m_textureName = params["diffuse_map"].asStdString(); } // Texture scale { const std::array<float, 2> uvScale = params["diffuse_map_scale"].asFloat2({m_diffuseScale.x, m_diffuseScale.y}); enum { U = 0, V }; m_diffuseScale.u = uvScale.at(U); m_diffuseScale.v = uvScale.at(V); } }
const std::list<sf::Vector2i> King::getValidMoves(const std::array<std::array<std::shared_ptr<Figure>, 8>, 8> &board) { std::list<sf::Vector2i> movements; #pragma region 1 to all directions for(int x = this->m_Position.x -1; x <= this->m_Position.x +1; ++x) { for(int y = this->m_Position.y -1; y <= this->m_Position.y +1; ++y) { if(x >= 0 && x < 8 && y >= 0 && y < 8 && (x != 0 || y != 0) ) { if(board.at(x).at(y) != NULL) // other figure at position { if(board.at(x).at(y)->isPlayerOne() == this->m_PlayerOne) // figure of same color -> not a valid move continue; } // different players or no other figure on the field movements.push_back(sf::Vector2i(x, y) ); } } } #pragma endregion // to do #pragma region Rochade // to do #pragma endregion return movements; }
bool fileinformation::validate_lines_information(std::string& line) { std::smatch matches; bool output = false; std::size_t index; static bool recursivecomment = false; for(index = 0; index < regularexpression.size(); ++index) { regularexpression[index].second = std::regex_search(line, matches, regularexpression[index].first); /* { output = true; if(index != 2){ break; } } */ } recursivecomment = (regularexpression.at(2).second) && !(regularexpression.at(3).second); for(index = 0; index < regularexpression.size(); ++index) { regularexpression[index].second = false; } return output; }
std::array<float, 3> Param::asFloat3(const std::array<float, 3> &defaultData) const { std::array<float, 4> resultArr = asFloat4({{defaultData.at(0), defaultData.at(1), defaultData.at(2), 0.f}}); std::array<float, 3> returnArr {{ resultArr.at(0), resultArr.at(1), resultArr.at(2) }}; return returnArr; }
inline uint32_t GetPayloadLenght(std::array<char, 4>& x) { Int32U conv; conv.c[0] = x.at(0); conv.c[1] = x.at(1); conv.c[2] = x.at(2); conv.c[3] = x.at(3); return conv.dw; }
void PointLightComponent::onParams(const CaffUtil::Param ¶ms) { const std::array<float, 3> color = params["color"].asFloat3({m_color.x, m_color.y, m_color.z}); enum { X = 0, Y, Z }; m_color = CaffMath::Vector3Init(color.at(X), color.at(Y), color.at(Z)); m_intensity = params["intensity"].asFloat(m_intensity); m_radius = params["radius"].asFloat(m_radius); }
uint16_t collatz(uint32_t n) { uint16_t count = 1; while (n != 1) { if (n < 1000000 && dm.at(n-1) != 0) { return count + dm.at(n-1); } ++count; if (n % 2 == 0) { n /= 2; } else { n = 3 * n + 1; } } return count; };
bool Bishop::beatableMove(const sf::Vector2i position, const std::array<std::array<std::shared_ptr<Figure>, 8>, 8> &board) { int rel_x = this->m_Position.x - position.x, rel_y = this->m_Position.y - position.y; if( (rel_x != rel_y) && (rel_x != -1*rel_y) ) return false; int relative_movement_x = -1, relative_movement_y = -1; if(rel_x < 0) relative_movement_x = 1; if(rel_y < 0) relative_movement_y = 1; int new_X = this->m_Position.x, new_Y = this->m_Position.y; for(int i = relative_movement_x; i != -rel_x; i += relative_movement_x) { new_X += relative_movement_x; new_Y += relative_movement_y; if(board.at(new_X).at(new_Y) != NULL) return false; } return true; }
std::string select(){ if (++current_ >= methods_.size()) { current_ = 0; } return methods_.at(current_); }
uint16_t operator()( uint16_t code ) const { if ( code < code_.size() ) return code_.at( code ); return (-1); }
void SingleDigit::drawHorizontalSegment(QPainter &painter, const QPointF& startPoint, bool filled, QBrush &brush) { const std::array<QPointF, 7>baseSegment{ QPointF(0,0), QPointF(3,-3), QPointF(23,-3), QPointF(26,0), QPointF(23,3), QPointF(3,3), QPointF(0,0) }; QPainterPath segmentPath; segmentPath.moveTo(baseSegment.at(0)+startPoint); for(auto & point : baseSegment) segmentPath.lineTo(point*m_scale + startPoint); if(filled) painter.fillPath(segmentPath,brush); else painter.drawPath(segmentPath); }
/// /// Конвертирование текстового ИД константы в ее значение в коде. /// \return значение константы или -1, если ничего не было найдено /// int to_num(IdType type, const std::string &str) { if (type < TEXT_ID_COUNT) { return text_id_list.at(type).to_num(str); } return -1; }
void Boss::handleCollision(std::array<bool, CollisionSide::SOLID_TOTAL> detections_){ if(detections_.at(CollisionSide::SOLID_TOP)){ this->vy = 0.0; } if(detections_.at(CollisionSide::SOLID_BOTTOM)){ this->nextY -= fmod(this->nextY, 64.0) - 16.0; this->vy = 0.0; } if(detections_.at(CollisionSide::SOLID_LEFT)){ this->nextX = this->x; this->vx = 0.0; } if(detections_.at(CollisionSide::SOLID_RIGHT)){ this->nextX = this->x; this->vx = -0.001; } }
/// /// Конвертирование значения константы в ее текстовый ИД. /// \return текстовый ИД константы или пустая строка, если ничего не было найдено /// std::string to_str(IdType type, int num) { if (type < TEXT_ID_COUNT) { return text_id_list.at(type).to_str(num); } return ""; }
void print_ar1(std::array<int, size> ar) { for (int i = 0; i < sizey; i++) { for (int j = 0; j < sizex; j++) { std::cout << ar.at(i * sizey + j) << " "; } std::cout << std::endl; } std::cout << std::endl; }
/// /// Инит текстовых ИД параметров предметов для сохранения в файл. /// void init_obj_vals() { TextIdNode &tmp = text_id_list.at(OBJ_VALS); tmp.add(ObjVal::POTION_SPELL1_NUM, "POTION_SPELL1_NUM"); tmp.add(ObjVal::POTION_SPELL1_LVL, "POTION_SPELL1_LVL"); tmp.add(ObjVal::POTION_SPELL2_NUM, "POTION_SPELL2_NUM"); tmp.add(ObjVal::POTION_SPELL2_LVL, "POTION_SPELL2_LVL"); tmp.add(ObjVal::POTION_SPELL3_NUM, "POTION_SPELL3_NUM"); tmp.add(ObjVal::POTION_SPELL3_LVL, "POTION_SPELL3_LVL"); tmp.add(ObjVal::POTION_PROTO_VNUM, "POTION_PROTO_VNUM"); }
const QByteArray& TorProtocolManager::getName(const ProtocolManager::State state) { static const std::array<QByteArray, 5> names = {{ "OFFLINE", "CONNECTING", "CONNECTED", "ONLINE", "SHUTTINGDOWN" }}; return names.at(static_cast<size_t>(state)); }
const std::vector<unsigned int>& getPoseBodyPartPairsRender(const PoseModel poseModel) { try { return POSE_BODY_PART_PAIRS_RENDER.at((int)poseModel); } catch (const std::exception& e) { error(e.what(), __LINE__, __FUNCTION__, __FILE__); return POSE_BODY_PART_PAIRS_RENDER[(int)poseModel]; } }
const std::vector<float>& getPoseColors(const PoseModel poseModel) { try { return POSE_COLORS.at((int)poseModel); } catch (const std::exception& e) { error(e.what(), __LINE__, __FUNCTION__, __FILE__); return POSE_COLORS[(int)poseModel]; } }
uint16_t extendedChecksum16(const std::array<unsigned char, MAXIMUM_BUFFER>& bytes, int count) { uint16_t accumulator = 0; //Sums bytes 6 to n-1 to an unsigned 2 byte value for (int i = 6; i < count; ++i) { accumulator += static_cast<uint16_t>(bytes.at(i)); } return accumulator; }
void ModelObject::load(std::istream &stream, const std::array<std::array<char,8>,750> &mdldata) { mXRot = VFS::read_le32(stream); mYRot = VFS::read_le32(stream); mZRot = VFS::read_le32(stream); mModelIdx = VFS::read_le16(stream); mActionFlags = VFS::read_le32(stream); mSoundId = stream.get(); mActionOffset = VFS::read_le32(stream); mModelData = mdldata.at(mModelIdx); }
//----------------------------------------------------------------------// // This operator is used for regular stream formatting std::ostream& operator<<(std::ostream& strm, SeverityLevel level) { try { strm << s_strings.at(static_cast<int>(level)); } catch (...) { assert(false); strm << static_cast<int>(level); } return strm; }
void print_ar2(std::array<int, size> ar) { for (int i = 0; i < sizey; i++) { for (int j = 0; j < sizex; j++) { if (ar.at(i * sizey + j) == 1) { std::cout << 'o'; } else { std::cout << 'x'; } } std::cout << std::endl; } std::cout << std::endl; }
inline typename IsingModelRule::state_type IsingModelRule::step(const cell_type& cell) const { const bool center = cell.state; short dE = 0; for(auto iter = cell.neighbors.cbegin(); iter != cell.neighbors.cend(); ++iter) { if(center != (*iter)->state) --dE; else ++dE; } return (dE <= 0) ? (!center) : ((rng_->uniform_real<float>(0.,1.) < probs.at(dE)) != center); }
int main( void ) { dm.fill(0); uint16_t max = 0; uint32_t num = 0; for (uint32_t i = 1; i < 1000000; ++i ){ uint16_t v = collatz(i); dm.at(i-1) = v; if (v > max) { max = v; num = i; } } std::cout << num << std::endl; return 0; };
std::string ExteriorLocation::getMapBlockName(size_t idx, size_t regnum) const { std::stringstream name; name<< gBuildingLabel.at(mBlockIndex[idx]).data(); if(mBlockIndex[idx] == 13 || mBlockIndex[idx] == 14) { if(mBlockCharacter[idx] > 0x07) name<< "GA"; else name<< "AA"; static const char numbers[8][3] = { "A0", "B0", "C0", "D0", "E0", "F0", "G0", "H0" }; name<< numbers[mBlockCharacter[idx]&0x07]; } else { size_t q = mBlockCharacter[idx] >> 4; if(regnum == 23 /* Wayrest special-case */) { if(mBlockIndex[idx] == 40) q = 0; else if(q > 0) --q; } else if(regnum == 20 /* Sentinel special-case */) { if(mBlockIndex[idx] == 40) q = 8; } else { if(mBlockIndex[idx] == 40) q = 0; } const std::array<std::array<char,3>,12> letters{{ {"AA"}, {"BA"}, {"AL"}, {"BL"}, {"AM"}, {"BM"}, {"AS"}, {"BS"}, {"GA"}, {"GL"}, {"GM"}, {"GS"} }}; name<< letters.at(q).data(); name<< std::setfill('0')<<std::setw(2)<<(int)mBlockNumber[idx]; } name<< ".RMB"; return name.str(); }
//----------------------------------------------------------------------// // The operator is used when putting the severity level to log boost::log::formatting_ostream& operator<<(boost::log::formatting_ostream& strm, boost::log::to_log_manip<SeverityLevel, SeverityTag > const& manip) { SeverityLevel level = manip.get(); try { strm << s_strings.at(static_cast<int>(level)); } catch (...) { assert(false); strm << static_cast<int>(level); } return strm; }
void DirectionalLightComponent::onParams(const CaffUtil::Param ¶ms) { enum { X = 0, Y, Z }; const std::array<float, 3> color = params["color"].asFloat3({m_color.x, m_color.y, m_color.z}); m_color = CaffMath::Vector3Init(color.at(X), color.at(Y), color.at(Z)); const std::array<float, 3> ambient = params["ambient"].asFloat3({m_ambient.x, m_ambient.y, m_ambient.z}); m_ambient = CaffMath::Vector3Init(ambient.at(X), ambient.at(Y), ambient.at(Z)); m_intensity = params["intensity"].asFloat(m_intensity); }
unsigned char normalChecksum8(const std::array<unsigned char, MAXIMUM_BUFFER>& bytes, int count) { uint16_t accumulator = 0; //Sums bytes 1 to n-1 unsigned to a 2 byte value. Sums quotient and //remainder of 256 division. Again, sums quotient and remainder of //256 division. for (int i = 1; i < count; ++i) { accumulator += static_cast<uint16_t>(bytes.at(i)); } uint16_t quotient = accumulator / 256; accumulator = (accumulator - 256 * quotient) + quotient; quotient = accumulator / 256; return static_cast<unsigned char>((accumulator - 256 * quotient) + quotient); }