C++ 三消游戏基本实现
最近在研究三消算法，我想试试在完全不借助网络资源的情况下搞定这个东西，所以有些地方可能不是最优的。
代码留此备忘。
1. 3x_desk_event.h
1 #pragma once 2 3 #ifndef __3X_DESK_EVENT_H_ 4 #define __3X_DESK_EVENT_H_ 5 6 #include "3x_desk_inc.h" 7 #include <vector> 8 #include <map> 9 10 /////////////////////// Event Action Datas /////////////////////// 11 12 #define StateEventCallBackT std::function<void(EAction, const __Event&)> 13 14 struct Action {}; 15 struct Bonus : public Action 16 { 17 EBonusType _bonus = EBonusType::BONUS_None; 18 uint32_t _count = 0; //The max-count of line. {[3, 5]} & {0} 19 std::vector<Coord> _cleared; 20 }; 21 22 struct Exchange : public Action 23 { 24 Coord _coordA; 25 Coord _coordB; 26 }; 27 28 struct Replenish : public Action 29 { 30 std::vector<Coord> _news; 31 std::vector<Coord> _changed; 32 }; 33 34 struct Refresh : public Action 35 { 36 std::vector<Coord> _src; 37 std::vector<Coord> _become; 38 }; 39 40 struct Select : public Action 41 { 42 Coord _coord; 43 int _ex = 0; 44 }; 45 46 struct NoneAction : public Action 47 { 48 public: 49 union __Act 50 { 51 public: 52 Exchange _exchange; 53 Select _select; 54 __Act() 55 { 56 new(&_exchange) Exchange; 57 new(&_select) Select; 58 } 59 ~__Act(){} 60 }; 61 62 ~NoneAction() 63 { 64 switch (_type) 65 { 66 case EAction::ACTION_EXCHANGE: 67 _info._exchange.~Exchange(); 68 break; 69 70 case EAction::ACTION_BONUS_BOMB: 71 _info._select.~Select(); 72 break; 73 74 default: 75 break; 76 } 77 } 78 79 void Init(EAction t, Action* pAct) 80 { 81 if(t == EAction::ACTION_None) 82 return; 83 84 _type = t; 85 86 if(pAct == nullptr) 87 return; 88 89 switch (t) 90 { 91 case EAction::ACTION_EXCHANGE: 92 _info._exchange = *((Exchange*)pAct); 93 break; 94 95 case EAction::ACTION_BONUS_BOMB: 96 _info._select = *((Select*)pAct); 97 break; 98 99 default: 100 break; 101 } 102 } 103 104 inline EAction GetType() const noexcept { return _type; } 105 inline __Act GetInfo() const noexcept { return _info; } 106 107 private: 108 __Act _info; 109 EAction _type = EAction::ACTION_None; 110 }; 111 112 /////////////////////// Event types /////////////////////// 113 template<EAction E> struct __action_type{}; 114 template<> struct __action_type<EAction::ACTION_EXCHANGE> 115 { 116 using type = Exchange; 117 }; 118 template<> struct __action_type<EAction::ACTION_BONUS> 119 { 120 using type = Bonus; 121 }; 122 template<> struct __action_type<EAction::ACTION_REPLENISH> 123 { 124 using type = Replenish; 125 }; 126 template<> struct __action_type<EAction::ACTION_REFRESH> 127 { 128 using type = Refresh; 129 }; 130 template<> struct __action_type<EAction::ACTION_BONUS_BOMB> 131 { 132 using type = Bonus; 133 }; 134 template<> struct __action_type<EAction::ACTION_None> 135 { 136 using type = NoneAction; 137 }; 138 template<> struct __action_type<EAction::ACTION_FINAL> 139 { 140 using type = bool; 141 }; 142 143 template<> struct __action_type<EAction::ACTION_BONUS_BOMB_INPUT> 144 { 145 using type = Select; 146 }; 147 148 template<> struct __action_type<EAction::ACTION_EXCHANGE_INPUT> 149 { 150 using type = Exchange; 151 }; 152 153 /////////////////////// Events /////////////////////// 154 struct __Event {}; 155 template<EAction t> struct Event 156 : public __Event 157 { 158 public: 159 enum { _type = t }; 160 Event(){} 161 ~Event(){}; 162 163 public: 164 inline constexpr const EAction GetType() const { return t; } 165 typename __action_type<t>::type& Info() noexcept 166 { 167 return _info; 168 } 169 170 const typename __action_type<t>::type& GetInfo() const noexcept 171 { 172 return _info; 173 } 174 175 private: 176 typename __action_type<t>::type _info; 177 }; 178 179 180 181 #endif
2. 3x_desk_inc.h
1 #pragma once 2 3 #ifndef __3X_DESK_INC_H_ 4 #define __3X_DESK_INC_H_ 5 6 #include <stdint.h> 7 #include <array> 8 9 enum EDeck : uint8_t 10 { 11 DECK_None , 12 DECK_BLOCK , 13 DECK_WALL , 14 DECK_FREEZE , 15 }; 16 17 enum EElem : uint8_t 18 { 19 ELEM_None, 20 ELEM_A, 21 ELEM_B, 22 ELEM_C, 23 ELEM_D, 24 ELEM_E, 25 ELEM_F, 26 ELEM_G, 27 ELEM_H, 28 ELEM_I, 29 ELEM_J, 30 31 __ELEM_MAX_ , 32 __ELEM_COUNT_ = __ELEM_MAX_ - 1 33 }; 34 35 enum EAction 36 { 37 ACTION_None, //开始 38 ACTION_EXCHANGE, //交换 39 ACTION_BONUS, //消除 40 ACTION_REPLENISH, //充满 41 ACTION_REFRESH, //刷新/重排 42 ACTION_BONUS_BOMB, //特殊消除 43 ACTION_FINAL, //结束 44 45 //作为输入指令, 不进行类型偏特化，仅作为输入时的状态 46 ACTION_EXCHANGE_INPUT, 47 ACTION_BONUS_BOMB_INPUT, 48 }; 49 50 enum EBonusType : uint32_t 51 { 52 __BONUS_BOMB_ = 0xB000, 53 BONUS_None = 0, //nothing 54 BONUS_ACROSS = (1 << 0), //--- 55 BONUS_VERTICAL = (1 << 1), //||| 56 BONUS_CROSS = BONUS_ACROSS|BONUS_VERTICAL, // +++ / LLL 57 BONUS_BOMB_ACROSS = (__BONUS_BOMB_ | BONUS_ACROSS), 58 BONUS_BOMB_VERTICAL = (__BONUS_BOMB_ | BONUS_VERTICAL), 59 BONUS_BOMB_CROSS = (__BONUS_BOMB_ | BONUS_CROSS), 60 BONUS_BOMB_BY_SELECT = (__BONUS_BOMB_ | 0xFE), 61 BONUS_BOMB_CLEAR = (__BONUS_BOMB_ | 0xFF), 62 63 }; 64 65 using Axis = int; //signed intager must! 66 enum AxisType { AxisX, AxisY }; 67 68 struct Coord 69 { 70 Coord(Axis x, Axis y) 71 : _x(x), _y(y) 72 {} 73 74 Coord(Axis x, Axis y, EElem e) 75 : _x(x), _y(y), _e(e) 76 {} 77 78 Coord() : Coord(0, 0) 79 {} 80 81 Coord& operator()(Axis x, Axis y) 82 { 83 _x = x, _y = y; 84 return *this; 85 } 86 87 bool operator< (const Coord& r) 88 { 89 return _x < r._x ? true : _y < r._y; 90 } 91 92 bool operator==(const Coord& r) 93 { 94 return _x == r._x && _y == r._y; 95 } 96 97 Axis _x = 0, _y = 0; 98 99 //@notice: This value is uarely used. 100 EElem _e = EElem::ELEM_None; 101 }; 102 103 104 #endif
3. 3x_desk_state.h
1 /** 2 * @file 3x_desk_state.h 3 * @author EvenOyan 4 * @brief 三消游戏的状态机， 5 * 一共分为 开始、交换、消除、下落、刷新、结束 6个状态， 6 * 每个状态都在执行属于自己的事情， 7 * @notice: 此状态机的实现稍为复杂， 8 * 使用了大量的模版特化，静态判断，宏替换, 9 * 在试图更改此代码时，务必注意细节, 10 * 11 * @version 0.3 12 * @date 2021-02 13 * 14 * @copyright Copyright (c) 2021 15 * 16 */ 17 18 #pragma once 19 20 #ifndef __3X_DESK_STATE_H 21 #define __3X_DESK_STATE_H 22 23 #include "3x_desk.h" 24 25 #include "../../stdinc/lc_random.h" 26 #include "../../stdinc/lc_singleton.h" 27 28 #include <functional> 29 #include <unordered_set> 30 31 /////////////////////// Defines /////////////////////// 32 33 #define InputFuncBegin(state)\ 34 template<EAction action> \ 35 void __3x_state<state>::Input(Desk* pDesk, const Event<action>& in, const StateEventCallBackT& cb){\ 36 if(pDesk == nullptr) return; 37 38 #define UpdateFuncBegin(state)\ 39 template<EAction action> \ 40 void __3x_state<state>::Update(Desk* pDesk, const Event<action>& in, const StateEventCallBackT& cb){\ 41 if(pDesk == nullptr) return; 42 43 #define FuncEnd() } 44 45 #define __IUpdate(ev)\ 46 Update<stateB>(pDesk, ev, cb) 47 48 #define __IGoTo(stateB, ev)\ 49 __3x_state<stateB>::Input<(EAction)_state>(pDesk, ev, cb); \ 50 51 #define Start_3x_State(pDesk, stateB, ev, fc)\ 52 __3x_state<EAction::ACTION_None>::Input<stateB>(pDesk, ev, fc); 53 54 //e.g.: state A->B->C => B.Input(A); C = B.Update(); 55 #define __StateClassDefine(state) \ 56 template<> \ 57 class __3x_state<state> \ 58 : public Singleton<__3x_state<state> > \ 59 { \ 60 public: \ 61 __3x_state(token){} \ 62 \ 63 private: \ 64 enum { _state = state }; \ 65 \ 66 public: \ 67 template<EAction action> /*输入状态*/\ 68 static void Input(Desk* pDesk, const Event<action>& in/*输入参数*/, const StateEventCallBackT& cb);\ 69 template<EAction action> /*输入状态*/\ 70 static void Update(Desk* pDesk, const Event<action>& in/*输入参数*/, const StateEventCallBackT& cb);\ 71 \ 72 }; 73 74 //used at 'input' 75 #define __StateAccept(stateA)\ 76 if constexpr(stateA == action) { __3x_state<(EAction)_state>::Update<stateA>(pDesk, in, cb); return; } 77 78 /////////////////////// State Graph /////////////////////// 79 template<EAction E>class __3x_state {}; 80 template<> class __3x_state<EAction::ACTION_None>; 81 template<> class __3x_state<EAction::ACTION_EXCHANGE>; 82 template<> class __3x_state<EAction::ACTION_BONUS_BOMB>; 83 template<> class __3x_state<EAction::ACTION_BONUS>; 84 template<> class __3x_state<EAction::ACTION_REPLENISH>; 85 template<> class __3x_state<EAction::ACTION_REFRESH>; 86 template<> class __3x_state<EAction::ACTION_FINAL>; 87 88 __StateClassDefine(EAction::ACTION_EXCHANGE); 89 __StateClassDefine(EAction::ACTION_BONUS_BOMB); 90 __StateClassDefine(EAction::ACTION_None); 91 __StateClassDefine(EAction::ACTION_BONUS); 92 __StateClassDefine(EAction::ACTION_REPLENISH); 93 __StateClassDefine(EAction::ACTION_REFRESH); 94 __StateClassDefine(EAction::ACTION_FINAL); 95 96 #include "3x_desk_state.inl" 97 98 #endif
4. 3x_desk_state.inl
#include <iostream> #include <unordered_set> ////////////////////////////////////////////////////////////////////////////////////////// InputFuncBegin(EAction::ACTION_None) //开始状态， __StateAccept(EAction::ACTION_EXCHANGE_INPUT); __StateAccept(EAction::ACTION_BONUS_BOMB_INPUT); FuncEnd() UpdateFuncBegin(EAction::ACTION_None) Event<EAction::ACTION_None> ev; if(in.GetType() == EAction::ACTION_EXCHANGE_INPUT) { std::cout << "exchange input: " << in.GetInfo()._coordA._x << in.GetInfo()._coordA._y << in.GetInfo()._coordB._x << in.GetInfo()._coordB._y<< std::endl; ev.Info().Init(EAction::ACTION_EXCHANGE, (Action*)&(in.GetInfo())); __IGoTo(EAction::ACTION_EXCHANGE, ev); return; } if(in.GetType() == EAction::ACTION_BONUS_BOMB_INPUT) { ev.Info().Init(EAction::ACTION_BONUS_BOMB, (Action*)&(in.GetInfo())); __IGoTo(EAction::ACTION_BONUS_BOMB, ev); return; } FuncEnd() ////////////////////////////////////////////////////////////////////////////////////////// InputFuncBegin(EAction::ACTION_FINAL) __StateAccept(EAction::ACTION_REFRESH); FuncEnd() UpdateFuncBegin(EAction::ACTION_FINAL) Event<EAction::ACTION_FINAL> ev; cb(EAction::ACTION_FINAL, ev); //响应 final 状态 FuncEnd() ////////////////////////////////////////////////////////////////////////////////////////// InputFuncBegin(EAction::ACTION_EXCHANGE) std::cout << "exchange input function " << std::endl; __StateAccept(EAction::ACTION_None); FuncEnd() UpdateFuncBegin(EAction::ACTION_EXCHANGE) //仅接受初始状态，在交换过后需要进入‘消除’状态 //在当前状态直接判断是否可以消除，可以简化许多操作 //所以在此，仅当可以消除时，才可以进入下一个状态 if(in.GetType() != EAction::ACTION_None) { std::cout << "in.GetType() != EAction::ACTION_None " << std::endl; return; } const auto& act = in.GetInfo().GetInfo()._exchange; //尝试交换 if(!pDesk->Exchange(act._coordA, act._coordB)) { std::cout << "!pDesk->Exchange(act._coordA, act._coordB)) " << std::endl; return; } if(pDesk->IsInBonus(act._coordA) || pDesk->IsInBonus(act._coordB) ) { std::cout << "can bonus." << std::endl; //只有可消除才会响应交换事件，进入Bonus状态 Event<EAction::ACTION_EXCHANGE> ev; ev.Info()._coordA = act._coordA; ev.Info()._coordA._e = pDesk->get<EElem>(act._coordA._x, act._coordA._y); ev.Info()._coordB = act._coordB; ev.Info()._coordB._e = pDesk->get<EElem>(act._coordB._x, act._coordB._y); cb(EAction::ACTION_EXCHANGE, ev); __IGoTo(EAction::ACTION_BONUS, ev); return ; } else { //发现交换过后并不能消除，还原 std::cout << "can not bonus." << std::endl; pDesk->Exchange(act._coordA, act._coordB); return ; } return ; FuncEnd() ////////////////////////////////////////////////////////////////////////////////////////// InputFuncBegin(EAction::ACTION_BONUS) if(in.GetType() != action) return; //接受‘交换’和‘充满’两个状态， __StateAccept(EAction::ACTION_EXCHANGE); __StateAccept(EAction::ACTION_REPLENISH); FuncEnd() UpdateFuncBegin(EAction::ACTION_BONUS) //1. Check the 'Event& in', // 1.1 If the action is 'ACTION_EXCHANGE', check bonus is can do or not. // 1.1.1 If not, reduce reversive, return FALSE(-1). // 1.1.2 If can do, do bonus. // 1.2 If the action is 'NoneAction', SPECIAL-SKILLs perhaps...[?] //2. Do bonus, // 2.1 If bonus is happend, return 1, or return 2. std::vector<Coord> changes; const auto& act = in.GetInfo(); //上个阶段是“交换” if constexpr(action == EAction::ACTION_EXCHANGE) { changes.push_back(act._coordA); changes.push_back(act._coordB); } //上一个阶段是“补充”，需要计算补充而来的新元素是否可以消除 else if(action == EAction::ACTION_REPLENISH) { changes = act._changed; } bool isBonus = false; //消除事件是否发生 std::vector<Coord> cleared; //如果消除事件发生，被消除的坐标 std::vector<Coord> bonusUnit; std::unordered_set<int> signTotal; // for (const auto& coord : changes) { if(signTotal.find(pDesk->CoordToNum(coord)) != signTotal.end()) continue; std::unordered_set<int> sign; int bonusType = EBonusType::BONUS_None; std::vector<Coord> bonus; //There are coord with elem-type. It's chche. int count = 0, maxCountLine = 0; bonusType |= (int)(pDesk->Bonus(coord, bonus, count)); maxCountLine = std::max(maxCountLine, count); if(bonusType == EBonusType::BONUS_None) continue; std::vector<int> stack; //to stack for(const Coord& b : bonus) stack.push_back(pDesk->CoordToNum(b)); bonus.clear(); while(!stack.empty()) { int num = stack.back(); stack.pop_back(); if(sign.find(num) != sign.end()) continue; sign.insert(num); Coord next = pDesk->NumToCoord(num); bonusUnit.push_back(next); bonusType |= pDesk->Bonus(next, bonus, count); maxCountLine = std::max(maxCountLine, count); for(const Coord& b : bonus) stack.push_back(pDesk->CoordToNum(b)); } if(bonusType != EBonusType::BONUS_None) { isBonus = true; Event<EAction::ACTION_BONUS> cbEvent; cbEvent.Info()._bonus = (EBonusType)bonusType; cbEvent.Info()._cleared = bonusUnit; cbEvent.Info()._count = maxCountLine; cb(EAction::ACTION_BONUS, cbEvent); //事件响应：每一个单元的消除都会执行一次事件响应，与次数无关 for (const auto& bu : bonusUnit) signTotal.insert(pDesk->CoordToNum(bu)); } cleared.insert(cleared.end(), bonusUnit.begin(), bonusUnit.end()); bonusUnit.clear(); /////////////////////////////////////////////////////////// // //bonus happen. // std::vector<Coord> bonus; //There are coord with elem-type. // int count = 0; // //尝试消除，不真正更改棋盘 // //返回值 bonus 携带元素类型， // EBonusType t = pDesk->Bonus(coord, bonus, count); // if(bonus.empty()) // continue; //It's have no bonus. // { // //in cache // for(const auto& c : bonus) // cache[pDesk->CoordToNum(c)] = c; // } // isBonus = true; // Event<EAction::ACTION_BONUS> cbEvent; // cbEvent.Info()._bonus = t; // cbEvent.Info()._cleared = bonus; // cbEvent.Info()._count = count; // cb(EAction::ACTION_BONUS, cbEvent); //事件响应：每一个单元的消除都会执行一次事件响应，与次数无关 } Event<EAction::ACTION_BONUS> ev; if(isBonus) { //set block. for (auto&& each : cleared) pDesk->get<EElem>(each._x, each._y) = EElem::ELEM_None; //Next state is 'ACTION_REPLENISH'. ev.Info()._cleared = cleared; __IGoTo(EAction::ACTION_REPLENISH, ev); //////////////////////test for (size_t i = 0; i < pDesk->_height; i++) { for (size_t j = 0; j < pDesk->_width; j++) { std::cout << (int)(pDesk->get<EElem>(j, i)) << " "; } std::cout << std::endl; } std::cout << std::endl; ////////////////////// return; // 已经成功执行了消除操作，进入‘充满’状态； } else { //Next state is 'ACTION_REFRESH'. __IGoTo(EAction::ACTION_REFRESH, ev); return; // 没有发生消除事件，进入‘判断重排’状态； } return; //发生未知错误，状态机停止此刻，不阻塞，不更新 FuncEnd() ////////////////////////////////////////////////////////////////////////////////////////// InputFuncBegin(EAction::ACTION_REPLENISH) //仅接受‘bonus’状态，更新本状态后，再次进入‘bonus’状态， //开始进入好运连续消除的状态循环 __StateAccept(EAction::ACTION_BONUS); __StateAccept(EAction::ACTION_BONUS_BOMB); FuncEnd() UpdateFuncBegin(EAction::ACTION_REPLENISH) const auto& act = in.GetInfo(); std::set<Axis> xs; std::unordered_map<Axis, Axis> changed; //x:y for (const auto& each : act._cleared) { xs.insert(each._x); //changed //only insert y-max for each x. auto it = changed.find(each._x); if(it == changed.end() || it->second < each._y) changed[each._x] = each._y; } Event<EAction::ACTION_REPLENISH> ev; for(const auto[x, y] : changed) { for(Axis i = y; i >= 0; --i) { ev.Info()._changed.emplace_back(x, i); } } std::vector<Coord> newCoords; for (Axis x : xs) { std::vector<EElem>& eachX = pDesk->getcolume<EElem>(x); int blockCnt = 0, lastBlock = -1; //b for (Axis i = eachX.size() - 1; i >= 0; --i) //i { if(eachX[i] == EElem::ELEM_None) { blockCnt++; /** * -------1. find 'b', it's block * x * o * x * x <- b * o * ------- */ if(lastBlock == -1) lastBlock = i; continue; } /** * -------2. find 'i', it's not block. * x * o <- i * x * x <- b * o * ------- */ if(lastBlock > -1 && eachX[i] != EElem::ELEM_None) { /** * -------3. swap * x * x <- i * x * o <- b * o * ------- */ std::swap(eachX[lastBlock], eachX[i]); /** * -------4. reset 'b' * x * x <- i * x <- b * o * o * ------- */ lastBlock--; continue; } } for (size_t i = 0; i < blockCnt; i++) newCoords.emplace_back(x, i, pDesk->GetRandomElem()); } for(auto&& neweach : newCoords) { pDesk->set<EElem>(neweach._x, neweach._y, neweach._e); } ev.Info()._news = newCoords; cb(EAction::ACTION_REPLENISH, ev); __IGoTo(EAction::ACTION_BONUS, ev); FuncEnd() ////////////////////////////////////////////////////////////////////////////////////////// InputFuncBegin(EAction::ACTION_REFRESH) //仅接受‘bonus’状态, //在‘bonus’状态没有成功时，输入此状态, //更新之后，进入‘结束’状态 //所以，务必保证此状态更新之后，不会导致存在可消除的情况 __StateAccept(EAction::ACTION_BONUS); FuncEnd() UpdateFuncBegin(EAction::ACTION_REFRESH) Event<EAction::ACTION_REFRESH> ev; if(!pDesk->IsDead()) { __IGoTo(EAction::ACTION_FINAL, ev); return; } std::vector<Coord> recordA, becomeB; pDesk->Refresh(recordA, becomeB); ev.Info()._src = recordA; ev.Info()._become = becomeB; cb(EAction::ACTION_REFRESH, ev); __IGoTo(EAction::ACTION_FINAL, ev); FuncEnd() ////////////////////////////////////////////////////////////////////////////////////////// //特殊消除，具体需求为： // 消除 N 个某种颜色的元素 InputFuncBegin(EAction::ACTION_BONUS_BOMB) //存在执行消除事件的情况，进入‘充满’状态 //特殊情况：棋盘中不存在所谓的“某种颜色”，消除未被执行 __StateAccept(EAction::ACTION_None); FuncEnd() UpdateFuncBegin(EAction::ACTION_BONUS_BOMB) if(in.GetType() != EAction::ACTION_BONUS_BOMB) return; const auto& act = in.GetInfo(); const Coord& coord = act.GetInfo()._select._coord; EElem e = pDesk->get<EElem>(coord._x, coord._y); if(e == EElem::ELEM_None) return; //error int i = 0; std::vector<Coord> bonus; pDesk->foreach<EElem>([&](Axis x, Axis y, const EElem& each) -> bool { if(each != e) return true; pDesk->get<EElem>(x, y) = EElem::ELEM_None; ++i; bonus.emplace_back(x, y, each); return true; }); Event<EAction::ACTION_BONUS_BOMB> ev; if(i == 0) { cb(EAction::ACTION_BONUS_BOMB, ev); __IGoTo(EAction::ACTION_REFRESH, ev); return; } ev.Info()._bonus = EBonusType::BONUS_BOMB_BY_SELECT; ev.Info()._cleared = bonus; ev.Info()._count = i; cb(EAction::ACTION_BONUS_BOMB, ev); __IGoTo(EAction::ACTION_REPLENISH, ev); FuncEnd()
5. 3x_desk.h
1 #pragma once 2 3 #ifndef __LC_3X_DESK_H_ 4 #define __LC_3X_DESK_H_ 5 6 #include <array> 7 #include <vector> 8 #include <functional> 9 #include <unordered_map> 10 #include <set> 11 #include "lc_random.h" 12 #include <bitset> 13 #include "../__lc_component.h" 14 #include "3x_desk_event.h" 15 16 17 class Desk 18 { 19 public: 20 struct ElemWeight 21 { 22 EElem _ele; 23 int _weight = 0; 24 }; 25 26 struct TryBonusInfo 27 { 28 int _count = 0; 29 EElem _elem = EElem::ELEM_None; 30 std::vector<Coord> _bouns; 31 Coord _coordA; 32 Coord _coordB; 33 }; 34 35 public: 36 Desk() = delete; 37 Desk(Axis w, Axis h); 38 39 ~Desk(){} 40 41 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* = nullptr > 42 void foreach(std::function<bool(Axis x, Axis y, T& e)> && cb); 43 44 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* = nullptr > 45 void foreach(std::function<bool(Axis x, Axis y, const T& e)> && cb) const; 46 47 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* = nullptr > 48 T& get(Axis x, Axis y); 49 50 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* = nullptr > 51 T get(Axis x, Axis y) const; 52 53 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* = nullptr > 54 bool set(Axis x, Axis y, T e); 55 56 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* = nullptr > 57 std::vector<T>& getcolume(Axis x); 58 59 inline bool IsValidCoord(Axis x, Axis y) const noexcept; 60 bool IsFreeCoord(Axis x, Axis y) const; 61 62 bool IsNeighbour(const Coord& coordA, const Coord& coordB) const; 63 64 inline int CoordToNum(const Coord& coordA) const noexcept { return coordA._y * _width + coordA._x; } 65 inline Coord NumToCoord(int num) const noexcept {Axis x = num % _width; Axis y = num / _width; return { x, y, get<EElem>(x, y) }; }; 66 67 public: 68 void Init(const std::vector<ElemWeight>& weight); 69 bool IsDead() const; 70 71 //This function is a blur check. 72 //If it returns true then bonus must be available, 73 //and not necessarily if it returns false. 74 bool IsCanBonus(const Coord& coord, bool isAccurate = false) const; //@CHECK-RES:1 75 76 bool IsInBonus(const Coord& coord) const; //@CHECK-RES:1 77 inline bool IsElemEqual(Axis x, Axis y, EElem e) const noexcept; //@CHECK-RES:1 78 79 public: 80 bool IsCanExchange(const Coord& coordA, const Coord& coordB, bool isForce = false) const; 81 void DoExchange(const Coord& coordA, const Coord& coordB, const StateEventCallBackT& cb, bool isForce = false); 82 83 //则仅仅尝试计算，不真正执行消除而导致的更改棋盘。 84 EBonusType Bonus(const Coord& coordA, std::vector<Coord>& out, int& maxCountLine) const; 85 86 int FindBonus(std::vector<TryBonusInfo>& out, bool isBest = false); 87 88 EElem GetRandomElem() const; 89 90 //@return Is function 'ResetDesk' called? 91 bool Refresh(std::vector<Coord>& recordA, std::vector<Coord>& becomeB, int times = 0); 92 bool Exchange(const Coord& coordA, const Coord& coordB, bool isForce = false); //@CHECK-RES:1 93 94 //private: 95 void ResetWeight(const std::vector<ElemWeight>& weight); 96 void ResetDesk(); //@CHECK-RES:01 97 98 template<AxisType AT> 99 std::bitset<5> BonusSign(const Coord & coord) const; //@CHECK-RES:01 100 101 bool IsBonusBySign(const std::bitset<5>& sign) const; //@CHECK-RES:1 102 103 template<AxisType AT> 104 std::bitset<5> TestSign(Coord&& coord) const; //@CHECK-RES:1 105 106 bool FindNeverBonusCoordWith(EElem e, Coord& out, uint64_t startWith = 0) const; 107 void TestNonBonusWith(Coord coord, std::set<EElem>& out) const; 108 109 public: 110 111 112 //private: 113 Axis _width = 0; 114 Axis _height = 0; 115 116 std::vector< //w 117 std::vector<EElem> //h 118 > _eles; 119 120 std::vector< 121 std::vector<EDeck> 122 > _decks; 123 124 //std::unordered_map<EElem, int> _pool; 125 RandomItem<ElemWeight> _randPool; 126 }; 127 128 #include "3x_desk.inl" 129 130 #endif
6. 3x_desk.cpp
1 #include "3x_desk.h" 2 #include "3x_desk_state.h" 3 #include "inc.h" 4 #include "lc_logmgr.h" 5 #include "custom/CFG_CTM_Elem.h" 6 #include <algorithm> 7 8 Desk::Desk(Axis w, Axis h) 9 : _width(w) 10 , _height(h) 11 { 12 if(w < 5 || h < 5) 13 { 14 LogPrint("ERROR", "The Desk height or width too less. W: ", w, "; H: ", h); 15 return; 16 } 17 18 _eles.resize(w); 19 for (auto& eachW : _eles) 20 { 21 eachW.resize(h); 22 for(EElem& eachH : eachW) 23 eachH = EElem::ELEM_None; 24 } 25 26 _decks.resize(w); 27 for (auto& eachW : _decks) 28 { 29 eachW.resize(h); 30 for(EDeck& eachH : eachW) 31 eachH = EDeck::DECK_BLOCK; 32 } 33 34 std::vector<ElemWeight> pool; 35 const int defaultW = 2310; 36 for (uint8_t i = (uint8_t)EElem::ELEM_None + 1; i <= (uint8_t)EElem::ELEM_None + CFG_ELEM.Size(); i++) 37 { 38 EElem e = EElem(i); 39 pool.push_back({e, defaultW}); 40 } 41 42 Init(pool); 43 } 44 45 void Desk::ResetWeight(const std::vector<ElemWeight>& weight) 46 { 47 _randPool.Init(weight, [](const ElemWeight& item)->int{ return item._weight; }); 48 } 49 50 bool Desk::IsFreeCoord(Axis x, Axis y) const 51 { 52 if(!IsValidCoord(x, y)) 53 return false; 54 55 EDeck deck = get<EDeck>(x, y); 56 return !(deck == EDeck::DECK_WALL || deck == EDeck::DECK_FREEZE); 57 } 58 59 bool Desk::IsNeighbour(const Coord& coordA, const Coord& coordB) const 60 { 61 if(!(IsValidCoord(coordA._x, coordA._y) 62 && IsValidCoord(coordB._x, coordB._y)) 63 ) return false; 64 65 return 66 (coordA._x == coordB._x && std::abs(coordA._y - coordB._y) == 1) 67 || (coordA._y == coordB._y && std::abs(coordA._x - coordB._x) == 1) ; 68 } 69 70 bool Desk::IsInBonus(const Coord& coord) const 71 { 72 if(!IsValidCoord(coord._x, coord._y)) 73 return false; 74 75 return IsBonusBySign(BonusSign<AxisType::AxisX>(coord)) 76 || IsBonusBySign(BonusSign<AxisType::AxisY>(coord)); 77 } 78 79 bool Desk::IsBonusBySign(const std::bitset<5>& sign) const 80 { 81 if(!sign[2]) 82 return false; 83 84 return (sign[0] && sign[1]) 85 ||(sign[3] && sign[4]) 86 || (sign[1] && sign[3]); 87 } 88 89 bool Desk::IsDead() const 90 { 91 bool ret = true; 92 foreach<EElem>([this, &ret](Axis x, Axis y, const EElem& e) -> bool 93 { 94 if(e == EElem::ELEM_None) 95 return true; 96 97 if(IsInBonus({x, y}) || IsCanBonus({x, y})) 98 { 99 ret = false; 100 return false; 101 } 102 return true; 103 }); 104 105 return ret; 106 } 107 108 inline bool Desk::IsElemEqual(Axis x, Axis y, EElem e) const noexcept 109 { 110 return IsValidCoord(x, y) 111 && (e != EElem::ELEM_None) 112 && (get<EElem>(x, y) == e) 113 ; 114 } 115 116 bool Desk::IsCanBonus(const Coord& coord, bool isAccurate) const 117 { 118 bool isCan = false; 119 const EElem e = get<EElem>(coord._x, coord._y); 120 121 { 122 /** 123 * 3. 124 * X P X 125 * P X P 126 * X C X 127 * X C X 128 * P X P 129 * X P X 130 */ 131 132 for (Axis i = coord._y - 1; i < coord._y + 1; i++) 133 { 134 if(i == coord._y) 135 continue; 136 137 if(!IsElemEqual(coord._x, i, e)) 138 continue; 139 140 Axis x1, x2, x3 141 , y1, y2, y3, y4; 142 x1 = coord._x - 1; 143 x2 = coord._x + 1; 144 x3 = coord._x; 145 146 Axis ymin = std::min(coord._y, i); 147 Axis ymax = std::max(coord._y, i); 148 149 y1 = ymin - 1; 150 y2 = ymax + 1; 151 y3 = ymin - 2; 152 y4 = ymax + 2; 153 154 isCan = IsElemEqual(x1, y1, e) 155 || IsElemEqual(x1, y2, e) 156 || IsElemEqual(x2, y1, e) 157 || IsElemEqual(x2, y2, e) 158 || IsElemEqual(x3, y3, e) 159 || IsElemEqual(x3, y4, e); 160 } 161 162 if(isCan) 163 return true; 164 } 165 166 { 167 /** 168 * 2. 169 * X P X X P X 170 * P X C C X P 171 * X P X X P X 172 */ 173 174 for (Axis i = coord._x - 1; i < coord._x + 1; i++) 175 { 176 if(i == coord._x) 177 continue; 178 179 if(!IsElemEqual(i, coord._y, e)) 180 continue; 181 182 Axis x1, x2, x3, x4 183 , y1, y2, y3; 184 Axis xmin = std::min(i, coord._x); 185 Axis xmax = std::max(i, coord._x); 186 187 x1 = xmin - 1; 188 x2 = xmax + 1; 189 x3 = xmin - 2; 190 x4 = xmax + 2; 191 192 y1 = coord._y - 1; 193 y2 = coord._y + 1; 194 y3 = coord._y; 195 196 isCan = IsElemEqual(x1, y1, e) 197 || IsElemEqual(x1, y2, e) 198 || IsElemEqual(x2, y1, e) 199 || IsElemEqual(x2, y2, e) 200 || IsElemEqual(x3, y3, e) 201 || IsElemEqual(x4, y3, e); 202 } 203 204 if(isCan) 205 return true; 206 } 207 208 { 209 /** 210 * 1. 211 * P X P 212 * X C X 213 * P X P 214 */ 215 216 static const Coord edge[2] = {{-1, -1}, {1, 1}}; 217 for (size_t i = 0; i < 2; i++) 218 { 219 const Coord& edgei = edge[i]; 220 Coord cur(edgei._x + coord._x, edgei._y + coord._y); 221 if(!IsElemEqual(cur._x, cur._y, e)) 222 continue; 223 224 else //found one. 225 { 226 //check x 227 cur._x = cur._x + -2 * edgei._x; 228 if(!IsElemEqual(cur._x, cur._y, e)) 229 { 230 //check y 231 cur._y = cur._y + -2 * edgei._y; 232 233 //finding two. 234 isCan = IsElemEqual(cur._x, cur._y, e); 235 } 236 else 237 isCan = true; 238 239 240 } 241 } 242 243 if(isCan) 244 return true; 245 } 246 247 if(!isAccurate) 248 return false; 249 250 { 251 /** 252 * 4. 253 * P P X P P 254 * X X C X X 255 * P P X P P 256 */ 257 258 //check line 259 std::bitset<5> signs[4] = 260 { 261 TestSign<AxisType::AxisX>({coord._x, coord._y - 1, e}), 262 TestSign<AxisType::AxisX>({coord._x, coord._y + 1, e}), 263 TestSign<AxisType::AxisY>({coord._x - 1, coord._y, e}), 264 TestSign<AxisType::AxisY>({coord._x + 1, coord._y, e}) 265 }; 266 for (size_t i = 0; i < 4; i++) 267 { 268 if(IsBonusBySign(signs[i])) 269 return true; 270 } 271 272 } 273 274 return false; 275 } 276 277 EElem Desk::GetRandomElem() const 278 { 279 auto* pItem = _randPool.Get(); 280 if(pItem == nullptr) 281 return EElem::ELEM_None; 282 return pItem->_ele; 283 } 284 285 bool Desk::Refresh(std::vector<Coord>& recordA, std::vector<Coord>& becomeB, int times) 286 { 287 if(times >= 10) 288 { 289 ResetDesk(); 290 return true; 291 } 292 293 const uint32_t total = _width * _height; 294 recordA.reserve(total); 295 becomeB.reserve(total); 296 for (size_t i = 0; i < total - 2; i++) 297 { 298 Axis x1 = i % _width; 299 Axis y1 = i / _width; 300 301 std::set<EElem> nonBonus; 302 TestNonBonusWith(Coord(x1, y1), nonBonus); 303 if(nonBonus.empty()) 304 return Refresh(recordA, becomeB, times + 1); 305 306 bool isFound = false; 307 for(EElem nonEle : nonBonus) 308 { 309 Coord found; 310 if(!FindNeverBonusCoordWith(nonEle, found, i + 1)) 311 continue; 312 313 isFound = true; 314 std::swap(_eles[x1][y1], _eles[found._x][found._y]); 315 recordA.push_back({x1, y1}); 316 becomeB.push_back(found); 317 break; 318 } 319 320 if(!isFound) 321 return Refresh(recordA, becomeB, times + 1); 322 } 323 324 if(IsDead()) 325 return Refresh(recordA, becomeB, times + 1); 326 327 return false; 328 } 329 330 //寻找一个坐标 out，这个坐标若是被设置成 e, 则不会被成为 InBonus. 331 //@return Is found. 332 bool Desk::FindNeverBonusCoordWith(EElem e, Coord& out, uint64_t startWith) const 333 { 334 const uint32_t total = _width * _height; 335 if(startWith >= total) 336 startWith = 0; 337 338 bool ret = false; 339 uint64_t r = RandomAvg::Instance().Get(startWith, total); 340 loop_start_by(startWith, total, r, [&](int64_t i) 341 { 342 Axis x1 = i % _width; 343 Axis y1 = i / _width; 344 345 auto sign1x = TestSign<AxisType::AxisX>({x1, y1, e}); 346 if(IsBonusBySign(sign1x)) 347 return true; 348 349 auto sign1y = TestSign<AxisType::AxisY>({x1, y1, e}); 350 if(IsBonusBySign(sign1y)) 351 return true; 352 353 out(x1, y1); 354 ret = true; 355 return false; 356 }); 357 358 return ret; 359 } 360 361 //判断 coord 位置的元素，接受哪些元素类型（out）才不会成为 InBonus。 362 void Desk::TestNonBonusWith(Coord coord, std::set<EElem>& out) const 363 { 364 if(!IsValidCoord(coord._x, coord._y)) 365 return; 366 367 for(uint8_t i = (uint8_t)EElem::ELEM_None + 1; i <= (uint8_t)EElem::ELEM_None + CFG_ELEM.Size(); ++i) 368 { 369 EElem e = (EElem)i; 370 auto sign1x = TestSign<AxisType::AxisX>({coord._x, coord._y, e}); 371 if(IsBonusBySign(sign1x)) 372 continue; 373 374 auto sign1y = TestSign<AxisType::AxisY>({coord._x, coord._y, e}); 375 if(IsBonusBySign(sign1y)) 376 continue; 377 378 out.insert(e); 379 } 380 } 381 382 void Desk::ResetDesk() 383 { 384 const uint32_t total = _width * _height; 385 std::vector<bool> symbol; //标识 386 symbol.resize(total, false); 387 388 //为了保证生成的棋盘不是一个死局， 389 //那么就在它还是一个空棋盘的时候，在随机位置 r 设置一个可以消除的情况， 390 //并将标识设置为 true 391 { 392 uint64_t r = RandomAvg::Instance().Get(0, total); 393 Axis x2 = r % _width; 394 Axis y2 = r / _width; 395 396 //为了后面的处理简单，则保证随机的位置 r 不在棋盘的边缘 397 //至少空余 2 个位置 398 x2 = x2 % ((_width - 2) - 2) + 2; 399 y2 = y2 % ((_height - 2) - 2) + 2; 400 401 //随机一个种类的元素 402 uint64_t rElem = _randPool.Get()->_ele; 403 _eles[x2][y2] = (EElem)rElem; 404 _eles[x2][y2 - 1] = (EElem)rElem; 405 _eles[x2 + 1][y2 + 1] = (EElem)rElem; 406 symbol[y2 * _width + x2] = true; 407 symbol[(y2 - 1) * _width + x2] = true; 408 symbol[(y2 + 1) * _width + (x2 + 1)] = true; 409 } 410 411 //开始初始化棋盘 412 for (uint32_t i = 0; i < total; i++) 413 { 414 const Axis x1 = i % _width; 415 const Axis y1 = i / _width; 416 417 if(symbol[i]) 418 continue; 419 420 bool isSet = false; 421 //随机每个格子 422 uint64_t r = _randPool.Get()->_ele; 423 //此循环的意义在于，若是随机的元素 r 被设置后，导致了存在可消除的情况， 424 //那么则采用其他元素类型 [[unlikely]] 425 loop_start_by((int64_t)EElem::ELEM_None + 1, (int64_t)EElem::ELEM_None + CFG_ELEM.Size() + 1, r, [&](int64_t ie) -> bool 426 { 427 EElem e = (EElem)ie; 428 429 //测试位置(x1, y1)若是被设置了元素 e， 430 auto sign1x = TestSign<AxisType::AxisX>({x1, y1, e}); 431 //是否可以消除， 432 if(IsBonusBySign(sign1x)) 433 return true; //如果可消除，则 continue. 434 435 auto sign1y = TestSign<AxisType::AxisY>({x1, y1, e}); 436 if(IsBonusBySign(sign1y)) 437 return true; 438 439 _eles[x1][y1] = e; 440 symbol[i] = true; 441 isSet = true; 442 443 return false; 444 }); 445 446 //如果所有元素的测试均未通过，则重新初始化棋盘, 447 //在棋盘大小以及元素种类个数设置合理的情况下，这种情况几乎不可能发生 448 //在 8x8 的棋盘，并最多存在6种不同元素情况下，经过 3x50W 次测试，没有命中 449 if(!isSet) 450 { 451 ResetDesk(); 452 break; 453 } 454 455 } 456 457 } 458 459 bool Desk::IsCanExchange(const Coord& coordA, const Coord& coordB, bool isForce) const 460 { 461 if(IsElemEqual(coordA._x, coordA._y, get<EElem>(coordB._x, coordB._y))) 462 { 463 return false; 464 } 465 466 if(!isForce && !IsNeighbour(coordA, coordB)) 467 { 468 return false; 469 } 470 471 if(isForce && IsValidCoord(coordA._x, coordA._y) && IsValidCoord(coordB._x, coordB._y)) 472 { 473 return false; 474 } 475 476 if(!(IsFreeCoord(coordA._x, coordA._y) && IsFreeCoord(coordB._x, coordB._y))) 477 { 478 return false; 479 } 480 481 return true; 482 } 483 484 bool Desk::Exchange(const Coord& coordA, const Coord& coordB, bool isForce) 485 { 486 if(!IsCanExchange(coordA, coordB, isForce)) 487 return false; 488 489 std::swap(_eles[coordA._x][coordA._y], _eles[coordB._x][coordB._y]); 490 return true; 491 } 492 493 void Desk::Init(const std::vector<ElemWeight>& weight) 494 { 495 ResetWeight(weight); 496 ResetDesk(); 497 } 498 499 EBonusType Desk::Bonus(const Coord& coordA, std::vector<Coord>& out, int& maxCountLine) const 500 { 501 if(!IsValidCoord(coordA._x, coordA._y)) 502 return EBonusType::BONUS_None; 503 504 EElem e = get<EElem>(coordA._x, coordA._y); 505 if(e == EElem::ELEM_None) 506 return EBonusType::BONUS_None; 507 508 EBonusType ret = EBonusType::BONUS_None; 509 bool isA = false, isV = false; // 横向/纵向是否存在消除 510 int cA = 0, cV = 0; // 横向/纵向消除数量 511 512 std::vector<Coord> outA, outV; 513 ///判断横向消除 514 { 515 //0,1,2,3,4 这 5 个元素以 2 位置为判断点，相同元素标识位为 1 516 std::bitset<5> signX = TestSign<AxisType::AxisX>({coordA._x, coordA._y, e}); 517 for (size_t i = 1; i >= 0; i--) //<<-- //判断点的左侧两个元素 1, 0 518 { 519 if(signX[i]) 520 { 521 Axis x = coordA._x + i - 2, 522 y = coordA._y; 523 524 //@Notice 需要设置点位置的元素类型，尽可能使返回值充分 525 outA.emplace_back(x, y, e); 526 } 527 else break; //顺序判断，一旦存在不相同，则立即退出 528 } 529 530 //加入判断点本身 531 outA.push_back(Coord(coordA._x, coordA._y, e)); 532 533 for (size_t i = 3; i < 5; i++) //-->> //判断点的右侧两个元素 3, 4 534 { 535 if(signX[i]) 536 { 537 Axis x = coordA._x + i - 2, 538 y = coordA._y; 539 540 outA.emplace_back(x, y, e); 541 } 542 543 else break; 544 } 545 } 546 547 ///判断纵向消除 548 { 549 std::bitset<5> signY = BonusSign<AxisType::AxisY>(coordA); 550 for (size_t i = 1; i >= 0; i--) //<<-- 551 { 552 if(signY[i]) 553 { 554 Axis x = coordA._x, 555 y = coordA._y + i - 2; 556 outV.emplace_back(x, y, e); 557 } 558 else break; 559 } 560 561 //判断点不可以包含两次 562 if(outA.size() < 3) outV.push_back(Coord(coordA._x, coordA._y, e)); 563 564 for (size_t i = 3; i < 5; i++) //-->> 565 { 566 if(signY[i]) 567 { 568 Axis x = coordA._x, 569 y = coordA._y + i - 2; 570 outV.emplace_back(x, y, e); 571 } 572 573 else break; 574 } 575 } 576 577 //执行横向消除 578 cA = outA.size(); 579 if(cA >= 3) //大于等于 3 个可消除 580 { 581 isA = true; 582 for (auto& each : outA) 583 out.push_back(each); 584 } 585 586 //执行纵向消除 587 cV = outV.size(); 588 if(cV >= 3 || (isA && outV.size() >= 2)) 589 { 590 isV = true; 591 for (const auto& each : outV) 592 out.push_back(each); 593 } 594 595 //判断消除形状 596 maxCountLine = std::max(cA, cV); 597 if(isV && isA) return EBonusType::BONUS_CROSS; //十字形消除(T / L) 598 if(isA) return EBonusType::BONUS_ACROSS; //横向消除 599 if(isV) return EBonusType::BONUS_VERTICAL; //纵向消除 600 return EBonusType::BONUS_None; 601 } 602 603 int Desk::FindBonus(std::vector<TryBonusInfo>& out, bool isBest) 604 { 605 std::array<Coord, 4> side = { Coord{-1, 0}, Coord{1, 0}, Coord{0, -1}, Coord{0, 1} }; 606 607 std::vector<Coord> bonus; 608 int count = 0; 609 int tmp = 0; 610 foreach<EElem>([&](Axis x, Axis y, const EElem& e)->bool 611 { 612 TryBonusInfo info; 613 Coord coordA(x, y, e); //the coordA is checked point. 614 for (size_t i = 0; i < side.size(); i++) 615 { 616 Axis bx = x + side[i]._x; 617 Axis by = y + side[i]._y; 618 619 if(!IsValidCoord(bx, by)) 620 continue; 621 622 EElem be = get<EElem>(bx, by); 623 if(be == e) 624 continue; 625 626 Coord coordB(bx, by, be); 627 bonus.clear(); 628 629 bool isExchange = Exchange(coordA, coordB, false); 630 if(!isExchange) 631 continue; 632 633 EBonusType bonusType = Bonus(coordA, bonus, tmp); 634 if(bonusType == EBonusType::BONUS_None) 635 { 636 Exchange(coordA, coordB, false); 637 continue; 638 } 639 640 const size_t s = bonus.size(); 641 642 info._bouns = bonus; 643 info._count = s; 644 info._elem = bonus.front()._e; 645 info._coordA = coordA; 646 info._coordB = coordB; 647 648 if(!isBest) 649 { 650 out.push_back(info); 651 Exchange(coordA, coordB, false); 652 continue; 653 } 654 655 if(s > count) 656 { 657 out.clear(); 658 out.push_back(info); 659 660 count = s; 661 } 662 else if(s == count && s > 0) 663 { 664 out.push_back(info); 665 } 666 667 Exchange(coordA, coordB, false); 668 } 669 670 return true; 671 }); 672 673 return count; 674 } 675 676 /////////////////////// 677 678 void Desk::DoExchange(const Coord& coordA, const Coord& coordB, const StateEventCallBackT& cb, bool isForce) 679 { 680 Event<EAction::ACTION_EXCHANGE_INPUT> ev; 681 ev.Info()._coordA = coordA; 682 ev.Info()._coordB = coordB; 683 Start_3x_State(this, EAction::ACTION_EXCHANGE_INPUT, ev, cb); 684 }
7. 3x_desk.inl
1 template<typename T, 2 typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* 3 > 4 void Desk::foreach(std::function<bool(Axis w, Axis h, T& e)> && cb) 5 { 6 for (Axis j = 0; j < _width; j++) 7 { 8 for (Axis i = 0; i < _height; i++) 9 { 10 bool is = false; 11 if constexpr(std::is_same<T, EElem>::value) 12 is = cb(j, i, _eles[j][i]); 13 else if(std::is_same<T, EDeck>::value) 14 is = cb(j, i, _decks[j][i]); 15 else break; 16 17 if(!is) break; 18 } 19 } 20 21 return; 22 } 23 24 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* > 25 void Desk::foreach(std::function<bool(Axis w, Axis h, const T& e)> && cb) const 26 { 27 for (Axis j = 0; j < _width; j++) 28 { 29 for (Axis i = 0; i < _height; i++) 30 { 31 bool is = false; 32 if constexpr(std::is_same<T, EElem>::value) 33 is = cb(j, i, _eles[j][i]); 34 else if(std::is_same<T, EDeck>::value) 35 is = cb(j, i, _decks[j][i]); 36 else break; 37 38 if(!is) break; 39 } 40 } 41 return; 42 } 43 44 45 46 template<typename T, 47 typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* 48 > 49 T& Desk::get(Axis x, Axis y) 50 { 51 if constexpr(std::is_same<T, EElem>::value) 52 { 53 return _eles[x][y]; 54 } 55 56 else if(std::is_same<T, EDeck>::value) 57 { 58 return _decks[x][y]; 59 } 60 } 61 62 template<typename T, 63 typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* 64 > 65 bool Desk::set(Axis x, Axis y, T e) 66 { 67 if(!IsValidCoord(x, y)) 68 return false; 69 70 get<T>(x, y) = e; 71 return true; 72 } 73 74 template<typename T, 75 typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* 76 > 77 T Desk::get(Axis x, Axis y) const 78 { 79 if constexpr(std::is_same<T, EElem>::value) 80 { 81 if(!IsValidCoord(x, y)) 82 return EElem::ELEM_None; 83 return _eles[x][y]; 84 } 85 86 else if(std::is_same<T, EDeck>::value) 87 { 88 if(!IsValidCoord(x, y)) 89 return EDeck::DECK_None; 90 return _decks[x][y]; 91 } 92 } 93 94 template<AxisType AT> 95 std::bitset<5> Desk::BonusSign(const Coord & coord) const 96 { 97 EElem e = get<EElem>(coord._x, coord._y); 98 if(e == EElem::ELEM_None) 99 return 0; 100 101 size_t i = 0; 102 std::bitset<5> ret; 103 104 if constexpr(AT == AxisType::AxisY) 105 { 106 for (Axis y = coord._y - 2; y <= coord._y + 2; y++, i++) 107 { 108 if(!IsValidCoord(coord._x, y)) 109 { 110 ret[i] = 0; 111 continue; 112 } 113 114 ret[i] = get<EElem>(coord._x, y) == e ? 1 : 0; 115 } 116 return ret; 117 } 118 119 if constexpr(AT == AxisType::AxisX) 120 { 121 for (Axis x = coord._x - 2; x <= coord._x + 2; x++, i++) 122 { 123 if(!IsValidCoord(x, coord._y)) 124 { 125 ret[i] = 0; 126 continue; 127 } 128 ret[i] = get<EElem>(x, coord._y) == e ? 1 : 0; 129 } 130 return ret; 131 } 132 133 return 0; 134 } 135 136 template<AxisType AT> 137 std::bitset<5> Desk::TestSign(Coord&& coord) const 138 { 139 EElem e = coord._e; 140 if(e == EElem::ELEM_None) 141 return 0; 142 143 size_t i = 0; 144 std::bitset<5> ret; 145 146 if constexpr(AT == AxisType::AxisY) 147 { 148 for (Axis y = coord._y - 2; y <= coord._y + 2; y++, i++) 149 { 150 if(!IsValidCoord(coord._x, y)) 151 { 152 ret[i] = 0; 153 continue; 154 } 155 156 ret[i] = get<EElem>(coord._x, y) == e ? 1 : 0; 157 } 158 ret[2] = 1; 159 return ret; 160 } 161 162 if constexpr(AT == AxisType::AxisX) 163 { 164 for (Axis x = coord._x - 2; x <= coord._x + 2; x++, i++) 165 { 166 if(!IsValidCoord(x, coord._y)) 167 { 168 ret[i] = 0; 169 continue; 170 } 171 ret[i] = get<EElem>(x, coord._y) == e ? 1 : 0; 172 } 173 ret[2] = 1; 174 return ret; 175 } 176 177 return 0; 178 } 179 180 template<typename T, typename std::enable_if<std::is_same<T, EElem>::value||std::is_same<T, EDeck>::value, T>::type* > 181 std::vector<T>& Desk::getcolume(Axis x) 182 { 183 if constexpr(std::is_same<T, EElem>::value ) 184 return _eles[x]; 185 else 186 return _decks[x]; 187 } 188 189 inline bool Desk::IsValidCoord(Axis x, Axis y) const noexcept 190 { 191 return x < _width && y < _height && x >= 0 && y >= 0; 192 }
