3008 lines
90 KiB
C++
3008 lines
90 KiB
C++
#include "stdafx.h"
|
|
#include "Tetris.h"
|
|
|
|
int nType = 0;
|
|
int type = 0;
|
|
int state = 0;
|
|
int tScore = 0;
|
|
bool gameOverFlag = false;
|
|
bool suspendFlag = false;
|
|
bool targetFlag = false;
|
|
int workRegion[20][10] = { 0 };
|
|
Point point = { 0, 0 };
|
|
Point target = { 0, 0 };
|
|
MenuState menuState = { 0, 2 };
|
|
PlayerStats classicStats = { 0, 1, 0, 0, 0 };
|
|
PlayerStats rogueStats = { 0, 1, 0, 30, 0, 100, 100, 0 };
|
|
UpgradeUiState upgradeUiState = { 0, 0, 0, 0, {} };
|
|
FeedbackState feedbackState = { 0, _T(""), _T("") };
|
|
int currentScreen = SCREEN_MENU;
|
|
int currentMode = MODE_CLASSIC;
|
|
int currentFallInterval = 500;
|
|
int nextTypes[3] = { 0, 0, 0 };
|
|
int holdType = -1;
|
|
bool holdUsedThisTurn = false;
|
|
bool currentPieceIsExplosive = false;
|
|
bool currentPieceIsLaser = false;
|
|
bool currentPieceIsCross = false;
|
|
bool currentPieceIsRainbow = false;
|
|
Point pendingChainBombCenter = { 0, 0 };
|
|
bool pendingChainBombFollowup = false;
|
|
|
|
enum UpgradeId
|
|
{
|
|
UPGRADE_SCORE_MULTIPLIER = 0,
|
|
UPGRADE_EXP_MULTIPLIER = 1,
|
|
UPGRADE_SLOW_FALL = 2,
|
|
UPGRADE_COMBO_BONUS = 3,
|
|
UPGRADE_PREVIEW_PLUS_ONE = 4,
|
|
UPGRADE_LAST_CHANCE = 5,
|
|
UPGRADE_HOLD_UNLOCK = 6,
|
|
UPGRADE_PRESSURE_RELIEF = 7,
|
|
UPGRADE_SWEEPER = 8,
|
|
UPGRADE_EXPLOSIVE_PIECE = 9,
|
|
UPGRADE_STABLE_STRUCTURE = 10,
|
|
UPGRADE_DOUBLE_GROWTH = 11,
|
|
UPGRADE_PIECE_TUNING = 12,
|
|
UPGRADE_GAMBLER = 13,
|
|
UPGRADE_CHAIN_BLAST = 14,
|
|
UPGRADE_CHAIN_BOMB = 15,
|
|
UPGRADE_LASER_PIECE = 16,
|
|
UPGRADE_THUNDER_TETRIS = 17,
|
|
UPGRADE_THUNDER_LASER = 18,
|
|
UPGRADE_FEVER_MODE = 19,
|
|
UPGRADE_RAGE_STACK = 20,
|
|
UPGRADE_INFINITE_FEVER = 21,
|
|
UPGRADE_SCREEN_BOMB = 22,
|
|
UPGRADE_TERMINAL_CLEAR = 23,
|
|
UPGRADE_DUAL_CHOICE = 24,
|
|
UPGRADE_DESTINY_WHEEL = 25,
|
|
UPGRADE_PERFECT_ROTATE = 26,
|
|
UPGRADE_TIME_DILATION = 27,
|
|
UPGRADE_HIGH_PRESSURE = 28,
|
|
UPGRADE_TETRIS_GAMBLE = 29,
|
|
UPGRADE_EXTREME_PLAYER = 30,
|
|
UPGRADE_UPGRADE_SHOCKWAVE = 31,
|
|
UPGRADE_EVOLUTION_IMPACT = 32,
|
|
UPGRADE_CONTROL_MASTER = 33,
|
|
UPGRADE_BLOCK_STORM = 34,
|
|
UPGRADE_CROSS_PIECE = 35,
|
|
UPGRADE_BLACK_HOLE = 36,
|
|
UPGRADE_AIR_RESHAPE = 37,
|
|
UPGRADE_RAINBOW_PIECE = 38,
|
|
UPGRADE_VOID_CORE = 39
|
|
};
|
|
|
|
static const UpgradeEntry kUpgradePool[] =
|
|
{
|
|
{ UPGRADE_SCORE_MULTIPLIER, -1, 100, true, _T("\u5206\u6570\u500d\u7387"), _T("\u5f97\u5206"), _T("\u6240\u6709\u5f97\u5206\u63d0\u9ad8 20%\u3002") },
|
|
{ UPGRADE_COMBO_BONUS, -1, 95, true, _T("\u8fde\u51fb\u52a0\u6210"), _T("\u8282\u594f"), _T("\u8fde\u7eed\u6d88\u884c\u65f6\u8ffd\u52a0\u8fde\u51fb\u5956\u52b1\u3002") },
|
|
{ UPGRADE_SLOW_FALL, -1, 90, true, _T("\u6162\u901f\u4e0b\u843d"), _T("\u64cd\u4f5c"), _T("\u81ea\u7136\u4e0b\u843d\u53d8\u6162\uff0c\u6bcf\u6b21\u63d0\u9ad8 80ms\u3002") },
|
|
{ UPGRADE_PREVIEW_PLUS_ONE, 3, 85, false, _T("\u989d\u5916\u9884\u89c8"), _T("\u89c6\u91ce"), _T("\u4e0b\u4e00\u4e2a\u65b9\u5757\u9884\u89c8 +1\uff0c\u6700\u591a 3 \u4e2a\u3002") },
|
|
{ UPGRADE_EXP_MULTIPLIER, -1, 100, true, _T("\u7ecf\u9a8c\u5f3a\u5316"), _T("\u6210\u957f"), _T("\u540e\u7eed\u6d88\u884c\u83b7\u5f97 EXP \u63d0\u9ad8 25%\u3002") },
|
|
{ UPGRADE_LAST_CHANCE, 1, 72, false, _T("\u6700\u540e\u4e00\u640f"), _T("\u4fdd\u547d"), _T("\u9996\u6b21\u9876\u6b7b\u65f6\u81ea\u52a8\u6e05\u9664\u5e95\u90e8 3 \u884c\u5e76\u7ee7\u7eed\u6e38\u620f\u3002") },
|
|
{ UPGRADE_HOLD_UNLOCK, 1, 78, false, _T("Hold \u89e3\u9501"), _T("\u7279\u6b8a"), _T("\u89e3\u9501 Hold \u69fd\uff0c\u5bf9\u5c40\u4e2d\u53ef\u7528 C \u6216 Shift \u6682\u5b58\u65b9\u5757\u3002") },
|
|
{ UPGRADE_PRESSURE_RELIEF, -1, 82, true, _T("\u51cf\u538b"), _T("\u7279\u6b8a"), _T("\u7acb\u5373\u6e05\u9664\u5f53\u524d\u6700\u9ad8\u5360\u7528\u884c\uff0c\u4e3a\u76d8\u9762\u817e\u51fa\u547c\u5438\u7a7a\u95f4\u3002") },
|
|
{ UPGRADE_SWEEPER, -1, 74, true, _T("\u6e05\u626b\u8005"), _T("\u7279\u6b8a"), _T("\u7d2f\u8ba1\u6d88\u884c\u5145\u80fd\uff0c\u6536\u6ee1\u540e\u81ea\u52a8\u6e05\u9664\u5e95\u90e8 1 \u884c\u3002") },
|
|
{ UPGRADE_EXPLOSIVE_PIECE, -1, 76, true, _T("\u7206\u7834\u65b9\u5757"), _T("\u7279\u6b8a"), _T("\u63d0\u9ad8\u7206\u7834\u65b9\u5757\u51fa\u73b0\u6982\u7387\uff0c\u843d\u5730\u65f6\u89e6\u53d1 3x3 \u6e05\u9664\u3002") },
|
|
{ UPGRADE_CHAIN_BLAST, 1, 92, false, _T("\u8fde\u9501\u7206\u7834"), _T("\u8fdb\u9636"), _T("\u6d88\u884c\u540e\u5bf9\u88ab\u6e05\u9664\u884c\u9644\u8fd1\u968f\u673a\u6e05\u6389\u51e0\u683c\u3002") },
|
|
{ UPGRADE_CHAIN_BOMB, 1, 110, false, _T("\u8fde\u73af\u70b8\u5f39"), _T("\u8fdb\u5316"), _T("\u7206\u7834\u8303\u56f4\u63d0\u5347\u4e3a 5x5\uff0c\u82e5\u5f15\u53d1\u6d88\u884c\u5219\u8ffd\u52a0\u4e00\u6b21\u5c0f\u7206\u70b8\u3002") },
|
|
{ UPGRADE_LASER_PIECE, -1, 72, true, _T("\u6fc0\u5149\u65b9\u5757"), _T("\u7279\u6b8a"), _T("\u63d0\u9ad8\u6fc0\u5149\u65b9\u5757\u51fa\u73b0\u6982\u7387\uff0c\u843d\u5730\u540e\u6e05\u9664\u6240\u5728\u6574\u5217\u3002") },
|
|
{ UPGRADE_THUNDER_TETRIS, 1, 94, false, _T("\u96f7\u9706\u56db\u6d88"), _T("\u8fdb\u9636"), _T("\u6bcf\u6b21\u5b8c\u6210\u56db\u6d88\u65f6\uff0c\u989d\u5916\u6e05\u9664\u968f\u673a 2 \u884c\u3002") },
|
|
{ UPGRADE_THUNDER_LASER, 1, 112, false, _T("\u96f7\u9706\u6fc0\u5149"), _T("\u8fdb\u5316"), _T("\u56db\u6d88\u65f6\u989d\u5916\u53d1\u5c04 2 \u9053\u6fc0\u5149\uff0c\u968f\u673a\u6e05\u9664 2 \u5217\u5e76\u83b7\u5f97 EXP\u3002") },
|
|
{ UPGRADE_FEVER_MODE, 1, 84, false, _T("\u72c2\u70ed\u6a21\u5f0f"), _T("\u8fdb\u9636"), _T("\u7d2f\u8ba1\u6d88\u884c 20 \u884c\u540e\u8fdb\u5165 10 \u79d2\u72c2\u70ed\u72b6\u6001\u3002") },
|
|
{ UPGRADE_RAGE_STACK, 1, 84, false, _T("\u66b4\u8d70\u5806\u53e0"), _T("\u8fdb\u9636"), _T("\u8fde\u7eed\u6d88\u884c\u8d8a\u591a\uff0c\u5f97\u5206\u500d\u7387\u8ffd\u52a0\u8d8a\u9ad8\u3002") },
|
|
{ UPGRADE_INFINITE_FEVER, 1, 110, false, _T("\u65e0\u9650\u72c2\u70ed"), _T("\u8fdb\u5316"), _T("\u72c2\u70ed\u671f\u95f4\u6d88\u884c\u53ef\u5ef6\u957f\u65f6\u95f4\uff0c\u8fde\u51fb\u8d8a\u9ad8\u500d\u7387\u8d8a\u5f3a\u3002") },
|
|
{ UPGRADE_SCREEN_BOMB, 1, 78, false, _T("\u6e05\u5c4f\u70b8\u5f39"), _T("\u8fdb\u9636"), _T("\u7d2f\u8ba1\u6d88\u884c 30 \u884c\u540e\u83b7\u5f97 1 \u6b21\u6e05\u5c4f\u70b8\u5f39\uff0c\u53ef\u81ea\u52a8\u6216\u4e3b\u52a8\u6e05\u9664\u5e95\u90e8 5 \u884c\u3002") },
|
|
{ UPGRADE_TERMINAL_CLEAR, 1, 108, false, _T("\u7ec8\u672b\u6e05\u573a"), _T("\u8fdb\u5316"), _T("\u6fc0\u6d3b\u6700\u540e\u4e00\u640f\u65f6\u81ea\u52a8\u91ca\u653e\u4e00\u6b21\u6e05\u5c4f\u70b8\u5f39\uff0c\u5e76\u8fdb\u5165 10 \u79d2\u72c2\u70ed\u3002") },
|
|
{ UPGRADE_DUAL_CHOICE, 1, 68, false, _T("\u53cc\u91cd\u9009\u62e9"), _T("\u8fdb\u9636"), _T("\u6bcf\u6b21\u5347\u7ea7\u53ef\u989d\u5916\u518d\u9009 1 \u4e2a\u5f3a\u5316\uff0c\u4f46\u4e0b\u4e00\u6b21\u5347\u7ea7\u9700\u6c42 +30%\u3002") },
|
|
{ UPGRADE_DESTINY_WHEEL, 1, 104, false, _T("\u547d\u8fd0\u8f6e\u76d8"), _T("\u8fdb\u5316"), _T("\u6bcf\u6b21\u5347\u7ea7\u51fa\u73b0 5 \u4e2a\u9009\u9879\uff0c\u53ef\u9009 2 \u4e2a\uff0c\u4f46\u5176\u4e2d 1 \u4e2a\u9644\u5e26\u8d1f\u9762\u6548\u679c\u3002") },
|
|
{ UPGRADE_PERFECT_ROTATE, 1, 82, false, _T("\u5b8c\u7f8e\u65cb\u8f6c"), _T("\u64cd\u4f5c"), _T("\u65cb\u8f6c\u5931\u8d25\u65f6\u81ea\u52a8\u5c1d\u8bd5\u5de6\u53f3\u5404\u504f\u79fb 1 \u683c\u8fdb\u884c\u4fee\u6b63\u3002") },
|
|
{ UPGRADE_TIME_DILATION, 1, 80, false, _T("\u65f6\u95f4\u7f13\u6d41"), _T("\u4fdd\u547d"), _T("\u76d8\u9762\u63a5\u8fd1\u9876\u7aef\u65f6\u81ea\u52a8\u964d\u4f4e\u4e0b\u843d\u901f\u5ea6\uff0c\u4e3a\u8865\u6551\u7559\u51fa\u53cd\u5e94\u7a7a\u95f4\u3002") },
|
|
{ UPGRADE_HIGH_PRESSURE, 1, 70, false, _T("\u9ad8\u538b\u5956\u52b1"), _T("\u98ce\u9669"), _T("\u4e0b\u843d\u901f\u5ea6\u63d0\u9ad8 15%\uff0c\u4f46\u5f97\u5206\u4e0e EXP \u989d\u5916\u63d0\u9ad8 50%\u3002") },
|
|
{ UPGRADE_TETRIS_GAMBLE, 1, 78, false, _T("\u8d4c\u547d\u56db\u6d88"), _T("\u98ce\u9669"), _T("\u666e\u901a 1~3 \u6d88\u6536\u76ca\u964d\u4f4e\uff0c\u4f46 4 \u6d88\u6536\u76ca\u66b4\u589e\u3002") },
|
|
{ UPGRADE_EXTREME_PLAYER, 1, 114, false, _T("\u6781\u9650\u73a9\u5bb6"), _T("\u8fdb\u5316"), _T("\u7ec4\u5408\u9ad8\u538b\u4e0e\u8d4c\u547d\u56db\u6d88\uff0c\u901f\u5ea6\u8fdb\u4e00\u6b65\u63d0\u9ad8\uff0c\u56db\u6d88\u540e\u77ed\u6682\u7f13\u901f\u3002") },
|
|
{ UPGRADE_UPGRADE_SHOCKWAVE, 1, 106, false, _T("\u5347\u7ea7\u51b2\u51fb\u6ce2"), _T("\u8fdb\u9636"), _T("\u5373\u5c06\u5347\u7ea7\u65f6\u81ea\u52a8\u6e05\u9664\u5e95\u90e8 2 \u884c\uff0c\u5f3a\u5316\u5347\u7ea7\u8282\u594f\u53cd\u9988\u3002") },
|
|
{ UPGRADE_EVOLUTION_IMPACT, 1, 118, false, _T("\u8fdb\u5316\u51b2\u51fb"), _T("\u8fdb\u5316"), _T("\u5347\u7ea7\u65f6\u6e05\u9664\u5e95\u90e8 3 \u884c\uff0c\u5e76\u83b7\u5f97 10 \u79d2\u53cc\u500d EXP\u3002") },
|
|
{ UPGRADE_CONTROL_MASTER, 1, 112, false, _T("\u64cd\u63a7\u5927\u5e08"), _T("\u8fdb\u5316"), _T("Hold \u540e\u77ed\u6682\u964d\u4f4e\u4e0b\u843d\u901f\u5ea6\uff0c\u5e76\u989d\u5916\u589e\u52a0 1 \u4e2a\u9884\u89c8\u65b9\u5757\u3002") },
|
|
{ UPGRADE_BLOCK_STORM, 1, 82, false, _T("\u65b9\u5757\u98ce\u66b4"), _T("\u723d\u611f"), _T("\u63a5\u4e0b\u6765 5 \u4e2a\u65b9\u5757\u5168\u90e8\u53d8\u6210 I \u5757\uff0c\u5feb\u901f\u5236\u9020\u56db\u6d88\u673a\u4f1a\u3002") },
|
|
{ UPGRADE_CROSS_PIECE, -1, 76, true, _T("\u5341\u5b57\u65b9\u5757"), _T("\u723d\u611f"), _T("\u63d0\u9ad8\u5341\u5b57\u65b9\u5757\u51fa\u73b0\u6982\u7387\uff0c\u843d\u5730\u540e\u6e05\u9664\u6240\u5728\u884c\u4e0e\u6240\u5728\u5217\u3002") },
|
|
{ UPGRADE_BLACK_HOLE, 1, 78, false, _T("\u9ed1\u6d1e"), _T("\u7279\u6b8a"), _T("\u83b7\u5f97 1 \u6b21\u4e3b\u52a8\u9ed1\u6d1e\uff0c\u91ca\u653e\u540e\u6e05\u9664\u68cb\u76d8\u4e0a\u6570\u91cf\u6700\u591a\u7684\u4e00\u79cd\u65b9\u5757\u3002") },
|
|
{ UPGRADE_AIR_RESHAPE, 1, 74, false, _T("\u7a7a\u4e2d\u6362\u5f62"), _T("\u64cd\u4f5c"), _T("\u83b7\u5f97 1 \u6b21\u4e3b\u52a8\u6362\u5f62\uff0c\u53ef\u5c06\u5f53\u524d\u65b9\u5757\u53d8\u4e3a I \u5757\u3002") },
|
|
{ UPGRADE_RAINBOW_PIECE, 1, 74, false, _T("\u5f69\u8679\u65b9\u5757"), _T("\u723d\u611f"), _T("\u6982\u7387\u751f\u6210\u5f69\u8679\u65b9\u5757\uff0c\u843d\u5730\u540e\u53ef\u81ea\u52a8\u8865\u5168\u884c\u5185\u7f3a\u53e3\uff0c\u66f4\u5bb9\u6613\u8865\u9f50\u6d88\u884c\u3002") },
|
|
{ UPGRADE_VOID_CORE, 1, 112, false, _T("\u865a\u7a7a\u6838\u5fc3"), _T("\u8fdb\u5316"), _T("\u9ed1\u6d1e\u540e\u989d\u5916\u751f\u6210 1 \u4e2a\u5f69\u8679\u65b9\u5757\uff0c\u5f69\u8679\u6d88\u884c\u65f6\u89e6\u53d1\u5c0f\u578b\u9ed1\u6d1e\u3002") },
|
|
{ UPGRADE_STABLE_STRUCTURE, -1, 72, true, _T("\u7a33\u5b9a\u7ed3\u6784"), _T("\u7279\u6b8a"), _T("\u843d\u5730\u540e\u5c0f\u6982\u7387\u81ea\u52a8\u586b\u8865\u90bb\u8fd1\u7a7a\u6d1e\uff0c\u63d0\u9ad8\u76d8\u9762\u7ed3\u6784\u7a33\u5b9a\u6027\u3002") },
|
|
{ UPGRADE_DOUBLE_GROWTH, 1, 84, false, _T("\u6210\u957f\u6838\u5fc3"), _T("\u6210\u957f"), _T("\u6c38\u4e45\u83b7\u5f97 +15% \u5f97\u5206\u4e0e +15% EXP\uff0c\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\u3002") },
|
|
{ UPGRADE_PIECE_TUNING, -1, 64, true, _T("\u65b9\u5757\u6539\u9020"), _T("\u7279\u6b8a"), _T("\u9009\u62e9\u4e00\u79cd\u65b9\u5757\uff0c\u964d\u4f4e\u5176\u540e\u7eed\u51fa\u73b0\u6982\u7387\u3002") },
|
|
{ UPGRADE_GAMBLER, -1, 64, true, _T("\u8d4c\u5f92"), _T("\u7279\u6b8a"), _T("\u9009\u62e9\u5f3a\u5316\u65f6\uff0c\u6709\u6982\u7387\u53cc\u500d\u751f\u6548\uff0c\u4e5f\u6709\u6982\u7387\u5b8c\u5168\u843d\u7a7a\u3002") }
|
|
};
|
|
|
|
static constexpr int kUpgradePoolSize = sizeof(kUpgradePool) / sizeof(kUpgradePool[0]);
|
|
static int GetTopOccupiedRow();
|
|
|
|
int bricks[7][4][4][4] =
|
|
{
|
|
{
|
|
{{0, 0, 0, 0}, {0, 0, 0, 0}, {1, 1, 1, 1}, {0, 0, 0, 0}},
|
|
{{0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0}},
|
|
{{0, 0, 0, 0}, {0, 0, 0, 0}, {1, 1, 1, 1}, {0, 0, 0, 0}},
|
|
{{0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0}}
|
|
},
|
|
{
|
|
{{0, 0, 0, 0}, {0, 0, 2, 0}, {0, 2, 2, 2}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 0, 2, 0}, {0, 0, 2, 2}, {0, 0, 2, 0}},
|
|
{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 2, 2, 2}, {0, 0, 2, 0}},
|
|
{{0, 0, 0, 0}, {0, 0, 2, 0}, {0, 2, 2, 0}, {0, 0, 2, 0}}
|
|
},
|
|
{
|
|
{{0, 3, 0, 0}, {0, 3, 0, 0}, {0, 3, 3, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {3, 3, 3, 0}, {3, 0, 0, 0}, {0, 0, 0, 0}},
|
|
{{3, 3, 0, 0}, {0, 3, 0, 0}, {0, 3, 0, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 3, 0}, {3, 3, 3, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}
|
|
},
|
|
{
|
|
{{0, 0, 4, 0}, {0, 0, 4, 0}, {0, 4, 4, 0}, {0, 0, 0, 0}},
|
|
{{0, 4, 0, 0}, {0, 4, 4, 4}, {0, 0, 0, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 4, 4}, {0, 0, 4, 0}, {0, 0, 4, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 4, 4, 4}, {0, 0, 0, 4}, {0, 0, 0, 0}}
|
|
},
|
|
{
|
|
{{0, 0, 0, 0}, {0, 5, 5, 0}, {0, 5, 5, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 5, 5, 0}, {0, 5, 5, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 5, 5, 0}, {0, 5, 5, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 5, 5, 0}, {0, 5, 5, 0}, {0, 0, 0, 0}}
|
|
},
|
|
{
|
|
{{0, 6, 0, 0}, {0, 6, 6, 0}, {0, 0, 6, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 6, 6, 0}, {6, 6, 0, 0}, {0, 0, 0, 0}},
|
|
{{6, 0, 0, 0}, {6, 6, 0, 0}, {0, 6, 0, 0}, {0, 0, 0, 0}},
|
|
{{0, 6, 6, 0}, {6, 6, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}
|
|
},
|
|
{
|
|
{{0, 0, 7, 0}, {0, 7, 7, 0}, {0, 7, 0, 0}, {0, 0, 0, 0}},
|
|
{{0, 7, 7, 0}, {0, 0, 7, 7}, {0, 0, 0, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 7}, {0, 0, 7, 7}, {0, 0, 7, 0}, {0, 0, 0, 0}},
|
|
{{0, 0, 0, 0}, {0, 7, 7, 0}, {0, 0, 7, 7}, {0, 0, 0, 0}}
|
|
}
|
|
};
|
|
|
|
COLORREF BrickColor[7] =
|
|
{
|
|
RGB(244, 144, 165),
|
|
RGB(255, 181, 197),
|
|
RGB(170, 215, 255),
|
|
RGB(134, 230, 220),
|
|
RGB(255, 187, 143),
|
|
RGB(255, 223, 146),
|
|
RGB(197, 170, 255)
|
|
};
|
|
|
|
/**
|
|
* @brief 计算指定方块在指定旋转状态下的最小包围盒边界。
|
|
*
|
|
* 该函数会遍历 4x4 形状矩阵，找出所有非空单元的上下左右边界，
|
|
* 供后续统一计算生成位置和对齐方式时使用。
|
|
*
|
|
* @param brickType 方块类型编号。
|
|
* @param brickState 方块旋转状态编号。
|
|
* @param minRow 返回最上方非空行号。
|
|
* @param maxRow 返回最下方非空行号。
|
|
* @param minCol 返回最左侧非空列号。
|
|
* @param maxCol 返回最右侧非空列号。
|
|
*/
|
|
static void GetBrickBounds(int brickType, int brickState, int& minRow, int& maxRow, int& minCol, int& maxCol)
|
|
{
|
|
minRow = 4;
|
|
maxRow = -1;
|
|
minCol = 4;
|
|
maxCol = -1;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
if (bricks[brickType][brickState][i][j] != 0)
|
|
{
|
|
if (i < minRow)
|
|
{
|
|
minRow = i;
|
|
}
|
|
if (i > maxRow)
|
|
{
|
|
maxRow = i;
|
|
}
|
|
if (j < minCol)
|
|
{
|
|
minCol = j;
|
|
}
|
|
if (j > maxCol)
|
|
{
|
|
maxCol = j;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 计算指定方块的统一生成位置。
|
|
*
|
|
* 该函数会根据方块在初始旋转状态下的最小包围盒，
|
|
* 自动把方块水平居中到游戏区附近，并将顶部非空行对齐到可视区域顶部。
|
|
* 这样不同形状的方块在生成时看起来会更加统一。
|
|
*
|
|
* @param brickType 方块类型编号。
|
|
* @return Point 计算得到的生成坐标。
|
|
*/
|
|
static Point GetSpawnPoint(int brickType)
|
|
{
|
|
int minRow, maxRow, minCol, maxCol;
|
|
GetBrickBounds(brickType, 0, minRow, maxRow, minCol, maxCol);
|
|
|
|
int brickWidth = maxCol - minCol + 1;
|
|
int brickHeight = maxRow - minRow + 1;
|
|
Point spawnPoint;
|
|
spawnPoint.x = (nGameWidth - brickWidth) / 2 - minCol;
|
|
spawnPoint.y = -brickHeight;
|
|
|
|
return spawnPoint;
|
|
}
|
|
|
|
static void ResetPlayerStats(PlayerStats& stats, bool useRogueRules)
|
|
{
|
|
stats.score = 0;
|
|
stats.level = 1;
|
|
stats.exp = 0;
|
|
stats.requiredExp = useRogueRules ? 30 : 0;
|
|
stats.totalLinesCleared = 0;
|
|
stats.scoreMultiplierPercent = 100;
|
|
stats.expMultiplierPercent = 100;
|
|
stats.slowFallStacks = 0;
|
|
stats.comboBonusStacks = 0;
|
|
stats.comboChain = 0;
|
|
stats.previewCount = 1;
|
|
stats.lastChanceCount = 0;
|
|
stats.scoreUpgradeLevel = 0;
|
|
stats.expUpgradeLevel = 0;
|
|
stats.previewUpgradeLevel = 0;
|
|
stats.lastChanceUpgradeLevel = 0;
|
|
stats.holdUnlocked = 0;
|
|
stats.pressureReliefLevel = 0;
|
|
stats.sweeperLevel = 0;
|
|
stats.sweeperCharge = 0;
|
|
stats.explosiveLevel = 0;
|
|
stats.explosivePieceCounter = 0;
|
|
stats.chainBlastLevel = 0;
|
|
stats.chainBombLevel = 0;
|
|
stats.laserLevel = 0;
|
|
stats.thunderTetrisLevel = 0;
|
|
stats.thunderLaserLevel = 0;
|
|
stats.feverLevel = 0;
|
|
stats.rageStackLevel = 0;
|
|
stats.infiniteFeverLevel = 0;
|
|
stats.feverLineCharge = 0;
|
|
stats.feverTicks = 0;
|
|
stats.screenBombLevel = 0;
|
|
stats.screenBombCharge = 0;
|
|
stats.screenBombCount = 0;
|
|
stats.terminalClearLevel = 0;
|
|
stats.dualChoiceLevel = 0;
|
|
stats.destinyWheelLevel = 0;
|
|
stats.perfectRotateLevel = 0;
|
|
stats.timeDilationLevel = 0;
|
|
stats.highPressureLevel = 0;
|
|
stats.tetrisGambleLevel = 0;
|
|
stats.extremePlayerLevel = 0;
|
|
stats.extremeSlowTicks = 0;
|
|
stats.upgradeShockwaveLevel = 0;
|
|
stats.evolutionImpactLevel = 0;
|
|
stats.controlMasterLevel = 0;
|
|
stats.holdSlowTicks = 0;
|
|
stats.blockStormLevel = 0;
|
|
stats.blockStormPiecesRemaining = 0;
|
|
stats.blackHoleLevel = 0;
|
|
stats.blackHoleCharges = 0;
|
|
stats.reshapeLevel = 0;
|
|
stats.reshapeCharges = 0;
|
|
stats.rainbowPieceLevel = 0;
|
|
stats.voidCoreLevel = 0;
|
|
stats.pendingRainbowPieceCount = 0;
|
|
stats.stableStructureLevel = 0;
|
|
stats.doubleGrowthLevel = 0;
|
|
stats.gamblerLevel = 0;
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
stats.pieceTuningLevels[i] = 0;
|
|
}
|
|
}
|
|
|
|
static int GetNextPreviewLimit()
|
|
{
|
|
if (currentMode != MODE_ROGUE)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (rogueStats.previewCount < 1)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (rogueStats.previewCount > 3)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
return rogueStats.previewCount;
|
|
}
|
|
|
|
static int GetUpgradeCurrentLevel(int upgradeId)
|
|
{
|
|
switch (upgradeId)
|
|
{
|
|
case UPGRADE_SCORE_MULTIPLIER:
|
|
return rogueStats.scoreUpgradeLevel;
|
|
case UPGRADE_EXP_MULTIPLIER:
|
|
return rogueStats.expUpgradeLevel;
|
|
case UPGRADE_SLOW_FALL:
|
|
return rogueStats.slowFallStacks;
|
|
case UPGRADE_COMBO_BONUS:
|
|
return rogueStats.comboBonusStacks;
|
|
case UPGRADE_PREVIEW_PLUS_ONE:
|
|
return rogueStats.previewUpgradeLevel;
|
|
case UPGRADE_LAST_CHANCE:
|
|
return rogueStats.lastChanceUpgradeLevel;
|
|
case UPGRADE_HOLD_UNLOCK:
|
|
return rogueStats.holdUnlocked;
|
|
case UPGRADE_PRESSURE_RELIEF:
|
|
return rogueStats.pressureReliefLevel;
|
|
case UPGRADE_SWEEPER:
|
|
return rogueStats.sweeperLevel;
|
|
case UPGRADE_EXPLOSIVE_PIECE:
|
|
return rogueStats.explosiveLevel;
|
|
case UPGRADE_CHAIN_BLAST:
|
|
return rogueStats.chainBlastLevel;
|
|
case UPGRADE_CHAIN_BOMB:
|
|
return rogueStats.chainBombLevel;
|
|
case UPGRADE_LASER_PIECE:
|
|
return rogueStats.laserLevel;
|
|
case UPGRADE_THUNDER_TETRIS:
|
|
return rogueStats.thunderTetrisLevel;
|
|
case UPGRADE_THUNDER_LASER:
|
|
return rogueStats.thunderLaserLevel;
|
|
case UPGRADE_FEVER_MODE:
|
|
return rogueStats.feverLevel;
|
|
case UPGRADE_RAGE_STACK:
|
|
return rogueStats.rageStackLevel;
|
|
case UPGRADE_INFINITE_FEVER:
|
|
return rogueStats.infiniteFeverLevel;
|
|
case UPGRADE_SCREEN_BOMB:
|
|
return rogueStats.screenBombLevel;
|
|
case UPGRADE_TERMINAL_CLEAR:
|
|
return rogueStats.terminalClearLevel;
|
|
case UPGRADE_DUAL_CHOICE:
|
|
return rogueStats.dualChoiceLevel;
|
|
case UPGRADE_DESTINY_WHEEL:
|
|
return rogueStats.destinyWheelLevel;
|
|
case UPGRADE_PERFECT_ROTATE:
|
|
return rogueStats.perfectRotateLevel;
|
|
case UPGRADE_TIME_DILATION:
|
|
return rogueStats.timeDilationLevel;
|
|
case UPGRADE_HIGH_PRESSURE:
|
|
return rogueStats.highPressureLevel;
|
|
case UPGRADE_TETRIS_GAMBLE:
|
|
return rogueStats.tetrisGambleLevel;
|
|
case UPGRADE_EXTREME_PLAYER:
|
|
return rogueStats.extremePlayerLevel;
|
|
case UPGRADE_UPGRADE_SHOCKWAVE:
|
|
return rogueStats.upgradeShockwaveLevel;
|
|
case UPGRADE_EVOLUTION_IMPACT:
|
|
return rogueStats.evolutionImpactLevel;
|
|
case UPGRADE_CONTROL_MASTER:
|
|
return rogueStats.controlMasterLevel;
|
|
case UPGRADE_BLOCK_STORM:
|
|
return rogueStats.blockStormLevel;
|
|
case UPGRADE_CROSS_PIECE:
|
|
return rogueStats.crossPieceLevel;
|
|
case UPGRADE_BLACK_HOLE:
|
|
return rogueStats.blackHoleLevel;
|
|
case UPGRADE_AIR_RESHAPE:
|
|
return rogueStats.reshapeLevel;
|
|
case UPGRADE_RAINBOW_PIECE:
|
|
return rogueStats.rainbowPieceLevel;
|
|
case UPGRADE_VOID_CORE:
|
|
return rogueStats.voidCoreLevel;
|
|
case UPGRADE_STABLE_STRUCTURE:
|
|
return rogueStats.stableStructureLevel;
|
|
case UPGRADE_DOUBLE_GROWTH:
|
|
return rogueStats.doubleGrowthLevel;
|
|
case UPGRADE_GAMBLER:
|
|
return rogueStats.gamblerLevel;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int GetUpgradeDynamicWeight(const UpgradeEntry& entry)
|
|
{
|
|
int weight = entry.baseWeight;
|
|
int currentLevel = GetUpgradeCurrentLevel(entry.id);
|
|
int topOccupiedRow = GetTopOccupiedRow();
|
|
bool boardIsDangerous = (topOccupiedRow >= 0 && topOccupiedRow <= 6);
|
|
bool boardIsStable = (topOccupiedRow < 0 || topOccupiedRow >= 12);
|
|
|
|
if (entry.repeatable)
|
|
{
|
|
weight -= currentLevel * 8;
|
|
}
|
|
else if (currentLevel > 0)
|
|
{
|
|
weight = 0;
|
|
}
|
|
|
|
switch (entry.id)
|
|
{
|
|
case UPGRADE_SCORE_MULTIPLIER:
|
|
if (rogueStats.level >= 4)
|
|
{
|
|
weight += 8;
|
|
}
|
|
break;
|
|
case UPGRADE_EXP_MULTIPLIER:
|
|
if (rogueStats.level <= 5)
|
|
{
|
|
weight += 16;
|
|
}
|
|
break;
|
|
case UPGRADE_SLOW_FALL:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 22;
|
|
}
|
|
break;
|
|
case UPGRADE_COMBO_BONUS:
|
|
if (rogueStats.comboChain >= 2)
|
|
{
|
|
weight += 18;
|
|
}
|
|
break;
|
|
case UPGRADE_PREVIEW_PLUS_ONE:
|
|
if (boardIsStable)
|
|
{
|
|
weight += 10;
|
|
}
|
|
break;
|
|
case UPGRADE_LAST_CHANCE:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 30;
|
|
}
|
|
break;
|
|
case UPGRADE_HOLD_UNLOCK:
|
|
if (rogueStats.holdUnlocked == 0 && rogueStats.level <= 6)
|
|
{
|
|
weight += 14;
|
|
}
|
|
break;
|
|
case UPGRADE_PRESSURE_RELIEF:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 26;
|
|
}
|
|
break;
|
|
case UPGRADE_SWEEPER:
|
|
if (rogueStats.totalLinesCleared >= 8)
|
|
{
|
|
weight += 12;
|
|
}
|
|
break;
|
|
case UPGRADE_EXPLOSIVE_PIECE:
|
|
if (rogueStats.explosiveLevel == 0)
|
|
{
|
|
weight += 12;
|
|
}
|
|
break;
|
|
case UPGRADE_CHAIN_BLAST:
|
|
weight += rogueStats.explosiveLevel * 20;
|
|
break;
|
|
case UPGRADE_CHAIN_BOMB:
|
|
weight += 28;
|
|
break;
|
|
case UPGRADE_LASER_PIECE:
|
|
if (rogueStats.laserLevel == 0)
|
|
{
|
|
weight += 10;
|
|
}
|
|
break;
|
|
case UPGRADE_THUNDER_TETRIS:
|
|
weight += rogueStats.laserLevel * 18;
|
|
break;
|
|
case UPGRADE_THUNDER_LASER:
|
|
weight += 28;
|
|
break;
|
|
case UPGRADE_FEVER_MODE:
|
|
if (rogueStats.totalLinesCleared >= 10)
|
|
{
|
|
weight += 14;
|
|
}
|
|
break;
|
|
case UPGRADE_RAGE_STACK:
|
|
if (rogueStats.comboBonusStacks > 0 || rogueStats.comboChain >= 2)
|
|
{
|
|
weight += 18;
|
|
}
|
|
break;
|
|
case UPGRADE_INFINITE_FEVER:
|
|
if (rogueStats.feverLevel > 0 && rogueStats.rageStackLevel > 0)
|
|
{
|
|
weight += 34;
|
|
}
|
|
break;
|
|
case UPGRADE_SCREEN_BOMB:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 18;
|
|
}
|
|
break;
|
|
case UPGRADE_TERMINAL_CLEAR:
|
|
weight += 34;
|
|
break;
|
|
case UPGRADE_DUAL_CHOICE:
|
|
if (rogueStats.level <= 6)
|
|
{
|
|
weight += 10;
|
|
}
|
|
break;
|
|
case UPGRADE_DESTINY_WHEEL:
|
|
weight += 30;
|
|
break;
|
|
case UPGRADE_PERFECT_ROTATE:
|
|
if (rogueStats.holdUnlocked == 0 || boardIsDangerous)
|
|
{
|
|
weight += 14;
|
|
}
|
|
break;
|
|
case UPGRADE_TIME_DILATION:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 24;
|
|
}
|
|
break;
|
|
case UPGRADE_HIGH_PRESSURE:
|
|
if (boardIsStable && rogueStats.level >= 3)
|
|
{
|
|
weight += 18;
|
|
}
|
|
break;
|
|
case UPGRADE_TETRIS_GAMBLE:
|
|
if (rogueStats.level >= 4)
|
|
{
|
|
weight += 14;
|
|
}
|
|
break;
|
|
case UPGRADE_EXTREME_PLAYER:
|
|
weight += 36;
|
|
break;
|
|
case UPGRADE_UPGRADE_SHOCKWAVE:
|
|
weight += 34;
|
|
break;
|
|
case UPGRADE_EVOLUTION_IMPACT:
|
|
weight += 40;
|
|
break;
|
|
case UPGRADE_CONTROL_MASTER:
|
|
weight += 34;
|
|
break;
|
|
case UPGRADE_BLOCK_STORM:
|
|
if (rogueStats.tetrisGambleLevel > 0 || rogueStats.thunderTetrisLevel > 0)
|
|
{
|
|
weight += 20;
|
|
}
|
|
break;
|
|
case UPGRADE_CROSS_PIECE:
|
|
if (rogueStats.laserLevel > 0 || rogueStats.feverLevel > 0)
|
|
{
|
|
weight += 14;
|
|
}
|
|
break;
|
|
case UPGRADE_BLACK_HOLE:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 18;
|
|
}
|
|
break;
|
|
case UPGRADE_AIR_RESHAPE:
|
|
if (boardIsDangerous || rogueStats.tetrisGambleLevel > 0)
|
|
{
|
|
weight += 18;
|
|
}
|
|
break;
|
|
case UPGRADE_RAINBOW_PIECE:
|
|
if (boardIsDangerous || rogueStats.totalLinesCleared >= 8)
|
|
{
|
|
weight += 16;
|
|
}
|
|
break;
|
|
case UPGRADE_VOID_CORE:
|
|
weight += 30;
|
|
break;
|
|
case UPGRADE_STABLE_STRUCTURE:
|
|
if (boardIsDangerous)
|
|
{
|
|
weight += 14;
|
|
}
|
|
break;
|
|
case UPGRADE_DOUBLE_GROWTH:
|
|
if (rogueStats.level >= 3)
|
|
{
|
|
weight += 12;
|
|
}
|
|
break;
|
|
case UPGRADE_PIECE_TUNING:
|
|
if (rogueStats.level >= 4)
|
|
{
|
|
weight += 8;
|
|
}
|
|
break;
|
|
case UPGRADE_GAMBLER:
|
|
if (rogueStats.level >= 5)
|
|
{
|
|
weight += 10;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (weight < 1)
|
|
{
|
|
weight = 1;
|
|
}
|
|
|
|
return weight;
|
|
}
|
|
|
|
static const TCHAR* GetPieceShortName(int pieceType)
|
|
{
|
|
static const TCHAR* kPieceNames[7] =
|
|
{
|
|
_T("I"),
|
|
_T("T"),
|
|
_T("L"),
|
|
_T("J"),
|
|
_T("O"),
|
|
_T("S"),
|
|
_T("Z")
|
|
};
|
|
|
|
if (pieceType < 0 || pieceType >= 7)
|
|
{
|
|
return _T("?");
|
|
}
|
|
|
|
return kPieceNames[pieceType];
|
|
}
|
|
|
|
static bool IsUpgradeSelectable(const UpgradeEntry& entry)
|
|
{
|
|
if (entry.id == UPGRADE_CHAIN_BLAST)
|
|
{
|
|
return rogueStats.explosiveLevel > 0 && rogueStats.chainBlastLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_CHAIN_BOMB)
|
|
{
|
|
return rogueStats.explosiveLevel > 0 && rogueStats.chainBlastLevel > 0 && rogueStats.chainBombLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_THUNDER_TETRIS)
|
|
{
|
|
return rogueStats.laserLevel > 0 && rogueStats.thunderTetrisLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_THUNDER_LASER)
|
|
{
|
|
return rogueStats.laserLevel > 0 && rogueStats.thunderTetrisLevel > 0 && rogueStats.thunderLaserLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_FEVER_MODE)
|
|
{
|
|
return rogueStats.feverLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_RAGE_STACK)
|
|
{
|
|
return rogueStats.rageStackLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_INFINITE_FEVER)
|
|
{
|
|
return rogueStats.feverLevel > 0 && rogueStats.rageStackLevel > 0 && rogueStats.infiniteFeverLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_SCREEN_BOMB)
|
|
{
|
|
return rogueStats.screenBombLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_TERMINAL_CLEAR)
|
|
{
|
|
return rogueStats.screenBombLevel > 0 && rogueStats.lastChanceUpgradeLevel > 0 && rogueStats.terminalClearLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_DUAL_CHOICE)
|
|
{
|
|
return rogueStats.dualChoiceLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_DESTINY_WHEEL)
|
|
{
|
|
return rogueStats.gamblerLevel > 0 && rogueStats.dualChoiceLevel > 0 && rogueStats.destinyWheelLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_EXTREME_PLAYER)
|
|
{
|
|
return rogueStats.highPressureLevel > 0 && rogueStats.tetrisGambleLevel > 0 && rogueStats.extremePlayerLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_UPGRADE_SHOCKWAVE)
|
|
{
|
|
return rogueStats.scoreUpgradeLevel > 0 &&
|
|
rogueStats.expUpgradeLevel > 0 &&
|
|
rogueStats.pressureReliefLevel > 0 &&
|
|
rogueStats.upgradeShockwaveLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_EVOLUTION_IMPACT)
|
|
{
|
|
return rogueStats.upgradeShockwaveLevel > 0 &&
|
|
rogueStats.doubleGrowthLevel > 0 &&
|
|
rogueStats.evolutionImpactLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_CONTROL_MASTER)
|
|
{
|
|
return rogueStats.perfectRotateLevel > 0 &&
|
|
rogueStats.holdUnlocked > 0 &&
|
|
rogueStats.controlMasterLevel == 0;
|
|
}
|
|
|
|
if (entry.id == UPGRADE_VOID_CORE)
|
|
{
|
|
return rogueStats.blackHoleLevel > 0 &&
|
|
rogueStats.rainbowPieceLevel > 0 &&
|
|
rogueStats.voidCoreLevel == 0;
|
|
}
|
|
|
|
if (entry.repeatable)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (entry.maxLevel <= 0)
|
|
{
|
|
return GetUpgradeCurrentLevel(entry.id) == 0;
|
|
}
|
|
|
|
return GetUpgradeCurrentLevel(entry.id) < entry.maxLevel;
|
|
}
|
|
|
|
static void SetFeedbackMessage(const TCHAR* title, const TCHAR* detail, int ticks)
|
|
{
|
|
feedbackState.visibleTicks = ticks;
|
|
lstrcpyn(feedbackState.title, title, sizeof(feedbackState.title) / sizeof(TCHAR));
|
|
lstrcpyn(feedbackState.detail, detail, sizeof(feedbackState.detail) / sizeof(TCHAR));
|
|
}
|
|
|
|
static bool IsPiecePlacementValid(int pieceType, int pieceState, Point position)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
if (bricks[pieceType][pieceState][i][j] == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
int checkY = position.y + i;
|
|
int checkX = position.x + j;
|
|
|
|
if (checkX < 0 || checkX >= nGameWidth || checkY >= nGameHeight)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (checkY >= 0 && workRegion[checkY][checkX] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int GetTopOccupiedRow()
|
|
{
|
|
for (int i = 0; i < nGameHeight; i++)
|
|
{
|
|
for (int j = 0; j < nGameWidth; j++)
|
|
{
|
|
if (workRegion[i][j] != 0)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int GetSweeperThreshold()
|
|
{
|
|
int reduction = (rogueStats.sweeperLevel - 1) * 2;
|
|
int threshold = 8 - reduction;
|
|
return threshold < 3 ? 3 : threshold;
|
|
}
|
|
|
|
static bool RollExplosivePiece()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.explosiveLevel <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (rogueStats.explosivePieceCounter < 10)
|
|
{
|
|
rogueStats.explosivePieceCounter++;
|
|
}
|
|
|
|
if (rogueStats.explosivePieceCounter < 10)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
rogueStats.explosivePieceCounter = 0;
|
|
return true;
|
|
}
|
|
|
|
static bool RollLaserPiece()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.laserLevel <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int chancePercent = 10 + (rogueStats.laserLevel - 1) * 8;
|
|
if (chancePercent > 35)
|
|
{
|
|
chancePercent = 35;
|
|
}
|
|
|
|
return (rand() % 100) < chancePercent;
|
|
}
|
|
|
|
static bool RollCrossPiece()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.crossPieceLevel <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int chancePercent = 8 + (rogueStats.crossPieceLevel - 1) * 6;
|
|
if (chancePercent > 28)
|
|
{
|
|
chancePercent = 28;
|
|
}
|
|
|
|
return (rand() % 100) < chancePercent;
|
|
}
|
|
|
|
static bool RollRainbowPiece()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.rainbowPieceLevel <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int chancePercent = 12;
|
|
return (rand() % 100) < chancePercent;
|
|
}
|
|
|
|
static bool IsRainbowBoardCell(int cellValue)
|
|
{
|
|
return cellValue == 8;
|
|
}
|
|
|
|
static int TriggerMiniBlackHole(int maxCellsToClear)
|
|
{
|
|
int blockCounts[8] = { 0 };
|
|
|
|
for (int y = 0; y < nGameHeight; y++)
|
|
{
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
int cell = workRegion[y][x];
|
|
if (cell >= 1 && cell <= 7)
|
|
{
|
|
blockCounts[cell]++;
|
|
}
|
|
}
|
|
}
|
|
|
|
int targetBlock = 0;
|
|
int maxCount = 0;
|
|
for (int block = 1; block <= 7; block++)
|
|
{
|
|
if (blockCounts[block] > maxCount)
|
|
{
|
|
maxCount = blockCounts[block];
|
|
targetBlock = block;
|
|
}
|
|
}
|
|
|
|
if (targetBlock == 0 || maxCellsToClear <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int clearedCellCount = 0;
|
|
for (int y = nGameHeight - 1; y >= 0 && clearedCellCount < maxCellsToClear; y--)
|
|
{
|
|
for (int x = 0; x < nGameWidth && clearedCellCount < maxCellsToClear; x++)
|
|
{
|
|
if (workRegion[y][x] == targetBlock)
|
|
{
|
|
workRegion[y][x] = 0;
|
|
clearedCellCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static void RollCurrentPieceSpecialFlags(bool allowRandomSpecials)
|
|
{
|
|
if (!allowRandomSpecials)
|
|
{
|
|
currentPieceIsExplosive = false;
|
|
currentPieceIsLaser = false;
|
|
currentPieceIsCross = false;
|
|
currentPieceIsRainbow = false;
|
|
return;
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE && rogueStats.pendingRainbowPieceCount > 0)
|
|
{
|
|
rogueStats.pendingRainbowPieceCount--;
|
|
currentPieceIsExplosive = false;
|
|
currentPieceIsLaser = false;
|
|
currentPieceIsCross = false;
|
|
currentPieceIsRainbow = true;
|
|
return;
|
|
}
|
|
|
|
currentPieceIsExplosive = RollExplosivePiece();
|
|
currentPieceIsLaser = !currentPieceIsExplosive && RollLaserPiece();
|
|
currentPieceIsCross = !currentPieceIsExplosive && !currentPieceIsLaser && RollCrossPiece();
|
|
currentPieceIsRainbow = !currentPieceIsExplosive && !currentPieceIsLaser && !currentPieceIsCross && RollRainbowPiece();
|
|
}
|
|
|
|
static int ClearExplosiveAreaAt(int centerY, int centerX)
|
|
{
|
|
int radius = (currentMode == MODE_ROGUE && rogueStats.chainBombLevel > 0) ? 2 : 1;
|
|
int clearedCellCount = 0;
|
|
|
|
for (int y = centerY - radius; y <= centerY + radius; y++)
|
|
{
|
|
for (int x = centerX - radius; x <= centerX + radius; x++)
|
|
{
|
|
if (y >= 0 && y < nGameHeight && x >= 0 && x < nGameWidth)
|
|
{
|
|
if (workRegion[y][x] != 0)
|
|
{
|
|
clearedCellCount++;
|
|
workRegion[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static int ClearColumnAt(int column)
|
|
{
|
|
int clearedCellCount = 0;
|
|
|
|
if (column < 0 || column >= nGameWidth)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
for (int y = 0; y < nGameHeight; y++)
|
|
{
|
|
if (workRegion[y][column] != 0)
|
|
{
|
|
workRegion[y][column] = 0;
|
|
clearedCellCount++;
|
|
}
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static int ClearRowAt(int row)
|
|
{
|
|
int clearedCellCount = 0;
|
|
|
|
if (row < 0 || row >= nGameHeight)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
if (workRegion[row][x] != 0)
|
|
{
|
|
workRegion[row][x] = 0;
|
|
clearedCellCount++;
|
|
}
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static int TriggerRainbowRowCompletion(int minRow, int maxRow)
|
|
{
|
|
int filledCellCount = 0;
|
|
|
|
if (minRow < 0)
|
|
{
|
|
minRow = 0;
|
|
}
|
|
if (maxRow >= nGameHeight)
|
|
{
|
|
maxRow = nGameHeight - 1;
|
|
}
|
|
|
|
for (int row = minRow; row <= maxRow; row++)
|
|
{
|
|
int emptyCount = 0;
|
|
int emptyColumn = -1;
|
|
bool hasRainbowCell = false;
|
|
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
if (workRegion[row][x] == 0)
|
|
{
|
|
emptyCount++;
|
|
emptyColumn = x;
|
|
}
|
|
else if (IsRainbowBoardCell(workRegion[row][x]))
|
|
{
|
|
hasRainbowCell = true;
|
|
}
|
|
}
|
|
|
|
if (hasRainbowCell && emptyCount == 1 && emptyColumn >= 0)
|
|
{
|
|
workRegion[row][emptyColumn] = 8;
|
|
filledCellCount++;
|
|
}
|
|
}
|
|
|
|
return filledCellCount;
|
|
}
|
|
|
|
static int TriggerBlackHole()
|
|
{
|
|
int blockCounts[8] = { 0 };
|
|
for (int y = 0; y < nGameHeight; y++)
|
|
{
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
int cell = workRegion[y][x];
|
|
if (cell >= 1 && cell <= 7)
|
|
{
|
|
blockCounts[cell]++;
|
|
}
|
|
}
|
|
}
|
|
|
|
int targetBlock = 0;
|
|
int maxCount = 0;
|
|
for (int block = 1; block <= 7; block++)
|
|
{
|
|
if (blockCounts[block] > maxCount)
|
|
{
|
|
maxCount = blockCounts[block];
|
|
targetBlock = block;
|
|
}
|
|
}
|
|
|
|
if (targetBlock == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int clearedCellCount = 0;
|
|
for (int y = 0; y < nGameHeight; y++)
|
|
{
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
if (workRegion[y][x] == targetBlock)
|
|
{
|
|
workRegion[y][x] = 0;
|
|
clearedCellCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static int TriggerScreenBomb()
|
|
{
|
|
int clearedCellCount = 0;
|
|
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
int row = nGameHeight - 1 - i;
|
|
if (row < 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
if (workRegion[row][x] != 0)
|
|
{
|
|
clearedCellCount++;
|
|
}
|
|
}
|
|
|
|
DeleteOneLine(row);
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static int TriggerChainBlast(int lineAnchor)
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.chainBlastLevel <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int clearedCellCount = 0;
|
|
int blastCount = 2 + rogueStats.chainBlastLevel;
|
|
|
|
for (int blastIndex = 0; blastIndex < blastCount; blastIndex++)
|
|
{
|
|
int randomY = lineAnchor + (rand() % 3) - 1;
|
|
int randomX = rand() % nGameWidth;
|
|
|
|
if (randomY < 0)
|
|
{
|
|
randomY = 0;
|
|
}
|
|
if (randomY >= nGameHeight)
|
|
{
|
|
randomY = nGameHeight - 1;
|
|
}
|
|
|
|
if (workRegion[randomY][randomX] != 0)
|
|
{
|
|
workRegion[randomY][randomX] = 0;
|
|
clearedCellCount++;
|
|
}
|
|
}
|
|
|
|
return clearedCellCount;
|
|
}
|
|
|
|
static int RollNextPieceType()
|
|
{
|
|
if (currentMode == MODE_ROGUE && rogueStats.blockStormPiecesRemaining > 0)
|
|
{
|
|
rogueStats.blockStormPiecesRemaining--;
|
|
return 0;
|
|
}
|
|
|
|
int weights[7] = { 100, 100, 100, 100, 100, 100, 100 };
|
|
|
|
if (currentMode == MODE_ROGUE)
|
|
{
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
weights[i] -= rogueStats.pieceTuningLevels[i] * 20;
|
|
if (weights[i] < 20)
|
|
{
|
|
weights[i] = 20;
|
|
}
|
|
}
|
|
}
|
|
|
|
int totalWeight = 0;
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
totalWeight += weights[i];
|
|
}
|
|
|
|
int roll = rand() % totalWeight;
|
|
for (int i = 0; i < 7; i++)
|
|
{
|
|
if (roll < weights[i])
|
|
{
|
|
return i;
|
|
}
|
|
roll -= weights[i];
|
|
}
|
|
|
|
return rand() % 7;
|
|
}
|
|
|
|
static int TryStabilizeBoard()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.stableStructureLevel <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int triggerChance = 15 + (rogueStats.stableStructureLevel - 1) * 10;
|
|
if (triggerChance > 50)
|
|
{
|
|
triggerChance = 50;
|
|
}
|
|
|
|
if ((rand() % 100) >= triggerChance)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
for (int y = nGameHeight - 2; y >= 1; y--)
|
|
{
|
|
for (int x = 1; x < nGameWidth - 1; x++)
|
|
{
|
|
if (workRegion[y][x] != 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
bool hasSupportBelow = workRegion[y + 1][x] != 0;
|
|
bool hasLeftNeighbor = workRegion[y][x - 1] != 0;
|
|
bool hasRightNeighbor = workRegion[y][x + 1] != 0;
|
|
|
|
if (hasSupportBelow && hasLeftNeighbor && hasRightNeighbor)
|
|
{
|
|
int fillValue = workRegion[y + 1][x];
|
|
if (fillValue == 0)
|
|
{
|
|
fillValue = hasLeftNeighbor ? workRegion[y][x - 1] : workRegion[y][x + 1];
|
|
}
|
|
workRegion[y][x] = fillValue;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ResetNextQueue()
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
nextTypes[i] = RollNextPieceType();
|
|
}
|
|
}
|
|
|
|
static int ConsumeNextType()
|
|
{
|
|
int nextType = nextTypes[0];
|
|
nextTypes[0] = nextTypes[1];
|
|
nextTypes[1] = nextTypes[2];
|
|
nextTypes[2] = RollNextPieceType();
|
|
return nextType;
|
|
}
|
|
|
|
static int GetRogueScoreByLines(int linesCleared)
|
|
{
|
|
switch (linesCleared)
|
|
{
|
|
case 1: return 100;
|
|
case 2: return 300;
|
|
case 3: return 500;
|
|
case 4: return 800;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
static int GetRogueExpByLines(int linesCleared)
|
|
{
|
|
switch (linesCleared)
|
|
{
|
|
case 1: return 10;
|
|
case 2: return 25;
|
|
case 3: return 45;
|
|
case 4: return 80;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
static int ApplyLevelProgress(PlayerStats& stats)
|
|
{
|
|
int levelUps = 0;
|
|
|
|
while (stats.requiredExp > 0 && stats.exp >= stats.requiredExp)
|
|
{
|
|
stats.exp -= stats.requiredExp;
|
|
stats.level++;
|
|
stats.requiredExp = 20 + stats.level * 10;
|
|
levelUps++;
|
|
}
|
|
|
|
return levelUps;
|
|
}
|
|
|
|
static int TriggerUpgradeShockwave(int rowsToClear)
|
|
{
|
|
int clearedRows = 0;
|
|
|
|
for (int i = 0; i < rowsToClear; i++)
|
|
{
|
|
DeleteOneLine(nGameHeight - 1);
|
|
clearedRows++;
|
|
}
|
|
|
|
return clearedRows;
|
|
}
|
|
|
|
static void FillUpgradeOptions()
|
|
{
|
|
int selectableIndexes[kUpgradePoolSize] = { 0 };
|
|
int selectableWeights[kUpgradePoolSize] = { 0 };
|
|
int selectableCount = 0;
|
|
|
|
for (int i = 0; i < kUpgradePoolSize; i++)
|
|
{
|
|
if (IsUpgradeSelectable(kUpgradePool[i]))
|
|
{
|
|
selectableIndexes[selectableCount] = i;
|
|
selectableWeights[selectableCount] = GetUpgradeDynamicWeight(kUpgradePool[i]);
|
|
selectableCount++;
|
|
}
|
|
}
|
|
|
|
int optionLimit = (rogueStats.destinyWheelLevel > 0) ? 5 : 3;
|
|
int optionCount = selectableCount < optionLimit ? selectableCount : optionLimit;
|
|
upgradeUiState.optionCount = optionCount;
|
|
upgradeUiState.selectedIndex = 0;
|
|
upgradeUiState.picksRemaining = (rogueStats.dualChoiceLevel > 0 || rogueStats.destinyWheelLevel > 0) ? 2 : 1;
|
|
|
|
for (int i = 0; i < optionCount; i++)
|
|
{
|
|
int totalWeight = 0;
|
|
for (int weightIndex = 0; weightIndex < selectableCount; weightIndex++)
|
|
{
|
|
totalWeight += selectableWeights[weightIndex];
|
|
}
|
|
|
|
int pickSlot = 0;
|
|
if (totalWeight > 0)
|
|
{
|
|
int roll = rand() % totalWeight;
|
|
int accumulatedWeight = 0;
|
|
|
|
for (int weightIndex = 0; weightIndex < selectableCount; weightIndex++)
|
|
{
|
|
accumulatedWeight += selectableWeights[weightIndex];
|
|
if (roll < accumulatedWeight)
|
|
{
|
|
pickSlot = weightIndex;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int pickedIndex = selectableIndexes[pickSlot];
|
|
const UpgradeEntry& pickedEntry = kUpgradePool[pickedIndex];
|
|
|
|
upgradeUiState.options[i].id = pickedEntry.id;
|
|
upgradeUiState.options[i].currentLevel = GetUpgradeCurrentLevel(pickedEntry.id);
|
|
upgradeUiState.options[i].targetPieceType = -1;
|
|
upgradeUiState.options[i].cursed = false;
|
|
upgradeUiState.options[i].name = pickedEntry.name;
|
|
upgradeUiState.options[i].category = pickedEntry.category;
|
|
upgradeUiState.options[i].description = pickedEntry.description;
|
|
|
|
if (pickedEntry.id == UPGRADE_PIECE_TUNING)
|
|
{
|
|
int targetPieceType = rand() % 7;
|
|
bool duplicatedPiece = true;
|
|
int guard = 0;
|
|
|
|
while (duplicatedPiece && guard < 16)
|
|
{
|
|
duplicatedPiece = false;
|
|
for (int optionIndex = 0; optionIndex < i; optionIndex++)
|
|
{
|
|
if (upgradeUiState.options[optionIndex].id == UPGRADE_PIECE_TUNING &&
|
|
upgradeUiState.options[optionIndex].targetPieceType == targetPieceType)
|
|
{
|
|
duplicatedPiece = true;
|
|
targetPieceType = (targetPieceType + 1) % 7;
|
|
break;
|
|
}
|
|
}
|
|
guard++;
|
|
}
|
|
|
|
upgradeUiState.options[i].targetPieceType = targetPieceType;
|
|
upgradeUiState.options[i].currentLevel = rogueStats.pieceTuningLevels[targetPieceType];
|
|
upgradeUiState.options[i].name = _T("\u65b9\u5757\u6539\u9020");
|
|
|
|
static TCHAR tuningDescriptions[4][64];
|
|
_stprintf_s(
|
|
tuningDescriptions[i],
|
|
_T("\u964d\u4f4e %s \u65b9\u5757\u7684\u51fa\u73b0\u6982\u7387\u3002"),
|
|
GetPieceShortName(targetPieceType));
|
|
upgradeUiState.options[i].description = tuningDescriptions[i];
|
|
}
|
|
|
|
selectableIndexes[pickSlot] = selectableIndexes[selectableCount - 1];
|
|
selectableWeights[pickSlot] = selectableWeights[selectableCount - 1];
|
|
selectableCount--;
|
|
}
|
|
|
|
if (rogueStats.destinyWheelLevel > 0 && optionCount > 0)
|
|
{
|
|
int cursedIndex = rand() % optionCount;
|
|
upgradeUiState.options[cursedIndex].cursed = true;
|
|
}
|
|
}
|
|
|
|
int GetRogueFallInterval()
|
|
{
|
|
int baseInterval = 500 + rogueStats.slowFallStacks * 80;
|
|
|
|
if (rogueStats.highPressureLevel > 0)
|
|
{
|
|
baseInterval = baseInterval * 85 / 100;
|
|
}
|
|
|
|
if (rogueStats.extremePlayerLevel > 0)
|
|
{
|
|
baseInterval = baseInterval * 90 / 100;
|
|
}
|
|
|
|
if (rogueStats.timeDilationLevel > 0)
|
|
{
|
|
int topOccupiedRow = GetTopOccupiedRow();
|
|
if (topOccupiedRow >= 0 && topOccupiedRow <= 5)
|
|
{
|
|
baseInterval += 180;
|
|
}
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE && rogueStats.feverTicks > 0)
|
|
{
|
|
baseInterval += 120;
|
|
}
|
|
|
|
if (rogueStats.extremeSlowTicks > 0)
|
|
{
|
|
baseInterval += 180;
|
|
}
|
|
|
|
if (rogueStats.holdSlowTicks > 0)
|
|
{
|
|
baseInterval += 140;
|
|
}
|
|
|
|
if (baseInterval < 120)
|
|
{
|
|
baseInterval = 120;
|
|
}
|
|
|
|
return baseInterval;
|
|
}
|
|
|
|
static void ApplyUpgradeById(int upgradeId, int targetPieceType, int applyCount)
|
|
{
|
|
if (applyCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (upgradeId)
|
|
{
|
|
case UPGRADE_SCORE_MULTIPLIER:
|
|
rogueStats.scoreMultiplierPercent += 20 * applyCount;
|
|
rogueStats.scoreUpgradeLevel += applyCount;
|
|
break;
|
|
case UPGRADE_COMBO_BONUS:
|
|
rogueStats.comboBonusStacks += applyCount;
|
|
break;
|
|
case UPGRADE_EXP_MULTIPLIER:
|
|
rogueStats.expMultiplierPercent += 25 * applyCount;
|
|
rogueStats.expUpgradeLevel += applyCount;
|
|
break;
|
|
case UPGRADE_SLOW_FALL:
|
|
rogueStats.slowFallStacks += applyCount;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
break;
|
|
case UPGRADE_PREVIEW_PLUS_ONE:
|
|
for (int i = 0; i < applyCount; i++)
|
|
{
|
|
if (rogueStats.previewCount < 3)
|
|
{
|
|
rogueStats.previewCount++;
|
|
}
|
|
}
|
|
rogueStats.previewUpgradeLevel = rogueStats.previewCount - 1;
|
|
break;
|
|
case UPGRADE_LAST_CHANCE:
|
|
rogueStats.lastChanceCount += applyCount;
|
|
rogueStats.lastChanceUpgradeLevel += applyCount;
|
|
break;
|
|
case UPGRADE_HOLD_UNLOCK:
|
|
rogueStats.holdUnlocked = 1;
|
|
break;
|
|
case UPGRADE_PRESSURE_RELIEF:
|
|
{
|
|
rogueStats.pressureReliefLevel += applyCount;
|
|
for (int i = 0; i < applyCount; i++)
|
|
{
|
|
int topOccupiedRow = GetTopOccupiedRow();
|
|
if (topOccupiedRow >= 0)
|
|
{
|
|
DeleteOneLine(topOccupiedRow);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case UPGRADE_SWEEPER:
|
|
rogueStats.sweeperLevel += applyCount;
|
|
break;
|
|
case UPGRADE_EXPLOSIVE_PIECE:
|
|
rogueStats.explosiveLevel += applyCount;
|
|
break;
|
|
case UPGRADE_CHAIN_BLAST:
|
|
rogueStats.chainBlastLevel = 1;
|
|
break;
|
|
case UPGRADE_CHAIN_BOMB:
|
|
rogueStats.chainBombLevel = 1;
|
|
break;
|
|
case UPGRADE_LASER_PIECE:
|
|
rogueStats.laserLevel += applyCount;
|
|
break;
|
|
case UPGRADE_THUNDER_TETRIS:
|
|
rogueStats.thunderTetrisLevel = 1;
|
|
break;
|
|
case UPGRADE_THUNDER_LASER:
|
|
rogueStats.thunderLaserLevel = 1;
|
|
break;
|
|
case UPGRADE_FEVER_MODE:
|
|
rogueStats.feverLevel = 1;
|
|
break;
|
|
case UPGRADE_RAGE_STACK:
|
|
rogueStats.rageStackLevel = 1;
|
|
break;
|
|
case UPGRADE_INFINITE_FEVER:
|
|
rogueStats.infiniteFeverLevel = 1;
|
|
break;
|
|
case UPGRADE_SCREEN_BOMB:
|
|
rogueStats.screenBombLevel = 1;
|
|
break;
|
|
case UPGRADE_TERMINAL_CLEAR:
|
|
rogueStats.terminalClearLevel = 1;
|
|
break;
|
|
case UPGRADE_DUAL_CHOICE:
|
|
rogueStats.dualChoiceLevel = 1;
|
|
rogueStats.requiredExp = rogueStats.requiredExp * 130 / 100;
|
|
if (rogueStats.requiredExp < 10)
|
|
{
|
|
rogueStats.requiredExp = 10;
|
|
}
|
|
break;
|
|
case UPGRADE_DESTINY_WHEEL:
|
|
rogueStats.destinyWheelLevel = 1;
|
|
break;
|
|
case UPGRADE_PERFECT_ROTATE:
|
|
rogueStats.perfectRotateLevel = 1;
|
|
break;
|
|
case UPGRADE_TIME_DILATION:
|
|
rogueStats.timeDilationLevel = 1;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
break;
|
|
case UPGRADE_HIGH_PRESSURE:
|
|
rogueStats.highPressureLevel = 1;
|
|
rogueStats.scoreMultiplierPercent += 50;
|
|
rogueStats.expMultiplierPercent += 50;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
break;
|
|
case UPGRADE_TETRIS_GAMBLE:
|
|
rogueStats.tetrisGambleLevel = 1;
|
|
break;
|
|
case UPGRADE_EXTREME_PLAYER:
|
|
rogueStats.extremePlayerLevel = 1;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
break;
|
|
case UPGRADE_UPGRADE_SHOCKWAVE:
|
|
rogueStats.upgradeShockwaveLevel = 1;
|
|
break;
|
|
case UPGRADE_EVOLUTION_IMPACT:
|
|
rogueStats.evolutionImpactLevel = 1;
|
|
break;
|
|
case UPGRADE_CONTROL_MASTER:
|
|
rogueStats.controlMasterLevel = 1;
|
|
if (rogueStats.previewCount < 3)
|
|
{
|
|
rogueStats.previewCount++;
|
|
}
|
|
rogueStats.previewUpgradeLevel = rogueStats.previewCount - 1;
|
|
break;
|
|
case UPGRADE_BLOCK_STORM:
|
|
rogueStats.blockStormLevel = 1;
|
|
rogueStats.blockStormPiecesRemaining = 2;
|
|
nextTypes[0] = 0;
|
|
nextTypes[1] = 0;
|
|
nextTypes[2] = 0;
|
|
break;
|
|
case UPGRADE_CROSS_PIECE:
|
|
rogueStats.crossPieceLevel += applyCount;
|
|
break;
|
|
case UPGRADE_BLACK_HOLE:
|
|
rogueStats.blackHoleLevel = 1;
|
|
rogueStats.blackHoleCharges++;
|
|
break;
|
|
case UPGRADE_AIR_RESHAPE:
|
|
rogueStats.reshapeLevel = 1;
|
|
rogueStats.reshapeCharges++;
|
|
break;
|
|
case UPGRADE_RAINBOW_PIECE:
|
|
rogueStats.rainbowPieceLevel = 1;
|
|
break;
|
|
case UPGRADE_VOID_CORE:
|
|
rogueStats.voidCoreLevel = 1;
|
|
break;
|
|
case UPGRADE_STABLE_STRUCTURE:
|
|
rogueStats.stableStructureLevel += applyCount;
|
|
break;
|
|
case UPGRADE_DOUBLE_GROWTH:
|
|
rogueStats.doubleGrowthLevel = 1;
|
|
rogueStats.scoreMultiplierPercent += 15;
|
|
rogueStats.expMultiplierPercent += 15;
|
|
break;
|
|
case UPGRADE_PIECE_TUNING:
|
|
if (targetPieceType >= 0 && targetPieceType < 7)
|
|
{
|
|
rogueStats.pieceTuningLevels[targetPieceType] += applyCount;
|
|
}
|
|
break;
|
|
case UPGRADE_GAMBLER:
|
|
rogueStats.gamblerLevel += applyCount;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void ApplyLineClearResult(int linesCleared)
|
|
{
|
|
if (linesCleared <= 0)
|
|
{
|
|
if (currentMode == MODE_ROGUE)
|
|
{
|
|
rogueStats.comboChain = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (currentMode == MODE_CLASSIC)
|
|
{
|
|
classicStats.totalLinesCleared += linesCleared;
|
|
classicStats.score += linesCleared * 100;
|
|
tScore = classicStats.score;
|
|
return;
|
|
}
|
|
|
|
int scoreGain = GetRogueScoreByLines(linesCleared);
|
|
scoreGain = scoreGain * rogueStats.scoreMultiplierPercent / 100;
|
|
|
|
int expGain = GetRogueExpByLines(linesCleared);
|
|
expGain = expGain * rogueStats.expMultiplierPercent / 100;
|
|
|
|
if (rogueStats.tetrisGambleLevel > 0)
|
|
{
|
|
if (linesCleared == 4)
|
|
{
|
|
scoreGain *= 4;
|
|
expGain *= 3;
|
|
}
|
|
else
|
|
{
|
|
scoreGain = scoreGain * 60 / 100;
|
|
expGain = expGain * 75 / 100;
|
|
}
|
|
}
|
|
|
|
if (rogueStats.doubleGrowthLevel > 0)
|
|
{
|
|
int growthMultiplierPercent = 100 + rogueStats.doubleGrowthLevel * 15;
|
|
scoreGain = scoreGain * growthMultiplierPercent / 100;
|
|
expGain = expGain * growthMultiplierPercent / 100;
|
|
}
|
|
|
|
if (rogueStats.feverTicks > 0)
|
|
{
|
|
scoreGain *= 2;
|
|
expGain *= 2;
|
|
}
|
|
|
|
int gamblerBonusPercent = 0;
|
|
if (rogueStats.gamblerLevel > 0)
|
|
{
|
|
int variance = 20 + (rogueStats.gamblerLevel - 1) * 10;
|
|
if (variance > 50)
|
|
{
|
|
variance = 50;
|
|
}
|
|
|
|
gamblerBonusPercent = (rand() % (variance * 2 + 1)) - variance;
|
|
scoreGain = scoreGain * (100 + gamblerBonusPercent) / 100;
|
|
expGain = expGain * (100 + gamblerBonusPercent) / 100;
|
|
}
|
|
|
|
rogueStats.comboChain++;
|
|
if (rogueStats.comboBonusStacks > 0 && rogueStats.comboChain > 1)
|
|
{
|
|
scoreGain += (rogueStats.comboChain - 1) * rogueStats.comboBonusStacks * 50;
|
|
}
|
|
|
|
if (rogueStats.rageStackLevel > 0 && rogueStats.comboChain > 1)
|
|
{
|
|
int rageBonusPercent = (rogueStats.comboChain - 1) * 15;
|
|
if (rogueStats.infiniteFeverLevel > 0 && rogueStats.feverTicks > 0)
|
|
{
|
|
rageBonusPercent += (rogueStats.comboChain - 1) * 10;
|
|
}
|
|
scoreGain += scoreGain * rageBonusPercent / 100;
|
|
}
|
|
|
|
rogueStats.totalLinesCleared += linesCleared;
|
|
rogueStats.score += scoreGain;
|
|
rogueStats.exp += expGain;
|
|
|
|
if (rogueStats.feverLevel > 0)
|
|
{
|
|
rogueStats.feverLineCharge += linesCleared;
|
|
while (rogueStats.feverLineCharge >= 20)
|
|
{
|
|
rogueStats.feverLineCharge -= 20;
|
|
rogueStats.feverTicks = 10;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
SetFeedbackMessage(_T("\u8fdb\u5165\u72c2\u70ed\u6a21\u5f0f"), _T("\u672a\u6765 10 \u79d2\u5f97\u5206 / EXP x2\uff0c\u4e0b\u843d\u66f4\u6162\u3002"), 12);
|
|
}
|
|
}
|
|
|
|
if (rogueStats.infiniteFeverLevel > 0 && rogueStats.feverTicks > 0)
|
|
{
|
|
rogueStats.feverTicks += 1;
|
|
if (linesCleared == 4)
|
|
{
|
|
rogueStats.feverTicks += 3;
|
|
}
|
|
if (rogueStats.feverTicks > 20)
|
|
{
|
|
rogueStats.feverTicks = 20;
|
|
}
|
|
currentFallInterval = GetRogueFallInterval();
|
|
}
|
|
|
|
if (rogueStats.extremePlayerLevel > 0 && linesCleared == 4)
|
|
{
|
|
rogueStats.extremeSlowTicks = 5;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
SetFeedbackMessage(_T("\u6781\u9650\u73a9\u5bb6\u89e6\u53d1"), _T("\u56db\u6d88\u6210\u529f\uff0c\u63a5\u4e0b\u6765 5 \u79d2\u77ed\u6682\u7f13\u901f\u8865\u4f4d\u3002"), 12);
|
|
}
|
|
|
|
if (rogueStats.screenBombLevel > 0)
|
|
{
|
|
rogueStats.screenBombCharge += linesCleared;
|
|
while (rogueStats.screenBombCharge >= 30)
|
|
{
|
|
rogueStats.screenBombCharge -= 30;
|
|
rogueStats.screenBombCount++;
|
|
SetFeedbackMessage(_T("\u6e05\u5c4f\u70b8\u5f39\u5c31\u7eea"), _T("\u5df2\u83b7\u5f97 1 \u6b21\u6e05\u9664\u5e95\u90e8 5 \u884c\u7684\u673a\u4f1a\u3002"), 12);
|
|
}
|
|
}
|
|
|
|
if (rogueStats.chainBlastLevel > 0)
|
|
{
|
|
int chainBlastCells = 0;
|
|
for (int i = 0; i < linesCleared; i++)
|
|
{
|
|
chainBlastCells += TriggerChainBlast(nGameHeight - 1 - i);
|
|
}
|
|
|
|
if (chainBlastCells > 0)
|
|
{
|
|
int chainBlastScore = chainBlastCells * rogueStats.scoreMultiplierPercent / 100;
|
|
if (chainBlastScore < chainBlastCells)
|
|
{
|
|
chainBlastScore = chainBlastCells;
|
|
}
|
|
rogueStats.score += chainBlastScore;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR blastDetail[128];
|
|
_stprintf_s(
|
|
blastDetail,
|
|
_T("\u989d\u5916\u6e05\u9664 %d \u683c +%d Score"),
|
|
chainBlastCells,
|
|
chainBlastScore);
|
|
SetFeedbackMessage(_T("\u8fde\u9501\u7206\u7834\u89e6\u53d1"), blastDetail, 12);
|
|
}
|
|
}
|
|
|
|
if (linesCleared == 4 && rogueStats.thunderTetrisLevel > 0)
|
|
{
|
|
int thunderRowsCleared = 0;
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
int randomRow = rand() % nGameHeight;
|
|
for (int x = 0; x < nGameWidth; x++)
|
|
{
|
|
if (workRegion[randomRow][x] != 0)
|
|
{
|
|
workRegion[randomRow][x] = 0;
|
|
thunderRowsCleared++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (thunderRowsCleared > 0)
|
|
{
|
|
int thunderScore = thunderRowsCleared * rogueStats.scoreMultiplierPercent / 100;
|
|
if (thunderScore < thunderRowsCleared)
|
|
{
|
|
thunderScore = thunderRowsCleared;
|
|
}
|
|
rogueStats.score += thunderScore;
|
|
tScore = rogueStats.score;
|
|
SetFeedbackMessage(_T("\u96f7\u9706\u56db\u6d88\u89e6\u53d1"), _T("\u56db\u6d88\u540e\u989d\u5916\u6e05\u7406\u4e86 2 \u884c\u8303\u56f4\u5185\u7684\u683c\u5b50\u3002"), 12);
|
|
}
|
|
}
|
|
|
|
if (linesCleared == 4 && rogueStats.thunderLaserLevel > 0)
|
|
{
|
|
int laserCellsCleared = 0;
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
laserCellsCleared += ClearColumnAt(rand() % nGameWidth);
|
|
}
|
|
|
|
if (laserCellsCleared > 0)
|
|
{
|
|
int laserScore = laserCellsCleared * rogueStats.scoreMultiplierPercent / 100;
|
|
int laserExp = laserCellsCleared * rogueStats.expMultiplierPercent / 100;
|
|
if (laserScore < laserCellsCleared)
|
|
{
|
|
laserScore = laserCellsCleared;
|
|
}
|
|
if (laserExp < laserCellsCleared)
|
|
{
|
|
laserExp = laserCellsCleared;
|
|
}
|
|
|
|
rogueStats.score += laserScore;
|
|
rogueStats.exp += laserExp;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR thunderLaserDetail[128];
|
|
_stprintf_s(
|
|
thunderLaserDetail,
|
|
_T("\u968f\u673a\u6fc0\u5149\u6e05\u9664 %d \u683c +%d Score +%d EXP"),
|
|
laserCellsCleared,
|
|
laserScore,
|
|
laserExp);
|
|
SetFeedbackMessage(_T("\u96f7\u9706\u6fc0\u5149\u89e6\u53d1"), thunderLaserDetail, 12);
|
|
}
|
|
}
|
|
|
|
if (rogueStats.sweeperLevel > 0)
|
|
{
|
|
rogueStats.sweeperCharge += linesCleared;
|
|
int sweeperThreshold = GetSweeperThreshold();
|
|
int clearedBySweeper = 0;
|
|
|
|
while (rogueStats.sweeperCharge >= sweeperThreshold)
|
|
{
|
|
rogueStats.sweeperCharge -= sweeperThreshold;
|
|
DeleteOneLine(nGameHeight - 1);
|
|
clearedBySweeper++;
|
|
}
|
|
|
|
if (clearedBySweeper > 0)
|
|
{
|
|
TCHAR sweeperDetail[128];
|
|
_stprintf_s(
|
|
sweeperDetail,
|
|
_T("\u81ea\u52a8\u6e05\u7406\u5e95\u90e8 %d \u884c \u5269\u4f59\u5145\u80fd %d/%d"),
|
|
clearedBySweeper,
|
|
rogueStats.sweeperCharge,
|
|
sweeperThreshold);
|
|
SetFeedbackMessage(_T("\u6e05\u626b\u8005\u89e6\u53d1"), sweeperDetail, 12);
|
|
}
|
|
}
|
|
|
|
int levelUps = ApplyLevelProgress(rogueStats);
|
|
upgradeUiState.pendingCount += levelUps;
|
|
tScore = rogueStats.score;
|
|
|
|
if (levelUps > 0)
|
|
{
|
|
int shockwaveRows = 0;
|
|
if (rogueStats.evolutionImpactLevel > 0)
|
|
{
|
|
shockwaveRows = 3;
|
|
rogueStats.feverTicks = 10;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
}
|
|
else if (rogueStats.upgradeShockwaveLevel > 0)
|
|
{
|
|
shockwaveRows = 2;
|
|
}
|
|
|
|
if (shockwaveRows > 0)
|
|
{
|
|
int clearedRows = TriggerUpgradeShockwave(shockwaveRows);
|
|
TCHAR shockwaveDetail[128];
|
|
|
|
if (rogueStats.evolutionImpactLevel > 0)
|
|
{
|
|
_stprintf_s(
|
|
shockwaveDetail,
|
|
_T("\u5347\u7ea7\u6e05\u9664\u5e95\u90e8 %d \u884c\uff0c\u5e76\u83b7\u5f97 10 \u79d2\u53cc\u500d EXP\u3002"),
|
|
clearedRows);
|
|
SetFeedbackMessage(_T("\u8fdb\u5316\u51b2\u51fb\u89e6\u53d1"), shockwaveDetail, 14);
|
|
}
|
|
else
|
|
{
|
|
_stprintf_s(
|
|
shockwaveDetail,
|
|
_T("\u5347\u7ea7\u6e05\u9664\u5e95\u90e8 %d \u884c\uff0c\u89e6\u53d1\u5347\u7ea7\u51b2\u51fb\u6ce2\u3002"),
|
|
clearedRows);
|
|
SetFeedbackMessage(_T("\u5347\u7ea7\u51b2\u51fb\u6ce2\u89e6\u53d1"), shockwaveDetail, 12);
|
|
}
|
|
}
|
|
}
|
|
|
|
TCHAR feedbackTitle[64];
|
|
TCHAR feedbackDetail[128];
|
|
if (feedbackState.visibleTicks <= 0)
|
|
{
|
|
_stprintf_s(feedbackTitle, _T("+%d Score +%d EXP"), scoreGain, expGain);
|
|
if (levelUps > 0)
|
|
{
|
|
_stprintf_s(feedbackDetail, _T("Level Up x%d \u5f53\u524d Lv.%d"), levelUps, rogueStats.level);
|
|
}
|
|
else if (rogueStats.sweeperLevel > 0)
|
|
{
|
|
_stprintf_s(
|
|
feedbackDetail,
|
|
_T("\u6d88\u884c %d \u6e05\u626b\u8005 %d/%d"),
|
|
linesCleared,
|
|
rogueStats.sweeperCharge,
|
|
GetSweeperThreshold());
|
|
}
|
|
else if (rogueStats.gamblerLevel > 0)
|
|
{
|
|
_stprintf_s(feedbackDetail, _T("\u6d88\u884c %d \u8d4c\u5f92\u6ce2\u52a8 %+d%%"), linesCleared, gamblerBonusPercent);
|
|
}
|
|
else
|
|
{
|
|
_stprintf_s(feedbackDetail, _T("\u6d88\u884c %d \u8fde\u51fb %d"), linesCleared, rogueStats.comboChain);
|
|
}
|
|
SetFeedbackMessage(feedbackTitle, feedbackDetail, 10);
|
|
}
|
|
|
|
if (upgradeUiState.pendingCount > 0)
|
|
{
|
|
OpenUpgradeMenu();
|
|
}
|
|
|
|
currentFallInterval = GetRogueFallInterval();
|
|
}
|
|
|
|
static void ApplyDestinyCurse()
|
|
{
|
|
int expPenalty = rogueStats.requiredExp * 25 / 100;
|
|
if (expPenalty < 10)
|
|
{
|
|
expPenalty = 10;
|
|
}
|
|
|
|
rogueStats.requiredExp += expPenalty;
|
|
}
|
|
|
|
/**
|
|
* @brief 判断当前方块是否可以继续向下移动。
|
|
*
|
|
* 遍历当前处于活动状态下方块的 4x4 矩阵，计算其下落一步（Y 坐标加 1）后的位置，
|
|
* 并检查每个非空方块单元：
|
|
* 1. 是否超出了游戏工作区的底部边界（对应数组索引 >= 20）。
|
|
* 2. 是否与工作区下方已经固定的其他方块发生碰撞（即对应位置的值不为 0）。
|
|
* 如果遇到以上任意一种情况，则认为方块受到阻挡，无法继续下落。
|
|
*
|
|
* @return bool 如果可以继续安全下落返回 true，否则返回 false。
|
|
*/
|
|
bool CanMoveDown()
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
if (bricks[type][state][i][j] != 0)
|
|
{
|
|
int nextY = point.y + i + 1;
|
|
int nextX = point.x + j;
|
|
|
|
// 检查是否到达底部边界
|
|
if (nextY >= nGameHeight)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 检查下方是否有其他固定方块
|
|
if (nextY >= 0 && workRegion[nextY][nextX] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 判断当前方块是否可以继续向左移动。
|
|
*
|
|
* 遍历当前处于活动状态下方块的 4x4 矩阵，计算其向左移动一步（X 坐标减 1）后的位置，
|
|
* 并检查每个非空方块单元：
|
|
* 1. 是否超出了游戏工作区的左侧边界（对应数组索引 < 0）。
|
|
* 2. 是否与工作区左侧已经固定的其他方块发生碰撞（即对应位置的值不为 0）。
|
|
* 如果遇到以上任意一种情况，则认为方块受到阻挡，无法继续左移。
|
|
*
|
|
* @return bool 如果可以继续安全左移返回 true，否则返回 false。
|
|
*/
|
|
bool CanMoveLeft()
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
if (bricks[type][state][i][j] != 0)
|
|
{
|
|
int nextY = point.y + i;
|
|
int nextX = point.x + j - 1;
|
|
|
|
// 检查是否到达左侧边界
|
|
if (nextX < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 检查左侧是否有其他固定方块
|
|
if (nextY >= 0 && workRegion[nextY][nextX] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 判断当前方块是否可以继续向右移动。
|
|
*
|
|
* 遍历当前处于活动状态下方块的 4x4 矩阵，计算其向右移动一步（X 坐标加 1）后的位置，
|
|
* 并检查每个非空方块单元：
|
|
* 1. 是否超出了游戏工作区的右侧边界（对应数组索引 >= 10）。
|
|
* 2. 是否与工作区右侧已经固定的其他方块发生碰撞（即对应位置的值不为 0）。
|
|
* 如果遇到以上任意一种情况，则认为方块受到阻挡，无法继续右移。
|
|
*
|
|
* @return bool 如果可以继续安全右移返回 true，否则返回 false。
|
|
*/
|
|
bool CanMoveRight()
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
if (bricks[type][state][i][j] != 0)
|
|
{
|
|
int nextY = point.y + i;
|
|
int nextX = point.x + j + 1;
|
|
|
|
// 检查是否到达右侧边界
|
|
if (nextX >= nGameWidth)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 检查右侧是否有其他固定方块
|
|
if (nextY >= 0 && workRegion[nextY][nextX] != 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool TryRotateWithOffset(int nextState, int offsetX)
|
|
{
|
|
Point rotatedPoint = point;
|
|
rotatedPoint.x += offsetX;
|
|
return IsPiecePlacementValid(type, nextState, rotatedPoint);
|
|
}
|
|
|
|
/**
|
|
* @brief 将当前活动方块向下移动一格。
|
|
*
|
|
* 该函数只负责修改当前活动方块的纵坐标，将其在工作区中的位置向下推进 1 格。
|
|
* 是否允许下移由外部配合 CanMoveDown 函数提前判断。
|
|
*/
|
|
void MoveDown()
|
|
{
|
|
// 当前方块下移一格
|
|
point.y++;
|
|
}
|
|
|
|
/**
|
|
* @brief 将当前活动方块向左移动一格。
|
|
*
|
|
* 该函数只负责修改当前活动方块的横坐标，将其在工作区中的位置向左推进 1 格。
|
|
* 是否允许左移由外部配合 CanMoveLeft 函数提前判断。
|
|
*/
|
|
void MoveLeft()
|
|
{
|
|
// 当前方块左移一格
|
|
point.x--;
|
|
}
|
|
|
|
/**
|
|
* @brief 将当前活动方块向右移动一格。
|
|
*
|
|
* 该函数只负责修改当前活动方块的横坐标，将其在工作区中的位置向右推进 1 格。
|
|
* 是否允许右移由外部配合 CanMoveRight 函数提前判断。
|
|
*/
|
|
void MoveRight()
|
|
{
|
|
// 当前方块右移一格
|
|
point.x++;
|
|
}
|
|
|
|
/**
|
|
* @brief 旋转当前活动方块到下一种朝向。
|
|
*
|
|
* 游戏中的每种方块都预置了 4 种旋转状态，该函数会先尝试切换到下一状态，
|
|
* 然后检查旋转后的方块是否越界或与固定方块重叠。
|
|
* 如果旋转后的状态非法，则恢复到旋转前的状态。
|
|
*/
|
|
void Rotate()
|
|
{
|
|
int nextState = (state + 1) % 4;
|
|
if (IsPiecePlacementValid(type, nextState, point))
|
|
{
|
|
state = nextState;
|
|
return;
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE && rogueStats.perfectRotateLevel > 0)
|
|
{
|
|
if (TryRotateWithOffset(nextState, -1))
|
|
{
|
|
state = nextState;
|
|
point.x--;
|
|
return;
|
|
}
|
|
|
|
if (TryRotateWithOffset(nextState, 1))
|
|
{
|
|
state = nextState;
|
|
point.x++;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 让当前活动方块快速下落到当前位置能够到达的最低点。
|
|
*
|
|
* 该函数会持续检查当前方块是否还能继续下移，只要可以下移就重复调用 MoveDown，
|
|
* 直到方块到达底部或被其他固定方块阻挡为止。
|
|
*/
|
|
void DropDown()
|
|
{
|
|
// 只要还能继续下落，就不断下移
|
|
while (CanMoveDown())
|
|
{
|
|
MoveDown();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 将当前活动方块固定到工作区，并生成下一个活动方块。
|
|
*
|
|
* 遍历当前方块 4x4 形状矩阵，把其中所有非空单元写入工作区数组，
|
|
* 表示该方块已经落地并转为固定状态。
|
|
* 如果固定时仍有任意非空单元位于可视区域顶部之外，则判定游戏结束。
|
|
* 此时当前方块在可视区域内的部分仍会保留在工作区中。
|
|
* 若未超出顶部，再将“下一方块”切换为新的当前方块，重置旋转状态，
|
|
* 并把新方块生成到工作区上方的初始位置，同时刷新预测落点。
|
|
*/
|
|
void Fixing()
|
|
{
|
|
bool overflowTop = false;
|
|
Point explosiveCells[4] = {};
|
|
int explosiveCellCount = 0;
|
|
int rainbowFilledCount = 0;
|
|
pendingChainBombFollowup = false;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
if (bricks[type][state][i][j] != 0)
|
|
{
|
|
int fixY = point.y + i;
|
|
int fixX = point.x + j;
|
|
|
|
// 只要当前方块任意非空单元仍超出顶部，就标记为结束
|
|
if (fixY < 0)
|
|
{
|
|
overflowTop = true;
|
|
}
|
|
|
|
// 将当前方块在可视区域内的部分写入工作区
|
|
if (fixY >= 0 && fixY < nGameHeight && fixX >= 0 && fixX < nGameWidth)
|
|
{
|
|
workRegion[fixY][fixX] = currentPieceIsRainbow ? 8 : bricks[type][state][i][j];
|
|
if (currentPieceIsExplosive && explosiveCellCount < 4)
|
|
{
|
|
explosiveCells[explosiveCellCount].x = fixX;
|
|
explosiveCells[explosiveCellCount].y = fixY;
|
|
explosiveCellCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!overflowTop && currentPieceIsRainbow)
|
|
{
|
|
rainbowFilledCount = TriggerRainbowRowCompletion(point.y, point.y + 3);
|
|
if (rainbowFilledCount > 0)
|
|
{
|
|
TCHAR rainbowDetail[128];
|
|
_stprintf_s(rainbowDetail, _T("\u8865\u5168 %d \u4e2a\u884c\u5185\u7f3a\u53e3\uff0c\u66f4\u5bb9\u6613\u8fbe\u6210\u6d88\u884c\u3002"), rainbowFilledCount);
|
|
SetFeedbackMessage(_T("\u5f69\u8679\u65b9\u5757\u751f\u6548"), rainbowDetail, 10);
|
|
}
|
|
}
|
|
|
|
if (overflowTop)
|
|
{
|
|
if (currentMode == MODE_ROGUE && rogueStats.terminalClearLevel > 0 && rogueStats.lastChanceCount > 0 && rogueStats.screenBombCount > 0)
|
|
{
|
|
rogueStats.lastChanceCount--;
|
|
rogueStats.screenBombCount--;
|
|
|
|
int clearedByTerminal = TriggerScreenBomb();
|
|
rogueStats.feverTicks = 10;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
|
|
TCHAR terminalDetail[128];
|
|
_stprintf_s(
|
|
terminalDetail,
|
|
_T("\u7ec8\u672b\u6e05\u573a\u751f\u6548\uff0c\u6e05\u9664 %d \u683c\uff0c\u5e76\u8fdb\u5165 10 \u79d2\u72c2\u70ed\u3002"),
|
|
clearedByTerminal);
|
|
SetFeedbackMessage(_T("\u7ec8\u672b\u6e05\u573a\u89e6\u53d1"), terminalDetail, 14);
|
|
}
|
|
else if (currentMode == MODE_ROGUE && rogueStats.lastChanceCount > 0)
|
|
{
|
|
rogueStats.lastChanceCount--;
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
DeleteOneLine(nGameHeight - 1);
|
|
}
|
|
|
|
SetFeedbackMessage(
|
|
_T("\u6700\u540e\u4e00\u640f\u89e6\u53d1"),
|
|
_T("\u81ea\u52a8\u6e05\u9664\u5e95\u90e8 3 \u884c\uff0c\u672c\u5c40\u7ee7\u7eed\u3002"),
|
|
14);
|
|
}
|
|
else
|
|
{
|
|
gameOverFlag = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (currentPieceIsExplosive)
|
|
{
|
|
int explosiveScoreGain = 0;
|
|
|
|
for (int i = 0; i < explosiveCellCount; i++)
|
|
{
|
|
explosiveScoreGain += ClearExplosiveAreaAt(explosiveCells[i].y, explosiveCells[i].x);
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE && explosiveScoreGain > 0)
|
|
{
|
|
explosiveScoreGain = explosiveScoreGain * rogueStats.scoreMultiplierPercent / 100;
|
|
rogueStats.score += explosiveScoreGain;
|
|
tScore = rogueStats.score;
|
|
}
|
|
|
|
TCHAR explosiveDetail[128];
|
|
_stprintf_s(
|
|
explosiveDetail,
|
|
_T("\u6e05\u9664 %d \u4e2a\u683c\u5b50 +%d Score"),
|
|
explosiveScoreGain > 0 ? explosiveScoreGain * 100 / rogueStats.scoreMultiplierPercent : 0,
|
|
explosiveScoreGain);
|
|
SetFeedbackMessage(_T("\u7206\u7834\u65b9\u5757\u89e6\u53d1"), explosiveDetail, 12);
|
|
|
|
if (rogueStats.chainBombLevel > 0 && explosiveCellCount > 0)
|
|
{
|
|
pendingChainBombCenter = explosiveCells[0];
|
|
pendingChainBombFollowup = true;
|
|
}
|
|
}
|
|
|
|
if (currentPieceIsLaser)
|
|
{
|
|
int laserColumn = point.x + 1;
|
|
if (laserColumn < 0)
|
|
{
|
|
laserColumn = 0;
|
|
}
|
|
if (laserColumn >= nGameWidth)
|
|
{
|
|
laserColumn = nGameWidth - 1;
|
|
}
|
|
|
|
int laserCellsCleared = ClearColumnAt(laserColumn);
|
|
if (currentMode == MODE_ROGUE && laserCellsCleared > 0)
|
|
{
|
|
int laserScore = laserCellsCleared * rogueStats.scoreMultiplierPercent / 100;
|
|
if (laserScore < laserCellsCleared)
|
|
{
|
|
laserScore = laserCellsCleared;
|
|
}
|
|
rogueStats.score += laserScore;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR laserDetail[128];
|
|
_stprintf_s(laserDetail, _T("\u6e05\u9664 %d \u683c +%d Score"), laserCellsCleared, laserScore);
|
|
SetFeedbackMessage(_T("\u6fc0\u5149\u65b9\u5757\u89e6\u53d1"), laserDetail, 12);
|
|
}
|
|
}
|
|
|
|
if (currentPieceIsCross)
|
|
{
|
|
int crossRow = point.y + 1;
|
|
int crossColumn = point.x + 1;
|
|
if (crossRow < 0)
|
|
{
|
|
crossRow = 0;
|
|
}
|
|
if (crossRow >= nGameHeight)
|
|
{
|
|
crossRow = nGameHeight - 1;
|
|
}
|
|
if (crossColumn < 0)
|
|
{
|
|
crossColumn = 0;
|
|
}
|
|
if (crossColumn >= nGameWidth)
|
|
{
|
|
crossColumn = nGameWidth - 1;
|
|
}
|
|
|
|
int crossCellsCleared = ClearRowAt(crossRow);
|
|
int columnCellsCleared = ClearColumnAt(crossColumn);
|
|
if (workRegion[crossRow][crossColumn] == 0 && columnCellsCleared > 0)
|
|
{
|
|
// center cell may already be counted by row clear
|
|
}
|
|
int totalCrossCleared = crossCellsCleared + columnCellsCleared;
|
|
|
|
if (currentMode == MODE_ROGUE && totalCrossCleared > 0)
|
|
{
|
|
int crossScore = totalCrossCleared * rogueStats.scoreMultiplierPercent / 100;
|
|
if (crossScore < totalCrossCleared)
|
|
{
|
|
crossScore = totalCrossCleared;
|
|
}
|
|
rogueStats.score += crossScore;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR crossDetail[128];
|
|
_stprintf_s(crossDetail, _T("\u6e05\u9664 %d \u683c +%d Score"), totalCrossCleared, crossScore);
|
|
SetFeedbackMessage(_T("\u5341\u5b57\u65b9\u5757\u89e6\u53d1"), crossDetail, 12);
|
|
}
|
|
}
|
|
|
|
if (TryStabilizeBoard() > 0)
|
|
{
|
|
SetFeedbackMessage(_T("\u7a33\u5b9a\u7ed3\u6784\u751f\u6548"), _T("\u81ea\u52a8\u586b\u8865\u4e86\u4e00\u4e2a\u90bb\u8fd1\u7a7a\u6d1e\u3002"), 10);
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE)
|
|
{
|
|
currentFallInterval = GetRogueFallInterval();
|
|
}
|
|
|
|
// 生成下一个活动方块
|
|
type = ConsumeNextType();
|
|
nType = nextTypes[0];
|
|
state = 0;
|
|
holdUsedThisTurn = false;
|
|
RollCurrentPieceSpecialFlags(true);
|
|
point = GetSpawnPoint(type);
|
|
target = point;
|
|
ComputeTarget();
|
|
}
|
|
|
|
/**
|
|
* @brief 删除指定行，并让其上方所有行整体下移一格。
|
|
*
|
|
* 该函数会先将目标行上方的所有数据逐行向下复制，
|
|
* 再把最顶端一行清空，从而完成一次标准的消行下移操作。
|
|
*
|
|
* @param number 需要被删除的目标行号。
|
|
*/
|
|
void DeleteOneLine(int number)
|
|
{
|
|
for (int i = number; i > 0; i--)
|
|
{
|
|
for (int j = 0; j < nGameWidth; j++)
|
|
{
|
|
workRegion[i][j] = workRegion[i - 1][j];
|
|
}
|
|
}
|
|
|
|
// 清空最顶端一行
|
|
for (int j = 0; j < nGameWidth; j++)
|
|
{
|
|
workRegion[0][j] = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 检查并删除所有已满的行，同时更新当前得分。
|
|
*
|
|
* 该函数会从底部向上遍历工作区，判断每一行是否被完全填满。
|
|
* 如果某一行全部非 0，则调用 DeleteOneLine 删除该行，
|
|
* 并将该行上方的内容整体下移。为了避免连续满行被漏检，
|
|
* 删除后会继续检查当前行号。每成功消除 1 行，当前得分增加 100 分。
|
|
*/
|
|
int DeleteLines()
|
|
{
|
|
int clearedLines = 0;
|
|
bool clearedWithRainbow = false;
|
|
|
|
for (int i = nGameHeight - 1; i >= 0; i--)
|
|
{
|
|
bool fullLine = true;
|
|
|
|
for (int j = 0; j < nGameWidth; j++)
|
|
{
|
|
if (workRegion[i][j] == 0)
|
|
{
|
|
fullLine = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fullLine)
|
|
{
|
|
for (int j = 0; j < nGameWidth; j++)
|
|
{
|
|
if (IsRainbowBoardCell(workRegion[i][j]))
|
|
{
|
|
clearedWithRainbow = true;
|
|
break;
|
|
}
|
|
}
|
|
DeleteOneLine(i);
|
|
clearedLines++;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
ApplyLineClearResult(clearedLines);
|
|
|
|
if (pendingChainBombFollowup && clearedLines > 0)
|
|
{
|
|
pendingChainBombFollowup = false;
|
|
|
|
int followupCleared = 0;
|
|
int centerY = pendingChainBombCenter.y;
|
|
int centerX = pendingChainBombCenter.x;
|
|
|
|
for (int y = centerY - 1; y <= centerY + 1; y++)
|
|
{
|
|
for (int x = centerX - 1; x <= centerX + 1; x++)
|
|
{
|
|
if (y >= 0 && y < nGameHeight && x >= 0 && x < nGameWidth && workRegion[y][x] != 0)
|
|
{
|
|
workRegion[y][x] = 0;
|
|
followupCleared++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE && followupCleared > 0)
|
|
{
|
|
int followupScore = followupCleared * rogueStats.scoreMultiplierPercent / 100;
|
|
if (followupScore < followupCleared)
|
|
{
|
|
followupScore = followupCleared;
|
|
}
|
|
rogueStats.score += followupScore;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR followupDetail[128];
|
|
_stprintf_s(
|
|
followupDetail,
|
|
_T("\u8ffd\u52a0\u5c0f\u7206\u70b8\u6e05\u9664 %d \u683c +%d Score"),
|
|
followupCleared,
|
|
followupScore);
|
|
SetFeedbackMessage(_T("\u8fde\u73af\u70b8\u5f39\u89e6\u53d1"), followupDetail, 12);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pendingChainBombFollowup = false;
|
|
}
|
|
|
|
if (currentMode == MODE_ROGUE && clearedWithRainbow && rogueStats.voidCoreLevel > 0)
|
|
{
|
|
int miniBlackHoleCleared = TriggerMiniBlackHole(5);
|
|
if (miniBlackHoleCleared > 0)
|
|
{
|
|
int miniScore = miniBlackHoleCleared * rogueStats.scoreMultiplierPercent / 100;
|
|
if (miniScore < miniBlackHoleCleared)
|
|
{
|
|
miniScore = miniBlackHoleCleared;
|
|
}
|
|
rogueStats.score += miniScore;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR miniDetail[128];
|
|
_stprintf_s(miniDetail, _T("\u5f69\u8679\u6d88\u884c\u89e6\u53d1\u5c0f\u578b\u9ed1\u6d1e\uff0c\u6e05\u9664 %d \u683c +%d Score"), miniBlackHoleCleared, miniScore);
|
|
SetFeedbackMessage(_T("\u865a\u7a7a\u6838\u5fc3\u89e6\u53d1"), miniDetail, 12);
|
|
}
|
|
}
|
|
|
|
return clearedLines;
|
|
}
|
|
|
|
/**
|
|
* @brief 计算当前活动方块的预测落点位置。
|
|
*
|
|
* 该函数以当前活动方块的位置为起点，使用虚拟下落的方式不断尝试向下移动，
|
|
* 直到方块无法继续下落为止。最终得到的最低可达位置会写入 target，
|
|
* 供后续界面绘制瞄准器或落点提示时使用。
|
|
*
|
|
* 计算过程中不会改变当前方块的真实位置 point。
|
|
*/
|
|
void ComputeTarget()
|
|
{
|
|
Point originalPoint = point;
|
|
|
|
// 从当前方块位置开始向下试探
|
|
target = point;
|
|
|
|
while (CanMoveDown())
|
|
{
|
|
point.y++;
|
|
target = point;
|
|
}
|
|
|
|
// 恢复当前方块的真实位置
|
|
point = originalPoint;
|
|
}
|
|
|
|
/**
|
|
* @brief 重置整个游戏状态，开始新的一局。
|
|
*
|
|
* 该函数会清空工作区中的所有固定方块数据，重置分数、结束标记和暂停标记，
|
|
* 并重新初始化当前方块、下一方块、旋转状态以及生成位置。
|
|
* 最后会重新计算一次当前方块的预测落点。
|
|
*/
|
|
void Restart()
|
|
{
|
|
for (int i = 0; i < nGameHeight; i++)
|
|
{
|
|
for (int j = 0; j < nGameWidth; j++)
|
|
{
|
|
workRegion[i][j] = 0;
|
|
}
|
|
}
|
|
|
|
gameOverFlag = false;
|
|
suspendFlag = false;
|
|
targetFlag = true;
|
|
currentFallInterval = 500;
|
|
|
|
ResetPlayerStats(classicStats, false);
|
|
ResetPlayerStats(rogueStats, true);
|
|
upgradeUiState.selectedIndex = 0;
|
|
upgradeUiState.optionCount = 0;
|
|
upgradeUiState.pendingCount = 0;
|
|
upgradeUiState.totalChosenCount = 0;
|
|
upgradeUiState.picksRemaining = 0;
|
|
feedbackState.visibleTicks = 0;
|
|
feedbackState.title[0] = _T('\0');
|
|
feedbackState.detail[0] = _T('\0');
|
|
holdType = -1;
|
|
holdUsedThisTurn = false;
|
|
RollCurrentPieceSpecialFlags(false);
|
|
tScore = 0;
|
|
|
|
ResetNextQueue();
|
|
type = ConsumeNextType();
|
|
nType = nextTypes[0];
|
|
state = 0;
|
|
holdUsedThisTurn = false;
|
|
RollCurrentPieceSpecialFlags(true);
|
|
point = GetSpawnPoint(type);
|
|
target = point;
|
|
|
|
ComputeTarget();
|
|
}
|
|
|
|
void StartGameWithMode(int mode)
|
|
{
|
|
currentMode = mode;
|
|
currentScreen = SCREEN_PLAYING;
|
|
Restart();
|
|
currentFallInterval = (currentMode == MODE_ROGUE) ? GetRogueFallInterval() : 500;
|
|
tScore = (currentMode == MODE_CLASSIC) ? classicStats.score : rogueStats.score;
|
|
}
|
|
|
|
void ReturnToMainMenu()
|
|
{
|
|
currentScreen = SCREEN_MENU;
|
|
suspendFlag = false;
|
|
gameOverFlag = false;
|
|
menuState.optionCount = 3;
|
|
upgradeUiState.pendingCount = 0;
|
|
upgradeUiState.picksRemaining = 0;
|
|
|
|
if (menuState.selectedIndex < 0 || menuState.selectedIndex >= menuState.optionCount)
|
|
{
|
|
menuState.selectedIndex = 0;
|
|
}
|
|
}
|
|
|
|
void OpenRulesScreen()
|
|
{
|
|
currentScreen = SCREEN_RULES;
|
|
suspendFlag = false;
|
|
}
|
|
|
|
void OpenUpgradeMenu()
|
|
{
|
|
if (currentMode != MODE_ROGUE || upgradeUiState.pendingCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FillUpgradeOptions();
|
|
currentScreen = SCREEN_UPGRADE;
|
|
}
|
|
|
|
void ConfirmUpgradeSelection()
|
|
{
|
|
if (currentScreen != SCREEN_UPGRADE || upgradeUiState.optionCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
UpgradeOption selectedOption = upgradeUiState.options[upgradeUiState.selectedIndex];
|
|
int applyCount = 1;
|
|
TCHAR gamblerSuffix[64] = _T("");
|
|
|
|
if (currentMode == MODE_ROGUE && rogueStats.gamblerLevel > 0)
|
|
{
|
|
int gamblerChance = 20 + (rogueStats.gamblerLevel - 1) * 5;
|
|
if (gamblerChance > 40)
|
|
{
|
|
gamblerChance = 40;
|
|
}
|
|
|
|
int roll = rand() % 100;
|
|
if (roll < gamblerChance)
|
|
{
|
|
applyCount = 2;
|
|
_stprintf_s(gamblerSuffix, _T(" \u8d4c\u5f92\uff1a\u53cc\u500d"));
|
|
}
|
|
else if (roll >= 100 - gamblerChance)
|
|
{
|
|
applyCount = 0;
|
|
_stprintf_s(gamblerSuffix, _T(" \u8d4c\u5f92\uff1a\u843d\u7a7a"));
|
|
}
|
|
}
|
|
|
|
ApplyUpgradeById(selectedOption.id, selectedOption.targetPieceType, applyCount);
|
|
upgradeUiState.totalChosenCount++;
|
|
TCHAR feedbackTitle[64];
|
|
TCHAR feedbackDetail[128];
|
|
_stprintf_s(feedbackTitle, _T("\u5df2\u83b7\u5f97\uff1a%s"), selectedOption.name);
|
|
if (selectedOption.id == UPGRADE_PIECE_TUNING && selectedOption.targetPieceType >= 0)
|
|
{
|
|
_stprintf_s(
|
|
feedbackDetail,
|
|
_T("\u964d\u4f4e %s \u65b9\u5757\u51fa\u73b0\u6982\u7387%s"),
|
|
GetPieceShortName(selectedOption.targetPieceType),
|
|
gamblerSuffix);
|
|
}
|
|
else
|
|
{
|
|
_stprintf_s(feedbackDetail, _T("%s%s"), selectedOption.description, gamblerSuffix);
|
|
}
|
|
|
|
if (selectedOption.cursed)
|
|
{
|
|
ApplyDestinyCurse();
|
|
_stprintf_s(
|
|
feedbackDetail + lstrlen(feedbackDetail),
|
|
128 - lstrlen(feedbackDetail),
|
|
_T(" \u8be5\u9009\u9879\u9644\u5e26\u8bc5\u5492\uff1a\u4e0b\u6b21\u5347\u7ea7\u6240\u9700 EXP \u63d0\u9ad8 25%\u3002"));
|
|
}
|
|
|
|
SetFeedbackMessage(feedbackTitle, feedbackDetail, 12);
|
|
|
|
if (upgradeUiState.picksRemaining > 0)
|
|
{
|
|
upgradeUiState.picksRemaining--;
|
|
}
|
|
|
|
for (int i = upgradeUiState.selectedIndex; i + 1 < upgradeUiState.optionCount; i++)
|
|
{
|
|
upgradeUiState.options[i] = upgradeUiState.options[i + 1];
|
|
}
|
|
if (upgradeUiState.optionCount > 0)
|
|
{
|
|
upgradeUiState.optionCount--;
|
|
}
|
|
|
|
if (upgradeUiState.optionCount > 0 && upgradeUiState.selectedIndex >= upgradeUiState.optionCount)
|
|
{
|
|
upgradeUiState.selectedIndex = upgradeUiState.optionCount - 1;
|
|
}
|
|
|
|
if (upgradeUiState.picksRemaining > 0 && upgradeUiState.optionCount > 0)
|
|
{
|
|
currentScreen = SCREEN_UPGRADE;
|
|
return;
|
|
}
|
|
|
|
if (upgradeUiState.pendingCount > 0)
|
|
{
|
|
upgradeUiState.pendingCount--;
|
|
}
|
|
|
|
if (upgradeUiState.pendingCount > 0)
|
|
{
|
|
FillUpgradeOptions();
|
|
currentScreen = SCREEN_UPGRADE;
|
|
return;
|
|
}
|
|
|
|
upgradeUiState.optionCount = 0;
|
|
upgradeUiState.picksRemaining = 0;
|
|
|
|
currentScreen = SCREEN_PLAYING;
|
|
}
|
|
|
|
void HoldCurrentPiece()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.holdUnlocked == 0 || holdUsedThisTurn || gameOverFlag)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int previousHoldType = holdType;
|
|
holdType = type;
|
|
state = 0;
|
|
holdUsedThisTurn = true;
|
|
|
|
if (previousHoldType < 0)
|
|
{
|
|
type = ConsumeNextType();
|
|
nType = nextTypes[0];
|
|
RollCurrentPieceSpecialFlags(true);
|
|
}
|
|
else
|
|
{
|
|
type = previousHoldType;
|
|
RollCurrentPieceSpecialFlags(false);
|
|
}
|
|
|
|
point = GetSpawnPoint(type);
|
|
target = point;
|
|
if (currentMode == MODE_ROGUE && rogueStats.controlMasterLevel > 0)
|
|
{
|
|
rogueStats.holdSlowTicks = 4;
|
|
currentFallInterval = GetRogueFallInterval();
|
|
}
|
|
|
|
if (!IsPiecePlacementValid(type, state, point))
|
|
{
|
|
gameOverFlag = true;
|
|
SetFeedbackMessage(_T("Hold \u5931\u8d25"), _T("\u6362\u51fa\u7684\u65b9\u5757\u65e0\u6cd5\u653e\u7f6e\uff0c\u5bf9\u5c40\u7ed3\u675f\u3002"), 12);
|
|
return;
|
|
}
|
|
|
|
ComputeTarget();
|
|
|
|
if (previousHoldType < 0)
|
|
{
|
|
SetFeedbackMessage(_T("Hold \u5df2\u5b58\u5165"), _T("\u5f53\u524d\u65b9\u5757\u5df2\u8fdb\u5165 Hold \u69fd\u3002"), 10);
|
|
}
|
|
else
|
|
{
|
|
SetFeedbackMessage(_T("Hold \u5df2\u4ea4\u6362"), _T("\u5df2\u4e0e Hold \u69fd\u4e2d\u7684\u65b9\u5757\u4ea4\u6362\u3002"), 10);
|
|
}
|
|
}
|
|
|
|
void UseScreenBomb()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.screenBombCount <= 0 || currentScreen != SCREEN_PLAYING || suspendFlag || gameOverFlag)
|
|
{
|
|
return;
|
|
}
|
|
|
|
rogueStats.screenBombCount--;
|
|
int clearedCells = TriggerScreenBomb();
|
|
int scoreGain = clearedCells * rogueStats.scoreMultiplierPercent / 100;
|
|
if (scoreGain < clearedCells)
|
|
{
|
|
scoreGain = clearedCells;
|
|
}
|
|
|
|
rogueStats.score += scoreGain;
|
|
tScore = rogueStats.score;
|
|
|
|
TCHAR detail[128];
|
|
_stprintf_s(
|
|
detail,
|
|
_T("\u6e05\u9664\u5e95\u90e8 5 \u884c\uff0c\u6e05\u6389 %d \u683c +%d Score"),
|
|
clearedCells,
|
|
scoreGain);
|
|
SetFeedbackMessage(_T("\u4e3b\u52a8\u91ca\u653e\u6e05\u5c4f\u70b8\u5f39"), detail, 12);
|
|
|
|
currentFallInterval = GetRogueFallInterval();
|
|
ComputeTarget();
|
|
}
|
|
|
|
void UseBlackHole()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.blackHoleCharges <= 0 || currentScreen != SCREEN_PLAYING || suspendFlag || gameOverFlag)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int clearedCells = TriggerBlackHole();
|
|
if (clearedCells <= 0)
|
|
{
|
|
SetFeedbackMessage(_T("黑洞未触发"), _T("当前棋盘上没有可被黑洞吞噬的固定方块。"), 10);
|
|
return;
|
|
}
|
|
|
|
rogueStats.blackHoleCharges--;
|
|
|
|
int scoreGain = clearedCells * rogueStats.scoreMultiplierPercent / 100;
|
|
if (scoreGain < clearedCells)
|
|
{
|
|
scoreGain = clearedCells;
|
|
}
|
|
|
|
rogueStats.score += scoreGain;
|
|
tScore = rogueStats.score;
|
|
|
|
if (rogueStats.voidCoreLevel > 0)
|
|
{
|
|
rogueStats.pendingRainbowPieceCount++;
|
|
}
|
|
|
|
TCHAR detail[128];
|
|
if (rogueStats.voidCoreLevel > 0)
|
|
{
|
|
_stprintf_s(
|
|
detail,
|
|
_T("吞噬数量最多的一种方块，清除 %d 格 +%d Score 并生成 1 个彩虹方块"),
|
|
clearedCells,
|
|
scoreGain);
|
|
}
|
|
else
|
|
{
|
|
_stprintf_s(
|
|
detail,
|
|
_T("吞噬数量最多的一种方块，清除 %d 格 +%d Score"),
|
|
clearedCells,
|
|
scoreGain);
|
|
}
|
|
SetFeedbackMessage(_T("主动释放黑洞"), detail, 12);
|
|
|
|
currentFallInterval = GetRogueFallInterval();
|
|
ComputeTarget();
|
|
}
|
|
|
|
void UseAirReshape()
|
|
{
|
|
if (currentMode != MODE_ROGUE || rogueStats.reshapeCharges <= 0 || currentScreen != SCREEN_PLAYING || suspendFlag || gameOverFlag)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const int targetType = 0;
|
|
const int candidateStates[2] = { 0, 1 };
|
|
const int candidateOffsets[5] = { 0, -1, 1, -2, 2 };
|
|
Point originalPoint = point;
|
|
int originalType = type;
|
|
int originalState = state;
|
|
bool transformed = false;
|
|
|
|
for (int stateIndex = 0; stateIndex < 2 && !transformed; stateIndex++)
|
|
{
|
|
int nextState = candidateStates[stateIndex];
|
|
for (int offsetIndex = 0; offsetIndex < 5; offsetIndex++)
|
|
{
|
|
Point candidatePoint = originalPoint;
|
|
candidatePoint.x += candidateOffsets[offsetIndex];
|
|
|
|
if (IsPiecePlacementValid(targetType, nextState, candidatePoint))
|
|
{
|
|
type = targetType;
|
|
state = nextState;
|
|
point = candidatePoint;
|
|
transformed = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!transformed)
|
|
{
|
|
type = originalType;
|
|
state = originalState;
|
|
point = originalPoint;
|
|
SetFeedbackMessage(_T("空中换形失败"), _T("当前空间不足，无法将方块变为 I 方块。"), 10);
|
|
return;
|
|
}
|
|
|
|
rogueStats.reshapeCharges--;
|
|
|
|
TCHAR detail[128];
|
|
_stprintf_s(detail, _T("当前方块已变为 I 方块，剩余 %d 次。"), rogueStats.reshapeCharges);
|
|
SetFeedbackMessage(_T("空中换形"), detail, 12);
|
|
ComputeTarget();
|
|
}
|