最近在研究三消算法，我想试试在完全不借助网络资源的情况下搞定这个东西，所以有些地方可能不是最优的。
代码留此备忘。
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 }