qqwq
2017gdgzoi999 · · 个人记录
// -std=c++14 -lgdi32 -lOpengl32
#include <bits/stdc++.h>
#include <windows.h>
#include <conio.h>
#include <gl/gl.h>
using namespace std;
typedef long long ll;
typedef __int128 lll;
mt19937 rng(time(0));
int rnd(int p) {
return int(rng()%p);
}
double rndf() {
return double(rnd(10001)*0.0001);
}
double BackgroundRatio = 0.1;
double BoardRatio = 0.2;
int GridColor=0x888888, BufferColor=0x555555, ShadowColor=0x777777, RoundColor=0xAAAAAA, VanishColor=0x330066;
int SlotColor=0x555555, OverSlotColor=0x333333;
int StatColor=0x99FFFF, TextColor=0xDDDDDD;
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_CREATE:
return 0;
case WM_CLOSE:
PostQuitMessage (0);
return 0;
case WM_DESTROY:
return 0;
case WM_KEYDOWN:
switch (wParam) {
/*case VK_ESCAPE:
PostQuitMessage(0);
return 0;*/
}
return 0;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
void EnableOpenGL(HWND hWnd, HDC *hDC, HGLRC *hRC) {
PIXELFORMATDESCRIPTOR pfd; int iFormat;
*hDC = GetDC(hWnd);
ZeroMemory(&pfd, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
iFormat = ChoosePixelFormat(*hDC, &pfd);
SetPixelFormat(*hDC, iFormat, &pfd);
*hRC = wglCreateContext(*hDC);
wglMakeCurrent(*hDC, *hRC);
}
void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC) {
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hRC);
ReleaseDC(hWnd, hDC);
}
int Mix(int ca, int cb, double rt) {
int Ar = (ca>>16);
int Ag = ((ca>>8)&((1<<8)-1));
int Ab = (ca&((1<<8)-1));
int Br = (cb>>16);
int Bg = ((cb>>8)&((1<<8)-1));
int Bb = (cb&((1<<8)-1));
int R = int(floor(rt*double(Ar)+(1.0-rt)*double(Br)));
int G = int(floor(rt*double(Ag)+(1.0-rt)*double(Bg)));
int B = int(floor(rt*double(Ab)+(1.0-rt)*double(Bb)));
return (max(0,min(255,R))<<16)+(max(0,min(255,G))<<8)+max(0,min(255,B));
}
int PS = 800;
struct ClassPiece {
int B[10][10], LX, LY, clr, SDel, FstX, FstY;
ClassPiece() {
LX=LY=clr=SDel=0; FstX=FstY=-1;
for (int i=0; i<=9; ++i) {
for (int j=0; j<=9; ++j) B[i][j]=0;
}
}
ClassPiece(int _LX, int _LY, int _clr, int _SDel, vector<vector<int> > _B) {
LX=_LX; LY=_LY; clr=_clr; SDel=_SDel; FstX=FstY=-1;
for (int i=0; i<=9; ++i) {
for (int j=0; j<=9; ++j) B[i][j]=0;
}
for (int i=0; i<_LX; ++i) {
for (int j=0; j<_LY; ++j) {
B[i][j] = _B[_LX-i-1][j];
if ((B[i][j])&&(FstX<0)) {
FstX=i; FstY=j;
}
}
}
}
} Piece[155][4];
vector<pair<int,int> > Kick[155][4][4];
bool Focus = false;
int SelX=0, SelY=0;
bool LButtonCD = false;
bool CheckKey(char ch) {
if (!Focus) return false;
if (ch==VK_LBUTTON) {
if (!(GetAsyncKeyState(ch)&0x8000)) LButtonCD=false;
if (LButtonCD) return false;
}
return bool(GetAsyncKeyState(ch)&0x8000);
}
struct Particle {
double x, y, vx, vy, ax, ay, sz, de, th; int n, clr;
};
struct FloatText {
double x, y, sz, bd, de; string str; int clr;
};
struct ClassSta {
int p, d, x, y;
bool operator <(ClassSta b) const {
if (p!=b.p) return p<b.p;
if (d!=b.d) return d<b.d;
if (x!=b.x) return x<b.x;
return y<b.y;
}
};
#warning char
vector<string> Char[999]; string LCW[999], ATKN[999];
char PName[155] = {' ','I','J','L','O','S','T','Z','C','D','B','A','i','t','U','V','X','F','E','s','z','j','l','Y','R','H','N','Q','P','W'};
int Flip[155];
void InitChar() {
LCW[1]="SINGLE"; LCW[2]="DOUBLE"; LCW[3]="TRIPLE"; LCW[4]="QUAD";
LCW[5]="PENTA"; LCW[6]="HEXA"; LCW[7]="HEPTA"; LCW[8]="OCTA";
LCW[9]="ENNEA"; LCW[10]="DECA"; LCW[11]="HENDECA"; LCW[12]="DODECA";
LCW[13]="TRIADECA"; LCW[14]="TESSARADECA"; LCW[15]="PENTEDECA"; LCW[16]="HEXADECA";
LCW[17]="HEPTADECA"; LCW[18]="OCTADECA"; LCW[19]="ENNEADECA"; LCW[20]="EICOSA";
LCW[21]="ULTIMATRIS"; LCW[22]="KIRBTRIS"; LCW[23]="INFINITRIS"; LCW[24]="KAGARIS"; LCW[25]="ELECTRIS";
for(int i=26; i<999; ++i) LCW[i]="PERFECTRIS";
ATKN[1] = "Even";
ATKN[2] = "KO\'s";
ATKN[3] = "Random";
ATKN[4] = "Payback";
ATKN[5] = "Badges";
ATKN[6] = "Attackers";
Char['0'] = {"fbdj375zf","zj"};
Char['1'] = {"kc6","48"};
Char['2'] = {"fbdjo483"};
Char['3'] = {"fbdjosy374","qs"};
Char['4'] = {"7dckuy"};
Char['5'] = {"eapmt374"};
Char['6'] = {"jdbfz573ysp"};
Char['7'] = {"aejr6"};
Char['8'] = {"qsojdbfkquz573ys"};
Char['9'] = {"tqkfbdj375z"};
Char['A'] = {"4c8","vx"};
Char['B'] = {"sojdapsy374p"};
Char['C'] = {"jdbfz573"};
Char['D'] = {"adj374a"};
Char['E'] = {"ea48","pt"};
Char['F'] = {"ea4","pt"};
Char['G'] = {"jdbfz56ytr","y8"};
Char['H'] = {"a4","e8","pt"};
Char['I'] = {"ae","48","c6"};
Char['J'] = {"de375z"};
Char['K'] = {"a4","eq8","pq"};
Char['L'] = {"a48"};
Char['M'] = {"4are8"};
Char['N'] = {"4a8e"};
Char['O'] = {"fbdj375zf"};
Char['P'] = {"4adjosp"};
Char['Q'] = {"6yjdbfz56","w8"};
Char['R'] = {"4adjosp","q8"};
Char['S'] = {"jdbfkqsy375z"};
Char['T'] = {"ae","c6"};
Char['U'] = {"az573e"};
Char['V'] = {"a6e"};
Char['W'] = {"a5m7e"};
Char['X'] = {"a8","4e"};
Char['Y'] = {"6r","are"};
Char['Z'] = {"ae48"};
Char['a'] = {"y65zplnt8"};
Char['b'] = {"a473tnk"};
Char['c'] = {"tnlpz573"};
Char['d'] = {"e85zplo"};
Char['e'] = {"uxtnlpz58"};
Char['f'] = {"edh;?","ko"};
Char['g'] = {"85zplntBFD>","ot"};
Char['h'] = {"a4","plms7"};
Char['i'] = {"76rq","h"};
Char['j'] = {"i","rs<@?9"};
Char['k'] = {"a4","nu8"};
Char['l'] = {"c67"};
Char['m'] = {"4k","plr6","rnt8"};
Char['n'] = {"4k","plms7"};
Char['o'] = {"z573tnlpz"};
Char['p'] = {"z573tnlp","kC"};
Char['q'] = {"oG","tnlpz573"};
Char['r'] = {"4k","plms"};
Char['s'] = {"z573xvplnt"};
Char['t'] = {"ko","c173"};
Char['u'] = {"kz562","n78"};
Char['v'] = {"k6o"};
Char['w'] = {"kp5r7to"};
Char['x'] = {"k8","o4"};
Char['y'] = {"kz573","oBFD>"};
Char['z'] = {"ko48"};
Char['+'] = {"pt","h1"};
Char['-'] = {"ps"};
Char['*'] = {"ay","eu"};
Char['/'] = {"e4"};
Char['\\'] = {"a8"};
Char[','] = {"y7"};
Char['.'] = {"7"};
Char['?'] = {"fbdjorw","6"};
Char['!'] = {"cw","6"};
Char[':'] = {"h","w"};
Char['#'] = {"fj","uy","b4","e7"};
Char['|'] = {"cm","r6"};
Char['\''] = {"dm"};
Char['\"'] = {"cl","en"};
Char['~'] = {"plso"};
Char['['] = {"ca46"};
Char[']'] = {"ce86"};
Char['<'] = {"jp3"};
Char['>'] = {"ftz"};
Char['%'] = {"abgfa","e4","23872"};
Char['$'] = {"oigkqsy375z","c;"};
Char['_'] = {"48"};
Char['='] = {"ko","uy"};
Char['{'] = {"dcglpv067"};
Char['}'] = {"bcintx265"};
Char['('] = {"dlv7"};
Char[')'] = {"bnx5"};
Char['^'] = {"lcn"};
Char['@'] = {"smqwsxyjdbfz473"};
Char[';'] = {"h","w15"};
Char[0] = {"r"};
Char[1] = {"ht1ph","mswqm","r"};
Char[2] = {"hp1th","hm","pq","ts","1w","r"};
/*
a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
z 0 1 2 3
4 5 6 7 8
9 : ; < =
> ? @ A B
C D E F G
*/
}
int ERR=-998244353, ERR2=-998244352;
int _TIME=time(0), Plrs, PlrsCnt, RoundTot=0; char buf[9999];
int TarRem[111][111], ShiftCD[111];
int PaintLim = 10;
bool Con=false; string Command="", Respond; int RespondTime=0, RespondColor=0;
bool CheckBlockType(int tp) {
if (tp>154) return false;
return ((!tp)||(Piece[tp][0].LX>0));
}
pair<int,int> Shift[155][4];
string BaseRule="default", SpinRule="allspin", B2BRule="surge", ComboRule="multipler", KickTable="extend", ACRule="extend";
string GarbageShape = "cheese";
string GarbageMode = "combo";
string GarbageCancel = "default";
string ClutchRule = "default";
string GarbageType = "layer";
string ClearGravity = "default";
string LevelRule = "default";
bool LqOS = false;
void InitKick() {
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
Shift[o][i] = make_pair(0,0);
for (int j=0; j<4; ++j) Kick[o][i][j]={{0,0}};
}
}
if ((KickTable=="default")||(KickTable=="srsplus")||(KickTable=="extend")||(KickTable=="srs")) {
if ((KickTable!="default")&&(KickTable!="extend")) {
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
}
else {
Shift[4][3]={+1,0}; Shift[4][2]={+1,-1}; Shift[4][1]={0,-1};
Shift[11][3]={+1,0}; Shift[11][2]={+1,-1}; Shift[11][1]={0,-1};
Shift[16][3]={+1,0}; Shift[16][2]={+1,-1}; Shift[16][1]={0,-1};
}
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
Kick[1][0][3]={{0,0},{-2,0},{+1,0},{-2,-1},{+1,+2}};
Kick[1][3][0]={{0,0},{+2,0},{-1,0},{+2,+1},{-1,-2}};
Kick[1][3][2]={{0,0},{-1,0},{+2,0},{-1,+2},{+2,-1}};
Kick[1][2][3]={{0,0},{+1,0},{-2,0},{+1,-2},{-2,+1}};
Kick[1][2][1]={{0,0},{+2,0},{-1,0},{+2,+1},{-1,-2}};
Kick[1][1][2]={{0,0},{-2,0},{+1,0},{-2,-1},{+1,+2}};
Kick[1][1][0]={{0,0},{+1,0},{-2,0},{+1,-2},{-2,+1}};
Kick[1][0][1]={{0,0},{-1,0},{+2,0},{-1,+2},{+2,-1}};
Kick[1][0][2]={{0,0},{0,+1},{+1,+1},{-1,+1},{+1,0},{-1,0}};
Kick[1][2][0]={{0,0},{0,-1},{-1,-1},{+1,-1},{-1,0},{+1,0}};
Kick[1][1][3]={{0,0},{-1,0},{-1,+2},{-1,+1},{0,+2},{0,+1}};
Kick[1][3][1]={{0,0},{+1,0},{+1,+2},{+1,+1},{0,+2},{0,+1}};
for (int o=2; o<155; ++o) {
Kick[o][0][3]={{0,0},{-1,0},{-1,+1},{0,-2},{-1,-2}};
Kick[o][3][0]={{0,0},{+1,0},{+1,-1},{0,+2},{+1,+2}};
Kick[o][3][2]={{0,0},{+1,0},{+1,-1},{0,+2},{+1,+2}};
Kick[o][2][3]={{0,0},{-1,0},{-1,+1},{0,-2},{-1,-2}};
Kick[o][2][1]={{0,0},{+1,0},{+1,+1},{0,-2},{+1,-2}};
Kick[o][1][2]={{0,0},{-1,0},{-1,-1},{0,+2},{-1,+2}};
Kick[o][1][0]={{0,0},{-1,0},{-1,-1},{0,+2},{-1,+2}};
Kick[o][0][1]={{0,0},{+1,0},{+1,+1},{0,-2},{+1,-2}};
Kick[o][0][2]={{0,0},{0,+1},{+1,+1},{-1,+1},{+1,0},{-1,0}};
Kick[o][2][0]={{0,0},{0,-1},{-1,-1},{+1,-1},{-1,0},{+1,0}};
Kick[o][1][3]={{0,0},{-1,0},{-1,+2},{-1,+1},{0,+2},{0,+1}};
Kick[o][3][1]={{0,0},{+1,0},{+1,+2},{+1,+1},{0,+2},{0,+1}};
}
}
}
if (KickTable!="srs") {
/*Kick[1][0][3]={{0,0},{-2,0},{+1,0},{+1,+2},{-2,-1}};
Kick[1][3][0]={{0,0},{+2,0},{-1,0},{+2,+1},{-1,-2}};
Kick[1][3][2]={{0,0},{-1,0},{+2,0},{-1,+2},{+2,-1}};
Kick[1][2][3]={{0,0},{-2,0},{+1,0},{-2,+1},{+1,-1}};
Kick[1][2][1]={{0,0},{+2,0},{-1,0},{+2,+1},{-1,-1}};
Kick[1][1][2]={{0,0},{+1,0},{-2,0},{+1,+2},{-2,-1}};
Kick[1][1][0]={{0,0},{-2,0},{+1,0},{-2,+1},{+1,-2}};
Kick[1][0][1]={{0,0},{+2,0},{-1,0},{-1,+2},{+2,-1}};
Kick[1][0][2]={{0,0},{0,+1},{+1,+1},{-1,+1},{+1,0},{-1,0}};
Kick[1][2][0]={{0,0},{0,-1},{-1,-1},{+1,-1},{-1,0},{+1,0}};
Kick[1][1][3]={{0,0},{-1,0},{-1,+2},{-1,+1},{0,+2},{0,+1}};
Kick[1][3][1]={{0,0},{+1,0},{+1,+2},{+1,+1},{0,+2},{0,+1}};*/
Kick[1][0][3]={{0,0},{+1,0},{-2,0},{-2,-1},{+1,+2}};
Kick[1][3][0]={{0,0},{-1,0},{+2,0},{-1,-2},{+2,+1}};
Kick[1][3][2]={{0,0},{-1,0},{+2,0},{-1,+2},{+2,-1}};
Kick[1][2][3]={{0,0},{-2,0},{+1,0},{-2,+1},{+1,-2}};
Kick[1][2][1]={{0,0},{+2,0},{-1,0},{+2,+1},{-1,-2}};
Kick[1][1][2]={{0,0},{+1,0},{-2,0},{+1,+2},{-2,-1}};
Kick[1][1][0]={{0,0},{+1,0},{-2,0},{+1,-2},{-2,+1}};
Kick[1][0][1]={{0,0},{-1,0},{+2,0},{+2,-1},{-1,+2}};
Kick[1][0][2]={{0,0},{0,+1},{+1,+1},{-1,+1},{+1,0},{-1,0}};
Kick[1][2][0]={{0,0},{0,-1},{-1,-1},{+1,-1},{-1,0},{+1,0}};
Kick[1][1][3]={{0,0},{-1,0},{-1,+2},{-1,+1},{0,+2},{0,+1}};
Kick[1][3][1]={{0,0},{+1,0},{+1,+2},{+1,+1},{0,+2},{0,+1}};
}
if ((KickTable=="default")||(KickTable=="extend")) {
vector<pair<int,int> > CCW={{0,0},{0,-1},{1,0},{1,-1},{0,-2},{1,-2},{2,0},{2,-1},{2,-2},{-1,0},{-1,-1},{0,1},{1,1},{2,1},{-1,-2},{-2,0},{0,2},{1,2},{2,2},{-2,-1},{-2,-2},{-1,1},{-1,2},{-2,1},{-2,2}}, CW, FLIP, RFLIP;
for (pair<int,int> p : CCW) CW.push_back(make_pair(-p.first,p.second));
for (int i=0; i<CW.size(); ++i) {
bool ok = true;
for (int j=0; j<FLIP.size(); ++j) {
if (FLIP[j]==CCW[i]) ok=false;
}
if (ok) FLIP.push_back(CCW[i]);
ok = true;
for (int j=0; j<FLIP.size(); ++j) {
if (FLIP[j]==CW[i]) ok=false;
}
if (ok) FLIP.push_back(CW[i]);
}
for (pair<int,int> p : FLIP) RFLIP.push_back(make_pair(-p.first,p.second));
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
for (int o=12; o<155; ++o) {
if (j==((i+1)&3)) Kick[o][i][j]=CCW;
if (j==((i+2)&3)) Kick[o][i][j]=(i<2)?FLIP:RFLIP;
if (j==((i+3)&3)) Kick[o][i][j]=CW;
}
}
}
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
for (int o=1; o<11; ++o) {
vector<pair<int,int> > NK;
if (j==((i+1)&3)) NK=CCW;
if (j==((i+2)&3)) {
NK=(i<2)?FLIP:RFLIP; if (KickTable=="extend") Kick[o][i][j].clear();
}
if (j==((i+3)&3)) NK=CW;
for (pair<int,int> gg : NK) {
bool ok = true;
for (pair<int,int> hh : Kick[o][i][j]) {
if (gg==hh) ok=false;
}
if (ok) Kick[o][i][j].push_back(gg);
}
}
}
}
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) Kick[4][i][j]=Kick[1][i][j];
}
}
if (KickTable=="srs") {
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
int j = (i==3)?0:i+1;
int k = (j==3)?0:j+1;
for (int d=0; d<Kick[o][i][k].size(); ++d) Kick[o][i][k][d]=make_pair(Kick[o][i][j][d].first+Kick[o][j][k][d].first,Kick[o][i][j][d].second+Kick[o][j][k][d].second);
}
}
}
}
if ((KickTable=="asc")||(KickTable=="ascplus")) {
vector<pair<int,int> > CCW={{0,0},{1,0},{0,-1},{1,-1},{0,-2},{1,-2},{2,0},{2,-1},{2,-2},{-1,0},{-1,-1},{0,1},{1,1},{2,1},{-1,-2},{-2,0},{0,2},{1,2},{2,2},{-2,-1},{-2,-2},{-1,1}}, CW, FLIP, RFLIP;
if (KickTable=="asc") {
Shift[1][1]={+1,0}; Shift[1][2]={+1,+1}; Shift[1][3]={0,+1};
}
else {
Shift[4][3]={+1,0}; Shift[4][2]={+1,-1}; Shift[4][1]={0,-1};
Shift[11][3]={+1,0}; Shift[11][2]={+1,-1}; Shift[11][1]={0,-1};
Shift[16][3]={+1,0}; Shift[16][2]={+1,-1}; Shift[16][1]={0,-1};
CCW = {{0,0},{0,-1},{1,0},{1,-1},{0,-2},{1,-2},{2,0},{2,-1},{2,-2},{-1,0},{-1,-1},{0,1},{1,1},{2,1},{-1,-2},{-2,0},{0,2},{1,2},{2,2},{-2,-1},{-2,-2},{-1,1},{-1,2},{-2,1},{-2,2}};
}
for (pair<int,int>p : CCW) CW.push_back(make_pair(-p.first,p.second));
for (int i=0; i<CW.size(); ++i) {
bool ok = true;
for (int j=0; j<FLIP.size(); ++j) {
if (FLIP[j]==CCW[i]) ok=false;
}
if (ok) FLIP.push_back(CCW[i]);
ok = true;
for (int j=0; j<FLIP.size(); ++j) {
if (FLIP[j]==CW[i]) ok=false;
}
if (ok) FLIP.push_back(CW[i]);
}
for (pair<int,int> p : FLIP) RFLIP.push_back(make_pair(-p.first,p.second));
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
for (int o=1; o<155; ++o) {
if (j==((i+1)&3)) Kick[o][i][j]=CCW;
if (j==((i+2)&3)) Kick[o][i][j]=(i<2)?FLIP:RFLIP;
if (j==((i+3)&3)) Kick[o][i][j]=CW;
}
}
}
}
if (KickTable=="ors") {
Shift[1][1]={+1,0}; Shift[1][2]={0,+1};
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[5][0]={0,-1}; Shift[5][1]={+1,0};
Shift[7][0]={0,-1}; Shift[7][1]={+1,0};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
}
if (KickTable=="rnrs") {
Shift[1][1]={+1,0}; Shift[1][0]={0,-1};
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[5][0]={0,-1}; Shift[5][1]={+1,0};
Shift[7][0]={0,-1}; Shift[7][1]={+1,0};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
}
if (KickTable=="lnrs") {
Shift[1][1]={+1,0}; Shift[1][0]={0,-1};
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[5][0]={0,-1}; Shift[5][3]={-1,0};
Shift[7][0]={0,-1}; Shift[7][3]={-1,0};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
}
if (KickTable=="ars") {
Shift[1][1]={+1,0}; Shift[1][2]={0,+1};
Shift[2][0]=Shift[3][0]={0,-1};
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[5][0]={0,-1}; Shift[5][1]={+1,0};
Shift[6][0] = {0,-1};
Shift[7][0]={0,-1}; Shift[7][3]={-1,0};
Shift[10][0] ={0,-1};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[14][1]=Shift[14][2]=Shift[14][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
Shift[21][1]=Shift[21][3]={0,+1};
Shift[22][1]=Shift[22][3]={0,+1};
Shift[23][1]=Shift[23][3]={0,+1};
Shift[24][1]=Shift[24][3]={0,+1};
Shift[25][1]=Shift[25][3]={0,+1};
Shift[26][1]=Shift[26][3]={0,+1};
Shift[27][1]=Shift[27][2]=Shift[27][3]={0,+1};
Shift[28][1]=Shift[28][2]=Shift[28][3]={0,+1};
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) Kick[o][i][j]={{0,0},{+1,0},{-1,0}};
}
}
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
if ((i&1)&&(!(j&1))) {
Kick[1][i][j] = {{0,0},{+1,0},{-1,0},{+2,0},{-2,0}};
Kick[12][i][j] = {{0,0},{+1,0},{-1,0},{+2,0},{-2,0}};
Kick[21][i][j] = {{0,0},{+1,0},{-1,0},{+2,0},{-2,0}};
Kick[22][i][j] = {{0,0},{+1,0},{-1,0},{+2,0},{-2,0}};
Kick[23][i][j] = {{0,0},{+1,0},{-1,0},{+2,0},{-2,0}};
Kick[24][i][j] = {{0,0},{+1,0},{-1,0},{+2,0},{-2,0}};
}
if ((!(i&1))&&(j&1)) {
Kick[1][i][j].push_back({0,+1}); Kick[1][i][j].push_back({0,+2});
Kick[12][i][j].push_back({0,+1}); Kick[12][i][j].push_back({0,+2});
Kick[21][i][j].push_back({0,+1}); Kick[21][i][j].push_back({0,+2});
Kick[22][i][j].push_back({0,+1}); Kick[22][i][j].push_back({0,+2});
Kick[23][i][j].push_back({0,+1}); Kick[23][i][j].push_back({0,+2});
Kick[24][i][j].push_back({0,+1}); Kick[24][i][j].push_back({0,+2});
Kick[25][i][j].push_back({0,+1}); Kick[25][i][j].push_back({0,+2});
Kick[26][i][j].push_back({0,+1}); Kick[26][i][j].push_back({0,+2});
}
if (!j) {
Kick[6][i][j].push_back({0,+1}); Kick[13][i][j].push_back({0,+1});
}
}
}
}
if (KickTable=="c2") {
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) Kick[o][i][j]={{0,0},{-1,0},{+1,0},{0,-1},{-1,-1},{+1,-1},{-2,0},{+2,0}};
}
}
}
if (KickTable=="new") {
Shift[1][0]={0,-1}; Shift[1][3]={-1,0};
Shift[2][2]={0,+1}; Shift[2][1]={+1,0};
Shift[3][2]={0,+1}; Shift[3][3]={-1,0};
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[5][2]={0,+1}; Shift[5][1]={+1,0};
Shift[7][2]={0,+1}; Shift[7][3]={-1,0};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
if (j==((i+1)&3)) Kick[o][i][j]={{0,0},{-1,0},{0,-1},{+1,0},{0,+1}};
if (j==((i+3)&3)) Kick[o][i][j]={{0,0},{+1,0},{0,-1},{-1,0},{0,+1}};
}
}
}
}
if (KickTable=="atari") {
Shift[1][0]={0,+1}; Shift[1][2]={0,+2}; Shift[1][3]={-1,0};
Shift[2][2]={0,+1}; Shift[2][3]={-1,0};
Shift[3][2]={0,+1}; Shift[3][3]={-1,0};
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[5][2]={0,+1}; Shift[5][3]={-1,0};
Shift[6][2]={0,+1}; Shift[6][3]={-1,0};
Shift[7][2]={0,+1}; Shift[7][3]={-1,0};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) Kick[o][i][j]={{0,0},{-1,0}};
}
}
}
if (KickTable=="tetrax") {
Shift[4][1]={+1,0}; Shift[4][2]={+1,+1}; Shift[4][3]={0,+1};
Shift[11][1]={+1,0}; Shift[11][2]={+1,+1}; Shift[11][3]={0,+1};
Shift[16][1]={+1,0}; Shift[16][2]={+1,+1}; Shift[16][3]={0,+1};
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
if (((i+2)&3)==j) {
if (o!=1) Kick[o][i][j]={{0,0},{0,+1},{0,-1},{-1,0},{+1,0}};
else Kick[o][i][j]={{0,0},{0,-1},{0,+1}};
}
else if (i!=j) {
if (((i+3)&3)==j) Kick[o][i][j]={{0,0},{0,+1},{-1,0},{+1,0},{-1,+1},{+1,+1},{0,-1},{-1,-1},{+1,-1}};
else Kick[o][i][j]={{0,0},{0,+1},{+1,0},{-1,0},{+1,+1},{-1,+1},{0,-1},{+1,-1},{-1,-1}};
}
}
}
}
Kick[1][0][3] = {{0,0},{0,-1},{0,-2},{0,+1},{+1,-1},{-1,-1},{+1,-2},{-1,-2}};
Kick[1][3][0]=Kick[1][3][2]={{0,0},{0,-1},{0,-2},{0,+1},{-1,0},{+1,0},{+2,0}};
Kick[1][2][3] = {{0,0},{0,+1},{0,+2},{0,-1},{-1,+1},{+1,+1},{-1,+2},{+1,+2}};
Kick[1][2][1] = {{0,0},{0,+1},{0,+2},{0,-1},{+1,+1},{-1,+1},{+1,+2},{-1,+2}};
Kick[1][1][2]=Kick[1][1][0]={{0,0},{0,-1},{0,-2},{0,-1},{+1,0},{-1,0},{-2,0}};
Kick[1][0][1] = {{0,0},{0,-1},{0,-2},{0,+1},{-1,-1},{+1,-1},{-1,-2},{+1,-2}};
}
if (KickTable=="none") {
Shift[4][3]={+1,0}; Shift[4][2]={+1,-1}; Shift[4][1]={0,-1};
}
for (int o=0; o<155; ++o) {
for (int i=0; i<4; ++i) {
for (int j=0; j<4; ++j) {
for (int d=0; d<Kick[o][i][j].size(); ++d) {
Kick[o][i][j][d].first += Shift[o][j].first-Shift[o][i].first;
Kick[o][i][j][d].second += Shift[o][j].second-Shift[o][i].second;
}
}
}
}
}
char AskKey(string str) {
if (str.empty()) return 0;
if (str.size()==1) {
char ch = str[0];
if ((ch>='a')&&(ch<='z')) return ch+'A'-'a';
if ((ch>='0')&&(ch<='9')) return ch;
return 0;
}
if (str=="up") return VK_UP;
if (str=="down") return VK_DOWN;
if (str=="left") return VK_LEFT;
if (str=="right") return VK_RIGHT;
if (str=="shift") return VK_SHIFT;
if (str=="space") return VK_SPACE;
if (str=="tab") return VK_TAB;
if (str=="enter") return VK_RETURN;
//if (str=="esc") return VK_ESCAPE;
if (str=="caps") return VK_CAPITAL;
if (str=="ctrl") return VK_CONTROL;
if (str=="none") return VK_F24;
return 0;
}
string IToS(int x) {
if (!x) return "0";
string res = "";
while (x) {
res=char(x%10+'0')+res; x/=10;
}
return res;
}
int SToI(string s) {
if (s=="max") return 99999999;
if (s.size()>8) return ERR;
int res = 0;
for (char ch : s) {
if ((ch<'0')||(ch>'9')) return ERR;
res = res*10+int(ch-'0');
}
return res;
}
struct ClassAtkEff {
double x, y, th, dir; int tar, clr, sz;
};
vector<ClassAtkEff> AtkEff;
string ForceExecute = "";
int Obs = -1;
bool ForceRound, ForceAbort; int sortval[999];
bool QuickPlay = false;
bool Odoo = false;
int ConstE = 0;
bool Arcade=false, ArcadeRound=false;
bool ObserveAI = true;
string TargetBonus = "default";
string BadgeBonus = "default";
bool DisAtk = true;
string GarbageBonus="default", OpenerBonus="default", Style="default", DefaultRot="ccw";
int _InnerMess=0, _SegMess=100, _Luck=0;
int BegDelay=3000; bool Zen=false, Storage=false, Undo=false;
vector<int> DefaultBag = {1,2,3,4,5,6,7};
vector<pair<int,int> > DDP[155][4]; int UseAI=0;
vector<ll> Floor =
{0, 50, 150, 300, 450, 650, 850, 1100, 1350, 1650,
2000, 2400, 2950, 3500, 4000, 4500, 5000, 5500, 6000, 6500,
7000, 7500, 8000, 8500, 9000, 9500, 10000, 11000, 12000, 15000};
vector<int> DecDis = {5000,4800,3900,2100,1400,1300,900,600,400,300,200,180,160,140,120,100,90,80,70,60,55,50,45,40,35,30,25,20,15,10,5,0};
vector<int> ComboBase = {2440,1120,400,60,-160,-330,-470,-600,-710,-830,-940,-1050,-1160,-1260};
vector<int> ComboBonus = {1220,610,300,180,120,90,70,50,40,30,30,20};
vector<int> GradeDec = {125,80,80,50,45,45,45,40,40,40,40,40,30,30,30,20,20,20,20,20,15,15,15,15,15,15,15,15,15,15,10};
vector<int> ArcadeAre = {25,25,25,25,25,25,25,16,12,12,6,5,4};
vector<int> ArcadeLcd = {40,40,40,40,40,25,16,12,6};
vector<int> ArcadeLock = {30,30,30,30,30,30,30,30,30,17,17,15};
vector<int> CoolTm = {52,52,49,45,45,42,42,38,38,-1};
vector<int> RegretTm = {90,75,75,68,60,60,50,50,50,50,99999};
vector<pair<int,int> > ArcadeGrav = {{0,4},{30,6},{35,8},{40,10},{50,12},{60,16},{70,32},{80,48},{90,64},{100,80},{120,96},{140,112},{160,128},{170,144},
{200,4},{220,32},{230,64},{233,96},{236,128},{239,160},{243,192},{247,224},{251,256},{300,512},{330,768},{360,1024},{400,1280},{420,1024},{450,768},{500,5120}};
vector<int> GradeBonus[5], ComboMul[5];
vector<int> SegGrade = {0,1,2,3,4,5,5,6,6,7,7,7,8,8,8,9,9,9,10,11,12,12,12,13,13,14,14,15,15,16,16,17};
vector<string> GradeName = {"9","8","7","6","5","4","3","2","1","S1","S2","S3","S4","S5","S6","S7","S8","S9","m1","m2","m3","m4","m5","m6","m7","m8","m9","M","MK","MV","MO","MM","GM"};
int DX0 = 0;
int AddTp = 1;
bool RDown = false;
bool _fstl = true;
double MX[111], MY[111];
int HoleEval[111];
queue<ll> FP;
vector<lll> ClearTemplate; int TemplatePos=0;
char KEY_LEFT = VK_LEFT;
char KEY_RIGHT = VK_RIGHT;
char KEY_DOWN = VK_DOWN;
char KEY_UP = 'W';
char KEY_CW = 'X';
char KEY_CCW = 'Z';
char KEY_180 = 'A';
char KEY_HARD = ' ';
char KEY_HOLD = 'C';
char KEY_ROT = VK_UP;
char KEY_EVEN = '1';
char KEY_KO = '2';
char KEY_RANDOM = '3';
char KEY_PAYBACK = '4';
char KEY_BADGE = '5';
char KEY_ATTACKERS = '6';
char KEY_UNDO = 'P';
char KEY_RETRY = 'U';
char KEY_RESET = 'E';
char KEY_SONIC = 'S';
char KEY_WASTE = 'T';
char KEY_FLIP = 'Q';
char KEY_LOCK = 'R';
int RotType = 3;
//int DAS=60, ARR=0, SDDAS=0, SDARR=0;
int DAS=167, ARR=33, SDDAS=300, SDARR=20;
int DCD=0, HCD=100;
bool DropEff=true, RotEff=false;
bool MoveEff=true, SpinEff=true;
struct Board {
int HoldRule=1, Sequence=1, DivOperTime=0, UndoCD=0;
int ModHold=0, ModMess=0, ModGravity=0, ModStrength=0, ModDivergence=0, ModInvisible=0, ModSpin=0, ModExpert=0;
int Plr, Tar=-1; bool Over=false, InChain=false; int ChainLine=0;
int B[111][55], C[111][55], ID[111][55], LE[111][55], PrePos[111][55], LX, LY, DX;
int PartID = 0;
int Hold, HoldEnable, InitFacing=0;
int DropL=800, LockL=500, ResetLim=15, ARE=0, LCD=0, DeathARE=500, AreLeft=0;
int GLockL=99999999, FLockL=99999999, GTime=0, FTime=0;
int DcdLeft=0, HcdLeft=0, DrdLeft=0, VisTm=0;
int BaseDropL=800, BaseLockL=500;
int InitHold=0, InitRot=0;
int GarbageGap=8, DXDel=0;
int DRD = 0;
int GarbDelay=500, GarbRise=0, Stock=0, Life=0;
deque<int> Next; vector<Particle> PQu; vector<FloatText> TQu;
deque<pair<int,pair<lll,ll> > > Rec; queue<pair<int,int> > Atk;
deque<pair<int,lll> > ActiveGarb;
deque<pair<int,lll> > AllSpinGarb;
vector<lll> ClearShape;
int EV[8], ED[8];
bool UseRotEff = false;
bool AllSpinGarbOper = false;
double KX, KY, sz=1.0; int Pid, Dir, LstReady=999, ViewNxt=5;
double DropKX=0.0, DropKY=0.0, Rot=0.0, DropRot=0.0;
int RoundHeight=0, VanishHeight=99999999;
int StaticHeight=0, StartHeight=0;
int AtkType = 1;
int DropTime, ResetRem; bool Bot=false;
int LastGarb=9999999, Combo, B2B, ComboRem=0;
int ComboCol[55];
double ShiftX, ShiftY; mt19937 gen;
vector<char> KeyList = {0,KEY_DOWN,KEY_LEFT,KEY_RIGHT,KEY_CW,KEY_CCW,KEY_180,KEY_HARD,KEY_HOLD,
KEY_ROT,KEY_EVEN,KEY_KO,KEY_RANDOM,KEY_PAYBACK,KEY_BADGE,KEY_ATTACKERS,KEY_UNDO,KEY_LOCK,KEY_RETRY,KEY_RESET,KEY_SONIC,KEY_WASTE,KEY_FLIP,KEY_UP};
vector<char> DasKey = {KEY_DOWN,KEY_LEFT,KEY_RIGHT,KEY_UP,KEY_SONIC};
int KeySta[256], KeyTime[256], Key; bool KeyDas[256], UseDas[256];
double avx=0.0, avy=0.0; ll begtm = clock();
double savx=-100.0, savy=-100.0, tavx=-100.0, tavy=-100.0;
int OperDis, OperTime=0; bool MiniSpin=false; pair<int,int> LstAct=make_pair(-1,-1);
int SumPiece=0, SumLine=0, SumAttack=0, SumDig=0, KO=0, SKO=0; ll Score=0LL, DisScore=0LL;
int ClearType=0, ClearWType=0, ClearTm=0, ClearColor=0, SpinType=0, SpinFull=0, SpinTm=0, SpinDis=0;
int ComboType=0, ComboTm=0, B2BType=0, B2BTm=0, Wins=0, PCTime=0;
int VSRnk=0, GarbagePreview=10, OpenerPhrase=14;
double SKX, SKY, Ssz, isz; int LstAtk=-1; bool BeFrom=false, BeTo=false, ShowShadow=true, Flipped=false;
bool AllowMove=true, AllowRot=true, Allow2Rot=true, AllowHalf=true, AllowHard=true, AllowSoft=true, AllowSonic=true;
bool AllowFlip=false, AllowUp=false, AllowLock=false, AllowDeep=false; int WasteLim=0, WasteRem=0;
bool ForceOver=0, ForceLock=0; int ForceWaste=0;
int Level=0, SumCool=0, SumRegret=0, CurSeg=0, Seg70=0, Seg100=0, SegSta[12];
int Acc=0, AccRnk=0, AccProtect=0, CurFloor=0;
int AggTm=0, AggDec=0, LstHole=0, FloorTm=0, RecIncTm=0;
int Grade=0, GradeRnk=0, GradeDecTm=0, ArcadeInvis=0, InvisGrade=0, InvisTm=0;
int His=4, Rol=6, Ext=0, BagSz=0; deque<int> HisSeq;
bool Complete = false;
int TarPiece=0, TarLine=0, TarAttack=0, TarTime=0, TarScore=0, Passthrough=0;
int EcCD=0, BnCD=0, ScTm=0, OgTm=0; queue<ll> Bl; deque<pair<ll,int> > Cy;
int LevBase=0, LevStart=0, LevLine=0, LevTime=0, LevPiece=0, LevAttack=0, LstLev=0;
int LevLineInc=0, LevTimeInc=0, LevPieceInc=0, LevAttackInc=0;
int MasterBeg=18, Diff=7;
double RotEffVal=0.0; int LqC=0;
vector<int> Bag = {};
Board() {
}
Board(int _Plr, int _LX, int _LY, int _DX, double _KX, double _KY, bool _Bot=false, int _OperTime=0) {
Plr=_Plr; begtm=clock();
LX=_LX; LY=_LY; DX=_DX;
KX=SKX=_KX; KY=SKY=_KY; Bot=_Bot; OperTime=_OperTime;
for (int i=0; i<111; ++i) {
for (int j=0; j<55; ++j) B[i][j]=C[i][j]=0;
}
for (int i=0; i<256; ++i) {
KeySta[i]=KeyTime[i]=0; KeyDas[i]=UseDas[i]=false;
}
for (int i : DasKey) UseDas[i]=true;
Next.clear();
Hold=DropTime=0; HoldEnable=1; ResetRem=max(1,ResetLim);
double tmp = min(300.0/double(10),600.0/double(22))*0.7;
isz=sz=Ssz=min(300.0/double(LY),600.0/double(DX))*0.7/tmp*20.0;
SumPiece=SumLine=SumAttack=0;
ShiftX=ShiftY=0.0; gen=mt19937(_TIME);
if (QuickPlay) ++_TIME;
}
void ReloadKey() {
for (int i=0; i<256; ++i) {
KeySta[i]=KeyTime[i]=0; KeyDas[i]=UseDas[i]=false;
}
KeyList = {0,KEY_DOWN,KEY_LEFT,KEY_RIGHT,KEY_CW,KEY_CCW,KEY_180,KEY_HARD,KEY_HOLD,
KEY_ROT,KEY_EVEN,KEY_KO,KEY_RANDOM,KEY_PAYBACK,KEY_BADGE,KEY_ATTACKERS,KEY_UNDO,KEY_LOCK,KEY_RETRY,KEY_RESET,KEY_SONIC,KEY_WASTE,KEY_FLIP,KEY_UP};
DasKey = {KEY_DOWN,KEY_LEFT,KEY_RIGHT,KEY_UP,KEY_SONIC};
for (int i : DasKey) UseDas[i]=true;
}
void Plot(double x, double y, int clr) {
int _clr=clr; clr=abs(clr);
if ((fabs(RotEffVal)>=0.001)&&(UseRotEff)&&(savx>=-99.0)) {
double mx=sz*double(double(DX)-savx), my=sz*double(savy), len=sqrt((x-mx)*(x-mx)+(y-my)*(y-my));
if ((len>=0.001)&&(abs(RotEffVal)>=0.001)&&(sz>=10.0)) {
double theta = atan2(y-my,x-mx);
x=mx+cos(theta+RotEffVal)*len; y=my+sin(theta+RotEffVal)*len;
}
}
if (fabs(Rot)>=0.001) {
double mx=sz*double(DX)*0.5, my=sz*double(LY)*0.5, len=sqrt((x-mx)*(x-mx)+(y-my)*(y-my));
if ((len>=0.001)&&(abs(Rot)>=0.001)&&(sz>=10.0)) {
double theta = atan2(y-my,x-mx);
x=mx+cos(theta+Rot)*len; y=my+sin(theta+Rot)*len;
}
}
x+=KX; y+=KY;
int B=clr&255; clr>>=8;
int G=clr&255; clr>>=8;
int R = clr&255;
double px = 1.0-x/double(PS);
double py = y/double(PS);
px = px*1.6-0.8;
py = py*1.6-0.8;
glColor3f(min(1.0,max(0.0,double(R)/255.0)), min(1.0,max(0.0,double(G)/255.0)), min(1.0,max(0.0,double(B)/255.0)));
glVertex2f(py*2.0/3.0-1.0/3.0, px);
}
void Poly(double x, double y, double r, int n, int clr, double th=0.0) {
glBegin(GL_POLYGON);
for (int i=0; i<n; ++i) {
Plot(x-r*cos(th), y+r*sin(th), clr);
th += 2.0*acos(-1.0)/double(n);
}
glEnd();
}
void Square(double x, double y, double d, int clr) {
glBegin(GL_POLYGON);
Plot(x, y, clr);
Plot(x+d, y, clr);
Plot(x+d, y+d, clr);
Plot(x, y+d, clr);
glEnd();
}
void Rectangle(double x, double y, double dx, double dy, int clr) {
glBegin(GL_POLYGON);
Plot(x, y, clr);
Plot(x+dx, y, clr);
Plot(x+dx, y+dy, clr);
Plot(x, y+dy, clr);
glEnd();
}
void PaintChar(int ch, double x, double y, double sz, int clr, double bd=0.15, double th=0.0, double sc=0.0) {
ch%=256; if (ch<0) ch+=256;
bd*=sz; sz/=6.0;
double mx=x+sz*3, my=y+sz*2.5;
for (string str : Char[ch]) {
if (str.size()==1) {
int val = ((str[0]>='a')&&(str[0]<='z'))?str[0]-'a':26+str[0]-'0';
double sx=x+sz*double(val/5), sy=y+sz*double(val%5);
if ((th)||(sc)) {
double dis = sqrt((sx-mx)*(sx-mx)+(sy-my)*(sy-my));
dis = dis*(1.0+sc);
if (dis>0.01) {
double tt = atan2(sy-my,sx-mx);
sx=mx+dis*cos(tt+th); sy=my+dis*sin(tt+th);
}
}
double dx=bd*0.5, dy=bd*0.5;
glBegin(GL_POLYGON);
Plot(sx+dx, sy+dy, clr);
Plot(sx+dx, sy-dy, clr);
Plot(sx-dx, sy-dy, clr);
Plot(sx-dx, sy+dy, clr);
glEnd();
continue;
}
for (int i=1; i<str.size(); ++i) {
int val = ((str[i-1]>='a')&&(str[i-1]<='z'))?str[i-1]-'a':26+str[i-1]-'0';
double sx=x+sz*double(val/5), sy=y+sz*double(val%5);
val = ((str[i]>='a')&&(str[i]<='z'))?str[i]-'a':26+str[i]-'0';
double ex=x+sz*double(val/5), ey=y+sz*double(val%5);
if ((th)||(sc)) {
double dis = sqrt((sx-mx)*(sx-mx)+(sy-my)*(sy-my));
dis = dis*(1.0+sc);
if (dis>0.01) {
double tt = atan2(sy-my,sx-mx);
sx=mx+dis*cos(tt+th); sy=my+dis*sin(tt+th);
}
swap(sx,ex); swap(sy,ey);
dis = sqrt((sx-mx)*(sx-mx)+(sy-my)*(sy-my));
dis = dis*(1.0+sc);
if (dis>0.01) {
double tt = atan2(sy-my,sx-mx);
sx=mx+dis*cos(tt+th); sy=my+dis*sin(tt+th);
}
swap(sx,ex); swap(sy,ey);
}
double dx=ex-sx, dy=ey-sy, len=sqrt(dx*dx+dy*dy);
double rat = bd/len*0.2;
sx-=rat*dx; sy-=rat*dy;
ex+=rat*dx; ey+=rat*dy;
dx=sy-ey; dy=ex-sx;
rat = 0.5*bd/sqrt((sx-ex)*(sx-ex)+(sy-ey)*(sy-ey));
dx*=rat; dy*=rat;
glBegin(GL_POLYGON);
Plot(sx+dx, sy+dy, clr);
Plot(ex+dx, ey+dy, clr);
Plot(ex-dx, ey-dy, clr);
Plot(sx-dx, sy-dy, clr);
glEnd();
}
}
}
void PaintStrL(string str, double x, double y, double sz, int clr, double bd=0.15, double dis=1.0) {
dis *= sz;
for (char ch : str) {
PaintChar(int(ch), x, y, sz, clr, bd);
y += dis;
}
}
void PaintStrR(string str, double x, double y, double sz, int clr, double bd=0.15, double dis=1.0, bool sp=false, double th=0.0, double sc=0.0) {
if (sp) {
dis=1.5; bd=0.1;
}
dis *= sz;
reverse(str.begin(), str.end());
int oo = sp;
for (char ch : str) {
if (sp) Rectangle(x+oo*sz*0.1-sz*0.2,y-sz*0.2,sz*1.5,sz,0xFF3333);
PaintChar(int(ch), x+oo*sz*0.1, y, sz, (sp)?0xFFFFFF:clr, bd, th, sc);
y -= dis;
oo *= -1;
}
}
void PaintStrM(string str, double x, double y, double sz, int clr, double bd=0.15, double dis=1.0) {
dis *= sz;
y -= dis*0.5*double(str.size()-1)-sz*0.5;
for (char ch : str) {
PaintChar(int(ch), x, y, sz, clr, bd);
y += dis;
}
}
bool CheckActive() {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) return true;
}
}
return false;
}
bool CheckPlace(int x, int y) {
if ((min(x,y)<1)||((x>LX)||(y>LY))) return true;
return ((B[x][y])&&(!C[x][y]));
}
bool CheckFill(int x, int y) {
if ((min(x,y)<1)||((x>LX)||(y>LY))) return true;
return B[x][y];
}
int QueryFloor() {
int res = 0;
for (ll x : Floor) {
if (Score>=x) ++res;
}
return res;
}
int QueryHeight() {
for (int i=LX; i; --i) {
for (int j=1; j<=LY; ++j) {
if ((B[i][j])&&(!C[i][j])) return i;
}
}
return 0;
}
int RollPiece() {
if (BagSz!=Bag.size()) {
BagSz=Bag.size(); HisSeq.clear();
}
if (!BagSz) return 4;
int res = 0;
for (int i=0; i<Rol; ++i) {
int x = gen()%BagSz;
res=x; bool ok=true;
for (int y : HisSeq) {
if (x==y) {
ok=false; break;
}
}
if (ok) break;
}
HisSeq.push_back(res);
while (HisSeq.size()>His) HisSeq.pop_front();
return Bag[res];
}
bool CheckSpawn(int _Pid, int _Dir, int Inc=0) {
ClassPiece P = Piece[_Pid][_Dir];
int SX=DX-1+P.SDel, SY=(LY-P.LY)/2+1;
SY = max(1,min(LY-P.LY+1,SY));
SX = max(2,min(LX,SX))+Inc;
for (int i=0; i<P.LX; ++i) {
for (int j=0; j<P.LY; ++j) {
if ((CheckPlace(SX+i,SY+j))&&(P.B[i][j])) return false;
}
}
return true;
}
bool Spawn(int _Pid, int _Dir, bool Clutch=false) {
Flipped = false;
RotEffVal = 0.0;
DX += DXDel;
LqC = 0;
GTime=FTime=0;
while ((Bl.size())&&(Bl.front()+3000LL<clock())) {
if (rnd(100)<_SegMess) LstHole=RollHole(_Luck);
Bl.pop(); AddGarbage(2,RollGarb());
}
ll curtm=clock(); DXDel=AllSpinGarb.size()+Bl.size();
int Mins = int((curtm-begtm-BegDelay)/60000LL);
if ((Plrs>1)&&(QuickPlay)) {
if (Mins>=8) DXDel+=(ModExpert<2)?2:3;
if (Mins>=10) DXDel+=(ModExpert<2)?3:5;
if (Mins>=12) DXDel+=(ModExpert<2)?5:12;
}
DX -= DXDel;
ClassPiece P = Piece[_Pid][_Dir];
//if (LY<P.LY) return false;
int SX=DX-1+P.SDel, SY=(LY-P.LY)/2+1;
SY = max(1,min(LY-P.LY+1,SY));
SX = max(2,min(LX,SX));
int Inc = 0;
if (Clutch) {
while ((SX+Inc<LX+5)&&(!CheckSpawn(_Pid,_Dir,Inc))) ++Inc;
SX += Inc;
}
for (int i=0; i<P.LX; ++i) {
for (int j=0; j<P.LY; ++j) {
if ((CheckPlace(SX+i,SY+j))&&(P.B[i][j])) return false;
}
}
if (Inc) {
double asz = sz*0.7;
sprintf(buf, "+ %d +", Inc);
TQu.push_back({-asz*1.5,sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0004,buf,0xFFFFFF});
}
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
B[i][j]=C[i][j]=0; LE[i][j]=10000;
}
}
}
for (int i=0; i<P.LX; ++i) {
for (int j=0; j<P.LY; ++j) {
if (P.B[i][j]) {
C[SX+i][SY+j]=1; B[SX+i][SY+j]=_Pid;
}
}
}
for (int i=1; i<=LY; ++i) PieceCol[i]=false;
Pid=_Pid; Dir=_Dir;
DrdLeft = DRD;
savx=savy=tavx=tavy=-100.0;
return true;
}
bool CheckUp() {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((C[i][j])&&(CheckPlace(i+1,j))) return false;
}
}
return true;
}
bool MoveUp() {
if (!CheckUp()) return false;
for (int i=LX; i>1; --i) {
for (int j=1; j<=LY; ++j) {
if (C[i-1][j]) {
B[i][j]=B[i-1][j]; C[i][j]=1;
B[i-1][j]=C[i-1][j]=0;
}
}
}
MiniSpin = false;
return true;
}
bool CheckDown() {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((C[i][j])&&(CheckPlace(i-1,j))) return false;
}
}
return true;
}
bool MoveDown() {
if (!CheckDown()) return false;
for (int i=1; i<LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i+1][j]) {
B[i][j]=B[i+1][j]; C[i][j]=1;
B[i+1][j]=C[i+1][j]=0;
}
}
}
MiniSpin = false;
return true;
}
bool DeepDrop() {
int dd = 0;
for (int d=1; d<=LX; ++d) {
bool ok = true;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (!C[i][j]) continue;
if (CheckPlace(i-d,j)) {
ok=false; break;
}
}
if (!ok) break;
}
if (ok) {
dd=d; break;
}
}
if (!dd) return false;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (!C[i][j]) continue;
C[i-dd][j]=true; C[i][j]=false;
B[i-dd][j]=B[i][j]; B[i][j]=0;
}
}
MiniSpin = false;
return true;
}
bool CheckLeft() {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((C[i][j])&&(CheckPlace(i,j-1))) return false;
}
}
return true;
}
bool MoveLeft() {
if (!CheckLeft()) {
if ((MoveEff)&&(sz>15)&&(!Bot)) DropKY=max(-sz*2,DropKY-sz);
if (DropKY>sz*2) DropKY=sz*2;
if (DropKY<-sz*2) DropKY=-sz*2;
return false;
}
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j+1]) {
B[i][j]=B[i][j+1]; C[i][j]=1;
B[i][j+1]=C[i][j+1]=0;
}
}
}
MiniSpin = false;
return true;
}
bool CheckRight() {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((C[i][j])&&(CheckPlace(i,j+1))) return false;
}
}
return true;
}
bool MoveRight() {
if (!CheckRight()) {
if ((MoveEff)&&(sz>15)&&(!Bot)) DropKY=min(sz*2,DropKY+sz);
if (DropKY>sz*2) DropKY=sz*2;
if (DropKY<-sz*2) DropKY=-sz*2;
return false;
}
for (int i=1; i<=LX; ++i) {
for (int j=LY; j; --j) {
if (C[i][j-1]) {
B[i][j]=B[i][j-1]; C[i][j]=1;
B[i][j-1]=C[i][j-1]=0;
}
}
}
MiniSpin = false;
return true;
}
bool ResetDec = false;
int QueryLen() {
int res = 0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<LY; ++j) {
if (D[i][j]!=D[i][j+1]) ++res;
if ((i<LX)&&(D[i][j]!=D[i+1][j])) ++res;
}
if (!D[i][1]) ++res;
if (!D[i][LY]) ++res;
}
for (int j=1; j<=LY; ++j) {
if (!D[1][j]) ++res;
if (!D[LX][j]) ++res;
}
return res;
}
bool Rotate(int NewDir, int NewPid=0) {
ResetDec = false;
int del = (Dir-NewDir+4)&3;
if (!NewPid) NewPid=Pid;
if ((NewDir<0)||(NewDir>3)||(!Pid)) return false;
int FstX=0, FstY=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
FstX=i; FstY=j; break;
}
}
if (FstX) break;
}
if (!FstX) return false;
if (((LqOS)||(LqC>=17))&&(!Bot)&&(Pid==4)&&(NewPid==4)&&(((!CheckLeft())&&(!CheckRight()))||((LqOS)&&((!CheckUp())||(!CheckDown())||(!CheckLeft())||(!CheckRight()))))) {
vector<pair<int,int> > CLst;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (!C[i][j]) continue;
if ((C[i+1][j])&&(C[i][j+1])&&(!C[i+1][j+1])) continue;
if ((C[i+1][j])&&(C[i][j-1])&&(!C[i+1][j-1])) continue;
if ((C[i-1][j])&&(C[i][j+1])&&(!C[i-1][j+1])) continue;
if ((C[i-1][j])&&(C[i][j-1])&&(!C[i-1][j-1])) continue;
if ((C[i-1][j])&&(C[i+1][j])) continue;
if ((C[i][j-1])&&(C[i][j+1])) continue;
CLst.push_back(make_pair(i,j));
}
}
set<pair<pair<int,int>,pair<int,int> > > st;
pair<pair<int,int>,pair<int,int> > Bst = make_pair(make_pair(0,0),make_pair(0,0));
st.insert(Bst);
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
D[i][j] = (B[i][j]>0);
if (!C[i][j]) continue;
for (int ii=-1; ii<=1; ++ii) {
for (int jj=-1; jj<=1; ++jj) {
if (abs(ii)+abs(jj)!=1) continue;
int x=i+ii, y=j+jj;
if ((min(x,y)<1)||(x>LX)||(y>LY)) continue;
if (B[x][y]) continue;
for (pair<int,int> o : CLst) {
if (make_pair(i,j)!=o) st.insert(make_pair(make_pair(x,y),o));
}
}
}
}
}
pair<int,int> Rec = make_pair(99999999,0);
int len = QueryLen();
for (pair<pair<int,int>,pair<int,int> > o : st) {
//printf("(%d,%d),(%d,%d)\n",o.first.first,o.first.second,o.second.first,o.second.second);
if (o.first.first) {
D[o.first.first][o.first.second] = 1;
D[o.second.first][o.second.second] = 0;
}
int val = 0;
if (((Dir+3)&3)==NewDir) val=(o.first.second-o.second.second)*100+o.first.second;
if (((Dir+2)&3)==NewDir) val=(o.first.first-o.second.first)*100+o.first.first;
if (((Dir+1)&3)==NewDir) val=(o.second.second-o.first.second)*100-o.first.second;
val = val*100+o.first.first;
pair<int,int> Now = make_pair(val,QueryLen());
if (!o.first.first) Now=make_pair(99999999,0);
if (Now<=Rec) {
Rec=Now; Bst=o;
}
if (o.first.first) {
D[o.first.first][o.first.second] = 0;
D[o.second.first][o.second.second] = 1;
}
}
if (Bst.first.first) {
pair<pair<int,int>,pair<int,int> > o = Bst;
B[o.first.first][o.first.second]=Pid; C[o.first.first][o.first.second]=true;
B[o.second.first][o.second.second]=0; C[o.second.first][o.second.second]=false;
Dir = 0;
ResetRem=max(0,ResetRem-1); ResetDec=true;
MiniSpin = false;
if ((!CheckUp())&&(!CheckDown())&&(!CheckLeft())&&(!CheckRight())) {
double x=0.0, y=0.0; int bn=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
++bn; x+=double(i); y+=double(j);
}
}
}
x=x/double(bn)-0.5; y=y/double(bn)+0.5;
double dx=sz*double(DX-x), dy=sz*double(y-1);
double th = rndf()*acos(-1.0)*2.0;
for (int i=0; i<10; ++i) {
th += acos(-1.0)*2.0/10.0;
PQu.push_back({dx,dy,sin(th)*0.1,cos(th)*0.1,0,0,sz*0.15,0.006,rndf()*acos(-1.0)*2.0,5,Mix(Piece[(Flipped)?Flip[Pid]:Pid][0].clr,0xFFFFFF,0.7)});
}
if (SpinEff) {
if (del==1) DropRot+=0.1;
if (del==3) DropRot-=0.1;
}
}
if ((CheckLeft())||(CheckRight())||(CheckDown())) LqC=0;
return true;
}
}
int SX=FstX-Piece[Pid][Dir].FstX, SY=FstY-Piece[Pid][Dir].FstY;
ClassPiece P = Piece[NewPid][NewDir];
bool flag = false;
int beg=Dir; if (beg&1) beg^=2;
int en=NewDir; if (en&1) en^=2;
bool fst = true;
for (pair<int,int> KT : Kick[Pid][beg][en]) {
if ((ResetLim)&&(!ResetRem)&&((KT.second>Shift[Pid][en].second-Shift[Pid][beg].second)||(Pid!=NewPid))&&(!Bot)) break;
SX+=KT.second; SY+=KT.first;
bool ok = true;
int iid=0, did=0;
for (int i=P.LX-1; i>=0; --i) {
for (int j=0; j<P.LY; ++j) {
++iid;
if ((P.B[i][j])&&(CheckPlace(SX+i,SY+j))) {
did=iid; ok=false; break;
}
}
if (!ok) break;
}
if ((KickTable=="ars")&&(fst)&&(did%3==2)&&((Pid==2)||(Pid==3)||(Pid==5))&&(!Bot)) break;
fst = false;
if (ok) {
if (((KT.second>Shift[Pid][en].second-Shift[Pid][beg].second)||(Pid!=NewPid))&&(!Bot)) {
ResetRem=max(0,ResetRem-1); if ((KickTable=="ars")&&(ResetRem)) ResetRem=max(ResetRem-999,1);
ResetDec = true;
}
flag=true; break;
}
else {
SX-=KT.second; SY-=KT.first;
}
}
if (!flag) return false;
MiniSpin = false;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) B[i][j]=C[i][j]=0;
}
}
for (int i=0; i<P.LX; ++i) {
for (int j=0; j<P.LY; ++j) {
if (P.B[i][j]) {
B[SX+i][SY+j]=NewPid; C[SX+i][SY+j]=1;
}
}
}
if (Pid!=NewPid) Flipped^=1;
Dir = NewDir;
Pid = NewPid;
double bavx=0.0, bavy=0.0;
bool ckd = CheckDown();
if (RotEff) {
int tot=0, totx=0, toty=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
totx+=i; toty+=j; ++tot;
}
}
}
if (tot) {
bavx = double(totx)/double(max(tot,1))-0.5+DXDel;
bavy = double(toty)/double(max(tot,1))-0.5;
if ((DropEff)&&(ckd)) bavx-=max(0.0,min(1.0,double(DropTime)/double(max(1,DropL))));
if ((GarbageType!="fall")&&(GarbRise)) bavx-=double(max(0,min(GarbRise-LastGarb,GarbRise)))/double(GarbRise);
}
}
if (del==1) RotEffVal-=acos(-1.0)*0.5;
if (del==3) RotEffVal+=acos(-1.0)*0.5;
if (del==2) {
if (RotType==1) RotEffVal-=acos(-1.0);
else RotEffVal+=acos(-1.0);
}
if (del) {
double nx = bavx-savx;
double ny = bavy-savy;
savx = (savx+bavx)*0.5;
savy = (savy+bavy)*0.5;
if (del==1) {
savx+=ny*0.5; savy-=nx*0.5;
}
if (del==3) {
savx-=ny*0.5; savy+=nx*0.5;
}
}
if (Pid==4) {
if (((KickTable=="default")||(KickTable=="extend")||(KickTable=="asc+"))&&((!CheckLeft())&&(!CheckRight())&&(!CheckDown()))) ++LqC;
else LqC=0;
}
else LqC=0;
if ((!CheckUp())&&(!CheckDown())&&(!CheckLeft())&&(!CheckRight())) {
double x=0.0, y=0.0; int bn=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
++bn; x+=double(i); y+=double(j);
}
}
}
x=x/double(bn)-0.5; y=y/double(bn)+0.5;
double dx=sz*double(DX-x), dy=sz*double(y-1);
double th = rndf()*acos(-1.0)*2.0;
for (int i=0; i<10; ++i) {
th += acos(-1.0)*2.0/10.0;
PQu.push_back({dx,dy,sin(th)*0.1,cos(th)*0.1,0,0,sz*0.15,0.006,rndf()*acos(-1.0)*2.0,5,Mix(Piece[(Flipped)?Flip[Pid]:Pid][0].clr,0xFFFFFF,0.7)});
}
if (SpinEff) {
if (del==1) DropRot+=0.1;
if (del==3) DropRot-=0.1;
}
}
else if (!CheckDown()) {
bool hp=false, ok=true; int nc=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (!C[i][j]) continue;
if (int(C[i-1][j])+int(C[i+1][j])+int(C[i][j-1])+int(C[i][j+1])+int(C[i-1][j-1])+int(C[i-1][j+1])+int(C[i+1][j-1])+int(C[i+1][j+1])<3) continue;
if (int(CheckFill(i-1,j-1))+int(CheckFill(i+1,j-1))+int(CheckFill(i-1,j+1))+int(CheckFill(i+1,j+1))<3) ok=false;
if (int(CheckPlace(i-1,j-1))+int(CheckPlace(i+1,j-1))+int(CheckPlace(i-1,j+1))+int(CheckPlace(i+1,j+1))<3) ++nc;
hp = true;
}
}
if ((!hp)||(nc>1)||(del==2)) ok=false;
if (SpinRule=="easy") ok=true;
if (ok) {
MiniSpin = true;
double x=0.0, y=0.0; int bn=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
++bn; x+=double(i); y+=double(j);
}
}
}
x=x/double(bn)-0.5; y=y/double(bn)+0.5;
double dx=sz*double(DX-x), dy=sz*double(y-1);
double th = rndf()*acos(-1.0)*2.0;
for (int i=0; i<5; ++i) {
th += acos(-1.0)*2.0/5.0;
PQu.push_back({dx,dy,sin(th)*0.1,cos(th)*0.1,0,0,sz*0.1,0.006,rndf()*acos(-1.0)*2.0,5,Mix(Piece[(Flipped)?Flip[Pid]:Pid][0].clr,0xFFFFFF,0.7)});
}
}
}
return true;
}
int RollHole(int Luck=_Luck, bool NoSame=false) {
if (!Luck) {
if ((LstHole<1)||(LstHole>LY)) return rnd(LY)+1;
if (NoSame) {
int x = rnd(LY-1)+1;
return (x==LstHole)?LY:x;
}
return rnd(LY)+1;
}
vector<int> Ord(LY,0), W(LY,0);
int Height = 0;
int GarbPos = 0;
for (int i=1; i<=LX; ++i) {
bool Garb = false;
for (int j=1; j<=LY; ++j) {
if (CheckPlace(i,j)) Height=i;
if (B[i][j]==154) Garb=true;
}
if (Garb) {
for (int j=1; j<=LY; ++j) {
if (!B[i][j]) GarbPos=j;
}
}
}
for (int j=1; j<=LY; ++j) {
Ord[j-1] = j;
int Hole = 0;
for (int i=1; i<=LX; ++i) {
if (!CheckPlace(i,j)) {
Hole=i; break;
}
}
HoleEval[j] = Height-Hole;
if (GarbPos) HoleEval[j]+=5*abs(GarbPos-j);
}
shuffle(Ord.begin(), Ord.end(), rng);
stable_sort(Ord.begin(), Ord.end(), [](int x, int y) {
return HoleEval[x]>HoleEval[y];
});
int SW = 0;
for (int i=0; i<LY; ++i) {
W[i]=max(0,90+Luck*(10-i*2)); if ((NoSame)&&(Ord[i]==LstHole)) W[i]=0;
SW += W[i];
}
if (!SW) {
if ((LstHole<1)||(LstHole>LY)) return rnd(LY)+1;
if (NoSame) {
int x = rnd(LY-1)+1;
return (x==LstHole)?LY:x;
}
return rnd(LY)+1;
}
int Pick = rnd(SW);
for (int i=0; i<LY; ++i) {
if (Pick<W[i]) return Ord[i];
Pick -= W[i];
}
return 1;
}
lll RollGarb() {
if (!ClearTemplate.empty()) return ClearTemplate[(TemplatePos++)%ClearTemplate.size()];
if ((LstHole<1)||(LstHole>LY)) LstHole=RollHole(_Luck);
lll gb = (lll(1)<<(LY+1))-1-(lll(1)<<LstHole);
if (ModHold==2) {
if (LstHole==1) gb&=~(lll(1)<<(LstHole+1));
else gb&=~(lll(1)<<(LstHole-1));
}
if (GarbageShape=="full") gb=(lll(1)<<(LY+1))-1;
if (GarbageShape=="empty") gb=0;
if (GarbageShape=="random") {
for (int i=1; i<=LY; ++i) {
if (rnd(2)) gb&=~(lll(1)<<i);
}
}
if (GarbageShape=="bubble") gb^=(lll(1)<<(LY+1))-1;
if (GarbageShape=="board") {
LstHole ^= 1;
gb = (lll(1)<<(LY+1))-1;
for (int i=1; i<=LY; ++i) {
if ((i+LstHole)&1) gb&=~(lll(1)<<i);
}
}
if ((!rnd(3))&&(ModDivergence==1)) gb&=~(lll(2)<<rnd(LY));
if (ModDivergence==2) {
for (int i=0; i<6; ++i) gb&=~(lll(2)<<rnd(LY));
}
if (GarbageShape=="copy") {
gb = lll(0);
for (int i=1; i<=LY; ++i) {
if (CheckPlace(1,i)) gb|=(lll(1)<<i);
}
if (ActiveGarb.size()) gb=ActiveGarb.back().second;
if (Rec.size()) gb=Rec.back().second.first;
}
return gb;
}
int Spin, SemiSpin; double ravx=0.0, ravy=0.0;
void Lock() {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) PieceCol[j]=true;
}
}
savx=savy=tavx=tavy=-100.0;
if ((DropKX<=sz*15)&&(MoveEff)) DropKX+=sz*3;
if ((ClearGravity=="sticky")||(ClearGravity=="cascade")||(ClearGravity=="separate")) InChain=true;
if ((Arcade)&&(Level%100!=99)&&((Zen)||(Level!=998))) ++Level;
Spin = ((!CheckUp())&&(!CheckDown())&&(!CheckLeft())&&(!CheckRight()));
SemiSpin = false;
if (Spin) {
bool ex=false, sw=false, a3=false, ew=false;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
int td=0, te=0;
for (int ii=-1; ii<=1; ++ii) {
for (int jj=-1; jj<=1; ++jj) {
int dis = abs(ii)+abs(jj);
if ((dis==1)&&((!CheckPlace(i+ii,j+jj)&&(C[i+ii][j+jj])))) ++td;
if ((dis==1)&&((!CheckPlace(i+ii,j+jj)&&(!B[i+ii][j+jj])))) ++te;
}
}
if ((C[i][j])&&(te>1)) ex=true;
if ((C[i][j])&&(te>2)) a3=true;
if ((!B[i][j])&&(td>1)) sw=true;
if ((!C[i][j])&&(td>1)) ew=true;
}
}
SemiSpin = (((ex)&&((sw)||(!ew)))||(a3));
}
if (!Complete) ++SumPiece;
int totx=0, toty=0, tot=0;
for (int j=1; j<=LY; ++j) {
bool ok = false;
for (int i=LX-1; i; --i) {
if (C[i+1][j]) ok=true;
if ((B[i][j]==151)&&(ok)) {
for (int jj=1; jj<=LY; ++jj) {
B[i][jj]=151; LE[i][jj]=10000;
}
}
else ok=false;
}
}
int Lines = 0;
vector<lll> Shape;
for (int i=1; i<=LX; ++i) {
if (i<=RoundHeight) continue;
bool ok=true; lll gb=lll(0);
for (int j=1; j<=LY; ++j) {
if ((!B[i][j])||(B[i][j]==153)) ok=false;
if (!C[i][j]) gb|=(lll(1)<<j);
}
if (ok) {
++Lines; Shape.push_back(gb);
}
}
if (Lines) {
if (GarbageShape=="arcade") reverse(Shape.begin(),Shape.end());
ClearShape = Shape;
}
++PartID;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
totx+=i; toty+=j; ++tot;
C[i][j]=0; LE[i][j]=10000; ID[i][j]=PartID;
if (Flipped) B[i][j]=Flip[B[i][j]];
}
}
}
memset(C, 0, sizeof(C));
avx = double(totx)/double(max(tot,1));
avy = double(toty)/double(max(tot,1));
ravx = sz*double(DX-avx)+sz*0.5+KX;
ravy = sz*double(avy-1)+sz*0.5+KY;
AreLeft = (Lines)?LCD:ARE;
for (int i=VanishHeight+1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]) {
double dx=sz*double(DX-i)+sz*0.5, dy=sz*double(j-1)+sz*0.5;
#define sq(beg, ss, clr) PQu.push_back({dx,dy,vx,vy,0.001,0,sz*0.5*ss,0.002,theta,4,clr})
double vx = -0.7+0.2*(rnd(10000)*0.0001);
double vy = 0.2*(rnd(10000)*0.0001-0.5);
double theta = acos(-1.0)*rndf();
int clr = Mix(Piece[B[i][j]][0].clr,0xFFFFFF,0.7);
sq(0, 1, clr);
#undef sq
B[i][j]=C[i][j]=LE[i][j]=ID[i][j]=0;
}
}
}
if ((Next.size())&&(!CheckSpawn(Next[0],InitFacing))) AreLeft=max(AreLeft,DeathARE);
DcdLeft=DCD; HcdLeft=HCD; DrdLeft=DRD;
}
void HardDrop() {
while (CheckDown()) {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
double dx=sz*double(DX-i)+sz*rndf(), dy=sz*double(j-1)+sz*rndf();
PQu.push_back({dx,dy,-1,0,0,0,2,0.01,rndf()*acos(-1.0),4,Mix(0xFFFFFF,Piece[B[i][j]][0].clr,0.3)});
}
}
}
MoveDown(); if ((!QuickPlay)&&(!Complete)) Score+=2;
}
Lock();
}
bool Dig = false;
bool RVis[111][55]; int RBel[111][55];
vector<pair<int,int> > Group;
void RDfs(int x, int y) {
RVis[x][y] = true;
Group.push_back(make_pair(x,y));
if (ClearGravity=="separate") return;
for (int ii=-1; ii<=1; ++ii) {
for (int jj=-1; jj<=1; ++jj) {
if (abs(ii)+abs(jj)!=1) continue;
int nx=x+ii, ny=y+jj;
if ((!B[nx][ny])||(RVis[nx][ny])) continue;
if ((ClearGravity=="cascade")&&(ID[nx][ny]!=ID[x][y])) continue;
RDfs(nx, ny);
}
}
}
bool PieceCol[55];
int RemoveLines() {
int res=0; Dig=false;
int low = 0;
for (int i=1; i<=LX; ++i) {
if (i<=RoundHeight) continue;
bool ok=true, garb=false;
for (int j=1; j<=LY; ++j) {
if (!CheckPlace(i,j)) ok=false;
if (B[i][j]==153) ok=false;
if (B[i][j]>150) garb=true;
}
if (!ok) continue;
if (garb) {
Dig=true; if (!Complete) ++SumDig;
}
for (int j=1; j<=LY; ++j) {
double dx=sz*double(DX-i-res)+sz*0.5, dy=sz*double(j-1)+sz*0.5;
PQu.push_back({dx,dy,-0.7+0.2*(rnd(10000)*0.0001),0.2*(rnd(10000)*0.0001-0.5),0.003,0,sz*0.12,0.001,rnd(10000)*0.0002*acos(-1.0),12,((ClearGravity=="sticky")||(ClearGravity=="cascade")||(ClearGravity=="separate"))?0x99FFFF:Piece[B[i][j]][0].clr});
}
++res; if (!low) low=i;
if (ClearGravity!="default") {
for (int j=1; j<=LY; ++j) B[i][j]=C[i][j]=LE[i][j]=ID[i][j]=0;
continue;
}
for (int j=i; j<LX; ++j) {
for (int k=1; k<=LY; ++k) {
B[j][k]=B[j+1][k]; C[j][k]=C[j+1][k]; LE[j][k]=LE[j+1][k]; ID[j][k]=ID[j+1][k];
}
}
for (int j=1; j<=LY; ++j) B[LX][j]=C[LX][j]=LE[LX][j]=ID[LX][j]=0;
--i;
}
if ((res)&&((ClearGravity=="sticky")||(ClearGravity=="cascade")||(ClearGravity=="separate"))) {
for (int i=1; i<=LX; ++i) {
RVis[i][0]=RVis[i][LY+1]=true;
for (int j=1; j<=LY; ++j) {
RVis[i][j]=false; RVis[j][0]=RVis[j][LX+1]=true;
PrePos[i][j] = i;
}
}
if (ClearGravity=="separate") {
for (int i=1; i<low; ++i) {
for (int j=1; j<=LY; ++j) RVis[i][j]=true;
}
}
vector<vector<pair<int,int> > > Groups;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((B[i][j])&&(!RVis[i][j])) {
Group.clear(); RDfs(i,j);
sort(Group.begin(), Group.end());
Groups.push_back(Group);
}
}
}
for (;;) {
memset(RBel, 0, sizeof(RBel));
for (int i=0; i<Groups.size(); ++i) {
for (pair<int,int> o : Groups[i]) RBel[o.first][o.second]=i+1;
}
vector<int> ok;
for (int i=0; i<Groups.size(); ++i) {
bool curr = true;
for (pair<int,int> o : Groups[i]) {
if ((o.first==1)||((B[o.first-1][o.second])&&(!RBel[o.first-1][o.second]))||((RBel[o.first-1][o.second])&&(RBel[o.first-1][o.second]!=RBel[o.first][o.second]))) {
curr=false; break;
}
}
if (curr) ok.push_back(i);
}
if (ok.empty()) break;
for (int i : ok) {
for (pair<int,int> o : Groups[i]) {
int x=o.first, y=o.second;
B[x-1][y]=B[x][y]; LE[x-1][y]=LE[x][y]; ID[x-1][y]=ID[x][y];
B[x][y]=LE[x][y]=ID[x][y]=0;
PrePos[x-1][y] = PrePos[x][y];
}
for (int j=0; j<Groups[i].size(); ++j) --Groups[i][j].first;
}
}
}
return res;
}
void GiveScore(int x, bool Ignore=false) {
if (Complete) return;
if (!QuickPlay) return;
if ((Odoo)&&(!Ignore)) x*=2;
if ((Ignore)&&(ModExpert==2)) {
x = x*(CurFloor*CurFloor+CurFloor+10)/20;
Score=max(Floor[max(0,CurFloor-1)],Score-ll(x)); return;
}
if ((CurFloor<Floor.size())&&(Score>=Floor[CurFloor])) {
++CurFloor; FloorTm=0;
sprintf(buf, "Floor %d", CurFloor);
double asz = sz*0.12*double(LY);
TQu.push_back({sz*0.2*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.00006,buf,0xFFCCCC});
sprintf(buf, "%lld m", Floor[CurFloor-1]/1000LL);
asz = sz*0.1*double(LY);
TQu.push_back({sz*0.3*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.1,0.00003,buf,0xFFCCCC});
}
ll pre = Score;
Score += (x*(Acc+1))/4;
int rem = x*(Acc+1)%4;
if (rnd(4)<rem) ++Score;
if (!Ignore) {
int del = int(Score-pre);
if (!del) return;
double asz = sz*0.08*double(LY);
sprintf(buf, "+%lld.%lld", del/1000, del/100%10);
double remtm = sqrt(max(0.0,double(del)*4.0/double(Acc+1)))/30.0;
TQu.push_back({sz*0.95*double(DX+2),sz*0.5*double(LY)-asz*0.7,asz,0.2,min(0.0003,max(0.00002,0.001/remtm)),buf,0x99FFFF});
}
}
void EText(string str, int clr) {
double asz = sz*0.06*double(LY);
TQu.push_back({sz*0.95*double(DX+2)+asz,sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0003,str,clr});
}
int B2BClr(int x) {
vector<pair<int,int> > lst={{4,0x00FFCC},{13,0xFFFF00},{31,0xFF0000},{45,0xDF3782},{70,0xAF2FFF},{90,0x0080FF},
{130,0x66CCFF},{150,0x99FFFF},{220,0xE5E59C}};
for (int i=1; i<lst.size(); ++i) {
if ((lst[i-1].first<=x)&&(x<=lst[i].first)) return Mix(lst[i].second,lst[i-1].second,double(x-lst[i-1].first)/double(lst[i].first-lst[i-1].first));
}
if (x<=lst[0].first) return lst[0].second;
return lst.back().second;
}
int QueryLev() {
if (Arcade) return 0;
int res = LevBase;
if (LevLine) {
int x=SumLine, val=LevLine;
while (res<100) {
if (x<val) break;
x-=val; val+=LevLineInc;
++res;
}
}
if (LevTime) {
int x=int((clock()-begtm-BegDelay)/1000LL), val=LevTime;
while (res<100) {
if (x<val) break;
x-=val; val+=LevTimeInc;
++res;
}
}
if (LevPiece) {
int x=SumPiece, val=LevPiece;
while (res<100) {
if (x<val) break;
x-=val; val+=LevPieceInc;
++res;
}
}
if (LevAttack) {
int x=SumPiece, val=LevAttack;
while (res<100) {
if (x<val) break;
x-=val; val+=LevAttackInc;
++res;
}
}
return max(0,min(100,max(res,LevStart)));
}
void PaintText(int tm) {
#warning text
ll timer = max(0LL,clock()-begtm-BegDelay);
double tsz=sz*0.6, tx=sz*max(DX,22);
if (max(Life,Stock)) {
tx += tsz*4.7;
sprintf(buf, "/ %d", Stock+1);
tx-=tsz; PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, 0xFF6666);
sprintf(buf, "%d", Life+1);
tx-=tsz*1.5; PaintStrR(buf,tx,-tsz*3.5,tsz,0xFF6666);
tx-=tsz*1.2; PaintStrR("LIFE", tx, -tsz*3.5, tsz*0.8, TextColor);
tx -= tsz;
}
sprintf(buf, "%.2f /m", double(SumAttack)*60000.0/double(timer));
tx-=tsz; PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, StatColor);
if ((QuickPlay)&&(Plrs>1)) {
sprintf(buf, "Rnk #%d", VSRnk);
PaintStrL(buf, tx+tsz*0.2, sz*LY+tsz*1.5, tsz*0.6, StatColor);
}
else if (QuickPlay) {
sprintf(buf, "Floor %d", QueryFloor());
PaintStrL(buf, tx+tsz*0.2, sz*LY+tsz*1.5, tsz*0.6, StatColor);
}
else if (Plrs>2) {
sprintf(buf, "%.2f VS", double(SumAttack+SumDig)*100000.0/double(timer));
PaintStrL(buf, tx+tsz*0.2, sz*LY+tsz*1.5, tsz*0.6, StatColor);
}
else if (Arcade) {
sprintf(buf, "/ %d", (Zen)?100*(Level/100+1):min(999,100*(Level/100+1)));
PaintStrL(buf, tx+tsz*0.2, sz*LY+tsz*1.5, tsz*0.6, StatColor);
}
else if ((Plrs==1)&&(!Zen)) {
sprintf(buf, "%.2f /p", double(Score)/max(1,SumPiece));
PaintStrL(buf, tx+tsz*0.2, sz*LY+tsz*1.5, tsz*0.6, StatColor);
}
sprintf(buf, "%d", (SumAttack<TarAttack)?TarAttack-SumAttack:SumAttack);
tx-=tsz*1.5; PaintStrR(buf, tx, -tsz*3.5, tsz, (TarAttack)?((SumAttack>=TarAttack)?0x00FFCC:0xFDD000):StatColor);
if ((Plrs>2)&&(!QuickPlay)) {
sprintf(buf, "%2d", VSRnk);
PaintStrL(buf, tx, sz*LY+tsz*1.5, tsz, StatColor);
sprintf(buf, " /%2d", PlrsCnt);
PaintStrL(buf, tx+tsz*0.6, sz*LY+tsz*4.5, tsz*0.6, StatColor);
sprintf(buf, " /%2d", Plrs);
PaintStrL(buf, tx-tsz, sz*LY+tsz*4.5, tsz*0.6, TextColor);
}
else if ((Plrs==2)&&(!QuickPlay)) {
sprintf(buf, "%.2f", double(SumAttack+SumDig)*100000.0/double(timer));
PaintStrL(buf, tx, sz*LY+tsz*1.5, tsz, StatColor);
}
else {
if (Score<=DisScore) DisScore=Score;
else {
ll del = Score-DisScore;
del = min(del,max(1LL,del/10LL));
DisScore += del;
}
ll dd = (DisScore<ll(TarScore))?ll(TarScore)-DisScore:DisScore;
if (QuickPlay) sprintf(buf, "%lld.%02lld", dd/1000LL, dd/10LL%100LL);
else if (Arcade) sprintf(buf, "%d", (Zen)?Level:min(999,Level));
else sprintf(buf, "%lld", dd);
PaintStrL(buf, tx, sz*LY+tsz*1.5, tsz, (TarScore)?((DisScore>=ll(TarScore))?0x00FFCC:0xFDD000):StatColor);
}
tx-=tsz*1.2; PaintStrR("ATTACK", tx, -tsz*3.5, tsz*0.8, TextColor);
if ((Plrs>2)&&(!QuickPlay)) PaintStrL("RANK", tx, sz*LY+tsz*1.5, tsz*0.8, TextColor);
else if ((Plrs==2)&&(!QuickPlay)) PaintStrL("VS SCORE", tx, sz*LY+tsz*1.5, tsz*0.8, TextColor);
else if (Arcade) PaintStrL("LEVEL", tx, sz*LY+tsz*1.5, tsz*0.8, TextColor);
else PaintStrL("SCORE", tx, sz*LY+tsz*1.5, tsz*0.8, TextColor);
tx -= tsz;
sprintf(buf, "%.2f /m", double(SumLine)*60000.0/double(timer));
tx-=tsz; PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, StatColor);
sprintf(buf, "%d", (SumLine<TarLine)?TarLine-SumLine:SumLine);
tx-=tsz*1.5; PaintStrR(buf, tx, -tsz*3.5, tsz, (TarLine)?((SumLine>=TarLine)?0x00FFCC:0xFDD000):StatColor);
tx-=tsz*1.2; PaintStrR("LINE", tx, -tsz*3.5, tsz*0.8, TextColor);
tx -= tsz;
sprintf(buf, "%.2f /s", double(SumPiece)*1000.0/double(timer));
tx-=tsz; PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, StatColor);
sprintf(buf, "%d", (SumPiece<TarPiece)?TarPiece-SumPiece:SumPiece);
tx-=tsz*1.5; PaintStrR(buf, tx, -tsz*3.5, tsz, (TarPiece)?((SumPiece>=TarPiece)?0x00FFCC:0xFDD000):StatColor);
tx-=tsz*1.2; PaintStrR("PIECE", tx, -tsz*3.5, tsz*0.8, TextColor);
ll _tmr = timer;
if ((TarTime)&&(_tmr<ll(TarTime))) timer=ll(TarTime)-_tmr;
tx -= tsz;
sprintf(buf, ".%03d",timer%1000);
tx-=tsz*1.5; PaintStrR(buf, tx+tsz*0.2, -tsz*3.5, tsz*0.8, (TarTime)?((_tmr>=ll(TarTime))?0x00FFCC:0xFDD000):StatColor);
sprintf(buf, "%02d:%02d",timer/60000,timer/1000%60);
PaintStrR(buf, tx, -tsz*6.5, tsz, (TarTime)?((_tmr>=ll(TarTime))?0x00FFCC:0xFDD000):StatColor);
timer = _tmr;
tx-=tsz*1.2; PaintStrR("TIME", tx, -tsz*3.5, tsz*0.8, TextColor);
if ((Plrs>2)||(QuickPlay)) {
tx -= tsz;
sprintf(buf, "%d KO\'s", KO);
tx-=tsz; if (Plrs>1) PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, StatColor);
if (QuickPlay) sprintf(buf,"%d",Acc);
else sprintf(buf,"%d",SKO);
tx-=tsz*1.5; PaintStrR(buf, tx, -tsz*3.5, tsz, StatColor);
tx-=tsz*1.2; PaintStrR((QuickPlay)?"BOOST":"BADGE", tx, -tsz*3.5, tsz*0.8, TextColor);
}
else if (Plrs==2) {
tx -= tsz;
sprintf(buf, "of %d", RoundTot);
tx-=tsz; PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, StatColor);
sprintf(buf, "%d", Wins);
tx-=tsz*1.5; PaintStrR(buf, tx, -tsz*3.5, tsz, StatColor);
tx-=tsz*1.2; PaintStrR("POINT", tx, -tsz*3.5, tsz*0.8, TextColor);
}
else if (Arcade) {
tx -= tsz;
int gr = max(0,SegGrade[min(int(SegGrade.size())-1,Grade)]+SumCool-SumRegret+min(8,InvisGrade/100));
if (ArcadeInvis) sprintf(buf,"+ %d.%02d +",InvisGrade/100,InvisGrade%100);
else if (InvisTm)sprintf(buf, "+ GAME CLEAR +", Grade);
else sprintf(buf, "+ %d +", Grade);
tx-=tsz; PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, StatColor);
tx-=tsz*1.5; PaintStrR(GradeName[min(int(GradeName.size())-1,gr)], tx, -tsz*3.5, tsz, StatColor);
tx-=tsz*1.2; PaintStrR("GRADE", tx, -tsz*3.5, tsz*0.8, TextColor);
}
else if ((LevStart)||(LevBase)||(LevLine)||(LevTime)||(LevPiece)||(LevAttack)) {
tx -= tsz;
sprintf(buf, "%d", QueryLev());
tx-=tsz*1.5; PaintStrR(buf, tx, -tsz*3.5, tsz, StatColor);
tx-=tsz*1.2; PaintStrR("LEVEL", tx, -tsz*3.5, tsz*0.8, TextColor);
}
tx = sz*4.0;
SpinTm = max(((ModSpin)&&(SpinType==LstAct.first))?7500:0,SpinTm-tm*((SpinDis)?50:3));
int bg = Mix(0xFFFFFF,0x000000,BackgroundRatio);
double rat = double(SpinTm)/15000.0;
rat *= rat;
sprintf(buf, "%c-Spin", PName[SpinType]);
bool sp = ((AllSpinGarbOper)&&(SpinType==LstAct.first));
double spin = acos(-1.0)*max(rat-0.9,0.0)*10.0;
if ((sp)||((Bot)&&(OperTime<100))) spin=0.0;
if ((SpinType)&&(SpinTm)) {
if (SpinFull==2) PaintStrR(buf, tx, -tsz*3.5, tsz, Mix(Piece[SpinType][0].clr,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, spin);
else if (SpinFull==1) {
sprintf(buf, "Semi %c-Spin", PName[SpinType]);
PaintStrR(buf, tx+tsz*0.1, -tsz*3.5, tsz*0.8, Mix(Piece[SpinType][0].clr,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, spin);
}
else {
PaintStrR("Mini", tx-tsz*0.4, -tsz*3.5, tsz*0.7, Mix(Piece[SpinType][0].clr,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, spin);
PaintStrR(buf, tx+tsz*0.5, -tsz*3.5, tsz*0.7, Mix(Piece[SpinType][0].clr,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, spin);
}
}
tx += tsz*2.0;
ClearTm = max(((ModSpin)&&(ClearType==LstAct.second))?5000:0,ClearTm-tm*3);
bg = Mix(0xFFFFFF,0x000000,BackgroundRatio);
rat = double(ClearTm)/10000.0;
rat *= rat;
spin = acos(-1.0)*max(rat-0.9,0.0)*10.0;
double scale = max(rat-0.8,0.0);
if ((sp)||((Bot)&&(OperTime<100))) spin=0.0;
if (ClearType<4) scale=0.0;
sp = ((AllSpinGarbOper)&&(ClearType==LstAct.second));
if (ClearTm) {
if (ClearWType) {
sprintf(buf, "%d-WIDE", ClearWType);
PaintStrR(buf, tx, -tsz*3.5, tsz*0.8, Mix((ClearColor)?Mix(0xFFFFFF,Piece[ClearColor][0].clr,0.5):0xFFFFFF,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, (ClearColor)?spin:0, scale);
PaintStrR(LCW[ClearType], tx+tsz, -tsz*3.5, tsz*1.2, Mix((ClearColor)?Mix(0xFFFFFF,Piece[ClearColor][0].clr,0.5):0xFFFFFF,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, (ClearColor)?spin:0, scale);
}
else PaintStrR(LCW[ClearType], tx, -tsz*3.5, tsz*1.5, Mix((ClearColor)?Mix(0xFFFFFF,Piece[ClearColor][0].clr,0.5):0xFFFFFF,bg,rat), 0.05+0.1*rat, 1.5-0.5*rat, sp, (ClearColor)?spin:0, scale);
}
tx += tsz*2.5;
ComboTm = max((ComboType)?7500:0,ComboTm-tm*((ComboType)?10:50));
rat = double(ComboTm)/10000.0;
scale = max(rat-0.8,0.0);
if ((!ComboType)||((Bot)&&(OperTime<100))) scale=0.0;
if ((ComboRule=="c2")&&(ComboType)) rat=double(min(5000,ComboRem))/5000.0*0.6+0.4;
else if (ComboRule=="c2") {
rat=min(rat,0.4); ComboTm=min(ComboTm,4000);
}
sprintf(buf, "%d Combo", ComboType);
PaintStrR(buf, tx, -tsz*3.5, tsz, Mix((ComboType)?Mix(0xFFFFFF,0x39C5BB,(double(min(21,ComboType)-1)/20.0)):0x888888,bg,min(rat,0.75)/0.75), 0.05+0.1*rat, 1.5-0.5*rat, 0, 0,scale);
tx += tsz*1.8;
B2BTm = max((B2BType)?7500:0,B2BTm-tm*((B2BType)?10:50));
rat = double(B2BTm)/10000.0;
scale = max(rat-0.8,0.0);
if ((!B2BType)||((Bot)&&(OperTime<100))) scale=0.0;
if (B2BRule=="techmino") {
sprintf(buf, "B%dB %d%%", (B2BType>80)?3:((B2BType>=5)?2:bool(B2B)), B2BType);
int clr = 0x888888;
if (B2BType>=5) clr=0xFF6666;
if (B2BType>80) clr=0x9999FF;
PaintStrR(buf, tx, -tsz*3.5, tsz, Mix(clr,bg,min(rat,0.75)/0.75), 0.05+0.1*rat, 1.5-0.5*rat, 0, 0, scale);
}
else {
sprintf(buf, "B2B x%d", B2BType);
double ra = 1.0;
if ((B2BRule=="surge")&&(B2BType>3)) ra=pow(double(min(300,B2BType)-2),0.05);
PaintStrR((B2BRule=="default")?"Back to Back":buf, tx, -tsz*3.5, tsz*ra, Mix((B2BType)?(((B2BType>3)&&(B2BRule=="surge"))?B2BClr(B2BType):0xFDD000):0x888888,bg,min(rat,0.75)/0.75), (1.0+scale)*0.05+0.1*rat, 1.5-0.5*rat, 0, 0, scale);
}
}
#warning paint
void Paint(int tm) {
bool ckd = CheckDown();
if (RotEff) {
int tot=0, totx=0, toty=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
totx+=i; toty+=j; ++tot;
}
}
}
if (tot) {
tavx = double(totx)/double(max(tot,1))-0.5+DXDel;
tavy = double(toty)/double(max(tot,1))-0.5;
if ((DropEff)&&(ckd)) tavx-=max(0.0,min(1.0,double(DropTime)/double(max(1,DropL))));
if ((GarbageType!="fall")&&(GarbRise)) tavx-=double(max(0,min(GarbRise-LastGarb,GarbRise)))/double(GarbRise);
}
else tavx=tavy=savx=savy=-100.0;
}
DX += DXDel;
tm *= 2;
int brd = Mix(0xFFFFFF,0x000000,BoardRatio);
if (isz!=Ssz) {
double del = fabs(isz-Ssz);
double val = min(del,max(del*0.0008*tm,tm*0.002));
if (isz>Ssz) isz-=val;
else isz+=val;
}
DropKX = max(0.0,DropKX*double(1000-tm*10)/1000.0);
DropKY = DropKY*double(1000-tm*10)/1000.0;
DropRot = DropRot*double(1000-tm*2)/1000.0;
SKX += DropKX;
SKY += DropKY;
if (KX!=SKX) {
double del = fabs(KX-SKX);
double val = min(del,max(del*0.001*tm,tm*0.01));
if (KX>SKX) KX-=val;
else KX+=val;
}
if (KY!=SKY) {
double del = fabs(KY-SKY);
double val = min(del,max(del*0.001*tm,tm*0.01));
if (KY>SKY) KY-=val;
else KY+=val;
}
if (Rot!=DropRot) {
double del = fabs(Rot-DropRot);
double val = min(del,max(del*0.00001*tm,tm*0.0001));
if (Rot>DropRot) Rot-=val;
else Rot+=val;
}
if (fabs(RotEffVal)>=0.001) {
double del = fabs(RotEffVal);
double val = min(del,max(del*0.001*tm,tm*0.01));
if (RotEffVal>0.0) RotEffVal-=val;
else RotEffVal+=val;
}
if (tavx>=-99.0) {
if ((savx<-99.0)||(fabs(RotEffVal)<0.001)) savx=tavx;
if (savx!=tavx) {
double del = fabs(savx-tavx);
double val = max(min(del,max(del*0.01*tm,tm*0.01)),del-1.0);
if (savx>tavx) savx-=val;
else savx+=val;
}
}
else savx=-100.0;
if (tavy>=-99.0) {
if ((savy<-99.0)||(fabs(RotEffVal)<0.001)) savy=tavy;
if (savy!=tavy) {
double del = fabs(savy-tavy);
double val = max(min(del,max(del*0.01*tm,tm*0.01)),del-1.0);
if (savy>tavy) savy-=val;
else savy+=val;
}
}
else savy=-100.0;
SKX -= DropKX;
SKY -= DropKY;
tm /= 2;
PaintText(tm);
int DropLen = 3321;
for (int j=1; j<=LY; ++j) {
int lst = 0;
for (int i=1; i<=LX; ++i) {
if (C[i][j]) DropLen=min(DropLen,i-lst-1);
else if (B[i][j]) lst=i;
}
}
sz = isz;
//sz=floor(sz); if (int(sz)&1) sz+=1.0;
deque<pair<int,pair<int,int> > > rec; deque<int> ps;
int ActiveTot=0;
for (pair<int,int> o : ActiveGarb) {
rec.push_back(make_pair(o.first,make_pair(o.second,-1LL))); ActiveTot+=o.first;
ps.push_back(0);
}
for (pair<int,pair<lll,ll> > o : Rec) {
rec.push_back(o); ps.push_back((int(clock()-o.second.second)<Passthrough)&&(Passthrough));
}
int RecTot=0; for (pair<int,pair<lll,ll> > o : rec) RecTot+=o.first;
int Mins = int((clock()-begtm-BegDelay)/60000LL);
int AggCap = 12;
if (Mins>=3) AggCap+=4;
if (Mins>=5) AggCap+=4;
if (Mins>=7) AggCap+=4;
int Agg = AggCap;
int Dg = 0;
int RecHeight = QueryHeight()+ActiveGarb.size();
for (pair<int,pair<lll,ll> > o : Rec) RecHeight+=o.first;
if ((RecHeight+7>DX)&&(!ModExpert)) Dg+=6;
if ((ModSpin==2)||(ModMess==2)||(ModDivergence==2)) {
int GarbC = 0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]==154) {
++GarbC; break;
}
}
}
Dg += min(GarbC,5)*2;
}
Dg = min(Dg,AggCap);
for (int i=1; i<=max(DX,24); ++i) {
if ((i<=10)&&(Arcade)) {
int clr = 0x555555;
if (i-1<=Level/100) clr=0xCCCCCC;
if (SegSta[i-1]>0) clr=0x66CCFF;
if (SegSta[i-1]<0) clr=0xEE0000;
Rectangle(sz*(double(DX)-0.5*double(i)), -10, sz*0.5-3, 3, clr);
}
if ((i<=24)&&(QuickPlay)) {
int clr = 0x555555;
if (i<=AggCap) clr=0xCCCCCC;
if (i<=Agg) clr=0xFDD000;
if (i<=Agg-AggDec) clr=0xEE0000;
if (i<=Dg) clr=0xFFAAAA;
if ((AggDec)&&(i==Agg-AggDec+1)) {
double rat = min(1.0,max(0.0,double(AggTm)/double(max(1,DecDis[min(int(DecDis.size()-1),QueryFloor())]))));
clr = Mix(0xFFA500,0xFDD000,rat);
}
Rectangle(sz*(double(DX)-0.5*double(i)), -10, sz*0.5-3, 3, clr);
}
if ((i<=8)&&(QuickPlay)) {
int clr = 0x555555;
if ((i==1)&&(ModHold)) clr=0xEE82EE;
if ((i==2)&&(ModMess)) clr=0xFFA500;
if ((i==3)&&(ModGravity)) clr=0xFDD000;
if ((i==4)&&(ModStrength)) clr=0xEE0000;
if ((i==5)&&(ModDivergence)) clr=0x0080FF;
if ((i==6)&&(ModInvisible)) clr=0x9999FF;
if ((i==7)&&(ModSpin)) clr=0x00FFCC;
if ((i==8)&&(ModExpert)) clr=0xFFFF00;
Rectangle(sz*(double(DX)-0.5*double(i)), -18, sz*0.5-3, 3, clr);
clr = 0;
if ((i==1)&&(ModHold==2)) clr=0xEE82EE;
if ((i==2)&&(ModMess==2)) clr=0xFFA500;
if ((i==3)&&(ModGravity==2)) clr=0xFDD000;
if ((i==4)&&(ModStrength==2)) clr=0xEE0000;
if ((i==5)&&(ModDivergence==2)) clr=0x0080FF;
if ((i==6)&&(ModInvisible==2)) clr=0x9999FF;
if ((i==7)&&(ModSpin==2)) clr=0x00FFCC;
if ((i==8)&&(ModExpert==2)) clr=0xFFFF00;
if (clr) Rectangle(sz*(double(DX)-0.5*double(i)),-22,sz*0.5-3,3,clr);
}
if (i<=Cy.size()) {
int base = 0xFFE211;
if (Cy[i-1].second==1) base=0xEE0000;
if (Cy[i-1].second==2) base=0x0080FF;
if (Cy[i-1].second==3) base=0x00FFCC;
if (Cy[i-1].second==4) base=0xEE82EE;
if (Cy[i-1].second==5) base=Mix(0x000000,0x33EE00,0.1);
if (Cy[i-1].second==6) base=0x66CCFF;
if (Cy[i-1].second==7) base=0xFFA500;
Rectangle(sz*double(DX-i)+2, sz*double(LY)+6, sz-7, 3, base);
}
if ((i<=7)&&(Odoo)) {
int base = 0x000000;
if (i==1) base=0xEE0000;
if (i==2) base=0x0080FF;
if (i==3) base=0x00FFCC;
if (i==4) base=0xEE82EE;
if (i==5) base=Mix(0x000000,0x33EE00,0.1);
if (i==6) base=0x66CCFF;
if (i==7) base=0xFFA500;
double rat = 0.0;
if (EV[i]) rat=min(1.0,0.2+double(EV[i])/200000.0*0.8);
Rectangle(sz*double(DX-i), sz*double(LY)+2, sz-3, 3, Mix(base,0x555555,rat));
}
if (i>DX) continue;
for (int j=1; j<=LY; ++j) {
int clr=GridColor; if (i+2>DX) clr=BufferColor;
if ((Style=="classic")||(Style=="arcade")) clr=brd;
if ((i==SelX)&&(j==SelY)) clr=0x39C5BB;
Square(sz*double(DX-i),sz*double(j-1),sz,clr);
Square(sz*double(DX-i)+sz*0.05,sz*double(j-1)+sz*0.05,sz*0.9,brd);
}
if (i>RecTot) {
Rectangle(sz*double(DX-i),-5,sz-3*sz/20.0,3,(i<=GarbageGap+ActiveTot)?SlotColor:OverSlotColor); continue;
}
bool flag=false, active=false, avail=false; int cur=0;
ll curt=clock(); int clr=0;
bool Pass = false;
int oid = 0;
for (pair<int,pair<lll,ll> > o : rec) {
if (cur+1==i) flag=true;
cur += o.first;
if (cur>=i) {
if (o.second.second<0LL) active=true;
else if (curt-ll(GarbDelay)>=o.second.second) avail=true;
else {
double rat = min(1.0,max(0.0,double(curt-o.second.second)/double(max(1,GarbDelay))));
clr = Mix(0xFFA500,0xFFE211,rat);
}
if (oid<ps.size()) Pass=ps[oid];
break;
}
++oid;
}
clr = (active)?0xDF3782:(((avail)?((i<=ActiveTot+GarbageGap)?0xEE0000:0xFF6666):clr));
if (Pass) clr=Mix(0xFFFFFF,clr,0.6);
Rectangle(sz*double(DX-i), -5, (flag)?sz-3:sz, 3, clr);
}
int bg = Mix(0xFFFFFF,0x000000,BackgroundRatio);
if (!RotEff) savx=savy=tavx=tavy=-100.0;
for (int i=1; i<=GarbagePreview; ++i) {
if (i>RecTot) break;
int cur=0; lll gb=lll(0);
for (pair<int,pair<lll,ll> > o : rec) {
cur += o.first;
if (cur>=i) {
gb=o.second.first; break;
}
}
for (int j=1; j<=LY; ++j) {
if ((GarbageType!="bomb")&&(!(gb&(lll(1)<<j)))) continue;
int clr = Mix(Mix(0xFFFFFF,0x000000,BackgroundRatio),Piece[154][0].clr,double(i-1)/double(GarbagePreview));
if (GarbageType=="bomb") clr=(gb&(lll(1)<<j))?0x444444:0xFFFF99;
if ((GarbageType=="solid")&&(gb&(lll(1)<<j))) clr=0x444444;
#define sq(beg, ss, clr) Square(sz*0.4+sz*double(DX-(1-i))+beg*sz,sz*double(j-1)+beg*sz,sz*ss,clr)
#define rec(begx, begy, sx, sy, clr) Rectangle(sz*0.4+sz*double(DX-(1-i))+sz*begx,sz*double(j-1)+sz*begy,sz*sx,sz*sy,clr)
if (sz<6) {
sq(0,1,clr); continue;
}
if (Style=="classic") {
sq(0, 1, brd);
sq(0.1, 0.8, clr);
sq(0.1, 0.1, Mix(0xFFFFFF,clr,0.5));
sq(0.2, 0.2, Mix(0xFFFFFF,clr,0.5));
sq(0.3, 0.1, clr);
continue;
}
if (Style=="arcade") {
clr = Mix(0x000000,clr,0.3);
sq(0, 1, Mix(0xFFFFFF,clr,0.5));
sq(0.1, 0.9, Mix(0x000000,clr,0.5));
sq(0.1, 0.8, clr);
rec(0.3, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.05));
rec(0.4, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.1));
rec(0.5, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.15));
rec(0.6, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.2));
rec(0.7, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.25));
rec(0.8, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.3));
continue;
}
if (Style=="simple") {
sq(0, 1, clr);
continue;
}
sq(0, 1, Mix(0xFFFFFF,clr,0.1));
sq(0.1, 0.9, Mix(0x000000,clr,0.2));
sq(0.1, 0.8, clr);
sq(0.2, 0.6, Mix(0x000000,clr,0.05));
sq(0.25, 0.5, Mix(0x000000,clr,0.1));
sq(0.3, 0.4, Mix(0x000000,clr,0.15));
#undef sq
#undef rec
}
}
bool invis = ((ArcadeInvis)||(ModInvisible));
bool Active = false;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) Active=true;
}
}
int FullLines = 0;
int seekh=0, seekr=3;
for (int i=LX; i; --i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]==154) {
if (--seekr==0) seekh=i;
break;
}
}
if (!seekr) break;
}
seekh += DXDel;
int oid = 0;
for (int __=0; __<((RotEff)?2:1); ++__) {
for (int i=((Zen)&&((!GarbagePreview)||((!ActiveGarb.size())&&(!Rec.size()))))?-11:1; i<=LX; ++i) {
if (!i) continue;
bool ok = true;
if (i>DXDel) {
for (int j=1; j<=LY; ++j) {
if (!B[i-DXDel][j]) ok=false;
if (C[i-DXDel][j]) ok=false;
if (B[i-DXDel][j]==153) ok=false;
}
if (i-DXDel<=RoundHeight) ok=false;
if (ok) ++FullLines;
}
else ok=false;
for (int j=1; j<=((i<0)?10:LY); ++j) {
int cB = (i>DXDel)?B[i-DXDel][j]:((i>DXDel-AllSpinGarb.size())?152:153);
int cC = (i>DXDel)?C[i-DXDel][j]:0;
int cLE = (i>DXDel)?LE[i-DXDel][j]:0;
if ((cC)&&(Flipped)) cB=Flip[cB];
if (i<0) {
++oid; cB=154; cC=cLE=0;
if (Piece[oid][0].clr) cB=oid;
if (!Piece[oid][0].clr) cB=0;
if (oid>106) cB=150+oid-106;
}
if (((!RotEff)||(!__))&&(i<=DX)&&(RoundHeight)&&(i-DXDel<=RoundHeight)) Square(sz*double(DX-i)+sz*0.1,sz*double(j-1)+sz*0.1,sz*0.8,RoundColor);
if (((!RotEff)||(!__))&&(i<=DX)&&(i>VanishHeight)) Square(sz*double(DX-i)+sz*0.1,sz*double(j-1)+sz*0.1,sz*0.8,VanishColor);
if (((!RotEff)||(!__))&&(i<=DX)&&(DropLen+i<=LX)&&(C[DropLen+i-DXDel][j])&&(ShowShadow)&&(ModHold<2)) Square(sz*double(DX-i)+sz*0.1,sz*double(j-1)+sz*0.1,sz*0.8,ShadowColor);
//if (PieceCol[j]) Square(sz*double(DX-i)+sz*0.1,sz*double(j-1)+sz*0.1,sz*0.8,0x666600);
if ((cC!=__)&&(RotEff)) continue;
if (!cB) continue;
if ((invis)&&(!cLE)&&(!cC)&&((cB<=150)||((ModInvisible==2)&&(cB>150)&&(i<seekh)))) continue;
int clr = Piece[cB][0].clr;
if ((!cC)&&(cLE)) {
clr = Mix(((invis)&&((cB<=150)||((ModInvisible==2)&&(cB>150)&&(i<seekh))))?brd:0xFFFFFF,clr,(((invis)&&((cB<=150)||((ModInvisible==2)&&(cB>150)&&(i<seekh))))?10000-cLE:cLE)*(((invis)&&((cB<=150)||((ModInvisible==2)&&(cB>150))))?0.0001:0.00005));
if (i>DXDel) LE[i-DXDel][j]=max(0,cLE-tm*((ArcadeInvis==1)?2:40));
}
//if ((cC)&&(cB)) clr=Mix(0xFFFFFF,clr,0.1);
double rat = 0.0;
if ((LCD)&&(ok)&&(!Active)) clr=Mix(clr,((ClearGravity=="sticky")||(ClearGravity=="cascade")||(ClearGravity=="separate"))?0x99FFFF:bg,pow(double(max(0,min(LCD,AreLeft)))/double(LCD),0.3));
if ((cC)&&(ckd)&&(DropEff)) rat=max(0.0,min(1.0,double(DropTime)/double(max(1,DropL))));
else if ((LCD)&&(ClearGravity=="default")&&(!Active)&&(!ok)&&(FullLines)) rat=FullLines*double(max(0,min(LCD,LCD-AreLeft)))/double(LCD);
if ((GarbageType!="fall")&&(GarbRise)&&(i>DXDel)) rat+=double(max(0,min(GarbRise-LastGarb,GarbRise)))/double(GarbRise);
if (((ClearGravity=="sticky")||(ClearGravity=="cascade")||(ClearGravity=="separate"))&&(i>DXDel)&&(PrePos[i-DXDel][j])&&(!Active)&&(InChain)&&(LCD)) rat-=double(max(0,min(LCD,AreLeft)))/double(LCD)*double(PrePos[i-DXDel][j]-(i-DXDel));
if ((cB==154)&&(GarbageType=="fall")) rat-=double(LX-i)*double(max(0,cLE))/20000.0;
double lrat = max(0.0,min(1.0,double(DropTime)/double(max(1,LockL))));
if (ckd) lrat=0.0;
#define sq(beg, ss, clr) Square(sz*double(DX-i)+rat*sz+sz*beg,sz*double(j-1)+sz*beg,sz*ss,clr)
#define rec(begx, begy, sx, sy, clr) Rectangle(sz*double(DX-i)+rat*sz+sz*begx,sz*double(j-1)+sz*begy,sz*sx,sz*sy,clr)
if (sz<6) {
sq(0, 1, (cC)?Mix(0xFFFFFF,clr,0.1):clr); continue;
}
if (cC) {
if (RotEff) UseRotEff=true;
double rr = 0.4-0.2*lrat;
double rb = 0.05+0.05*lrat;
if (Style=="classic") {
sq(0, 1, brd);
sq(0.1, 0.8, clr);
sq(0.2, 0.6, Mix(clr,0xFFFFFF,lrat*0.8));
sq(0.1, 0.1, 0xFFFFFF);
sq(0.2, 0.2, 0xFFFFFF);
sq(0.3, 0.1, Mix(clr,0xFFFFFF,lrat*0.8));
UseRotEff = false;
continue;
}
if (Style=="arcade") {
sq(0, 1, Mix(0xFFFFFF,clr,0.5));
sq(0.1, 0.9, Mix(0x000000,clr,0.5));
sq(0.1, 0.8, clr);
rec(0.3, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.05));
rec(0.4, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.1));
rec(0.5, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.15));
rec(0.6, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.2));
rec(0.7, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.25));
rec(0.8, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.3));
UseRotEff = false;
continue;
}
if (Style=="simple") {
sq(0, 1, Mix(0xFFFFFF,clr,rr*0.2));
UseRotEff = false;
continue;
}
sq(0, 1, Mix(0xFFFFFF,clr,rr));
sq(0.1, 0.9, Mix(0x000000,clr,rb));
sq(0.1, 0.8, clr);
sq(0.2, 0.65, Mix(0xFFFFFF,clr,rr));
sq(0.2, 0.6, Mix(0x000000,clr,rb*0.5));
sq(0.3, 0.4, Mix(0xFFFFFF,clr,rr));
sq(0.35, 0.3, clr);
UseRotEff = false;
}
else if (cB<=150) {
if (Style=="classic") {
sq(0, 1, brd);
sq(0.1, 0.8, clr);
sq(0.1, 0.1, 0xFFFFFF);
sq(0.2, 0.2, 0xFFFFFF);
sq(0.3, 0.1, clr);
continue;
}
if (Style=="arcade") {
clr = Mix(0x000000,clr,0.3);
sq(0, 1, Mix(0xFFFFFF,clr,0.5));
sq(0.1, 0.9, Mix(0x000000,clr,0.5));
sq(0.1, 0.8, clr);
rec(0.3, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.05));
rec(0.4, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.1));
rec(0.5, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.15));
rec(0.6, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.2));
rec(0.7, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.25));
rec(0.8, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.3));
continue;
}
if (Style=="simple") {
sq(0, 1, clr);
continue;
}
sq(0, 1, Mix(0xFFFFFF,clr,0.1));
sq(0.1, 0.9, Mix(0x000000,clr,0.2));
sq(0.1, 0.8, clr);
sq(0.2, 0.65, Mix(0xFFFFFF,clr,0.2));
sq(0.2, 0.6, Mix(0x000000,clr,0.05));
sq(0.3, 0.4, Mix(0xFFFFFF,clr,0.2));
sq(0.35, 0.3, clr);
}
else {
if (Style=="classic") {
sq(0, 1, brd);
sq(0.1, 0.8, clr);
sq(0.1, 0.1, Mix(0xFFFFFF,clr,0.5));
sq(0.2, 0.2, Mix(0xFFFFFF,clr,0.5));
sq(0.3, 0.1, clr);
continue;
}
if (Style=="arcade") {
clr = Mix(0x000000,clr,0.3);
sq(0, 1, Mix(0xFFFFFF,clr,0.5));
sq(0.1, 0.9, Mix(0x000000,clr,0.5));
sq(0.1, 0.8, clr);
rec(0.3, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.05));
rec(0.4, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.1));
rec(0.5, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.15));
rec(0.6, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.2));
rec(0.7, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.25));
rec(0.8, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.3));
continue;
}
if (Style=="simple") {
sq(0, 1, clr);
continue;
}
sq(0, 1, Mix(0xFFFFFF,clr,0.1));
sq(0.1, 0.9, Mix(0x000000,clr,0.2));
sq(0.1, 0.8, clr);
sq(0.2, 0.6, Mix(0x000000,clr,0.05));
sq(0.25, 0.5, Mix(0x000000,clr,0.1));
sq(0.3, 0.4, Mix(0x000000,clr,0.15));
}
#undef sq
#undef rec
}
}
}
for (int i=0; i<AllSpinGarb.size(); ++i) {
sprintf(buf, "%d", AllSpinGarb[i].first);
for (int j=1; j<=LY; ++j) {
if (AllSpinGarb[i].second&(lll(1)<<j)) continue;
PaintStrM(buf,sz*double(DX-(DXDel-i))+sz*0.2,sz*double(j-1)+sz*0.05,sz*0.6,0xFFCCFF);
}
}
ClassPiece P = Piece[(Next.size())?Next[0]:0][InitFacing];
int SX=DX-1+P.SDel, SY=(LY-P.LY)/2+1;
SY = max(1,min(LY-P.LY+1,SY));
SX = max(2,min(LX,SX));
double rat = double(max(0,min(5,5-(DX-2-QueryHeight()))))*0.2;
for (int ii=0; ii<P.LX; ++ii) {
for (int jj=0; jj<P.LY; ++jj) {
if (!P.B[ii][jj]) continue;
int i=SX+ii, j=SY+jj;
PaintStrM("*",sz*double(DX-i)+sz*0.15,sz*double(j-1)-sz*0.3,sz,0xFF0000,rat*0.2);
}
}
rat = double(max(0,min(5,5-(VanishHeight-2-QueryHeight()))))*0.2;
if (rat>0.1) {
for (int i=1; i<=LY; ++i) {
PaintStrM("*",sz*double(DX-VanishHeight-1)+sz*0.15,sz*double(i-1)-sz*0.3,sz,VanishColor,rat*0.2);
}
}
rat = max(0.0,min(1.0,double(DropTime)/double(max(1,LockL))));
if (CheckDown()) rat=0.0;
rat = 1.0-rat;
Rectangle(sz*double(DX),0.0,sz*0.2,sz*LY,0xEEEEEE);
Rectangle(sz*double(DX),0.0,sz*0.2,sz*LY*rat,0xFDD000);
rat = 1.0-max(0.0,min(1.0,double(GTime)/double(max(1,GLockL))));
if (GLockL<99999999) Rectangle(sz*double(DX)+sz*0.2*1.0/3.0,0.0,sz*0.2*2.0/3.0,sz*LY*rat,0xEE82EE);
rat = 1.0-max(0.0,min(1.0,double(FTime)/double(max(1,FLockL))));
if (FLockL<99999999) Rectangle(sz*double(DX)+sz*0.2*2.0/3.0,0.0,sz*0.2*1.0/3.0,sz*LY*rat,0xEE0000);
rat = max(0.0,min(1.0,double(ResetRem)/double(max(1,ResetLim))));
if (!ResetLim) rat=0.0;
Rectangle(sz*0.2+sz*double(DX),0.0,sz*0.2,sz*LY,0xDDDDDD);
Rectangle(sz*0.2+sz*double(DX),0.0,sz*0.2,sz*LY*rat,0xFFA500);
if (Bot) Rectangle(sz*double(DX),0.0,sz*0.4,sz*LY,0xDEDEDE);
if (QuickPlay) {
vector<int> clr = {
0x888888,0xC23A30,0x006098,0xEE0000,0x008E9C,
0xA6217F,0xD29700,0xF6C582,0x009B6B,0x8FC13F,
0x009BC0,0xED796B,0x995D35,0xFFE211,0xD5A7A1,
0x5B2C68,0x76A32E,0x39C5BB,0x86001A,0xEE82EE,
0x203864,0x73E9DB,0xFFCCCC,0x9999FF,0xE40077,
0xE46022,0xB35A20,0xD97DAD,0x395C00,0xFF5353,
0xC6E002,0x999900,0x006666,0xFFFF00,0xA29BBB,
0x0080FF,0x66CCFF,0xCB35BD,0x00DEB4,0xB9A567,
0xFFFFFF};
double rat = max(0.0,min(1.0,double(AccRnk)/double(4000*60*(Acc+1))));
Rectangle(sz*0.4+sz*double(DX),0.0,sz*0.2,sz*LY,clr[min(int(clr.size()-1),Acc)]);
Rectangle(sz*0.4+sz*double(DX),sz*LY*(1.0-rat)*0.5,sz*0.2,sz*LY*rat,clr[min(int(clr.size()-1),Acc+1)]);
}
if (Arcade) {
vector<int> clr = {
0x888888,0xC23A30,0x006098,0xEE0000,0x008E9C,
0xA6217F,0xD29700,0xF6C582,0x009B6B,0x8FC13F,
0x009BC0,0xED796B,0x995D35,0xFFE211,0xD5A7A1,
0x5B2C68,0x76A32E,0x39C5BB,0x86001A,0xEE82EE,
0x203864,0x73E9DB,0xFFCCCC,0x9999FF,0xE40077,
0xE46022,0xB35A20,0xD97DAD,0x395C00,0xFF5353,
0xC6E002,0x999900,0x006666,0xFFFF00,0xA29BBB,
0x0080FF,0x66CCFF,0xCB35BD,0x00DEB4,0xB9A567,
0xFFFFFF};
if (Grade>20) clr[0]=0xFFFFFF;
double rat = max(0.0,min(1.0,double(GradeRnk)/1000.0));
Rectangle(sz*0.4+sz*double(DX),0.0,sz*0.2,sz*LY,clr[Grade%40]);
Rectangle(sz*0.4+sz*double(DX),sz*LY*(1.0-rat)*0.5,sz*0.2,sz*LY*rat,clr[(Grade+1)%40]);
}
double msz = sz*0.8;
SX=0; SY=0;
if (Hold) {
if (Piece[Hold][0].LX<=3) SX=1;
if (Piece[Hold][0].LX<=1) SX=2;
if (Piece[Hold][0].LY<=3) SY=1;
if (Piece[Hold][0].LY<=1) SY=2;
}
if (HoldRule) {
Rectangle(10, -sz*3-msz*4.5, msz*4.0, msz*6.0, brd);
for (int i=0; i<5; ++i) {
for (int j=0; j<5; ++j) {
int clr = brd;
if (min(4-i-SX,4-j-SY)>=0) {
if (Piece[Hold][InitFacing].B[4-i-SX][4-j-SY]) clr=((HoldEnable)&&(HoldRule))?Piece[Hold][InitFacing].clr:0x888888;
}
if (clr==brd) continue;
#define sq(beg, ss, clr) Square(msz*double(i)+10+msz*beg,msz*0.5*double(!(Piece[Hold][0].LY&1))-sz*3-msz*double(j)+msz*beg,msz*ss,clr)
#define rec(begx, begy, sx, sy, clr) Rectangle(msz*double(i)+10+msz*begx,msz*0.5*double(!(Piece[Hold][0].LY&1))-sz*3-msz*double(j)+msz*begy,msz*sx,msz*sy,clr)
//Square(msz*double(i+d*5)+10, msz*0.5*double(!(Piece[cur][0].LY&1))+sz*double(LY+1)+msz*double(j), msz*0.9, Mix(0xFFFFFF,clr,0.5));
//Square(msz*double(i+d*5)+10, msz*0.5*double(!(Piece[cur][0].LY&1))+sz*double(LY+1)+msz*double(j), msz*0.8, clr);
if (Style=="classic") {
sq(0, 1, brd);
sq(0.1, 0.8, clr);
sq(0.2, 0.6, ((HoldEnable)&&(HoldRule))?0xFFFFFF:0xCCCCCC);
sq(0.1, 0.1, ((HoldEnable)&&(HoldRule))?0xFFFFFF:0xCCCCCC);
continue;
}
if (Style=="arcade") {
sq(0, 1, Mix(0xFFFFFF,clr,0.5));
sq(0.1, 0.9, Mix(0x000000,clr,0.5));
sq(0.1, 0.8, clr);
rec(0.3, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.05));
rec(0.4, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.1));
rec(0.5, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.15));
rec(0.6, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.2));
rec(0.7, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.25));
rec(0.8, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.3));
continue;
}
if (Style=="simple") {
sq(0, 1, clr);
continue;
}
sq(0, 1, Mix(0xFFFFFF,clr,0.1));
sq(0.1, 0.9, Mix(0x000000,clr,0.2));
sq(0.1, 0.8, clr);
sq(0.2, 0.65, Mix(0xFFFFFF,clr,0.2));
sq(0.2, 0.6, Mix(0x000000,clr,0.05));
sq(0.3, 0.4, Mix(0xFFFFFF,clr,0.2));
sq(0.35, 0.3, clr);
#undef sq
#undef rec
}
}
}
for (int d=0; d<ViewNxt; ++d) {
Rectangle(-msz*1+10+msz*double(d*5), sz*double(LY+1)-msz*0.5, msz*4.0, msz*6.0, brd);
if (Next.size()<=d) break;
int cur = Next[d];
SX=SY=0;
if (Piece[cur][InitFacing].LY<=3) SY=1;
if (Piece[cur][InitFacing].LY<=1) SY=2;
for (int i=-2; i<3; ++i) {
for (int j=0; j<5; ++j) {
int clr = brd;
if (min(2-i-SX,j-SY)>=0) clr=(Piece[cur][InitFacing].B[2-i-SX][j-SY])?Piece[cur][InitFacing].clr:brd;
if (clr==brd) continue;
#define sq(beg, ss, clr) Square(msz*double(i+d*5)+10+msz*beg,msz*0.5*double(!(Piece[cur][0].LY&1))+sz*double(LY+1)+msz*double(j)+msz*beg,msz*ss,clr)
#define rec(begx, begy, sx, sy, clr) Rectangle(msz*double(i+d*5)+10+msz*begx,msz*0.5*double(!(Piece[cur][0].LY&1))+sz*double(LY+1)+msz*double(j)+msz*begy,msz*sx,msz*sy,clr)
//Square(msz*double(i+d*5)+10, msz*0.5*double(!(Piece[cur][0].LY&1))+sz*double(LY+1)+msz*double(j), msz*0.9, Mix(0xFFFFFF,clr,0.5));
//Square(msz*double(i+d*5)+10, msz*0.5*double(!(Piece[cur][0].LY&1))+sz*double(LY+1)+msz*double(j), msz*0.8, clr);
if (Style=="classic") {
sq(0, 1, brd);
sq(0.1, 0.8, clr);
sq(0.2, 0.6, 0xFFFFFF);
sq(0.1, 0.1, 0xFFFFFF);
continue;
}
if (Style=="arcade") {
sq(0, 1, Mix(0xFFFFFF,clr,0.5));
sq(0.1, 0.9, Mix(0x000000,clr,0.5));
sq(0.1, 0.8, clr);
rec(0.3, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.05));
rec(0.4, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.1));
rec(0.5, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.15));
rec(0.6, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.2));
rec(0.7, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.25));
rec(0.8, 0.1, 0.1, 0.8, Mix(0x000000,clr,0.3));
continue;
}
if (Style=="simple") {
sq(0, 1, clr);
continue;
}
sq(0, 1, Mix(0xFFFFFF,clr,0.1));
sq(0.1, 0.9, Mix(0x000000,clr,0.2));
sq(0.1, 0.8, clr);
sq(0.2, 0.65, Mix(0xFFFFFF,clr,0.2));
sq(0.2, 0.6, Mix(0x000000,clr,0.05));
sq(0.3, 0.4, Mix(0xFFFFFF,clr,0.2));
sq(0.35, 0.3, clr);
#undef sq
#undef rec
}
}
}
if (RecTot>=min(DX-2,15)) {
sprintf(buf, "-%d", RecTot);
double asz = sz*double(LY)*0.1;
TQu.push_back({-sz*0.1*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,6,buf,0xFF9999});
}
DX -= DXDel;
}
void PaintParticle(int tm, int tars) {
DX += DXDel;
ll del = clock()-begtm;
sprintf(buf, "%d Targeting You", tars);
if ((Plrs>2)&&(!Over)) PaintStrM(buf,sz*double(DX+1),sz*0.5*double(LY-1),sz*0.5,(tars<2)?((!tars)?0xAAAAAA:0xCCCCCC):((tars<6)?0xFFA500:0xEE0000));
if ((Plrs>2)&&(!Over)) PaintStrM(ATKN[AtkType],sz*double(DX+2),sz*0.5*double(LY-1),sz*0.5,0xDF3782);
int pcnt = 0;
double rat = double(max(1,tm));
for (int i=0; i<PQu.size(); ++i) {
Particle o = PQu[i];
Poly(o.x, o.y, o.sz*sz/15.0, o.n, o.clr, o.th);
o.x+=o.vx*rat; o.y+=o.vy*rat;
o.vx+=o.ax*rat; o.vy+=o.ay*rat;
o.sz -= o.de*rat*0.5;
if ((Bot)&&((sz<10)||(OperTime<5))&&(o.clr>=0)) o.sz=-1.0;
if (o.sz>0.0) PQu[pcnt++]=o;
}
while (PQu.size()>pcnt) PQu.pop_back();
int tcnt = 0;
for (int i=0; i<TQu.size(); ++i) {
FloatText o = TQu[i];
PaintStrM(o.str, o.x, o.y, o.sz, abs(o.clr), o.bd);
o.bd -= o.de*rat*0.5;
if ((Bot)&&(sz<10)&&(o.clr>=0)) o.bd=-1.0;
if (o.bd>0.0) TQu[tcnt++]=o;
}
while (TQu.size()>tcnt) TQu.pop_back();
if ((BeFrom)&&(!Over)) PaintStrM(string(1,1),sz*double(DX)*0.3,-0.15*sz*double(LY),sz*0.8*double(LY),0xDF3782,0.06);
if ((BeTo)&&(!Over)) PaintStrM(string(1,2),sz*double(DX)*0.3,-0.15*sz*double(LY),sz*0.8*double(LY),0xFDD000,0.06);
if (Complete) {
double asz = sz*0.12*double(LY);
FloatText o = FloatText({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,6,"Complete",0xCCFFCC});
PaintStrM(o.str, o.x, o.y, o.sz, abs(o.clr), o.bd);
sprintf(buf, "Press %s to Retry", KeyName(KEY_RETRY).c_str());
asz = sz*0.06*double(LY);
o = FloatText({sz*0.6*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,6,buf,0xFFFFFF});
PaintStrM(o.str, o.x, o.y, o.sz, abs(o.clr), o.bd);
}
if (((Plrs==1)||(QuickPlay))&&(!Complete)&&(!Zen)&&(Over)) {
double asz = sz*0.12*double(LY);
FloatText o = FloatText({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,6,"Game Over",0xFFCCCC});
PaintStrM(o.str, o.x, o.y, o.sz, abs(o.clr), o.bd);
sprintf(buf, "Press %s to Retry", KeyName(KEY_RETRY).c_str());
asz = sz*0.06*double(LY);
o = FloatText({sz*0.6*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,6,buf,0xFFFFFF});
PaintStrM(o.str, o.x, o.y, o.sz, abs(o.clr), o.bd);
}
DX -= DXDel;
}
vector<char> GetKey(int tm) {
if ((Bot)&&((fabs(SKY-DropKY)<0.01)&&(Plrs>1))) return vector<char>();
vector<char> res;
for (char ch : KeyList) {
if ((Bot)&&(ch!=KEY_RETRY)&&(ch!=KEY_UNDO)) continue;
bool nw = CheckKey(ch);
if (UseDas[ch]) {
if (!KeySta[ch]) {
if (nw) {
KeySta[ch]=true; res.push_back(ch); KeyTime[ch]=0;
}
}
else {
if (!nw) {
KeySta[ch]=KeyDas[ch]=false; KeyTime[ch]=0;
}
else {
KeyTime[ch]+=tm; int val=(KeyDas[ch])?((ch==KEY_DOWN)?0:ARR):((ch==KEY_DOWN)?SDDAS:DAS);
if (KeyTime[ch]>=val) {
KeyTime[ch]-=val; KeyDas[ch]=true;
if (!DcdLeft) res.push_back(ch);
}
}
}
if ((nw)&&(!((ch==KEY_DOWN)?SDDAS:DAS))) KeyDas[ch]=true;
}
else {
if ((nw)&&(!KeySta[ch])) res.push_back(ch);
KeySta[ch] = nw;
}
}
return res;
}
set<ClassSta> st; map<ClassSta,string> mp;
bool CheckPos(ClassSta o) {
int p=o.p, d=o.d, x=o.x, y=o.y;
for (int i=0; i<Piece[p][d].LX; ++i) {
for (int j=0; j<Piece[p][d].LY; ++j) {
if ((Piece[p][d].B[i][j])&&(CheckPlace(x+i,y+j))) return false;
}
}
return true;
}
void bfs(int p, int d, int x, int y) {
ClassSta o = (ClassSta){p,d,x,y};
if (!CheckPos(o)) return;
queue<ClassSta> q; q.push(o); st.insert(o);
while (!q.empty()) {
o=q.front(); q.pop();
ClassSta nw=o; --nw.x;
if ((!st.count(nw))&&(CheckPos(nw))) {
mp[nw] = mp[o]+KEY_DOWN;
st.insert(nw); q.push(nw);
}
if ((!DropL)&&(CheckPos(nw))) continue;
nw=o; --nw.y;
if ((!st.count(nw))&&(CheckPos(nw))&&(AllowMove)) {
mp[nw] = mp[o]+KEY_LEFT;
st.insert(nw); q.push(nw);
}
nw=o; ++nw.y;
if ((!st.count(nw))&&(CheckPos(nw))&&(AllowMove)) {
mp[nw] = mp[o]+KEY_RIGHT;
st.insert(nw); q.push(nw);
}
for (int i=0; i<4; ++i) {
if (i==o.d) continue;
int beg=o.d; if (beg&1) beg^=2;
int en=i; if (i&1) en^=2;
char ch = KEY_180;
if (i==((o.d+1)&3)) ch=KEY_CW;
if (i==((o.d+3)&3)) ch=KEY_CCW;
if (i==((o.d+RotType)&3)) ch=KEY_ROT;
if (!AllowRot) continue;
if ((ch==KEY_180)&&(!AllowHalf)) continue;
if (((ch==KEY_CW)||(ch==KEY_CCW))&&(!Allow2Rot)) continue;
for (pair<int,int> KT : Kick[p][beg][en]) {
nw=o; nw.d=i; nw.x+=KT.second; nw.y+=KT.first;
if (CheckPos(nw)) {
if (!st.count(nw)) {
mp[nw] = mp[o]+ch;
st.insert(nw); q.push(nw);
}
else if (((Plr==2)||(Plr==3)||(Plr==5)||(Plr==6))&&(ch!=KEY_180)) {
char lst=0; if (mp[nw]!="") lst=mp[nw].back();
if ((lst!=KEY_CW)&&(lst!=KEY_CCW)) mp[nw]=mp[o]+ch;
}
break;
}
}
}
}
}
void AddGarbage(int x, lll pos) {
x = min(x,LX);
if (GarbageType=="fall") {
for (int i=1; i<=LY; ++i) {
if (!(pos&(lll(1)<<i))) continue;
int pp = 1;
for (int j=1; j<=LX; ++j) {
if ((B[j][i])&&(!C[j][i])) pp=j+1;
}
int rem = x;
for (int j=pp; j<=LX; ++j) {
if (!rem) break;
if (B[j][i]) continue;
B[j][i]=154; LE[j][i]=20000; --rem; ID[j][i]=++PartID;
}
}
return;
}
LastGarb = 0;
for (int i=LX; i>x; --i) {
for (int j=1; j<=LY; ++j) {
B[i][j]=B[i-x][j]; C[i][j]=C[i-x][j]; LE[i][j]=LE[i-x][j]; ID[i][j]=ID[i-x][j];
}
}
for (int i=1; i<=min(x,LX); ++i) {
++PartID;
for (int j=1; j<=LY; ++j) {
C[i][j]=0; B[i][j]=154*bool(pos&(lll(1)<<j));
if (GarbageType=="bomb") B[i][j]=(B[i][j])?153:151;
if (GarbageType=="solid") B[i][j]=(B[i][j])?153:0;
if (B[i][j]) LE[i][j]=20000;
else LE[i][j]=0;
ID[i][j] = (B[i][j])?PartID:0;
}
}
for (int i=VanishHeight+1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((B[i][j])&&(!C[i][j])) {
double dx=sz*double(DX-i)+sz*0.5, dy=sz*double(j-1)+sz*0.5;
#define sq(beg, ss, clr) PQu.push_back({dx,dy,vx,vy,0.001,0,sz*0.5*ss,0.002,theta,4,clr})
double vx = -0.7+0.2*(rnd(10000)*0.0001);
double vy = 0.2*(rnd(10000)*0.0001-0.5);
double theta = acos(-1.0)*rndf();
int clr = Mix(Piece[B[i][j]][0].clr,0xFFFFFF,0.7);
sq(0, 1, clr);
#undef sq
B[i][j]=C[i][j]=LE[i][j]=ID[i][j]=0;
}
}
}
}
int ClearGarbage(int x) {
x = max(x,0);
while (x) {
bool ok = false;
for (int i=1; i<=LY; ++i) ok|=(B[1][i]>150);
if (!ok) break;
for (int i=1; i<LX; ++i) {
for (int j=1; j<=LY; ++j) {
B[i][j]=B[i+1][j]; C[i][j]=C[i+1][j]; LE[i][j]=LE[i+1][j]; ID[i][j]=ID[i+1][j];
}
}
for (int i=1; i<=LY; ++i) B[LX][i]=C[LX][i]=LE[LX][i]=ID[LX][i]=0;
--x;
}
return x;
}
void ClearAll(int seed, bool Over=true) {
DropL=BaseDropL; LockL=BaseLockL; LstLev=LqC=0; WasteRem=WasteLim;
savx=savy=tavx=tavy=-100.0; GTime=FTime=0; ClearShape.clear();
memset(C, 0, sizeof(C));
for (int i=1; i<=7; ++i) ED[i]=EV[i]=0;
EcCD=BnCD=ScTm=OgTm=0; while (!Bl.empty()) Bl.pop();
while (!Cy.empty()) Cy.pop_front();
Complete=InChain=AllSpinGarbOper=Flipped=false; ChainLine=0;
FloorTm=RecIncTm=0;
Life=Stock; Tar=-1;
DX+=DXDel; DXDel=AggTm=AggDec=LstHole=AreLeft=InitHold=InitRot=ComboRem=0;
Level=SumCool=SumRegret=CurSeg=Seg70=Seg100=ArcadeInvis=InvisGrade=0;
HisSeq.clear(); InvisTm=0;
AllSpinGarb.clear(); LstAct=make_pair(-1,-1);
for (int i=0; i<12; ++i) SegSta[i]=0;
Grade=GradeRnk=GradeDecTm=0;
for (int i=0; i<55; ++i) {
ComboCol[i]=0; PieceCol[i]=false;
}
if (Bag.empty()) Bag=DefaultBag;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
double dx=sz*double(DX-i)+sz*0.5, dy=sz*double(j-1)+sz*0.5;
if (B[i][j]) {
if (Over) {
#define sq(beg, ss, clr) PQu.push_back({dx,dy,vx,vy,0.001,0,sz*0.5*ss,0.002,theta,4,clr})
double vx = -0.7+0.2*(rnd(10000)*0.0001);
double vy = 0.2*(rnd(10000)*0.0001-0.5);
double theta = acos(-1.0)*rndf();
int clr = Mix(Piece[B[i][j]][0].clr,0xFFFFFF,0.7);
sq(0, 1, clr);
#undef sq
}
}
B[i][j]=C[i][j]=ID[i][j]=0;
}
}
Combo=B2B=LastGarb=ComboTm=B2BTm=ComboType=B2BType=PCTime=CurFloor=0; LstReady=999;
SumPiece=SumLine=SumAttack=SumDig=KO=SKO=0; Acc=AccRnk=AccProtect=0;
if ((!Zen)||(QuickPlay)) Score=DisScore=0LL;
while (Rec.size()) Rec.pop_front();
while (ActiveGarb.size()) ActiveGarb.pop_front();
while (Atk.size()) Atk.pop();
gen = mt19937(seed); Next.clear(); Hold=Spin=0;
while (Next.size()<=10) {
if (!Sequence) {
Next.push_back(RollPiece()); continue;
}
vector<int> vec;
for (int i : Bag) vec.push_back(i);
if (Sequence==1) {
shuffle(vec.begin(), vec.end(), gen);
for (int i=0; i<Ext; ++i) vec.push_back(vec[i]);
shuffle(vec.begin(), vec.end(), gen);
}
for (int i : vec) Next.push_back(i);
}
Oper.clear();
DropTime=0; ResetRem=max(1,ResetLim); MiniSpin=false;
begtm = clock();
LastGarb = GarbRise;
if (ModDivergence==2) {
for (int i=1; i<=min(LX,12); ++i) {
for (int j=1; j<=LY; ++j) {
if (!((i+j)&1)) B[i][j]=26;
}
}
}
else if (ModMess==2) {
for (int i=1; i<=min(LX,12); ++i) {
for (int j=1; j<=LY; ++j) {
int x=(i-1)%4, y=(j-1)%5;
x=min(x,4-x); y=min(y,4-y);
if (min(x,y)==1) B[i][j]=154;
}
}
}
else if (ModSpin==2) {
for (int i=0; i<10; ++i) {
LstHole = RollHole(_Luck,true);
Rec.push_back(make_pair(1,make_pair((lll(1)<<(LY+1))-1-(lll(1)<<LstHole),0LL)));
}
}
else if (ModInvisible==2) {
for (int i=0; i<3; ++i) {
LstHole = RollHole(_Luck,true);
Rec.push_back(make_pair(1,make_pair((lll(1)<<(LY+1))-1-(lll(1)<<LstHole),0LL)));
}
}
LstHole = RollHole(_Luck);
for (int i=0; i<min(LX,StartHeight); ++i) {
if (rnd(100)<_SegMess) LstHole=RollHole(_Luck);
AddGarbage(1, RollGarb());
}
}
deque<char> Oper; int D[111][55],G[111][55]; bool SetSpin=true;
bool CheckD(int x, int y) {
if ((min(x,y)<1)||(x>LX)||(y>LY)) return true;
return D[x][y];
}
bool CheckF(int x, int y) {
if ((min(x,y)<1)||(x>LX)||(y>LY)) return true;
return D[x][y]==1;
}
bool CheckDPos(ClassSta o) {
int p=o.p, d=o.d, x=o.x, y=o.y;
for (pair<int,int> oo : DDP[o.p][o.d]) {
if (CheckD(x+oo.first,y+oo.second)) return false;
}
return true;
}
void Victory() {
double asz = sz*0.12*double(LY);
TQu.push_back({sz*0.5*double(DX)-asz*1.5,sz*0.5*double(LY)-asz*0.7,asz,0.25,0.0001,"VICTORY",0xFFA500});
TQu.push_back({sz*0.5*double(DX)-asz*1.5,sz*0.5*double(LY)-asz*0.7,asz,0.1,0.00005,"VICTORY",0xFFE211});
sprintf(buf, "%d Points", Wins);
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0001,string(buf),0xFFFFFF});
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.1,0.00005,string(buf),0x0080FF});
}
double MdRate = 0.0;
bool DV[4][111][75]; vector<ClassSta> VV; int LI=0;
bool CheckNw(ClassSta o) {
if (DV[o.d][o.x+10][o.y+10]) return false;
if (o.x>LI) return false;
return CheckDPos(o);
}
void Mark(ClassSta o) {
DV[o.d][o.x+10][o.y+10]=true; VV.push_back(o);
}
bool Ddfs(ClassSta o) {
stack<ClassSta> stk; stk.push(o); Mark(o);
while (stk.size()) {
o=stk.top(); stk.pop();
int p=o.p, d=o.d, x=o.x, y=o.y;
if (x>LI) continue;
ClassSta nw=o; --o.x;
if (CheckNw(nw)) {
Mark(nw); stk.push(nw);
}
nw=o; ++o.y;
if ((CheckNw(nw))&&(AllowMove)) {
Mark(nw); stk.push(nw);
}
nw=o; --o.y;
if ((CheckNw(nw))&&(AllowMove)) {
Mark(nw); stk.push(nw);
}
for (int i=0; i<4; ++i) {
if (i==d) continue;
if (!AllowRot) continue;
if ((i==((d+2)&3))&&(!AllowHalf)) continue;
if ((i==((d+(2^RotType))&3))&&(!Allow2Rot)) continue;
int beg=d, en=i;
if (beg&1) beg^=2;
if (en&1) en^=2;
for (pair<int,int> KT : Kick[p][beg][en]) {
nw=o; nw.d=i; nw.x+=KT.second; nw.y+=KT.first;
if (CheckNw(nw)) {
Mark(nw); stk.push(nw);
}
if (CheckPos(nw)) break;
}
}
}
return true;
}
void ScreenEffect(double ss, double de, int clr, int pp=1) {
for (int i=1; i<=DX; ++i) {
for (int j=1; j<=LY; ++j) {
double dx=sz*double(DX-i)+sz*rndf(), dy=sz*double(j-1)+sz*rndf();
if (!rnd(pp)) PQu.push_back({dx,dy,0.05,0,0,0,ss,de,rndf()*acos(-1.0),6,clr});
}
}
}
void LockEff(int clr, double ss, int n, double ve) {
double dx=sz*double(DX-avx), dy=sz*double(avy-1);
double th = rndf()*acos(-1.0)*2.0;
for (int i=0; i<n; ++i) {
th += acos(-1.0)*2.0/double(n);
PQu.push_back({dx,dy,sin(th)*ve,cos(th)*ve,0,0,ss,0.006,rndf()*acos(-1.0)*2.0,5,clr});
}
}
#warning frame
void Frame(int tm, int tars, bool PermitAI=false) {
if (DefaultRot=="ccw") RotType=3;
else RotType=1;
for (int i=1; i<=7; ++i) {
if ((i==7)&&(EV[5])&&(!EV[1])) {
EV[i] = max(0,EV[i]-20*tm);
continue;
}
EV[i] = max(0,EV[i]-tm*ED[i]);
}
DcdLeft = max(0,DcdLeft-tm);
HcdLeft = max(0,HcdLeft-tm);
DrdLeft = max(0,DrdLeft-tm);
if (DcdLeft>5000) DcdLeft=min(DcdLeft,DCD);
if (HcdLeft>5000) HcdLeft=min(HcdLeft,HCD);
if ((SelX>0)&&(SelX>DXDel)&&(SelX<=DXDel+LX)&&(SelY<=LY)) {
int x=SelX-DXDel, y=SelY;
if ((CheckKey(VK_LBUTTON))&&(!_fstl)) {
if (!C[x][y]) {
B[x][y] = AddTp;
LE[x][y]=10000; ID[x][y]=++PartID;
if (!CheckDown()) DropTime=0;
}
}
if (CheckKey(VK_RBUTTON)) {
if (!C[x][y]) {
if (!CheckDown()) DropTime=0;
B[x][y]=LE[x][y]=ID[x][y]=0;
}
}
}
else if ((SelX<0)&&(SelY<=10)&&(Zen)) {
int oo = (11+SelX)*10+SelY;
int dy = (oo>106)?150+oo-106:oo;
if (CheckKey(VK_LBUTTON)) {
if (Piece[dy][0].clr) AddTp=dy;
}
if (CheckKey(VK_RBUTTON)) {
if (Piece[dy][0].clr) Next.push_front(dy);
else Next.push_front(0);
++ForceWaste;
}
}
if (Bot) ResetLim=max(1,ResetLim);
UndoCD = max(0,UndoCD-tm);
if (Bag.empty()) Bag=DefaultBag;
if (Over) {
begtm += ll(tm);
vector<char> chs = GetKey(tm);
for (char x : chs) {
if (x==KEY_RETRY) ForceAbort=true;
if (x==KEY_UNDO) Undo=true;
}
return;
}
if (Complete) begtm+=ll(tm);
else if ((TarPiece)||(TarLine)||(TarAttack)||(TarScore)||(TarTime)) {
Complete = true;
if (clock()-begtm-BegDelay<ll(TarTime)) Complete=false;
if (SumLine<TarLine) Complete=false;
if (SumAttack<TarAttack) Complete=false;
if (SumPiece<TarPiece) Complete=false;
if (Score<ll(TarScore)) Complete=false;
}
int cursec = max(0,int((BegDelay-clock()+begtm+999LL)/1000LL));
if (cursec<LstReady) {
int asz = sz*0.28*double(LY);
sprintf(buf,"%d",cursec); LstReady=cursec;
if (!cursec) sprintf(buf,"GO");
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.3,0.0009,string(buf),0xFFFFFF});
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0006,string(buf),0xFDD000});
}
if (clock()-begtm<BegDelay) {
Rec.clear(); ActiveGarb.clear();
vector<char> chs = GetKey(tm);
for (char x : chs) {
if (x==KEY_RETRY) ForceAbort=true;
}
return;
}
if (!Arcade) {
DropL=BaseDropL; LockL=BaseLockL;
int lv = min(100,QueryLev());
if (lv!=LstLev) {
LstLev = lv;
sprintf(buf, "Level %d", lv);
double asz = sz*0.12*double(LY);
TQu.push_back({sz*0.2*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0006,buf,0xFFCCCC});
}
if (lv) {
if (lv>=MasterBeg) {
vector<int> LockR = {300,295,276,252,228,204,175,168,156,150,132,115,114,108,102,96,85,84,78,72,66,55};
LockL *= double(LockR[min(lv-MasterBeg,int(LockR.size())-1)])/300.0;
DropL = 0;
}
else {
if (LevelRule=="div") DropL/=(1.0+0.001*double(Diff)*double(lv));
else if (LevelRule=="dec") DropL*=max(0.0,1.0-0.001*double(Diff)*double(lv));
else if (LevelRule=="exp") DropL*=pow(max(0.0,1.0-0.001*double(Diff)),double(lv));
else DropL*=pow(max(0.0,0.8-0.001*double(Diff)*double(lv)),lv)/0.8;
}
}
}
while ((Cy.size())&&((Cy.front().first+10000LL<clock())||(Cy.size()>8))) Cy.pop_front();
if (Odoo) {
if ((EV[5])&&(EV[7])&&(!EV[1])) RoundHeight=99;
else RoundHeight=0;
}
else {
for (int i=1; i<=7; ++i) EV[i]=0;
}
if (ForceOver) {
while (Atk.size()) Atk.pop();
while (Rec.size()) Rec.pop_front();
Over=true; ForceOver=false;
return;
}
if (GarbageMode=="instant") {
int rem=GarbageGap; ll curtm=clock();
while ((Rec.size())&&(Rec.front().second.second+ll(GarbDelay)<curtm)&&(rem)) {
int val = min(rem,Rec.front().first);
rem -= val;
if (GarbRise) ActiveGarb.push_back(make_pair(val,Rec.front().second.first));
else {
AddGarbage(val, Rec.front().second.first); MoveDown();
}
Rec.front().first-=val; if (!Rec.front().first) Rec.pop_front();
}
}
int gbc = 0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]>150) {
++gbc; break;
}
}
}
LastGarb += tm;
if ((gbc<StaticHeight)&&(LastGarb>GarbRise)) {
if ((GarbageShape!="board")&&(rnd(100)<_SegMess)||(LstHole<1)||(LstHole>LY)) LstHole=RollHole(_Luck);
AddGarbage(1, RollGarb());
if (!GarbRise) MoveDown();
++gbc;
}
if (Arcade) {
if ((!Zen)&&(Level==999)) Level=1000;
if (ArcadeInvis) InvisTm+=tm;
int lev = Level/100;
double asz = sz*0.1*double(LY);
if (ArcadeRound) RoundHeight=((lev&1)&&(lev>1))?10:0;
if (lev>CurSeg) {
if ((Seg100>RegretTm[min(int(RegretTm.size())-1,CurSeg)])&&(!Zen)) {
if (CurSeg<10) {
SegSta[CurSeg]=-1; ++SumRegret;
}
TQu.push_back({sz*0.95*double(DX+2),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.00003,"REGRET",0xEE0000});
}
else if (Seg70<=CoolTm[min(int(CoolTm.size())-1,CurSeg)]) {
if (CurSeg<10) {
SegSta[CurSeg]=1; ++SumCool;
}
else if (Zen) ++SumCool;
TQu.push_back({sz*0.95*double(DX+2),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.00003,"COOL!",0x66CCFF});
}
++CurSeg; Seg70=Seg100=0;
}
if ((!ArcadeInvis)&&(!Zen)&&(!InvisTm)&&(Level>999)) {
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) B[i][j]=C[i][j]=LE[i][j]=0;
}
AreLeft = 3000;
ArcadeInvis = ((SumCool>8)&&(Grade>=27))?2:1;
}
if ((InvisTm>60000)&&(ArcadeInvis)) {
InvisGrade += (ArcadeInvis==2)?160:50;
ArcadeInvis = 0;
double asz = sz*0.16*double(LY);
Complete = true;
TQu.push_back({sz*0.5*double(DX)-asz*1.5,sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0002,"STAGE",0xFDD000});
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0002,"CLEAR",0xFDD000});
}
if (Level%100<70) Seg70+=tm;
Seg100 += tm;
lev += SumCool;
ARE = ArcadeAre[min(int(ArcadeAre.size()-1),lev)];
LCD = ArcadeLcd[min(int(ArcadeLcd.size()-1),lev)];
if (!Zen) LockL=ArcadeLock[min(int(ArcadeLock.size()-1),lev)];
DropL = 99999999;
for (pair<int,int> o : ArcadeGrav) {
if (Level>=o.first) {
if (o.second>=5120) DropL=0;
else DropL=12800/o.second/3;
}
}
if ((InvisTm)&&(!ArcadeInvis)) {
DropL=1000; LockL=500;
}
}
if ((!AreLeft)&&(Combo<2)) GradeDecTm+=tm;
if (GradeDecTm>GradeDec[min(int(GradeDec.size())-1,Grade)]) {
GradeDecTm -= GradeDec[min(int(GradeDec.size())-1,Grade)];
GradeRnk = max(0,GradeRnk-1);
}
if (QuickPlay) {
ll dis = 6000LL;
for (ll x : Floor) {
if (Score<x) dis=min(dis,x-Score);
}
if (ModExpert==2) dis=6000LL;
ll rat = max(0LL,dis-1000LL);
GiveScore((tm*rat+4999LL)/5000LL, true);
while (AccRnk>4000*(Acc+1)*60) {
AccRnk-=4000*(Acc+1)*60; ++Acc;
AccProtect = 5000;
}
if (!AccProtect) AccRnk=max(0,AccRnk-((ModExpert)?5:3)*tm*((Acc+1)*(Acc+1)+Acc+1));
if ((!AccRnk)&&(Acc)) {
--Acc; AccRnk=4000*(Acc+1)*60;
}
int flr = QueryFloor();
vector<int> delay = {2500,2500,2250,2000,1750,1500,1250,1000,750,500,250};
if (ModExpert) delay={1100,1100,1000,900,800,700,600,500,400,300,200};
GarbDelay = delay[min(int(delay.size())-1,flr)]*2;
if ((ModHold==2)||(ModMess==2)||(ModGravity==2)||(ModStrength==2)
||(ModDivergence==2)||(ModInvisible==2)||(ModSpin==2)) GarbDelay=min(GarbDelay,2500);
if ((ModMess==2)||(ModStrength==2)||(ModDivergence==2)) GarbDelay=2500;
DropL = int(floor(1000.0/60.0/(1.0/30.0+double(flr-1)*0.03)));
if (ModGravity==1) {
vector<int> lck = {30,30,29,28,27,26,24,22,20,18,16};
DropL/=10; LockL=lck[min(flr,int(lck.size())-1)]*50/3;
}
if (ModGravity==2) {
vector<int> lck = {24,24,22,20,18,16,15,14,13,12,11};
DropL=0; LockL=lck[min(flr,int(lck.size())-1)]*50/3;
}
if (!Zen) {
LockL=max(200,520-20*flr); if (ModGravity==2) LockL=LockL*2/3;
}
if (ModExpert==2) {
if (FloorTm>=60000) RecIncTm+=tm;
FloorTm += tm;
}
}
EcCD = max(0,EcCD-tm);
BnCD = max(0,BnCD-tm);
ScTm = max(0,ScTm-tm);
OgTm = max(0,OgTm-tm);
if ((!EcCD)&&(min(EV[2],EV[4])>40000)&&(!EV[6])) {
EV[2]-=40000; EV[4]-=40000;
++ForceWaste; EcCD=1000;
}
if ((!BnCD)&&(EV[1])&&(EV[5])) {
int dd = 1;
for (int i=2; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (CheckPlace(i,j)) dd=i;
}
}
int x=rnd(dd)+1, y=rnd(LY);
if (!C[x][y]) B[x][y]=LE[x][y]=ID[x][y]=0;
BnCD = 500;
}
if ((EV[2])&&(EV[6])) {
for (int i=0; i<256; ++i) KeyDas[i]=false;
}
if (ComboRule=="c2") {
ComboRem = max(0,ComboRem-tm);
if (!ComboRem) {
if (ComboType) ComboTm=4000;
Combo=ComboType=0;
//for (int i=1; i<=LY; ++i) ComboCol[i]=0;
}
}
AccProtect = max(0,AccProtect-tm);
if (AreLeft>5000) AreLeft=min(AreLeft,max(DeathARE,max(ARE,LCD)));
if (AreLeft) {
AreLeft = max(0,AreLeft-tm);
vector<char> chs = GetKey(tm);
for (char ch : chs) {
if ((ch==KEY_HOLD)&&(HoldRule)&&((!InitHold)||(HoldRule==2))) {
++InitHold; InitRot=0;
}
if (ch==KEY_RESET) InitRot=0;
if (ch==KEY_ROT) InitRot+=RotType;
if (ch==KEY_CW) InitRot+=1;
if (ch==KEY_180) InitRot+=2;
if (ch==KEY_CCW) InitRot+=3;
InitRot &= 3;
if ((ch==KEY_UNDO)&&(Zen)&&(!UndoCD)) Undo=true;
if (ch==KEY_RETRY) ForceAbort=true;
}
return;
}
if (ForceWaste) {
bool ok = false;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
B[i][j]=C[i][j]=0; ok=true;
}
}
}
--ForceWaste; Spin=MiniSpin=SemiSpin=false;
Oper.clear();
}
if ((CheckActive())&&(ForceLock)) {
ForceLock=false; Lock();
}
VisTm += tm;
if ((ModInvisible==1)&&(VisTm>=5000)) {
VisTm = 0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((B[i][j])&&(B[i][j]<=150)&&(!C[i][j])) LE[i][j]=10000;
}
}
}
int totx=0, toty=0, tot=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
totx+=i; toty+=j; ++tot;
}
}
}
if (tot) {
int avx = double(totx)/double(max(tot,1));
int avy = double(toty)/double(max(tot,1));
ravx = sz*double(DX-avx)+sz*0.5+KX;
ravy = sz*double(avy-1)+sz*0.5+KY;
}
int ttm = ((EV[2])&&(EV[6]))?tm/5+(rnd(5)<tm%5):tm;
if (!Bot) {
if (!DrdLeft) DropTime+=ttm;
if ((GTime)&&(GLockL<99999999)) GTime+=ttm;
if (FLockL<99999999) FTime+=ttm;
}
else OperDis+=ttm;
while (Next.size()<=10) {
if (!Sequence) {
Next.push_back(RollPiece()); continue;
}
vector<int> vec;
for (int i : Bag) vec.push_back(i);
if (Sequence==1) {
shuffle(vec.begin(), vec.end(), gen);
for (int i=0; i<Ext; ++i) vec.push_back(vec[i]);
shuffle(vec.begin(), vec.end(), gen);
}
for (int i : vec) Next.push_back(i);
}
if (LastGarb<GarbRise) {
if (CheckDown()) DropTime+=tm*DropL/max(1,GarbRise);
}
if (ActiveGarb.size()) {
if (LastGarb>GarbRise) {
AddGarbage(1, ActiveGarb.front().second);
//MoveDown();
if (!(--ActiveGarb.front().first)) ActiveGarb.pop_front();
LastGarb = 0;
}
}
if (!CheckActive()) {
HoldEnable=true; int NewLines=RemoveLines();
int Lines = NewLines+ChainLine;
if (!NewLines) {
InChain=false; ChainLine=0;
}
int CbW = 0;
if ((ComboRule=="multipler")||(ComboRule=="aquamino")) {
int mx = -999;
for (int i=1; i<=LY; ++i) {
if (PieceCol[i]) ComboCol[i]=-4;
else ComboCol[i]=min(0,ComboCol[i]+1);
}
int mnp=LY+1, mxp=0;
for (int i=1; i<=LY; ++i) {
if (ComboCol[i]<0) {
++CbW; mnp=min(mnp,i); mxp=max(mxp,i);
}
}
CbW = max(CbW,mxp-mnp+1);
if ((!Combo)||(CbW<2)||(CbW>4)||(!Lines)) CbW=0;
}
if (Arcade) Level+=min(6,Lines+max(0,Lines-2));
if (ArcadeInvis) {
int x = 0;
if (Lines>0) x=4;
if (Lines>1) x=8;
if (Lines>2) x=12;
if (Lines>3) x=26;
if (ArcadeInvis==2) {
x=x*5/2; if (Lines>3) x=100;
}
InvisGrade += x;
}
else if (!InvisTm) GradeRnk+=min(4,1+Level/250)*GradeBonus[min(Lines,4)][min(int(GradeBonus[min(Lines,4)].size())-1,Grade)]*(ComboMul[min(Lines,4)][min(int(ComboMul[min(Lines,4)].size())-1,Combo)]+10);
if (GradeRnk>=1000) {
++Grade; GradeRnk=0;
}
if ((SpinRule=="allfull")||(ModSpin)||(Odoo)) {
if (Spin) SemiSpin=false;
}
else if (SpinRule=="allsemi") {
if ((Spin)&&(Pid!=6)) SemiSpin=true;
}
else if (SpinRule=="allmini") {
if ((Spin)&&(Pid!=6)) {
Spin=SemiSpin=false; MiniSpin=true;
}
else if ((!Spin)&&(Pid!=6)) MiniSpin=false;
}
else if (SpinRule=="tspin") {
if (Pid!=6) Spin=SemiSpin=MiniSpin=false;
}
else if (SpinRule=="default") {
if (Pid!=6) Spin=SemiSpin=MiniSpin=false;
if ((Spin)&&(SemiSpin)) {
Spin=SemiSpin=false; MiniSpin=true;
}
}
else if (SpinRule=="minionly") {
if (Spin) {
Spin=SemiSpin=false; MiniSpin=true;
}
}
else if (SpinRule=="none") Spin=SemiSpin=MiniSpin=false;
if (SpinRule=="easy") {
SemiSpin = false;
if (MiniSpin) {
MiniSpin=false; Spin=true;
}
if ((Spin)&&(!Lines)) {
Spin=false; MiniSpin=true;
}
}
if ((ModHold==2)||((EV[6])&&(EV[5])&&(!EV[1]))) {
if (Spin) {
MiniSpin=true; Spin=SemiSpin=false;
}
}
if ((Spin)||(MiniSpin)) {
SpinType=Pid; SpinDis=0; SpinTm=15000; SpinFull=(Spin)?((SemiSpin)?1:2):0;
if (Flipped) SpinType=Flip[SpinType];
}
else if (Lines) SpinDis=1;
if ((ModSpin==2)&&(!Spin)&&(!MiniSpin)) Lines=min(Lines,1);
if ((ModSpin)&&((Spin)||(Lines))) {
pair<int,int> CurAct = make_pair(((Spin)||(MiniSpin))?Pid:0,Lines);
if (CurAct==LstAct) {
AllSpinGarbOper = true;
for (int i=0; i<((ModSpin==2)?20:1); ++i) {
lll gb = (lll(1)<<(LY+1))-lll(1);
gb &= ~(lll(1)<<RollHole(_Luck));
if (AllSpinGarb.size()<999) AllSpinGarb.push_back(make_pair(5+QueryFloor(),gb));
}
}
else {
AllSpinGarbOper = false;
LstAct = CurAct;
for (int i=0; i<AllSpinGarb.size(); ++i) --AllSpinGarb[i].first;
while ((!AllSpinGarb.empty())&&(AllSpinGarb.front().first<1)) {
AddGarbage(1,AllSpinGarb.front().second); AllSpinGarb.pop_front();
LastGarb = GarbRise;
}
}
}
if (!Complete) SumLine+=Lines;
int Attack = (Lines>1)?(1<<Lines-2):0;
int Defence=0, Heal=0, PrevB2B=B2B;
if (Lines>4) Attack=Lines;
if (BaseRule=="asc") {
if (Lines==4) --Attack;
}
if (BaseRule=="classic") Attack=(Lines>2)?Lines-1:0;
if (BaseRule=="equal") Attack=Lines;
if (BaseRule=="arcade") Attack=(Lines>2)?Lines:0;
if (BaseRule=="none") Attack=0;
if ((Lines)&&(Spin)) Attack=Lines*2-int(SemiSpin);
if ((Lines>1)&&(!Spin)&&(MiniSpin)&&(Pid==6)&&(ModHold<2)&&(SpinRule!="minionly")&&(!Odoo)) Attack=Lines*2+1;
if ((Lines)&&(tars>1)&&(TargetBonus!="none")&&(Plrs>2)&&(!QuickPlay)) {
if ((TargetBonus!="defensive")&&(AtkType==6)) Attack+=tars*2-3;
else if (TargetBonus!="99") Defence+=tars*2-3;
}
if ((!Combo)&&(Lines==1)&&(ComboRule!="none")&&(!Spin)&&(!MiniSpin)&&(QuickPlay)&&(!ModExpert)
&&(ModHold<2)&&(ModMess<2)&&(ModGravity<2)&&(ModStrength<2)&&(ModDivergence<2)
&&(ModInvisible<2)&&(ModSpin<2)) Attack=1;
int ComboAttack=0, Surge=0;
bool AC=bool(Lines), HAC=bool(Lines)&&(!Dig);
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]) {
AC=false; if (B[i][j]<=150) HAC=false;
}
}
}
if ((ACRule!="extend")&&(ACRule!="techmino")) HAC=false;
if (ACRule=="none") AC=false;
int Advanced=0, Scr=0;
if (Lines) {
ComboRem = max(0,ComboRem+ComboBase[min(int(ComboBase.size())-1,Combo)]+Lines*ComboBonus[min(int(ComboBonus.size())-1,Combo)]);
if (((Lines>1)||(!Arcade))&&(!InChain)) ++Combo;
ClearType=Lines; if (NewLines) ClearTm=10000;
ClearWType = CbW;
if (ComboRule=="none") {
Combo=0; for (int i=1; i<=LY; ++i) ComboCol[i]=0;
}
if (Spin) ClearColor=(Flipped)?Flip[Pid]:Pid;
else ClearColor=0;
if ((Combo>1)||((Combo)&&(ComboRule=="c2"))) {
ComboType=Combo-(ComboRule!="c2"); ComboTm=10000;
}
vector<int> lst;
if (ComboRule=="multipler") {
lst = {2,4,6,9,11};
if (CbW==2) lst={2,6,16,20};
if (CbW==3) lst={2,7,18,22};
if (CbW==4) lst={3,9,21,25};
}
if (ComboRule=="aquamino") {
lst = {3,6,9,12,15,18};
if (CbW==2) lst={3,6,11,15,19};
if (CbW==3) lst={3,8,15};
if (CbW==4) lst={3,9,18};
}
if (ComboRule=="io") lst={2,6,16,20};
if (ComboRule=="default") lst={2,4,6,9,11};
if (ComboRule=="friends") lst={2,5,5,7,12};
if (ComboRule=="expert") lst={2,5,7,9,12};
if (ComboRule=="battle") lst={1,3,5,7};
if (ComboRule=="99") lst={1,3,5,7,10};
if (ComboRule=="ppt") lst={2,4,6,8,13};
if (ComboRule=="effect") lst={2,4,7,13};
if (ComboRule=="zone") lst={2,4,12};
if (ComboRule=="c2") lst={1,4,6,7,7,8,8,9,9,10};
for (int o : lst) {
if (Combo>o) ++ComboAttack;
}
if ((ComboRule!="io")&&(ComboRule!="multipler")&&(ComboRule!="techmino")) Attack+=ComboAttack;
if (Combo>1) LockEff(0x39C5BB,sz*0.15,3+min(35,Combo-2),0.03);
Advanced = (Spin)||(Lines>3)||(MiniSpin)||(((AC)||(HAC))&&((ACRule=="quickplay")||(ACRule=="league")||(B2BRule=="techmino")));
if (InChain) Advanced=false;
if (Spin) {
Scr=400*(Lines+1); if (SemiSpin) Scr>>=1;
}
else if (MiniSpin) Scr=max(100,200*Lines);
else if (Lines) {
Scr=Lines*200-100; if (Lines>3) Scr+=(Lines-3)*100;
}
if ((Advanced)&&(B2BRule!="none")) {
if (B2BRule=="techmino") {
if ((Spin)||(MiniSpin)) B2B=min(100,B2B+vector<int>({0,5,10,18,80,100})[min(Lines,5)]/((Spin)?1:2));
else if (Lines>3) B2B=min(100,B2B+vector<int>({0,0,0,0,15,20})[min(Lines,5)]);
if ((PCTime)&&((AC)||(HAC))) B2B=min(100,B2B+80);
}
else {
++B2B; if (((AC)||(HAC))&&(ACRule=="quickplay")) ++B2B;
}
if (B2BRule=="default") B2B=min(B2B,2);
if (B2B>1) {
B2BType=B2B-1; B2BTm=10000;
}
if ((Spin)||(Lines>3)||(MiniSpin)) {
if (B2BRule=="techmino") {
if (PrevB2B>80) {
Attack=max(Attack+1,Attack*3/2); ++Defence; Scr*=2;
}
else if (PrevB2B>=5) {
++Attack; Scr=Scr*3/2;
}
}
else {
if (B2B>1) {
++Attack; Scr=Scr*3/2;
}
if (B2BRule=="chain") {
if (B2B>3) ++Attack;
if (B2B>8) ++Attack;
if (B2B>24) ++Attack;
if (B2B>67) ++Attack;
}
}
}
int clr=0xF3BDBD;
if (B2B>1) clr=0xFFE211;
if ((B2B>4)&&(B2BRule=="surge")) clr=B2BClr(B2B-1);
if (B2BRule=="techmino") swap(B2B,PrevB2B);
LockEff(clr, (B2B>1)?sz*0.25:sz*0.15, (B2BRule=="techmino")?(2+B2B/5):(B2B>1)?(3+min(35,B2B-2)):2, 0.04);
if (B2BRule=="techmino") swap(B2B,PrevB2B);
}
else if (!InChain) {
if (B2BRule=="techmino") B2B=max(0,B2B-25);
else {
Surge=max(0,B2B-1); B2B=0;
}
}
Scr += (Combo-1)*50;
}
else {
if (ComboRule=="c2") {
if (!InChain) ComboRem=max(0,ComboRem-390);
if (!ComboRem) {
if (ComboType) ComboTm=4000;
Combo=ComboType=0;
//for (int i=1; i<=LY; ++i) ComboCol[i]=0;
}
}
else if (!InChain) {
Combo=ComboType=0;
//for (int i=1; i<=LY; ++i) ComboCol[i]=0;
}
if (B2BRule=="techmino") {
if ((Spin)||(MiniSpin)) B2B=min(100,B2B+2);
else if (B2B>80) B2B=max(80,B2B-2);
}
if (Spin) {
if (SemiSpin) Scr=200;
else Scr=400;
}
else if (MiniSpin) Scr=100;
}
if ((B2BRule=="techmino")&&((PrevB2B!=B2B)||(((PrevB2B)||(B2B))&&(Lines)))) {
B2BType=B2B; B2BTm=10000;
}
if ((ComboRule=="multipler")||(ComboRule=="io")||(ComboRule=="techmino")) {
if ((Lines>1)||(ComboRule!="techmino")) Attack=max(ComboAttack,Attack*(4+min(max(0,Combo-1),(ComboRule=="techmino")?12:(((ComboRule=="io")||(CbW<2))?99999999:((CbW==2)?12:((CbW==3)?8:5)))))/4);
else Attack=max(ComboAttack,Attack*(10+min(max(0,Combo-1),12)*3)/10);
}
if ((Combo>3)&&(ComboRule=="techmino")) ++Attack;
if ((Dig)&&(Advanced)) {
if (GarbageBonus=="default") ++Defence;
if (GarbageBonus=="io") ++Attack;
}
if (Surge) {
B2BType=0; B2BTm=10000;
}
if ((Surge>3)&&(B2BRule=="surge")) {
Attack+=Surge; LockEff(0xFFFFFF,sz*0.15,15,0.2);
}
else if (Surge) {
LockEff(0xFF6666,sz*0.15,3,0.04); Surge=0;
}
if ((AC)||(HAC)) ++PCTime;
if (AC) {
ScreenEffect(sz*0.1,0.005,0xFFE211,3); Scr+=3500;
if (ACRule=="extend") {
Attack+=LY; Defence+=2;
}
else if (ACRule=="default") Attack+=LY;
else if (ACRule=="techmino") {
Attack+=min(16,6+PCTime*2); Defence+=2;
}
else if (ACRule=="quickplay") Attack+=3;
else if (ACRule=="league") Attack+=5;
else if (ACRule=="99") Attack+=4;
else if (ACRule=="arcade") Attack<<=1;
double asz = sz*0.16*double(LY);
TQu.push_back({sz*0.5*double(DX)-asz*1.5,sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0002,"ALL",0xFDD000});
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0002,"CLEAR",0xFDD000});
}
else if (HAC) {
ScreenEffect(sz*0.05,0.005,0xFFE211,3); Scr+=2000;
if (ACRule=="extend") {
int Bonus = min(LY/2,(LY+2)/3);
Attack+=Bonus; Heal+=min(4,LY-Bonus);
}
else if (ACRule=="techmino") {
Attack+=min(12,2+PCTime*2); Defence+=2;
}
double asz = sz*0.16*double(LY);
TQu.push_back({sz*0.5*double(DX)-asz*1.5,sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0004,"HALF",0xFDD000});
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0004,"CLEAR",0xFDD000});
}
ll curtm = clock();
int Mins = int((curtm-begtm)/30000LL);
if ((Mins>=6)&&(Plrs>1)&&(!QuickPlay)) Attack=Attack*min(15,Mins)/6;
if (BadgeBonus=="default") {
int Bonus = 0;
if (SKO>=2) ++Bonus;
if (SKO>=4) ++Bonus;
if (SKO>=8) ++Bonus;
if (SKO>=16) ++Bonus;
if (SKO>=32) ++Bonus;
if (SKO>=64) ++Bonus;
Attack += Attack*Bonus/15+(rnd(15)<(Attack*Bonus%15));
}
if (BadgeBonus=="99") {
int Bonus = 0;
if (SKO>=2) ++Bonus;
if (SKO>=6) ++Bonus;
if (SKO>=14) ++Bonus;
if (SKO>=30) ++Bonus;
Attack += Attack*Bonus/4+(rnd(4)<(Attack*Bonus%4));
}
if (InChain) Attack=Defence=Heal=0;
if (!Complete) SumAttack+=Attack;
if (SumPiece<OpenerPhrase) {
if (OpenerBonus=="default") Defence+=Attack;
if ((OpenerBonus=="io")&&((Attack<<1)<=ActiveGarb.size()+Rec.size())) Defence+=Attack;
}
if (GarbageCancel=="dig") {
Heal+=Attack; Attack=0;
}
int preHeal=Heal; Heal=ClearGarbage(Heal);
SumDig += preHeal-Heal;
int Cancel=preHeal-Heal; Attack+=Heal;
if ((Cancel)&&(DisAtk)) {
sprintf(buf, "+%d", Cancel);
double px=sz*(DX-avx), py=sz*avy, rat=min(10.0,1.0+double(Cancel-1)*0.1);
double th=rndf()*acos(-1.0)*2.0; px+=sin(th)*sz*3.0; py+=cos(th)*sz*3.0;
TQu.push_back((FloatText){px,py,sz*rat,0.4,0.0011/min(3.0,rat),string(buf),Mix(0x000000,0xA4FF00,0.2)});
TQu.push_back((FloatText){px,py,sz*rat,0.3,0.001/min(3.0,rat),string(buf),0xFFFFFF});
}
if (ModStrength==1) Attack<<=1;
Cancel = 0;
while ((ActiveGarb.size())&&(Defence)&&(ModDivergence<2)&&(GarbageCancel!="none")) {
int val=min(Defence,ActiveGarb.front().first);
Defence-=val; ActiveGarb.front().first-=val; Cancel+=val;
if (!ActiveGarb.front().first) ActiveGarb.pop_front();
}
while ((Rec.size())&&(Defence)&&(ModDivergence<2)&&(GarbageCancel!="none")) {
int val=min(Defence,Rec.front().first); Defence-=val; Cancel+=val;
Rec.front().first-=val; if (!Rec.front().first) Rec.pop_front();
}
if ((Cancel)&&(DisAtk)) {
if (!ModExpert) AccRnk+=150*Cancel*60;
sprintf(buf, "-%d", Cancel);
double px=sz*(DX-avx), py=sz*avy, rat=min(10.0,1.0+double(Cancel-1)*0.1);
double th=rndf()*acos(-1.0)*2.0; px+=sin(th)*sz*3.0; py+=cos(th)*sz*3.0;
TQu.push_back((FloatText){px,py,sz*rat,0.4,0.0011/min(3.0,rat),string(buf),0xFAAFBE});
TQu.push_back((FloatText){px,py,sz*rat,0.3,0.001/min(3.0,rat),string(buf),0xFFFFFF});
}
if ((Defence)&&(DisAtk)) {
sprintf(buf, "-%d", Defence);
double px=sz*(DX-avx), py=sz*avy, rat=min(10.0,1.0+double(Cancel-1)*0.1);
double th=rndf()*acos(-1.0)*2.0; px+=sin(th)*sz*3.0; py+=cos(th)*sz*3.0;
TQu.push_back((FloatText){px,py,sz*rat,0.1,0.00025/min(3.0,rat),string(buf),0xCCCCCC});
}
int E = 0;
if (Odoo) {
if (Lines>3) E=3;
if ((Spin)||(MiniSpin)) {
if (Pid==4) {
for (int _=0; _<max(1,Lines); ++_) Cy.push_back(make_pair(clock(),0));
}
if (Pid==7) E=1;
if (Pid==2) E=2;
if (Pid==6) E=4;
if (Pid==5) E=5;
if (Pid==1) E=6;
if (Pid==3) E=7;
}
if (!QuickPlay) Attack>>=1;
if ((Lines>1)||((Lines)&&(Combo>2))) Attack=max(1,Attack);
}
if ((E)&&(!Attack)) Atk.push(make_pair(0,E));
Cancel = 0;
while ((ActiveGarb.size())&&(Attack)&&(ModDivergence<2)&&(GarbageCancel!="none")) {
int val=min(Attack,ActiveGarb.front().first);
Attack-=val; ActiveGarb.front().first-=val; Cancel+=val;
if (!ActiveGarb.front().first) ActiveGarb.pop_front();
}
while ((Rec.size())&&(Attack)&&(ModDivergence<2)&&(GarbageCancel!="none")) {
if ((Passthrough)&&(int(curtm-Rec.front().second.second)<Passthrough)) break;
int val=min(Attack,Rec.front().first); Attack-=val; Cancel+=val;
Rec.front().first-=val; if (!Rec.front().first) Rec.pop_front();
}
if ((Cancel)&&(DisAtk)) {
if (!ModExpert) AccRnk+=150*Cancel*60;
sprintf(buf, "%d", Cancel);
double px=sz*(DX-avx), py=sz*avy, rat=min(10.0,1.0+double(Cancel-1)*0.1);
double th=rndf()*acos(-1.0)*2.0; px+=sin(th)*sz*3.0; py+=cos(th)*sz*3.0;
int clr = 0xAAAAAA;
if (Surge) clr=0x00FFCC;
else if ((Spin)||(MiniSpin)) clr=Piece[Pid][0].clr;
else if (Combo>1) clr=0x39C5BB;
if (Odoo) {
clr = 0xAAAAAA;
if (E==1) clr=0xEE0000;
if (E==2) clr=0x0080FF;
if (E==3) clr=0x00FFCC;
if (E==4) clr=0xEE82EE;
if (E==5) clr=Mix(0x000000,0x33EE00,0.1);
if (E==6) clr=0x66CCFF;
if (E==7) clr=0xFFA500;
}
TQu.push_back((FloatText){px,py,sz*rat,0.4,0.0011/min(3.0,rat),string(buf),clr});
TQu.push_back((FloatText){px,py,sz*rat,0.3,0.001/min(3.0,rat),string(buf),0xFFFFFF});
}
if (ModStrength==1) Attack>>=1;
if ((Attack)&&(DisAtk)) {
sprintf(buf, "%d", Attack);
double px=sz*(DX-avx), py=sz*avy, rat=min(10.0,1.0+double(Attack-1)*0.1);
double th=rndf()*acos(-1.0)*2.0; px+=sin(th)*sz*3.0; py+=cos(th)*sz*3.0;
int clr = 0xAAAAAA;
if (Surge) clr=0x00FFCC;
else if ((Spin)||(MiniSpin)) clr=Piece[Pid][0].clr;
else if (Combo>1) clr=0x39C5BB;
if (Odoo) {
clr = 0xAAAAAA;
if (E==1) clr=0xEE0000;
if (E==2) clr=0x0080FF;
if (E==3) clr=0x00FFCC;
if (E==4) clr=0xEE82EE;
if (E==5) clr=Mix(0x000000,0x33EE00,0.1);
if (E==6) clr=0x66CCFF;
if (E==7) clr=0xFFA500;
}
TQu.push_back((FloatText){px,py,sz*rat,0.4,0.0011/min(3.0,rat),string(buf),(B2B>1)?0xFDD000:0xFFFFFF});
TQu.push_back((FloatText){px,py,sz*rat,0.3,0.001/min(3.0,rat),string(buf),clr});
}
if (QuickPlay) {
GiveScore(Attack*1000); AccRnk+=1050*Attack*60;
}
else if (!Complete) Score+=Scr*min(40,1+QueryLev());
int Segs = (Surge)?3:1;
if ((!QuickPlay)&&(Plrs>2)&&(AtkType==6)) Segs=max(Segs,100);
for (int i=Segs; i; --i) {
if (!Attack) break;
Atk.push(make_pair((Attack+i-1)/i,E)); Attack-=(Attack+i-1)/i;
}
if (((!Lines)&&(GarbageMode=="combo"))||(GarbageMode=="lock")||((!Attack)&&(GarbageMode=="attack"))) {
int rem = GarbageGap;
while ((Rec.size())&&(Rec.front().second.second+ll(GarbDelay)<curtm)&&(rem)) {
int val = min(rem,Rec.front().first);
rem -= val;
if (GarbRise) ActiveGarb.push_back(make_pair(val,Rec.front().second.first));
else AddGarbage(val, Rec.front().second.first);
Rec.front().first-=val; if (!Rec.front().first) Rec.pop_front();
}
}
if (!ModExpert) {
if (Lines>1) AccRnk+=2050*60;
else if (Lines) AccRnk+=1050*60;
}
if ((NewLines)&&((ClearGravity=="sticky")||(ClearGravity=="cascade")||(ClearGravity=="separate"))) {
InChain=true; ChainLine=Lines; AreLeft=LCD;
}
else {
while (InitHold--) {
if (Hold) swap(Next.front(),Hold);
else if (Next.size()>1) {
Hold=Next.front(); Next.pop_front();
}
}
bool suc = false;
bool cl = bool(Lines);
if (ClutchRule=="always") cl=true;
if (ClutchRule=="none") cl=false;
if (CheckSpawn(Next.front(),(InitRot+InitFacing)&3)) suc=Spawn(Next.front(),(InitRot+InitFacing)&3,cl);
else suc=Spawn(Next.front(),InitFacing,cl);
InitHold=InitRot=0;
int seed = time(0);
if (suc) {
Next.pop_front(); if (Zen) Storage=true;
}
else if (Life) {
while (Rec.size()) Rec.pop_front();
while (Bl.size()) Bl.pop();
while (ActiveGarb.size()) ActiveGarb.pop_front();
for (int i=1; i<=7; ++i) EV[i]=0;
--Life;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]) {
double dx=sz*double(DX-i)+sz*0.5, dy=sz*double(j-1)+sz*0.5;
#define sq(beg, ss, clr) PQu.push_back({dx,dy,vx,vy,0.001,0,sz*0.5*ss,0.002,theta,4,clr})
double vx = -0.7+0.2*(rnd(10000)*0.0001);
double vy = 0.2*(rnd(10000)*0.0001-0.5);
double theta = acos(-1.0)*rndf();
int clr = Mix(Piece[B[i][j]][0].clr,0xFFFFFF,0.7);
sq(0, 1, clr);
#undef sq
}
B[i][j]=C[i][j]=LE[i][j]=0;
}
}
if (Zen) Storage=true;
}
else {
while (Atk.size()) Atk.pop();
while (Rec.size()) Rec.pop_front();
while (ActiveGarb.size()) ActiveGarb.pop_front();
Over = true;
return;
}
DropTime=0; ResetRem=max(1,ResetLim);
if (!suc) return;
}
}
else memset(PrePos,0,sizeof(PrePos));
if ((Bot)&&(CheckActive())&&(Oper.empty())&&(PermitAI)) {
++UseAI;
st.clear(); mp.clear();
int fx=0, fy=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (C[i][j]) {
fx=i; fy=j; break;
}
}
if (fx) break;
}
bfs(Pid, InitFacing, fx-Piece[Pid][InitFacing].FstX, fy-Piece[Pid][InitFacing].FstY);
int pp = (Hold)?Hold:Next.front();
int SX=DX-1+Piece[pp][InitFacing].SDel, SY=(LY-Piece[pp][InitFacing].LY)/2+1;
SY = max(1,min(LY-Piece[pp][InitFacing].LY+1,SY));
SX = max(1,min(LX,SX));
if ((Pid!=pp)&&(HoldEnable)&&(HoldRule)) bfs(pp,InitFacing,SX,SY);
string rstr; int MaxEval=-1000000000; ClassSta best;
bool ee = true;
int _stas=0, _stas2=0;
for (ClassSta o : st) {
if (st.count((ClassSta){o.p,o.d,o.x-1,o.y})) continue;
++_stas;
int Height=0, NewHeight=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
D[i][j]=((B[i][j])&&(!C[i][j]));
if (D[i][j]) Height=i;
}
}
NewHeight = Height;
for (int i=0; i<Piece[o.p][o.d].LX; ++i) {
for (int j=0; j<Piece[o.p][o.d].LY; ++j) {
if (Piece[o.p][o.d].B[i][j]) {
D[o.x+i][o.y+j]=2; NewHeight=max(NewHeight,o.x+i);
}
}
}
bool sU=false, sD=false, sL=false, sR=false;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (D[i][j]!=2) continue;
if ((i==1)||(D[i-1][j]==1)) sD=true;
if ((i==LX)||(D[i+1][j]==1)) sU=true;
if ((j==1)||(D[i][j-1]==1)) sL=true;
if ((j==LY)||(D[i][j+1]==1)) sR=true;
}
}
#warning eval
int Eval = 0;
if ((Plr==2&&0)&&(Height+8<DX)) {
bool ff = false;
int mx=0, bel=1;
for (int j=1; j<=LY; ++j) {
int cnt = 0;
for (int i=1; i<=LX; ++i) {
if (!B[i][j]) ++cnt;
}
if (cnt>=mx) {
mx=cnt; bel=j;
}
}
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((D[i][j]==2)&&(j==bel)) ff=true;
}
}
if (ff) Eval-=10;
}
for (int i=1; i<=LY; ++i) G[LX+1][i]=1;
for (int i=LX; i; --i) {
for (int j=1; j<=LY; ++j) {
if (D[i][j]) G[i][j]=0;
else G[i][j]=G[i+1][j];
}
for (int j=2; j<=LY; ++j) {
if (!D[i][j]) G[i][j]|=G[i][j-1];
}
for (int j=LY-1; j; --j) {
if (!D[i][j]) G[i][j]|=G[i][j+1];
}
}
bool ook = false;
if (Plr==4) {
int cnt = 0;
for (int i=1; i<=LX; ++i) {
bool f1=false, f2=true;
for (int j=1; j<=LY; ++j) {
if (D[i][j]==2) f1=true;
if (G[i][j]) f2=false;
}
if ((f1)&&(f2)) ++cnt;
}
if (cnt>3) ook=true;
}
int Tsc=0, Tsn=0;
vector<int> Exist(155,0);
for (int i=0; i<min(int(Next.size()),6); ++i) Exist[Next[i]]=max(Exist[Next[i]],6-i);
if (Hold) Exist[Hold^Pid^o.p]=6;
for (int i : Bag) ++Exist[i];
if (Plr==6) {
for (int i=0; i<155; ++i) {
if (Exist[i]<4) Exist[i]=0;
}
}
int bubline=0, gbrem=5, ckli=0; bool iso=false, cel=false;
for (int i=LX; i; --i) {
bool ce=false, gb=false;
for (int j=1; j<=LY; ++j) {
if (B[i][j]>150) gb=true;
if ((i+1<LX)&&(!D[i][j])&&(!D[i+1][j])&&(D[i+2][j])) ce=true;
}
if ((gb)&&(gbrem)) {
--gbrem; continue;
}
int tt = 0;
for (int j=1; j<=LY; ++j) {
if ((D[i][j])||(!G[i][j])) ++tt;
if ((!D[i][j])&&(!G[i][j])) {
++bubline; tt=-1; break;
}
}
if ((tt>=0)&&(ce)&&(iso)) ++bubline;
if (ce) cel=true;
if (tt>=LY-1) iso=true;
if (ce) ckli=max(ckli,i);
}
int c2w = 0;
for (int i=2; i<=LX; ++i) {
for (int j=1; j<LY; ++j) {
if ((G[i][j])&&(!D[i][j])&&(!D[i][j+1])&&(!D[i-1][j])&&(!D[i-1][j+1])
&&(CheckD(i,j-1))&&(CheckD(i,j+2))&&(CheckD(i-1,j-1))&&(CheckD(i-1,j+2))) ++c2w;
}
}
//if (Plr==5) Eval-=2*max(0,c2w-2);
if (ee) {
ee = false;
if (bubline<2||(Height+7<DX&&B2B)) SetSpin=true;
if (bubline>((Bag.size()<10)?5:5)||Height+6>=DX) SetSpin=false;
//SetSpin = ((Height<=10)||(bubline<3))&&(Height<=15);
}
if (ModSpin==2) SetSpin=true;
//if ((Plr==6)&&(KickTable=="asc")&&(Height+10>DX)) SetSpin=false;
int bk=0, mTsn=0, mTsc=0, cn=0, dif=0, MxSp=0;
vector<int> IsBub(LX+1,0), Fill(LX+1,0), PFill(LX+1,0), CurV(LX+1,0), ExtScr(LX+1,0), NxtScr(LX+1,0);
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((!D[i][j])&&(!G[i][j])) IsBub[i]=true;
//if ((!SetSpin)&&(i<LX)&&(!D[i][j])&&(D[i+1][j])) IsBub[i]=true;
if (D[i][j]) {
++Fill[i]; ++PFill[i];
}
}
//if ((!SetSpin)&&(i<LX)&&(IsBub[i+1])) IsBub[i]=true;
}
for (int j=1; j<=LY; ++j) {
for (int i=LX; i; --i) {
if (D[i][j]) break;
++PFill[i];
}
}
bool Mini=true, hp=false; int nc=0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (D[i][j]!=2) continue;
if (int(D[i-1][j]==2)+int(D[i+1][j]==2)+int(D[i][j-1]==2)+int(D[i][j+1]==2)
+int(D[i-1][j-1]==2)+int(D[i-1][j+1]==2)+int(D[i+1][j-1]==2)+int(D[i+1][j+1]==2)<3) continue;
if (int(CheckF(i-1,j-1))+int(CheckF(i+1,j-1))+int(CheckF(i-1,j+1))+int(CheckF(i+1,j+1))<3) Mini=false;
if (int(CheckD(i-1,j-1))+int(CheckD(i+1,j-1))+int(CheckD(i-1,j+1))+int(CheckD(i+1,j+1))<3) ++nc;
hp = true;
}
}
if ((!hp)||(nc>1)) Mini=false;
if ((mp[o].empty())||((mp[o].back()!=KEY_CW)&&(mp[o].back()!=KEY_CCW))) Mini=false;
int SpinScr=0, spid=0, ExtraScr=0;
int Land=0, Lines=0, Ero=0, pn=0;
for (int i=1; i<=LX; ++i) {
bool ok=true; int ins=0;
for (int j=1; j<=LY; ++j) {
if (!D[i][j]) ok=false;
if (B[i][j]==153) ok=false;
if (D[i][j]==2) {
++ins; Land=i;
}
}
if (i<=RoundHeight) ok=false;
if (ok) {
++Lines; Ero+=ins;
}
else {
++pn; for (int j=1; j<=LY; ++j) D[pn][j]=D[i][j];
}
}
for (int i=1; i<155; ++i) {
if ((Plr!=6)||(!Exist[i])||(Height+8>DX)) continue;
//if (!SetSpin) continue;
//if ((!(sU*sD*sL*sR))&&(Lines)&&(SetSpin)) continue;
int CurSp=0, ImeSp=0;
SX=DX-1+Piece[i][InitFacing].SDel, SY=(LY-Piece[i][InitFacing].LY)/2+1;
SY = max(1,min(LY-Piece[i][InitFacing].LY+1,SY));
SX = max(1,min(LX,SX));
LI = Height+2;
SX = min(SX,LI);
Ddfs((ClassSta){i,InitFacing,SX,SY});
//VV.clear(); continue;
for (ClassSta vv : VV) {
++_stas2; int d=vv.d, x=vv.x, y=vv.y;
//if (x>20) printf("p=%d x=%d y=%d d=%d\n",i,x,y,d);
bool ff = (!CheckDPos((ClassSta){i,d,x-1,y}))&&(!CheckDPos((ClassSta){i,d,x+1,y}))&&(!CheckDPos((ClassSta){i,d,x,y-1}))&&(!CheckDPos((ClassSta){i,d,x,y+1}));
if (ff) {
++spid; int Cert=0, Prob=0, Tot=0;
for (pair<int,int> pp : DDP[i][d]) {
int nx = x+pp.first;
++Fill[nx]; ++PFill[nx];
if (Fill[nx]==LY) ++Cert;
if (PFill[nx]==LY) ++Prob;
if (CurV[nx]<spid) {
CurV[nx]=spid; ++Tot; //if (!IsBub[nx]) ++Prob;
}
}
if ((Cert)&&(!ff)) ExtraScr+=Cert*5;
if (!ff) Cert=Prob=0;
int Er=0; for (pair<int,int> pp : DDP[i][d]) Er+=int(Fill[x+pp.first]==LY);
int sn=0, se=0;
int vv = 100;//(Height+12<DX)?200:100;
vv = 100-5*bubline;
vv = max(0,vv);
sn = vv*Er*(Prob+Cert);
se = vv*Er*(Prob+Cert)/2;///4;
//if ((!Cert)&&(Exist[i]==7)&&(!SetSpin)) Prob=0;
sn = sn*max(1,Exist[i]-3)/3;
se *= Cert;
for (int j=LX; j; --j) {
if ((!IsBub[j])&&(CurV[j]==spid)) {
ExtScr[j] = max(ExtScr[j],se/max(1,2+bubline));
}
if (Fill[j]==LY) {
ExtScr[j]=max(ExtScr[j],se/max(1,5+bubline)); break;
}
}
CurSp = max(CurSp,sn);
if (Cert&&bubline<5) ImeSp=max(ImeSp,600);
for (pair<int,int> pp : DDP[i][d]) {
--Fill[x+pp.first]; --PFill[x+pp.first];
}
}
}
for (ClassSta vv : VV) DV[vv.d][vv.x+10][vv.y+10]=false;
VV.clear();
//CurSp *= (5+Exist[i])/7;
MxSp = max(MxSp,CurSp);
if (Exist[i]>=6) SpinScr+=ImeSp;
}
int rem = 999;
for (int i=LX; i; --i) {
if (--rem<=0) break;
if (ExtScr[i]) {
SpinScr+=ExtScr[i]; rem=min(rem,(SetSpin&&Height<10)?4:2);
}
}
SpinScr += MxSp;
SpinScr += ExtraScr;
SpinScr = SpinScr*7/10;
if ((Plr==6)&&(KickTable=="asc")&&(Height+10>DX)&&0) SpinScr/=2;
if (Plr==6) {
for (int j=1; j<=LY; ++j) {
int tt = 0;
int bb = -999;
for (int i=LX; i; --i) {
if (D[i][j]) {
++tt; if (bb<0) bb=5;
}
if ((i+5<DX)&&(!D[i][j])&&((CheckD(i+3,j-1)||(CheckD(i+3,j+1))))&&((!CheckD(i,j-1))||(!CheckD(i,j+1))||(ModSpin==2)))
SpinScr-=max(0,180-i*10);//((i<=15)?((i<=5)?150:100):50);
if ((!D[i][j])&&(!G[i][j])&&(SetSpin)) SpinScr-=max(0,bb)*tt+max(0,15-i);
if (bb>=0) --bb;
}
}
}
if (Plr==6) Eval-=bubline;
for (int i=LX; i>=1; --i) {
if (Plr!=5&&Plr!=6) continue;
int fn=0, fg=0, bub=0, bub2=0, dii=0;
for (int j=1; j<=LY; ++j) {
fn += (D[i][j]!=0);
fg += (G[i][j]==0);
if (i<LX) bub+=((!G[i][j])&&(!D[i][j]));
if (i+1<LX) bub2+=((!G[i+1][j])&&(!D[i+1][j]));
if ((G[i][j])&&(!D[i][j])&&(CheckD(i,j-1))) ++dii;
//if ((!SetSpin)&&(i<LX)&&(!G[i][j])&&(!D[i][j])&&(D[i+1][j])) Eval-=2;
}
if (dii>1) dif=1;
if (dif) ++dif;
if (dif>3&&Plr==5) Eval-=1;
for (int j=1; j<=LY; ++j) {
bool ok = (!CheckD(i,j))&&(!CheckD(i,j-1))&&(!CheckD(i+1,j))&&(CheckD(i+1,j+1))&&(CheckD(i+1,j-1))&&(CheckD(i+2,j+1));
if (!ok) continue;
//if ((Height<8)&&(CheckD(i-1,j))) continue;
if (SetSpin) Eval-=1;
}
for (int j=1; j<=LY; ++j) {
bool ok = (!CheckD(i,j))&&(!CheckD(i,j+1))&&(!CheckD(i+1,j))&&(CheckD(i+1,j+1))&&(CheckD(i+1,j-1))&&(CheckD(i+2,j-1));
if (!ok) continue;
//if ((Height<8)&&(CheckD(i-1,j))) continue;
if (SetSpin) Eval-=1;
}
if (Plr!=5) continue;
if (fg>=LY-1) cn=max(cn,1);
if (cn) {
if (++cn>3) break;
}
if ((bub)&&(bub2)) continue;
if (i+1<ckli) continue;
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
if ((!CheckD(i+1,j-1))||(!CheckD(i-1,j-1))) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i-1,j))&&(!CheckD(i,j+1));
if (!ok) continue;
ok = (!CheckD(i+2,j))&&(!CheckD(i+2,j+1))&&(!CheckD(i+2,j+2))&&(!CheckD(i+3,j+1))&&(!CheckD(i+3,j+2));
if (!ok) continue;
if ((CheckD(i+2,j+3))&&(!CheckD(i+3,j+3))) continue;
int cn = int(CheckD(i+1,j+1))+int(CheckD(i+3,j))+int(CheckD(i-2,j)||CheckD(i-1,j+1));
if (cn==3) Tsn=max(Tsn,Exist[6]),Eval+=10;
if (cn==3&&fn>=LY-2) Tsc=max(Tsc,Exist[6]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
if ((!CheckD(i+1,j+1))||(!CheckD(i-1,j+1))) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i-1,j))&&(!CheckD(i,j-1));
if (!ok) continue;
ok = (!CheckD(i+2,j))&&(!CheckD(i+2,j-1))&&(!CheckD(i+2,j-2))&&(!CheckD(i+3,j-1))&&(!CheckD(i+3,j-2));
if (!ok) continue;
if ((CheckD(i+2,j-3))&&(!CheckD(i+3,j-3))) continue;
int cn = int(CheckD(i+1,j-1))+int(CheckD(i+3,j))+int(CheckD(i-2,j)||CheckD(i-1,j-1));
if (cn==3) Tsn=max(Tsn,Exist[6]),Eval+=10;
if (cn==3&&fn>=LY-2) Tsc=max(Tsc,Exist[6]);
}
/*for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
if ((!CheckD(i+1,j-1))||(!CheckD(i-1,j-1))) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i-1,j))&&(!CheckD(i-1,j+1));
if (!ok) continue;
ok = (!CheckD(i+2,j))&&(!CheckD(i+2,j+1))&&(!CheckD(i+2,j+2))&&(!CheckD(i+3,j+2));
if (!ok) continue;
if ((CheckD(i+2,j+3))&&(!CheckD(i+3,j+3))) continue;
int cn = int(CheckD(i,j+1))+int(CheckD(i+1,j+1))+int(CheckD(i+3,j)||CheckD(i+4,j))+int(CheckD(i-2,j)||CheckD(i-2,j+1));
if (cn==4) Tsn=max(Tsn,Exist[3]),Eval+=0;
if (cn==4&&fn>=LY-1) Tsc=max(Tsc,Exist[3]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
if ((!CheckD(i+1,j+1))||(!CheckD(i-1,j+1))) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i-1,j))&&(!CheckD(i-1,j-1));
if (!ok) continue;
ok = (!CheckD(i+2,j))&&(!CheckD(i+2,j-1))&&(!CheckD(i+2,j-2))&&(!CheckD(i+3,j-2));
if (!ok) continue;
if ((CheckD(i+2,j-3))&&(!CheckD(i+3,j-3))) continue;
int cn = int(CheckD(i,j-1))+int(CheckD(i+1,j-1))+int(CheckD(i+3,j)||CheckD(i+4,j))+int(CheckD(i-2,j)||CheckD(i-2,j-1));
if (cn==4) Tsn=max(Tsn,Exist[2]),Eval+=0;
if (cn==4&&fn>=LY-1) Tsc=max(Tsc,Exist[2]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
if ((!CheckD(i+1,j+1))||(!CheckD(i-1,j+1))) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i-1,j+1))&&(!CheckD(i,j+1));
if (!ok) continue;
ok = (!CheckD(i+2,j))&&(!CheckD(i+2,j+1))&&(!CheckD(i+3,j+2))&&(!CheckD(i+3,j+1));
if (!ok) continue;
int cn = int(CheckD(i+1,j+1))+int(CheckD(i+3,j)||CheckD(i+4,j))+int(CheckD(i-2,j+1)||CheckD(i-1,j));
if (cn==3) Tsn=max(Tsn,Exist[5]);
if (cn==3&&fn>=LY-2) Tsc=max(Tsc,Exist[5]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
if ((!CheckD(i+1,j+1))||(!CheckD(i-1,j+1))) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i-1,j-1))&&(!CheckD(i,j-1));
if (!ok) continue;
ok = (!CheckD(i+2,j))&&(!CheckD(i+2,j-1))&&(!CheckD(i+3,j-2))&&(!CheckD(i+3,j-1));
if (!ok) continue;
int cn = int(CheckD(i+1,j-1))+int(CheckD(i+3,j)||CheckD(i+4,j))+int(CheckD(i-2,j-1)||CheckD(i-1,j));
if (cn==3) Tsn=max(Tsn,Exist[7]);
if (cn==3&&fn>=LY-2) Tsc=max(Tsc,Exist[7]);
}*/
if (i<ckli) continue;
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i,j+1))&&(!CheckD(i-1,j+1));
if (!ok) continue;
//if ((!CheckD(i,j+2))&&(!CheckD(i-1,j+2))) continue;
int cn = int(CheckD(i+1,j+1))+int(CheckD(i+2,j+2))+int(CheckD(i-2,j+1)||CheckD(i-1,j));
if ((CheckD(i+2,j))||(CheckD(i+2,j+1))||(CheckD(i+3,j+1))||(CheckD(i+3,j+2))) continue;
if (cn==3) Tsn=max(Tsn,Exist[5]);
if (cn==3&&fn>=LY-3) Tsc=max(Tsc,Exist[5]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i,j-1))&&(!CheckD(i-1,j-1));
if (!ok) continue;
//if ((!CheckD(i,j-2))&&(!CheckD(i-1,j-2))) continue;
int cn = int(CheckD(i+1,j-1))+int(CheckD(i+2,j-2))+int(CheckD(i-2,j-1)||CheckD(i-1,j));
if ((CheckD(i+2,j))||(CheckD(i+2,j-1))||(CheckD(i+3,j-1))||(CheckD(i+3,j-2))) continue;
if (cn==3) Tsn=max(Tsn,Exist[7]);
if (cn==3&&fn>=LY-3) Tsc=max(Tsc,Exist[7]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i+1,j-1))&&(!CheckD(i+1,j-2))&&(!CheckD(i+1,j-1))&&(CheckD(i+2,j));
if (!ok) continue;
if ((!CheckD(i+2,j-3))||(!CheckD(i+1,j-3))) continue;
int cn = int(CheckD(i,j-1))+int(CheckD(i,j-2))+int(CheckD(i+2,j));
if (cn==3) Tsn=max(Tsn,Exist[2]);
if (cn==3&&fn>=LY-3) Tsc=max(Tsc,Exist[2]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i+1,j+1))&&(!CheckD(i+1,j+2))&&(!CheckD(i+1,j+1))&&(CheckD(i+2,j));
if (!ok) continue;
if ((!CheckD(i+2,j+3))||(!CheckD(i+1,j+3))) continue;
int cn = int(CheckD(i,j+1))+int(CheckD(i,j+2))+int(CheckD(i+2,j));
if (cn==3) Tsn=max(Tsn,Exist[3]);
if (cn==3&&fn>=LY-3) Tsc=max(Tsc,Exist[3]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i,j))&&(!CheckD(i+2,j))&&(!CheckD(i+1,j-1))&&(!CheckD(i+1,j+1));
if (!ok) continue;
int cn = int(CheckD(i+2,j+1))+int(CheckD(i,j+1))+int(CheckD(i+2,j-1))+int(CheckD(i,j-1));
//if (CheckD(i+2,j-1)&&CheckD(i+2,j+1)) continue;
if (cn==3) Tsn=max(Tsn,Exist[6]);
if (cn==3&&fn>=LY-3) Tsc=max(Tsc,Exist[6]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i+1,j+1))&&(!CheckD(i,j-1))&&(!CheckD(i+2,j));
if (!ok) continue;
if ((CheckD(i+2,j-1))&&((!CheckD(i+2,j-1))||(!CheckD(i+2,j+2)||(CheckD(i+2,j+1))))) continue;
int cn = int(CheckD(i,j+1))+int(CheckD(i+1,j-1));
if (cn==2) Tsn=max(Tsn,Exist[5]);
if (cn==2&&fn>=LY-2) Tsc=max(Tsc,Exist[5]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i+1,j))&&(!CheckD(i+1,j-1))&&(!CheckD(i,j+1))&&(!CheckD(i+2,j));
if (!ok) continue;
if ((CheckD(i+2,j+1))&&((!CheckD(i+2,j+1))||(!CheckD(i+2,j-2)||(CheckD(i+2,j-1))))) continue;
int cn = int(CheckD(i,j-1))+int(CheckD(i+1,j+1));
if (cn==2) Tsn=max(Tsn,Exist[7]);
if (cn==2&&fn>=LY-2) Tsc=max(Tsc,Exist[7]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i,j-1))&&(!CheckD(i,j+1))&&(!CheckD(i+1,j-1));
if (!ok) continue;
//if ((!CheckD(i-1,j))&&(!CheckD(i-1,j-1))&&(!CheckD(i-1,j+1))&&(!CheckD(i-2,j+1))) continue;
int cn = int(CheckD(i+1,j))+int(CheckD(i+1,j+1));
if (cn==2) Tsn=max(Tsn,Exist[2]);
if (cn==2&&fn>=LY-3) Tsc=max(Tsc,Exist[2]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i,j-1))&&(!CheckD(i,j+1))&&(!CheckD(i+1,j+1));
if (!ok) continue;
//if ((!CheckD(i-1,j))&&(!CheckD(i-1,j-1))&&(!CheckD(i-1,j+1))&&(!CheckD(i-2,j-1))) continue;
int cn = int(CheckD(i+1,j))+int(CheckD(i+1,j-1));
if (cn==2) Tsn=max(Tsn,Exist[3]);
if (cn==2&&fn>=LY-3) Tsc=max(Tsc,Exist[3]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i,j-1))&&(!CheckD(i+1,j))&&(!CheckD(i+2,j))&&(!CheckD(i+2,j+1))&&(CheckD(i+1,j+1));
if (!ok) continue;
if ((!CheckD(i-1,j))&&(!CheckD(i-1,j-1))) continue;
int cn = int(CheckD(i+1,j-1))+int(CheckD(i-1,j));
if (cn==2) Tsn=max(Tsn,Exist[2]);
if (cn==2&&fn>=LY-2) Tsc=max(Tsc,Exist[2]);
}
for (int j=1; j<=LY; ++j) {
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i,j+1))&&(!CheckD(i+1,j))&&(!CheckD(i+2,j))&&(!CheckD(i+2,j-1))&&(CheckD(i+1,j-1));
if (!ok) continue;
if ((!CheckD(i-1,j))&&(!CheckD(i-1,j+1))) continue;
int cn = int(CheckD(i+1,j+1))+int(CheckD(i-1,j));
if (cn==2) Tsn=max(Tsn,Exist[3]);
if (cn==2&&fn>=LY-2) Tsc=max(Tsc,Exist[3]);
}
for (int j=1; j<=LY; ++j) {
if (bub) continue;
if (!G[i][j]) continue;
bool ok = (!CheckD(i,j))&&(!CheckD(i,j+1))&&(!CheckD(i,j+2))&&(!CheckD(i,j+3));
if (!ok) continue;
if ((!CheckD(i,j-1))||(!CheckD(i,j+4))) continue;
if ((!CheckD(i+1,j))&&(!CheckD(i+1,j+1))&&(!CheckD(i+1,j+2))&&(!CheckD(i+1,j+3))) continue;
if ((!CheckD(i-1,j))&&(!CheckD(i-1,j+1))&&(!CheckD(i-1,j+2))&&(!CheckD(i-1,j+3))) continue;
if ((CheckD(i+1,j))&&(CheckD(i+1,j+3))&&(CheckD(i-1,j))&&(CheckD(i-1,j+1))&&(CheckD(i-1,j+2))&&(CheckD(i-1,j+3))) continue;
int tot = ((CheckD(i-1,j))||(CheckD(i+1,j)))+((CheckD(i-1,j+1))||(CheckD(i+1,j+1)))+((CheckD(i-1,j+2))||(CheckD(i+1,j+2)))+((CheckD(i-1,j+3))||(CheckD(i+1,j+3)));
if (tot<4) continue;
Tsn=max(Tsn,Exist[1]);
if (fn>=LY-4) Tsc=max(Tsc,Exist[1]);
}
if ((Plr==5)&&(Tsn)&&(Height+8<DX)&&(SetSpin)) Eval+=((bubline>2)?0:2);
mTsn=max(mTsn,Tsn); mTsc=max(mTsc,Tsc);
Tsn=Tsc=0;
}
if ((Plr==5)&&(mTsn)&&(Height+8<DX)&&(SetSpin)) Eval+=10;
if ((Plr==5)&&(mTsc>=6)&&(Height+8<DX)) Eval+=10;
if ((Plr==6)&&(SetSpin)) {
for (int i=1; i<=LX; ++i) {
int tot = 0;
for (int j=2; j<LY; ++j) {
if (D[i][j]) ++tot;
}
if (tot==LY-2) Eval-=2;
}
}
bool Alt = ((Plr==2||Plr==3)&&(Height+8<DX));
int GarC = 0;
for (int i=1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if (B[i][j]>150) {
++GarC; break;
}
}
}
//if (GarC>5) Alt=false;
for (int i=pn+1; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) D[i][j]=0;
}
Eval += Ero*Lines-Land;
if (!SetSpin&&Plr==6) Eval-=NewHeight-Lines;
for (int i=1; i<=LY; ++i) D[0][i]=1;
for (int i=1; i<=LX; ++i) D[i][0]=D[i][LY+1]=1;
int Bubble=0, Float=0;
for (int i=2; i<=LX; ++i) {
for (int j=1; j<=LY; ++j) {
if ((D[i][j])&&(!D[i][j-1])&&(!G[i][j-1])) ++Bubble;
if ((D[i][j]==2)&&(!D[i][j-1]&&!D[i][j+1])&&(!D[i-1][j])) ++Float;
}
}
//if (Plr==5&&sU*sD*sL*sR&&(o.p==2||o.p==3)&&!SetSpin) Eval-=10*Float;
if ((Plr==3)&&(Height+12<DX)) Eval-=Bubble;
if ((Height+6<DX)&&((Lines)&&(Lines<4))&&(!sU*sD*sL*sR)&&(Combo<1)&&(Plr==4)&&(!ook)) Eval-=30;
if (((sU*sD*sL*sR)&&((Lines)||(!SetSpin)))||(Lines>=4)) Eval+=Ero*Lines*((Combo)?5:5),SpinScr+=((SetSpin)?100:50)*Lines;//5;
else if ((Mini)&&(Lines)) Eval+=Ero*Lines*0;
else if (((Plr==2)||(Plr==3)||(Plr==5)||(Plr==6))&&(Combo<=2||Plr==6)&&(Lines)) {
if (Combo<2||((Plr==6))) {
//if (Height+12<DX) Eval-=Ero*Lines/2;
//if (Plr==5) Bubble=false;
if (Height+12<DX) Eval-=Ero*Lines/((Bubble)?2:1);
}
}
if ((Height+12<DX)&&(Plr==6)&&(Combo<=3)&&(Lines)&&(Lines<4)&&(!(sU*sD*sL*sR))) Eval-=Ero*((SetSpin)?4:2);
if ((SetSpin)&&(Lines==1)&&(!(sU*sD*sL*sR))&&(Ero==1)&&((o.p==1)||(o.p==4)||(o.p==5)||(o.p==7))) Eval-=3;
pair<int,int> Act = make_pair(0,Lines);
if ((ModSpin==2)&&(Lines)&&(!Mini)&&(!(sU*sD*sL*sR))) Act.second=1;
if ((sU*sD*sL*sR)||(Mini)) Act.first=o.p;
if ((ModSpin)&&(Act!=make_pair(0,0))&&(Act==LstAct)) Eval=-99999999;
for (int i=1; i<=LY; ++i) D[0][i]=3;
int BRC = 2;//(GarC<2)?5:1;
if (Plr==5) BRC=(SetSpin)?0:0;
if (Bubble) BRC=1;
if (Bubble>1) BRC=0;
if (Plr==2) BRC=1;
int BRem=BRC, LstIso=0;
for (int i=LX; i; --i) {
D[i][0]=D[i][LY+1]=3;
int UseB=0, Tot=0; bool Iso=false; int Sep=0;
for (int j=1; j<=LY; ++j) {
if ((!D[i][j])&&(D[i+1][j])&&(!G[i][j])) BRem=0;
if (D[i][j]) ++Tot;
if ((!D[i][j])&&((j==1)||(D[i][j-1]))&&((j==LY)||(D[i][j+1]))) Iso=true;
if ((!D[i][j])&&((j==1)||(D[i][j-1]))) ++Sep;
}
if (Tot+2>LY) BRem=0;
for (int j=1; j<=LY; ++j) {
if ((!D[i][j])&&(D[i+1][j])) {
if ((G[i][j])&&(Alt)&&((i<2)||(D[i-1][j]))&&(BRem)) ++UseB;
Eval -= 4;
}
if (bool(D[i][j])!=bool(D[i-1][j])) --Eval;
if (bool(D[i][j])!=bool(D[i][j-1])) --Eval;
if ((!D[i][j])&&((D[i][j+1])&&(D[i][j-1]))) Eval-=1;
}
if ((Iso)&&(LstIso)&&(Alt)&&(Plr==3)) Eval-=((BRC)?3:1);
LstIso = Iso;
if (UseB==1) Eval+=12;
if (UseB>1) BRem=0;
if (!D[i][LY]) --Eval;
if (UseB) --BRem;
if ((Iso)||(Sep>1)) BRem=0;
if ((!UseB)&&(BRem<BRC)) BRem=0;
}
int gpos=0, ghei=0;
for (int i=1; i<=LX; ++i) {
int emp=0, bub=0;
for (int j=1; j<=LY; ++j) {
if (!D[i][j]) {
++emp; bub=j;
}
}
if (emp==1) {
gpos=bub; ghei=i;
}
else break;
}
if ((Plr)&&(gpos)) {
int he=LX; while ((he)&&(!D[he][gpos])) --he;
Eval -= min(0,he-ghei);
}
Eval *= 100;
Eval += SpinScr;//*85/100;
Eval += 10*abs(fy-Piece[Pid][0].FstY-o.y);
Eval += (fy-Piece[Pid][0].FstY>o.y);
if (Eval>MaxEval) {
MaxEval=Eval; rstr=mp[o]; best=o;
}
}
//printf("%d %d (%d)\n",_stas,_stas2,_stas2/max(1,_stas));
Oper.clear(); if (best.p!=Pid) Oper.push_back(KEY_HOLD);
for (char ch : rstr) Oper.push_back(ch);
if ((Oper.size())&&(double(rnd(1<<30)+1)/double(1<<30)<MdRate)) {
int type = rnd(3);
if (!type) {
deque<char> NwOper;
for(char c:Oper) if(rng()&1) NwOper.push_back(c);
Oper = NwOper;
}
else if (type==1) Oper.resize(rnd(Oper.size()));
else shuffle(Oper.begin(),Oper.end(),rng);
}
Oper.push_back(0);
DivOperTime = OperTime/Oper.size();
//printf("*%d %d %d %d\n",best.p,best.d,best.x,best.y);
}
vector<char> chs = GetKey(tm);
if ((Oper.size())&&(OperDis>=(((OperTime>=300)||(Arcade))?DivOperTime:OperTime))) {
while (Oper.size()) {
chs.push_back(Oper.front()); Oper.pop_front();
if ((OperTime>=300)||(Arcade)) break;
}
OperDis = 0;
/*bool tp = (Oper.front()==KEY_DOWN);
chs.push_back(Oper.front()); Oper.pop_front();
if (tp) {
while ((Oper.size())&&(Oper.front()==KEY_DOWN)) {
chs.push_back(Oper.front()); Oper.pop_front();
}
}*/
}
if (CheckActive()) {
bool ckd = CheckDown();
bool rsl=false, ru=false;
for (char ch : chs) {
if ((ch==KEY_LEFT)&&(AllowMove)) {
rsl|=MoveLeft();
if ((!ARR)&&(!Bot)&&(KeyDas[ch])) {
if (((!SDARR)&&(KeyDas[KEY_DOWN])&&(AllowSoft))||(!DropL)) {
bool ok = false;
while (MoveDown()) {
Score+=((!QuickPlay)&&(!Complete)); ok=true;
}
if ((ok)&&(ResetRem>0)) DropTime=0;
}
while (MoveLeft()) {
if (((!SDARR)&&(KeyDas[KEY_DOWN])&&(AllowSoft))||(!DropL)) {
bool ok = false;
while (MoveDown()) {
Score+=((!QuickPlay)&&(!Complete)); ok=true;
}
if ((ok)&&(ResetRem>0)) DropTime=0;
}
}
}
}
if ((ch==KEY_RIGHT)&&(AllowMove)) {
rsl|=MoveRight();
if ((!ARR)&&(!Bot)&&(KeyDas[ch])) {
if ((((!SDARR)&&(KeyDas[KEY_DOWN])&&(AllowSoft))||(!DropL))) {
bool ok = false;
while (MoveDown()) {
Score+=((!QuickPlay)&&(!Complete)); ok=true;
}
if ((ok)&&(ResetRem>0)) DropTime=0;
}
while (MoveRight()) {
if ((((!SDARR)&&(KeyDas[KEY_DOWN])&&(AllowSoft))||(!DropL))) {
bool ok = false;
while (MoveDown()) {
Score+=((!QuickPlay)&&(!Complete)); ok=true;
}
if ((ok)&&(ResetRem>0)) DropTime=0;
}
}
}
}
if ((ch==KEY_CW)&&(AllowRot)&&(Allow2Rot)) rsl|=Rotate((Dir+1)&3);
if ((ch==KEY_CCW)&&(AllowRot)&&(Allow2Rot)) rsl|=Rotate((Dir+3)&3);
if ((ch==KEY_180)&&(AllowRot)&&(AllowHalf)) rsl|=Rotate((Dir+2)&3);
if ((ch==KEY_FLIP)&&(Flip[Pid])&&(AllowFlip)) rsl|=Rotate((Dir+2)&3,Flip[Pid]);
if ((ch==KEY_WASTE)&&((Zen)||(WasteRem))) {
ForceWaste=true;
if ((!Zen)&&(WasteRem<99999999)) {
--WasteRem;
sprintf(buf, "%d", WasteRem);
double asz = sz*double(LY)*0.1;
TQu.push_back({sz*0.5*double(DX),sz*0.5*double(LY)-asz*0.7,asz,0.2,0.0006,buf,0xFFFFFF});
}
}
if ((ch==KEY_LOCK)&&(AllowLock)) Lock();
if ((ch==KEY_ROT)&&(AllowRot)) rsl|=Rotate((Dir+RotType)&3);
if ((ch==KEY_DOWN)&&(AllowSoft)) {
if ((KeyDas[KEY_DOWN])&&(!Bot)) {
if (ckd) {
if (SDARR) DropTime+=DropL*double(tm)/double(SDARR);
else {
bool ok = false;
while (CheckDown()) {
MoveDown(); Score+=((!QuickPlay)&&(!Complete)); ok=true;
}
if ((ok)&&(ResetRem>0)) DropTime=0;
}
}
}
else {
if (MoveDown()) {
Score+=((!QuickPlay)&&(!Complete));
if ((ResetRem>0)||(!ResetLim)) DropTime=0;
}
else if ((AllowDeep)&&(!Bot)) rsl|=DeepDrop();
}
}
if ((ch==KEY_UP)&&(AllowUp)) {
bool tmp = MoveUp();
rsl|=tmp; ru|=tmp;
}
if ((ch==KEY_SONIC)&&(AllowSonic)) {
while (CheckDown()) {
MoveDown(); Score+=((!QuickPlay)&&(!Complete));
}
if ((!ResetLim)||(ResetRem)) DropTime=0;
}
if (((ch==KEY_HARD)&&((Bot)||(AllowHard)))||(!ch)) {
if ((Bot)||(((!EV[2])||(!EV[6]))&&(!HcdLeft))) HardDrop();
}
if (ch==KEY_HOLD) {
if ((!HoldEnable)||(!HoldRule)) continue;
int pid = Pid;
if (Hold) {
if (Spawn(Hold,InitFacing)) {
Hold = pid;
if (HoldRule==1) HoldEnable=false;
DropTime=0; ResetRem=max(1,ResetLim);
}
}
else if (Next.size()>1) {
if (Spawn(Next.front(),InitFacing)) {
Hold=pid; Next.pop_front();
if (HoldRule==1) HoldEnable=false;
DropTime=0; ResetRem=max(1,ResetLim);
}
}
}
if ((ch==KEY_RESET)&&(HoldRule==2)) {
if (Spawn(Pid,InitFacing)) {
DropTime=0; ResetRem=max(1,ResetLim);
}
}
if (ch==KEY_EVEN) AtkType=1;
if (ch==KEY_KO) AtkType=2;
if (ch==KEY_RANDOM) AtkType=3;
if (ch==KEY_PAYBACK) AtkType=4;
if (ch==KEY_BADGE) AtkType=5;
if (ch==KEY_ATTACKERS) AtkType=6;
if ((ch==KEY_UNDO)&&(Zen)&&(!UndoCD)) Undo=true;
if (ch==KEY_RETRY) ForceAbort=true;
}
if ((CheckActive())&&(Bot)&&(!DropL)) {
while (MoveDown());
}
if ((CheckActive())&&(!Bot)) {
bool nckd = CheckDown();
if (((ckd)&&(nckd))&&(!ru)) rsl=false;
if ((DropTime)&&(rsl)&&(ResetRem>0)) {
if (ResetLim) DropTime=0;
if (!ResetDec) ResetRem=max(0,ResetRem-1);
}
if (ResetDec) ResetDec=false;
if (nckd) {
if (!DropL) {
bool ok = false;
while (CheckDown()) {
MoveDown(); ok=true; if (KeyDas[KEY_DOWN]) Score+=((!QuickPlay)&&(!Complete));
}
if (ResetRem>0) DropTime=0;
}
else if (DropTime>=DropL) {
while (DropTime>=DropL) {
if (!CheckDown()) {
if (ResetRem>0) DropTime=0;
break;
}
if (ResetRem>0) DropTime-=DropL;
if (MoveDown()) {
if (KeyDas[KEY_DOWN]) Score+=((!QuickPlay)&&(!Complete));
}
}
if (ResetRem>0) {
if (CheckDown()) DropTime%=DropL;
else DropTime=0;
}
}
}
else if ((DropTime>LockL)&&(!Bot)) Lock();
}
if (!CheckDown()) GTime=max(1,GTime);
if ((GTime>GLockL)||(FTime>FLockL)) HardDrop();
}
}
string KeyName(char ch) {
if ((ch>='a')&&(ch<='z')) return string("")+char(ch+'A'-'a');
if ((ch>='A')&&(ch<='Z')) return string("")+char(ch);
if (ch==VK_UP) return "Up";
if (ch==VK_DOWN) return "Down";
if (ch==VK_LEFT) return "Left";
if (ch==VK_RIGHT) return "Tight";
if (ch==VK_SHIFT) return "Shift";
if (ch==VK_SPACE) return "Space";
if (ch==VK_TAB) return "Tab";
if (ch==VK_RETURN) return "Enter";
if (ch==VK_CAPITAL) return "Caps";
if (ch==VK_CONTROL) return "Ctrl";
return "none";
}
vector<string> GetHint(string Command) {
if (Command=="") return {};
while ((Command.size())&&(Command.back())) Command.pop_back();
string cur=""; vector<string> Co;
for (char ch : Command) {
if (ch) cur.push_back(ch);
else {
Co.push_back(cur); cur="";
}
}
if (cur.size()) Co.push_back(cur);
int pp = 0;
for (int i=0; i<Co.size(); ++i) {
if ((Co[i]=="forall")||(Co[i]=="run")) pp=i+1;
}
if ((Co.size())&&(!pp)&&(Co[0]=="for")) {
return {"[X] e [x] - Select players satisfying their [X] equal to x",
"[X] ne [x] - Select players satisfying their [X] unequal to x",
"[X] g [x] - Select players satisfying their [X] greater than x",
"[X] l [x] - Select players satisfying their [X] less than x",
"[X] ge [x] - Select players satisfying their [X] not less than x",
"[X] le [x] - Select players satisfying their [X] not greater than x",
"pick [x] - Pick the first [x] players",
"sort [X] - Sort current list by ascending order of [X]",
"rsort [X] - Sort current list by descending order of [X]",
"shuffle - Random shuffle the current list"};
}
vector<string> ChangeList = {"complete - does goal completed",
"levelstart - start level calculated as max",
"levelbase - base level of level calculation",
"levelline - line cleared per level",
"leveltime - time per level",
"levelpiece - piece per level",
"levelattack - attack per level",
"increaseline - increasing line cleared required per level",
"increasetime - increasing time required per level",
"increasepiece - increasing piece required per level",
"increaseattack - increasing attack required per level",
"levelmaster - begin level of 20g",
"levelratio - difficulty scale of level",
"targetpiece - goal pieces",
"targettime - goal time",
"targetline - goal cleared lines",
"targetattack - goal attack points",
"targetscore - goal score",
"sumpiece - number of placed pieces",
"sumline - number of cleared lines",
"sumdig - number of cleared garbage lines",
"sumattack - number of total attack points",
"staticheight - height of auto filled garbage lines",
"startheight - height of starting garbage lines",
"usemove - allow moving",
"userotate - allow rotation",
"use2rotate - allow two direct rotation",
"usehalf - allow half rotation",
"usehard - allow hard drop",
"usesoft - allow soft drop",
"usesonic - allow sonic drop",
"useflip - allow flip operation",
"useup - allow moving up",
"uselock - allow lock in place",
"usedeep - allow deep drop",
"wastelimit - allow waste operations in one game",
"holdpiece - holding piece",
"pid - active piece",
"tar - target of attack",
"attacktype - targeting style",
"passthrough - passthrough delay",
"bot - does the player controlled by cpu",
"bottype - algorithm of cpu control",
"point - number of victory rounds",
"height - displaying height of board",
"realheight - real height of board",
"vanish - height of vanish zone",
"width - width of board",
"ko - knockouts",
"badge - badges from knockout",
"botspeed - the operating distance of cpu",
"over - does the game be over",
"next - next piece",
"history - predecessor remembered by piece generator",
"roll - roll tries of piece generator",
"extra - extra pieces in one bag",
"reset - lock delay reset limit",
"lock - lock delay",
"groundlock - force lock delay after on ground",
"forcelock - force lock delay",
"drop - time of drop per grid",
"openerphrase - length of opener bonus",
"garbagepreview - count of garbage previewed",
"garbagegap - limit of garbage entering at once",
"garbagedelay - delay of garbage being active",
"garbagerise - entering distance between garbage layers",
"initfacing - inital facing of piece",
"hold - hold rule",
"sequence - piece generation rule",
"das - delayed auto shift",
"arr - auto repeat rate",
"drd - drop delay",
"dropdas - soft drop delayed auto shift",
"droparr - soft drop auto repeat rate",
"dcd - auto shift cancel delay",
"hcd - hard drop cooldown",
"deathare - delay given to prevent top out",
"are - appearance delay",
"lcd - line clear delay",
"shadow - shadow piece",
"roundheight - height avoiding line clear",
"stock - extra lifes in one game",
"life - remaining extra lifes",
"mod2 - quick play mod : No Hold",
"mod3 - quick play mod : Messier Garbage",
"mod4 - quick play mod : Gravity",
"mod5 - quick play mod : Volatile Garbage",
"mod6 - quick play mod : Double Hold Garbage",
"mod7 - quick play mod : Invisible",
"mod8 - quick play mod : All-Spin",
"mod9 - quick play mod : Expert Mode"};
vector<string> tmp;
for (int i=pp; i<Co.size(); ++i) tmp.push_back(Co[i]);
Co = tmp;
if (!Co.size()) {
if (pp) {
return {
"launch - launch a certain game mode",
"quit - quit the current game",
"config - change configs used by players",
"keymap - change key bindings",
"finish - finish the current game",
"abort - abort the current game",
"setblock - change a block on a certain place",
"fill - fill blocks in a square area",
"garbage - push garbage lines",
"damage - send attack to selected player",
"waste - waste the current piece",
"lock - force the current piece to lock",
"set - change a certain value of the selected players",
"gamerule - change rules of the game",
"spectate - spectate a certain player"};
}
else {
return {"forall - run command to all players",
"for <condition> run - run command to players satisfying certain conditions",
"launch - launch a certain game mode",
"quit - quit the current game",
"config - change configs used by players",
"keymap - change key bindings",
"finish - finish the current game",
"abort - abort the current game",
"setblock - change a block on a certain place",
"fill - fill blocks in a square area",
"garbage - push garbage lines",
"damage - send attack to selected player",
"waste - waste the current piece",
"lock - force the current piece to lock",
"set - change a certain value of the selected players",
"gamerule - change rules of the game",
"spectate - spectate a certain player"};
}
}
if (Co.size()==1) Co.push_back(".");
if (Co[0]=="config") {
if (Co[1]=="style") return {"default","classic","arcade","simple"};
if (Co[1]=="defaultrotate") return {"ccw - counterclockwise",
"cw - clockwise"};
if ((Co[1]=="dropeffect")||(Co[1]=="rotateeffect")||(Co[1]=="moveeffect")||(Co[1]=="spineffect")) return {"true","false"};
return {"das - delayed auto shift",
"arr - auto repeat rate",
"dropdas - soft drop delayed auto shift",
"droparr - soft drop auto repeat rate",
"dcd - auto shift cancel delay",
"hcd - hard drop cooldown",
"defaultrotate - direction of default rotation",
"style - visual style",
"moveeffect - visual effect on stuck move and lock",
"spineffect - visual effect on spin",
"dropeffect - visual drop effect",
"rotateeffect - visual rotate effect"};
}
if (Co[0]=="keymap") {
if (Co[1]!=".") return {};
return {"left - move left",
"right - move right",
"down - soft drop",
"drop - hard drop",
"sonic - sonic drop",
"rotate - default rotate",
"cw - clockwise rotate",
"ccw - counterclockwise rotate",
"half - half rotate",
"hold - swap hold piece",
"undo - undo the last piece [zen exclusive]",
"retry - restart the game",
"reset - reset the piece to inital position [zen exclusive]",
"flip - flip the current piece",
"up - move up",
"waste - skip the current piece",
"even - set attack mode to Even",
"ko - set attack mode to KOs",
"random - set attack mode to Random",
"payback - set attack mode to Payback",
"badge - set attack mode to Badges",
"attacker - set attack mode to Attackers"};
}
vector<string> BlockList = {"0 - Empty"};
for (int i=1; i<155; ++i) {
if (CheckBlockType(i)) BlockList.push_back(IToS(i)+" - "+PName[i]);
}
if (Co[0]=="setblock") {
if (Co.size()>=3) return BlockList;
return {"setblock [x] [y] [val=154] [replace=-1]"};
}
if (Co[0]=="fill") {
if (Co.size()>=5) return BlockList;
return {"fill [beg x] [beg y] [end x] [end y] [val=154] [replace=-1]"};
}
if (Co[0]=="garbage") return {"garbage [count=1] [type=random]"};
if (Co[0]=="damage") return {"damage [count=1] [type=random]"};
if (Co[0]=="waste") return {"waste [count=1]"};
if (Co[0]=="set") return ChangeList;
if (Co[0]=="spectate") return {"spectate [player=current]"};
if (Co[0]=="gamerule") {
if (Co[1]=="spin") return {"allspin - pieces are equal and spins are divided to 3 levels",
"allfull - every immovable spin is counted as full",
"allsemi - spins without T-piece are counted as semi",
"allmini - spins without T-piece are counted as mini",
"minionly - all spins are regarded as mini",
"tspin - only T-spins are rewarded",
"default - spin rule similar to guildline",
"easy - spin rule of TGM3 easy mode",
"none - disable spin detection"};
if (Co[1]=="clutch") return {"default - enable clutch on line clears",
"always - always enable clutch",
"none - disable clutch"};
if (Co[1]=="baseattack") return {"default - guideline rule of normal clear attack",
"asc - attack rule of ascension and cultris",
"classic - attack rule of huopin",
"arcade - attack rule of TGM",
"equal - basic attack equals to lines cleared",
"none - disable normal clear attack"};
if (Co[1]=="cleargravity") return {"default - normal clear gravity",
"none - no clear gravity",
"cascade - every piece falls separately",
"sticky - every connected part falls separately",
"separate - every block above cleared lines falls separately"};
if (Co[1]=="b2b") return {"default - B2B rule of guildline",
"chain - continuous B2B is extra rewarded",
"surge - send surge attack while ending B2B chain",
"techmino - B2B is accumulated by percentage",
"none - disable B2B"};
if (Co[1]=="combo") return {"multipler - combo boost base attack by multipler with 2,3,4-wide weakened",
"io - combo boost base attack by multipler",
"default - combo table of guildline",
"firends - combo table of 4 friends",
"expert - combo table of 4 friends expert mode",
"battle - combo table of 4 battle",
"99 - combo table of 4 99",
"ppt - combo rule of puyo puyo T",
"effect - combo rule of T effect",
"zone - combo rule of T effect zone battle",
"techmino - a weakened multipler combo system",
"c2 - a series of line clears in a short time",
"aquamino - 2,3,4-wide weakened",
"none - disable combo bonus"};
if (Co[1]=="rotation") return {"default - rotate system based on srs+ with ospin and additional kicks",
"extend - rotate system with powerful half rotation kicks",
"srs - rotate system of guildline",
"srsplus - rotate system based on srs with basic half rotation kicks",
"asc - rotate system suitable for multiminos",
"ascplus - rotate system based on asc with maxium spin possibilities",
"ors - rotate system of original T",
"rnrs - rotate system of nes T",
"lnrs - rotate system of gameboy T",
"atari - rotate system of atari T",
"ars - rotate system of arcade",
"tetrax - tetra-x rotate system",
"c2 - rotate system of cultris",
"new - rotate system of the new T",
"none - same basic rotation as default but without kicks"};
if (Co[1]=="allclear") return {"extend - all clear give the same attack as width and half clear decrease garbage",
"default - all clear give the same attack as width",
"techmino - damage of all clear and half clear increase by 2 every time",
"quickplay - all clear give 3 attack and 2 B2B",
"league - all clear give 5 attack and 1 B2B",
"99 - all clear give 4 attack",
"arcade - all clear doubles the current attack",
"none - disable all clear"};
if (Co[1]=="garbagetype") return {"layer - garbage enter as fall garbage",
"bomb - garbage enter as bomb line",
"fall - garbage fall to the top of stack",
"solid - garbage line cannot be cleared"};
if (Co[1]=="garbagemode") return {"combo - garbage enter upon none clearing locks",
"attack - garbage enter upon none attack locks",
"lock - garbage enter upon lock",
"instant - garbage enter instantly"};
if (Co[1]=="garbagecancel") return {"default - attack points cancel pending garbage",
"none - no garbage canceling",
"dig - attack points dig garbage lines on board"};
if (Co[1]=="garbageshape") return {"cheese - garbage with 1 hole per line",
"full - full filled garbage",
"empty - empty garbage line",
"random - every position of garbage is random",
"bubble - garbage with 1 block per line",
"copy - copy the bottom line of receiver",
"clear - copy the shape of attacker\'s clear",
"arcade - copy the upside-down shape of attacker\'s clear",
"board - garbage with board and hole alternating"};
if (Co[1]=="garbagebonus") return {"default - advanced clear with garbage give 1 defence",
"io - advanced clear with garbage give 1 attack",
"none - no garbage clear bonus"};
if (Co[1]=="opener") return {"default - given the same defence as attack in opener phrase",
"io - cancel twice if many garbage in queue in opener phrase",
"none - disable opener phrase"};
if (Co[1]=="sequence") return {"random - each piece is generated separately",
"bag - pieces are generated by bag",
"fixed - pieces are generated in a sequence loop"};
if (Co[1]=="initfacing") return {"up","down","left","right"};
if (Co[1]=="hold") return {"none - disable hold",
"default - hold no more than one before lock",
"infinity - free hold and reset function enabled"};
if (Co[1]=="targetbonus") return {"default - reward attack when targeted by many players and using attackers targeting and defence otherwise",
"99 - reward attack when targeted by many players and using attackers targeting",
"defensive - reward defence when targeted by many players",
"none - no target bonus"};
if (Co[1]=="badgebonus") return {"default - reward attack from badges smoothly",
"99 - reward attack from badges like T 99",
"none - no badge bonus"};
if ((Co[1]=="arcaderound")||(Co[1]=="observebot")||(Co[1]=="shadow")||(Co[1]=="usemove")||(Co[1]=="userotate")||(Co[1]=="use2rotate")||(Co[1]=="usehalf")||(Co[1]=="usehard")||(Co[1]=="usesoft")||(Co[1]=="usesonic")||(Co[1]=="useflip")||(Co[1]=="useup")||(Co[1]=="uselock")||(Co[1]=="usedeep")) return {"false","true"};
if (Co[1]=="scaletype") return {"default - scale difficulty by marathon rule",
"div - scale difficulty by inverse proportion",
"dec - reduce delay by static value per level",
"exp - scale difficulty exponentially"};
if (Co[1]=="piece") return {""};
return {
"levelstart - start level calculated as max",
"levelbase - base level of level calculation",
"levelline - lines cleared per level",
"leveltime - time per level",
"levelpiece - piece per level",
"levelattack - attack per level",
"increaseline - increasing line cleared required per level",
"increasetime - increasing time required per level",
"increasepiece - increasing piece required per level",
"increaseattack - increasing attack required per level",
"levelmaster - begin level of 20g",
"levelratio - difficulty scale of level",
"scaletype - scale type of leveling",
"usemove - allow moving",
"userotate - allow rotation",
"use2rotate - allow two direct rotation",
"usehalf - allow half rotation",
"usehard - allow hard drop",
"usesoft - allow soft drop",
"usesonic - allow sonic drop",
"useflip - allow flip operation",
"useup - allow moving up",
"uselock - allow lock in place",
"usedeep - allow deep drop",
"wastelimit - allow waste operations in one game",
"spin - spin detecting rule",
"clutch - clutch rule",
"baseattack - basic attack rule",
"cleargravity - tule of block drop after clear",
"b2b - back to back rule",
"combo - combo rule",
"rotation - rotate system",
"allclear - all clear rule",
"garbageluck - clear easiness of garbage hole position",
"passthrough - passthrough delay",
"garbagetype - type of attack effect",
"garbagemode - garbage entering mode",
"garbagecancel - garbage cancel rule",
"garbageshape - position mode of garbage",
"garbagebonus - bonus of clearing garbage with advanced clear",
"opener - opener phrase rule",
"sequence - piece generation rule",
"initfacing - inital facing of piece",
"arcaderound - use round in arcade",
"observebot - observe cpu players battle after knockout",
"shadow - shadow piece",
"targetbonus - bonus when targeted by many players",
"badgebonus - attack bonus from badges",
"hold - hold rule",
"innermess - messiness inside a segment of attack",
"segmess - messiness between segments of attack",
"openerphrase - length of opener bonus",
"garbagepreview - count of garbage previewed",
"garbagegap - limit of garbage entering at once",
"garbagedelay - delay of garbage being active",
"garbagerise - entering distance between garbage layers",
"drop - time of drop per grid",
"lock - lock delay",
"groundlock - force lock delay after on ground",
"forcelock - force lock delay",
"reset - lock delay reset limit",
"deathare - delay given to prevent top out",
"are - appearance delay",
"lcd - line clear delay",
"drd - drop delay",
"next - next piece",
"history - predecessor remembered by piece generator",
"roll - roll tries of piece generator",
"extra - extra pieces in one bag",
"height - displaying height of board",
"realheight - real height of board",
"vanish - height of vanish zone"
"width - width of board",
"stock - extra lifes in one game",
"piece - the used piece in generation"};
}
return {};
}
bool Press = false;
string Str(int x) {
return string("")+char(x);
}
void PaintGlobal(int tm) {
ll curtm = clock();
while ((FP.size())&&(FP.front()+1000LL<=curtm)) FP.pop();
FP.push(curtm);
POINT p; GetCursorPos(&p);
ScreenToClient(GetForegroundWindow(), &p);
p.y-=96; p.x-=100;
p.y/=4.86/5.00; p.x/=4.98/5.00;
//Command="forall set botspeed 0";
vector<pair<string,string> > Option = {
{"General",""},{"Resume","forall"}, {"Retry","abort"},{"Kill","kill"},{"Quit","quit"},
{"Hold",""},{"Disable","gamerule hold none"}, {"Enable","gamerule hold default"}, {"Infinite","gamerule hold infinity"},{"",""},
{"Next","gamerule next ~"},{"Disable","gamerule next 0"},{"1","gamerule next 1"},{"3","gamerule next 3"},{"5","gamerule next 5"},
{"Rotation",""},{"Default","gamerule rotation default"},{"SRS","gamerule rotation srs"},{"SRS+","gamerule rotation srsplus"},{"Extend","gamerule rotation extend"},
{"",""},{"ASC+","gamerule rotation ascplus"},{"TETRA-X","gamerule rotation tetrax"},{"ORS","gamerule rotation ors"},{"ARS","gamerule rotation ars"},
{"",""},{"NES","gamerule rotation rnrs"},{"GB","gamerule rotation lnrs"},{"Cultris","gamerule rotation c2"},{"Atari","gamerule rotation atari"},
{"",""},{"ASC","gamerule rotation asc"},{"New","gamerule rotation new"},{"None","gamerule rotation none"},{"",""},
{"UseMove",""},{"On","gamerule usemove true"},{"Off","gamerule usemove false"},{"",""},{"",""},
{"UseRot",""},{"On","gamerule userotate true"},{"Off","gamerule userotate false"},{"",""},{"",""},
{"Use2Rot",""},{"On","gamerule use2rotate true"},{"Off","gamerule use2rotate false"},{"",""},{"",""},
{"UseHalf",""},{"On","gamerule usehalf true"},{"Off","gamerule usehalf false"},{"",""},{"",""},
{"UseHard",""},{"On","gamerule usehard true"},{"Off","gamerule usehard false"},{"",""},{"",""},
{"UseSoft",""},{"On","gamerule usesoft true"},{"Off","gamerule usesoft false"},{"",""},{"",""},
{"UseSonic",""},{"On","gamerule usesonic true"},{"Off","gamerule usesonic false"},{"",""},{"",""},
{"UseFlip",""},{"On","gamerule useflip true"},{"Off","gamerule useflip false"},{"",""},{"",""},
{"UseUp",""},{"On","gamerule useup true"},{"Off","gamerule useup false"},{"",""},{"",""},
{"UseLock",""},{"On","gamerule uselock true"},{"Off","gamerule uselock false"},{"",""},{"",""},
{"UseDeep",""},{"On","gamerule usedeep true"},{"Off","gamerule usedeep false"},{"",""},{"",""},
{"BaseAtk",""},{"Guildline","gamerule baseattack default"},{"ASC","gamerule baseattack asc"},{"Classic","gamerule baseattack classic"},{"Arcade","gamerule baseattack arcade"},
{"",""},{"Equal","gamerule baseattack equal"},{"Disable","gamerule baseattack none"},{"",""},{"",""},
{"Combo",""},{"Multipler","gamerule combo multipler"},{"IO","gamerule combo io"},{"Guildline","gamerule combo default"},{"99","gamerule combo 99"},
{"",""},{"PPT","gamerule combo ppt"},{"Effect","gamerule combo effect"},{"Zone","gamerule combo zone"},{"Cultris","gamerule combo c2"},
{"",""},{"Techmino","gamerule combo techmino"},{"Battle","gamerule combo battle"},{"Friends","gamerule combo friends"},{"Expert","gamerule combo expert"},
{"",""},{"Aquamino","gamerule combo aquamino"},{"Disable","gamerule combo none"},{"",""},{"",""},
{"B2B",""},{"Guildline","gamerule b2b default"},{"Chain","gamerule b2b chain"},{"Surge","gamerule b2b surge"},{"Techmino","gamerule b2b techmino"},
{"",""},{"Disable","gamerule b2b none"},{"",""},{"",""},{"",""},
{"Spin",""},{"All-Spin","gamerule spin allspin"},{"Guildline","gamerule spin default"},{"All-Full","gamerule spin allfull"},{"All-Semi","gamerule spin allsemi"},
{"",""},{"All-Mini","gamerule spin allmini"},{"T-Spin","gamerule spin tspin"},{"Easy","gamerule spin easy"},{"Mini-Only","gamerule spin minionly"},
{"",""},{"Disable","gamerule spin none"},{"",""},{"",""},{"",""},
{"PC",""},{"Extend","gamerule allclear extend"},{"Default","gamerule allclear default"},{"Techmino","gamerule allclear techmino"},{"IO","gamerule allclear league"},
{"",""},{"QP","gamerule allclear quickplay"},{"99","gamerule allclear 99"},{"Arcade","gamerule allclear arcade"},{"Disable","gamerule allclear none"},
{"DefRot",""},{"CCW","config defaultrotate ccw"},{"CW","config defaultrotate cw"},{"",""},{"",""},
{"DAS","config das ~"},{"0","config das 0"},{"0.05","config das 50"},{"0.06","config das 60"},{"0.08","config das 80"},
{"",""},{"0.1","config das 100"},{"0.12","config das 120"},{"0.167","config das 167"},{"0.2","config das 200"},
{"",""},{"0.25","config das 250"},{"0.3","config das 300"},{"0.5","config das 500"},{"1","config das 1000"},
{"ARR","config arr ~"},{"0","config arr 0"},{"0.01","config arr 10"},{"0.02","config arr 20"},{"0.033","config arr 33"},
{"",""},{"0.05","config arr 50"},{"0.1","config arr 100"},{"0.15","config arr 150"},{"0.2","config arr 200"},
{"SDDAS","config dropdas ~"},{"0","config dropdas 0"},{"0.05","config dropdas 50"},{"0.06","config dropdas 60"},{"0.08","config dropdas 80"},
{"",""},{"0.1","config dropdas 100"},{"0.12","config dropdas 120"},{"0.15","config dropdas 150"},{"0.2","config dropdas 200"},
{"",""},{"0.25","config dropdas 250"},{"0.3","config dropdas 300"},{"0.5","config dropdas 500"},{"1","config dropdas 1000"},
{"SDARR","config droparr ~"},{"0","config droparr 0"},{"0.01","config droparr 10"},{"0.02","config droparr 20"},{"0.05","config droparr 50"},
{"",""},{"0.075","config droparr 75"},{"0.1","config droparr 100"},{"0.15","config droparr 150"},{"0.2","config droparr 200"},
{"DCD","config dcd ~"},{"0","config dcd 0"},{"0.01","config dcd 10"},{"0.02","config dcd 20"},{"0.03","config dcd 30"},
{"",""},{"0.05","config dcd 50"},{"0.075","config dcd 75"},{"0.1","config dcd 100"},{"0.15","config dcd 150"},
{"",""},{"0.2","config dcd 200"},{"0.5","config dcd 500"},{"1","config dcd 1000"},{"Infinity","config dcd max"},
{"HCD","config hcd ~"},{"0","config hcd 0"},{"0.01","config hcd 10"},{"0.02","config hcd 20"},{"0.03","config hcd 30"},
{"",""},{"0.05","config hcd 50"},{"0.075","config hcd 75"},{"0.1","config hcd 100"},{"0.15","config hcd 150"},
{"",""},{"0.2","config hcd 200"},{"0.5","config hcd 500"},{"1","config hcd 1000"},{"Infinity","config hcd max"},
{"GarbType",""},{"Layer","gamerule garbagetype layer"},{"Bomb","gamerule garbagetype bomb"},{"Fall","gamerule garbagetype fall"},{"Solid","gamerule garbagetype solid"},
{"GarbMode",""},{"Combo","gamerule garbagemode combo"},{"Attack","gamerule garbagemode attack"},{"Lock","gamerule garbagemode lock"},{"Instant","gamerule garbagemode instant"},
{"GarbCnel",""},{"Default","gamerule garbagecancel default"},{"Dig","gamerule garbagecancel dig"},{"Disable","gamerule garbagecancel none"},{"",""},
{"GarbShape",""},{"Cheese","gamerule garbageshape cheese"},{"Full","gamerule garbageshape full"},{"Empty","gamerule garbageshape empty"},{"Random","gamerule garbageshape random"},
{"",""},{"Board","gamerule garbageshape board"},{"Bubble","gamerule garbageshape bubble"},{"Copy","gamerule garbageshape copy"},{"Clear","gamerule garbageshape clear"},
{"",""},{"Arcade","gamerule garbageshape arcade"},{"",""},{"",""},{"",""},
{"Opener",""},{"Default","gamerule opener default"},{"IO","gamerule opener io"},{"Disable","gamerule opener none"},{"",""},
{"OpenLen","gamerule openerphrase ~"},{"7","gamerule openerphrase 7"},{"14","gamerule openerphrase 14"},{"28","gamerule openerphrase 28"},{"50","gamerule openerphrase 50"},
{"DigBonus",""},{"Default","gamerule garbagebonus default"},{"IO","gamerule garbagebonus io"},{"Disable","gamerule garbagebonus none"},{"",""},
{"GarbDelay","gamerule garbagedelay ~"},{"0","gamerule garbagedelay 0"},{"0.1","gamerule garbagedelay 100"},{"0.25","gamerule garbagedelay 250"},{"0.5","gamerule garbagedelay 500"},
{"",""},{"1","gamerule garbagedelay 1000"},{"1.5","gamerule garbagedelay 1500"},{"2","gamerule garbagedelay 2000"},{"5","gamerule garbagedelay 5000"},
{"GarbRise","gamerule garbagerise ~"},{"0","gamerule garbagerise 0"},{"0.01","gamerule garbagerise 10"},{"0.02","gamerule garbagerise 20"},{"0.05","gamerule garbagerise 50"},
{"",""},{"0.75","gamerule garbagerise 75"},{"0.1","gamerule garbagerise 100"},{"0.2","gamerule garbagerise 200"},{"0.5","gamerule garbagerise 500"},
{"",""},{"1","gamerule garbagerise 1000"},{"2","gamerule garbagerise 2000"},{"5","gamerule garbagerise 5000"},{"10","gamerule garbagerise 10000"},
{"GarbPrev","gamerule garbagepreview ~"},{"Off","gamerule garbagepreview 0"},{"1","gamerule garbagepreview 1"},{"3","gamerule garbagepreview 3"},{"10","gamerule garbagepreview 10"},
{"GarbGap","gamerule garbagegap ~"},{"0","gamerule garbagegap 0"},{"1","gamerule garbagegap 1"},{"2","gamerule garbagegap 2"},{"4","gamerule garbagegap 4"},
{"",""},{"5","gamerule garbagegap 5"},{"8","gamerule garbagegap 8"},{"10","gamerule garbagegap 10"},{"Infinity","gamerule garbagegap max"},
{"InnerMess","gamerule innermess ~"},{"0","gamerule innermess 0"},{"0.01","gamerule innermess 1"},{"0.02","gamerule innermess 2"},{"0.05","gamerule innermess 5"},
{"",""},{"0.1","gamerule innermess 10"},{"0.15","gamerule innermess 15"},{"0.2","gamerule innermess 2"},{"0.25","gamerule innermess 25"},
{"",""},{"0.3","gamerule innermess 30"},{"0.5","gamerule innermess 50"},{"0.75","gamerule innermess 75"},{"1","gamerule innermess 100"},
{"SegMess","gamerule segmess ~"},{"0","gamerule segmess 0"},{"0.01","gamerule segmess 1"},{"0.02","gamerule segmess 2"},{"0.05","gamerule segmess 5"},
{"",""},{"0.1","gamerule segmess 10"},{"0.15","gamerule segmess 15"},{"0.2","gamerule segmess 2"},{"0.25","gamerule segmess 25"},
{"",""},{"0.3","gamerule segmess 30"},{"0.5","gamerule segmess 50"},{"0.75","gamerule segmess 75"},{"1","gamerule segmess 100"},
{"GarbPass","gamerule passthrough ~"},{"0","gamerule passthrough 0"},{"0.001","gamerule passthrough 1"},{"0.05","gamerule passthrough 50"},{"0.1","gamerule passthrough 100"},
{"",""},{"0.2","gamerule passthrough 200"},{"0.333","gamerule passthrough 333"},{"0.5","gamerule passthrough 500"},{"1","gamerule passthrough 1000"},
{"",""},{"1.25","gamerule passthrough 1250"},{"1.5","gamerule passthrough 1500"},{"2","gamerule passthrough 2000"},{"Infinity","gamerule passthrough max"},
{"GarbLuck","gamerule garbageluck ~"},{"-100","gamerule garbageluck 0"},{"-75","gamerule garbageluck 25"},{"-50","gamerule garbageluck 50"},{"-30","gamerule garbageluck 70"},
{"",""},{"-25","gamerule garbageluck 75"},{"-20","gamerule garbageluck 80"},{"-15","gamerule garbageluck 85"},{"-10","gamerule garbageluck 90"},
{"",""},{"-5","gamerule garbageluck 95"},{"0","gamerule garbageluck 100"},{"+5","gamerule garbageluck 105"},{"+10","gamerule garbageluck 110"},
{"",""},{"+15","gamerule garbageluck 115"},{"+20","gamerule garbageluck 120"},{"+25","gamerule garbageluck 125"},{"+30","gamerule garbageluck 130"},
{"",""},{"+50","gamerule garbageluck 150"},{"+75","gamerule garbageluck 175"},{"+100","gamerule garbageluck 200"},{"+1000","gamerule garbageluck 1100"},
{"ClearGrav",""},{"Default","gamerule cleargravity default"},{"None","gamerule cleargravity none"},{"Sticky","gamerule cleargravity sticky"},{"Cascade","gamerule cleargravity cascade"},
{"",""},{"Separate","gamerule cleargravity separate"},{"",""},{"",""},{"",""},
{"Clutch",""},{"Default","gamerule clutch default"},{"Always","gamerule clutch always"},{"Disable","gamerule clutch none"},{"",""},
{"Piece","gamerule piece ~"},{"M1","gamerule piece a"},{"M2","gamerule piece b"},{"M3","gamerule piece cd"},{"M4","gamerule piece ijlostz"},
{"",""},{"M5","gamerule piece efhi5j5l5npqrs5t5uvwxyz5"},{"M6","gamerule piece k30k31k32k33k34k35k36k37k38k39k40k41k42k43k44k45k46k47k48k49k50k51k52k53k54k55k56k57k58k59k60k61k62k63k64k65k66k67k68k69k70k71k72k73k74k75k76k77k78k79k80k81k82k83k84k85k86k87k88k89"},{"M123","gamerule piece abcd"},{"M1234","gamerule piece abcdijlostz"},
{"",""},{"M12345","gamerule piece abcdefhijlnopqrstuvwxyzi5j5l5s5t5z5"},{"M45","gamerule piece ijlostzefhi5j5l5npqrs5t5uvwxyz5"},{"M123456","gamerule piece abcdefhijlnopqrstuvwxyzi5j5l5s5t5z5k30k31k32k33k34k35k36k37k38k39k40k41k42k43k44k45k46k47k48k49k50k51k52k53k54k55k56k57k58k59k60k61k62k63k64k65k66k67k68k69k70k71k72k73k74k75k76k77k78k79k80k81k82k83k84k85k86k87k88k89"},{"Mixed","ciallo"},
{"",""},{"14-Bag","gamerule piece iijjlloossttzz"},{"Drought","gamerule piece jlostz"},{"Kid\'s","gamerule piece ijlot"},{"Heaven","gamerule piece i"},
{"",""},{"M4-","gamerule piece ijost"},{"M5-","gamerule piece ehi5j5prs5t5uvwx"},{"M6-","gamerule piece k30k31k32k33k34k35k36k37k38k39k40k42k44k46k48k50k52k54k56k58k60k62k64k66k68k70k72k74k76k78k80k82k84k86k88"},{"M45-","gamerule piece ijostehi5j5prs5t5uvwx"},
{"",""},{"M12345-","gamerule piece abcijostehi5j5prs5t5uvwx"},{"M123456-","gamerule piece abcijostehi5j5prs5t5uvwxk30k31k32k33k34k35k36k37k38k39k40k42k44k46k48k50k52k54k56k58k60k62k64k66k68k70k72k74k76k78k80k82k84k86k88"},{"",""},{"",""},
{"Sequence",""},{"Bag","gamerule sequence bag"},{"Random","gamerule sequence random"},{"Fixed","gamerule sequence fixed"},{"",""},
{"SeqHis","gamerule history ~"},{"0","gamerule history 0"},{"1","gamerule history 1"},{"2","gamerule history 2"},{"4","gamerule history 4"},
{"SeqRoll","gamerule roll ~"},{"1","gamerule roll 1"},{"2","gamerule roll 2"},{"4","gamerule roll 4"},{"6","gamerule roll 6"},
{"BagExtra","gamerule extra ~"},{"0","gamerule extra 0"},{"1","gamerule extra 1"},{"2","gamerule extra 2"},{"3","gamerule extra 3"},
{"InitDir",""},{"Up","gamerule initfacing up"},{"Down","gamerule initfacing down"},{"Left","gamerule initfacing left"},{"Right","gamerule initfacing right"},
{"Shadow",""},{"On","gamerule shadow true"},{"Off","gamerule shadow false"},{"",""},{"",""},
{"ObsBot",""},{"On","gamerule observebot true"},{"Off","gamerule observebot false"},{"",""},{"",""},
{"TarBonus",""},{"Default","gamerule targetbonus default"},{"99","gamerule targetbonus 99"},{"Defense","gamerule targetbonus defensive"},{"Disable","gamerule targetbonus none"},
{"BdgBonus",""},{"Default","gamerule badgebonus default"},{"99","gamerule badgebonus 99"},{"Disable","gamerule badgebonus none"},{"",""},
{"StartH","set startheight ~"},{"Off","set startheight 0"},{"1","set startheight 1"},{"2","set startheight 2"},{"3","set startheight 3"},
{"",""},{"4","set startheight 4"},{"10","set startheight 10"},{"15","set startheight 15"},{"20","set startheight 20"},
{"StaticH","set staticheight ~"},{"Off","set staticheight 0"},{"1","set staticheight 1"},{"2","set staticheight 2"},{"3","set staticheight 3"},
{"",""},{"4","set staticheight 4"},{"10","set staticheight 10"},{"20","set staticheight 20"},{"Infinity","set staticheight max"},
{"Width","gamerule width ~"},{"4","gamerule width 4"},{"5","gamerule width 5"},{"8","gamerule width 8"},{"10","gamerule width 10"},
{"",""},{"12","gamerule width 12"},{"15","gamerule width 15"},{"20","gamerule width 20"},{"50","gamerule width 50"},
{"Height","gamerule height ~"},{"0","gamerule height 2"},{"2","gamerule height 4"},{"5","gamerule height 7"},{"10","gamerule height 12"},
{"",""},{"15","gamerule height 17"},{"20","gamerule height 22"},{"40","gamerule height 42"},{"88","gamerule height 90"},
{"BufHeight","gamerule realheight ~"},{"4","gamerule realheight 4"},{"22","gamerule realheight 22"},{"40","gamerule realheight 40"},{"90","gamerule realheight 90"},
{"WasteLim","gamerule wastelimit ~"},{"0","gamerule wastelimit 0"},{"10","gamerule wastelimit 10"},{"25","gamerule wastelimit 25"},{"Infinity","gamerule wastelimit max"},
{"Reset","gamerule reset ~"},{"0","gamerule reset 0"},{"1","gamerule reset 1"},{"2","gamerule reset 2"},{"5","gamerule reset 5"},
{"",""},{"10","gamerule reset 10"},{"15","gamerule reset 15"},{"30","gamerule reset 30"},{"Infinity","gamerule reset max"},
{"Drop","gamerule drop ~"},{"0","gamerule drop 0"},{"0.01","gamerule drop 10"},{"0.02","gamerule drop 20"},{"0.05","gamerule drop 50"},
{"",""},{"0.1","gamerule drop 100"},{"0.2","gamerule drop 200"},{"0.25","gamerule drop 250"},{"0.5","gamerule drop 500"},
{"",""},{"0.75","gamerule drop 750"},{"0.8","gamerule drop 800"},{"1","gamerule drop 1000"},{"2","gamerule drop 2000"},
{"",""},{"2.5","gamerule drop 2500"},{"3","gamerule drop 3000"},{"5","gamerule drop 5000"},{"Infinity","gamerule drop max"},
{"Lock","gamerule lock ~"},{"0","gamerule lock 0"},{"0.1","gamerule lock 100"},{"0.2","gamerule lock 200"},{"0.25","gamerule lock 250"},
{"",""},{"0.3","gamerule lock 300"},{"0.5","gamerule lock 500"},{"1","gamerule lock 1000"},{"1.5","gamerule lock 1500"},
{"",""},{"2","gamerule lock 2000"},{"3","gamerule lock 3000"},{"5","gamerule lock 5000"},{"Infinity","gamerule lock max"},
{"GndLock","gamerule groundlock ~"},{"0","gamerule groundlock 0"},{"0.2","gamerule groundlock 200"},{"0.25","gamerule groundlock 250"},{"0.5","gamerule groundlock 500"},
{"",""},{"0.75","gamerule groundlock 750"},{"1","gamerule groundlock 1000"},{"1.5","gamerule groundlock 1500"},{"2","gamerule groundlock 2000"},
{"",""},{"3","gamerule groundlock 3000"},{"5","gamerule groundlock 5000"},{"10","gamerule groundlock 10000"},{"Infinity","gamerule groundlock max"},
{"FceLock","gamerule forcelock ~"},{"0.2","gamerule forcelock 200"},{"0.25","gamerule forcelock 250"},{"0.5","gamerule forcelock 500"},{"0.75","gamerule forcelock 750"},
{"",""},{"1","gamerule forcelock 1000"},{"1.5","gamerule forcelock 1500"},{"2","gamerule forcelock 2000"},{"3","gamerule forcelock 3000"},
{"",""},{"5","gamerule forcelock 5000"},{"10","gamerule forcelock 10000"},{"20","gamerule forcelock 20000"},{"Infinity","gamerule forcelock max"},
{"ARE","gamerule are ~"},{"0","gamerule are 0"},{"0.05","gamerule are 50"},{"0.1","gamerule are 100"},{"0.2","gamerule are 200"},
{"",""},{"0.25","gamerule are 250"},{"0.5","gamerule are 500"},{"1","gamerule are 1000"},{"2","gamerule are 2000"},
{"LCD","gamerule lcd ~"},{"0","gamerule lcd 0"},{"0.05","gamerule lcd 50"},{"0.1","gamerule lcd 100"},{"0.2","gamerule lcd 200"},
{"",""},{"0.25","gamerule lcd 250"},{"0.5","gamerule lcd 500"},{"1","gamerule lcd 1000"},{"2","gamerule lcd 2000"},
{"DRD","gamerule drd ~"},{"0","gamerule drd 0"},{"0.05","gamerule drd 50"},{"0.1","gamerule drd 100"},{"0.15","gamerule drd 150"},
{"",""},{"0.2","gamerule drd 200"},{"0.25","gamerule drd 250"},{"0.3","gamerule drd 300"},{"0.5","gamerule drd 500"},
{"",""},{"0.75","gamerule drd 750"},{"1","gamerule drd 1000"},{"1.5","gamerule drd 1500"},{"Infinity","gamerule drd max"},
{"DeathARE","gamerule deathare ~"},{"0","gamerule deathare 0"},{"0.05","gamerule deathare 50"},{"0.1","gamerule deathare 100"},{"0.2","gamerule deathare 200"},
{"",""},{"0.25","gamerule deathare 250"},{"0.5","gamerule deathare 500"},{"1","gamerule deathare 1000"},{"2","gamerule deathare 2000"},
{"Lifes","gamerule stock ~"},{"1","gamerule stock 0"},{"2","gamerule stock 1"},{"3","gamerule stock 2"},{"5","gamerule stock 4"},
{"",""},{"8","gamerule stock 7"},{"10","gamerule stock 9"},{"20","gamerule stock 19"},{"Infinity","gamerule stock max"},
{"Bot",""},{"Human","set bot 0"},{"Bot","set bot 1"},{"AllHuman","forall set bot 0"},{"AllBot","forall set bot 1"},
{"BotType",""},{"0","set bottype 0"},{"1","set bottype 1"},{"2","set bottype 2"},{"3","set bottype 3"},
{"",""},{"4","set bottype 4"},{"5","set bottype 5"},{"6","set bottype 6"},{"",""},
{"AllType",""},{"0","forall set bottype 0"},{"1","forall set bottype 1"},{"2","forall set bottype 2"},{"3","forall set bottype 3"},
{"",""},{"4","forall set bottype 4"},{"5","forall set bottype 5"},{"6","forall set bottype 6"},{"",""},
{"BotSpeed","set botspeed ~"},{"0","set botspeed 0"},{"5","set botspeed 5"},{"10","set botspeed 10"},{"20","set botspeed 20"},
{"",""},{"50","set botspeed 50"},{"100","set botspeed 100"},{"200","set botspeed 200"},{"300","set botspeed 300"},
{"",""},{"500","set botspeed 500"},{"750","set botspeed 750"},{"1000","set botspeed 1000"},{"1500","set botspeed 1500"},
{"AllSpeed","forall set botspeed ~"},{"0","forall set botspeed 0"},{"5","forall set botspeed 5"},{"10","forall set botspeed 10"},{"20","forall set botspeed 20"},
{"",""},{"50","forall set botspeed 50"},{"100","forall set botspeed 100"},{"200","forall set botspeed 200"},{"300","forall set botspeed 300"},
{"",""},{"500","forall set botspeed 500"},{"750","forall set botspeed 750"},{"1000","forall set botspeed 1000"},{"1500","forall set botspeed 1500"},
{"QPModOff",""},{"-Hold","set mod2 0"},{"-Messier","set mod3 0"},{"-Gravity","set mod4 0"},{"-Strength","set mod5 0"},
{"",""},{"-Holes","set mod6 0"},{"-Invis","set mod7 0"},{"-AllSpin","set mod8 0"},{"-Expert","set mod9 0"},
{"QPModOn",""},{"Hold","set mod2 1"},{"Messier","set mod3 1"},{"Gravity","set mod4 1"},{"Strength","set mod5 1"},
{"",""},{"Holes","set mod6 1"},{"Invis","set mod7 1"},{"AllSpin","set mod8 1"},{"Expert","set mod9 1"},
{"QPModRev",""},{"+Hold","set mod2 2"},{"+Messier","set mod3 2"},{"+Gravity","set mod4 2"},{"+Strength","set mod5 2"},
{"",""},{"+Holes","set mod6 2"},{"+Invis","set mod7 2"},{"+AllSpin","set mod8 2"},{"+Expert","set mod9 2"},
{"Operate",""},{"1Garb","garbage 1"},{"2Garb","garbage 2"},{"4Garb","garbage 4"},{"10Garb","garbage 10"},
{"",""},{"1Damage","damage 1"},{"2Damage","damage 2"},{"4Damage","damage 4"},{"10Damage","damage 10"},
{"",""},{"Clear","fill 1 1 99 99 0"},{"FillAll","fill 1 1 99 99"},{"Lock","lock"},{"Waste","waste"},
{"GoalLine","set targetline ~"},{"Off","set targetline 0"},{"10","set targetline 10"},{"20","set targetline 20"},{"40","set targetline 40"},
{"",""},{"100","set targetline 100"},{"200","set targetline 200"},{"500","set targetline 500"},{"1000","set targetline 1000"},
{"GoalPiece","set targetpiece ~"},{"Off","set targetpiece 0"},{"25","set targetpiece 25"},{"50","set targetpiece 50"},{"100","set targetpiece 100"},
{"",""},{"250","set targetpiece 250"},{"500","set targetpiece 500"},{"1000","set targetpiece 1000"},{"2000","set targetpiece 2000"},
{"GoalAtk","set targetattack ~"},{"Off","set targetattack 0"},{"10","set targetattack 10"},{"20","set targetattack 20"},{"40","set targetattack 40"},
{"",""},{"100","set targetattack 100"},{"200","set targetattack 200"},{"500","set targetattack 500"},{"1000","set targetattack 1000"},
{"GoalScore","set targetscore ~"},{"Off","set targetscore 0"},{"1000","set targetscore 1000"},{"5000","set targetscore 5000"},{"10000","set targetscore 10000"},
{"",""},{"50000","set targetscore 50000"},{"100000","set targetscore 100000"},{"500000","set targetscore 500000"},{"1000000","set targetscore 1000000"},
{"TimeLim","set targettime ~"},{"Off","set targettime 0"},{"10","set targettime 10000"},{"30","set targettime 30000"},{"60","set targettime 60000"},
{"",""},{"120","set targettime 120000"},{"180","set targettime 180000"},{"300","set targettime 300000"},{"600","set targettime 600000"},
{"BaseLev","gamerule levelbase ~"},{"0","gamerule levelbase 0"},{"2","gamerule levelbase 2"},{"5","gamerule levelbase 5"},{"10","gamerule levelbase 10"},
{"",""},{"15","gamerule levelbase 15"},{"18","gamerule levelbase 18"},{"20","gamerule levelbase 20"},{"30","gamerule levelbase 30"},
{"StartLev","gamerule levelstart ~"},{"0","gamerule levelstart 0"},{"2","gamerule levelstart 2"},{"5","gamerule levelstart 5"},{"10","gamerule levelstart 10"},
{"",""},{"15","gamerule levelstart 15"},{"18","gamerule levelstart 18"},{"20","gamerule levelstart 20"},{"30","gamerule levelstart 30"},
{"LevLine","gamerule levelline ~"},{"None","gamerule levelline 0"},{"5","gamerule levelline 5"},{"10","gamerule levelline 10"},{"20","gamerule levelline 20"},
{"IncLine","gamerule increaseline ~"},{"0","gamerule increaseline 0"},{"1","gamerule increaseline 1"},{"5","gamerule increaseline 5"},{"10","gamerule increaseline 10"},
{"LevPiece","gamerule levelpiece ~"},{"None","gamerule levelpiece 0"},{"25","gamerule levelpiece 25"},{"50","gamerule levelpiece 50"},{"100","gamerule levelpiece 100"},
{"IncPiece","gamerule increasepiece ~"},{"0","gamerule increasepiece 0"},{"5","gamerule increasepiece 5"},{"10","gamerule increasepiece 10"},{"25","gamerule increasepiece 25"},
{"LevTime","gamerule leveltime ~"},{"None","gamerule leveltime 0"},{"30","gamerule leveltime 30"},{"60","gamerule leveltime 60"},{"120","gamerule leveltime 120"},
{"IncTime","gamerule increasetime ~"},{"0","gamerule increasetime 0"},{"5","gamerule increasetime 5"},{"10","gamerule increasetime 10"},{"30","gamerule increasetime 30"},
{"LevAtk","gamerule levelattack ~"},{"None","gamerule levelattack 0"},{"10","gamerule levelattack 5"},{"25","gamerule levelattack 25"},{"50","gamerule levelattack 50"},
{"IncAtk","gamerule increaseattack ~"},{"0","gamerule increaseattack 0"},{"1","gamerule increaseattack 1"},{"5","gamerule increaseattack 5"},{"10","gamerule increaseattack 10"},
{"20GLev","gamerule levelmaster ~"},{"1","gamerule levelmaster 1"},{"5","gamerule levelmaster 5"},{"10","gamerule levelmaster 10"},{"15","gamerule levelmaster 15"},
{"",""},{"18","gamerule levelmaster 18"},{"20","gamerule levelmaster 20"},{"30","gamerule levelmaster 30"},{"None","gamerule levelmaster max"},
{"LevScale","gamerule levelratio ~"},{"0","gamerule levelratio 0"},{"0.001","gamerule levelratio 1"},{"0.002","gamerule levelratio 2"},{"0.005","gamerule levelratio 5"},
{"",""},{"0.007","gamerule levelratio 7"},{"0.01","gamerule levelratio 10"},{"0.02","gamerule levelratio 20"},{"0.05","gamerule levelratio 50"},
{"",""},{"0.075","gamerule levelratio 75"},{"0.1","gamerule levelratio 100"},{"0.2","gamerule levelratio 200"},{"0.25","gamerule levelratio 250"},
{"",""},{"0.3","gamerule levelratio 300"},{"0.5","gamerule levelratio 500"},{"0.75","gamerule levelratio 750"},{"1","gamerule levelratio 1000"},
{"LevType",""},{"Default","gamerule scaletype default"},{"Div","gamerule scaletype div"},{"Dec","gamerule scaletype dec"},{"Exp","gamerule scaletype exp"},
{"Style",""},{"Default","config style default"},{"Classic","config style classic"},{"Arcade","config style arcade"},{"Simple","config style simple"},
{"KeyMap",""},{"Left","keymap left ~"},{"Right","keymap right ~"},{"SoftDrop","keymap down ~"},{"HardDrop","keymap drop ~"},
{"",""},{"Rotate","keymap rotate ~"},{"CW","keymap cw ~"},{"CCW","keymap ccw ~"},{"Half","keymap half ~"},
{"",""},{"Hold","keymap hold ~"},{"Retry","keymap retry ~"},{"Reset","keymap reset ~"},{"Sonic","keymap sonic ~"},
{"",""},{"Undo","keymap undo ~"},{"Flip","keymap flip ~"},{"Up","keymap up ~"},{"Waste","keymap waste ~"},
{"",""},{"Lock","keymap lock ~"},{"Even","keymap even ~"},{"KO\'s","keymap ko ~"},{"Random","keymap random ~"},
{"",""},{"Payback","keymap payback ~"},{"Badge","keymap badge ~"},{"Attacker","keymap attacker ~"},{"",""},
{"MoveEff",""},{"On","config moveeffect true"},{"Off","config moveeffect false"},{"",""},{"",""},
{"SpinEff",""},{"On","config spineffect true"},{"Off","config spineffect false"},{"",""},{"",""},
{"DropEff",""},{"On","config dropeffect true"},{"Off","config dropeffect false"},{"",""},{"",""},
{"RotEff",""},{"On","config rotateeffect true"},{"Off","config rotateeffect false"},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
};
if (Command!="") Option.clear();
if ((Plrs)&&(!Con)) Option={{"Pause","~"},{"",""},{"",""},{"",""},{"",""},
{"Retry","abort"},{"",""},{"",""},{"",""},{"",""},
{"Quit","quit"}};
if ((!Plrs)&&(Command=="")) Option= {
{"DefRot",""},{"CCW","config defaultrotate ccw"},{"CW","config defaultrotate cw"},{"",""},{"",""},
{"DAS","config das ~"},{"0","config das 0"},{"0.05","config das 50"},{"0.06","config das 60"},{"0.08","config das 80"},
{"",""},{"0.1","config das 100"},{"0.12","config das 120"},{"0.167","config das 167"},{"0.2","config das 200"},
{"",""},{"0.25","config das 250"},{"0.3","config das 300"},{"0.5","config das 500"},{"1","config das 1000"},
{"ARR","config arr ~"},{"0","config arr 0"},{"0.01","config arr 10"},{"0.02","config arr 20"},{"0.033","config arr 33"},
{"",""},{"0.05","config arr 50"},{"0.1","config arr 100"},{"0.15","config arr 150"},{"0.2","config arr 200"},
{"SDDAS","config dropdas ~"},{"0","config dropdas 0"},{"0.05","config dropdas 50"},{"0.06","config dropdas 60"},{"0.08","config dropdas 80"},
{"",""},{"0.1","config dropdas 100"},{"0.12","config dropdas 120"},{"0.15","config dropdas 150"},{"0.2","config dropdas 200"},
{"",""},{"0.25","config dropdas 250"},{"0.3","config dropdas 300"},{"0.5","config dropdas 500"},{"1","config dropdas 1000"},
{"SDARR","config droparr ~"},{"0","config droparr 0"},{"0.01","config droparr 10"},{"0.02","config droparr 20"},{"0.05","config droparr 50"},
{"",""},{"0.075","config droparr 75"},{"0.1","config droparr 100"},{"0.15","config droparr 150"},{"0.2","config droparr 200"},
{"DCD","config dcd ~"},{"0","config dcd 0"},{"0.01","config dcd 10"},{"0.02","config dcd 20"},{"0.03","config dcd 30"},
{"",""},{"0.05","config dcd 50"},{"0.075","config dcd 75"},{"0.1","config dcd 100"},{"0.15","config dcd 150"},
{"",""},{"0.2","config dcd 200"},{"0.5","config dcd 500"},{"1","config dcd 1000"},{"Infinity","config dcd max"},
{"HCD","config hcd ~"},{"0","config hcd 0"},{"0.01","config hcd 10"},{"0.02","config hcd 20"},{"0.03","config hcd 30"},
{"",""},{"0.05","config hcd 50"},{"0.075","config hcd 75"},{"0.1","config hcd 100"},{"0.15","config hcd 150"},
{"",""},{"0.2","config hcd 200"},{"0.5","config hcd 500"},{"1","config hcd 1000"},{"Infinity","config hcd max"},
{"Style",""},{"Default","config style default"},{"Classic","config style classic"},{"Arcade","config style arcade"},{"Simple","config style simple"},
{"KeyMap",""},{"Left","keymap left ~"},{"Right","keymap right ~"},{"SoftDrop","keymap down ~"},{"HardDrop","keymap drop ~"},
{"",""},{"Rotate","keymap rotate ~"},{"CW","keymap cw ~"},{"CCW","keymap ccw ~"},{"Half","keymap half ~"},
{"",""},{"Hold","keymap hold ~"},{"Retry","keymap retry ~"},{"Reset","keymap reset ~"},{"Sonic","keymap sonic ~"},
{"",""},{"Undo","keymap undo ~"},{"Flip","keymap flip ~"},{"Up","keymap up ~"},{"Waste","keymap waste ~"},
{"",""},{"Lock","keymap lock ~"},{"Even","keymap even ~"},{"KO\'s","keymap ko ~"},{"Random","keymap random ~"},
{"",""},{"Payback","keymap payback ~"},{"Badge","keymap badge ~"},{"Attacker","keymap attacker ~"},{"",""},
{"MoveEff",""},{"On","config moveeffect true"},{"Off","config moveeffect false"},{"",""},{"",""},
{"SpinEff",""},{"On","config spineffect true"},{"Off","config spineffect false"},{"",""},{"",""},
{"DropEff",""},{"On","config dropeffect true"},{"Off","config dropeffect false"},{"",""},{"",""},
{"RotEff",""},{"On","config rotateeffect true"},{"Off","config rotateeffect false"},{"",""},{"",""},
{"1P",""},{"Normal","launch x"},{"Marathon","launch marathon"},{"Sprint","launch sprint"},{"Ultra","launch ultra"},
{"",""},{"Zenith","launch zenith"},{"Zen","launch zen"},{"Classic","launch classic"},{"Arcade","launch arcade"},
{"",""},{"Dig","launch dig"},{"4-Wide","launch x 4w"},{"M5","launch x m5"},{"M5-","launch x 13w 26h mm5 flip"},
{"",""},{"M123","launch x m123"},{"M12345","launch x m12345"},{"M12345-","launch x mm12345 13w 25h flip"},{"M123456-","launch x mm123456 15w 30h flip"},
{"Marathon",""},{"Lv. 5","launch marathon lv5"},{"Lv. 10","launch marathon lv10"},{"Lv. 15","launch marathon lv15"},{"Lv. 20","launch marathon lv20"},
{"Sprint",""},{"10L","launch sprint 10l"},{"20L","launch sprint 20l"},{"40L","launch sprint 40l"},{"100L","launch sprint 40l"},
{"",""},{"200L","launch sprint 200l"},{"500L","launch sprint 500l"},{"1000L","launch sprint 1000l"},{"Zenith","launch zenithsprint"},
{"Ultra",""},{"30s","launch ultra 30s"},{"60s","launch ultra 60s"},{"100s","launch ultra 100s"},{"120s","launch ultra 120s"},
{"",""},{"180s","launch ultra 180s"},{"300s","launch ultra 300s"},{"600s","launch ultra 600s"},{"",""},
{"Battle",""},{"2P","launch battle"},{"10P","launch battle 10p"},{"31P","launch battle 31p"},{"100P","launch battle 100p"},
{"Zenith",""},{"10P","launch zenith 10p"},{"31P","launch zenith 31p"},{"50P","launch zenith 50p"},{"100P","launch zenith 100p"},
{"Survive",""},{"0.5","launch survive 500gr"},{"1","launch survive 1000gr"},{"2","launch survive 2000gr"},{"5","launch survive 5000gr"},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
};
int SpaceC = 0;
for (char ch : Command) SpaceC+=(!ch);
if ((Command.size()>6)&&(Command.substr(0,6)=="keymap")&&(SpaceC==2)) Option={
{"",""},{"Back","~"},{"",""},{"",""},{"None","~none"},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"Up","~up"},{"Down","~down"},{"Left","~left"},{"Right","~right"},
{"",""},{"Space","~space"},{"Shift","~shift"},{"Tab","~tab"},{"Enter","~enter"},
{"",""},{"Caps","~caps"},{"Ctrl","~ctrl"},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"A","~a"},{"B","~b"},{"C","~c"},{"D","~d"},
{"",""},{"E","~e"},{"F","~f"},{"G","~g"},{"H","~h"},
{"",""},{"I","~i"},{"J","~j"},{"K","~k"},{"L","~l"},
{"",""},{"M","~m"},{"N","~n"},{"O","~o"},{"P","~p"},
{"",""},{"Q","~q"},{"R","~r"},{"S","~s"},{"T","~t"},
{"",""},{"U","~u"},{"V","~v"},{"W","~w"},{"X","~x"},
{"",""},{"Y","~y"},{"Z","~z"},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"0","~0"},{"1","~1"},{"2","~2"},{"3","~3"},
{"",""},{"4","~4"},{"5","~5"},{"6","~6"},{"7","~7"},
{"",""},{"8","~8"},{"9","~9"},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
};
if ((Command.size()>13)&&(Command.substr(0,8)=="gamerule")&&(Command.substr(9,5)=="piece")&&(SpaceC==2)) Option={
{"",""},{"Back","~"},{"OK","~ "},{"",""},{"Clear","gamerule piece "},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"Garb","+k154"},{"Solid","+k153"},{"Spin","+k152"},{"Bomb","+k151"},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"A","+a"},{"",""},{"B","+b"},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"M3","+cd"},{"",""},{"C","+c"},{"D","+d"},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"M4","+ijlostz"},{"M4-","+ijost"},{"",""},{"",""},
{"",""},{"I","+i"},{"J","+j"},{"L","+l"},{"O","+o"},
{"",""},{"S","+s"},{"T","+t"},{"Z","+z"},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"M5","+efhi5j5l5npqrs5t5uvwxyz5"},{"M5-","ehi5j5prs5t5uvwx"},{"",""},{"",""},
{"",""},{"E","+e"},{"F","+f"},{"H","+h"},{"I","+i5"},
{"",""},{"J","+j5"},{"L","+l5"},{"N","+n"},{"P","+p"},
{"",""},{"Q","+q"},{"R","+r"},{"S","+s5"},{"T","+t5"},
{"",""},{"U","+u"},{"V","+v"},{"W","+w"},{"X","+x"},
{"",""},{"Y","+y"},{"Z","+z5"},{"",""},{"",""},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"M6","+k30k31k32k33k34k35k36k37k38k39k40k41k42k43k44k45k46k47k48k49k50k51k52k53k54k55k56k57k58k59k60k61k62k63k64k65k66k67k68k69k70k71k72k73k74k75k76k77k78k79k80k81k82k83k84k85k86k87k88k89"},{"M6-","+k30k31k32k33k34k35k36k37k38k39k40k42k44k46k48k50k52k54k56k58k60k62k64k66k68k70k72k74k76k78k80k82k84k86k88"},{"",""},{"",""},
{"",""},{Str(132),"+k30"},{"d","+k31"},{Str(133),"+k32"},{"0","+k33"},
{"",""},{"e","+k34"},{Str(134),"+k35"},{"x","+k36"},{Str(145),"+k37"},
{"",""},{"c","+k38"},{"|","+k39"},{Str(135),"+k40"},{Str(136),"+k41"},
{"",""},{"y","+k42"},{"1","+k43"},{"n","+k44"},{"h","+k45"},
{"",""},{"p","+k46"},{"q","+k47"},{"f","+48"},{Str(137),"+k49"},
{"",""},{"<","+k50"},{">","+k51"},{"r","+k52"},{Str(138),"+k53"},
{"",""},{Str(139),"+k54"},{Str(140),"+k55"},{"7","+k56"},{Str(141),"+k57"},
{"",""},{Str(142),"+k58"},{Str(143),"+k59"},{"$","+k60"},{"%","+k61"},
{"",""},{"4","+k62"},{Str(144),"+k63"},{"G","+k64"},{"?","+k65"},
{"",""},{"/","+k66"},{"\\","+k67"},{Str(146),"+k68"},{Str(147),"+k69"},
{"",""},{Str(148),"+k70"},{Str(149),"+k71"},{"K","+k72"},{Str(150),"+k73"},
{"",""},{Str(151),"+k74"},{Str(152),"+k75"},{"2","+k76"},{"5","+k77"},
{"",""},{"{","+k78"},{"}","+k79"},{Str(153),"+k80"},{"u","+k81"},
{"",""},{Str(154),"+k82"},{Str(155),"+k83"},{Str(156),"+k84"},{Str(157),"+k85"},
{"",""},{Str(158),"+k86"},{"a","+k87"},{"M","+k88"},{"m","+k89"},
{"",""},{"",""},{"",""},{"",""},{"",""},
{"",""},{"@","+k90"},{"o","+k91"},{"^","+k92"},{",","+k93"},
{"",""},{":","+k94"},{"(","+k95"},{")","+k96"},{";","+k97"},
{"",""},{"[","+k98"},{"]","+k99"},{"#","+k100"},{"",""},
};
int oid = 0;
int sid = -1;
int RowCnt = 50;
int RowDis = 17;
int RowLen = 15;
int ColDis = 65;
int ColLen = 62;
int LColDis = 350;
int TextSz = 7;
if (Option.size()<=240) {
RowDis *= 1.5;
RowLen *= 1.5;
ColDis *= 1.5;
ColLen *= 1.5;
LColDis *= 1.5;
TextSz *= 1.5;
RowCnt = 28;
}
for (int i=0; i<Option.size()/5+2; ++i) {
for (int j=0; j<5; ++j) {
if (oid>=Option.size()) break;
bool ok = ((p.y>=(i%RowCnt)*RowDis-30)&&(p.y<=(i%RowCnt)*RowDis-30+RowLen)&&(p.x>=-95+LColDis*(i/RowCnt)+j*ColDis)&&(p.x<=-95+LColDis*(i/RowCnt)+j*ColDis+ColLen));
if (Option[oid].second=="") {
ok = false;
if (Option[oid].first=="") {
++oid; continue;
}
}
if (ok) sid=oid;
Rectangle((i%RowCnt)*RowDis-30,-95+j*ColDis+LColDis*(i/RowCnt),RowLen,ColLen,0x888888);
Rectangle((i%RowCnt)*RowDis-30,-95+j*ColDis+LColDis*(i/RowCnt),RowLen-1,ColLen-1,0xCCCCCC);
Rectangle((i%RowCnt)*RowDis-30+1,-95+j*ColDis+LColDis*(i/RowCnt)+1,RowLen-2,ColLen-2,(ok)?0x66CCFF:0xAAAAAA);
PaintStrM(Option[oid].first,(i%RowCnt)*RowDis-30+ColDis/15,-95+j*ColDis+LColDis*(i/RowCnt)+ColDis/2-TextSz,TextSz,(oid%5)?0x666666:0x333333);
++oid;
}
if (oid>=Option.size()) break;
}
int pcnt = 0;
double rat = double(max(1,tm));
for (int i=0; i<PQu.size(); ++i) {
Particle o = PQu[i];
Poly(o.x, o.y, o.sz*sz/15.0, o.n, o.clr, o.th);
o.x+=o.vx*rat; o.y+=o.vy*rat;
o.vx+=o.ax*rat; o.vy+=o.ay*rat;
o.sz -= o.de*rat*0.5;
if (o.sz>0.0) PQu[pcnt++]=o;
}
while (PQu.size()>pcnt) PQu.pop_back();
int tcnt = 0;
for (int i=0; i<TQu.size(); ++i) {
FloatText o = TQu[i];
PaintStrM(o.str, o.x, o.y, o.sz, abs(o.clr), o.bd);
o.bd -= o.de*rat*0.5;
if ((Bot)&&(sz<10)&&(o.clr>=0)) o.bd=-1.0;
if (o.bd>0.0) TQu[tcnt++]=o;
}
while (TQu.size()>tcnt) TQu.pop_back();
bool nw = ((CheckKey(VK_LBUTTON))||(CheckKey(VK_RBUTTON)));
SelX=SelY=0;
for (int i=-11; i<=100; ++i) {
if (!Zen) break;
if ((Command=="")&&(Con)) break;
if (!i) continue;
for (int j=1; j<=100; ++j) {
if ((20*(DX0-i)<=p.y)&&(p.y<=20*(DX0-i+1))&&(20*(j-1)+400<=p.x)&&(p.x<=20*j+400)) {
SelX=i; SelY=j;
}
}
}
vector<ClassAtkEff> nwAtkEff;
for (ClassAtkEff oo : AtkEff) {
ClassAtkEff o = oo;
Poly(o.x, o.y, o.sz*5, 8, o.clr, o.th);
o.th += tm*0.001;
double tx=MX[o.tar], ty=MY[o.tar];
double dis = (o.x-tx)*(o.x-tx)+(o.y-ty)*(o.y-ty);
if (dis<0.1) continue;
double td = atan2(ty-o.y,tx-o.x);
double pi = acos(-1.0);
//if (o.dir+pi<td) o.dir+=pi*2.0;
//if (o.dir-pi>td) o.dir-=pi*2.0;
o.dir = td;
//if (o.dir<0.0) o.dir+=pi*2.0;
//if (o.dir>=pi*2.0) o.dir-=pi*2.0;
double dd = min(double(tm),sqrt(dis));
o.x+=dd*cos(o.dir); o.y+=dd*sin(o.dir);
nwAtkEff.push_back(o);
}
AtkEff = nwAtkEff;
if (nw) {
// Square(sz*double(DX-i),sz*double(j-1),sz*ss,clr)
int clp = AddTp;
int clr = Piece[clp][0].clr;
if (Press) PQu.push_back({p.y,p.x,0,0,0,0,30,0.2,rndf()*acos(-1.0)*2.0,20,clr});
else {
if (sid>=0) {
Con = true;
ForceExecute = Option[sid].second;
LButtonCD = true;
for (int i=0; i<ForceExecute.size(); ++i) {
if (ForceExecute[i]==' ') ForceExecute[i]=0;
}
}
double th = rndf()*acos(-1.0)*2.0;
PQu.push_back({p.y,p.x,0,0,0,0,60,0.1,rndf()*acos(-1.0)*2.0,20,clr});
for (int i=0; i<5; ++i) {
th += acos(-1.0)*2.0/5.0;
PQu.push_back({p.y,p.x,sin(th)*0.1,cos(th)*0.1,0,0,30,0.02,rndf()*acos(-1.0)*2.0,5,clr});
}
}
}
else if (Press) _fstl=false;
Press = nw;
int bg = Mix(0xFFFFFF,0x000000,BackgroundRatio);
RespondTime = max(0,RespondTime-tm);
if (RespondTime) PaintStrL(Respond, -65, 20, 9, Mix(RespondColor,bg,double(RespondTime)/10000.0));
sprintf(buf, " [%u]", FP.size());
PaintStrL(buf, -95, 0, 9, 0xEE82EE);
if (Con) {
vector<string> Hint = GetHint(Command);
for (int i=0; i<Hint.size(); ++i) PaintStrL(Hint[i], -40+15*(i%40), 20+500*(i/40), 9, 0xFFFFFF);
}
if (!Con) {
PaintStrL((Command.size())?"> "+Command:" Press [Esc] to pause...", -80, 0, 9, 0x888888);
//PaintStrL(str, -80, 0, 9, 0x888888);
return;
}
if ((Con)&&(sid>=0)) {
PaintStrL(": "+Option[sid].second, -80, 0, 9, 0xFDD000);
return;
}
if ((Con)&&(Command=="")) {
PaintStrL(" Press [Esc] to resume or input command ending with [Enter]...", -80, 0, 9, 0x39C5BB);
return;
}
PaintStrL("> "+Command, -80, 0, 9, 0x00FFCC);
}
int QueryVal(string str) {
if (str=="complete") return Complete;
if (str=="levelstart") return LevStart;
if (str=="levelbase") return LevBase;
if (str=="levelline") return LevLine;
if (str=="leveltime") return LevTime;
if (str=="levelpiece") return LevPiece;
if (str=="levelattack") return LevAttack;
if (str=="increaseline") return LevLineInc;
if (str=="increasetime") return LevTimeInc;
if (str=="increasepiece") return LevPieceInc;
if (str=="increaseattack") return LevAttackInc;
if (str=="levelmaster") return MasterBeg;
if (str=="levelratio") return Diff;
if (str=="targetpiece") return TarPiece;
if (str=="targettime") return TarTime;
if (str=="targetline") return TarLine;
if (str=="targetattack") return TarAttack;
if (str=="targetscore") return TarScore;
if (str=="passthrough") return Passthrough;
if (str=="blockheight") return QueryHeight();
if (str=="sumpiece") return SumPiece;
if (str=="sumline") return SumLine;
if (str=="sumdig") return SumDig;
if (str=="sumattack") return SumAttack;
if (str=="staticheight") return StaticHeight;
if (str=="startheight") return StartHeight;
if (str=="usemove") return AllowMove;
if (str=="userotate") return AllowRot;
if (str=="use2rotate") return Allow2Rot;
if (str=="usehalf") return AllowHalf;
if (str=="usehard") return AllowHard;
if (str=="usesoft") return AllowSoft;
if (str=="usesonic") return AllowSonic;
if (str=="useflip") return AllowFlip;
if (str=="useup") return AllowUp;
if (str=="uselock") return AllowLock;
if (str=="usedeep") return AllowDeep;
if (str=="wastelimit") return WasteLim;
if (str=="vs") return SumAttack+SumDig;
if (str=="holdpiece") return Hold;
if (str=="pid") return Pid;
if (str=="tar") return Tar;
if (str=="attacktype") return AtkType;
if (str=="receive") {
int tot=0; for (pair<int,pair<int,ll> > o : Rec) tot+=o.first;
return tot+ActiveGarb.size();
}
if (str=="queuegarbage") {
int tot=0; for (pair<int,pair<int,ll> > o : Rec) tot+=o.first;
return tot;
}
if (str=="activegarbage") return ActiveGarb.size();
if (str=="bot") return Bot;
if (str=="bottype") return Plr;
if (str=="point") return Wins;
if (str=="height") return DX;
if (str=="realheight") return LX;
if (str=="vanish") return VanishHeight;
if (str=="width") return LY;
if (str=="ko") return KO;
if (str=="badge") return SKO;
if (str=="botspeed") return OperTime;
if (str=="over") return Over;
if (str=="next") return ViewNxt;
if (str=="history") return His;
if (str=="roll") return Rol;
if (str=="extra") return Ext;
if (str=="reset") return ResetLim;
if (str=="lock") return BaseLockL;
if (str=="groundlock") return GLockL;
if (str=="forcelock") return FLockL;
if (str=="drop") return BaseDropL;
if (str=="openerphrase") return OpenerPhrase;
if (str=="garbagepreview") return GarbagePreview;
if (str=="garbagegap") return GarbageGap;
if (str=="garbagedelay") return GarbDelay;
if (str=="garbagerise") return GarbRise;
if (str=="initfacing") return InitFacing;
if (str=="hold") return HoldRule;
if (str=="sequence") return Sequence;
if (str=="das") return DAS;
if (str=="arr") return ARR;
if (str=="dropdas") return SDDAS;
if (str=="droparr") return SDARR;
if (str=="dcd") return DCD;
if (str=="hcd") return HCD;
if (str=="deathare") return DeathARE;
if (str=="are") return ARE;
if (str=="lcd") return LCD;
if (str=="drd") return DRD;
if (str=="shadow") return ShowShadow;
if (str=="roundheight") return RoundHeight;
if (str=="stock") return Stock;
if (str=="life") return Life;
if (str=="mod2") return ModHold;
if (str=="mod3") return ModMess;
if (str=="mod4") return ModGravity;
if (str=="mod5") return ModStrength;
if (str=="mod6") return ModDivergence;
if (str=="mod7") return ModInvisible;
if (str=="mod8") return ModSpin;
if (str=="mod9") return ModExpert;
return ERR;
}
int ChangeVal(string str, int x) {
if (x==ERR) return ERR;
if (str=="complete") Complete=bool(x);
else if (str=="levelstart") LevStart=x;
else if (str=="levelbase") LevBase=x;
else if (str=="levelline") LevLine=x;
else if (str=="leveltime") LevTime=x;
else if (str=="levelpiece") LevPiece=x;
else if (str=="levelattack") LevAttack=x;
else if (str=="increaseline") LevLineInc=x;
else if (str=="increasetime") LevTimeInc=x;
else if (str=="increasepiece") LevPieceInc=x;
else if (str=="increaseattack") LevAttackInc=x;
else if (str=="levelmaster") MasterBeg=x;
else if (str=="levelratio") Diff=x;
else if (str=="targetpiece") TarPiece=x;
else if (str=="targettime") TarTime=x;
else if (str=="targetline") TarLine=x;
else if (str=="targetattack") TarAttack=x;
else if (str=="targetscore") TarScore=x;
else if (str=="passthrough") Passthrough=x;
else if (str=="sumpiece") SumPiece=x;
else if (str=="sumline") SumLine=x;
else if (str=="sumdig") SumDig=x;
else if (str=="sumattack") SumAttack=x;
else if (str=="staticheight") StaticHeight=x;
else if (str=="startheight") StartHeight=x;
else if (str=="usemove") AllowMove=bool(x);
else if (str=="userotate") AllowRot=bool(x);
else if (str=="use2rotate") Allow2Rot=bool(x);
else if (str=="usehalf") AllowHalf=bool(x);
else if (str=="usehard") AllowHard=bool(x);
else if (str=="usesoft") AllowSoft=bool(x);
else if (str=="usesonic") AllowSonic=bool(x);
else if (str=="useflip") AllowFlip=bool(x);
else if (str=="useup") AllowUp=bool(x);
else if (str=="uselock") AllowLock=bool(x);
else if (str=="usedeep") AllowDeep=bool(x);
else if (str=="wastelimit") WasteLim=x;
else if (str=="holdpiece") {
if (!CheckBlockType(x)) return ERR;
Hold = x;
}
else if (str=="pid") {
if ((!x)||(!CheckBlockType(x))) return ERR;
Pid = x;
}
else if (str=="tar") {
if (x>=Plrs) return ERR;
Tar = x;
}
else if (str=="attacktype") {
if ((!x)||(x>6)) return ERR;
AtkType = x;
}
else if (str=="bot") Bot=x;
else if (str=="bottype") Plr=x;
else if (str=="point") Wins=x;
else if (str=="height") {
if ((x<2)||(x>100)) return ERR;
DX=x; LX=max(LX,DX);
VanishHeight = max(VanishHeight,DX+2);
}
else if (str=="realheight") {
if ((x<2)||(x>100)) return ERR;
LX=x; DX=min(DX,LX);
}
else if (str=="vanish") VanishHeight=x;
else if (str=="width") {
if ((x<2)||(x>50)) return ERR;
LY = x;
}
else if (str=="ko") KO=x;
else if (str=="badge") SKO=x;
else if (str=="botspeed") OperTime=x;
else if (str=="next") {
if (x>10) return ERR;
ViewNxt = x;
}
else if (str=="history") {
if (x>100) return ERR;
His = x;
}
else if (str=="roll") {
if ((!x)||(x>100)) return ERR;
Rol = x;
}
else if (str=="extra") {
if (x>100) return ERR;
Ext = x;
}
else if (str=="reset") ResetLim=x;
else if (str=="lock") BaseLockL=x;
else if (str=="groundlock") GLockL=x;
else if (str=="forcelock") FLockL=x;
else if (str=="drop") BaseDropL=x;
else if (str=="openerphrase") OpenerPhrase=x;
else if (str=="garbagepreview") GarbagePreview=x;
else if (str=="garbagegap") GarbageGap=x;
else if (str=="garbagedelay") GarbDelay=x;
else if (str=="garbagerise") GarbRise=x;
else if (str=="initfacing") InitFacing=x&3;
else if (str=="hold") {
if (x>2) return ERR;
HoldRule = x;
}
else if (str=="sequence") {
if (x>2) return ERR;
Sequence = x;
}
else if (str=="das") DAS=x;
else if (str=="arr") ARR=x;
else if (str=="dropdas") SDDAS=x;
else if (str=="droparr") SDARR=x;
else if (str=="dcd") DCD=x;
else if (str=="hcd") HCD=x;
else if (str=="deathare") DeathARE=x;
else if (str=="are") ARE=x;
else if (str=="lcd") LCD=x;
else if (str=="drd") DRD=x;
else if (str=="shadow") ShowShadow=bool(x);
else if (str=="roundheight") RoundHeight=x;
else if (str=="stock") Stock=x;
else if (str=="life") Life=x;
else if (str=="mod2") {
ModHold=min(x,2); HoldRule=(ModHold)?0:((Zen)?2:1);
Sequence = (ModHold==2)?0:1;
ViewNxt = (ModHold==2)?1:5;
if (ModHold==2) {
His=0; Rol=1;
}
}
else if (str=="mod3") {
ModMess=min(x,2); LCD=(ModMess==2)?1150:0;
}
else if (str=="mod4") ModGravity=min(x,2);
else if (str=="mod5") {
if (ModStrength==2) DX=min(LX,DX+6);
ModStrength = min(x,2);
if (ModStrength==2) DX=max(2,DX-6);
}
else if (str=="mod6") ModDivergence=min(x,2);
else if (str=="mod7") ModInvisible=min(x,2);
else if (str=="mod8") ModSpin=min(x,2);
else if (str=="mod9") {
ModExpert=min(x,2); GarbRise=(ModExpert)?0:100;
}
else return ERR;
return 0;
}
} Global;
Board Plr[111];
int curh[999]; bool KOCount[999], ConKey[999];
vector<int> TransferBag(string str) {
vector<int> res;
while (str.size()) {
char p=str.back(); int q=0; str.pop_back();
int pw = 1;
while ((p>='0')&&(p<='9')) {
if (str.empty()) return vector<int>();
q+=pw*int(p-'0'); pw*=10;
p=str.back(); str.pop_back();
}
char dy = 0;
int dg = 0;
if ((p>='a')&&(p<='z')) p+='A'-'a';
if (p=='A') {
if ((!q)||(q==1)) dy='A';
}
if (p=='B') {
if ((!q)||(q==2)) dy='B';
if (q==5) dy='Q';
}
if (p=='C') {
if ((!q)||(q==3)) dy='C';
}
if (p=='D') {
if ((!q)||(q==3)) dy='D';
if (q==2) dy='B';
if (q==5) dy='P';
}
if (p=='E') {
if ((!q)||(q==5)) dy='E';
}
if (p=='F') {
if ((!q)||(q==5)) dy='F';
}
if (p=='G') {
if ((!q)||(q==1)) dy='G';
if (q==2) dy='g';
}
if (p=='H') {
if ((!q)||(q==5)) dy='H';
}
if (p=='I') {
if ((!q)||(q==4)) dy='I';
if (q==5) dy='i';
if (q==3) dy='D';
if (q==2) dy='B';
if (q==1) dy='A';
}
if (p=='J') {
if ((!q)||(q==4)) dy='J';
if (q==5) dy='j';
if (q==3) dy='C';
}
if (p=='K') {
if (q) dg=q;
else dg=154;
}
if (p=='L') {
if ((!q)||(q==4)) dy='L';
if (q==5) dy='l';
if (q==3) dy='C';
}
if (p=='M') {
if ((!q)||(q==5)) dy='W';
if (q==1) dy='A';
}
if (p=='N') {
if ((!q)||(q==5)) dy='N';
}
if (p=='O') {
if ((!q)||(q==4)) dy='O';
if (q==1) dy='A';
}
if (p=='P') {
if ((!q)||(q==5)) dy='P';
}
if (p=='Q') {
if ((!q)||(q==5)) dy='Q';
}
if (p=='R') {
if ((!q)||(q==5)) dy='R';
}
if (p=='S') {
if ((!q)||(q==4)) dy='S';
if (q==5) dy='s';
if (q==1) dy='A';
}
if (p=='T') {
if ((!q)||(q==4)) dy='T';
if (q==5) dy='t';
}
if (p=='U') {
if ((!q)||(q==5)) dy='U';
}
if (p=='V') {
if ((!q)||(q==5)) dy='V';
if (q==3) dy='C';
}
if (p=='W') {
if ((!q)||(q==5)) dy='W';
}
if (p=='X') {
if ((!q)||(q==5)) dy='X';
}
if (p=='Y') {
if ((!q)||(q==5)) dy='Y';
}
if (p=='Z') {
if ((!q)||(q==4)) dy='Z';
if (q==5) dy='z';
}
if ((!dy)&&(!dg)) return vector<int>();
int pc = 0;
for (int i=1; i<155; ++i) {
if (PName[i]==dy) pc=i;
}
if ((dg>0)&&(CheckBlockType(dg))) pc=dg;
else if (dg) pc=0;
if (!pc) return vector<int>();
res.push_back(pc);
}
if (res.empty()) return res;
reverse(res.begin(), res.end());
return res;
}
void Apply(int o, int e, int x, int f) {
if (!Odoo) return;
if (QuickPlay) x>>=1;
int lev = 1;
if (x>=2) lev=2;
if (x>=3) lev=4;
int Fst=lev*100000, Rem=Fst;
#define t(x) Plr[o].EV[x]
if (e==1) {
if ((Rem)&&(!Plr[o].Bl.empty())){
while (Plr[o].Bl.size()) {
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].Bl.pop(); Plr[o].AddGarbage(3+(Plr[f].OgTm>0),Plr[o].RollGarb());
}
Plr[o].EText("Burgeon", 0xFFA500);
}
if ((Rem)&&(t(6))) {
int val = max(Rem,t(6)/2);
t(6) -= val*2;
t(2) = max(0,t(2)-val*2);
Rem -= val;
Plr[o].EText("Melt", 0xFFA500);
}
if ((Rem)&&(t(2))) {
int val = max(Rem/2,t(2));
t(2) -= val;
Rem -= val*2;
Plr[o].EText("Vaporize", 0xFFA500);
}
if ((Rem)&&(t(3))) {
int val = min(Rem,t(3));
t(3) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(4))&&(!t(5))) {
int val = min(Rem,t(4));
t(4) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(2+(Plr[f].OgTm>0), Plr[o].RollGarb());
if (Plr[o].CheckActive()) {
Plr[o].HardDrop(); Plr[o].Oper.clear();
}
Plr[o].EText("Overloaded", 0xEE0000);
}
}
if (e==2) {
if ((Rem)&&(t(1))) {
int val = max(Rem,t(1)/2);
t(1) -= val*2;
Rem -= val;
Plr[o].EText("Vaporize", 0xFFA500);
}
if ((Rem)&&(t(3))) {
int val = min(Rem,t(3));
t(3) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(5))&&(!t(1))) {
int val = min(Rem,t(5));
t(5) -= val;
t(4) = max(0,t(4)-val);
Rem -= val;
val = max(1,val/100000);
for (int i=0; i<min(10,val); ++i) Plr[o].Bl.push(clock());
if (val) Plr[o].EText("Bloom", 0x00FF00);
}
}
if (e==3) {
if ((Rem)&&(t(1))) {
int val = min(Rem,t(1));
t(1) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Apply(o, 1, 1, f);
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(6))) {
int val = min(Rem,t(6));
t(6) -= val;
t(2) = max(0,t(2)-val);
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Apply(o, 1, 1, f);
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(2))) {
int val = min(Rem,t(2));
t(2) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Apply(o, 2, 1, f);
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(4))&&(!t(5))) {
int val = min(Rem,t(4));
t(4) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Apply(o, 4, 1, f);
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(5))) {
int val = min(Rem,t(5));
t(5) -= val;
Rem -= val;
Plr[f].OgTm = 100000;
Plr[o].EText("Overgrown", 0x00FF00);
}
if ((Rem)&&(t(7))) {
int val = min(Rem,t(7));
t(7) -= val;
Rem -= val;
int dd = 1;
for (int i=1; i<=Plr[o].LX; ++i) {
for (int j=1; j<=Plr[o].LY; ++j) {
if ((Plr[o].B[i][j])&&(!Plr[o].C[i][j])) dd=i;
}
}
for (int _=0; _<2; ++_) {
int x=rnd(dd)+1, y=rnd(dd+1);
bool ok = true;
for (int i=1; i<=Plr[o].LY; ++i) {
if ((Plr[o].C[x][i])||(Plr[o].C[y][i])) ok=false;
}
if (!ok) continue;
for (int i=1; i<=Plr[o].LY; ++i) {
swap(Plr[o].B[x][i], Plr[o].B[y][i]);
swap(Plr[o].ID[x][i], Plr[o].ID[y][i]);
Plr[o].LE[x][i]=Plr[o].LE[y][i]=10000;
}
}
if (val) Plr[o].EText("Dustraise", 0xFFE211);
}
}
if (e==4) {
if ((Rem)&&(!Plr[o].Bl.empty())) {
while (Plr[o].Bl.size()) {
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].Bl.pop(); Plr[o].AddGarbage(1,Plr[o].RollGarb());
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0),Plr[o].RollGarb());
}
Plr[o].EText("Hyperbloom", 0xEE82EE);
}
if ((Rem)&&(t(1))) {
int val = min(Rem,t(1));
t(1) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(2+(Plr[f].OgTm>0), Plr[o].RollGarb());
if (Plr[o].CheckActive()) Plr[o].HardDrop();
Plr[o].EText("Overloaded", 0xEE0000);
}
if ((Rem)&&(t(3))) {
int val = min(Rem,t(3));
t(3) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(6))) {
int val = min(Rem,t(6));
t(6) -= val;
t(2) = max(0,t(2)-val);
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].ScTm = 5000;
Plr[o].EText("Superconduct", 0x66CCFF);
}
}
if (e==5) {
if ((Rem)&&(t(2))&&(!t(6))) {
int val = min(Rem,t(2));
t(2) -= val;
Rem -= val;
val = max(1,val/100000);
for (int i=0; i<min(10,val); ++i) Plr[o].Bl.push(clock());
if (val) Plr[o].EText("Bloom", 0x00FF00);
}
if ((Rem)&&(t(3))) {
int val = min(Rem,t(3));
t(3) -= val;
Rem -= val;
Plr[f].OgTm = 100000;
Plr[o].EText("Overgrown", 0x00FF00);
}
}
if (e==6) {
if ((Rem)&&(t(1))) {
int val = max(Rem/2,t(1));
t(1) -= val;
Rem -= val*2;
Plr[o].EText("Melt", 0xFFA500);
}
if ((Rem)&&(t(3))) {
int val = min(Rem,t(3));
t(3) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].EText("Swirl", 0x00FFCC);
}
if ((Rem)&&(t(4))&&(!t(5))) {
int val = min(Rem,t(4));
t(6) -= val;
Rem -= val;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(1+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].ScTm = 5000;
Plr[o].EText("Superconduct", 0x66CCFF);
}
}
if (e==7) {
if ((t(2))&&(t(6))) {
t(2)=t(6)=0;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(2+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].EText("Shattered", 0xFFE211);
}
if ((Rem)&&(t(1))) {
int val = min(Rem,t(1));
t(1) -= val;
Rem -= val;
Plr[f].Cy.push_back(make_pair(clock(),1));
Plr[f].Cy.push_back(make_pair(clock(),1));
Plr[o].EText("Crystalize", 0xFFE211);
}
if ((Rem)&&(t(6))) {
int val = min(Rem,t(6));
t(6) -= val;
t(2) = max(0,t(2)-val);
Rem -= val;
Plr[f].Cy.push_back(make_pair(clock(),6));
Plr[f].Cy.push_back(make_pair(clock(),6));
Plr[o].EText("Crystalize", 0xFFE211);
}
if ((Rem)&&(t(2))) {
int val = min(Rem,t(2));
t(2) -= val;
Rem -= val;
Plr[f].Cy.push_back(make_pair(clock(),2));
Plr[f].Cy.push_back(make_pair(clock(),2));
Plr[o].EText("Crystalize", 0xFFE211);
}
if ((Rem)&&(t(4))) {
int val = min(Rem,t(4));
t(4) -= val;
Rem -= val;
Plr[f].Cy.push_back(make_pair(clock(),4));
Plr[f].Cy.push_back(make_pair(clock(),4));
Plr[o].EText("Crystalize", 0xFFE211);
}
if ((Rem)&&(t(3))) {
int val = min(Rem,t(3));
t(3) -= val;
Rem -= val;
int dd = 1;
for (int i=1; i<=Plr[o].LX; ++i) {
for (int j=1; j<=Plr[o].LY; ++j) {
if ((Plr[o].B[i][j])&&(!Plr[o].C[i][j])) dd=i;
}
}
for (int _=0; _<2; ++_) {
int x=rnd(dd)+1, y=rnd(dd+1);
bool ok = true;
for (int i=1; i<=Plr[o].LY; ++i) {
if ((Plr[o].C[x][i])||(Plr[o].C[y][i])) ok=false;
}
if (!ok) continue;
for (int i=1; i<=Plr[o].LY; ++i) {
swap(Plr[o].B[x][i], Plr[o].B[y][i]);
swap(Plr[o].ID[x][i], Plr[o].ID[y][i]);
Plr[o].LE[x][i]=Plr[o].LE[y][i]=10000;
}
}
if (val) Plr[o].EText("Dustraise", 0xFFE211);
}
}
if ((!e)&&(x>1)) {
if ((t(2))&&(t(6))) {
t(2)=t(6)=0;
if (rnd(100)<_SegMess) Plr[o].LstHole=rnd(Plr[o].LY)+1;
Plr[o].AddGarbage(2+(Plr[f].OgTm>0), Plr[o].RollGarb());
Plr[o].EText("Shattered", 0xFFE211);
}
}
if (Rem<Fst) return;
if (e==1) {
if ((!t(1))&&(t(5))) Plr[o].EText("Burning",0xFFA500);
}
if (e==2) {
if ((!t(2))&&(t(4))&&(!t(6))) Plr[o].EText("Electro-Charged",0xEE82EE);
if ((!t(2))&&(t(6))) Plr[o].EText("Frozen",0x66CCFF);
}
if (e==4) {
if ((!t(4))&&(t(2))&&(!t(6))) Plr[o].EText("Electro-Charged",0xEE82EE);
if ((!t(4))&&(t(5))&&(!t(1))) Plr[o].EText("Quickened",0x00FF00);
if ((t(4))&&(t(5))&&(!t(1))) Plr[o].EText("Aggravate",0xEE82EE);
}
if (e==5) {
if ((!t(5))&&(t(1))) Plr[o].EText("Burning",0xFFA500);
if ((!t(5))&&(t(4))&&(!t(1))) Plr[o].EText("Quickened",0x00FF00);
if ((t(5))&&(t(4))&&(!t(1))) Plr[o].EText("Spread",0x00FF00);
if ((!t(5))&&(t(7))&&(!t(1))) Plr[o].EText("Solidification",0x00FF00);
if ((!t(5))&&(t(6))&&(!t(1))) Plr[o].EText("Wither",0x66CCFF);
}
if (e==6) {
if ((!t(6))&&(t(2))) Plr[o].EText("Frozen",0x66CCFF);
if ((!t(6))&&(t(5))&&(!t(1))) Plr[o].EText("Wither",0x66CCFF);
}
if (e==7) {
if ((!t(7))&&(t(5))&&(!t(1))) Plr[o].EText("Solidification",0x00FF00);
}
Plr[o].EV[e] = max(Plr[o].EV[e],Fst);
Plr[o].ED[e] = (lev<2)?4:6;
if (e==3) Plr[o].ED[e]*=2;
if (e==7) Plr[o].ED[e]*=100;
#undef t
}
string ForceLaunch = "";
vector<string> LaunchOpt;
pair<int,string> ExecuteProcess(vector<string> Co) {
if (Co[0]=="ciallo") {
DefaultBag.clear();
for (int i=1; i<=100; ++i) {
if (i!=91) DefaultBag.push_back(i);
}
for (int _=0; _<2; ++_) {
for (int i=1; i<=11; ++i) DefaultBag.push_back(i);
for (int __=0; __<2; ++__) {
for (int i=8; i<=11; ++i) DefaultBag.push_back(i);
}
}
for (int i=0; i<Plrs; ++i) Plr[i].Bag=DefaultBag;
return make_pair(0xEE82EE,"No Comment");
}
if (Co[0]=="odoo") {
Odoo = !Odoo;
return make_pair(0xEE82EE,"No Comment");
}
if (Co[0]=="lqos") {
LqOS = !LqOS;
return make_pair(0xEE82EE,"No Comment");
}
if ((Co.size()>1)&&(Co[0]=="conste")) {
int x = SToI(Co[1]);
if (x<8) ConstE=x;
return make_pair(0xEE82EE,"No Comment");
}
vector<int> lst; if (Obs>=0) lst.push_back(Obs);
if (Co[0]=="for") {
int pos = 0;
for (int i=1; i<Co.size(); ++i) {
if (Co[i]=="run") {
pos=i; break;
}
}
if (!pos) return make_pair(0xEE0000,"No paring \'run\' found in \'for\'");
lst.clear();
for (int i=0; i<Plrs; ++i) lst.push_back(i);
vector<string> nw; deque<string> filter;
for (int i=1; i<pos; ++i) filter.push_back(Co[i]);
while (filter.size()) {
string ValName=filter.front(); filter.pop_front();
if ((ValName=="sort")||(ValName=="rsort")) {
bool rev = (ValName=="rsort");
if (filter.empty()) return make_pair(0xEE0000,"No paring variable for sorting");
ValName=filter.front(); filter.pop_front();
int val = Global.QueryVal(ValName);
if (val==ERR) return make_pair(0xEE0000,"Unknown variable \'"+ValName+"\'");
for (int i : lst) {
sortval[i]=Plr[i].QueryVal(ValName); if (rev) sortval[i]*=-1;
}
stable_sort(lst.begin(), lst.end(), [](int x, int y) {
return sortval[x]<sortval[y];
});
continue;
}
if (ValName=="pick") {
if (filter.empty()) return make_pair(0xEE0000,"No paring count for picking");
string pc=filter.front(); int cnt=SToI(pc); filter.pop_front();
if (cnt==ERR) return make_pair(0xEE0000,"Invalid count \'"+pc+"\' for picking");
while (lst.size()>cnt) lst.pop_back();
continue;
}
if (ValName=="shuffle") {
shuffle(lst.begin(), lst.end(), rng);
continue;
}
int val = Global.QueryVal(ValName);
if (val==ERR) return make_pair(0xEE0000,"Unknown variable \'"+ValName+"\'");
if (filter.empty()) return make_pair(0xEE0000,"No paring limitation for variable \'"+ValName+"\'");
string Lim=filter.front(); filter.pop_front();
if ((Lim!="e")&&(Lim!="ne")&&(Lim!="ge")&&(Lim!="le")&&(Lim!="g")&&(Lim!="l")) {
return make_pair(0xEE0000,"Invalid limitation \'"+Lim+"\' for variable \'"+ValName+"\'");
}
if (filter.empty()) return make_pair(0xEE0000,"No paring value for variable \'"+ValName+"\'");
string cp=filter.front(); int cval=SToI(cp); filter.pop_front();
if (cval==ERR) return make_pair(0xEE0000,"Invalid value \'"+cp+"\' for variable \'"+ValName+"\'");
vector<int> nwlst;
for (int i : lst) {
val = Plr[i].QueryVal(ValName);
if ((Lim=="e")&&(val==cval)) nwlst.push_back(i);
if ((Lim=="ne")&&(val!=cval)) nwlst.push_back(i);
if ((Lim=="g")&&(val>cval)) nwlst.push_back(i);
if ((Lim=="ge")&&(val>=cval)) nwlst.push_back(i);
if ((Lim=="l")&&(val<cval)) nwlst.push_back(i);
if ((Lim=="le")&&(val<=cval)) nwlst.push_back(i);
}
lst = nwlst;
}
for (int i=pos+1; i<Co.size(); ++i) nw.push_back(Co[i]);
Co = nw;
}
else if (Co[0]=="forall") {
lst.clear(); for (int i=0; i<Plrs; ++i) lst.push_back(i);
vector<string> nw;
for (int i=1; i<Co.size(); ++i) nw.push_back(Co[i]);
Co = nw;
}
//if (lst.empty()) return make_pair(0xAAAAAA,"No target selected");
if (Co.empty()) return make_pair(0xAAAAAA,"No command");
if (Co[0]=="for") return make_pair(0xEE0000,"Invalid \'for\' command");
if (Co[0]=="run") return make_pair(0xEE0000,"Invalid \'run\' command");
if (Co[0]=="forall") return make_pair(0xEE0000,"Invalid \'forall\' command");
if (Co[0]=="sort") return make_pair(0xEE0000,"Invalid \'sort\' command");
if (Co[0]=="rsort") return make_pair(0xEE0000,"Invalid \'rsort\' command");
if (Co[0]=="pick") return make_pair(0xEE0000,"Invalid \'pick\' command");
if (Co[0]=="shuffle") return make_pair(0xEE0000,"Invalid \'shuffle\' command");
if (Co[0]=="kill") {
int tot = 0;
for (int d : lst) {
if (!Plr[d].Over) {
Plr[d].ForceOver=true; ++tot;
}
}
if (tot) return make_pair(0x66CCFF,"Cleared "+IToS(tot)+" player"+((tot>1)?"s":""));
else return make_pair(0xAAAAAA,"No players cleared");
}
if (Co[0]=="finish") {
ForceRound=true; return make_pair(0x66CCFF,"Finished the current game");
}
if (Co[0]=="abort") {
ForceAbort=true; return make_pair(0x66CCFF,"Aborted the current game");
}
if (Co[0]=="setblock") {
if (Co.size()<3) return make_pair(0xEE0000,"Insufficient values for \'setblock\' command");
int x=SToI(Co[1]), y=SToI(Co[2]), val=154, rep=-1;
if (Co.size()>=4) val=SToI(Co[3]);
if (Co.size()>=5) rep=SToI(Co[4]);
if (x==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[1]+"\' for \'setblock\' command");
if (y==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for \'setblock\' command");
if (val==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[3]+"\' for \'setblock\' command");
if (rep==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[4]+"\' for \'setblock\' command");
if (!CheckBlockType(val)) return make_pair(0xEE0000,"\'"+Co[3]+"\' is not a block type");
if ((rep>=0)&&(!CheckBlockType(rep))) return make_pair(0xEE0000,"\'"+Co[4]+"\' is not a block type");
int tot = 0;
for (int d : lst) {
if ((x>Plr[d].LX)||(y>Plr[d].LY)) continue;
if (Plr[d].C[x][y]) continue;
if ((rep>=0)&&(Plr[d].B[x][y]!=rep)) continue;
Plr[d].B[x][y]=val; ++tot;
Plr[d].ID[x][y] = ++Plr[d].PartID;
}
if (tot) return make_pair(0x66CCFF,"Placed "+IToS(tot)+" block"+((tot>1)?"s":""));
else return make_pair(0xAAAAAA,"No blocks placed");
}
if (Co[0]=="fill") {
if (Co.size()<5) return make_pair(0xEE0000,"Insufficient values for \'fill\' command");
int xl=SToI(Co[1]), yl=SToI(Co[2]), xr=SToI(Co[3]), yr=SToI(Co[4]), val=154, rep=-1;
if (Co.size()>=6) val=SToI(Co[5]);
if (Co.size()>=7) rep=SToI(Co[6]);
if (xl==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[1]+"\' for \'fill\' command");
if (yl==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for \'fill\' command");
if (xr==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[3]+"\' for \'fill\' command");
if (yr==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[4]+"\' for \'fill\' command");
if (val==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[5]+"\' for \'fill\' command");
if (rep==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[6]+"\' for \'fill\' command");
if (!CheckBlockType(val)) return make_pair(0xEE0000,"\'"+Co[5]+"\' is not a block type");
if ((rep>=0)&&(!CheckBlockType(rep))) return make_pair(0xEE0000,"\'"+Co[6]+"\' is not a block type");
if (xl>xr) swap(xl,xr);
if (yl>yr) swap(yl,yr);
int tot = 0;
for (int d : lst) {
++Plr[d].PartID;
for (int i=1; i<Plr[d].LX; ++i) {
for (int j=1; j<=Plr[d].LY; ++j) {
if (((xl<=i)&&(i<=xr))&&((yl<=j)&&(j<=yr))) {
if (Plr[d].C[i][j]) continue;
if ((rep>=0)&&(Plr[d].B[i][j]!=rep)) continue;
Plr[d].B[i][j]=val; ++tot;
Plr[d].ID[i][j] = Plr[d].PartID;
}
}
}
}
if (tot) return make_pair(0x66CCFF,"Placed "+IToS(tot)+" block"+((tot>1)?"s":""));
else return make_pair(0xAAAAAA,"No blocks placed");
}
if (Co[0]=="garbage") {
int val=1, pos=0;
if (Co.size()>=2) val=SToI(Co[1]);
if (Co.size()>=3) pos=SToI(Co[2]);
if (val==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[1]+"\' for \'garbage\' command");
if (pos==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for \'garbage\' command");
int tot = 0;
for (int d : lst) {
int cn=min(Plr[d].LX,val); tot+=cn;
if (pos) Plr[d].LstHole=pos;
else if (rnd(100)<_SegMess) Plr[d].LstHole=Plr[d].RollHole(_Luck);
Plr[d].AddGarbage(cn, Plr[d].RollGarb());
}
if (tot) return make_pair(0x66CCFF,"Pushed "+IToS(tot)+" garbage line"+((tot>1)?"s":""));
else return make_pair(0xAAAAAA,"No garbage lines pushed");
}
if (Co[0]=="launch") {
string Mode = "home";
if (Co.size()>=2) Mode=Co[1];
ForceLaunch = Mode;
LaunchOpt.clear();
for (int i=2; i<Co.size(); ++i) LaunchOpt.push_back(Co[i]);
return make_pair(0x66CCFF,"Launched mode "+Mode);
}
if (Co[0]=="quit") {
ForceLaunch = "home";
LaunchOpt.clear();
return make_pair(0x66CCFF,"Quit the current game");
}
if (Co[0]=="damage") {
int val=1, pos=0, src=-1;
if (Co.size()>=2) val=SToI(Co[1]);
if (Co.size()>=3) pos=SToI(Co[2]);
if (Co.size()>=4) src=SToI(Co[3]);
if (val==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[1]+"\' for \'damage\' command");
if (pos==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for \'damage\' command");
if (src==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[3]+"\' for \'damage\' command");
int tot=0; val=min(val,1000);
for (int d : lst) {
if (pos) Plr[d].LstHole=pos;
else if (rnd(100)<_SegMess) Plr[d].LstHole=Plr[d].RollHole(_Luck);
lll gb = Plr[d].RollGarb();
Plr[d].Rec.push_back(make_pair(val,make_pair(gb,clock()))); tot+=val;
if (src>=0) Plr[d].LstAtk=src;
}
if (tot) return make_pair(0x66CCFF,"Sent "+IToS(tot)+" attack"+((tot>1)?"s":""));
else return make_pair(0xAAAAAA,"No attack sent");
}
if (Co[0]=="waste") {
int val = 1;
if (Co.size()>=2) val=SToI(Co[1]);
if (val==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[1]+"\' for \'waste\' command");
int tot = 0;
for (int d : lst) {
Plr[d].ForceWaste+=val; tot+=val;
}
return make_pair(0x66CCFF,"Wasted "+IToS(tot)+" piece"+((tot>1)?"s":""));
}
if (Co[0]=="lock") {
int tot = 0;
for (int d : lst) {
Plr[d].ForceLock=true; ++tot;
}
return make_pair(0x66CCFF,"Locked "+IToS(tot)+" piece"+((tot>1)?"s":""));
}
if (Co[0]=="set") {
if (Co.size()<3) return make_pair(0xEE0000,"Insufficient values for \'set\' command");
string ValName=Co[1]; int val=Global.ChangeVal(ValName,((ValName=="width")||(ValName=="height")||(ValName=="realheight"))?4:((ValName=="tar")?0:1));
if (val==ERR) return make_pair(0xEE0000,"Unknown variable \'"+Co[1]+"\' for \'set\' command");
val=SToI(Co[2]); if (Global.ChangeVal(ValName,val)==ERR) return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for \'set\' command");
int tot = 0;
for (int d : lst) {
Plr[d].ChangeVal(ValName,val); ++tot;
}
return make_pair(0x66CCFF,"Changed "+IToS(tot)+" player"+((tot>1)?"s\'":"\'s")+" attribute \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
if (Co[0]=="gamerule") {
if (Co.size()<3) return make_pair(0xEE0000,"Insufficient values for \'gamerule\' command");
if (Co[1]=="spin") {
vector<string> lst = {"allspin","allfull","allsemi","allmini","tspin","default","easy","minionly","none"};
for (string ss : lst) {
if (ss==Co[2]) {
SpinRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="clutch") {
vector<string> lst = {"default","always","none"};
for (string ss : lst) {
if (ss==Co[2]) {
ClutchRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="baseattack") {
vector<string> lst = {"default","asc","classic","arcade","equal","none"};
for (string ss : lst) {
if (ss==Co[2]) {
BaseRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="cleargravity") {
vector<string> lst = {"default","none","sticky","cascade","separate"};
for (string ss : lst) {
if (ss==Co[2]) {
ClearGravity = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="b2b") {
vector<string> lst = {"default","chain","surge","techmino","none"};
for (string ss : lst) {
if (ss==Co[2]) {
B2BRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="combo") {
vector<string> lst = {"multipler","io","default","friends","expert","battle","99","ppt","effect","zone","techmino","c2","aquamino","none"};
for (string ss : lst) {
if (ss==Co[2]) {
ComboRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="rotation") {
vector<string> lst = {"default","extend","srs","srsplus","asc","ascplus","ors","rnrs","lnrs","atari","ars","tetrax","c2","new","none"};
for (string ss : lst) {
if (ss==Co[2]) {
KickTable=ss; InitKick();
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="allclear") {
vector<string> lst = {"default","extend","techmino","quickplay","league","99","arcade","none"};
for (string ss : lst) {
if (ss==Co[2]) {
ACRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="garbagetype") {
vector<string> lst = {"layer","bomb","fall","solid"};
for (string ss : lst) {
if (ss==Co[2]) {
GarbageType = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="garbagemode") {
vector<string> lst = {"combo","attack","lock","instant"};
for (string ss : lst) {
if (ss==Co[2]) {
GarbageMode = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="garbagecancel") {
vector<string> lst = {"default","dig","none"};
for (string ss : lst) {
if (ss==Co[2]) {
GarbageCancel = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="garbageshape") {
vector<string> lst = {"cheese","full","empty","random","bubble","copy","board","clear","arcade"};
for (string ss : lst) {
if (ss==Co[2]) {
GarbageShape = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="garbagebonus") {
vector<string> lst = {"default","io","none"};
for (string ss : lst) {
if (ss==Co[2]) {
GarbageBonus = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="opener") {
vector<string> lst = {"default","io","none"};
for (string ss : lst) {
if (ss==Co[2]) {
OpenerBonus = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="scaletype") {
vector<string> lst = {"default","div","dec","exp"};
for (string ss : lst) {
if (ss==Co[2]) {
LevelRule = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="sequence") {
vector<string> lst = {"random","bag","fixed"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].Sequence=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="initfacing") {
vector<string> lst = {"up","right","down","left"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].InitFacing=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="arcaderound") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
ArcadeRound = vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="observebot") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
ObserveAI = vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="shadow") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].ShowShadow=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="usemove") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowMove=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="userotate") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowRot=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="use2rotate") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].Allow2Rot=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="usehalf") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowHalf=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="usehard") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowHard=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="usesoft") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowSoft=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="usesonic") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowSonic=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="useflip") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowFlip=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="useup") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowUp=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="uselock") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowLock=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="usedeep") {
vector<string> lst = {"false","true"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].AllowDeep=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="targetbonus") {
vector<string> lst = {"default","99","defensive","none"};
for (string ss : lst) {
if (ss==Co[2]) {
TargetBonus = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="badgebonus") {
vector<string> lst = {"default","99","none"};
for (string ss : lst) {
if (ss==Co[2]) {
BadgeBonus = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="hold") {
vector<string> lst = {"none","default","infinity"};
int vv = 0;
for (string ss : lst) {
if (ss==Co[2]) {
for (int i=0; i<Plrs; ++i) Plr[i].HoldRule=vv;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
++vv;
}
}
else if (Co[1]=="innermess") {
int x = SToI(Co[2]);
if (x!=ERR) {
_InnerMess = min(100,x);
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="segmess") {
int x = SToI(Co[2]);
if (x!=ERR) {
_SegMess = min(100,x);
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="garbagedelay") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].GarbDelay=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="garbagerise") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].GarbRise=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="garbagegap") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].GarbageGap=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="garbageluck") {
int x = SToI(Co[2]);
if (x!=ERR) {
_Luck = x-100;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="garbagepreview") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].GarbagePreview=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="openerphrase") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].OpenerPhrase=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="drop") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].BaseDropL=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="lock") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].BaseLockL=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="groundlock") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].GLockL=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="forcelock") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].FLockL=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="reset") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].ResetLim=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="deathare") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].DeathARE=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="are") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].ARE=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="lcd") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LCD=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="drd") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].DRD=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="next") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x<=10)) {
for (int i=0; i<Plrs; ++i) Plr[i].ViewNxt=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="history") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x<=100)) {
for (int i=0; i<Plrs; ++i) Plr[i].His=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="roll") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x)&&(x<=100)) {
for (int i=0; i<Plrs; ++i) Plr[i].Rol=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="extra") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x<=100)) {
for (int i=0; i<Plrs; ++i) Plr[i].Ext=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="width") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x>=2)&&(x<=50)) {
for (int i=0; i<Plrs; ++i) Plr[i].ChangeVal("width",x);
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="height") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x>=2)&&(x<=90)) {
for (int i=0; i<Plrs; ++i) Plr[i].ChangeVal("height",x);
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="realheight") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x>=2)&&(x<=90)) {
for (int i=0; i<Plrs; ++i) Plr[i].ChangeVal("realheight",x);
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="vanish") {
int x = SToI(Co[2]);
if ((x!=ERR)&&(x>=2)&&(x<=90)) {
for (int i=0; i<Plrs; ++i) Plr[i].VanishHeight=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="stock") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].ChangeVal("stock",x);
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelbase") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevBase=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelstart") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevStart=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelline") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevLine=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="leveltime") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevTime=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelpiece") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevPiece=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelattack") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevAttack=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="increaseline") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevLineInc=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="increasetime") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevTimeInc=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="increasepiece") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevPieceInc=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="increaseattack") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].LevAttackInc=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelmaster") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].MasterBeg=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="levelratio") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].Diff=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="wastelimit") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].WasteLim=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="passthrough") {
int x = SToI(Co[2]);
if (x!=ERR) {
for (int i=0; i<Plrs; ++i) Plr[i].Passthrough=x;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="piece") {
vector<int> Bag = TransferBag(Co[2]);
if (Bag.size()) {
DefaultBag=Bag; for (int i=0; i<Plrs; ++i) Plr[i].Bag=Bag;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else return make_pair(0xEE0000,"Unknown gamerule \'"+Co[1]+"\'");
return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for gamerule \'"+Co[1]+"\'");
}
#warning execute
if (Co[0]=="config") {
if (Co.size()<3) return make_pair(0xEE0000,"Insufficient values for \'config\' command");
if (Co[1]=="das") {
int x = SToI(Co[2]);
if (x!=ERR) {
DAS = x;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="dropdas") {
int x = SToI(Co[2]);
if (x!=ERR) {
SDDAS = x;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="arr") {
int x = SToI(Co[2]);
if (x!=ERR) {
ARR = x;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="droparr") {
int x = SToI(Co[2]);
if (x!=ERR) {
SDARR = x;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="dcd") {
int x = SToI(Co[2]);
if (x!=ERR) {
DCD = x;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="hcd") {
int x = SToI(Co[2]);
if (x!=ERR) {
HCD = x;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
else if (Co[1]=="defaultrotate") {
vector<string> lst = {"ccw","cw"};
for (string ss : lst) {
if (ss==Co[2]) {
DefaultRot = ss;
return make_pair(0x66CCFF,"Changed gamerule \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="style") {
vector<string> lst = {"default","simple","arcade","classic"};
for (string ss : lst) {
if (ss==Co[2]) {
Style = ss;
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="moveeffect") {
vector<string> lst = {"true","false"};
for (string ss : lst) {
if (ss==Co[2]) {
MoveEff = (ss=="true");
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="spineffect") {
vector<string> lst = {"true","false"};
for (string ss : lst) {
if (ss==Co[2]) {
SpinEff = (ss=="true");
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="dropeffect") {
vector<string> lst = {"true","false"};
for (string ss : lst) {
if (ss==Co[2]) {
DropEff = (ss=="true");
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else if (Co[1]=="rotateeffect") {
vector<string> lst = {"true","false"};
for (string ss : lst) {
if (ss==Co[2]) {
RotEff = (ss=="true");
return make_pair(0x66CCFF,"Changed config \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
}
}
else return make_pair(0xEE0000,"Unknown config \'"+Co[1]+"\'");
return make_pair(0xEE0000,"Invalid value \'"+Co[2]+"\' for config \'"+Co[1]+"\'");
}
if (Co[0]=="keymap") {
if (Co.size()<3) return make_pair(0xEE0000,"Insufficient values for \'keymap\' command");
int Key = AskKey(Co[2]);
if (!Key) return make_pair(0xEE0000,"Invalid key name \'"+Co[2]+"\'");
string Op=Co[1]; bool Suc=false;
if (Op=="left") {
Suc=true; KEY_LEFT=Key;
}
if (Op=="right") {
Suc=true; KEY_RIGHT=Key;
}
if (Op=="down") {
Suc=true; KEY_DOWN=Key;
}
if (Op=="drop") {
Suc=true; KEY_HARD=Key;
}
if (Op=="sonic") {
Suc=true; KEY_SONIC=Key;
}
if (Op=="flip") {
Suc=true; KEY_FLIP=Key;
}
if (Op=="up") {
Suc=true; KEY_UP=Key;
}
if (Op=="waste") {
Suc=true; KEY_WASTE=Key;
}
if (Op=="rotate") {
Suc=true; KEY_ROT=Key;
}
if (Op=="cw") {
Suc=true; KEY_CW=Key;
}
if (Op=="ccw") {
Suc=true; KEY_CCW=Key;
}
if (Op=="half") {
Suc=true; KEY_180=Key;
}
if (Op=="hold") {
Suc=true; KEY_HOLD=Key;
}
if (Op=="even") {
Suc=true; KEY_EVEN=Key;
}
if (Op=="ko") {
Suc=true; KEY_KO=Key;
}
if (Op=="random") {
Suc=true; KEY_RANDOM=Key;
}
if (Op=="payback") {
Suc=true; KEY_PAYBACK=Key;
}
if (Op=="badge") {
Suc=true; KEY_BADGE=Key;
}
if (Op=="attacker") {
Suc=true; KEY_ATTACKERS=Key;
}
if (Op=="undo") {
Suc=true; KEY_UNDO=Key;
}
if (Op=="retry") {
Suc=true; KEY_RETRY=Key;
}
if (Op=="reset") {
Suc=true; KEY_RESET=Key;
}
if (Op=="lock") {
Suc=true; KEY_LOCK=Key;
}
if (Suc) {
for (int i=0; i<Plrs; ++i) Plr[i].ReloadKey();
return make_pair(0x66CCFF,"Changed key mapping of \'"+Co[1]+"\' to \'"+Co[2]+"\'");
}
else return make_pair(0xEE0000,"Invalid operation name \'"+Co[1]+"\'");
}
if (Co[0]=="spectate") {
int val = -1;
if (Co.size()>=2) val=SToI(Co[1]);
if (val==-1) {
for (int d : lst) {
if (!Plr[d].Over) {
Obs=d; return make_pair(0x66CCFF,"Spectating player "+IToS(d));
}
}
return make_pair(0xEE0000,"All targets are over");
}
if ((val<0)||(val>=Plrs)) return make_pair(0xEE0000,"Player \'"+Co[1]+"\' didn\'t exist");
if (Plr[val].Over) return make_pair(0xEE0000,"Player "+IToS(val)+" is over");
Obs=val; return make_pair(0x66CCFF,"Spectating player "+IToS(val));
}
return make_pair(0xEE0000,"Unknown command \'"+Co[0]+"\'");
}
pair<int,string> Execute(vector<string> Co) {
pair<int,string> res = ExecuteProcess(Co);
if ((Zen)&&(res.first!=0xEE0000)) Storage=true;
return res;
}
ClassPiece RotatePiece(ClassPiece x) {
ClassPiece res;
res.clr=x.clr; res.LX=x.LY; res.LY=x.LX; res.SDel=x.SDel;
res.FstX=res.FstY=-1;
for (int i=0; i<x.LX; ++i) {
for (int j=0; j<x.LY; ++j) res.B[x.LY-j-1][i]=x.B[i][j];
}
for (int i=0; i<res.LX; ++i) {
for (int j=0; j<res.LY; ++j) {
if ((res.FstX<0)&&(res.B[i][j])) {
res.FstX=i; res.FstY=j;
}
}
}
return res;
}
int StoragePos=1, StorageTot=1;
void Launch(string Mode="home") {
ForceExecute = "";;
Obs = -1;
_TIME = time(0);
Plrs = 1;
Storage=Undo=ForceRound=ForceAbort=false;
DisAtk = true;
UseAI = 0;
AddTp = 1;
Zen=QuickPlay=Arcade=false;
memset(KOCount, 0, sizeof(KOCount));
StoragePos=StorageTot=1;
DefaultBag = {1,2,3,4,5,6,7};
RoundTot = 0;
memset(TarRem, 0, sizeof(TarRem));
memset(ShiftCD, 0, sizeof(ShiftCD));
SpinRule = "allspin";
ClutchRule = "default";
BaseRule = "default";
ClearGravity = "default";
B2BRule = "surge";
ComboRule = "multipler";
KickTable = "default";
ACRule = "default";
GarbageType = "layer";
GarbageMode = "combo";
GarbageCancel = "default";
GarbageShape = "cheese";
GarbageBonus = "default";
OpenerBonus = "default";
LevelRule = "default";
ArcadeRound = "false";
ObserveAI = true;
TargetBonus = "default";
BadgeBonus = "default";
_InnerMess = 0;
_SegMess = 100;
_Luck = 0;
if (Mode=="battle") Plrs=2;
bool AllBot = false;
if (Mode=="zenzenith") QuickPlay=Zen=true;
if (Mode=="bot") AllBot=true;
if (Mode=="zenith") QuickPlay=true;
if (Mode=="botzenith") AllBot=QuickPlay=true;
for (string str : LaunchOpt) {
for (int i=2; i<=100; ++i) {
if (str==IToS(i)+"p") Plrs=i;
}
if (str=="mm4") DefaultBag={1,2,4,5,6};
if (str=="mm5") DefaultBag=TransferBag("ehi5j5prs5t5uvwx");
if (str=="mm6") DefaultBag=TransferBag("k30k31k32k33k34k35k36k37k38k39k40k42k44k46k48k50k52k54k56k58k60k62k64k66k68k70k72k74k76k78k80k82k84k86k88");
if (str=="mm45") DefaultBag=TransferBag("ijostehi5j5prs5t5uvwx");
if (str=="mm12345") DefaultBag=TransferBag("abcijostehi5j5prs5t5uvwx");
if (str=="mm123456") DefaultBag=TransferBag("abcijostehi5j5prs5t5uvwxk30k31k32k33k34k35k36k37k38k39k40k42k44k46k48k50k52k54k56k58k60k62k64k66k68k70k72k74k76k78k80k82k84k86k88");
if (str=="m45") {
DefaultBag.clear();
for (int i=1; i<8; ++i) DefaultBag.push_back(i);
for (int i=12; i<30; ++i) DefaultBag.push_back(i);
}
if (str=="m5") {
DefaultBag.clear();
for (int i=12; i<30; ++i) DefaultBag.push_back(i);
}
if (str=="m6") {
DefaultBag.clear();
for (int i=30; i<90; ++i) DefaultBag.push_back(i);
}
if (str=="m123") {
DefaultBag.clear();
for (int i=8; i<12; ++i) DefaultBag.push_back(i);
}
if (str=="m1234") {
DefaultBag.clear();
for (int i=1; i<12; ++i) DefaultBag.push_back(i);
}
if (str=="m12345") {
DefaultBag.clear();
for (int i=1; i<30; ++i) DefaultBag.push_back(i);
}
if (str=="m123456") {
DefaultBag.clear();
for (int i=1; i<90; ++i) DefaultBag.push_back(i);
}
}
for (int i=0; i<Plrs; ++i) {
Plr[i] = Board(6, 40, 10, 22, 0.0, (Plrs==1)?400.0:0.0, ((i+1<Plrs)||(AllBot)), 300);
Plr[i].ClearAll(_TIME);
Plr[i].ReloadKey();
}
if (Plrs>1) KickTable="extend";
if (AllBot) KickTable="ascplus";
if (Plrs>2) {
for (int i=0; i+1<Plrs; ++i) {
Plr[i].OperTime=100+(1000/Plrs)*i; Plr[i].Plr=6-(i%6);
if ((Plr[i].Plr==2)||(Plr[i].Plr==3)) Plr[i].Plr=6;
if (((Plr[i].Plr==2)||(Plr[i].Plr==3)||(Plr[i].Plr==5)||(Plr[i].Plr==4))&&(Plr[i].OperTime<300)) {
if (QuickPlay) Plr[i].Plr=6;
}
if ((Plr[i].Plr==6)&&(QuickPlay)) Plr[i].ModSpin=!(i&((Plr[Plrs-1].Bot)?7:1));
Plr[i].OperTime = max(150,Plr[i].OperTime);
Plr[i].GarbRise = 100;
}
}
else if (Plrs==2) {
Plr[0].Plr=6; Plr[0].OperTime=300;
}
if ((Mode=="classic")||(Mode=="zenclassic")) {
KickTable = "rnrs";
ClutchRule = "none";
Plr[0].DeathARE = 0;
if (Mode=="zenclassic") Zen=true;
Plr[0].LevLine = 10;
Plr[0].MasterBeg = 99999999;
Plr[0].HoldRule = 0;
Plr[0].His=1; Plr[0].Rol=2; Plr[0].ViewNxt=1;
Plr[0].Sequence = 0;
Plr[0].Plr = 1;
Plr[0].Allow2Rot=Plr[0].AllowHalf=Plr[0].AllowHard=Plr[0].AllowSonic=false;
Plr[0].ResetLim = 0;
}
if ((Mode=="arcade")||(Mode=="zenarcade")) {
KickTable = "srsplus";
SpinRule = "easy";
ClutchRule = "none";
B2BRule = "default";
Plr[0].DeathARE = 0;
Arcade = true;
if (Mode=="zenarcade") Zen=true;
Plr[0].His=1; Plr[0].Rol=2; Plr[0].ViewNxt=3;
Plr[0].Sequence = 0;
Plr[0].Plr = 4;
Plr[0].AllowHalf = false;
}
if (Mode=="zen") {
Zen=true; ClutchRule="always";
Plr[0].LCD = 200;
}
if (Mode=="marathon") {
Plr[0].LevLine = 10;
}
if (Mode=="sprint") Plr[0].TarLine=40;
if (Mode=="ultra") Plr[0].TarTime=120000;
if (Mode=="dig") Plr[0].StaticHeight=10;
if (Mode=="survive") {
Plr[0].StaticHeight=99999999; Plr[0].GarbRise=1500;
}
if (Mode=="zenithsprint") {
QuickPlay=true; Plr[0].TarScore=1650000;
}
if (Zen) {
BegDelay = 0;
Plr[0].BaseLockL=Plr[0].ResetLim=99999999;
Plr[0].HoldRule = 2;
}
if ((QuickPlay)&&((Plrs>1)||(Zen))) SpinRule="allmini";
for (string str : LaunchOpt) {
for (int i=2; i<=50; ++i) {
if (str==IToS(i)+"w") {
for (int j=0; j<Plrs; ++j) {
Plr[j].LY = i;
if (i<4) Plr[j].InitFacing=3;
}
}
}
for (int i=2; i<=80; ++i) {
if (str==IToS(i)+"h") {
for (int j=0; j<Plrs; ++j) {
Plr[j].DX=i+2; Plr[j].LX=max(Plr[j].LX,i+10);
}
}
}
for (int i=1; i<=10000; ++i) {
if (str==IToS(i)+"gr") {
for (int j=0; j<Plrs; ++j) Plr[j].GarbRise=i;
}
}
for (int i=1; i<=10000; ++i) {
if (str==IToS(i)+"l") {
for (int j=0; j<Plrs; ++j) Plr[j].TarLine=i;
}
}
for (int i=1; i<=10000; ++i) {
if (str==IToS(i)+"s") {
for (int j=0; j<Plrs; ++j) Plr[j].TarTime=i*1000;
}
}
for (int i=0; i<=10000; ++i) {
if (str==IToS(i)+"sp") {
for (int j=0; j<Plrs; ++j) Plr[j].OperTime=i;
}
}
if (str=="master") {
for (int j=0; j<Plrs; ++j) {
Plr[j].LevStart=max(Plr[j].LevStart,1); Plr[j].MasterBeg=1;
}
}
for (int i=1; i<=99; ++i) {
if (str=="lv"+IToS(i)) {
for (int j=0; j<Plrs; ++j) Plr[j].LevStart=i;
}
}
for (int i=1; i<=99; ++i) {
if (str==IToS(i)+"lvb") {
for (int j=0; j<Plrs; ++j) Plr[j].LevBase=i;
}
}
for (int i=0; i<=1000; ++i) {
if (str==IToS(i)+"lvl") {
for (int j=0; j<Plrs; ++j) Plr[j].LevLine=i;
}
}
for (int i=0; i<=1000; ++i) {
if (str==IToS(i)+"lvli") {
for (int j=0; j<Plrs; ++j) Plr[j].LevLineInc=i;
}
}
if (str=="srs") KickTable="srs";
if (str=="asc") KickTable="asc";
if (str=="srsplus") KickTable="srsplus";
if (str=="c2rs") KickTable="c2";
if (str=="defrs") KickTable="default";
if (str=="extrs") KickTable="extend";
if (str=="ascplus") KickTable="ascplus";
if (str=="tetrax") KickTable="tetrax";
if (str=="ars") {
KickTable = "ars";
for (int i=0; i<Plrs; ++i) Plr[i].InitFacing=2;
}
if (str=="ors") {
KickTable = "ors";
for (int i=0; i<Plrs; ++i) Plr[i].InitFacing=2;
}
if (str=="lnrs") {
KickTable = "lnrs";
for (int i=0; i<Plrs; ++i) Plr[i].InitFacing=2;
}
if ((str=="rnrs")||(str=="nrs")) {
KickTable = "rnrs";
for (int i=0; i<Plrs; ++i) Plr[i].InitFacing=2;
}
if (str=="deep") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowDeep=true;
}
if (str=="flip") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowFlip=true;
}
if (str=="up") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowUp=true;
}
if (str=="lock") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowLock=true;
}
if (str=="hold") {
for (int i=0; i<Plrs; ++i) Plr[i].HoldRule=1;
}
if (str=="nohold") {
for (int i=0; i<Plrs; ++i) Plr[i].HoldRule=0;
}
if (str=="infhold") {
for (int i=0; i<Plrs; ++i) Plr[i].HoldRule=2;
}
if (str=="allclutch") ClutchRule="always";
if (str=="noclutch") ClutchRule="none";
if (str=="clutch") ClutchRule="default";
if (str=="pack") {
for (int i=0; i<Plrs; ++i) Plr[i].RoundHeight=9999;
}
if (str=="nomove") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowMove=false;
}
if (str=="norot") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowRot=false;
}
if (str=="no2rot") {
for (int i=0; i<Plrs; ++i) Plr[i].Allow2Rot=false;
}
if (str=="2rot") {
for (int i=0; i<Plrs; ++i) Plr[i].Allow2Rot=true;
}
if (str=="nohalf") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowHalf=false;
}
if (str=="half") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowHalf=true;
}
if (str=="nohard") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowHard=false;
}
if (str=="hard") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowHard=true;
}
if (str=="nosonic") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowSonic=false;
}
if (str=="sonic") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowSonic=true;
}
if (str=="nosoft") {
for (int i=0; i<Plrs; ++i) Plr[i].AllowSoft=false;
}
if (str=="cascade") ClearGravity="separate";
}
if ((Plrs==1)&&(!QuickPlay)&&(!Zen)) DisAtk=false;
if (Mode=="home") Plrs=0;
LaunchOpt.clear();
// -- after --
InitKick();
if (Zen) {
Plr[1] = Plr[0];
}
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int iCmdShow) {
for (int i=0; i<Floor.size(); ++i) Floor[i]*=1000LL;
GradeBonus[0] = {0};
GradeBonus[1] = {10,10,10,10,10,5,5,5,5,5,2};
GradeBonus[2] = {20,20,20,15,15,15,10,10,10,10,12};
GradeBonus[3] = {40,30,30,30,20,20,20,15,15,15,13};
GradeBonus[4] = {50,40,40,40,40,30};
ComboMul[0] = {0};
ComboMul[1] = {0,2,2,4,4,4,4,5,5,10};
ComboMul[2] = {0,4,5,6,7,8,9,10,11,15};
ComboMul[3] = {0,5,8,10,12,13,14,15,16,20};
ComboMul[4] = {0,5,8,10,12,13,14,15,16,20};
for (int i=0; i<GradeDec.size(); ++i) GradeDec[i]=GradeDec[i]*5/3;
for (int i=0; i<ArcadeAre.size(); ++i) ArcadeAre[i]=ArcadeAre[i]*50/3;
for (int i=0; i<ArcadeLcd.size(); ++i) ArcadeLcd[i]=ArcadeLcd[i]*50/3;
for (int i=0; i<ArcadeLock.size(); ++i) ArcadeLock[i]=ArcadeLock[i]*50/3;
for (int i=0; i<CoolTm.size(); ++i) CoolTm[i]*=1000;
for (int i=0; i<RegretTm.size(); ++i) RegretTm[i]*=1000;
WNDCLASS wc;
HWND hWnd;
HDC hDC;
HGLRC hRC;
MSG msg;
BOOL bQuit = FALSE;
wc.style = CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = HBRUSH(GetStockObject (BLACK_BRUSH));
wc.lpszMenuName = NULL;
wc.lpszClassName = "GLSample";
RegisterClass(&wc);
//hWnd = GetConsoleWindow();
hWnd = CreateWindow("GLSample", "qqwq", WS_CAPTION|WS_POPUPWINDOW|WS_VISIBLE, 0, 0, 1500, 1000, NULL, NULL, hInstance, NULL);
EnableOpenGL(hWnd, &hDC, &hRC);
InitChar(); Global.sz=1;
for (int i=1; i<155; ++i) Flip[i]=i;
#define FL(i, j) Flip[i]=j, Flip[j]=i
Piece[1][0] = ClassPiece(4,4,0x66CCFF,-1,{{0,0,0,0},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
Piece[2][0] = ClassPiece(3,3,0x0080FF,-1,{{1,0,0},{1,1,1},{0,0,0}});
Piece[3][0] = ClassPiece(3,3,0xFFA500,-1,{{0,0,1},{1,1,1},{0,0,0}});
Piece[4][0] = ClassPiece(3,3,0xFFE211,-1,{{0,1,1},{0,1,1},{0,0,0}});
Piece[5][0] = ClassPiece(3,3,Mix(0x000000,0x33EE00,0.1),-1,{{0,1,1},{1,1,0},{0,0,0}});
Piece[6][0] = ClassPiece(3,3,0xEE82EE,-1,{{0,1,0},{1,1,1},{0,0,0}});
Piece[7][0] = ClassPiece(3,3,0xEE0000,-1,{{1,1,0},{0,1,1},{0,0,0}});
FL(2, 3);
FL(5, 7);
Piece[8][0] = ClassPiece(2,2,0xFFAFBE,0,{{1,0},{1,1}});
Piece[9][0] = ClassPiece(3,3,Mix(0x000000,0x00FFCC,0.1),0,{{0,0,0},{1,1,1},{0,0,0}});
Piece[10][0] = ClassPiece(2,2,Mix(0x000000,0x99FFFF,0.1),0,{{1,1},{0,0}});
Piece[11][0] = ClassPiece(2,2,0x006666,0,{{0,1},{0,0}});
Piece[12][0] = ClassPiece(5,5,0x66CCAA,-1,{{0,0,0,0,0},{0,0,0,0,0},{1,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
Piece[13][0] = ClassPiece(3,3,0xDF3782,0,{{0,1,0},{0,1,0},{1,1,1}});
Piece[14][0] = ClassPiece(3,3,0xB17D43,-1,{{1,0,1},{1,1,1},{0,0,0}});
Piece[15][0] = ClassPiece(3,3,0x9E00FF,0,{{0,0,1},{0,0,1},{1,1,1}});
Piece[16][0] = ClassPiece(4,4,0x9999FF,-1,{{0,0,1,0},{0,1,1,1},{0,0,1,0},{0,0,0,0}});
Piece[17][0] = ClassPiece(3,3,0xD29700,0,{{1,0,0},{1,1,1},{0,1,0}});
Piece[18][0] = ClassPiece(3,3,0x00AAAA,0,{{0,0,1},{1,1,1},{0,1,0}});
FL(17, 18);
Piece[19][0] = ClassPiece(3,3,0x00AA00,0,{{1,0,0},{1,1,1},{0,0,1}});
Piece[20][0] = ClassPiece(3,3,0xAA0000,0,{{0,0,1},{1,1,1},{1,0,0}});
FL(19, 20);
Piece[21][0] = ClassPiece(4,4,0x3333FF,-1,{{0,0,0,0},{1,0,0,0},{1,1,1,1},{0,0,0,0}});
Piece[22][0] = ClassPiece(4,4,0xFF5000,-1,{{0,0,0,0},{0,0,0,1},{1,1,1,1},{0,0,0,0}});
FL(21, 22);
Piece[23][0] = ClassPiece(4,4,0x00AAFF,-1,{{0,0,0,0},{0,0,1,0},{1,1,1,1},{0,0,0,0}});
Piece[24][0] = ClassPiece(4,4,0xCC99FF,-1,{{0,0,0,0},{0,1,0,0},{1,1,1,1},{0,0,0,0}});
FL(23, 24);
Piece[25][0] = ClassPiece(4,4,Mix(0x000000,0xAAFF66,0.1),-1,{{0,0,0,0},{0,0,1,1},{1,1,1,0},{0,0,0,0}});
Piece[26][0] = ClassPiece(4,4,0xFF6666,-1,{{0,0,0,0},{1,1,0,0},{0,1,1,1},{0,0,0,0}});
FL(25, 26);
Piece[27][0] = ClassPiece(3,3,0xCCCC00,-1,{{0,1,1},{1,1,1},{0,0,0}});
Piece[28][0] = ClassPiece(3,3,0xFCC000,-1,{{1,1,0},{1,1,1},{0,0,0}});
FL(27, 28);
Piece[29][0] = ClassPiece(3,3,0x5F630E,0,{{0,0,1},{0,1,1},{1,1,0}});
PName[30]=132; Piece[30][0]=ClassPiece(6,6,0x96D6CB,-2,{{0,0,0,0,0,0},{0,0,0,0,0,0},{1,1,1,1,1,1},{0,0,0,0,0,0},{0,0,0,0,0,0},{0,0,0,0,0,0}});
Char[132] = {"hw"};
PName[31]='d'; Piece[31][0]=ClassPiece(4,4,0x62FFE0,-2,{{0,1,1,0},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
PName[32]=133; Piece[32][0]=ClassPiece(3,3,0xEB22B9,0,{{0,1,0},{1,1,1},{1,1,0}});
Char[133] = {"jt10ukghny3"};
PName[33]='0'; Piece[33][0]=ClassPiece(3,3,0xCCCC99,-1,{{1,1,1},{1,1,1},{0,0,0}});
PName[34]='e'; Piece[34][0]=ClassPiece(3,3,0xC4A179,0,{{1,0,0},{1,1,0},{1,1,1}});
PName[35]=134; Piece[35][0]=ClassPiece(4,4,0x9A1751,-1,{{0,0,0,1},{1,1,1,1},{0,0,0,1},{0,0,0,0}});
Char[134] = {"kgj","hw23"};
PName[36]='x'; Piece[36][0]=ClassPiece(4,4,0xD1D1FF,-1,{{0,0,1,0},{1,1,1,1},{0,0,1,0},{0,0,0,0}});
PName[37]=145; Piece[37][0]=ClassPiece(3,3,0x006F9B,0,{{0,1,0},{1,1,1},{1,0,1}});
Char[145] = {"akqsoe","c6"};
PName[38]='c'; Piece[38][0]=ClassPiece(4,4,0xF3BDBD,-2,{{1,0,0,1},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
PName[39]='|'; Piece[39][0]=ClassPiece(5,5,0x686998,-2,{{0,0,0,0,0},{0,0,1,0,0},{1,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
PName[40]=135; Piece[40][0]=ClassPiece(5,5,0xFFD17C,-2,{{0,0,0,0,0},{0,0,0,0,1},{1,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
Char[135] = {"a452squ"};
PName[41]=136; Piece[41][0]=ClassPiece(5,5,0x48A4FF,-2,{{0,0,0,0,0},{1,0,0,0,0},{1,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
Char[136] = {"d265zvx"};
PName[42]='y'; Piece[42][0]=ClassPiece(5,5,0xB59ECD,-2,{{0,0,0,0,0},{0,1,0,0,0},{1,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
PName[43]='1'; Piece[43][0]=ClassPiece(5,5,0x7ED0F8,-2,{{0,0,0,0,0},{0,0,0,1,0},{1,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
PName[44]='n'; Piece[44][0]=ClassPiece(5,5,0xFF8F66,-2,{{0,0,0,0,0},{1,1,0,0,0},{0,1,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
PName[45]='h'; Piece[45][0]=ClassPiece(5,5,0x7ECD3F,-2,{{0,0,0,0,0},{0,0,0,1,1},{1,1,1,1,0},{0,0,0,0,0},{0,0,0,0,0}});
PName[46]='p'; Piece[46][0]=ClassPiece(4,4,0xCBB344,-2,{{1,1,0,0},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
PName[47]='q'; Piece[47][0]=ClassPiece(4,4,0xDCE654,-2,{{0,0,1,1},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
PName[48]='f'; Piece[48][0]=ClassPiece(4,4,0x3A96B5,-2,{{1,0,1,0},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
PName[49]=137; Piece[49][0]=ClassPiece(4,4,0xE2B977,-2,{{0,1,0,1},{1,1,1,1},{0,0,0,0},{0,0,0,0}});
Char[137] = {"ae","d7","nkp"};
PName[50]='<'; Piece[50][0]=ClassPiece(4,4,0xFFBF00,-1,{{0,0,0,1},{0,0,0,1},{1,1,1,1},{0,0,0,0}});
PName[51]='>'; Piece[51][0]=ClassPiece(4,4,0x93B0CC,-1,{{1,0,0,0},{1,0,0,0},{1,1,1,1},{0,0,0,0}});
PName[52]='r'; Piece[52][0]=ClassPiece(4,4,0xA879A7,-1,{{0,1,0,0},{0,1,0,0},{1,1,1,1},{0,0,0,0}});
PName[53]=138; Piece[53][0]=ClassPiece(4,4,0xC6F82F,-1,{{0,0,1,0},{0,0,1,0},{1,1,1,1},{0,0,0,0}});
Char[138] = {"bco3","iq0"};
PName[54]=139; Piece[54][0]=ClassPiece(4,4,0x1D9C58,-1,{{1,0,0,0},{1,1,1,1},{0,1,0,0},{0,0,0,0}});
Char[139] = {"afxz","hn","io"};
PName[55]=140; Piece[55][0]=ClassPiece(4,4,0xED396F,-1,{{0,0,0,1},{1,1,1,1},{0,0,1,0},{0,0,0,0}});
Char[140] = {"pmy","io","dj"};
PName[56]='7'; Piece[56][0]=ClassPiece(4,4,0x8F9878,-1,{{0,1,0,0},{1,1,1,1},{0,0,0,1},{0,0,0,0}});
PName[57]=141; Piece[57][0]=ClassPiece(4,4,0x92837C,-1,{{0,0,1,0},{1,1,1,1},{1,0,0,0},{0,0,0,0}});
Char[141] = {"ae","dswqv7"};
PName[58]=142; Piece[58][0]=ClassPiece(4,4,0x72FF72,-1,{{1,0,0,0},{1,1,1,1},{0,0,0,1},{0,0,0,0}});
Char[142] = {"jdh6:4"};
PName[59]=143; Piece[59][0]=ClassPiece(4,4,0xFF9999,-1,{{0,0,0,1},{1,1,1,1},{1,0,0,0},{0,0,0,0}});
Char[143] = {"aepu028<"};
PName[60]='$'; Piece[60][0]=ClassPiece(4,4,0xE1CD68,-1,{{0,1,0,0},{1,1,1,1},{0,0,1,0},{0,0,0,0}});
PName[61]='%'; Piece[61][0]=ClassPiece(4,4,0x658666,-1,{{0,0,1,0},{1,1,1,1},{0,1,0,0},{0,0,0,0}});
PName[62]='4'; Piece[62][0]=ClassPiece(4,4,0x6B3131,-1,{{0,0,1,0},{0,0,1,1},{1,1,1,0},{0,0,0,0}});
PName[63]=144; Piece[63][0]=ClassPiece(4,4,0x6B5531,-1,{{0,1,0,0},{1,1,0,0},{0,1,1,1},{0,0,0,0}});
Char[144] = {"ko","l04","n28"};
PName[64]='G'; Piece[64][0]=ClassPiece(4,4,0xD44AD6,-1,{{0,0,0,0},{0,1,1,1},{1,1,0,1},{0,0,0,0}});
PName[65]='?'; Piece[65][0]=ClassPiece(4,4,0xB56AFF,-1,{{0,0,0,0},{1,1,1,0},{1,0,1,1},{0,0,0,0}});
PName[66]='/'; Piece[66][0]=ClassPiece(5,5,0xA8C080,-2,{{0,0,0,0,0},{1,1,1,0,0},{0,0,1,1,1},{0,0,0,0,0},{0,0,0,0,0}});
PName[67]='\\'; Piece[67][0]=ClassPiece(5,5,0xA8C09F,-2,{{0,0,0,0,0},{0,0,1,1,1},{1,1,1,0,0},{0,0,0,0,0},{0,0,0,0,0}});
PName[68]=146; Piece[68][0]=ClassPiece(4,4,0x3B5224,-2,{{0,0,0,0},{1,1,1,0},{0,1,1,1},{0,0,0,0}});
Char[146] = {"gku02yoig","c6"};
PName[69]=147; Piece[69][0]=ClassPiece(4,4,0x114514,-1,{{0,0,0,0},{0,1,1,1},{1,1,1,0},{0,0,0,0}});
Char[147] = {"b0x","qn<"};
PName[70]=148; Piece[70][0]=ClassPiece(4,4,0x5F3C91,-1,{{0,0,1,1},{1,1,1,0},{0,0,1,0},{0,0,0,0}});
Char[148] = {"fbhs","eow6"};
PName[71]=149; Piece[71][0]=ClassPiece(4,4,0x913C72,-1,{{1,1,0,0},{0,1,1,1},{0,1,0,0},{0,0,0,0}});
Char[149] = {"bfpvxtjdh;"};
PName[72]='K'; Piece[72][0]=ClassPiece(3,3,0x8CE7CC,0,{{1,1,0},{1,1,1},{1,0,0}});
PName[73]=150; Piece[73][0]=ClassPiece(3,3,0x96DCFF,0,{{0,1,1},{1,1,1},{0,0,1}});
Char[150] = {"ae","d7","blrs"};
PName[74]=151; Piece[74][0]=ClassPiece(4,4,0x5E91D8,-1,{{0,1,0,0},{1,1,1,0},{0,0,1,1},{0,0,0,0}});
Char[151] = {"gku0wr","w2yoi"};
PName[75]=152; Piece[75][0]=ClassPiece(4,4,0xCC5DE8,-1,{{0,0,1,0},{0,1,1,1},{1,1,0,0},{0,0,0,0}});
Char[152] = {"dbfln","lpz57=A"};
PName[76]='2'; Piece[76][0]=ClassPiece(4,4,0x65CF70,-1,{{1,1,0,0},{0,1,0,0},{0,1,1,1},{0,0,0,0}});
PName[77]='5'; Piece[77][0]=ClassPiece(4,4,0x65B3CF,-1,{{0,0,1,1},{0,0,1,0},{1,1,1,0},{0,0,0,0}});
PName[78]='{'; Piece[78][0]=ClassPiece(4,4,0x6D6D14,-1,{{1,0,0,0},{1,1,0,0},{0,1,1,1},{0,0,0,0}});
PName[79]='}'; Piece[79][0]=ClassPiece(4,4,0x64334B,-1,{{0,0,0,1},{0,0,1,1},{1,1,1,0},{0,0,0,0}});
PName[80]=153; Piece[80][0]=ClassPiece(3,3,0xA2FF00,0,{{0,0,1},{1,0,1},{1,1,1}});
Char[153] = {"4ko8"};
PName[81]='u'; Piece[81][0]=ClassPiece(3,3,0x1CFF18,0,{{1,0,0},{1,0,1},{1,1,1}});
PName[82]=154; Piece[82][0]=ClassPiece(3,3,0x18E0FF,0,{{1,0,0},{1,1,1},{1,0,1}});
Char[154] = {"fz","kghn<B"};
PName[83]=155; Piece[83][0]=ClassPiece(3,3,0x5D54FF,0,{{0,0,1},{1,1,1},{1,0,1}});
Char[155] = {"akqrn","d28"};
PName[84]=156; Piece[84][0]=ClassPiece(4,4,0xBA4C4C,-1,{{1,0,0,0},{1,1,1,0},{0,0,1,1},{0,0,0,0}});
Char[156] = {"ear48"};
PName[85]=157; Piece[85][0]=ClassPiece(4,4,0xBAA147,-1,{{0,0,0,1},{0,1,1,1},{1,1,0,0},{0,0,0,0}});
Char[157] = {"dbfpvx37"};
PName[86]=158; Piece[86][0]=ClassPiece(3,3,0x7B60D3,0,{{0,1,1},{1,1,0},{1,1,0}});
Char[158] = {"ms265zplo"};
PName[87]='a'; Piece[87][0]=ClassPiece(3,3,0x60D395,0,{{1,1,0},{0,1,1},{0,1,1}});
PName[88]='M'; Piece[88][0]=ClassPiece(4,4,0x834BEB,-1,{{1,1,0,0},{0,1,1,0},{0,0,1,1},{0,0,0,0}});
PName[89]='m'; Piece[89][0]=ClassPiece(4,4,0xBC79B9,-1,{{0,0,1,1},{0,1,1,0},{1,1,0,0},{0,0,0,0}});
for (int i=40; i<=80; i+=2) FL(i,i+1);
PName[90]='@'; Piece[90][0]=ClassPiece(4,4,0xCCCCCC,-1,{{0,1,1,1},{0,1,1,1},{0,1,1,1},{0,0,0,0}});
PName[91]='o'; Piece[91][0]=ClassPiece(4,4,0xAAAAAA,-1,{{0,1,1,1},{0,1,0,1},{0,1,1,1},{0,0,0,0}});
PName[92]='^'; Piece[92][0]=ClassPiece(3,3,0xCDA9A9,-1,{{0,1,0},{1,0,1},{0,0,0}});
PName[93]=','; Piece[93][0]=ClassPiece(3,3,0x45C9AE,-1,{{1,0,0},{0,1,0},{0,0,0}});
PName[94]=':'; Piece[94][0]=ClassPiece(3,3,0x7EAEC8,-1,{{0,0,0},{1,0,1},{0,0,0}});
PName[95]='('; Piece[95][0]=ClassPiece(3,3,0xC2C25B,-1,{{1,0,0},{0,1,1},{0,0,0}});
PName[96]=')'; Piece[96][0]=ClassPiece(3,3,0xD3D38D,-1,{{0,0,1},{1,1,0},{0,0,0}});
FL(95, 96);
PName[97]=';'; Piece[97][0]=ClassPiece(4,4,0x6F8F79,-1,{{0,0,0,0},{1,1,0,1},{0,0,0,0},{0,0,0,0}});
PName[98]='['; Piece[98][0]=ClassPiece(3,3,0x9CC199,-1,{{0,0,1},{1,0,1},{0,0,0}});
PName[99]=']'; Piece[99][0]=ClassPiece(3,3,0x999FC1,-1,{{1,0,0},{1,0,1},{0,0,0}});
FL(98, 99);
PName[100]='#'; Piece[100][0]=ClassPiece(3,3,0x229468,-1,{{1,0,1},{1,0,1},{0,0,0}});
#undef FL
/*
a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
z 0 1 2 3
4 5 6 7 8
9 : ; < =
> ? @ A B
C D E F G
*/
#warning piece
Piece[151][0] = ClassPiece(1,1,0xFFFF99,-1,{{1}});
Piece[152][0] = ClassPiece(1,1,0x8800FF,-1,{{1}});
Piece[153][0] = ClassPiece(1,1,0x444444,-1,{{1}});
Piece[154][0] = ClassPiece(1,1,0x888888,-1,{{1}});
PName[151]=128; PName[152]=129;
PName[153]=130; PName[154]=131;
Char[128] = {"mh","nj","st","x3","w1","vz","qp","lf"};
Char[129] = {"acm","ckpv","mwy","wojd"};
Char[130] = {"fj3zf","f3","jz"};
Char[131] = {"fj3zf"};
for (int i=1; i<155; ++i) {
for (int j=1; j<4; ++j) Piece[i][j]=RotatePiece(Piece[i][j-1]);
}
for (int i=1; i<155; ++i) {
for (int j=0; j<4; ++j) {
for (int x=0; x<10; ++x) {
for (int y=0; y<10; ++y) {
if (Piece[i][j].B[x][y]) DDP[i][j].push_back(make_pair(x,y));
}
}
}
}
ll CurT = clock();
int PaintTm = 0;
int PrevPlrs = Plrs;
int ClearOnDuel = 0;
vector<string> Co;
bool EscCD = false;
Launch("marathon");
while (!bQuit) {
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
if (msg.message==WM_QUIT) bQuit=true;
else {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else {
if (!CheckKey(VK_ESCAPE)) EscCD=false;
Focus = (hWnd==GetFocus());
DX0 = Plr[0].DX+Plr[0].DXDel;
if (ForceLaunch!="") {
Launch(ForceLaunch); ForceLaunch="";
continue;
}
bool HumanAlive = false;
for (int i=0; i<Plrs; ++i) {
if ((!Plr[i].Over)&&(!Plr[i].Bot)) HumanAlive=true;
}
if ((Plrs>1)&&(CheckKey(VK_LBUTTON))) {
POINT p; GetCursorPos(&p);
ScreenToClient(GetForegroundWindow(), &p);
p.y-=96; p.x-=100;
p.y/=4.86/5.00; p.x/=4.98/5.00;
for (int i=0; i<Plrs; ++i) {
if (Plr[i].Over) continue;
if ((p.y>=Plr[i].KX)&&(p.y<=Plr[i].KX+(Plr[i].DX+Plr[i].DXDel)*Plr[i].sz)&&
(p.x>=Plr[i].KY)&&(p.x<=Plr[i].KY+Plr[i].LY*Plr[i].sz)) {
if ((HumanAlive)&&(!QuickPlay)) {
for (int j=0; j<Plrs; ++j) {
if ((!Plr[j].Over)&&(!Plr[j].Bot)&&(i!=j)) Plr[j].Tar=i;
}
}
if (!HumanAlive) Obs=i;
}
}
}
#warning console
if (Con) {
glClearColor(BackgroundRatio, BackgroundRatio, BackgroundRatio, 0);
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
ll NewT=clock(); int del=int(NewT-CurT);
CurT = NewT;
for (int i=0; i<Plrs; ++i) {
Plr[i].begtm += ll(del);
for (pair<int,pair<lll,ll> > &o : Plr[i].Rec) o.second.second+=del;
if ((!Plr[i].Over)||((Plrs==1)&&(!Zen))||(QuickPlay)) Plr[i].Paint(del);
}
for (int i=0; i<Plrs; ++i) {
if (!Plr[i].Over) {
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==i)||((Plr[i].AtkType==6)&&(TarRem[i][j])))&&(!Plr[j].Over));
Plr[i].PaintParticle(del, tars);
}
MX[i] = Plr[i].KX+Plr[i].DX*0.5*Plr[i].sz;
MY[i] = Plr[i].KY+Plr[i].LY*0.5*Plr[i].sz;
}
Global.PaintGlobal(del);
glPopMatrix();
SwapBuffers(hDC);
if ((CheckKey(VK_ESCAPE))&&(!EscCD)) {
EscCD = true;
Con=false; continue;
}
if ((ForceExecute!="")&&(ForceExecute.back()=='~')) {
Command=ForceExecute; ForceExecute=""; Command.pop_back();
}
if ((ForceExecute!="")&&(ForceExecute.front()=='+')) {
Command=Command+ForceExecute.substr(1,ForceExecute.size()-1); ForceExecute="";
}
if ((ForceExecute!="")&&(ForceExecute.front()=='~')) {
Command=Command+ForceExecute.substr(1,ForceExecute.size()-1); ForceExecute=Command;
}
if (((Command.size())&&(CheckKey(VK_RETURN)))||((ForceExecute!="")&&(ForceExecute.back()!='~'))) {
if (ForceExecute!="") {
Command=ForceExecute; ForceExecute="";
}
if (!Command.back()) Command.pop_back();
for (int i=0; i<Command.size(); ++i) {
if (Command[i]==' ') Command[i]=0;
}
while (CheckKey(VK_RETURN));
string cur=""; Co.clear();
for (char ch : Command) {
if (ch) cur.push_back(ch);
else {
Co.push_back(cur); cur="";
}
}
if (cur.size()) Co.push_back(cur);
Con=false; Command=""; continue;
}
vector<char> lst; lst.push_back(' '); lst.push_back(VK_BACK); lst.push_back(VK_DELETE);
for (char i='0'; i<='9'; ++i) lst.push_back(i);
for (char i='A'; i<='Z'; ++i) lst.push_back(i);
vector<char> key;
for (char ch : lst) {
bool sta = CheckKey(ch);
if ((sta)&&(!ConKey[ch])) key.push_back(ch);
ConKey[ch] = sta;
}
for (char ch : key) {
if (ch==VK_BACK) {
if (Command.size()) Command.pop_back();
continue;
}
if (ch==VK_DELETE) {
Command=""; continue;
}
char dy = ch;
if ((ch>='A')&&(ch<='Z')) dy+='a'-'A';
else if (ch==' ') dy=0;
if ((ch!=' ')||((Command.size())&&(Command.back()))) Command.push_back(dy);
}
continue;
}
if ((CheckKey(VK_ESCAPE))&&(!EscCD)) {
EscCD = true;
for (int i=0; i<999; ++i) ConKey[i]=false;
Con=true; continue;
}
if (Co.size()) {
pair<int,string> o=Execute(Co); Co.clear();
Respond=o.second; RespondColor=o.first; RespondTime=10000;
}
for (int i=0; i<Plrs; ++i) Plr[i].BeFrom=Plr[i].BeTo=false;
if ((PlrsCnt>2)&&(Obs>=0)) {
if (Plr[Obs].Tar>=0) Plr[Plr[Obs].Tar].BeTo=true;
if (Plr[Obs].AtkType==6) {
for (int i=0; i<Plrs; ++i) {
if (TarRem[Obs][i]) Plr[i].BeTo=true;
}
}
for (int i=0; i<Plrs; ++i) {
if (Plr[i].Tar==Obs) Plr[i].BeFrom=true;
if ((Plr[i].AtkType==6)&&(TarRem[i][Obs])) Plr[i].BeFrom=true;
}
}
if ((Obs>=0)&&(Plr[Obs].Over)&&((Plr[Obs].Bot)||(!QuickPlay))) {
bool ok = true;
if (QuickPlay) {
for (int i=0; i<Plrs; ++i) {
if ((!Plr[i].Bot)&&(!Plr[i].Over)) ok=false;
}
}
if ((!Plr[Plr[Obs].LstAtk].Over)&&(ok)) Obs=Plr[Obs].LstAtk;
else Obs=-1;
}
for (int i=0; i<Plrs; ++i) {
if ((Plr[i].Over)&&(QuickPlay)&&(Plr[i].Bot)) {
Plr[i].Over=KOCount[i]=false; Plr[i].ClearAll(time(0));
}
}
if (Obs<0) {
for (int i=0; i<Plrs; ++i) {
if ((!Plr[i].Bot)&&(!Plr[i].Over)) {
if (Obs<0) Obs=i;
}
}
for (int i=0; i<Plrs; ++i) {
if ((Plr[i].Bot)&&(!Plr[i].Over)) {
if (Obs<0) Obs=i;
}
}
}
vector<int> PlrOrd;
for (int i=0; i<Plrs; ++i) {
if ((!Plr[i].Bot)&&((!Plr[i].Over)||(QuickPlay))) PlrOrd.push_back(i);
}
for (int i=0; i<Plrs; ++i) {
if ((Plr[i].Bot)&&(!Plr[i].Over)) PlrOrd.push_back(i);
}
if (PlrOrd.size()==1) {
Plr[PlrOrd[0]].SKX=0; Plr[PlrOrd[0]].SKY=400; Plr[PlrOrd[0]].Ssz=20;
}
else if (PlrOrd.size()==2) {
if (PlrOrd[0]!=Obs) swap(PlrOrd[0],PlrOrd[1]);
Plr[PlrOrd[0]].SKX=0; Plr[PlrOrd[0]].SKY=100; Plr[PlrOrd[0]].Ssz=20;
Plr[PlrOrd[1]].SKX=0; Plr[PlrOrd[1]].SKY=600; Plr[PlrOrd[1]].Ssz=20;
}
else if (PlrOrd.size()>2){
int pos = 0;
vector<int> AtkOrd = PlrOrd;
if (QuickPlay) {
stable_sort(AtkOrd.begin(), AtkOrd.end(), [](int x, int y) {
return Plr[x].Score>Plr[y].Score;
});
}
int lnc=11; double ssz=4;
if (PlrOrd.size()<=81) {
lnc=10; ssz=4.3;
}
if (PlrOrd.size()<=64) {
lnc=9; ssz=4.7;
}
if (PlrOrd.size()<=49) {
lnc=8; ssz=5.4;
}
if (PlrOrd.size()<=36) {
lnc=7; ssz=6.2;
}
if (PlrOrd.size()<=31) {
lnc=6; ssz=7.1;
}
if (PlrOrd.size()<=21) {
lnc=5; ssz=8.8;
}
if (PlrOrd.size()<=13) {
lnc=4; ssz=11.4;
}
if (PlrOrd.size()<=7) {
lnc=3; ssz=15;
}
if (PlrOrd.size()<=5) {
lnc=2; ssz=17;
}
for (int i : AtkOrd) {
if (Obs==i) {
Plr[i].SKX=0; Plr[i].SKY=100; Plr[i].Ssz=20;
continue;
}
int yn=pos%lnc; if ((pos/lnc)&1) yn=lnc-1-yn;
Plr[i].SKX=110*ssz/4.0*(pos/lnc)-80; Plr[i].SKY=90*ssz/4.0*yn+450; Plr[i].Ssz=ssz;
if (lnc==2) Plr[i].SKY+=100;
++pos;
}
}
PlrsCnt = 0;
for (int i=0; i<Plrs; ++i) {
PlrsCnt+=(!Plr[i].Over); if (Plr[i].Over) continue;
Plr[i].VSRnk = 1;
for (int j=0; j<Plrs; ++j) {
if ((make_pair(Plr[j].SumAttack+Plr[j].SumDig,j)>make_pair(Plr[i].SumAttack+Plr[i].SumDig,i))&&(!Plr[j].Over)) ++Plr[i].VSRnk;
}
if (QuickPlay) {
Plr[i].VSRnk = 1;
for (int j=0; j<Plrs; ++j) {
if ((make_pair(Plr[j].Score,j)>make_pair(Plr[i].Score,i))&&(!Plr[j].Over)) ++Plr[i].VSRnk;
}
}
}
/*if ((Plrs>2)&&(PrevPlrs>2)&&(PlrsCnt==2)&&(ClearOnDuel)) {
int seed = time(0);
for (int i=0; i<Plrs; ++i) {
if (Plr[i].Over) continue;
for (int j=1; j<=Plr[i].LX; ++j) {
for (int k=1; k<=Plr[i].LY; ++k) {
Plr[i].B[j][k]=Plr[i].C[j][k]=0;
}
}
Plr[i].Hold=0; Plr[i].Next.clear(); Plr[i].gen=mt19937(seed);
}
}*/
PrevPlrs = PlrsCnt;
ll NewT=clock(); int del=int(NewT-CurT);
CurT=NewT; PaintTm+=del;
for (int i=0; i<Plrs; ++i) {
for (int j=0; j<Plrs; ++j) TarRem[i][j]=max(0,TarRem[i][j]-del);
ShiftCD[i] = max(0,ShiftCD[i]-del);
}
for (int i=0; i<Plrs; ++i) {
if (Plr[i].Tar>=0) TarRem[Plr[i].Tar][i]=3000;
}
int AILim = 5;
if (Plrs>40) AILim=4;
if (Plrs>50) AILim=3;
if (Plrs>60) AILim=2;
if (Plrs>70) AILim=1;
vector<int> Bot;
for (int i=0; i<Plrs; ++i) {
if ((Odoo)&&(ConstE)) Apply(i,ConstE,0,100);
}
for (int i=0; i<Plrs; ++i) {
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==i)||(((Plr[i].AtkType==6)&&(TarRem[i][j]))))&&(!Plr[j].Over));
if (Plr[i].Bot) Bot.push_back(i);
else Plr[i].Frame(del,tars);
}
if (Bot.size()>AILim) shuffle(Bot.begin(),Bot.end(),rng);
if (Bot.size()==Plrs) AILim=max(AILim,10);
AILim = min(AILim,int(Bot.size()));
for (int id=0; id<Bot.size(); ++id) {
int i = Bot[id];
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==i)||(((Plr[i].AtkType==6)&&(TarRem[i][j]))))&&(!Plr[j].Over));
UseAI=0; Plr[i].Frame(del,tars,(id<AILim));
if (!UseAI) ++AILim;
}
vector<int> AggList, AggVal(Plrs,0);
for (int i=0; i<Plrs; ++i) {
curh[i] = Plr[i].QueryHeight();
if (Plr[i].Over) continue;
int Mins = int((clock()-Plr[i].begtm-BegDelay)/60000LL);
int Agg = 12;
if (Mins>=3) Agg+=4;
if (Mins>=5) Agg+=4;
if (Mins>=7) Agg+=4;
int RecHeight = curh[i]+Plr[i].ActiveGarb.size();
for (pair<int,pair<lll,ll> > o : Plr[i].Rec) RecHeight+=o.first;
if ((RecHeight+7>Plr[i].DX)&&(!Plr[i].ModExpert)) Agg-=6;
if ((Plr[i].ModSpin==2)||(Plr[i].ModMess==2)||(Plr[i].ModDivergence==2)) {
int GarbC = 0;
for (int x=1; x<=Plr[i].LX; ++x) {
for (int y=1; y<=Plr[i].LY; ++y) {
if (Plr[i].B[x][y]==154) {
++GarbC; break;
}
}
}
Agg -= min(GarbC,5)*2;
}
Agg -= Plr[i].AggDec;
Agg = max(Agg,0);
AggVal[i] = Agg;
if (Plr[i].AggDec) {
Plr[i].AggTm += del;
if (Plr[i].AggTm>=DecDis[min(int(DecDis.size()-1),Plr[i].QueryFloor())]) {
Plr[i].AggTm=0; --Plr[i].AggDec;
}
}
for (int j=0; j<((QuickPlay)?Agg:1); ++j) AggList.push_back(i);
}
stable_sort(AggList.begin(), AggList.end(), [](int x, int y) {
return Plr[x].Score<Plr[y].Score;
});
for (int i=0; i<Plrs; ++i) {
if ((!QuickPlay)&&(rnd(5000)<del)) Plr[i].Tar=-1;
if ((QuickPlay)&&(Plr[i].Tar>=0)&&(!AggVal[Plr[i].Tar])) Plr[i].Tar=-1;
if (QuickPlay) Plr[i].AtkType=7;
if (Plr[i].AtkType==6) {
bool ok = false;
for (int j=0; j<Plrs; ++j) {
if ((!Plr[j].Over)&&(j!=i)&&(TarRem[i][j])) ok=true;
}
if (ok) Plr[i].Tar=-1;
}
if (((Plr[i].Tar<0)||(Plr[Plr[i].Tar].Over))&&(PlrsCnt>1)) {
vector<int> TarList;
for (int j=0; j<Plrs; ++j) {
if (i==j) continue;
if (!Plr[j].Over) TarList.push_back(j);
}
Plr[i].Tar = -1;
if (TarList.size()) {
shuffle(TarList.begin(), TarList.end(), rng);
if (Plr[i].AtkType==3) Plr[i].Tar=TarList[0];
else if (Plr[i].AtkType==4) {
if ((Plr[i].LstAtk>=0)&&(!Plr[Plr[i].LstAtk].Over)) Plr[i].Tar=Plr[i].LstAtk;
else Plr[i].Tar=TarList[0];
}
else if (Plr[i].AtkType==6) {
vector<int> lst;
for (int j : TarList) {
if ((!Plr[j].Over)&&(TarRem[i][j])) lst.push_back(j);
}
if (lst.size()) Plr[i].Tar=lst[rnd(lst.size())];
else Plr[i].Tar=TarList[0];
}
else if (Plr[i].AtkType==7) {
Plr[i].Tar = -1;
if (AggList.empty()) continue;
vector<int> NwList(Plrs,0);
bool exi=false; int ln=-1;
int mul=0; int NwTot=0;
for (int j=0; j<AggList.size(); ++j) {
if (AggList[j]==i) exi=true;
if ((AggList[j]!=i)&&(exi)) {
NwTot += (11-mul)*max(1,Plr[AggList[j]].QueryFloor()-6)/2;
NwList[AggList[j]] += (11-mul)*max(1,Plr[AggList[j]].QueryFloor()-6)/2;
if (AggList[j]!=ln) {
++mul; if (mul>10) break;
}
ln = AggList[j];
}
if ((exi)&&(AggList[j]!=i)&&(j+1==AggList.size())&&(mul<=10)) {
j=max(0,j-10); mul+=4;
}
}
exi=false; ln=-1; mul=0;
for (int j=AggList.size()-1; j>=0; --j) {
if (AggList[j]==i) exi=true;
if ((AggList[j]!=i)&&(exi)) {
NwTot+=min(11,20-mul); NwList[AggList[j]]+=min(11,20-mul);
if (AggList[j]!=ln) {
++mul; if (mul>10) break;
}
ln = AggList[j];
}
}
if (NwTot) {
int rn = rnd(NwTot);
for (int j=0; j<Plrs; ++j) {
if (rn<NwList[j]) {
Plr[i].Tar=j; break;
}
rn -= NwList[j];
}
}
if (Plr[i].Atk.size()>1) {
int att = 10;
while (att--) {
if (AggList.empty()) break;
int nw = AggList[rnd(AggList.size())];
if (nw!=i) {
Plr[i].Tar=nw; break;
}
}
}
}
else {
vector<pair<int,int> > lst;
int currnk = Plr[i].VSRnk;
for (int i : TarList) {
int val = 0;
if (Plr[i].AtkType==1) val=-curh[i];
else if (Plr[i].AtkType==2) val=curh[i];
else val=Plr[i].SKO;
lst.push_back(make_pair(val*10000+rnd(10000),i));
}
shuffle(lst.begin(), lst.end(), rng);
stable_sort(lst.begin(), lst.end(), [](pair<int,int> x, pair<int,int> y) {
return x.first>y.first;
});
vector<int> pool;
for (int i=0; i<min(10,int(TarList.size())); ++i) {
for (int j=i; j<10; ++j) pool.push_back(lst[i].second);
}
Plr[i].Tar = pool[rnd(pool.size())];
}
}
}
#warning atk
while (Plr[i].Atk.size()) {
int nw = Plr[i].Atk.front().first;
if (!nw) {
if ((Odoo)&&(Plr[i].Atk.front().second)) Apply(i,Plr[i].Atk.front().second,0,i);
Plr[i].Atk.pop(); continue;
}
int tar=Plr[i].Tar; ll curtm=clock();
//printf("%d : %d -> %d\n",i,nw,tar);
if (tar>=0) {
if (QuickPlay) {
int Mins = int((curtm-Plr[tar].begtm-BegDelay)/60000LL);
if (Mins>=11-2*(Plr[tar].ModExpert==2)) nw=nw*3/2+rnd(2)*(nw*3%2);
else if (Mins>=9-2*(Plr[tar].ModExpert==2)) nw=nw*5/4+(rnd(4)<nw*5%4);
if (Plr[tar].AggDec==12) nw=nw*3/4+(rnd(4)<nw*3%4);
}
if (Plr[tar].ModStrength) nw*=(1+Plr[tar].ModStrength);
if (Plr[tar].ModDivergence==2) nw=(nw/2)+rnd(2)*(nw%2);
if (Plr[tar].ModExpert==2) {
nw = nw*(200+Plr[tar].RecIncTm/1000);
nw = nw/200+(rnd(200)<nw%200);
}
int E = Plr[i].Atk.front().second;
int rnw = nw;
if (E==1) {
if (Plr[tar].EV[6]) nw=nw*2+(Plr[i].OgTm>0);
else if (Plr[tar].EV[2]) nw=nw*3/2+nw*3%2*rnd(2)+(Plr[i].OgTm>0);
}
if (E==2) {
if (Plr[tar].EV[1]) nw=nw*2+(Plr[i].OgTm>0);
}
if (E==6) {
if (Plr[tar].EV[1]) nw=nw*3/2+nw*3%2*rnd(2)+(Plr[i].OgTm>0);
}
if ((E==4)||(E==5)) {
if ((Plr[tar].EV[4])&&(Plr[tar].EV[5])&&(!Plr[tar].EV[1])) ++nw;
}
if (!E) {
if (Plr[tar].ScTm) ++nw;
}
while ((nw)&&(!Plr[tar].Cy.empty())) {
--nw;
if ((rnd(2))||(E!=Plr[tar].Cy.front().second)) Plr[tar].Cy.pop_front();
}
Apply(tar, E, rnw, i);
if (nw<1) {
Plr[i].Atk.pop(); continue;
}
nw = min(nw,Plr[tar].LX*5+100);
int RecSeg=9999; if (QuickPlay) RecSeg=4*(1+Plr[tar].ModStrength);
double InnerMess = 0.01*double(_InnerMess);
double SegMess = 0.01*double(_SegMess);
bool NoSame = false;
if (QuickPlay) {
double Mess = 0.03*Plr[tar].QueryFloor();
if (Plr[tar].ModMess) Mess+=0.25;
if (Plr[tar].ModMess==2) Mess+=0.75;
if (Plr[tar].ModExpert) Mess+=0.02*Plr[tar].QueryFloor();
if (Plr[tar].ModSpin==2) Mess+=0.3;
int Mins = 0;
if (Plr[tar].ModExpert==2) Mins=int((curtm-Plr[tar].begtm-BegDelay)/60000LL);
InnerMess = Mess;
if (Mins<6) InnerMess*=1.0-0.18*double(Plr[tar].AggDec)/12.0;
SegMess = Mess*2.5;
if (Mins<6) SegMess*=1.0-0.45*double(Plr[tar].AggDec)/12.0;
if (Mins>=11) {
NoSame=true; InnerMess=SegMess=1.0;
}
}
if ((!QuickPlay)&&(Plrs>2)&&(ShiftCD[tar])) InnerMess=SegMess=0.0;
if (Plr[tar].ModDivergence==2) {
InnerMess=SegMess=1.0; nw=min(nw,10);
}
int Luck = _Luck;
if (QuickPlay) {
Luck = 3-Plr[tar].QueryFloor()*3;
if (!Plr[tar].ModExpert) Luck+=33;
if (Plr[tar].ModMess) Luck-=25;
if (Plr[tar].ModStrength==2) Luck=50;
}
if (GarbageShape=="board") InnerMess=SegMess=0.0;
else if ((rndf()<SegMess)||((Plr[tar].LstHole<1)||(Plr[tar].LstHole>Plr[tar].LY))) Plr[tar].LstHole=Plr[tar].RollHole(Luck,NoSame);
int SegV = 0;
TemplatePos = 0;
if ((GarbageShape=="clear")||(GarbageShape=="arcade")) ClearTemplate=Plr[i].ClearShape;
else ClearTemplate.clear();
for (int _=0; _<nw; ++_) {
if (rndf()<InnerMess) Plr[tar].LstHole=Plr[tar].RollHole(Luck,NoSame);
lll gb = Plr[tar].RollGarb();
if (!Plr[tar].Rec.empty()) curtm=max(curtm,Plr[tar].Rec.back().second.second);
if (++SegV==RecSeg) {
curtm+=500LL; SegV=0;
}
if ((!Plr[tar].Rec.empty())&&((Plr[tar].Rec.back().second.second==curtm)&&(Plr[tar].Rec.back().second.first==gb))) ++Plr[tar].Rec.back().first;
else Plr[tar].Rec.push_back(make_pair(1,make_pair(gb,curtm)));
}
curtm = clock();
double fx=Plr[i].ravx-Plr[tar].KX, fy=Plr[i].ravy-Plr[tar].KY;
double ex=Plr[tar].ravx-Plr[tar].KX, ey=Plr[tar].ravy-Plr[tar].KY;
double ss = 5+2*min(Plr[i].Atk.front().first-1,20);
ss/=Plr[tar].sz; ss*=10;
int seg=min(20,int(sqrt((fx-ex)*(fx-ex)+(fy-ey)*(fy-ey))/30.0)); double cx=fx, cy=fy;
for (int i=0; i<seg; ++i) {
cx += (ex-fx)/double(seg+3);
cy += (ey-fy)/double(seg+3);
Plr[tar].PQu.push_back({cx,cy,0,0,0,0,double(i)/double(seg)*ss,0.2/Plr[tar].sz,0,8,-Mix(0xFFFFFF,0xDF3782,0.6)});
}
//AtkEff.push_back({Plr[i].KX+Plr[i].DX*Plr[i].sz*0.5,Plr[i].KY+Plr[i].LY*Plr[i].sz*0.5,rndf()*acos(-1.0)*2.0,rndf()*acos(-1.0)*2.0,tar,0xFFFF00,pow(nw,0.2)});
Plr[tar].LstAtk = i;
int cap = 12;
if (Plr[tar].ModExpert==2) cap=max(0,(4+(11-Plr[tar].QueryFloor())*2)/5);
Plr[tar].AggDec = min(cap,Plr[tar].AggDec+1);
ShiftCD[tar] = 100;
}
Plr[i].Atk.pop();
bool qd = false;
if (Plr[i].Atk.size()) {
Plr[i].Tar = -1;
int att = 10;
vector<int> List;
if (QuickPlay) List=AggList;
else {
if (Plr[i].AtkType==6) {
for (int j=0; j<Plrs; ++j) {
if ((!Plr[j].Over)&&(TarRem[i][j])) List.push_back(j);
}
}
if (List.empty()) {
for (int j=0; j<Plrs; ++j) {
if ((!Plr[j].Over)&&(i!=j)) List.push_back(j);
}
}
}
while (att--) {
if (List.empty()) break;
int nw = List[rnd(List.size())];
if (nw!=i) {
Plr[i].Tar=nw; qd=true; break;
}
}
}
if (QuickPlay) {
if ((Plr[i].Tar!=-1)&&(!qd)&&(!rnd(max(1,(Plr[Plr[i].Tar].QueryFloor()-8)/3)))) Plr[i].Tar=-1;
break;
}
}
}
int OverCnt = 0;
int Hm=0, HmOver=0;
for (int i=0; i<Plrs; ++i) {
if (Plr[i].Over) {
++OverCnt;
if ((Plr[i].LstAtk>=0)&&(!KOCount[i])) {
if (QuickPlay) Plr[Plr[i].LstAtk].GiveScore((Plr[i].ModExpert<2)?15000:8000);
else Plr[Plr[i].LstAtk].SKO+=1+Plr[i].SKO;
++Plr[Plr[i].LstAtk].KO; KOCount[i]=true;
}
}
if (!Plr[i].Bot) {
++Hm; if (Plr[i].Over) ++HmOver;
}
}
bool ok = false;
for (int i=0; i<Plrs; ++i) {
if (!Plr[i].Bot) ok=true;
}
if ((ForceAbort)&&(QuickPlay)&&(ok)) {
ForceAbort = false;
for (int i=0; i<Plrs; ++i) {
if (!Plr[i].Bot) {
Plr[i].Over=KOCount[i]=false; Plr[i].ClearAll(time(0)); Obs=i;
}
}
}
if ((ForceRound)||(ForceAbort)||((!QuickPlay)&&(((Plrs==1)&&(OverCnt)&&(Zen))||((OverCnt+1>=Plrs)&&(Plrs>1))||((Plrs>1)&&(Hm)&&(Hm==HmOver)&&(!ObserveAI))))) {
int seed=time(0); Obs=-1; if (!ForceAbort) ++RoundTot;
memset(TarRem, 0, sizeof(TarRem));
for (int i=0; i<Plrs; ++i) {
ShiftCD[i] = 0;
if ((!Plr[i].Over)&&(!ForceAbort)) {
++Plr[i].Wins; Plr[i].Victory();
}
else Plr[i].ClearAll(0,true);
}
if ((Plrs>1)&&(!ForceAbort)) {
PaintTm = 0;
while (PaintTm<3000) {
ll NxtT = clock();
int del=int(NxtT-CurT); PaintTm+=del;
CurT = NxtT;
glClearColor(BackgroundRatio, BackgroundRatio, BackgroundRatio, 0);
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
for (int i=0; i<Plrs; ++i) {
if (((!Plr[i].Over)||((Plrs==1)&&(!Zen))||(QuickPlay))&&(i!=Obs)) Plr[i].Paint(del);
MX[i] = Plr[i].KX+Plr[i].DX*0.5*Plr[i].sz;
MY[i] = Plr[i].KY+Plr[i].LY*0.5*Plr[i].sz;
}
if ((Obs>=0)&&((!Plr[Obs].Over)||((Plrs==1)&&(!Zen))||(QuickPlay))) Plr[Obs].Paint(del);
for (int i=0; i<Plrs; ++i) {
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==i)||(((Plr[i].AtkType==6)&&(TarRem[i][j]))))&&(!Plr[j].Over));
if (i!=Obs) Plr[i].PaintParticle(del,tars);
}
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==Obs)||(((Plr[Obs].AtkType==6)&&(TarRem[Obs][j]))))&&(!Plr[j].Over));
if (Obs>=0) Plr[Obs].PaintParticle(del,tars);
Global.PaintGlobal(del);
glPopMatrix();
SwapBuffers(hDC);
}
}
for (int i=0; i<Plrs; ++i) {
Plr[i].ClearAll(seed,Plr[i].Over); Plr[i].Over=false;
Plr[i].LstAtk=-1; KOCount[i]=false; Plr[i].Tar=-1;
if (QuickPlay) ++seed;
}
ForceRound=ForceAbort=false;
//if (Zen) Storage=true;
}
if (PaintTm>=PaintLim) {
glClearColor(BackgroundRatio, BackgroundRatio, BackgroundRatio, 0);
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
for (int i=0; i<Plrs; ++i) {
if (((!Plr[i].Over)||((Plrs==1)&&(!Zen))||(QuickPlay))&&(i!=Obs)) Plr[i].Paint(PaintTm);
}
if ((Obs>=0)&&((!Plr[Obs].Over)||((Plrs==1)&&(!Zen))||(QuickPlay))) Plr[Obs].Paint(PaintTm);
for (int i=0; i<Plrs; ++i) {
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==i)||(((Plr[i].AtkType==6)&&(TarRem[i][j]))))&&(!Plr[j].Over));
if (i!=Obs) Plr[i].PaintParticle(PaintTm,tars);
MX[i] = Plr[i].KX+Plr[i].DX*0.5*Plr[i].sz;
MY[i] = Plr[i].KY+Plr[i].LY*0.5*Plr[i].sz;
}
int tars=0; for (int j=0; j<Plrs; ++j) tars+=(((Plr[j].Tar==Obs)||(((Plr[Obs].AtkType==6)&&(TarRem[Obs][j]))))&&(!Plr[j].Over));
if (Obs>=0) Plr[Obs].PaintParticle(PaintTm,tars);
Global.PaintGlobal(PaintTm);
PaintTm = 0;
glPopMatrix();
SwapBuffers(hDC);
}
if (Zen) {
if (Storage) {
Storage = false;
StoragePos = (StoragePos<105)?StoragePos+1:1;
Plr[StoragePos] = Plr[0];
StorageTot = min(100,StorageTot+1);
}
if ((Undo)&&(StorageTot>1)) {
StoragePos = (StoragePos>1)?StoragePos-1:105;
Plr[0] = Plr[StoragePos];
for (int i=0; i<256; ++i) {
Plr[0].KeyDas[i]=Plr[0].KeySta[i]=false; Plr[0].KeyTime[i]=0;
}
Plr[0].UndoCD = 100;
--StorageTot;
}
if (Undo) Undo=false;
}
}
}
DisableOpenGL(hWnd, hDC, hRC);
DestroyWindow(hWnd);
return msg.wParam;
}