/programs/games/checkers/trunk/board.h |
---|
0,0 → 1,1410 |
#ifndef _HEADER_BOARD_H |
#define _HEADER_BOARD_H |
#ifndef __MENUET__ |
#include <string.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <time.h> |
#include <math.h> |
#include <limits.h> |
#endif |
#include "position.h" |
#include "history.h" |
#include "gr-draw.h" |
int ssf = 0; |
struct TIntPoint |
{ |
TIntPoint() {} |
TIntPoint(int x, int y) : x(x), y(y) {} |
TIntPoint(const TIntPoint &p) : x(p.x), y(p.y) {} |
TIntPoint &operator=(const TIntPoint &p) {x = p.x; y = p.y; return *this;} |
int x, y; |
}; |
struct TRealPoint |
{ |
TRealPoint() {} |
TRealPoint(double x, double y) : x(x), y(y) {} |
TRealPoint(const TRealPoint &p) : x(p.x), y(p.y) {} |
TRealPoint(const TIntPoint &p) : x(p.x), y(p.y) {} |
TRealPoint &operator=(const TRealPoint &p) {x = p.x; y = p.y; return *this;} |
TRealPoint &operator=(const TIntPoint &p) {x = p.x; y = p.y; return *this;} |
TIntPoint Round() {return TIntPoint((int)floor(x+0.5), (int)floor(y+0.5));} |
double x, y; |
}; |
struct TProjectivePoint |
{ |
TProjectivePoint() {} |
TProjectivePoint(const TProjectivePoint &p) : x(p.x), y(p.y), z(p.z) {} |
TProjectivePoint(double x, double y, double z = 1) : x(x), y(y), z(z) {} |
TProjectivePoint(const TIntPoint &p, double z = 1) : x(p.x), y(p.y), z(z) {} |
TProjectivePoint(const TRealPoint &p, double z = 1) : x(p.x), y(p.y), z(z) {} |
int IsCorrect() const {return fabs(x) > Eps || fabs(y) > Eps || fabs(z) > Eps;} |
int IsFinite() const; |
TRealPoint rpnt() const; |
int rpnt(TRealPoint &p) const; |
TIntPoint pnt() const; |
int pnt(TIntPoint &p) const; |
TProjectivePoint &operator=(const TProjectivePoint &p); |
TProjectivePoint &operator=(const TIntPoint &p) {x = p.x; y = p.y; z = 1; return *this;} |
TProjectivePoint &operator=(const TRealPoint &p) {x = p.x; y = p.y; z = 1; return *this;} |
TProjectivePoint &operator*=(int n) {x *= n; y *= n; z *= n; return *this;} |
friend TProjectivePoint operator*(const TProjectivePoint &p, int n) |
{return TProjectivePoint(p.x * n, p.y * n, p.z * n);} |
friend TProjectivePoint operator*(int n, const TProjectivePoint &p) |
{return TProjectivePoint(n * p.x, n * p.y, n * p.z);} |
TProjectivePoint &operator*=(double n) {x *= n; y *= n; z *= n; return *this;} |
friend TProjectivePoint operator*(const TProjectivePoint &p, double n) |
{return TProjectivePoint(p.x * n, p.y * n, p.z * n);} |
friend TProjectivePoint operator*(double n, const TProjectivePoint &p) |
{return TProjectivePoint(n * p.x, n * p.y, n * p.z);} |
double px() const {return x/z;} |
double py() const {return y/z;} |
double x, y, z; |
static const double Eps, FR; |
}; |
const double TProjectivePoint::Eps = 1e-12; |
const double TProjectivePoint::FR = 1e+4; |
inline int TProjectivePoint::IsFinite() const |
{ |
double fz = fabs(z); |
return fz > Eps && fabs(x) < fz * FR && fabs(y) < fz * FR; |
} |
TRealPoint TProjectivePoint::rpnt() const |
{ |
if (!IsFinite()) return TRealPoint(0, 0); |
else return TRealPoint(x/z, y/z); |
} |
inline int TProjectivePoint::rpnt(TRealPoint &p) const |
{ |
if (!IsFinite()) {p.x = 0; p.y = 0; return 0;} |
else {p.x = x/z; p.y = y/z; return 1;} |
} |
inline TIntPoint TProjectivePoint::pnt() const |
{ |
if (!IsFinite()) return TIntPoint(INT_MIN, INT_MIN); |
else return TIntPoint((int)floor(x/z + 0.5), (int)floor(y/z + 0.5)); |
} |
inline int TProjectivePoint::pnt(TIntPoint &p) const |
{ |
if (!IsFinite()) {p.x = INT_MIN; p.y = INT_MIN; return 0;} |
else |
{ |
p.x = (int)floor(x/z + 0.5); |
p.y = (int)floor(y/z + 0.5); |
return 1; |
} |
} |
TProjectivePoint &TProjectivePoint::operator=(const TProjectivePoint &p) |
{ |
x = p.x; y = p.y; z = p.z; |
return *this; |
} |
class TProjectiveMap |
{ |
public: |
TProjectiveMap() {} |
TProjectiveMap(int n) {p[0].x = p[1].y = p[2].z = n; |
p[0].y = p[0].z = p[1].x = p[1].z = p[2].x = p[2].y = 0;} |
TProjectiveMap(const TProjectiveMap &map) |
{p[0] = map.p[0]; p[1] = map.p[1]; p[2] = map.p[2];} |
TProjectiveMap(const TProjectivePoint pnt[]) |
{p[0] = pnt[0]; p[1] = pnt[1]; p[2] = pnt[2];} |
TProjectiveMap(const TProjectivePoint &p0, const TProjectivePoint &p1, |
const TProjectivePoint &p2) {p[0] = p0; p[1] = p1; p[2] = p2;} |
TProjectiveMap &operator=(const TProjectiveMap &map) |
{p[0] = map.p[0]; p[1] = map.p[1]; p[2] = map.p[2]; return *this;} |
TProjectiveMap &operator=(const TProjectivePoint pnt[]) |
{p[0] = pnt[0]; p[1] = pnt[1]; p[2] = pnt[2]; return *this;} |
TProjectiveMap &operator=(int n) {p[0].x = p[1].y = p[2].z = n; |
p[0].y = p[0].z = p[1].x = p[1].z = p[2].x = p[2].y = 0; return *this;} |
TProjectivePoint operator()(const TProjectivePoint &point) const; |
friend TProjectiveMap operator*(const TProjectiveMap &a, const TProjectiveMap &b); |
TProjectiveMap &operator*=(const TProjectiveMap &b); |
TProjectiveMap &operator*=(int n) {p[0] *= n; p[1] *= n; p[2] *= n; return *this;} |
friend TProjectiveMap operator*(const TProjectiveMap &a, int n) |
{return TProjectiveMap(a.p[0] * n, a.p[1] * n, a.p[2] * n);} |
friend TProjectiveMap operator*(int n, const TProjectiveMap &b) |
{return TProjectiveMap(n * b.p[0], n * b.p[1], n * b.p[2]);} |
TProjectiveMap Reversed() const; |
TProjectiveMap &Reverse() {return (*this) = Reversed();} |
friend TProjectiveMap operator/(const TProjectiveMap &a, const TProjectiveMap &b) |
{return a * b.Reversed();} |
TProjectiveMap &operator/=(const TProjectiveMap &b) {return (*this) *= b.Reversed();} |
TProjectiveMap &operator/=(int n) {if (!n) (*this) = 0; return *this;} |
TProjectivePoint Reversed(const TProjectivePoint &point) const; |
TProjectivePoint operator()(double x, double y, double z = 1) const |
{return (*this)(TProjectivePoint(x, y, z));} |
TProjectivePoint Reversed(double x, double y, double z = 1) const |
{return Reversed(TProjectivePoint(x, y, z));} |
TProjectiveMap &Set4(const TProjectivePoint &a0, const TProjectivePoint &a1, |
const TProjectivePoint &a2, const TProjectivePoint &a3); |
TProjectiveMap &Set4(const TProjectivePoint a[]) {return Set4(a[0], a[1], a[2], a[3]);} |
TProjectiveMap &Set4to4(const TProjectivePoint a[], const TProjectivePoint b[]) |
{return Set4(b) /= TProjectiveMap().Set4(a);} |
TProjectiveMap &Set4to4(const TProjectivePoint &a0, const TProjectivePoint &a1, |
const TProjectivePoint &a2, const TProjectivePoint &a3, |
const TProjectivePoint b[]) |
{return Set4(b) /= TProjectiveMap().Set4(a0, a1, a2, a3);} |
TProjectiveMap &Set4to4(const TProjectivePoint a[], |
const TProjectivePoint &b0, const TProjectivePoint &b1, |
const TProjectivePoint &b2, const TProjectivePoint &b3) |
{return Set4(b0, b1, b2, b2) /= TProjectiveMap().Set4(a);} |
TProjectiveMap &Set4to4(const TProjectivePoint &a0, const TProjectivePoint &a1, |
const TProjectivePoint &a2, const TProjectivePoint &a3, |
const TProjectivePoint &b0, const TProjectivePoint &b1, |
const TProjectivePoint &b2, const TProjectivePoint &b3) |
{return Set4(b0, b1, b2, b2) /= TProjectiveMap().Set4(a0, a1, a2, a3);} |
public: |
TProjectivePoint p[3]; |
}; |
TProjectivePoint TProjectiveMap::operator()(const TProjectivePoint &point) const |
{ |
return TProjectivePoint(p[0].x * point.x + p[1].x * point.y + p[2].x * point.z, |
p[0].y * point.x + p[1].y * point.y + p[2].y * point.z, |
p[0].z * point.x + p[1].z * point.y + p[2].z * point.z); |
} |
TProjectiveMap operator*(const TProjectiveMap &a, const TProjectiveMap &b) |
{ |
return TProjectiveMap(a(b.p[0]), a(b.p[1]), a(b.p[2])); |
} |
TProjectiveMap &TProjectiveMap::operator*=(const TProjectiveMap &b) |
{ |
TProjectivePoint p0 = (*this)(b.p[0]), p1 = (*this)(b.p[1]), p2 = (*this)(b.p[2]); |
p[0] = p0; p[1] = p1; p[2] = p2; |
return *this; |
} |
TProjectiveMap TProjectiveMap::Reversed() const |
{ |
return TProjectiveMap(TProjectivePoint(p[1].y * p[2].z - p[2].y * p[1].z, |
p[2].y * p[0].z - p[0].y * p[2].z, p[0].y * p[1].z - p[1].y * p[0].z), |
TProjectivePoint(p[1].z * p[2].x - p[2].z * p[1].x, |
p[2].z * p[0].x - p[0].z * p[2].x, p[0].z * p[1].x - p[1].z * p[0].x), |
TProjectivePoint(p[1].x * p[2].y - p[2].x * p[1].y, |
p[2].x * p[0].y - p[0].x * p[2].y, p[0].x * p[1].y - p[1].x * p[0].y)); |
} |
TProjectivePoint TProjectiveMap::Reversed(const TProjectivePoint &point) const |
{ |
return TProjectivePoint((p[1].y * p[2].z - p[2].y * p[1].z) * point.x + |
(p[1].z * p[2].x - p[2].z * p[1].x) * point.y + |
(p[1].x * p[2].y - p[2].x * p[1].y) * point.z, |
(p[2].y * p[0].z - p[0].y * p[2].z) * point.x + |
(p[2].z * p[0].x - p[0].z * p[2].x) * point.y + |
(p[2].x * p[0].y - p[0].x * p[2].y) * point.z, |
(p[0].y * p[1].z - p[1].y * p[0].z) * point.x + |
(p[0].z * p[1].x - p[1].z * p[0].x) * point.y + |
(p[0].x * p[1].y - p[1].x * p[0].y) * point.z); |
} |
TProjectiveMap &TProjectiveMap::Set4(const TProjectivePoint &a0, |
const TProjectivePoint &a1, const TProjectivePoint &a2, const TProjectivePoint &a3) |
{ |
p[0] = a0; p[1] = a1; p[2] = a2; |
TProjectivePoint K = Reversed(a3); |
p[0] *= K.x; p[1] *= K.y; p[2] *= K.z; |
return *this; |
} |
TRealPoint r_circle_pnt[13]; |
TRealPoint r_star_pnt[13]; |
const double r_star_large = 1.2, r_star_small = 0.8; |
const double r_ch_lines[] = {0.8, 0.7, 0.6, 0.5}; |
void InitBoardData() |
{ |
int i, len; |
double a, r; |
len = NELEM(r_circle_pnt) - 1; |
for (i = 0; i < len; i++) |
{ |
a = 2 * i * M_PI / len; |
r_circle_pnt[i].x = cos(a); |
r_circle_pnt[i].y = sin(a); |
} |
r_circle_pnt[len] = r_circle_pnt[0]; |
len = sizeof(r_star_pnt) / sizeof(r_star_pnt[0]) - 1; |
for (i = 0; i < len; i++) |
{ |
a = 2 * i * M_PI / len; |
r = (i % 2) ? r_star_small : r_star_large; |
r_star_pnt[i].x = cos(a) * r; |
r_star_pnt[i].y = sin(a) * r; |
} |
r_star_pnt[len] = r_star_pnt[0]; |
} |
class TChBoard; |
class TSomeDraw |
{ |
public: |
TSomeDraw() {} |
virtual void Draw(TGraphDraw *drw, int w, int h) = 0; |
virtual void DrawB(TGraphDraw *drw, TChBoard &brd); |
virtual TIntPoint GetDSize(int w, int h) {return TIntPoint(INT_MIN, INT_MIN);} |
}; |
class TChBoard |
{ |
public: |
TChBoard(int id = 0); |
TProjectiveMap Get4PMap() const; |
int GetW() const {return width;} |
int GetH() const {return height;} |
void ClearWH() {width = -1; height = -1;} |
void Resize(int w, int h); |
void Resize(TIntPoint size) {Resize(size.x, size.y);} |
TIntPoint PlToWin(double x, double y) const; |
TIntPoint PlToWin(TRealPoint rp) const {return PlToWin(rp.x, rp.y);} |
TRealPoint WinToPl(int x, int y) const; |
TRealPoint WinToPl(TIntPoint p) const {return WinToPl(p.x, p.y);} |
void NewGame(); |
int CanPlayerMove() const {return !IsPlayView && !game_end && !player[MainPos.wmove];} |
void Draw(TGraphDraw *drw); |
int ResizeDraw(TGraphDraw *drw, int w, int h); |
int CheckResize(TGraphDraw *drw); |
int HaveCheckResize() const {return check_resize;} |
void SetCheckResize(int cr) {check_resize = cr;} |
int MouseClick(TGraphDraw *drw, int x, int y); |
void UnMove(TGraphDraw *drw); |
int CMove(TGraphDraw *drw, int x, int y); |
int AutoMove(TGraphDraw *drw, int nmove = 0, int draw_check = 1); |
enum PKey {PNull, PEnter, PLeft, PRight, PUp, PDown}; |
PKey GetKeySide(PKey key); |
int PKeyEvent(TGraphDraw *drw, PKey key = PEnter); |
protected: |
enum TextLineType {TLT_Main, TLT_Move, TLT_Wait, TLT_GameEnd, TLT_WrongMove, |
TLT_PlDidntMove, TLT_PlWrongMove, TLT_WrongColor, |
TLT_WfCell, TLT_WnfCell, TLT_WMustEat, TLT_WMustEatMore, |
TLT_WNoMove, TLT_WChBack, TLT_WNotDm, TLT_WOnlyDiag, |
TLT_WEatYour, TLT_WMoreOne, TLT_WNotDmE, TLT_WMustEatMoreD, |
TLT_WTurnBack}; |
void GetTextLine(char str[]) const; |
void DrawTextLine(TGraphDraw *drw) const; |
void LineB(TGraphDraw *drw, double x1, double y1, double x2, double y2) const; |
void DrawCh(TGraphDraw *drw, double x0, double y0, const TRealPoint pnt[], int npnt, |
int L = NELEM(r_ch_lines)) const; |
void DrawIL(TGraphDraw *drw, double x0, double y0, int L) const; |
void MoveErase(); |
void CurPointClear(TGraphDraw *drw) const; |
void RenewMPos() {if (MainPlay.GetPos(MainPos, CurMoveN) < 0) MainPos.Init();} |
void PrintLMove(); |
void SetNoMove(TGraphDraw *drw = 0, int force = 1); |
TextLineType GetTLTfromA(int s) const; |
void ChangeTLT(TGraphDraw *drw, TextLineType t); |
TextLineType GetSimpleTLT() const; |
public: |
void ResetTextLine(TGraphDraw *drw); |
TChPlayer *GetPlayer(int k) const {return player[k];} |
void SetPlayer(int k, TChPlayer *pl) {player[k] = pl;} |
int GetBottomColor() const {return BottomColor;} |
void SetBottomColor(int c) {BottomColor = c & 1;} |
public: |
enum {textlineh = 14, min_brd = 120, max_delt = 20, min_brdsize = 70}; |
int GetTextLineY() const; |
TSomeDraw *GetSomeDraw() const {return some_draw;} |
void SetSomeDraw(TSomeDraw *drw) {some_draw = drw;} |
TIntPoint GetMinWSize() const {return min_wsize;} |
void SetMinWSize(TIntPoint mws) {min_wsize = mws; Resize(width, height);} |
void SetMinWSize(int w, int h) {SetMinWSize(TIntPoint(w, h));} |
void DrawTimer(TGraphDraw *drw, double t, int wh = 0) const; |
int GetNumMove() const {return MainPlay.GetN() - 1;} |
int GetCurMoveN() const {return CurMoveN;} |
int SetCurMoveN(int n, TGraphDraw *drw = 0); |
int SetPlay(const PlayWrite &play); |
PlayWrite GetPlay() const {return MainPlay;} |
int GetPViewStatus() const {return IsPlayView;} |
void SetPViewStatus(int pv) {IsPlayView = pv;} |
void GoToCurMove(); |
int GetGameEnd() const {return game_end;} |
void EraseHistory() {hist_inited = 0;} |
int ReinitHistory(); |
protected: |
double dw_delt, dw_cell; |
int width, height; |
TProjectiveMap PoleMap; |
Position MainPos; |
int BottomColor; |
unsigned char TheMove[NUM_CELL]; |
unsigned char Eaten[NUM_CELL]; |
unsigned char BecameD; |
TIntPoint CurPoint; |
int game_end; |
int check_resize; |
TIntPoint delta_size; |
TextLineType text_line_type; |
PlayWrite MainPlay; |
TChPlayer *player[2]; |
TSomeDraw *some_draw; |
TIntPoint min_wsize; |
int CurMoveN, IsPlayView; |
THistory history; |
int hist_inited; |
}; |
inline void TSomeDraw::DrawB(TGraphDraw *drw, TChBoard &brd) |
{ |
Draw(drw, brd.GetW(), brd.GetH()); |
} |
void TChBoard::MoveErase() |
{ |
TheMove[0] = 0; |
Eaten[0] = 0; |
BecameD = 0; |
} |
TChBoard::TChBoard(int id) : history(id) |
{ |
InitBoardData(); |
player[0] = player[1] = 0; |
dw_delt = 0.3; |
dw_cell = 1; |
BottomColor = 0; |
check_resize = 0; |
delta_size.x = 0; delta_size.y = 0; |
some_draw = 0; |
min_wsize.x = 80; min_wsize.y = 80; |
ClearWH(); |
Resize(400, 400); |
NewGame(); |
} |
TProjectiveMap TChBoard::Get4PMap() const |
{ |
return TProjectiveMap().Set4(TRealPoint(-dw_delt, -dw_delt), |
TRealPoint(NW_CELL*dw_cell + dw_delt, -dw_delt), |
TRealPoint(NW_CELL*dw_cell + dw_delt, NW_CELL*dw_cell + dw_delt), |
TRealPoint(-dw_delt, NW_CELL*dw_cell + dw_delt)); |
} |
void TChBoard::Resize(int w, int h) |
{ |
width = w; height = h; |
if (width < min_wsize.x) width = min_wsize.x; |
if (height < min_wsize.y) height = min_wsize.y; |
for (;;) |
{ |
if (some_draw) |
{ |
TIntPoint dsz = some_draw->GetDSize(width, height); |
if (dsz.x >= 0 && dsz.y >= 0) delta_size = dsz; |
} |
int change = 0; |
if (width < delta_size.x + min_brdsize) |
{ |
width = delta_size.x + min_brdsize; |
change++; |
} |
if (height < delta_size.y + min_brdsize + textlineh) |
{ |
height = delta_size.y + min_brdsize + textlineh; |
change++; |
} |
if (!some_draw || !change) break; |
} |
double sx = max_delt, dx = width - 2*sx - delta_size.x; |
double sy = max_delt, dy = height - 2*sy - delta_size.y - textlineh; |
if (dy < min_brd) |
{ |
double d = (min_brd - dy) / 2; |
if (d > sy) d = sy; |
sy -= d; dy += 2*d; |
} |
if (dx < min_brd) |
{ |
double d = (min_brd - dx) / 2; |
if (d > sx) d = sx; |
sx -= d; dx += 2*d; |
} |
if (dy > dx) {sy += (dy - dx) / 2; dy = dx;} |
double tx = (dx - dy * dy / dx) / 3; |
PoleMap.Set4(TRealPoint(sx, sy + dy - 70*ssf), TRealPoint(sx + dx, sy + dy), |
TRealPoint(sx + dx - tx, sy), TRealPoint(sx + tx, sy + 40*ssf)); |
PoleMap /= Get4PMap(); |
} |
TIntPoint TChBoard::PlToWin(double x, double y) const |
{ |
if (BottomColor == 1) y = NW_CELL*dw_cell - y; |
else x = NW_CELL*dw_cell - x; |
/**/if (ssf) y += 0.6 * sin(x);/**/ |
return PoleMap(x, y).pnt(); |
} |
TRealPoint TChBoard::WinToPl(int x, int y) const |
{ |
TRealPoint rpnt; |
if (PoleMap.Reversed(x, y).rpnt(rpnt)) |
{ |
/**/if (ssf) rpnt.y -= 0.6 * sin(rpnt.x);/**/ |
if (BottomColor == 1) rpnt.y = NW_CELL*dw_cell - rpnt.y; |
else rpnt.x = NW_CELL*dw_cell - rpnt.x; |
return rpnt; |
} |
else return TRealPoint(-dw_cell - dw_delt, -dw_cell - dw_delt); |
} |
void TChBoard::NewGame() |
{ |
int k; |
MoveErase(); |
MainPos.Init(); |
MainPlay.Clear(); |
for (k = 0; k < NW_CELL * 3 / 2; k++) MainPos.SH[k] = 1; |
for (k = 0; k < NW_CELL * 3 / 2; k++) MainPos.SH[NUM_CELL - k - 1] = 2; |
MainPlay.Add(0, MainPos); |
CurMoveN = 0; |
text_line_type = TLT_Main; |
game_end = 0; |
CurPoint.x = -1; CurPoint.y = -1; |
IsPlayView = 0; |
printf("\nCheckers: New game.\n"); |
EraseHistory(); |
} |
int TChBoard::GetTextLineY() const |
{ |
int y = height - (max_delt + textlineh + delta_size.y); |
int i, j; |
for (i = 0; i <= 1; i++) for (j = 0; j <= 1; j++) |
{ |
TRealPoint corner; |
corner.x = (2*i - 1) * dw_delt + i * NW_CELL * dw_cell; |
corner.y = (2*j - 1) * dw_delt + j * NW_CELL * dw_cell; |
TIntPoint wcr = PlToWin(corner); |
if (wcr.x != INT_MIN && wcr.y != INT_MIN) |
{ |
if (y < wcr.y) y = wcr.y; |
} |
} |
y -= textlineh; |
if (y > height - delta_size.y - 2*textlineh) |
{ |
y = height - delta_size.y - 2*textlineh; |
} |
return (y + height - delta_size.y) / 2; |
} |
#ifdef BUILD_RUS |
#define aCheckersGame "£à ¢ è 誨." |
#define aRedMoves "à áë¥ å®¤ïâ." |
#define aBlueMoves "¨¨¥ 室ïâ." |
#define aWait "®¤®¦¤¨â¥." |
#define aRedWins "à áë¥ ¢ë¨£à «¨." |
#define aBlueWins "¨¨¥ ¢ë¨£à «¨." |
#define aDraw "¨çìï." |
#define aRed "à áë¥ " |
#define aBlue "¨¨¥ " |
#define aMadeWrongMove "ᤥ« «¨ ¥¯à ¢¨«ìë© å®¤." |
#define aNoMove "¥ ᬮ£«¨ ᤥ« âì 室." |
#define aEndGame "®¥æ ¨£àë." |
#define aYouWin " (ë ¢ë¨£à «¨)" |
#define aYouLose " (ë ¯à®¨£à «¨)" |
#define aRedWin " (à áë¥ ¢ë¨£à «¨)" |
#define aBlueWin " (¨¨¥ ¢ë¨£à «¨)" |
#define aWrongMove "¥¢¥àë© å®¤." |
#define aNotYourChecker "â® ¥ ¢ è è èª ." |
#define aFreeCell "â ª«¥âª ¯ãáâ ï." |
#define aNotFreeCell " 誨 ¬®£ãâ 室¨âì ⮫쪮 ᢮¡®¤ë¥ ª«¥âª¨." |
#define aMustEat "ë ¤®«¦ë ¢§ïâì è èªã." |
#define aMustEatMore "ë ¤®«¦ë ¢§ïâì ¥éñ è èªã." |
#define aCheckerNoMove " í⮩ è 誨 ¥â 室®¢." |
#define aNoBack " 誨 ¥ 室ïâ § ¤." |
#define aNotDamka "â® ¥ ¤ ¬ª ." |
#define aOnlyDiag " 誨 室ïâ ⮫쪮 ¯® ¤¨ £® «¨." |
#define aEatYour " 誨 ¥ ¬®£ãâ ¥áâì ᢮¨å." |
#define aMoreOne "ë ¥ ¬®¦¥â¥ ¢§ïâì ¡®«¥¥ ®¤®© è 誨 § à §." |
#define aNoTurnBack " 誨 ¥ ¬®£ãâ à §¢®à 稢 âìáï § ¤ ¯à¨ ¢§ï⨨." |
#else |
#define aCheckersGame "The checkers game." |
#define aRedMoves "Red moves." |
#define aBlueMoves "Blue moves." |
#define aWait "Please wait." |
#define aRedWins "Red wins." |
#define aBlueWins "Blue wins." |
#define aDraw "Draw." |
#define aRed "Red " |
#define aBlue "Blue " |
#define aMadeWrongMove "make a wrong move." |
#define aNoMove "could not make a move." |
#define aEndGame "End of the game." |
#define aYouWin " (You win)" |
#define aYouLose " (You lose)" |
#define aRedWin " (Red win)" |
#define aBlueWin " (Blue win)" |
#define aWrongMove "Wrong move." |
#define aNotYourChecker "It isn't your checker." |
#define aFreeCell "The cell is free." |
#define aNotFreeCell "Checkers may be moved only on a free cell." |
#define aMustEat "You must eat a checker." |
#define aMustEatMore "You must eat more checkers." |
#define aCheckerNoMove "The checker have no moves." |
#define aNoBack "Checkers may not be moved back." |
#define aNotDamka "It is not a damka." |
#define aOnlyDiag "Checkers may be moved only along diagonal." |
#define aEatYour "You may not eat your checkers." |
#define aMoreOne "You may not eat more than one checker at a time." |
#define aNoTurnBack "Checkers may not turn back when eating." |
#endif |
void TChBoard::GetTextLine(char str[]) const |
{ |
str[0] = 0; |
int g = (game_end - 1) % 2, h = 0; |
switch(text_line_type) |
{ |
case TLT_Main: |
strcpy(str, aCheckersGame); |
break; |
case TLT_Move: |
if (MainPos.wmove == 0) |
{ |
strcpy(str, aRedMoves); |
} |
else strcpy(str, aBlueMoves); |
break; |
case TLT_Wait: |
strcpy(str, aWait); |
break; |
case TLT_GameEnd: |
case TLT_PlDidntMove: |
case TLT_PlWrongMove: |
if (!game_end) break; |
if (text_line_type == TLT_GameEnd) |
{ |
if (game_end == 1) strcpy(str, aRedWins); |
else if (game_end == 2) strcpy(str, aBlueWins); |
else if (game_end == 5) strcpy(str, aDraw); |
} |
if (!str[0]) |
{ |
if (game_end >= 1 && game_end <= 4) |
{ |
if (g == 0) strcpy(str, aRed); |
else strcpy(str, aBlue); |
if (text_line_type == TLT_PlWrongMove) |
{ |
strcat(str, aMadeWrongMove); |
} |
else strcat(str, aNoMove); |
h = 1; |
} |
else strcpy(str, aEndGame); |
} |
if (game_end >= 1 && game_end <= 4) |
{ |
if (!IsPlayView && player[1-g] && !player[g]) |
{ |
strcat(str, aYouWin); |
} |
else if (!IsPlayView && player[g] && !player[1-g]) |
{ |
strcat(str, aYouLose); |
} |
else if (h && g == 0) strcat(str, aRedWin); |
else if (h && g == 1) strcat(str, aBlueWin); |
} |
break; |
case TLT_WrongMove: |
strcpy(str, aWrongMove); |
break; |
case TLT_WrongColor: |
strcpy(str, aNotYourChecker); |
break; |
case TLT_WfCell: |
strcpy(str, aFreeCell); |
break; |
case TLT_WnfCell: |
strcpy(str, aNotFreeCell); |
break; |
case TLT_WMustEat: |
strcpy(str, aMustEat); |
break; |
case TLT_WMustEatMore: |
case TLT_WMustEatMoreD: |
strcpy(str, aMustEatMore); |
break; |
case TLT_WNoMove: |
strcpy(str, aCheckerNoMove); |
break; |
case TLT_WChBack: |
strcpy(str, aNoBack); |
break; |
case TLT_WNotDm: |
case TLT_WNotDmE: |
strcpy(str, aNotDamka); |
break; |
case TLT_WOnlyDiag: |
strcpy(str, aOnlyDiag); |
break; |
case TLT_WEatYour: |
strcpy(str, aEatYour); |
break; |
case TLT_WMoreOne: |
strcpy(str, aMoreOne); |
break; |
case TLT_WTurnBack: |
strcpy(str, aNoTurnBack); |
break; |
} |
} |
void TChBoard::DrawTextLine(TGraphDraw *drw) const |
{ |
if (!drw || !drw->IsDraw()) return; |
char str[100]; |
GetTextLine(str); |
if (str[0]) drw->DrawText(10, GetTextLineY(), str); |
} |
void TChBoard::ResetTextLine(TGraphDraw *drw) |
{ |
if (!game_end && text_line_type != TLT_Move) ChangeTLT(drw, TLT_Move); |
} |
void TChBoard::LineB(TGraphDraw *drw, double x1, double y1, double x2, double y2) const |
{ |
if (!drw || !drw->IsDraw()) return; |
TIntPoint p1 = PlToWin(x1, y1), p2 = PlToWin(x2, y2); |
if (p1.x != INT_MIN && p1.y != INT_MIN && p2.x != INT_MIN && p2.y != INT_MIN) |
{ |
drw->DrawLine(p1.x, p1.y, p2.x, p2.y); |
} |
} |
void TChBoard::DrawCh(TGraphDraw *drw, double x0, double y0, const TRealPoint pnt[], int npnt, int L) const |
{ |
if (!drw || !drw->IsDraw()) return; |
int i, j; |
for (j = 0; j < L; j++) |
{ |
for (i = 0; i < npnt - 1; i++) |
{ |
LineB(drw, x0 + pnt[i].x * dw_cell * r_ch_lines[j] / 2, |
y0 + pnt[i].y * dw_cell * r_ch_lines[j] / 2, |
x0 + pnt[i+1].x * dw_cell * r_ch_lines[j] / 2, |
y0 + pnt[i+1].y * dw_cell * r_ch_lines[j] / 2); |
} |
} |
} |
void TChBoard::DrawIL(TGraphDraw *drw, double x0, double y0, int L) const |
{ |
if (!drw || !drw->IsDraw()) return; |
int i, j; |
if (L == 0 || L == 1) |
{ |
const int numDST[2] = {2, 4}; |
const double DST[2][4] = {{0.96, 0.88}, {0.8, 0.76, 0.72, 0.68}}; |
const int MULT[4][4] = {{-1, -1, -1, 1}, {-1, 1, 1, 1}, |
{-1, -1, 1, -1}, {1, -1, 1, 1}}; |
for (i = 0; i < numDST[L]; i++) for (j = 0; j < 4; j++) |
{ |
LineB(drw, x0 + dw_cell * DST[L][i] * MULT[j][0] / 2, |
y0 + dw_cell * DST[L][i] * MULT[j][1] / 2, |
x0 + dw_cell * DST[L][i] * MULT[j][2] / 2, |
y0 + dw_cell * DST[L][i] * MULT[j][3] / 2); |
} |
} |
else if (L == 2) |
{ |
const double DP[] = {0.85, 0.90, 0.95}; |
const int numDP = NELEM(DP); |
for (i = 0; i < numDP; i++) for (j = -1; j <= 1; j += 2) |
{ |
LineB(drw, x0 - j * dw_cell * DP[i] / 2, |
y0 - dw_cell * DP[numDP - i - 1] / 2, |
x0 + j * dw_cell * DP[numDP - i - 1] / 2, |
y0 + dw_cell * DP[i] / 2); |
} |
} |
} |
void TChBoard::Draw(TGraphDraw *drw) |
{ |
if (!drw || !drw->IsDraw()) return; |
if (CheckResize(drw)) drw->DrawClear(); |
int i, j, k, kn; |
unsigned long black = drw->GetBlackColor(); |
unsigned long red = drw->CreateColor(65535u, 0, 0); |
unsigned long green = drw->CreateColor(0, 49151u, 0); |
unsigned long blue = drw->CreateColor(0, 0, 65535u); |
drw->SetColor(black); |
for (i = -1; i <= NW_CELL + 1; i++) for (j = -1; j <= NW_CELL; j++) |
{ |
if (i < 0 || i > NW_CELL || j >= 0 && j < NW_CELL) |
{ |
double mval = dw_cell * NW_CELL + dw_delt; |
double x, y0, y1; |
if (i < 0) x = -dw_delt; |
else if (i > NW_CELL) x = mval; |
else x = i * dw_cell; |
if (j < 0) y0 = -dw_delt; |
else if (j > NW_CELL) y0 = mval; |
else y0 = j * dw_cell; |
if ((j+1) < 0) y1 = -dw_delt; |
else if ((j+1) > NW_CELL) y1 = mval; |
else y1 = (j+1) * dw_cell; |
LineB(drw, x, y0, x, y1); |
} |
} |
for (i = -1; i <= NW_CELL; i++) for (j = -1; j <= NW_CELL + 1; j++) |
{ |
if (j < 0 || j > NW_CELL || i >= 0 && i < NW_CELL) |
{ |
double mval = dw_cell * NW_CELL + dw_delt; |
double x0, x1, y; |
if (i < 0) x0 = -dw_delt; |
else if (i > NW_CELL) x0 = mval; |
else x0 = i * dw_cell; |
if ((i+1) < 0) x1 = -dw_delt; |
else if ((i+1) > NW_CELL) x1 = mval; |
else x1 = (i+1) * dw_cell; |
if (j < 0) y = -dw_delt; |
else if (j > NW_CELL) y = mval; |
else y = j * dw_cell; |
LineB(drw, x0, y, x1, y); |
} |
} |
for (i = -1; i <= 1; i += 2) |
{ |
drw->SetColor((i < 0) ? red : blue); |
for (j = -1; j <= 1; j += 2) |
{ |
double c = dw_cell * NW_CELL / 2; |
double d = (dw_cell/2 > dw_delt) ? dw_delt : dw_cell/2; |
LineB(drw, c + j * (c + 0.5*d), c + i * (c - 0.5*d), |
c + j * (c + 0.5*d), c + i * (c - 3.5*d)); |
LineB(drw, c + j * (c + 0.5*d), c + i * (c - 3.5*d), |
c + j * (c + 0.2*d), c + i * (c - 2.5*d)); |
LineB(drw, c + j * (c + 0.5*d), c + i * (c - 3.5*d), |
c + j * (c + 0.8*d), c + i * (c - 2.5*d)); |
LineB(drw, c + j * (c + 0.2*d), c + i * (c - 2.5*d), |
c + j * (c + 0.8*d), c + i * (c - 2.5*d)); |
} |
} |
for (i = 0; i < NW_CELL; i++) for (j = 0; j < NW_CELL; j++) |
{ |
if (!PoleCpos(i, j)) |
{ |
drw->SetColor(black); |
LineB(drw, (i+0.33) * dw_cell, j * dw_cell, (i+0.33) * dw_cell, (j+1) * dw_cell); |
LineB(drw, (i+0.67) * dw_cell, j * dw_cell, (i+0.67) * dw_cell, (j+1) * dw_cell); |
LineB(drw, i * dw_cell, (j+0.33) * dw_cell, (i+1) * dw_cell, (j+0.33) * dw_cell); |
LineB(drw, i * dw_cell, (j+0.67) * dw_cell, (i+1) * dw_cell, (j+0.67) * dw_cell); |
LineB(drw, i * dw_cell, j * dw_cell, (i+1) * dw_cell, (j+1) * dw_cell); |
LineB(drw, (i+1) * dw_cell, j * dw_cell, i * dw_cell, (j+1) * dw_cell); |
} |
else |
{ |
k = PoleToNum(i, j); |
kn = MainPos.SH[k]; |
if (TheMove[0] > 0 && k == TheMove[1]) |
{ |
if (kn == 1 || kn == 2) kn = 5; |
else if (kn == 3 || kn == 4) kn = 6; |
} |
if (TheMove[0] > 0 && k == TheMove[TheMove[0]]) |
{ |
kn = MainPos.SH[TheMove[1]]; |
if (kn <= 2 && BecameD) kn += 2; |
} |
if (kn == 1) |
{ |
drw->SetColor(red); |
DrawCh(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, |
r_circle_pnt, NELEM(r_circle_pnt)); |
} |
else if (kn == 2) |
{ |
drw->SetColor(blue); |
DrawCh(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, |
r_circle_pnt, NELEM(r_circle_pnt)); |
} |
else if (kn == 3) |
{ |
drw->SetColor(red); |
DrawCh(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, |
r_star_pnt, NELEM(r_star_pnt)); |
} |
else if (kn == 4) |
{ |
drw->SetColor(blue); |
DrawCh(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, |
r_star_pnt, NELEM(r_star_pnt)); |
} |
else if (kn == 5) |
{ |
drw->SetColor(green); |
DrawCh(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, |
r_circle_pnt, NELEM(r_circle_pnt), 2); |
} |
else if (kn == 6) |
{ |
drw->SetColor(green); |
DrawCh(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, |
r_circle_pnt, NELEM(r_circle_pnt), 2); |
} |
} |
} |
for (k = 1; k <= Eaten[0]; k++) |
{ |
if (TheMove[0] <= 0 || Eaten[k] != TheMove[TheMove[0]]) |
{ |
NumToPole(Eaten[k], i, j); |
kn = MainPos.SH[Eaten[k]]; |
if (kn) |
{ |
if (kn == 1 || kn == 3) drw->SetColor(blue); |
else if (kn == 2 || kn == 4) drw->SetColor(red); |
DrawIL(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, 2); |
} |
} |
} |
if (TheMove[0] > 0) |
{ |
NumToPole(TheMove[TheMove[0]], i, j); |
drw->SetColor(green); |
DrawIL(drw, (i+0.5)*dw_cell, (j+0.5)*dw_cell, 1); |
} |
if (CurPoint.x >= 0 && CurPoint.y >= 0) |
{ |
drw->SetColor(green); |
DrawIL(drw, (CurPoint.x+0.5)*dw_cell, (CurPoint.y+0.5)*dw_cell, 0); |
} |
drw->SetColor(black); |
DrawTextLine(drw); |
if (some_draw) some_draw->DrawB(drw, *this); |
drw->FreeColor(red); |
drw->FreeColor(green); |
drw->FreeColor(blue); |
} |
int TChBoard::ResizeDraw(TGraphDraw *drw, int w, int h) |
{ |
int w0 = width, h0 = height; |
Resize(w, h); |
if (drw && drw->IsDraw() && (width != w0 || height != h0)) |
{ |
drw->DrawClear(); |
Draw(drw); |
return 1; |
} |
else return 0; |
} |
int TChBoard::CheckResize(TGraphDraw *drw) |
{ |
if (!drw || !check_resize) return 0; |
int w, h; |
drw->GetSize(w, h); |
if (w < 0 || h < 0) return 0; |
int w0 = width, h0 = height; |
Resize(w, h); |
return width != w0 || height != h0; |
} |
void TChBoard::CurPointClear(TGraphDraw *drw) const |
{ |
if (!drw || !drw->IsDraw()) return; |
drw->SetColor(drw->GetWhiteColor()); |
DrawIL(drw, (CurPoint.x+0.5)*dw_cell, (CurPoint.y+0.5)*dw_cell, 0); |
} |
int TChBoard::MouseClick(TGraphDraw *drw, int x, int y) |
{ |
TRealPoint rpnt = WinToPl(x, y); |
if (rpnt.x < -dw_delt || rpnt.y < -dw_delt || |
rpnt.x > NW_CELL*dw_cell + dw_delt || |
rpnt.y > NW_CELL*dw_cell + dw_delt) return -1; |
if (CurPoint.x >= 0 && CurPoint.y >= 0) |
{ |
CurPointClear(drw); |
CurPoint.x = -1; CurPoint.y = -1; |
Draw(drw); |
} |
ResetTextLine(drw); |
if (AutoMove(drw)) return 3; |
if (!CanPlayerMove()) return 0; |
int i = (int)floor(rpnt.x / dw_cell), j = (int)floor(rpnt.y / dw_cell); |
if (i < 0 || j < 0 || i >= NW_CELL || j >= NW_CELL) return 0; |
if (!PoleCpos(i, j)) return 1; |
return 2 + CMove(drw, i, j); |
} |
TChBoard::PKey TChBoard::GetKeySide(PKey key) |
{ |
if (key != PLeft && key != PRight && key != PUp && key != PDown) return key; |
TIntPoint a0 = PlToWin(4*dw_cell, 0); |
TIntPoint a1 = PlToWin(4*dw_cell, 8*dw_cell); |
TIntPoint b0 = PlToWin(0, 4*dw_cell); |
TIntPoint b1 = PlToWin(8*dw_cell, 4*dw_cell); |
double ax = a0.x - a1.x, ay = a0.y - a1.y; |
double bx = b0.x - b1.x, by = b0.y - b1.y; |
double t; |
if (a0.x == INT_MIN || a0.y == INT_MIN || a1.x == INT_MIN || |
a1.y == INT_MIN || fabs(ax) < 0.5 && fabs(ay) < 0.5) |
{ |
ax = 0, ay = 1; |
} |
if (b0.x == INT_MIN || b0.y == INT_MIN || b1.x == INT_MIN || |
b1.y == INT_MIN || fabs(bx) < 0.5 && fabs(by) < 0.5) |
{ |
bx = 1, by = 0; |
} |
t = fabs(ax) + fabs(ay); ax /= t; ay /= t; |
t = fabs(bx) + fabs(by); bx /= t; by /= t; |
if (fabs(ax) <= fabs(bx)) |
{ |
if (key == PLeft) return (bx > 0) ? PRight : PLeft; |
if (key == PRight) return (bx > 0) ? PLeft : PRight; |
if (key == PUp) return (ay > 0) ? PDown : PUp; |
if (key == PDown) return (ay > 0) ? PUp : PDown; |
} |
else |
{ |
if (key == PLeft) return (ax > 0) ? PDown : PUp; |
if (key == PRight) return (ax > 0) ? PUp : PDown; |
if (key == PUp) return (by > 0) ? PRight : PLeft; |
if (key == PDown) return (by > 0) ? PLeft : PRight; |
} |
return PNull; |
} |
int TChBoard::PKeyEvent(TGraphDraw *drw, PKey key) |
{ |
ResetTextLine(drw); |
if (AutoMove(drw)) return 3; |
if (!CanPlayerMove()) return 0; |
key = GetKeySide(key); |
if (CurPoint.x < 0 || CurPoint.y < 0 || |
CurPoint.x >= NW_CELL || CurPoint.y >= NW_CELL) |
{ |
CurPoint.x = NW_CELL / 2; |
CurPoint.y = NW_CELL / 2; |
Draw(drw); |
return 1; |
} |
if (key == PEnter) return 2 + CMove(drw, CurPoint.x, CurPoint.y); |
if (drw && drw->IsDraw() && CheckResize(drw)) |
{ |
drw->DrawClear(); |
Draw(drw); |
} |
if (key == PLeft) |
{ |
if (CurPoint.x == 0) return 0; |
CurPointClear(drw); |
CurPoint.x--; |
Draw(drw); |
return 1; |
} |
else if (key == PRight) |
{ |
if (CurPoint.x == NW_CELL - 1) return 0; |
CurPointClear(drw); |
CurPoint.x++; |
Draw(drw); |
return 1; |
} |
else if (key == PUp) |
{ |
if (CurPoint.y == 0) return 0; |
CurPointClear(drw); |
CurPoint.y--; |
Draw(drw); |
return 1; |
} |
else if (key == PDown) |
{ |
if (CurPoint.y == NW_CELL - 1) return 0; |
CurPointClear(drw); |
CurPoint.y++; |
Draw(drw); |
return 1; |
} |
else return 0; |
} |
void TChBoard::UnMove(TGraphDraw *drw) |
{ |
MoveErase(); |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
Draw(drw); |
} |
} |
TChBoard::TextLineType TChBoard::GetTLTfromA(int s) const |
{ |
if (s >= 0) return TLT_Main; |
switch(s) |
{ |
case Position::AWColor: return TLT_WrongColor; |
case Position::AfCell: return TLT_WfCell; |
case Position::AnfCell: return TLT_WnfCell; |
case Position::AMustEat: return TLT_WMustEat; |
case Position::AMustEatMore: return TLT_WMustEatMore; |
case Position::AMustEatMoreD: return TLT_WMustEatMoreD; |
case Position::ANoMove: return TLT_WNoMove; |
case Position::AChBack: return TLT_WChBack; |
case Position::ANotDm: return TLT_WNotDm; |
case Position::ANotDmE: return TLT_WNotDmE; |
case Position::AOnlyDiag: return TLT_WOnlyDiag; |
case Position::AEatYour: return TLT_WEatYour; |
case Position::AMoreOne: return TLT_WMoreOne; |
case Position::ATurnBack: return TLT_WTurnBack; |
default: return TLT_WrongMove; |
} |
} |
void TChBoard::ChangeTLT(TGraphDraw *drw, TextLineType t) |
{ |
if (text_line_type == t) return; |
if (drw && drw->IsDraw()) |
{ |
drw->SetColor(drw->GetWhiteColor()); |
DrawTextLine(drw); |
} |
text_line_type = t; |
if (drw && drw->IsDraw()) |
{ |
drw->SetColor(drw->GetBlackColor()); |
DrawTextLine(drw); |
} |
} |
TChBoard::TextLineType TChBoard::GetSimpleTLT() const |
{ |
if (game_end && CurMoveN >= MainPlay.GetN() - 1) return TLT_GameEnd; |
else return TLT_Move; |
} |
inline int TChBoard::ReinitHistory() |
{ |
if (history.Play(MainPlay)) {hist_inited = 1; return 1;} |
else {hist_inited = 0; return 0;} |
} |
void TChBoard::PrintLMove() |
{ |
PlayWrite::PMv pmv; |
if (MainPlay.GetMoveL(pmv.mv) >= 0) |
{ |
MainPlay.GetPosL(pmv.pos, 1); |
char *s = new char[pmv.pos.GetLenMvEx(pmv.mv, 11)]; |
if (s) |
{ |
pmv.pos.WriteMvEx(pmv.mv, s, 11); |
printf("Checkers: %s%s\n", (pmv.pos.wmove == 1) ? "..." : "", s); |
delete[] s; |
} |
if (!hist_inited) ReinitHistory(); |
else history.Move(pmv.pos, pmv.mv, MainPlay.GetN() - 1); |
} |
} |
int TChBoard::CMove(TGraphDraw *drw, int x, int y) |
{ |
if (AutoMove(drw)) return 1; |
if (!CanPlayerMove()) return 0; |
if (!game_end && text_line_type != TLT_Move) ChangeTLT(drw, TLT_Move); |
int k = PoleToNum(x, y), s; |
if (TheMove[0] > 0) |
{ |
if (!PoleCpos(x, y) || k == TheMove[TheMove[0]]) {UnMove(drw); return 1;} |
int e = 1; |
s = MainPos.AMove(TheMove, k, e); |
if (s < 0) |
{ |
ChangeTLT(drw, GetTLTfromA(s)); |
return 0; |
} |
if (s < NUM_CELL) Eaten[++Eaten[0]] = (unsigned char)s; |
TheMove[++TheMove[0]] = (unsigned char)k; |
BecameD = BecameD || MainPos.BecameD(k, MainPos.SH[TheMove[1]]); |
if (e == 0) |
{ |
if (MainPlay.Add(TheMove) != 0) |
{ |
ChangeTLT(drw, TLT_WrongMove); |
return 0; |
} |
CurMoveN = MainPlay.GetN() - 1; |
MoveErase(); |
RenewMPos(); |
PrintLMove(); |
if (AutoMove(drw)) return 1; |
} |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
Draw(drw); |
} |
return 1; |
} |
else |
{ |
if (!PoleCpos(x, y)) return 0; |
s = MainPos.AChCell(k); |
if (s != 1) |
{ |
ChangeTLT(drw, GetTLTfromA(s)); |
return 0; |
} |
TheMove[0] = 1; |
TheMove[1] = (unsigned char)k; |
Draw(drw); |
return 1; |
} |
} |
void TChBoard::SetNoMove(TGraphDraw *drw, int force) |
{ |
if (!force && CurPoint.x < 0 && CurPoint.y < 0 && TheMove[0] == 0 && Eaten[0] == 0) |
{ |
return; |
} |
CurPoint.x = -1; CurPoint.y = -1; |
MoveErase(); |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
Draw(drw); |
} |
} |
int TChBoard::AutoMove(TGraphDraw *drw, int nmove, int draw_check) |
{ |
if (game_end || IsPlayView) {SetNoMove(drw, 0); return 0;} |
if (CurMoveN < MainPlay.GetN() - 1) |
{ |
CurMoveN = MainPlay.GetN() - 1; |
RenewMPos(); |
SetNoMove(drw); |
return 2; |
} |
if (!MainPos.AllCanEat() && !MainPos.AllCanMove()) |
{ |
game_end = 2 - MainPos.wmove; |
ChangeTLT(drw, TLT_GameEnd); |
if (!player[game_end - 1]) printf("Checkers: You win.\n"); |
else printf("Checkers: You lose.\n"); |
SetNoMove(drw); |
return 3; |
} |
else if (draw_check > 0 && MainPlay.IsDraw()) |
{ |
game_end = 5; |
ChangeTLT(drw, TLT_GameEnd); |
printf("Checkers: Draw.\n"); |
SetNoMove(drw); |
return 3; |
} |
if (!player[MainPos.wmove]) return 0; |
TIntPoint CurP0 = CurPoint; |
if (CurPoint.x >= 0 && CurPoint.y >= 0) |
{ |
if (drw) CurPointClear(drw); |
CurPoint.x = -1; CurPoint.y = -1; |
} |
MoveErase(); |
int k; |
for (k = 0; player[MainPos.wmove] && (k < nmove || nmove == 0); k++) |
{ |
TChPlayer::PMv pmv; |
pmv.pos = MainPos; |
Position::SetNullMv(pmv.mv); |
MainPlay.GetMoveL(pmv.mv); |
text_line_type = TLT_Move; |
if (!player[MainPos.wmove]->Move(pmv)) |
{ |
text_line_type = TLT_PlDidntMove; |
game_end = 4 - MainPos.wmove; |
break; |
} |
if (MainPlay.Add(pmv.mv) != 0) |
{ |
text_line_type = TLT_PlWrongMove; |
game_end = 4 - MainPos.wmove; |
break; |
} |
CurMoveN = MainPlay.GetN() - 1; |
MoveErase(); |
RenewMPos(); |
PrintLMove(); |
if (!MainPos.AllCanEat() && !MainPos.AllCanMove()) |
{ |
game_end = 2 - MainPos.wmove; |
text_line_type = TLT_GameEnd; |
if (!player[game_end - 1]) printf("Checkers: You win.\n"); |
else printf("Checkers: You lose.\n"); |
break; |
} |
else if (draw_check >= 0 && MainPlay.IsDraw()) |
{ |
game_end = 5; |
text_line_type = TLT_GameEnd; |
printf("Checkers: Draw.\n"); |
break; |
} |
} |
if (!game_end) |
{ |
text_line_type = TLT_Move; |
CurPoint = CurP0; |
} |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
Draw(drw); |
} |
return 1; |
} |
void TChBoard::DrawTimer(TGraphDraw *drw, double t, int wh) const |
{ |
if (!drw || !drw->IsDraw()) return; |
if (wh) drw->SetColor(drw->GetWhiteColor()); |
else drw->SetColor(drw->GetBlackColor()); |
double r1 = dw_delt * 0.4, r2 = dw_delt * 0.45; |
double x = t * dw_cell * NW_CELL, y = -dw_delt / 2; |
if (MainPos.wmove == 1) |
{ |
x = dw_cell * NW_CELL - x; |
y = dw_cell * NW_CELL - y; |
} |
LineB(drw, x - r1, y - r2, x + r2, y + r1); |
LineB(drw, x - r2, y - r1, x + r1, y + r2); |
LineB(drw, x - r1, y + r2, x + r2, y - r1); |
LineB(drw, x - r2, y + r1, x + r1, y - r2); |
if (wh) |
{ |
int i, j, jj; |
drw->SetColor(drw->GetBlackColor()); |
for (i = -1; i <= NW_CELL; i++) |
{ |
double mval = dw_cell * NW_CELL + dw_delt; |
double x0, x1, y; |
if (i < 0) x0 = -dw_delt; |
else if (i > NW_CELL) x0 = mval; |
else x0 = i * dw_cell; |
if ((i+1) < 0) x1 = -dw_delt; |
else if ((i+1) > NW_CELL) x1 = mval; |
else x1 = (i+1) * dw_cell; |
if (fabs(x0 - x) < dw_delt || fabs(x1 - x) < dw_delt) |
{ |
for (jj = 0; jj <= 1; jj++) |
{ |
if (MainPos.wmove == 1) j = NW_CELL + jj; |
else j = -jj; |
if (j < 0 || j > NW_CELL || i >= 0 && i < NW_CELL) |
{ |
if (j < 0) y = -dw_delt; |
else if (j > NW_CELL) y = mval; |
else y = j * dw_cell; |
LineB(drw, x0, y, x1, y); |
} |
} |
} |
} |
} |
} |
int TChBoard::SetCurMoveN(int n, TGraphDraw *drw) |
{ |
int nmove = MainPlay.GetN() - 1; |
if (n > nmove) n = nmove; |
if (n < 0) n = 0; |
if (CurMoveN != n) |
{ |
CurMoveN = n; |
RenewMPos(); |
if (n < nmove) |
{ |
MoveErase(); |
CurPoint.x = -1; CurPoint.y = -1; |
} |
text_line_type = GetSimpleTLT(); |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
Draw(drw); |
} |
return 1; |
} |
else return 0; |
} |
int TChBoard::SetPlay(const PlayWrite &play) |
{ |
if (play.GetN() <= 0) return 0; |
MainPlay = play; |
MoveErase(); |
CurPoint.x = -1; CurPoint.y = -1; |
CurMoveN = INT_MIN; |
SetCurMoveN(play.GetN()); |
if (!MainPos.AllCanEat() && !MainPos.AllCanMove()) game_end = 2 - MainPos.wmove; |
else if (MainPlay.IsDraw()) game_end = 5; |
else game_end = 0; |
text_line_type = GetSimpleTLT(); |
IsPlayView = 1; |
EraseHistory(); |
return 1; |
} |
void TChBoard::GoToCurMove() |
{ |
if (!MainPos.AllCanEat() && !MainPos.AllCanMove() || |
MainPlay.IsDraw(CurMoveN + 1)) return; |
MainPlay.ClearFrom(CurMoveN + 1); |
MoveErase(); |
game_end = 0; |
text_line_type = GetSimpleTLT(); |
IsPlayView = 0; |
} |
#endif //_HEADER_BOARD_H |
/programs/games/checkers/trunk/buttons.h |
---|
0,0 → 1,355 |
#ifndef _HEADER_BUTTONS_H |
#define _HEADER_BUTTONS_H |
#ifndef __MENUET__ |
#include <string.h> |
#include <stdlib.h> |
#include <limits.h> |
#endif |
#include "gr-draw.h" |
struct TXButton |
{ |
TXButton(int n = -1, int w = 100, int h = 20) : num(n), w(w), h(h), drw(1) {} |
TXButton(const TXButton &b) : w(b.w), h(b.h) {} |
TXButton &operator=(const TXButton &b) {w = b.w; h = b.h; num = b.num; return *this;} |
virtual void Draw(TGraphDraw *drw, int x0, int y0, |
unsigned long dcolor, unsigned long lcolor, unsigned long tcolor, int ins = 0); |
virtual int ButtonPnt(int xp, int yp, int &n, int kind = 0); |
int num, w, h, drw; |
}; |
void TXButton::Draw(TGraphDraw *drw, int x0, int y0, |
unsigned long dcolor, unsigned long /*lcolor*/, |
unsigned long /*tcolor*/, int /*ins*/) |
{ |
if (!drw || !drw->IsDraw()) return; |
drw->SetColor(dcolor); |
drw->DrawLine(x0, y0, x0 + w, y0); |
drw->DrawLine(x0, y0, x0, y0 + h); |
drw->DrawLine(x0 + w, y0, x0 + w, y0 + h); |
drw->DrawLine(x0, y0 + h, x0 + w, y0 + h); |
} |
int TXButton::ButtonPnt(int xp, int yp, int &n, int /*kind*/) |
{ |
n = num; |
return (xp >= 0 && yp >= 0 && xp <= w && yp <= h) ? 1 : INT_MIN; |
} |
struct TextButton : public TXButton |
{ |
enum {thick_def = 3}; |
TextButton(int n = -1, int w = 100, int h = 20, char *text = 0, int thick = thick_def) |
: TXButton(n, w, h), text(text), thick(thick) {CheckDefW();} |
TextButton(const TXButton &b, char *text = 0, int thick = thick_def) |
: TXButton(b), text(text), thick(thick) {CheckDefW();} |
TextButton(const TextButton &b) : TXButton(b), text(b.text), thick(b.thick) {} |
TextButton &operator=(const TextButton &b); |
virtual void Draw(TGraphDraw *drw, int x0, int y0, |
unsigned long dcolor, unsigned long lcolor, unsigned long tcolor, int ins = 0); |
void CheckDefW(); |
int thick; |
char *text; |
}; |
inline TextButton &TextButton::operator=(const TextButton &b) |
{ |
text = b.text; |
TXButton::operator=(b); |
return *this; |
} |
void TextButton::Draw(TGraphDraw *drw, int x0, int y0, |
unsigned long dcolor, unsigned long lcolor, unsigned long tcolor, int ins) |
{ |
if (!drw || !drw->IsDraw()) return; |
int i; |
if (thick <= -1 && thick >= -5) |
{ |
drw->SetColor(dcolor); |
for (i = 0; i < -thick; i++) |
{ |
drw->DrawLine(x0 + i, y0 + i, x0 + w - i, y0 + i); |
drw->DrawLine(x0 + i, y0 + i, x0 + i, y0 + h - i); |
drw->DrawLine(x0 + w - i, y0 + i, x0 + w - i, y0 + h - i); |
drw->DrawLine(x0 + i, y0 + h - i, x0 + w - i, y0 + h - i); |
} |
} |
else if (thick > 0) |
{ |
for (i = 0; i < thick; i++) |
{ |
drw->SetColor(ins ? dcolor : lcolor); |
drw->DrawLine(x0 + i, y0 + i, x0 + w - i, y0 + i); |
drw->DrawLine(x0 + i, y0 + i, x0 + i, y0 + h - i); |
drw->SetColor(ins ? lcolor : dcolor); |
drw->DrawLine(x0 + w - i, y0 + i, x0 + w - i, y0 + h - i); |
drw->DrawLine(x0 + i, y0 + h - i, x0 + w - i, y0 + h - i); |
} |
} |
else TXButton::Draw(drw, x0, y0, dcolor, lcolor, tcolor, ins); |
if (text) |
{ |
drw->SetColor(tcolor); |
drw->DrawText(x0 + 7, y0 + (h - drw->GetTextH(text)) / 2, text); |
} |
} |
inline void TextButton::CheckDefW() |
{ |
if (w < 0 && text) w = 15 + strlen(text) * 8; |
} |
class TXButtonArray |
{ |
public: |
TXButtonArray(int d = 10) : button(0), nbutton(0), mbutton(0), |
delt(d), ins(-1), k_ins(0) {} |
~TXButtonArray() {Clear();} |
void Clear(); |
void Add(TXButton *bt); |
void Add(int n = -1, int w = 100, int h = 20, char *str = 0, |
int thick = TextButton::thick_def); |
TXButton *operator[](int i) {return button[i];} |
int GetNButton() const {return nbutton;} |
int GetInsert() const {return ins;} |
TXButton *GetButton(int n); |
int GetDelt() const {return delt;} |
void SetDelt(int d) {delt = d;} |
int GetParam(int w, int p) const; |
int GetNumStr(int w) const {return GetParam(w, 0);} |
int GetHeight(int w) const {return GetParam(w, 1);} |
int GetFWidth() const; |
void Draw(TGraphDraw *drw, int x0, int y0, int w); |
void Draw(TGraphDraw *drw, int x0, int y0, int w, |
unsigned long dcolor, unsigned long lcolor, unsigned long tcolor, int insd = 1); |
int ButtonPnt(int xp, int yp, int w, int &n, int kind = 0); |
protected: |
void Extend(int n = -1); |
TXButton **button; |
int nbutton, mbutton; |
int delt; |
int ins, k_ins; |
}; |
void TXButtonArray::Clear() |
{ |
int i; |
if (button) |
{ |
for (i = 0; i < nbutton; i++) if (button[i]) delete button[i]; |
delete[] button; |
} |
button = 0; nbutton = 0; mbutton = 0; |
} |
void TXButtonArray::Extend(int n) |
{ |
if (n < 0) n = nbutton + 1; |
if (mbutton < n) |
{ |
typedef TXButton *TXButtonPnt; |
TXButton **b_old = button; |
int m_old = mbutton; |
mbutton = n * 2; |
button = new TXButtonPnt[mbutton]; |
for (int i = 0; i < mbutton; i++) button[i] = 0; |
if (b_old) |
{ |
for (int i = 0; i < m_old; i++) button[i] = b_old[i]; |
delete[] b_old; |
} |
} |
} |
void TXButtonArray::Add(TXButton *bt) |
{ |
Extend(); |
if (button[nbutton]) delete[] button[nbutton]; |
button[nbutton] = bt; |
nbutton++; |
} |
void TXButtonArray::Add(int n, int w, int h, char *str, int thick) |
{ |
if (thick < 0 && !str) Add(new TXButton(n, w, h)); |
else Add(new TextButton(n, w, h, str, thick)); |
} |
TXButton *TXButtonArray::GetButton(int n) |
{ |
int i; |
for (i = 0; i < nbutton; i++) |
{ |
if (button[i] && button[i]->num == n) return button[i]; |
} |
return 0; |
} |
int TXButtonArray::GetFWidth() const |
{ |
int i, x = 0; |
for (i = 0; i < nbutton; i++) |
{ |
if (button[i] && button[i]->drw > 0) x += button[i]->w + delt; |
} |
if (x != 0) x -= delt; |
return x; |
} |
int TXButtonArray::GetParam(int w, int p) const |
{ |
int i, k = 0; |
int x = 0, y = 0, ym = 0; |
for (i = 0; i < nbutton; i++) if (button[i] && button[i]->drw > 0) |
{ |
int xx = x + button[i]->w + delt; |
if (x != 0 && xx > w + delt) |
{ |
k++; y += ym + delt; ym = 0; |
x = 0; xx = x + button[i]->w + delt; |
} |
x = xx; |
if (ym < button[i]->h) ym = button[i]->h; |
} |
if (x != 0) {k++; y += ym;} |
else if (y != 0) y -= delt; |
if (p == 0) return k; |
else if (p == 1) return y; |
else return -1; |
} |
void TXButtonArray::Draw(TGraphDraw *drw, int x0, int y0, int w) |
{ |
const unsigned short power_gray = 49152U; |
unsigned long black = drw->GetBlackColor(); |
unsigned long grey = drw->CreateColor(power_gray, power_gray, power_gray); |
Draw(drw, x0, y0, w, black, grey, black, 1); |
drw->FreeColor(grey); |
} |
void TXButtonArray::Draw(TGraphDraw *drw, int x0, int y0, int w, |
unsigned long dcolor, unsigned long lcolor, unsigned long tcolor, int insd) |
{ |
int i; |
int x = 0, y = 0, ym = 0; |
if (!insd && ins >= 0) k_ins = 2; |
for (i = 0; i < nbutton; i++) if (button[i] && button[i]->drw > 0) |
{ |
int xx = x + button[i]->w + delt; |
if (x != 0 && xx > w + delt) |
{ |
y += ym + delt; ym = 0; |
x = 0; xx = x + button[i]->w + delt; |
} |
button[i]->Draw(drw, x0 + x, y0 + y, |
dcolor, lcolor, tcolor, k_ins == 1 && ins == i); |
x = xx; |
if (ym < button[i]->h) ym = button[i]->h; |
} |
} |
int TXButtonArray::ButtonPnt(int xp, int yp, int w, int &n, int kind) |
{ |
int i; |
int x = 0, y = 0, ym = 0; |
if (ins < 0 && (kind == 2 || kind == 3)) return INT_MIN; |
for (i = 0; i < nbutton; i++) if (button[i] && button[i]->drw > 0) |
{ |
int xx = x + button[i]->w + delt; |
if (x != 0 && xx > w + delt) |
{ |
y += ym + delt; ym = 0; |
x = 0; xx = x + button[i]->w + delt; |
} |
if (ins < 0 || i == ins) |
{ |
int wh = button[i]->ButtonPnt(xp - x, yp - y, n, kind); |
if (n == -1) n = i; |
if (i == ins) |
{ |
if (kind == 1) return wh; |
else if (kind == 2) |
{ |
if (wh == INT_MIN || n < 0) |
{ |
if (k_ins != 2) {k_ins = 2; n = -10; return 1000;} |
} |
else if (k_ins != 1) {k_ins = 1; return 1000;} |
return wh; |
} |
else if (kind == 3) |
{ |
if (wh == INT_MIN) |
{ |
n = -10; |
if (k_ins == 1) wh = 1000; |
} |
k_ins = 0; ins = -1; |
return wh; |
} |
else return wh; |
} |
else if (wh != INT_MIN) |
{ |
if (kind == 1) {ins = i; k_ins = 1; return wh;} |
else if (kind == 2 || kind == 3) return INT_MIN; |
else return wh; |
} |
} |
x = xx; |
if (ym < button[i]->h) ym = button[i]->h; |
} |
n = -10; |
return INT_MIN; |
} |
struct TMultiButton : public TXButton |
{ |
TMultiButton(int n = -1, int w = 100, int h = 20, int d = 2) |
: TXButton(n, w, h), a(d) {} |
virtual void Draw(TGraphDraw *drw, int x0, int y0, unsigned long dcolor, |
unsigned long lcolor, unsigned long tcolor, int ins = 0); |
virtual int ButtonPnt(int xp, int yp, int &n, int kind = 0); |
void SetDefW(); |
TXButtonArray a; |
}; |
void TMultiButton::Draw(TGraphDraw *drw, int x0, int y0, unsigned long dcolor, |
unsigned long lcolor, unsigned long tcolor, int ins) |
{ |
a.Draw(drw, x0, y0, w, dcolor, lcolor, tcolor, ins); |
} |
int TMultiButton::ButtonPnt(int xp, int yp, int &n, int kind) |
{ |
if (a.GetInsert() < 0 && (xp < 0 || yp < 0 || xp > w || yp > h)) return INT_MIN; |
return a.ButtonPnt(xp, yp, w, n, kind); |
} |
void TMultiButton::SetDefW() |
{ |
w = a.GetFWidth(); |
if (w < 0) w = 0; |
h = a.GetHeight(w); |
} |
#endif //_HEADER_BUTTONS_H |
/programs/games/checkers/trunk/checkers.cpp |
---|
0,0 → 1,1420 |
#define BUILD_RUS |
#ifndef __MENUET__ |
#include <string.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <time.h> |
#include <math.h> |
#else |
#include <menuet.h> |
#include <me_heap.h> |
using namespace Menuet; |
#define strlen StrLen |
#define strcpy StrCopy |
#define memcpy MemCopy |
#include <stdarg.h> |
const unsigned dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000, |
10000, 1000, 100, 10, 0 }; |
int sprintf( char *Str, char* Format, ... ) |
{ |
int i, fmtlinesize, j, k, flag; |
unsigned head, tail; |
char c; |
va_list arglist; |
// |
va_start(arglist, Format); |
// |
fmtlinesize = strlen( Format ); |
// |
if( fmtlinesize == 0 ) return 0; |
// |
for( i = 0, j = 0; i < fmtlinesize; i++ ) |
{ |
// |
c = Format[i]; |
// |
if( c != '%' ) |
{ |
Str[j++] = c; |
continue; |
} |
// |
i++; |
// |
if( i >= fmtlinesize ) break; |
// |
flag = 0; |
// |
c = Format[i]; |
if (c == 'l') c = Format[++i]; |
// |
switch( c ) |
{ |
// |
case '%': |
Str[j++] = c; |
break; |
// |
case 's': |
char* str; |
str = va_arg(arglist, char*); |
for( k = 0; ( c = str[k] ) != 0; k++ ) |
{ |
Str[j++] = c; |
} |
break; |
// |
case 'c': |
Str[j++] = va_arg(arglist, int) & 0xFF; |
break; |
// |
case 'u': |
case 'd': |
head = va_arg(arglist, unsigned); |
for( k = 0; dectab[k] != 0; k++ ) |
{ |
tail = head % dectab[k]; |
head /= dectab[k]; |
c = head + '0'; |
if( c == '0' ) |
{ |
if( flag ) Str[j++] = c; |
} |
else |
{ |
flag++; |
Str[j++] = c; |
} |
// |
head = tail; |
} |
// |
c = head + '0'; |
Str[j++] = c; |
break; |
default: |
break; |
} |
} |
// |
Str[j] = 0; |
return j; |
} |
int isdigit(int c) |
{ |
return (c>='0' && c<='9'); |
} |
int atoi(const char* string) |
{ |
int res=0; |
int sign=0; |
const char* ptr; |
for (ptr=string; *ptr && *ptr<=' ';ptr++); |
if (*ptr=='-') {sign=1;++ptr;} |
while (*ptr >= '0' && *ptr <= '9') |
{ |
res = res*10 + *ptr++ - '0'; |
} |
if (sign) res = -res; |
return res; |
} |
int islower(int c) |
{ |
return (c>='a' && c<='z'); |
} |
int abs(int n) |
{ |
return (n<0)?-n:n; |
} |
int memcmp(const void* buf1, const void* buf2, unsigned count) |
{ |
const char* ptr1 = (const char*)buf1; |
const char* ptr2 = (const char*)buf2; |
unsigned i=0; |
while (i<count && *ptr1==*ptr2) {++i;++ptr1;++ptr2;} |
if (i==count) |
return 0; |
else if (*ptr1<*ptr2) |
return -1; |
else |
return 1; |
} |
void strncpy(char* dest, const char* source, unsigned len) |
{ |
char* ptr1 = dest; |
const char *ptr2 = source; |
for (;len-- && *ptr2; *ptr1++=*ptr2++) ; |
} |
unsigned int rand_data[4]; |
void randomize() |
{ |
rand_data[0] = (unsigned int)Clock(); |
rand_data[1] = (unsigned int)GetPackedTime(); |
rand_data[2] = (unsigned int)GetPackedDate(); |
rand_data[3] = (unsigned int)0xA3901BD2 ^ GetPid(); |
} |
unsigned int rand() |
{ |
rand_data[0] ^= _HashDword(rand_data[3] + 0x2835C013U); |
rand_data[1] += _HashDword(rand_data[0]); |
rand_data[2] -= _HashDword(rand_data[1]); |
rand_data[3] ^= _HashDword(rand_data[2]); |
return rand_data[3]; |
} |
#define random(k) (rand() % (k)) |
#define floor Floor |
double fabs(double x) |
{ |
__asm fld x |
__asm fabs |
} |
#define M_PI 3.14159265358979323846 |
double cos(double x) |
{ |
__asm fld x |
__asm fcos |
} |
double sin(double x) |
{ |
__asm fld x |
__asm fsin |
} |
/*inline void printf(const char* format, ...) |
{}*/ |
#define printf /* nothing */ |
inline void strcat(char* str1, const char* str2) |
{strcpy(str1+strlen(str1),str2);} |
int strncmp(const char* str1, const char* str2, unsigned len) |
{ |
for (;len--;) |
{ |
if (*str1 != *str2) break; |
if (*str1 == 0) |
return 0; |
++str1;++str2; |
} |
if (len==(unsigned)-1) |
return 0; |
if (*str1 < *str2) |
return -1; |
return 1; |
} |
#define clock Clock |
typedef unsigned int clock_t; |
#define CLOCKS_PER_SEC 100 |
#define XK_Left 0xB0 |
#define XK_Right 0xB3 |
#define XK_Up 0xB2 |
#define XK_Down 0xB1 |
#define XK_Return 0x0D |
#define XK_space 0x20 |
#define XK_Escape 0x1B |
#define XK_less '<' |
#define XK_comma ',' |
#define XK_period '.' |
#define XK_greater '>' |
#define XK_minus '-' |
#define XK_equal '=' |
#define XK_underscore '_' |
#define XK_plus '+' |
#define XK_Delete 0xB6 |
#define XK_F8 0x39 |
#define XK_l 'l' |
#define XK_L 'L' |
#define XK_F2 0x33 |
#define XK_s 's' |
#define XK_S 'S' |
#define XK_slash '/' |
#define XK_question '?' |
#define XK_n 'n' |
#define XK_N 'N' |
#define XK_t 't' |
#define XK_T 'T' |
#define XK_r 'r' |
#define XK_R 'R' |
#define XK_b 'b' |
#define XK_B 'B' |
#define XK_f 'f' |
#define XK_F 'F' |
#define assert(a) /* nothing */ |
#include "qsort.c" |
#endif |
#include "gr-draw.h" |
#include "board.h" |
#include "player.h" |
#include "buttons.h" |
#include "sysproc.h" |
char *strskipref(char *s1, char *s2) |
{ |
int L = strlen(s2); |
if (strncmp(s1, s2, L) == 0) return s1 + L; |
else return 0; |
} |
class TPlayArray |
{ |
public: |
TPlayArray(int d = 10) : play(0), nplay(0), mplay(0) {} |
~TPlayArray() {Clear();} |
void Clear(); |
void Add(const PlayWrite &pl); |
PlayWrite &operator[](int i) {return play[i];} |
int GetNPlay() const {return nplay;} |
#ifndef __MENUET__ |
int OpenFile(const char *name, int kind); |
int MsgOpenFile(const char *name, int kind); |
int SaveFile(const char *name, int num, int kind); |
int MsgSaveFile(const char *name, int num, int kind); |
#endif |
void Del(int n); |
protected: |
void Extend(int n = -1); |
PlayWrite *play; |
int nplay, mplay; |
protected: |
#ifndef __MENUET__ |
static const char *const search[]; |
static int AnalizeKind(FILE *f, const int w[], const char *smb = 0); |
static int ReadFileTo(FILE *f, char c); |
static int ReadFileTo(FILE *f, const char *c); |
static int ReadTheText(FILE *f, const char *s); |
#endif |
}; |
#ifndef __MENUET__ |
const char *const TPlayArray::search[] = |
{"checkers-", "play:", "text", "bin_1.0\n", "history_", "1.0", "1.1"}; |
#endif |
void TPlayArray::Clear() |
{ |
if (play) delete[] play; |
play = 0; nplay = 0; mplay = 0; |
} |
void TPlayArray::Extend(int n) |
{ |
if (n < 0) n = nplay + 1; |
if (mplay < n) |
{ |
PlayWrite *p_old = play; |
int m_old = mplay; |
mplay = n * 2; |
play = new PlayWrite[mplay]; |
if (p_old) |
{ |
for (int i = 0; i < m_old; i++) play[i] = p_old[i]; |
delete[] p_old; |
} |
} |
} |
void TPlayArray::Add(const PlayWrite &pl) |
{ |
Extend(); |
play[nplay] = pl; |
nplay++; |
} |
#ifndef __MENUET__ |
int TPlayArray::AnalizeKind(FILE *f, const int w[], const char *smb) |
{ |
int i, L, was1 = 1; |
unsigned char ch; |
int fnd[NELEM(search)]; |
for (i = 0; i < NELEM(search); i++) fnd[i] = 1; |
for (L = 0; was1; L++) |
{ |
was1 = 0; |
if (fread(&ch, 1, 1, f) != 1) return (L == 0) ? -2 : -1; |
for (i = 0; w[i] >= 0; i++) if (fnd[i]) |
{ |
if (tolower(ch) != tolower(search[w[i]][L])) fnd[i] = 0; |
else |
{ |
was1 = 1; |
if (search[w[i]][L+1] == 0) |
{ |
if (smb && smb[0] && fread(&ch, 1, 1, f) == 1) |
{ |
ungetc(ch, f); |
if (strchr(smb, tolower(ch)) || isalpha(ch) && strchr(smb, toupper(ch))) |
{ |
break; |
} |
} |
return i; |
} |
} |
} |
} |
return -10 - L; |
} |
int TPlayArray::ReadFileTo(FILE *f, char c) |
{ |
char ch; |
do |
{ |
if (fread(&ch, 1, 1, f) != 1) return 0; |
} |
while(ch != c); |
return 1; |
} |
int TPlayArray::ReadFileTo(FILE *f, const char *c) |
{ |
char ch; |
do |
{ |
if (fread(&ch, 1, 1, f) != 1) return 0; |
} |
while(!strchr(c, ch)); |
return 1; |
} |
int TPlayArray::ReadTheText(FILE *f, const char *s) |
{ |
char ch; |
while (*s) |
{ |
if (fread(&ch, 1, 1, f) != 1 || ch != *s) return 0; |
s++; |
} |
return 1; |
} |
int TPlayArray::OpenFile(const char *name, int kind) |
{ |
int k_fnd = 0; |
FILE *f = fopen(name, "rb"); |
if (!f) return -1; |
if (kind == -1) |
{ |
const int w[] = {0, -1}; |
int r = AnalizeKind(f, w); |
if (r >= 0) {kind = w[r]; k_fnd = 1;} |
else if (r == -11) {kind = 3; k_fnd = 3;} |
else {fclose(f); return (kind == -2) ? -2 : -10;} |
} |
if (kind == 0) |
{ |
if (k_fnd < 1 && !ReadFileTo(f, '-')) {fclose(f); return -10;} |
k_fnd = 1; |
const int w[] = {1, 4, -1}; |
int r = AnalizeKind(f, w); |
if (r >= 0) {kind = w[r]; k_fnd = 2;} |
else {fclose(f); return -10;} |
} |
if (kind == 1) |
{ |
if (k_fnd < 2 && !ReadFileTo(f, ':')) {fclose(f); return -10;} |
k_fnd = 2; |
const int w[] = {2, 3, -1}; |
int r = AnalizeKind(f, w); |
if (r >= 0) {kind = w[r]; k_fnd = 3;} |
else {fclose(f); return -10;} |
} |
if (kind == 4) |
{ |
if (k_fnd < 2 && !ReadFileTo(f, '_')) {fclose(f); return -10;} |
k_fnd = 2; |
const int w[] = {5, 6, -1}; |
int r = AnalizeKind(f, w, ".1234567890"); |
if (r >= 0) {kind = w[r]; k_fnd = 3;} |
else {fclose(f); return -10;} |
} |
if (kind == 5) {kind = 3; k_fnd = 0;} |
if (kind == 6) |
{ |
if (!ReadFileTo(f, "\n\r")) {fclose(f); return -4;} |
k_fnd = 3; |
PlayWrite *pl = 0; |
int np = THistory::HRead(f, pl); |
if (np > 0 && pl) |
{ |
int i; |
Extend(nplay + np); |
for (i = 0; i < np; i++) |
{ |
if (pl[i].GetN() >= 3) play[nplay++] = pl[i]; |
} |
} |
if (pl) delete[] pl; |
fclose(f); |
return 1; |
} |
if (kind == 2) |
{ |
printf("kind = 2\n"); |
unsigned char ch; |
do |
{ |
if (fread(&ch, 1, 1, f) != 1) {fclose(f); return -10;} |
} |
while(!isspace(ch)); |
PlayWrite pl; |
char word[101]; |
int i, kind = 0; |
for (;;) |
{ |
do |
{ |
if (fread(&ch, 1, 1, f) != 1) break; |
} |
while(ch == 0 || isspace(ch)); |
if (feof(f)) strcpy(word, "[end]"); |
else |
{ |
i = 0; |
while(ch != 0 && !isspace(ch)) |
{ |
if (i < 100) word[i++] = ch; |
if (fread(&ch, 1, 1, f) != 1) break; |
} |
word[i] = 0; |
} |
if (word[0] != '[') |
{ |
if (kind == 1) |
{ |
if (word[0] != '#' && word[0] != '$' && word[0] != '%') |
{ |
Position pos; |
pos.Read(word, 1); |
pl.Clear(); |
pl.Add(0, pos); |
kind = 2; |
} |
} |
else if (kind == 2) |
{ |
if (word[0] != '#' && word[0] != '$' && word[0] != '%') |
{ |
for (i = 0; word[i] && word[i] != '.' && word[i] != ','; i++) |
{ |
if (!isdigit((unsigned char)word[i])) {i = -1; break;} |
} |
if (i == -1) |
{ |
PlayWrite::PMv pmv; |
if (pl.GetPosL(pmv.pos) < 0) kind = 3; |
else if (!pmv.pos.ReadMv(pmv.mv, word, 1)) kind = 3; |
else if (pl.Add(pmv.mv) != 0) kind = 3; |
} |
} |
} |
} |
else |
{ |
if (kind == 2 || kind == 3) |
{ |
if (pl.GetN() > 0) Add(pl); |
pl.Clear(); |
} |
kind = 0; |
for (i = 0; word[i]; i++) |
{ |
word[i] = (char)tolower((unsigned char)word[i]); |
} |
if (strskipref(word, "[end]")) break; |
else if (strskipref(word, "[play_v1.1]")) kind = 1; |
} |
} |
fclose(f); |
return 1; |
} |
if (kind == 3) |
{ |
char ch[LEN_WPOS]; |
if (k_fnd < 3 && !ReadFileTo(f, '\n')) {fclose(f); return -10;} |
k_fnd = 3; |
do |
{ |
PlayWrite pl; |
for (;;) |
{ |
int i; |
for (i = 0; i < LEN_WPOS; i++) |
{ |
if (fread(ch + i, 1, 1, f) != 1 || ch[i] < 0) break; |
} |
if (i < LEN_WPOS) break; |
PlayWrite::PMv pmv0, pmv1; |
pmv1.pos.Read(ch); |
pmv1.pos.Reverse(); |
if (pl.GetPMvL(pmv0) >= 0) |
{ |
TComputerPlayer::Z z; |
z.FindAllMoves(pmv0); |
int r; |
for (r = 0; r < z.narr; r++) |
{ |
if (memcmp(z.array[r].pos.SH, pmv1.pos.SH, sizeof(pmv1.pos.SH)) == 0) |
{ |
pmv1 = z.array[r]; |
break; |
} |
} |
if (r < z.narr) pl.Add(pmv1); |
else {fclose(f); return -3;} |
} |
else pl.Add(0, pmv1.pos); |
} |
if (pl.GetN() > 0) Add(pl); |
} |
while(!feof(f)); |
fclose(f); |
return 1; |
} |
fclose(f); |
return -10; |
} |
int TPlayArray::MsgOpenFile(const char *name, int kind) |
{ |
int n0 = nplay, no_games = 0; |
int r = OpenFile(name, kind); |
if (r <= 0) |
{ |
if (r == -1) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ¥ ¬®£ã ®âªàëâì ä ©« \"%s\".\n", name); |
#else |
printf("\nCheckers: Can't open the file \"%s\".\n", name); |
#endif |
return 0; |
} |
else if (r == -2) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ©« \"%s\" ¯ãáâ.\n", name); |
#else |
printf("\nCheckers: The file \"%s\" is empty.\n", name); |
#endif |
return 0; |
} |
else if (r == -3) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ©« \"%s\" ®è¨¡®çë©.\n", name); |
#else |
printf("\nCheckers: Invalid file \"%s\".\n", name); |
#endif |
return 0; |
} |
else if (r == -4) no_games = 1; |
else if (r == -10) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ©« \"%s\" ¨¬¥¥â ¥¢¥àë© â¨¯.\n", name); |
#else |
printf("\nCheckers: The file \"%s\" has wrong type.\n", name); |
#endif |
return 0; |
} |
else |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: 訡ª ®âªàëâ¨ï ä ©« \"%s\".\n", name); |
#else |
printf("\nCheckers: Error openning the file \"%s\".\n", name); |
#endif |
return 0; |
} |
} |
if (!no_games && nplay > n0) return 1; |
else |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ©« \"%s\" ¥ ᮤ¥à¦¨â ¨£à.\n", name); |
#else |
printf("\nCheckers: File \"%s\" don't contains games.\n", name); |
#endif |
return 0; |
} |
} |
int TPlayArray::SaveFile(const char *name, int num, int kind) |
{ |
FILE *f = 0; |
if (kind == 0 || kind == 1 || kind == 2) |
{ |
f = fopen(name, "wt"); |
if (!f) return -1; |
fprintf(f, "checkers-play:text\n"); |
int i0 = num, i; |
if (num < 0) {i0 = 0; num = nplay-1;} |
for (i = i0; i <= num; i++) if (play[i].GetN() > 0) |
{ |
PlayWrite::PMv pmv; |
if (play[i].GetPos(pmv.pos, 0) < 0) return -9; |
char *str = new char[10 + NUM_CELL]; |
if (!str) return -5; |
pmv.pos.Write(str, 1); |
fprintf(f, "\n[Play_v1.1]#%d %s\n", i - i0 + 1, str); |
delete[] str; |
int j; |
for (j = 1; j < play[i].GetN(); j++) |
{ |
if (play[i].GetPos(pmv.pos, j - 1) < 0) return -9; |
if (play[i].GetMove(pmv.mv, j) < 0) return -9; |
str = new char[pmv.pos.GetLenMvEx(pmv.mv, 11)]; |
if (!str) return -5; |
pmv.pos.WriteMvEx(pmv.mv, str, 11); |
if (j % 2 == 1) |
{ |
int nbytes = fprintf(f, "%d. ", (j + 1) / 2); |
while(nbytes++ < 5) fprintf(f, " "); |
} |
fprintf(f, "%s", str); |
if (j % 2 == 0 || j == play[i].GetN() - 1) fprintf(f, "\n"); |
else fprintf(f, " ,\t"); |
delete[] str; |
} |
} |
fclose(f); |
return 1; |
} |
else if (kind == -1 || kind == 3) |
{ |
f = fopen(name, "wb"); |
if (!f) return -1; |
if (kind == 3) fprintf(f, "checkers-play:bin_1.0\n"); |
int i = num; |
if (num < 0) {i = 0; num = nplay-1;} |
for (; i <= num; i++) |
{ |
char ch[LEN_WPOS]; |
Position pos; |
play[i].GetPosL(pos); |
if (!pos.AllCanEat() && !pos.AllCanMove()) |
{ |
ch[0] = (pos.wmove == 0) ? char(-3) : char(-1); |
} |
else ch[0] = char(-2); |
fwrite(ch, 1, 1, f); |
int j; |
for (j = 0; j < play[i].GetN(); j++) |
{ |
Position pos; |
play[i].GetPos(pos, j); |
pos.Reverse(); |
pos.Write(ch); |
fwrite(ch, LEN_WPOS, 1, f); |
} |
} |
fclose(f); |
return 1; |
} |
if (f) fclose(f); |
return -10; |
} |
int TPlayArray::MsgSaveFile(const char *name, int num, int kind) |
{ |
int r = SaveFile(name, num, kind); |
if (r <= 0) |
{ |
if (r == -1) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ¥ ¬®£ã ®âªàëâì ä ©« \"%s\" § ¯¨áì.\n", name); |
#else |
printf("\nCheckers: Can't open the file \"%s\" to write.\n", name); |
#endif |
} |
else if (r == -5) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ¥ ¤®áâ â®ç® ¯ ¬ï⨠¤«ï á®åà ¥¨ï ä ©« \"%s\".\n", name); |
#else |
printf("\nCheckers: Not enough memory to save the file \"%s\".\n", name); |
#endif |
} |
else if (r == -10) |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ©« \"%s\" ¨¬¥¥â ¥¢¥àë© â¨¯.\n", name); |
#else |
printf("\nCheckers: The file \"%s\" has wrong type.\n", name); |
#endif |
} |
else |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: 訡ª á®åà ¥¨ï ä ©« \"%s\".\n", name); |
#else |
printf("\nCheckers: Error saving the file \"%s\".\n", name); |
#endif |
} |
return 0; |
} |
else |
{ |
#ifdef BUILD_RUS |
printf("\n 誨: ©« \"%s\" á®åà ñ.\n", name); |
#else |
printf("\nCheckers: File \"%s\" saved.\n", name); |
#endif |
return 1; |
} |
} |
#endif |
void TPlayArray::Del(int n) |
{ |
if (!play || n < 0 || n >= nplay) return; |
else if (nplay <= 1) {Clear(); return;} |
int i; |
for (i = n; i < nplay - 1; i++) play[i] = play[i+1]; |
play[nplay - 1].Clear(); |
nplay--; |
} |
void SetPlayerString(char *str, int c, TChPlayer *p) |
{ |
strcpy(str, c ? "blue: " : "red: "); |
if (!p) strcat(str, "input"); |
else strcat(str, "computer"); |
} |
class TMainDraw : public TSomeDraw |
{ |
public: |
TMainDraw() : undo_redo(0), ur_type(-1), cur_play(0), |
def_savefile("save.che"), def_savekind(2) {InitButton();} |
virtual void Draw(TGraphDraw *drw, int w, int h) |
{ |
int d = button.GetDelt(); |
int hh = button.GetHeight(w - 2*d); |
if (hh != 0) hh += d; |
drw->SetColor(drw->GetBlackColor()); |
button.Draw(drw, d, h - hh, w - 2*d); |
} |
virtual void DrawB(TGraphDraw *drw, TChBoard &board) |
{ |
int urt = (board.GetCurMoveN() <= 0) + |
2*(board.GetCurMoveN() >= board.GetNumMove()); |
if (ur_type != urt) SetButtonKind(board); |
Draw(drw, board.GetW(), board.GetH()); |
} |
virtual TIntPoint GetDSize(int w, int h) |
{ |
int d = button.GetDelt(); |
int hh = button.GetHeight(w - 2*d); |
if (hh != 0) hh += d; |
return TIntPoint(0, hh); |
} |
virtual int ButtonPnt(int xp, int yp, int w, int h, int &n, int k = 0) |
{ |
int d = button.GetDelt(); |
int hh = button.GetHeight(w - 2*d); |
if (hh != 0) hh += d; |
return button.ButtonPnt(xp - d, yp - (h - hh), w - 2*d, n, k); |
} |
void InitButton(); |
void SetButtonKind(const TChBoard &board); |
void PressUR(int n, TChBoard &board, TGraphDraw *drw); |
void PressLS(int n, TChBoard &board, TGraphDraw *drw); |
void CurPlayNorm() |
{ |
if (cur_play < 0 || cur_play >= play.GetNPlay()) cur_play = 0; |
} |
TXButtonArray button; |
TMultiButton *undo_redo, *play_list; |
char player_str[2][50], play_num[2][10]; |
TPlayArray play; |
int cur_play; |
char *def_savefile; |
int def_savekind; |
protected: |
int ur_type; |
}; |
void TMainDraw::InitButton() |
{ |
button.Add(1, 80, 22, "new game"); |
button.Add(6, 60, 22, "list"); |
button.Add(7, 60, 22, "delete"); |
play_list = new TMultiButton(20); |
play_list->a.Add(26, 20, 22, "1"); |
play_list->a.Add(21, 20, 22, "-"); |
play_list->a.Add(23, 37, 22, play_num[0], -2); |
play_list->a.Add(22, 20, 22, "+"); |
play_list->a.Add(27, 37, 22, play_num[1]); |
play_list->SetDefW(); |
button.Add(play_list); |
button.Add(24, 50, 22, "clear"); |
#ifndef __MENUET__ |
button.Add(25, 50, 22, "save"); |
#endif |
button.Add(2, 120, 22, player_str[0]); |
button.Add(3, 120, 22, player_str[1]); |
button.Add(4, 110, 22, "rotate board"); |
undo_redo = new TMultiButton(10); |
undo_redo->a.Add(11, 27, 22, "<<"); |
undo_redo->a.Add(12, 20, 22, "<"); |
undo_redo->a.Add(15, 20, 22, "^"); |
undo_redo->a.Add(13, 20, 22, ">"); |
undo_redo->a.Add(14, 27, 22, ">>"); |
undo_redo->SetDefW(); |
button.Add(undo_redo); |
button.Add(5, 60, 22, "exit"); |
} |
void TMainDraw::SetButtonKind(const TChBoard &board) |
{ |
int thick; |
TextButton *txb; |
TXButton *bt1; |
ur_type = 0; |
SetPlayerString(player_str[0], 0, board.GetPlayer(0)); |
SetPlayerString(player_str[1], 1, board.GetPlayer(1)); |
int is_drw = !board.GetPViewStatus(); |
bt1 = button.GetButton(2); |
if (bt1) bt1->drw = is_drw; |
bt1 = button.GetButton(3); |
if (bt1) bt1->drw = is_drw; |
if (board.GetCurMoveN() <= 0) {ur_type++; thick = 0;} |
else thick = 3; |
// txb = dynamic_cast<TextButton*>(undo_redo->a.GetButton(11)); |
// if (txb) txb->thick = thick; |
// txb = dynamic_cast<TextButton*>(undo_redo->a.GetButton(12)); |
// if (txb) txb->thick = thick; |
// we can use simple static cast |
((TextButton*)(undo_redo->a.GetButton(11)))->thick = thick; |
((TextButton*)(undo_redo->a.GetButton(12)))->thick = thick; |
if (board.GetCurMoveN() >= board.GetNumMove()) {ur_type += 2; thick = 0;} |
else thick = 3; |
// txb = dynamic_cast<TextButton*>(undo_redo->a.GetButton(13)); |
// if (txb) txb->thick = thick; |
// txb = dynamic_cast<TextButton*>(undo_redo->a.GetButton(14)); |
// if (txb) txb->thick = thick; |
((TextButton*)(undo_redo->a.GetButton(13)))->thick = thick; |
((TextButton*)(undo_redo->a.GetButton(14)))->thick = thick; |
if (board.GetCurMoveN() < board.GetNumMove() || |
(board.GetPViewStatus() && board.GetGameEnd() <= 0)) |
{ |
thick = 3; |
} |
else thick = 0; |
// txb = dynamic_cast<TextButton*>(undo_redo->a.GetButton(15)); |
// if (txb) txb->thick = thick; |
((TextButton*)(undo_redo->a.GetButton(15)))->thick = thick; |
if (play.GetNPlay() == 0) is_drw = 1; |
bt1 = button.GetButton(6); |
if (bt1) bt1->drw = is_drw; |
bt1 = button.GetButton(7); |
if (bt1) bt1->drw = !is_drw; |
#ifndef __MENUET__ |
bt1 = button.GetButton(25); |
if (bt1) bt1->drw = !is_drw; |
#endif |
is_drw = board.GetPViewStatus() && play.GetNPlay() > 1; |
bt1 = button.GetButton(20); |
if (bt1) bt1->drw = is_drw; |
bt1 = button.GetButton(24); |
if (bt1) bt1->drw = is_drw; |
if (is_drw) |
{ |
play_num[0][0] = 0; play_num[1][0] = 0; |
if (cur_play >= 0) sprintf(play_num[0], "%d", cur_play + 1); |
sprintf(play_num[1], "%d", play.GetNPlay()); |
thick = (cur_play <= 0) ? 0 : 3; |
#define dynamic_cast static_cast |
txb = dynamic_cast<TextButton*>(play_list->a.GetButton(21)); |
if (txb) txb->thick = thick; |
txb = dynamic_cast<TextButton*>(play_list->a.GetButton(26)); |
if (txb) txb->thick = thick; |
thick = (cur_play >= play.GetNPlay() - 1) ? 0 : 3; |
txb = dynamic_cast<TextButton*>(play_list->a.GetButton(22)); |
if (txb) txb->thick = thick; |
txb = dynamic_cast<TextButton*>(play_list->a.GetButton(27)); |
if (txb) txb->thick = thick; |
#undef dynamic_cast |
} |
} |
void TMainDraw::PressUR(int n, TChBoard &board, TGraphDraw *drw) |
{ |
int mv; |
if (n == 11) mv = 0; |
else if (n == 12) mv = board.GetCurMoveN() - 1; |
else if (n == 13) mv = board.GetCurMoveN() + 1; |
else mv = board.GetNumMove(); |
if (board.SetCurMoveN(mv)) |
{ |
SetButtonKind(board); |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
board.Draw(drw); |
} |
} |
else Draw(drw, board.GetW(), board.GetH()); |
} |
void TMainDraw::PressLS(int n, TChBoard &board, TGraphDraw *drw) |
{ |
int need_redraw = 0; |
if (n == 6) |
{ |
if (!board.GetPViewStatus() || play.GetNPlay() == 0) |
{ |
PlayWrite cur_pw = board.GetPlay(); |
if (cur_pw.GetN() > 2 || play.GetNPlay() == 0) play.Add(board.GetPlay()); |
cur_play = play.GetNPlay() - 1; |
board.SetPlay(play[cur_play]); |
need_redraw = 1; |
} |
} |
else if (n == 7) |
{ |
if (board.GetPViewStatus() && play.GetNPlay() != 0) |
{ |
play.Del(cur_play); |
if (play.GetNPlay() >= 1) |
{ |
if (cur_play >= play.GetNPlay()) cur_play--; |
board.SetPlay(play[cur_play]); |
} |
need_redraw = 1; |
} |
} |
else if (n == 21) |
{ |
if (cur_play > 0) {board.SetPlay(play[--cur_play]); need_redraw = 1;} |
} |
else if (n == 22) |
{ |
if (cur_play < play.GetNPlay() - 1) |
{ |
board.SetPlay(play[++cur_play]); need_redraw = 1; |
} |
} |
else if (n == 26) |
{ |
if (cur_play > 0) |
{ |
cur_play = 0; |
board.SetPlay(play[cur_play]); need_redraw = 1; |
} |
} |
else if (n == 27) |
{ |
if (cur_play < play.GetNPlay() - 1) |
{ |
cur_play = play.GetNPlay() - 1; |
board.SetPlay(play[cur_play]); need_redraw = 1; |
} |
} |
else if (n == 24) {play.Clear(); cur_play = 0; need_redraw = 1;} |
#ifndef __MENUET__ |
else if (n == 25) |
{ |
if (play.GetNPlay() > 0) play.MsgSaveFile(def_savefile, -1, def_savekind); |
} |
else if (n == 28) |
{ |
if (play.GetNPlay() > 0) play.MsgSaveFile(def_savefile, cur_play, def_savekind); |
} |
#endif |
if (need_redraw) |
{ |
SetButtonKind(board); |
if (drw && drw->IsDraw()) |
{ |
drw->DrawClear(); |
board.Draw(drw); |
} |
} |
else Draw(drw, board.GetW(), board.GetH()); |
} |
struct TTimerDraw |
{ |
TTimerDraw(TChBoard *brd, TGraphDraw *drw) : brd(brd), drw(drw) {} |
TChBoard *brd; |
clock_t st, ut, dt; |
double x0; |
TGraphDraw *drw; |
static void draw(void *v, int k = 0); |
}; |
void TTimerDraw::draw(void *v, int k) |
{ |
TTimerDraw &d = *(TTimerDraw*)v; |
clock_t t = clock(); |
if (k == 0 && t - d.ut < CLOCKS_PER_SEC * 0.01) return; |
if (k > 0) |
{ |
d.st = t; |
if (!d.drw || !d.drw->IsDraw()) return; |
d.drw->DrawClear(); |
d.brd->Draw(d.drw); |
d.dt = t; |
} |
else if (!d.drw || !d.drw->IsDraw()) return; |
double xold = d.x0; |
if (k >= 0) |
{ |
d.x0 = (1 - cos(2.0 * (t - d.st) / CLOCKS_PER_SEC)) / 2; |
d.brd->DrawTimer(d.drw, d.x0, 0); |
d.ut = t; |
if (k == 0 && t - d.dt > CLOCKS_PER_SEC * 0.5) |
{ |
d.brd->Draw(d.drw); |
d.dt = t; |
} |
} |
if (k <= 0) d.brd->DrawTimer(d.drw, xold, 1); |
} |
struct TMainData |
{ |
TChBoard board; |
TComputerPlayer player; |
TMainDraw main_draw; |
TMainData(int id = 0); |
void InitDef(); |
static int EventFunction(const TGraphDraw::event &ev); |
void NewGame(TGraphDraw *drw); |
void RotateBoard(TGraphDraw *drw); |
void PlayerPress(int np, TGraphDraw *drw); |
void GoToCurMove(TGraphDraw *drw); |
}; |
TMainData::TMainData(int id) : board(id) |
{ |
board.SetCheckResize(1); |
board.SetPlayer(1, &player); |
board.SetBottomColor(0); |
board.SetSomeDraw(&main_draw); |
board.SetMinWSize(90, 140); |
} |
void TMainData::InitDef() |
{ |
if (main_draw.play.GetNPlay() > 0) |
{ |
main_draw.CurPlayNorm(); |
board.SetPlay(main_draw.play[main_draw.cur_play]); |
} |
main_draw.SetButtonKind(board); |
} |
void TMainData::NewGame(TGraphDraw *drw) |
{ |
board.NewGame(); |
main_draw.SetButtonKind(board); |
if (drw && drw->IsDraw()) {drw->DrawClear(); board.Draw(drw);} |
} |
void TMainData::RotateBoard(TGraphDraw *drw) |
{ |
board.SetBottomColor(3 - board.GetBottomColor()); |
if (drw && drw->IsDraw()) {drw->DrawClear(); board.Draw(drw);} |
} |
void TMainData::PlayerPress(int np, TGraphDraw *drw) |
{ |
if (np != 0 && np != 1) return; |
if (board.GetPlayer(np)) board.SetPlayer(np, 0); |
else board.SetPlayer(np, &player); |
if (board.GetPlayer(0) && !board.GetPlayer(1)) |
{ |
board.SetBottomColor(1); |
} |
if (board.GetPlayer(1) && !board.GetPlayer(0)) |
{ |
board.SetBottomColor(0); |
} |
main_draw.SetButtonKind(board); |
if (drw && drw->IsDraw()) {drw->DrawClear(); board.Draw(drw);} |
} |
void TMainData::GoToCurMove(TGraphDraw *drw) |
{ |
board.GoToCurMove(); |
main_draw.SetButtonKind(board); |
if (drw && drw->IsDraw()) {drw->DrawClear(); board.Draw(drw);} |
} |
int TMainData::EventFunction(const TGraphDraw::event &ev) |
{ |
if (!ev.any.drw->data) return -100; |
TMainData &data = *(TMainData*)ev.any.drw->data; |
int nbutton, ret = 0; |
switch(ev.type) |
{ |
case TGraphDraw::event::button_down: |
if (ev.button.n != 1) break; |
ev.button.drw->OpenDraw(); |
if (data.main_draw.ButtonPnt(ev.button.x, ev.button.y, |
data.board.GetW(), data.board.GetH(), nbutton, 1) > 0) |
{ |
data.main_draw.Draw(ev.button.drw, data.board.GetW(), data.board.GetH()); |
ret |= TGraphDraw::ret_setcapture; |
} |
else data.board.MouseClick(ev.button.drw, ev.button.x, ev.button.y); |
ev.button.drw->CloseDraw(); |
break; |
case TGraphDraw::event::mouse_move: |
if (ev.button.n >= 0 && ev.button.n != 1) break; |
ev.button.drw->OpenDraw(); |
if (data.main_draw.ButtonPnt(ev.button.x, ev.button.y, |
data.board.GetW(), data.board.GetH(), nbutton, 2) >= 1000) |
{ |
data.main_draw.Draw(ev.button.drw, data.board.GetW(), data.board.GetH()); |
} |
ev.button.drw->CloseDraw(); |
break; |
case TGraphDraw::event::button_up: |
if (ev.button.n != 1) break; |
ev.button.drw->OpenDraw(); |
if (data.main_draw.ButtonPnt(ev.button.x, ev.button.y, |
data.board.GetW(), data.board.GetH(), nbutton, 3) > 0) |
{ |
switch(nbutton) |
{ |
case 1: |
data.NewGame(ev.button.drw); |
break; |
case 2: |
case 3: |
data.PlayerPress(nbutton - 2, ev.button.drw); |
break; |
case 4: |
data.RotateBoard(ev.button.drw); |
break; |
case 5: |
data.main_draw.Draw(ev.button.drw, data.board.GetW(), data.board.GetH()); |
ev.button.drw->Quit(); |
break; |
case 11: |
case 12: |
case 13: |
case 14: |
data.main_draw.PressUR(nbutton, data.board, ev.button.drw); |
break; |
case 15: |
data.GoToCurMove(ev.button.drw); |
break; |
case 6: |
case 7: |
case 21: |
case 22: |
case 23: |
case 24: |
case 25: |
case 26: |
case 27: |
data.main_draw.PressLS(nbutton, data.board, ev.button.drw); |
break; |
default: |
data.main_draw.Draw(ev.button.drw, data.board.GetW(), data.board.GetH()); |
break; |
} |
} |
ev.button.drw->CloseDraw(); |
break; |
case TGraphDraw::event::draw: |
ev.button.drw->OpenDraw(); |
data.board.Draw(ev.button.drw); |
ev.button.drw->CloseDraw(); |
break; |
case TGraphDraw::event::key_down: |
ev.button.drw->OpenDraw(); |
if (ev.key.k == XK_Left) data.board.PKeyEvent(ev.button.drw, TChBoard::PLeft); |
else if (ev.key.k == XK_Right) data.board.PKeyEvent(ev.button.drw, TChBoard::PRight); |
else if (ev.key.k == XK_Up) data.board.PKeyEvent(ev.button.drw, TChBoard::PUp); |
else if (ev.key.k == XK_Down) data.board.PKeyEvent(ev.button.drw, TChBoard::PDown); |
else if (ev.key.k == XK_Return || ev.key.k == XK_space) |
{ |
data.board.PKeyEvent(ev.button.drw, TChBoard::PEnter); |
} |
else if (ev.key.k == XK_Escape) ev.button.drw->Quit(); |
else if (ev.key.k == XK_less) data.main_draw.PressUR(11, data.board, ev.button.drw); |
else if (ev.key.k == XK_comma) data.main_draw.PressUR(12, data.board, ev.button.drw); |
else if (ev.key.k == XK_period) data.main_draw.PressUR(13, data.board, ev.button.drw); |
else if (ev.key.k == XK_greater) data.main_draw.PressUR(14, data.board, ev.button.drw); |
else if (ev.key.k == XK_minus) data.main_draw.PressLS(21, data.board, ev.button.drw); |
else if (ev.key.k == XK_equal) data.main_draw.PressLS(22, data.board, ev.button.drw); |
else if (ev.key.k == XK_underscore) data.main_draw.PressLS(26, data.board, ev.button.drw); |
else if (ev.key.k == XK_plus) data.main_draw.PressLS(27, data.board, ev.button.drw); |
else if (ev.key.k == XK_Delete) data.main_draw.PressLS(7, data.board, ev.button.drw); |
else if (ev.key.k == XK_F8) data.main_draw.PressLS(24, data.board, ev.button.drw); |
else if (ev.key.k == XK_l || ev.key.k == XK_L) data.main_draw.PressLS(6, data.board, ev.button.drw); |
#ifndef __MENUET__ |
else if (ev.key.k == XK_F2) data.main_draw.PressLS(25, data.board, ev.button.drw); |
#endif |
else if (ev.key.k == XK_s || ev.key.k == XK_S) data.main_draw.PressLS(28, data.board, ev.button.drw); |
else if (ev.key.k == XK_slash || ev.key.k == XK_question) data.GoToCurMove(ev.button.drw); |
else if (ev.key.k == XK_n || ev.key.k == XK_N) data.NewGame(ev.button.drw); |
else if (ev.key.k == XK_t || ev.key.k == XK_T) data.RotateBoard(ev.button.drw); |
else if (ev.key.k == XK_r || ev.key.k == XK_R) data.PlayerPress(0, ev.button.drw); |
else if (ev.key.k == XK_b || ev.key.k == XK_B) data.PlayerPress(1, ev.button.drw); |
else if (ev.key.k == XK_f || ev.key.k == XK_F) |
{ |
int w, h; |
ev.button.drw->GetSize(w, h); |
ev.button.drw->CloseDraw(); |
if (DuplicateProcess() == 0) |
{ |
ev.button.drw->ResReinit(w, h); |
data.board.EraseHistory(); |
} |
} |
ev.button.drw->CloseDraw(); |
break; |
case TGraphDraw::event::close: |
ret = 1; |
break; |
} |
return ret; |
} |
#ifndef __MENUET__ |
int main(int argc, char **argv) |
{ |
randomize(); |
THistory::InitHFile(argv[0]); |
TMainData data(-1); |
if (argv && argc >= 2) |
{ |
int i, kx = 1; |
for (i = 1; i < argc; i++) |
{ |
if (kx == 1 && argv[i][0] == '-') |
{ |
if (strcmp(argv[i], "--") == 0) kx = 0; |
else if (strcmp(argv[i], "-ssf") == 0) ssf = 1; |
else if (strncmp(argv[i], "-save", 5) == 0) |
{ |
int j = 5; |
if (argv[i][j]) |
{ |
if (argv[i][j] != '=' || !argv[i][j+1]) |
{ |
data.main_draw.def_savekind = atoi(argv[i] + j); |
while (argv[i][j] && argv[i][j] != '=') j++; |
if (argv[i][j] != '=' || !argv[i][j+1]) continue; |
} |
data.main_draw.def_savefile = argv[i] + j + 1; |
} |
} |
else printf("Checkers: Invalid key %s\n", argv[i]); |
} |
else if (kx == 0 || kx == 1) |
{ |
data.main_draw.play.MsgOpenFile(argv[i], -1); |
} |
} |
} |
data.InitDef(); |
TMainGraphDraw graph( |
#ifdef BUILD_RUS |
" 誨" |
#else |
"Checkers" |
#endif |
); |
TTimerDraw timer_draw(&data.board, &graph); |
data.player.draw = TTimerDraw::draw; data.player.data = &timer_draw; |
graph.evfunc = TMainData::EventFunction; graph.data = &data; |
graph.SetAboutInfo(1); |
graph.Run(TGraphDraw::button_down_mask | TGraphDraw::button_up_mask | |
TGraphDraw::key_down_mask | TGraphDraw::mouse_drag_mask, |
450 + 100 * ssf, 528); |
return 0; |
} |
#else |
TMainData* mdata; |
TMainGraphDraw* graph; |
bool MenuetOnStart(TStartData &me_start, TThreadData) |
{ |
mdata = new TMainData(-1); |
graph = new TMainGraphDraw; |
randomize(); |
mdata->InitDef(); |
static TTimerDraw timer_draw(&mdata->board, graph); |
mdata->player.draw = TTimerDraw::draw; mdata->player.data = &timer_draw; |
graph->data = mdata; |
me_start.WinData.Title = |
#ifdef BUILD_RUS |
" 誨" |
#else |
"Checkers" |
#endif |
; |
me_start.Width = 450 + 100*ssf; |
me_start.Height = 528; |
return true; |
} |
bool MenuetOnClose(TThreadData) |
{ |
delete mdata; |
delete graph; |
return true; |
} |
int MenuetOnIdle(TThreadData) |
{return -1;} |
void MenuetOnSize(int window_rect[], TThreadData) |
{mdata->board.Resize(window_rect[2]-window_rect[0], window_rect[3]-window_rect[1]);} |
void MenuetOnKeyPress(TThreadData) |
{ |
TGraphDraw::event ev; |
ev.type = TGraphDraw::event::key_down; |
ev.any.drw = graph; |
ev.key.k = GetKey(); |
mdata->EventFunction(ev); |
} |
void MenuetOnDraw(void) |
{ |
TGraphDraw::event ev; |
ev.type = TGraphDraw::event::draw; |
ev.any.drw = graph; |
mdata->EventFunction(ev); |
} |
void MenuetOnMouse(TThreadData) |
{ |
short x,y; |
GetMousePosition(x,y); |
int m = GetMouseButton() & 1; |
static int mprev = 0; |
if (m == mprev) |
return; |
mprev = m; |
TGraphDraw::event ev; |
ev.type = m ? TGraphDraw::event::button_down : TGraphDraw::event::button_up; |
ev.any.drw = graph; |
ev.button.n = 1; |
ev.button.x = x; |
ev.button.y = y; |
mdata->EventFunction(ev); |
} |
#endif |
/programs/games/checkers/trunk/compile.txt |
---|
0,0 → 1,21 |
1. Êîìïèëÿöèÿ ïîä Êîëèáðè. |
Äëÿ êîìïèëÿöèè íåîáõîäèì Borland C++ (èç âñåãî ïàêåòà íóæåí òîëüêî êîìïèëÿòîð |
êîìàíäíîé ñòðîêè), à òàêæå FASM âåðñèè íå áîëåå 1.64. |
cpp2asm.bat êîìïèëèðóåò Ñ++-èñõîäíèê â TASM-èñõîäíèê, |
à ïîòîì ïðåâðàùàåò åãî â FASM-èñõîäíèê. |
Ïîñëå ýòîãî, âîçìîæíî, ïîíàäîáèòñÿ ïåðåíåñòè â f_checkers.asm ñòðîêè ñ equ |
â íà÷àëî ôàéëà. |
Êîìïèëÿöèÿ áèíàðíèêà - êàê îáû÷íî, fasm f_checkers.asm checkers. |
2. Êîìïèëÿöèÿ ïîä Linux. |
Ïðîñòî ñêàæèòå make. Ïî êðàéíåé ìåðå â îäíîé Linux-ñèñòåìå ýòî ðàáîòàåò. |
 äðóãèõ ìîãóò ïîíàäîáèòüñÿ íåêîòîðûå èçìåíåíèÿ. |
 èñõîäíèêàõ ðóññêèå áóêâû çàïèñàíû â êîäèðîâêå DOS (cp866). Òàê ÷òî äëÿ |
âðàçóìèòåëüíûõ ñîîáùåíèé ëèáî çàêîììåíòèðóéòå ïåðâóþ ñòðîêó â checkers.cpp |
("#define BUILD_RUS"), ëèáî ïðîãîíèòå âñå *.cpp è *.h ôàéëû ÷åðåç dos2unix. |
3. Êîìïèëÿöèÿ ïîä DOS/Windows. |
Äëÿ êîìïèëÿöèè íåîáõîäèì ïàêåò Borland C++ for DOS/Windows ñîîòâåòñòâåííî. |
Êîìïèëÿöèÿ ñòàíäàðòíà äëÿ Borland C++, â ïðîåêò äîëæåí âõîäèòü îñíîâíîé ôàéë |
checkers.cpp è äëÿ Windows òàêæå ôàéë ðåñóðñîâ win-chk.rc; |
äëÿ DOS äîëæåí áûòü ïðèëèíêîâàí egavga.bgi. |
/programs/games/checkers/trunk/cpp2asm.bat |
---|
0,0 → 1,3 |
bcc32 -S -v- -R- -6 -a4 -O2 -Og -Oi -Ov -OS -k- -x- -D__MENUET__ -Iinclude checkers.cpp |
echo include "me_make.inc" > f_checkers.asm |
t2fasm < checkers.asm >> f_checkers.asm |
/programs/games/checkers/trunk/dos-draw.h |
---|
0,0 → 1,381 |
#include "gr-draw.h" |
#ifndef _DOS_GRAPHIC_DRAW_H |
#define _DOS_GRAPHIC_DRAW_H |
#include "dosmouse.h" |
#include "keysym.h" |
#include <graphics.h> |
#include <conio.h> |
#include <stdio.h> |
#include <limits.h> |
class TDosGraphDraw : public TGraphDraw |
{ |
public: |
TDosGraphDraw(const char *s = 0); |
~TDosGraphDraw() {} |
public: |
static unsigned long GetKeySym(unsigned int key); |
protected: |
unsigned long bgcolor; |
int quit; |
TCursorVisible cursor; |
public: |
unsigned long GetBlackColor() {return 0;} |
unsigned long GetWhiteColor() {return 15;} |
unsigned long CreateColor(unsigned short red, |
unsigned short green, unsigned short blue); |
void FreeColor(unsigned long c) {} |
unsigned long GetBgColor() {return bgcolor;} |
void SetBgColor(unsigned long c) {bgcolor = c;} |
int GetStatus() {return (graphresult() == grOk) ? 1 : 0;} |
int Init() {return 0;} |
int Run(int evmask = 0, int w = INT_MIN, int h = INT_MIN); |
void GetSize(int &w, int &h); |
int OpenDraw(); |
int IsDraw() {return graphresult() == grOk && cursor.IsHidden();} |
void CloseDraw() {cursor.Show();} |
int SetColor(unsigned long c); |
int DrawLine(int x0, int y0, int x1, int y1); |
int DrawText(int x0, int y0, char *text); |
int DrawClear(); |
int GetTextH(const char *s) {return 8;} |
int GetTextW(const char *s) {return 8 * sizeof(s);} |
void Quit(int q = 1) {quit = (q > 0) ? q : 0;} |
}; |
unsigned long TDosGraphDraw::GetKeySym(unsigned int key) |
{ |
switch(key) |
{ |
case 331: return XK_Left; |
case 333: return XK_Right; |
case 328: return XK_Up; |
case 336: return XK_Down; |
case 13: return XK_Return; |
case 32: return XK_space; |
case 27: return XK_Escape; |
case 44: return XK_comma; |
case 46: return XK_period; |
case 60: return XK_comma; |
case 62: return XK_period; |
case 45: return XK_minus; |
case 61: return XK_equal; |
case 95: return XK_underscore; |
case 43: return XK_plus; |
case 339: return XK_Delete; |
case 47: return XK_slash; |
case 63: return XK_question; |
case 315: return XK_F1; |
case 316: return XK_F2; |
case 317: return XK_F3; |
case 318: return XK_F4; |
case 319: return XK_F5; |
case 320: return XK_F6; |
case 321: return XK_F7; |
case 322: return XK_F8; |
case 323: return XK_F9; |
case 324: return XK_F10; |
case 389: return XK_F11; |
case 390: return XK_F12; |
case 97: return XK_a; |
case 98: return XK_b; |
case 99: return XK_c; |
case 100: return XK_d; |
case 101: return XK_e; |
case 102: return XK_f; |
case 103: return XK_g; |
case 104: return XK_h; |
case 105: return XK_i; |
case 106: return XK_j; |
case 107: return XK_k; |
case 108: return XK_l; |
case 109: return XK_m; |
case 110: return XK_n; |
case 111: return XK_o; |
case 112: return XK_p; |
case 113: return XK_q; |
case 114: return XK_r; |
case 115: return XK_s; |
case 116: return XK_t; |
case 117: return XK_u; |
case 118: return XK_v; |
case 119: return XK_w; |
case 120: return XK_x; |
case 121: return XK_y; |
case 122: return XK_z; |
case 65: return XK_A; |
case 66: return XK_B; |
case 67: return XK_C; |
case 68: return XK_D; |
case 69: return XK_E; |
case 70: return XK_F; |
case 71: return XK_G; |
case 72: return XK_H; |
case 73: return XK_I; |
case 74: return XK_J; |
case 75: return XK_K; |
case 76: return XK_L; |
case 77: return XK_M; |
case 78: return XK_N; |
case 79: return XK_O; |
case 80: return XK_P; |
case 81: return XK_Q; |
case 82: return XK_R; |
case 83: return XK_S; |
case 84: return XK_T; |
case 85: return XK_U; |
case 86: return XK_V; |
case 87: return XK_W; |
case 88: return XK_X; |
case 89: return XK_Y; |
case 90: return XK_Z; |
default: return XK_VoidSymbol; |
} |
} |
TDosGraphDraw::TDosGraphDraw(const char *s) : TGraphDraw(s) |
{ |
bgcolor = GetWhiteColor(); |
} |
unsigned long TDosGraphDraw::CreateColor(unsigned short red, |
unsigned short green, unsigned short blue) |
{ |
const unsigned short PD = 12288U, PM = 36863U, PL = 65535U; |
const unsigned short COLOR[16][3] = |
{{0U, 0U, 0U}, {0U, 0U, PM}, {0U, PM, 0U}, {0U, PM, PM}, |
{PM, 0U, 0U}, {PM, 0U, PM}, {PM, PM, 0U}, {PM, PM, PM}, |
{PD, PD, PD}, {PD, PD, PL}, {PD, PL, PD}, {PD, PL, PL}, |
{PL, PD, PD}, {PL, PD, PL}, {PL, PL, PD}, {PL, PL, PL}}; |
int b[3]; |
if (red > green) |
{ |
if (green > blue) {b[0] = 4; b[1] = 2; b[2] = 1;} |
else if (red > blue) {b[0] = 4; b[1] = 1; b[2] = 2;} |
else {b[0] = 1; b[1] = 4; b[2] = 2;} |
} |
else |
{ |
if (red > blue) {b[0] = 2; b[1] = 4; b[2] = 1;} |
else if (green > blue) {b[0] = 2; b[1] = 1; b[2] = 4;} |
else {b[0] = 1; b[1] = 2; b[2] = 4;} |
} |
int i, j, c, c0 = 0; |
long d, d0 = LONG_MAX; |
for (j = 0; j <= 8; j += 8) for (i = 0, c = j; i <= 3; c |= b[i++]) |
{ |
d = labs((long)red - COLOR[c][0]) + labs((long)green - COLOR[c][1]) + |
labs((long)blue - COLOR[c][2]); |
if (d0 >= d) {d0 = d; c0 = c;} |
} |
return c0; |
} |
void TDosGraphDraw::GetSize(int &w, int &h) |
{ |
if (graphresult() == grOk) |
{ |
w = getmaxx() + 1; h = getmaxy() + 1; |
} |
else TGraphDraw::GetSize(w, h); |
} |
int TDosGraphDraw::OpenDraw() |
{ |
if (graphresult() == grOk) |
{ |
cursor.Hide(); |
return 1; |
} |
else return 0; |
} |
int TDosGraphDraw::SetColor(unsigned long c) |
{ |
if (!IsDraw()) return 0; |
else {setcolor((int)c); return 1;} |
} |
int TDosGraphDraw::DrawLine(int x0, int y0, int x1, int y1) |
{ |
if (!IsDraw()) return 0; |
else {line(x0, y0, x1, y1); return 1;} |
} |
int TDosGraphDraw::DrawText(int x0, int y0, char *text) |
{ |
if (!IsDraw()) return 0; |
else {outtextxy(x0, y0, text); return 1;} |
} |
int TDosGraphDraw::DrawClear() |
{ |
if (!IsDraw()) return 0; |
setbkcolor((int)bgcolor); setcolor((int)bgcolor); |
bar(0, 0, getmaxx(), getmaxy()); |
setbkcolor(0); |
return 1; |
} |
int TDosGraphDraw::Run(int evmask, int /*w*/, int /*h*/) |
{ |
if (!evfunc) return -2; |
int wasgraph = graphresult(); |
if (!wasgraph) |
{ |
int gdriver = DETECT, gmode, errorcode; |
initgraph(&gdriver, &gmode, ""); |
if ((errorcode = graphresult()) != grOk) |
{ |
printf("Graphics error: %s\n", grapherrormsg(errorcode)); |
return -1; |
} |
} |
event ev; |
int ch = INT_MIN, stpr = 0; |
int old_mx = -1000, old_my = -1000; |
clock_t old_mtime = clock(); |
int show_cur = TCursorVisible::C.IsShowed(); |
freopen("NUL", "wt", stdout); |
quit = 0; |
while (quit == 0) |
{ |
if (stpr == 0) |
{ |
ev.type = event::start; |
ev.any.drw = this; |
evfunc(ev); |
CloseDraw(); |
stpr = 1; |
} |
else if (stpr == 1) |
{ |
ev.type = event::draw; |
ev.any.drw = this; |
evfunc(ev); |
CloseDraw(); |
stpr = 2; |
} |
else if (ch >= 0 && (evmask & key_down_mask)) |
{ |
ev.type = event::key_up; |
ev.key.drw = this; |
ev.key.k = ch; |
evfunc(ev); |
CloseDraw(); |
ch = INT_MIN; |
} |
else if (kbhit()) |
{ |
if (MouseStatus && TCursorVisible::C.IsShowed() && |
(unsigned long)(clock() - old_mtime) > 5 * CLK_TCK) |
{ |
TCursorVisible::C.Hide(); |
old_mtime = clock(); |
} |
int ch = (unsigned char)getch(); |
if (!ch && kbhit()) ch = 0x100 | (unsigned char)getch(); |
if (evmask & key_down_mask) |
{ |
ev.type = event::key_down; |
ev.key.drw = this; |
ev.key.k = GetKeySym(ch); |
evfunc(ev); |
CloseDraw(); |
} |
} |
else if (MouseStatus && (evmask & (button_down_mask | |
button_up_mask | mouse_move_mask | mouse_drag_mask))) |
{ |
int k, x, y, z; |
for (k = 0; k < MouseStatus; k++) |
{ |
z = GetButtonDown(k, x, y); |
if (z) |
{ |
TCursorVisible::C.Show(); |
old_mx = x; old_my = y; |
old_mtime = clock(); |
if (evmask & button_down_mask) |
{ |
ev.type = event::button_down; |
ev.button.drw = this; |
ev.button.x = x; ev.button.y = y; |
ev.button.n = k + 1; |
evfunc(ev); |
CloseDraw(); |
} |
old_mtime = clock(); |
k = -1; break; |
} |
z = GetButtonUp(k, x, y); |
if (z) |
{ |
TCursorVisible::C.Show(); |
old_mx = x; old_my = y; |
old_mtime = clock(); |
if (evmask & button_up_mask) |
{ |
ev.type = event::button_up; |
ev.button.drw = this; |
ev.button.x = x; ev.button.y = y; |
ev.button.n = k + 1; |
evfunc(ev); |
CloseDraw(); |
} |
k = -1; break; |
} |
} |
if (k >= 0) |
{ |
z = PosCursor(x, y); |
if (x != old_mx || y != old_my) |
{ |
TCursorVisible::C.Show(); |
old_mx = x; old_my = y; |
old_mtime = clock(); |
if (evmask & (mouse_move_mask | mouse_drag_mask)) |
{ |
for (k = 0; k < MouseStatus; k++) |
{ |
if (z & (1 << k)) break; |
} |
if (evmask & ((k == MouseStatus) ? mouse_move_mask : mouse_drag_mask)) |
{ |
ev.type = event::mouse_move; |
ev.button.drw = this; |
ev.button.x = x; ev.button.y = y; |
ev.button.n = (k >= MouseStatus) ? 0 : (k + 1); |
evfunc(ev); |
CloseDraw(); |
} |
} |
} |
else if (TCursorVisible::C.IsShowed() && |
(unsigned long)(clock() - old_mtime) > 30 * CLK_TCK) |
{ |
TCursorVisible::C.Hide(); |
old_mtime = clock(); |
} |
} |
} |
if (quit == 1) |
{ |
ev.type = event::close; |
ev.any.drw = this; |
Quit(evfunc(ev)); |
CloseDraw(); |
} |
} |
TCursorVisible::C.Set(show_cur); |
if (!wasgraph) closegraph(); |
freopen("CON", "wt", stdout); |
return quit; |
} |
#endif //_DOS_GRAPHIC_DRAW_H |
/programs/games/checkers/trunk/dosmouse.h |
---|
0,0 → 1,172 |
#ifndef _INCLUDE_DOS_MOUSE |
#define _INCLUDE_DOS_MOUSE |
#include <dos.h> |
inline int GetMouseStatus() |
{ |
int a, b; |
_AX = 0; |
geninterrupt(0x33); |
a = _AX; b = _BX; |
if (!a) return 0; |
else return b; |
} |
class TCursorVisible |
{ |
public: |
TCursorVisible(int s = 1) : visible(1) {if (!s) Hide();} |
~TCursorVisible() {Show();} |
int IsShowed() const {return visible;} |
int IsHidden() const {return !visible;} |
int Show() |
{ |
if (!visible) {_AX = 1; geninterrupt(0x33); visible = 1; return 1;} |
else return 0; |
} |
int Hide() |
{ |
if (visible) {_AX = 2; geninterrupt(0x33); visible = 0; return 1;} |
else return 0; |
} |
int Set(int v) {return v ? Show() : Hide();} |
private: |
int visible; |
public: |
class T_C |
{ |
public: |
~T_C() {Hide();} |
int IsShowed() const {return visible;} |
int IsHidden() const {return !visible;} |
int Show() |
{ |
if (!visible) {_AX = 1; geninterrupt(0x33); visible = 1; return 1;} |
else return 0; |
} |
int Hide() |
{ |
if (visible) {_AX = 2; geninterrupt(0x33); visible = 0; return 1;} |
else return 0; |
} |
int Set(int v) {return v ? Show() : Hide();} |
private: |
T_C() : visible(0) {} |
friend class TCursorVisible; |
int visible; |
}; |
static T_C C; |
}; |
extern int MouseStatus; |
inline void SetShowCursor(int show) |
{ |
if (MouseStatus) |
{ |
_AX = show ? 1 : 2; |
geninterrupt(0x33); |
} |
} |
inline void ShowCursor() |
{ |
if (MouseStatus) |
{ |
_AX = 1; |
geninterrupt(0x33); |
} |
} |
inline void HideCursor() |
{ |
if (MouseStatus) |
{ |
_AX = 2; |
geninterrupt(0x33); |
} |
} |
inline int PosCursor(int &x, int &y) |
{ |
if (MouseStatus) |
{ |
int xx, yy, r; |
_AX = 3; |
geninterrupt(0x33); |
xx = _CX; yy = _DX; |
r = _BX; |
x = xx; y = yy; |
return r; |
} |
else return 0; |
} |
inline int SetPosCursor(int x, int y) |
{ |
if (MouseStatus) |
{ |
_AX = 4; _CX = x; _DX = y; |
geninterrupt(0x33); |
return _BX; |
} |
else return 0; |
} |
inline int GetButtonDown(int n, int &x, int &y) |
{ |
if (MouseStatus) |
{ |
int xx, yy, r; |
_AX = 5; _BX = n; |
geninterrupt(0x33); |
xx = _CX; yy = _DX; |
r = _BX; |
x = xx; y = yy; |
return r; |
} |
else return 0; |
} |
inline int GetButtonUp(int n, int &x, int &y) |
{ |
if (MouseStatus) |
{ |
int xx, yy, r; |
_AX = 6; _BX = n; |
geninterrupt(0x33); |
xx = _CX; yy = _DX; |
r = _BX; |
x = xx; y = yy; |
return r; |
} |
else return 0; |
} |
inline void BoundCursorX(int x1, int x2) |
{ |
if (MouseStatus) |
{ |
_AX = 7; _CX = x1; _DX = x2; |
geninterrupt(0x33); |
} |
} |
inline void BoundCursorY(int y1, int y2) |
{ |
if (MouseStatus) |
{ |
_AX = 8; _CX = y1; _DX = y2; |
geninterrupt(0x33); |
} |
} |
int MouseStatus = GetMouseStatus(); |
TCursorVisible::T_C TCursorVisible::C; |
#endif //_INCLUDE_DOS_MOUSE |
/programs/games/checkers/trunk/egavga.bgi |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/programs/games/checkers/trunk/gnu-draw.h |
---|
0,0 → 1,295 |
#include "gr-draw.h" |
#include <X11/Xlib.h> |
#include <X11/Xutil.h> |
#include <X11/Xos.h> |
#include <X11/keysym.h> |
#include <stdio.h> |
#ifndef _GNU_GRAPHIC_DRAW_H |
#define _GNU_GRAPHIC_DRAW_H |
class TGnuGraphDraw : public TGraphDraw |
{ |
public: |
TGnuGraphDraw(const char *s = 0); |
~TGnuGraphDraw(); |
static unsigned long GetKeySym(unsigned int key) {return key;} |
unsigned long GetBlackColor(); |
unsigned long GetWhiteColor(); |
unsigned long CreateColor(unsigned short red, |
unsigned short green, unsigned short blue); |
void FreeColor(unsigned long c); |
unsigned int GetBgColor() const {return bgcolor;} |
void SetBgColor(unsigned long c) {bgcolor = c;} |
int GetStatus() {return disp ? (win ? 1 : 0) : (-1);} |
int Init() {return disp ? 0 : -1;} |
int Run(int evmask = 0, int w = INT_MIN, int h = INT_MIN); |
void GetSize(int &w, int &h); |
int OpenDraw(); |
int IsDraw() {return disp && win && prGC;} |
void CloseDraw() {if (prGC) {XFreeGC(disp, prGC); prGC = 0;}} |
int SetColor(unsigned long c); |
int DrawLine(int x0, int y0, int x1, int y1); |
int DrawText(int x0, int y0, char *text); |
int DrawClear(); |
int GetTextH(const char *s) {return 10;} |
int GetTextW(const char *s) {return 6 * strlen(s);} |
void Quit(int q = 1) {quit = (q > 0) ? q : 0;} |
void ResReinit(int w = INT_MIN, int h = INT_MIN); |
protected: |
void InitDisplay(); |
void InitWindow(int w = INT_MIN, int h = INT_MIN); |
protected: |
int quit; |
unsigned long bgcolor; |
Display *disp; |
Window win; |
int ScrNum; |
GC prGC; |
Mask xmask; |
}; |
TGnuGraphDraw::TGnuGraphDraw(const char *s /*= 0*/) : TGraphDraw(s), prGC(0) |
{ |
xmask = 0; |
InitDisplay(); |
} |
TGnuGraphDraw::~TGnuGraphDraw() |
{ |
CloseDraw(); |
if (disp) XCloseDisplay(disp); |
} |
void TGnuGraphDraw::InitDisplay() |
{ |
disp = XOpenDisplay(NULL); |
if (disp) ScrNum = DefaultScreen(disp); |
else |
{ |
int L = 100; |
if (title) L += strlen(title); |
char *str = new char[L]; |
if (str) |
{ |
strcpy(str, "\n"); |
if (title && title[0]) {strcat(str, title); strcat(str, ": ");} |
strcat(str, "Can't connect to X Server.\n"); |
printf("%s", str); |
} |
} |
bgcolor = GetWhiteColor(); |
} |
unsigned long TGnuGraphDraw::GetBlackColor() |
{ |
if (disp) return BlackPixel(disp, ScrNum); |
else return TGraphDraw::GetBlackColor(); |
} |
unsigned long TGnuGraphDraw::GetWhiteColor() |
{ |
if (disp) return WhitePixel(disp, ScrNum); |
else return TGraphDraw::GetWhiteColor(); |
} |
unsigned long TGnuGraphDraw::CreateColor(unsigned short red, |
unsigned short green, unsigned short blue) |
{ |
if (disp) |
{ |
XColor color; |
color.red = red; color.green = green; color.blue = blue; |
if (XAllocColor(disp, DefaultColormap(disp, ScrNum), &color)) |
{ |
return color.pixel; |
} |
else return BlackPixel(disp, ScrNum); |
} |
else return TGraphDraw::CreateColor(red, green, blue); |
} |
void TGnuGraphDraw::FreeColor(unsigned long c) |
{ |
if (disp && c != BlackPixel(disp, ScrNum)) |
{ |
XFreeColors(disp, DefaultColormap(disp, ScrNum), &c, 1, 0); |
} |
} |
void TGnuGraphDraw::GetSize(int &w, int &h) |
{ |
if (disp) |
{ |
int x, y; |
Window w_ret; |
unsigned int br, dr, width = 0, height = 0; |
XGetGeometry(disp, win, &w_ret, &x, &y, &width, &height, &br, &dr); |
w = width; h = height; |
} |
else TGraphDraw::GetSize(w, h); |
} |
int TGnuGraphDraw::OpenDraw() |
{ |
if (!disp && !win) return 0; |
if (!prGC) prGC = XCreateGC(disp, win, 0, NULL); |
return 1; |
} |
int TGnuGraphDraw::SetColor(unsigned long c) |
{ |
if (!disp || !prGC) return 0; |
XSetForeground(disp, prGC, c); |
return 1; |
} |
int TGnuGraphDraw::DrawLine(int x0, int y0, int x1, int y1) |
{ |
if (!disp || !prGC) return 0; |
XDrawLine(disp, win, prGC, x0, y0, x1, y1); |
return 1; |
} |
int TGnuGraphDraw::DrawText(int x0, int y0, char *text) |
{ |
if (!disp || !prGC) return 0; |
XDrawString(disp, win, prGC, x0, y0 + GetTextH(text), text, strlen(text)); |
return 1; |
} |
int TGnuGraphDraw::DrawClear() |
{ |
if (!disp || !prGC) return 0; |
XClearWindow(disp, win); |
return 1; |
} |
void TGnuGraphDraw::InitWindow(int w, int h) |
{ |
if (w <= 0 || h <= 0) TGraphDraw::GetSize(w, h); |
win = XCreateSimpleWindow(disp, RootWindow(disp, ScrNum), |
100, 100, w, h, 2, BlackPixel(disp, ScrNum), GetBgColor()); |
XSelectInput(disp, win, xmask); |
XMapWindow(disp, win); |
} |
void TGnuGraphDraw::ResReinit(int w, int h) |
{ |
if (disp) {free(disp); disp = 0;} |
InitDisplay(); |
if (!disp) exit(1); |
else if (win) InitWindow(w, h); |
} |
int TGnuGraphDraw::Run(int evmask, int w, int h) |
{ |
if (!disp) return -1; |
if (!evfunc) return -2; |
xmask = ExposureMask; |
if (evmask & button_down_mask) xmask |= ButtonPressMask; |
if (evmask & button_up_mask) xmask |= ButtonReleaseMask; |
if (evmask & key_down_mask) xmask |= KeyPressMask; |
if (evmask & key_up_mask) xmask |= KeyReleaseMask; |
if (evmask & mouse_move_mask) xmask |= PointerMotionMask; |
if (evmask & mouse_drag_mask) |
{ |
xmask |= ButtonMotionMask | Button1MotionMask | Button2MotionMask | |
Button3MotionMask | Button4MotionMask | Button5MotionMask; |
} |
InitWindow(w, h); |
XEvent xevent; |
KeySym sym; |
char str[50]; |
event ev; |
int stpr = 0; |
quit = 0; |
while (quit == 0) |
{ |
if (stpr == 0) |
{ |
ev.type = event::start; |
ev.any.drw = this; |
evfunc(ev); |
CloseDraw(); |
stpr = 1; |
} |
else |
{ |
XNextEvent(disp, &xevent); |
switch(xevent.type) |
{ |
case Expose: |
if (xevent.xexpose.count != 0) break; |
ev.type = event::draw; |
ev.any.drw = this; |
evfunc(ev); |
CloseDraw(); |
break; |
case ButtonPress: |
ev.type = event::button_down; |
ev.button.drw = this; |
ev.button.x = xevent.xbutton.x; |
ev.button.y = xevent.xbutton.y; |
ev.button.n = xevent.xbutton.button; |
evfunc(ev); |
CloseDraw(); |
break; |
case ButtonRelease: |
ev.type = event::button_up; |
ev.button.drw = this; |
ev.button.x = xevent.xbutton.x; |
ev.button.y = xevent.xbutton.y; |
ev.button.n = xevent.xbutton.button; |
evfunc(ev); |
CloseDraw(); |
break; |
case MotionNotify: |
ev.type = event::mouse_move; |
ev.button.drw = this; |
ev.button.x = xevent.xbutton.x; |
ev.button.y = xevent.xbutton.y; |
ev.button.n = xevent.xbutton.button; |
evfunc(ev); |
CloseDraw(); |
break; |
case KeyPress: |
memset(str, 0, 20); |
XLookupString(&xevent.xkey, str, 20, &sym, 0); |
ev.type = event::key_down; |
ev.key.drw = this; |
ev.key.k = (unsigned long)sym; |
evfunc(ev); |
CloseDraw(); |
break; |
case KeyRelease: |
memset(str, 0, 20); |
XLookupString(&xevent.xkey, str, 20, &sym, 0); |
ev.type = event::key_up; |
ev.key.drw = this; |
ev.key.k = (unsigned long)sym; |
evfunc(ev); |
CloseDraw(); |
break; |
} |
} |
if (quit == 1) |
{ |
ev.type = event::close; |
ev.any.drw = this; |
Quit(evfunc(ev)); |
CloseDraw(); |
} |
} |
CloseDraw(); |
XDestroyWindow(disp, win); |
win = 0; |
return quit; |
} |
#endif //_GNU_GRAPHIC_DRAW_H |
/programs/games/checkers/trunk/gr-draw.h |
---|
0,0 → 1,121 |
#ifndef _GRAPHIC_DRAW_H |
#define _GRAPHIC_DRAW_H |
#ifndef __MENUET__ |
#include <limits.h> |
#include <string.h> |
#ifdef _Windows |
# include <windows.h> |
#endif |
#else |
#define LONG_MIN (-2147483647L-1) /* minimum signed long value */ |
#define INT_MIN LONG_MIN |
#endif |
class TGraphDraw |
{ |
public: |
union event |
{ |
enum evtype {noevent = 0, draw, button_down, button_up, |
mouse_move, key_down, key_up, start, close} type; |
struct evany |
{ |
evtype type; |
TGraphDraw *drw; |
} any; |
struct evbutton : public evany |
{ |
int x, y, n; |
} button; |
struct evkey : public evany |
{ |
unsigned long k; |
} key; |
}; |
enum {button_down_mask = 0x1, button_up_mask = 0x2, key_down_mask = 0x4, |
key_up_mask = 0x8, mouse_move_mask = 0x10, mouse_drag_mask = 0x20}; |
enum {ret_setcapture = 0x10}; |
public: |
TGraphDraw(const char *s = 0) : title(0), about_info(0), |
evfunc(0), id(0), data(0) {CopyTitle(s);} |
~TGraphDraw() {FreeTitle();} |
virtual unsigned long GetBlackColor() {return 0;} |
virtual unsigned long GetWhiteColor() {return 0xFFFFFFL;} |
virtual unsigned long CreateColor(unsigned short red, |
unsigned short green, unsigned short blue); |
virtual void FreeColor(unsigned long c) {} |
virtual unsigned long GetBgColor() {return GetWhiteColor();} |
virtual void SetBgColor(unsigned long c) {} |
virtual void SetTitle(const char *s) {CopyTitle(s);} |
const char *GetTitle() const {return title;} |
virtual int GetStatus() {return 0;} //1 - can draw, 0 - can't draw, <0 - error |
virtual int Init() {return 0;} |
virtual void UnInit() {} |
virtual int Run(int evmask = 0, int w = INT_MIN, int h = INT_MIN) {return -100;} |
virtual void GetSize(int &w, int &h) {w = 200; h = 200;} |
virtual int OpenDraw() {return 0;} |
virtual int IsDraw() {return 0;} |
virtual void CloseDraw() {} |
virtual int SetColor(unsigned long c) {return 0;} |
virtual int DrawLine(int x0, int y0, int x1, int y1) {return 0;} |
virtual int DrawText(int x0, int y0, char *text) {return 0;} |
virtual int DrawClear() {return 0;} |
virtual int GetTextH(const char *s) {return 16;} |
virtual int GetTextW(const char *s) {return 8 * strlen(s);} |
virtual void Quit(int q = 1) {} |
virtual void ResReinit(int w = INT_MIN, int h = INT_MIN) {} |
virtual int GetAboutInfo() {return about_info;} |
virtual void SetAboutInfo(int inf) {about_info = inf;} |
protected: |
void FreeTitle() {if (title) {delete[] title; title = 0;}} |
void CopyTitle(const char *s); |
char *title; |
int about_info; |
public: |
int (*evfunc)(const event &ev); |
int id; |
void *data; |
}; |
unsigned long TGraphDraw::CreateColor(unsigned short red, |
unsigned short green, unsigned short blue) |
{ |
return (unsigned long)(red >> 8) + ((unsigned long)(green >> 8) << 8) + |
((unsigned long)(blue >> 8) << 16); |
} |
void TGraphDraw::CopyTitle(const char *s) |
{ |
FreeTitle(); |
if (s) {title = new char[strlen(s) + 1]; strcpy(title, s);} |
} |
#if defined __GNUC__ |
# include "gnu-draw.h" |
typedef TGnuGraphDraw TMainGraphDraw; |
#elif defined __MENUET__ |
# include "mt-draw.h" |
typedef TKlbrGraphDraw TMainGraphDraw; |
#elif defined _Windows |
# include "win-draw.h" |
typedef TWinGraphDraw TMainGraphDraw; |
#elif defined __MSDOS__ |
# include "dos-draw.h" |
typedef TDosGraphDraw TMainGraphDraw; |
#else |
typedef TGraphDraw TMainGraphDraw; |
#endif |
#endif //_GRAPHIC_DRAW_H |
/programs/games/checkers/trunk/hash.h |
---|
0,0 → 1,185 |
#if !defined(HASH_TABLE_H) |
#define HASH_TABLE_H |
template <class T, class TypeString, class HashFunction> |
class THashTable |
{ |
public: |
THashTable(int _m = -1) {MemInit(_m);} |
~THashTable() {null();} |
int hash1(const TypeString &x) const {return func1(x);} |
int hash2(const TypeString &x) const {return 2*func2(x) + 1;} |
void null(); |
int IsNull() const {return M >= 0;} |
int NumElem() const {return n;} |
int MaxNumElem() const {return stack_size;} |
int GetM() const {return M;} |
int TableSize() const {return 1 << M;} |
void resize(int _m); |
void push(const T &x); |
T *find(const TypeString &x); |
void pop(); |
T &last() {return stack[n-1];} |
const T &last() const {return stack[n-1];} |
T &first() {return stack[0];} |
const T &first() const {return stack[0];} |
T &operator[](int i) {return stack[i];} |
const T &operator[](int i) const {return stack[i];} |
T *operator()() {return stack;} |
const T *operator()() const {return stack;} |
protected: |
void _push(const T &x); |
int _find_pointer(const T *p) const; |
int _find(const TypeString &x) const; |
void MemInit(int _m); |
protected: |
int M; |
int stack_size; |
int n; |
T **table; |
T *stack; |
protected: |
HashFunction func1, func2; |
}; |
template <class T, class TypeString, class HashFunction> |
void THashTable<T, TypeString, HashFunction>::null() |
{ |
if (table) delete[] table; |
if (stack) delete[] stack; |
M = -1; |
table = 0; |
stack = 0; |
stack_size = 0; |
n = 0; |
func1.init(-1); |
func2.init(-1); |
} |
template <class T, class TypeString, class HashFunction> |
void THashTable<T, TypeString, HashFunction>::resize(int _m) |
{ |
delete[] table; |
T *stp = stack; |
int np = n; |
MemInit(_m); |
for (int i = 0; i < np && n < stack_size; i++) _push(stp[i]); |
if (stp) delete[] stp; |
} |
template <class T, class TypeString, class HashFunction> |
inline void THashTable<T, TypeString, HashFunction>::push(const T &x) |
{ |
if (n == stack_size) resize(M + 1); |
_push(x); |
} |
template <class T, class TypeString, class HashFunction> |
inline T *THashTable<T, TypeString, HashFunction>::find(const TypeString &x) |
{ |
int i = _find(x); |
if (i >= 0) return table[i]; |
else return 0; |
} |
template <class T, class TypeString, class HashFunction> |
inline void THashTable<T, TypeString, HashFunction>::pop() |
{ |
if (n > 0) |
{ |
n--; |
int i = _find_pointer(stack + n); |
if (i >= 0) table[i] = NULL; |
} |
} |
template <class T, class TypeString, class HashFunction> |
void THashTable<T, TypeString, HashFunction>::_push(const T &x) |
{ |
int h1 = hash1(x); |
int h2 = hash2(x); |
int i = h1; |
stack[n] = x; |
do |
{ |
if (table[i] == NULL) |
{ |
table[i] = stack + n; |
break; |
} |
i = (i + h2) & ((1 << M) - 1); |
} |
while (i != h1); |
n++; |
} |
template <class T, class TypeString, class HashFunction> |
int THashTable<T, TypeString, HashFunction>::_find_pointer(const T *p) const |
{ |
if (n > 0) |
{ |
int h1 = hash1(*p); |
int h2 = hash2(*p); |
int i = h1; |
do |
{ |
if (table[i] == NULL) break; |
if (table[i] == p) return i; |
i = (i + h2) & ((1 << M) - 1); |
} |
while (i != h1); |
} |
return -1; |
} |
template <class T, class TypeString, class HashFunction> |
int THashTable<T, TypeString, HashFunction>::_find(const TypeString &x) const |
{ |
if (n > 0) |
{ |
int h1 = hash1(x); |
int h2 = hash2(x); |
int i = h1; |
do |
{ |
if (table[i] == NULL) break; |
if ((*table[i]) == x) return i; |
i = (i + h2) & ((1 << M) - 1); |
} |
while (i != h1); |
} |
return -1; |
} |
template <class T, class TypeString, class HashFunction> |
void THashTable<T, TypeString, HashFunction>::MemInit(int _m) |
{ |
M = _m; |
if (M < 0) |
{ |
M = -1; |
stack_size = 0; |
table = 0; |
stack = 0; |
n = 0; |
func1.init(-1); |
func2.init(-1); |
} |
else |
{ |
if (M < 3) M = 3; |
stack_size = (1 << M) / 3; |
table = new T*[1 << M]; |
for (int i = 0; i < (1 << M); i++) table[i] = NULL; |
stack = new T[stack_size]; |
n = 0; |
func1.init(M); |
func2.init(M-1); |
} |
} |
#endif // HASH_TABLE_H |
/programs/games/checkers/trunk/history.h |
---|
0,0 → 1,402 |
#ifndef _HEADER_HISTORY_H |
#define _HEADER_HISTORY_H |
#ifndef __MENUET__ |
#include <string.h> |
#include <stdio.h> |
#include <time.h> |
#include <stdlib.h> |
#endif |
#include "position.h" |
#include "hash.h" |
#include "sysproc.h" |
class THistory |
{ |
#ifndef __MENUET__ |
public: |
static char FileName[1024]; |
#endif |
public: |
THistory(int id = 0) {if (id >= 0) Hid = NHid++; else Hid = id;} |
int GetId() const {return Hid;} |
static int GetNId() {return NHid;} |
int Start(const Position &pos) const; |
int Move(const Position &pos, const unsigned char mv[], int nmove) const; |
int Play(const PlayWrite &play) const; |
#ifndef __MENUET__ |
static int InitHFile(char *dname = 0); |
static int HRead(FILE *f, PlayWrite *&play); |
protected: |
int Print(const char *str) const; |
#endif |
int Hid; |
static int NHid; |
protected: |
struct TStr |
{ |
TStr(const char *ss = 0) : s(0) {(*this) = ss;} |
TStr(const TStr &ss) : s(0) {(*this) = ss.s;} |
~TStr() {(*this) = 0;} |
TStr &operator=(const char *ss); |
TStr &operator=(const TStr &ss) {return (*this) = ss.s;} |
operator char*() {return s;} |
operator const char*() const {return s;} |
char &operator*() {return *s;} |
const char &operator*() const {return *s;} |
char &operator[](int i) {return s[i];} |
const char &operator[](int i) const {return s[i];} |
void Extend(int n); |
friend int operator==(const TStr &s1, const TStr &s2) |
{return strcmp(s1, s2) == 0;} |
friend int operator==(const char *s1, const TStr &s2) |
{return strcmp(s1, s2) == 0;} |
friend int operator==(const TStr &s1, const char *s2) |
{return strcmp(s1, s2) == 0;} |
friend int operator!=(const TStr &s1, const TStr &s2) |
{return strcmp(s1, s2) != 0;} |
friend int operator!=(const char *s1, const TStr &s2) |
{return strcmp(s1, s2) != 0;} |
friend int operator!=(const TStr &s1, const char *s2) |
{return strcmp(s1, s2) != 0;} |
friend int operator>=(const TStr &s1, const TStr &s2) |
{return strcmp(s1, s2) >= 0;} |
friend int operator>=(const char *s1, const TStr &s2) |
{return strcmp(s1, s2) >= 0;} |
friend int operator>=(const TStr &s1, const char *s2) |
{return strcmp(s1, s2) >= 0;} |
friend int operator<=(const TStr &s1, const TStr &s2) |
{return strcmp(s1, s2) <= 0;} |
friend int operator<=(const char *s1, const TStr &s2) |
{return strcmp(s1, s2) <= 0;} |
friend int operator<=(const TStr &s1, const char *s2) |
{return strcmp(s1, s2) <= 0;} |
friend int operator>(const TStr &s1, const TStr &s2) |
{return strcmp(s1, s2) > 0;} |
friend int operator>(const char *s1, const TStr &s2) |
{return strcmp(s1, s2) > 0;} |
friend int operator>(const TStr &s1, const char *s2) |
{return strcmp(s1, s2) > 0;} |
friend int operator<(const TStr &s1, const TStr &s2) |
{return strcmp(s1, s2) < 0;} |
friend int operator<(const char *s1, const TStr &s2) |
{return strcmp(s1, s2) < 0;} |
friend int operator<(const TStr &s1, const char *s2) |
{return strcmp(s1, s2) < 0;} |
char *s; |
}; |
class THash |
{ |
public: |
void init(int _m); |
int operator()(const TStr &str) const; |
protected: |
int m; |
int K[16]; |
}; |
struct TTableItem |
{ |
TTableItem(const char *s = 0, int k = 0) : str(s), k(k) {} |
TTableItem(const TStr &s, int k = 0) : str(s), k(k) {} |
TTableItem(const TTableItem &t) : str(t.str), k(t.k) {} |
operator TStr&() {return str;} |
operator const TStr&() const {return str;} |
TStr str; |
int k; |
}; |
}; |
#ifndef __MENUET__ |
char THistory::FileName[1024] = "history.che"; |
#endif |
int THistory::NHid = 0; |
#ifndef __MENUET__ |
int THistory::Print(const char *str) const |
{ |
char *line = new char[30 + strlen(str)]; |
if (!line) return 0; |
unsigned long pr_id = GetProcessId(); |
if (Hid == -1) sprintf(line, "%lu %s\n", pr_id, str); |
else if (Hid < 0) sprintf(line, "%lu%c %s\n", pr_id, (char)Hid, str); |
else sprintf(line, "%lu:%d %s\n", pr_id, Hid, str); |
FILE *f = fopen(FileName, "at"); |
if (!f) |
{ |
clock_t cc = clock(); |
do {f = fopen(FileName, "at");} |
while(!f && (clock() - cc) <= 0.05 * CLOCKS_PER_SEC); |
} |
if (!f) {delete[] line; return 0;} |
fputs(line, f); |
fclose(f); |
delete[] line; |
return 1; |
} |
#endif |
int THistory::Start(const Position &pos) const |
{ |
char str[20 + NUM_CELL] = "Start "; |
if (!pos.Write(str + strlen(str), 1)) return 0; |
#ifndef __MENUET__ |
if (!Print(str)) return 0; |
#endif |
return 1; |
} |
int THistory::Move(const Position &pos, const unsigned char mv[], int nmove) const |
{ |
char *str = new char[15 + pos.GetLenMvEx(mv, 11)]; |
if (!str) return 0; |
sprintf(str, "%d.%s ", (nmove + 1) / 2, (nmove % 2 == 0) ? ".." : ""); |
pos.WriteMvEx(mv, str + strlen(str), 11); |
#ifndef __MENUET__ |
if (!Print(str)) {delete[] str; return 0;} |
#endif |
delete[] str; |
return 1; |
} |
int THistory::Play(const PlayWrite &play) const |
{ |
if (play.GetN() <= 0) return 0; |
Position pos; |
if (play.GetPos(pos, 0) < 0) return 0; |
if (!Start(pos)) return 0; |
int i; |
unsigned char mv[NUM_CELL]; |
for (i = 1; i < play.GetN(); i++) |
{ |
if (play.GetPos(pos, i - 1) < 0) return 0; |
if (play.GetMove(mv, i) < 0) return 0; |
if (!Move(pos, mv, i)) return 0; |
} |
return 1; |
} |
#ifndef __MENUET__ |
int THistory::InitHFile(char *dname) |
{ |
if (dname && dname[0]) |
{ |
char fnm[1024]; |
strcpy(fnm, dname); |
int i; |
for (i = strlen(fnm) - 1; i >= 0; i--) |
{ |
if (fnm[i] == DIR_SEPARATOR) break; |
} |
if (i >= 0) |
{ |
strcpy(fnm + i + 1, FileName); |
strcpy(FileName, fnm); |
} |
} |
int e = 1; |
FILE *f = fopen(FileName, "rt"); |
if (f) {e = feof(f); fclose(f);} |
if (!e) return 0; |
f = fopen(FileName, "wt"); |
if (!f) return -1; |
fputs("checkers-history_1.1\n", f); |
fclose(f); |
return 1; |
} |
#endif |
THistory::TStr &THistory::TStr::operator=(const char *ss) |
{ |
if (s) delete[] s; |
if (ss) |
{ |
s = new char[strlen(ss) + 1]; |
strcpy(s, ss); |
} |
else s = 0; |
return *this; |
} |
void THistory::TStr::Extend(int n) |
{ |
if (n <= 0) {(*this) = 0; return;} |
char *ss = s; |
s = new char[n+1]; |
if (ss) |
{ |
strncpy(s, ss, n); |
s[n] = 0; |
delete[] ss; |
} |
else s[0] = 0; |
} |
void THistory::THash::init(int _m) |
{ |
m = _m; |
for (int i = 0; i < 16; i++) |
{ |
K[i] = (2*random(32767) + 1) & ((1 << m) - 1); |
} |
} |
int THistory::THash::operator()(const TStr &str) const |
{ |
int i, r = 0; |
const char *s = str; |
for (i = 0; *s; i = (i+1) & 15) r += *(s++) * K[i]; |
r &= (1 << m) - 1; |
return r; |
} |
#ifndef __MENUET__ |
int THistory::HRead(FILE *f, PlayWrite *&play) |
{ |
const int MAX_INP_WORD = 100; |
int nplay = 0, mplay = 10; |
play = new PlayWrite[mplay]; |
THashTable<TTableItem, TStr, THash> table; |
TStr word; |
char inp_word[MAX_INP_WORD + 1]; |
int r, maxword = 0; |
unsigned char ch; |
int i, k = 0, kind = 0, wasspace = 1, nmove = 0; |
for (;;) |
{ |
r = (fread(&ch, 1, 1, f) == 1); |
if (!r || isspace(ch)) |
{ |
if (!wasspace) |
{ |
if (kind == 0) kind = 1; |
else if (kind == 2) |
{ |
for (i = 0; inp_word[i]; i++) |
{ |
inp_word[i] = (char)tolower((unsigned char)inp_word[i]); |
} |
if (strcmp(inp_word, "start") == 0) kind = 5; |
else kind = -1; |
inp_word[0] = 0; k = 0; |
} |
else if (kind == 3) |
{ |
nmove *= 2; |
if (k <= 1) nmove--; |
inp_word[0] = 0; |
k = 0; kind = 4; |
} |
else if (kind == 4) |
{ |
TTableItem *n_pl = table.find(word); |
if (!n_pl) kind = -1; |
else if (nmove < 1 || nmove > play[n_pl->k].GetN()) kind = -1; |
else |
{ |
PlayWrite::PMv pmv; |
if (play[n_pl->k].GetPos(pmv.pos, nmove - 1) < 0) kind = -1; |
else if (!pmv.pos.ReadMv(pmv.mv, inp_word, 1)) kind = -1; |
else |
{ |
play[n_pl->k].ClearFrom(nmove); |
if (play[n_pl->k].Add(pmv.mv) != 0) kind = -1; |
else {k = n_pl->k; kind = 11;} |
} |
} |
} |
else if (kind == 5) |
{ |
Position pos; |
pos.Read(inp_word, 1); |
if (pos.IsNull()) kind = -1; |
else |
{ |
TTableItem *n_pl = table.find(word); |
if (!n_pl) |
{ |
table.push(TTableItem(word, nplay)); |
n_pl = table.find(word); |
} |
if (!n_pl) kind = -1; |
else |
{ |
if (nplay >= mplay) |
{ |
PlayWrite *play0 = play; |
int mplay0 = mplay; |
mplay = 2*nplay + 3; |
play = new PlayWrite[mplay]; |
if (play0) |
{ |
for (i = 0; i < mplay0; i++) play[i] = play0[i]; |
delete[] play0; |
} |
} |
n_pl->k = nplay++; |
play[n_pl->k].Add(0, pos); |
k = n_pl->k; kind = 12; |
} |
} |
} |
} |
if (!r || ch == '\n' || ch == '\r') |
{ |
k = 0; |
kind = 0; |
if (!r) break; |
} |
wasspace = 1; |
} |
else |
{ |
if (kind == 0) |
{ |
if (k >= maxword) word.Extend(2*k + 3); |
word[k++] = ch; |
word[k] = 0; |
} |
else if (kind == 1) |
{ |
if (isdigit(ch)) {nmove = ch - '0'; k = 0; kind = 3;} |
else |
{ |
inp_word[0] = ch; |
inp_word[1] = 0; |
k = 1; kind = 2; |
} |
} |
else if (kind == 2 || kind == 4 || kind == 5) |
{ |
if (k < MAX_INP_WORD) |
{ |
inp_word[k++] = ch; |
inp_word[k] = 0; |
} |
} |
else if (kind == 3) |
{ |
if (k == 0 && isdigit(ch)) nmove = 10 * nmove + ch - '0'; |
else if (ch == '.') k++; |
else kind = -1; |
} |
wasspace = 0; |
} |
} |
return nplay; |
} |
#endif |
#endif //_HEADER_HISTORY_H |
/programs/games/checkers/trunk/include/me_func.inc |
---|
0,0 → 1,1135 |
;const int |
MENUET_BORDER_SIZE = 4; |
;const int |
MENUET_HEADER_SIZE = 20; |
;const int |
MENUET_THREAD_DATA_USER = 0; // Thread data begin from the user dword |
;const int |
MENUET_THREAD_DATA_ST_BEGIN = 1; // Stack beginning follows after the user dword |
;const int |
MENUET_THREAD_DATA_NEXT = 2; |
;const int |
MENUET_THREAD_DATA_PID = 3; |
;const int |
MENUET_THREAD_DATA_FLAG = 4; |
;const int |
MENUET_THREAD_DATA_X = 5; |
;const int |
MENUET_THREAD_DATA_Y = 6; |
;const int |
MENUET_THREAD_DATA_C_WINDOW = 7; |
;const int |
MENUET_THREAD_DATA_C_HEADER = 8; |
;const int |
MENUET_THREAD_DATA_C_BORDER = 9; |
;const int |
MENUET_THREAD_DATA_C_TITLE = 10; |
;const int |
MENUET_THREAD_DATA_TITLE = 11; |
;const int |
MENUET_THREAD_DATA_PICTURE = 12; |
;const int |
MENUET_THREAD_DATA_SZ_PICT = 13; |
;const int |
MENUET_THREAD_DATA_LAST_SX = 14; |
;const int |
MENUET_THREAD_DATA_LAST_SY = 15; |
;const int |
MENUET_THREAD_DATA_LEN = 16; |
;const int |
MENUET_MUTEX_MAX_TIME_WAIT = 20; |
;const int |
MENUET_FILE_BLOCK_SIZE = 512; |
;const int |
MENUET_FILE_MEMORY_OS_NEED = 4096; |
;/*** |
macro segment name |
{ |
segment name |
if name eq _init_ | name eq _INIT_ |
Menuet_SegmentInit: |
else if name eq _exit_ | name eq _EXIT_ |
Menuet_SegmentExit: |
end if |
} |
macro endseg name |
{ |
if name eq _init_ | name eq _INIT_ |
Menuet_SegmentInitEnd: |
else if name eq _exit_ | name eq _EXIT_ |
Menuet_SegmentExitEnd: |
end if |
endseg name |
} |
macro Menuet_Put_MovEaxVal_Ret address,val |
{ |
mov byte [address],0xB8 |
mov dword [address+4],0xC089C300 |
mov dword [address+1],val |
} |
define @Menuet@Main$qv |
nextdef MenuetEntryPoint |
and esp,not 3 |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov ebx,[esp+26] |
mov edx,[esp+30] |
lea eax,[ebx-0x20] |
add esp,1024 |
cmp esp,eax |
cmova esp,eax |
and esp,not 3 |
xor eax,eax |
cld |
mov edi,@Menuet@_ThreadTable |
mov ecx,256 |
rep stos dword [edi] |
mov esi,@Menuet@GetPid$qv |
mov edi,@Menuet@_ThreadSavedBegProc |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov esi,@Menuet@GetThreadData$qv |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
Menuet_Put_MovEaxVal_Ret @Menuet@GetPid$qv,edx |
if defined MenuetHeapInit |
mov ecx,esp |
push ebx |
push ecx |
push U_END |
call MenuetHeapInit ; Initialize a dynamic heap and create new memory in its begin. |
pop ecx ; Parameters: begin of a new heap, end of data to create in |
mov [esp+4],eax ; the begin of a heap. Return address of the created data. |
mov dword [esp],0 |
else |
xor eax,eax |
push eax |
push eax |
end if |
call @Menuet@ThreadMain$qpvt1 |
nextdef Menuet_ThreadFinish |
add esp,8 |
if defined MenuetHeapFreeAndThreadFinish |
test eax,eax |
jz Menuet_ThreadFinish_end |
push dword @Menuet@_ExitProcessNow |
push eax |
call MenuetHeapFreeAndThreadFinish ; Free the given memory and finish the thread, |
end if ; should exit process if second argument points to not zero. |
Menuet_ThreadFinish_end: |
or eax,-1 |
int 0x40 |
enddef |
define @Menuet@ThreadMain$qpvt1 |
xchg ebx,[esp+4] |
xchg ebp,[esp+8] |
push esi |
push edi |
sub esp,MENUET_THREAD_DATA_LEN*4 |
mov [esp],ebx |
mov [esp+4],ebp |
mov eax,40 |
mov ebx,0x27 |
int 0x40 |
mov ebx,esp |
cmp byte [@Menuet@_ThreadSavedBegProc],0x90 |
jz Menuet_main_else_first_check |
Menuet_Put_MovEaxVal_Ret @Menuet@GetThreadData$qv,esp |
if defined Menuet_SegmentInit & defined Menuet_SegmentInitEnd |
push Menuet_SegmentInitEnd |
push Menuet_SegmentInit |
jmp Menuet_main_after_first_check |
end if |
Menuet_main_else_first_check: |
xor eax,eax |
push eax |
push eax |
Menuet_main_after_first_check: |
push ebx |
call @@Menuet@_CallStart$qppvpvt2 |
add esp,12 |
test al,al |
jnz Menuet_main_test_close_first |
jmp Menuet_main_end |
Menuet_main_close_first: |
btr dword [esp+MENUET_THREAD_DATA_FLAG*4],31 |
push esp |
call @@MenuetOnClose$qppv |
pop ecx |
test al,al |
jnz Menuet_main_end |
Menuet_main_test_close_first: |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jl Menuet_main_close_first |
; push esp |
; push dword 1 |
; call @Menuet@Redraw$qippv |
; add esp,8 |
Menuet_main_paint_msg: |
or dword [esp+MENUET_THREAD_DATA_FLAG*4],3 |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov eax,[esp+34] |
mov ebx,[esp+38] |
mov ecx,[esp+42] |
mov edx,[esp+46] |
add esp,1024 |
cmp ecx,[esp+MENUET_THREAD_DATA_LAST_SX*4] |
jnz Menuet_main_size |
cmp edx,[esp+MENUET_THREAD_DATA_LAST_SY*4] |
jz Menuet_main_paint |
Menuet_main_size: |
mov [esp+MENUET_THREAD_DATA_LAST_SX*4],ecx |
mov [esp+MENUET_THREAD_DATA_LAST_SY*4],edx |
push edx |
push ecx |
push ebx |
push eax |
lea ecx,[esp+16] |
mov edx,esp |
push ecx |
push edx |
call @@MenuetOnSize$qpippv |
add esp,24 |
test dword [esp+MENUET_THREAD_DATA_FLAG*4],3 |
jz Menuet_main_cycle |
Menuet_main_paint: |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jl Menuet_main_close |
push esp |
push dword 0 |
call @Menuet@Redraw$qippv |
add esp,8 |
Menuet_main_cycle: |
mov eax,11 |
Menuet_main_message: |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jl Menuet_main_close |
int 0x40 |
test eax,eax |
jnz Menuet_main_on_message |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jne Menuet_main_paint |
push esp |
call @@MenuetOnIdle$qppv |
pop ecx |
test eax,eax |
jz Menuet_main_cycle |
jl Menuet_main_wait_message |
mov ebx,eax |
mov eax,23 |
jmp Menuet_main_message |
Menuet_main_wait_message: |
mov eax,10 |
jmp Menuet_main_message |
Menuet_main_key_press: |
push esp |
call @@MenuetOnKeyPress$qppv |
pop ecx |
jmp Menuet_main_cycle |
Menuet_main_mouse: |
push esp |
call @@MenuetOnMouse$qppv |
pop ecx |
jmp Menuet_main_cycle |
Menuet_main_on_message: |
dec eax |
jz Menuet_main_paint_msg |
dec eax |
jz Menuet_main_key_press |
cmp eax,4 |
jz Menuet_main_mouse |
dec eax |
jnz Menuet_main_cycle |
Menuet_main_button: |
mov eax,17 |
int 0x40 |
test al,al |
jnz Menuet_main_cycle |
Menuet_main_close: |
btr dword [esp+MENUET_THREAD_DATA_FLAG*4],31 |
push esp |
call @@MenuetOnClose$qppv |
pop ecx |
test al,al |
jz Menuet_main_button |
Menuet_main_end: |
mov ebx,esp |
lock dec dword [@Menuet@_ThreadNumber] |
if defined Menuet_SegmentExit & defined Menuet_SegmentExitEnd |
jnz Menuet_main_else_last_check |
push Menuet_SegmentExitEnd |
push Menuet_SegmentExit |
jmp Menuet_main_after_last_check |
end if |
Menuet_main_else_last_check: |
xor eax,eax |
push eax |
push eax |
Menuet_main_after_last_check: |
push ebx |
call @@Menuet@_RemoveThreadData$qppvpvt2 |
add esp,12 |
lock inc dword [@Menuet@_ThreadScanCount+4] |
mov ebx,1 |
jmp Menuet_main_end_wait |
Menuet_main_end_wait_loop: |
mov eax,5 |
int 0x40 |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_main_end_wait |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
Menuet_main_end_wait: |
cmp dword [@Menuet@_ExitProcessNow],0 |
jnz @Menuet@ExitProcess$qv |
cmp dword [@Menuet@_ThreadScanCount],0 |
jnz Menuet_main_end_wait_loop |
lock dec dword [@Menuet@_ThreadScanCount+4] |
mov ebp,[esp+4] |
mov ebx,[esp] |
add esp,MENUET_THREAD_DATA_LEN*4 |
mov eax,ebp |
pop edi |
pop esi |
xchg ebp,[esp+8] |
xchg ebx,[esp+4] |
ret |
enddef |
macro call func |
{ |
if func eq __chkstk |
sub esp,eax |
else |
call func |
end if |
} |
define @Menuet@Redraw$qippv |
push ebp |
mov ebp,[esp+12] |
mov edx,[ebp+MENUET_THREAD_DATA_FLAG*4] |
cmp dword [esp+8],0 |
jl Menuet_redraw_only_inv |
jz Menuet_redraw_no_frame |
or dl,2 |
Menuet_redraw_no_frame: |
bt edx,30 |
jnc Menuet_redraw_begin |
or dl,1 |
mov [ebp+MENUET_THREAD_DATA_FLAG*4],edx |
jmp Menuet_redraw_end |
Menuet_redraw_only_inv: |
test dl,3 |
jnz Menuet_redraw_no_frame |
Menuet_redraw_end: |
pop ebp |
ret |
Menuet_redraw_begin: |
push ebx |
push esi |
push edi |
and dword [ebp+MENUET_THREAD_DATA_FLAG*4],0xFFFFFFFC |
mov eax,12 |
mov ebx,1 |
int 0x40 |
test dl,2 |
jz Menuet_redraw_picture |
push 48 |
pop eax |
push 4 |
pop ebx |
int 0x40 |
mov ebx,[ebp+MENUET_THREAD_DATA_X*4] |
add ebx,2*5-1 |
mov ecx,[ebp+MENUET_THREAD_DATA_Y*4] |
add cx,ax |
add ecx,5-1 |
mov edx,[ebp+MENUET_THREAD_DATA_C_WINDOW*4] |
; mov esi,[ebp+MENUET_THREAD_DATA_C_HEADER*4] |
; mov edi,[ebp+MENUET_THREAD_DATA_C_BORDER*4] |
mov edi,[ebp+MENUET_THREAD_DATA_TITLE*4] |
xor eax,eax |
int 0x40 |
; mov edx,[ebp+MENUET_THREAD_DATA_TITLE*4] |
; test edx,edx |
; jz Menuet_redraw_picture |
; mov edi,edx |
; mov ecx,0xFFFFFFFF |
; xor al,al |
; cld |
; repnz scas byte [edi] |
; not ecx |
; mov esi,ecx |
; dec esi |
; jz Menuet_redraw_picture |
; mov eax,4 |
; mov ebx,0x00070007 |
; mov ecx,[ebp+MENUET_THREAD_DATA_C_TITLE*4] |
; int 0x40 |
Menuet_redraw_picture: |
; mov esi,[ebp+MENUET_THREAD_DATA_PICTURE*4] |
; test esi,esi |
; jz Menuet_redraw_end_draw |
; mov ecx,[ebp+MENUET_THREAD_DATA_SZ_PICT*4] |
; jecxz Menuet_redraw_end_draw |
; mov al,byte [ebp+MENUET_THREAD_DATA_C_WINDOW*4+3] |
; and al,15 |
; mov edx,MENUET_BORDER_SIZE*65536+MENUET_HEADER_SIZE |
; cmp al,3 |
; jnz Menuet_redraw_no_skin |
; mov eax,48 |
; mov ebx,4 |
; int 0x40 |
; mov dx,ax |
;Menuet_redraw_no_skin: |
; mov eax,7 |
; mov ebx,esi |
; int 0x40 |
call @@MenuetOnDraw$qv |
Menuet_redraw_end_draw: |
mov eax,12 |
mov ebx,2 |
int 0x40 |
pop edi |
pop esi |
pop ebx |
pop ebp |
ret |
enddef |
define @Menuet@MoveWindow$qxpxi |
push ebx |
push esi |
mov eax,[esp+12] |
mov ebx,[eax] |
mov ecx,[eax+4] |
mov edx,[eax+8] |
mov esi,[eax+12] |
mov eax,67 |
int 0x40 |
pop esi |
pop ebx |
ret |
enddef |
define @Menuet@Abort$qv |
push dword [@Menuet@DebugPrefix] |
call @Menuet@DebugPutString$qpxc |
mov dword [esp],Menuet_abort_string |
call @Menuet@DebugPutString$qpxc |
pop ecx |
nextdef @Menuet@ExitProcess$qv |
lock bts dword [@Menuet@_ExitProcessNow],0 |
jc Menuet_exit_process_wait |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov esi,eax |
mov edi,[esp+30] |
Menuet_exit_process_loop: |
mov eax,9 |
mov ebx,esp |
mov ecx,esi |
int 0x40 |
mov eax,[esp+30] |
cmp eax,edi |
jz Menuet_exit_process_continue |
mov ebx,eax |
or bl,15 |
inc ebx |
jz Menuet_exit_process_continue |
mov ebx,eax |
call Menuet_HashInt |
movzx eax,al |
mov eax,dword [@Menuet@_ThreadTable+eax*4] |
jmp Menuet_exit_process_test |
Menuet_exit_process_next: |
mov eax,dword [eax+MENUET_THREAD_DATA_NEXT*4] |
Menuet_exit_process_test: |
test eax,eax |
jz Menuet_exit_process_continue |
cmp ebx,[eax+MENUET_THREAD_DATA_PID*4] |
jnz Menuet_exit_process_next |
mov eax,18 |
mov ebx,2 |
mov ecx,esi |
int 0x40 |
Menuet_exit_process_continue: |
dec esi |
jnl Menuet_exit_process_loop |
add esp,1024 |
mov dword [@Menuet@_ExitProcessNow],-1 |
if defined EMULATOR |
int3 |
call 0x76543210 |
end if |
Menuet_exit_process_end: |
mov dword [@Menuet@_ThreadMutex],0 |
or eax,-1 |
int 0x40 |
Menuet_exit_process_wait: |
mov eax,5 |
mov ebx,1 |
Menuet_exit_process_wait_loop: |
cmp dword [@Menuet@_ExitProcessNow],0 |
jl Menuet_exit_process_end |
int 0x40 |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_exit_process_wait_loop |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jmp Menuet_exit_process_wait_loop |
enddef |
define @Menuet@ExitThread$qppv,@Menuet@ThreadMain$qpvt1 |
mov esp,[esp+4] |
jmp Menuet_main_end |
enddef |
define @Menuet@ReturnMessageLoop$qppv,@Menuet@ThreadMain$qpvt1 |
mov esp,[esp+4] |
bt dword [esp+MENUET_THREAD_DATA_FLAG*4],30 |
jc Menuet_main_end |
jmp Menuet_main_cycle |
enddef |
define @Menuet@Delay$qui |
push ebx |
mov eax,5 |
mov ebx,[esp+8] |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@Clock$qv |
push ebx |
mov eax,26 |
mov ebx,9 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetPackedTime$qv |
mov eax,3 |
int 0x40 |
ret |
enddef |
define @Menuet@GetTime$qpi |
mov eax,3 |
int 0x40 |
mov edx,[esp+4] |
movzx ecx,al |
shr ecx,4 |
and al,0x0F |
imul ecx,10 |
add cl,al |
mov dword [edx+8],ecx |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx+4],ecx |
bswap eax |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx],ecx |
ret |
enddef |
define @Menuet@GetPackedDate$qv |
mov eax,29 |
int 0x40 |
ret |
enddef |
define @Menuet@GetDate$qpi |
mov eax,29 |
int 0x40 |
mov edx,[esp+4] |
movzx ecx,al |
shr ecx,4 |
and al,0x0F |
imul ecx,10 |
add cl,al |
mov dword [edx+4],ecx |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx],ecx |
bswap eax |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx+8],ecx |
ret |
enddef |
define @Menuet@ReadCommonColors$qpui |
push ebx |
mov eax,48 |
mov ebx,3 |
mov ecx,[esp+8] |
mov edx,40 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetProcessInfo$qpuipct1t1piui |
push ebx |
push esi |
push edi |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,[1024+12+24+esp] |
int 0x40 |
xor edi,edi |
or edi,[1024+12+4+esp] |
jz Menuet_get_proc_info_no_usecpu |
mov ecx,[esp] |
mov [edi],ecx |
xor edi,edi |
Menuet_get_proc_info_no_usecpu: |
or edi,[1024+12+8+esp] |
jz Menuet_get_proc_info_no_name |
lea esi,[esp+10] |
cld |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov byte [edi],0 |
xor edi,edi |
Menuet_get_proc_info_no_name: |
or edi,[1024+12+12+esp] |
jz Menuet_get_proc_info_no_mem |
mov ecx,[esp+26] |
mov [edi],ecx |
xor edi,edi |
Menuet_get_proc_info_no_mem: |
or edi,[1024+12+16+esp] |
jz Menuet_get_proc_info_no_pid |
mov ecx,[esp+30] |
mov [edi],ecx |
xor edi,edi |
Menuet_get_proc_info_no_pid: |
or edi,[1024+12+20+esp] |
jz Menuet_get_proc_info_no_rect |
lea esi,[esp+34] |
cld |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
xor edi,edi |
Menuet_get_proc_info_no_rect: |
add esp,1024 |
pop edi |
pop esi |
pop ebx |
ret |
enddef |
define @Menuet@GetPid$qv |
push ebx |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov eax,[esp+30] |
add esp,1024 |
pop ebx |
ret |
enddef |
define @Menuet@GetPid$qppv |
mov ecx,[esp+4] |
mov eax,[ecx+MENUET_THREAD_DATA_PID*4] |
ret |
enddef |
define @Menuet@_HashByte$qui |
nextdef @Menuet@_HashWord$qui |
nextdef @Menuet@_HashDword$qui |
mov eax,[esp+4] |
nextdef Menuet_HashInt |
mul dword [Menuet_hash_int_val0] |
xor eax,edx |
bswap eax |
mul dword [Menuet_hash_int_val1] |
shrd eax,edx,14 |
bswap eax |
lea eax,[eax+4*eax] |
ror eax,9 |
ret |
Menuet_hash_int_val0: |
dd 0xA82F94C5 |
Menuet_hash_int_val1: |
dd 0x9193780B |
enddef |
define @Menuet@GetThreadData$qv |
call @Menuet@GetPid$qv |
push eax |
call @Menuet@GetThreadData$qui |
pop ecx |
ret |
enddef |
define @Menuet@GetThreadData$qui |
mov eax,[esp+4] |
call Menuet_HashInt |
movzx eax,al |
cmp dword [@Menuet@_ThreadScanCount+4],0 |
jnz Menuet_get_thread_data_wait |
Menuet_get_thread_data_nowait: |
lock inc dword [@Menuet@_ThreadScanCount] |
mov eax,dword [@Menuet@_ThreadTable+eax*4] |
mov ecx,[esp+4] |
jmp Menuet_get_thread_data_test |
Menuet_get_thread_data_loop: |
mov eax,dword [eax+MENUET_THREAD_DATA_NEXT*4] |
Menuet_get_thread_data_test: |
test eax,eax |
jz Menuet_get_thread_data_end |
cmp ecx,[eax+MENUET_THREAD_DATA_PID*4] |
jnz Menuet_get_thread_data_loop |
Menuet_get_thread_data_end: |
lock dec dword [@Menuet@_ThreadScanCount] |
ret |
Menuet_get_thread_data_wait: |
push eax |
push ebx |
mov eax,5 |
mov ebx,1 |
Menuet_get_thread_data_wait_loop: |
int 0x40 |
cmp dword [@Menuet@_ThreadScanCount+4],0 |
jz Menuet_get_thread_data_wait_end |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_get_thread_data_wait_loop |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jmp Menuet_get_thread_data_wait_loop |
Menuet_get_thread_data_wait_end: |
pop ebx |
pop eax |
jmp Menuet_get_thread_data_nowait |
enddef |
define @Menuet@_GetSkinHeader$qv |
push ebx |
mov eax,48 |
mov ebx,4 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetScreenSize$qrust1 |
mov eax,14 |
int 0x40 |
mov ecx,[esp+8] |
mov word [ecx],ax |
mov ecx,[esp+4] |
shr eax,16 |
mov word [ecx],ax |
ret |
enddef |
define Menuet_MutexLockNoWait |
pop eax |
xor al,al |
ret |
enddef |
define Menuet_MutexLockWait |
push ebx |
mov eax,5 |
xor ebx,ebx |
Menuet_lock_wait_cycle: |
int 0x40 |
shl byte [ecx],1 |
jz Menuet_lock_wait_cycle |
pop ebx |
mov al,1 |
ret |
enddef |
define Menuet_MutexLockWaitTime |
cmp dword [esp+12],0 |
jng Menuet_MutexLockWait |
push ebx |
push edx |
mov edx,[esp+20] |
mov eax,26 |
mov ebx,9 |
int 0x40 |
add edx,eax |
Menuet_lock_wait_time_cycle: |
mov eax,5 |
xor ebx,ebx |
int 0x40 |
shl byte [ecx],1 |
jnz Menuet_lock_wait_time_ret_true |
mov eax,26 |
mov ebx,9 |
int 0x40 |
cmp eax,edx |
js Menuet_lock_wait_time_cycle |
pop edx |
pop ebx |
pop eax |
xor al,al |
ret |
Menuet_lock_wait_time_ret_true: |
pop edx |
pop ebx |
mov al,1 |
ret |
enddef |
define Menuet_MutexLock |
shl byte [ecx],1 |
jnz Menuet_lock_first |
call eax |
Menuet_lock_first: |
mov al,1 |
ret |
enddef |
define @Menuet@TryLock$qp13Menuet@TMutex |
mov eax,Menuet_MutexLockNoWait |
mov ecx,[esp+4] |
jmp Menuet_MutexLock |
enddef |
define @Menuet@Lock$qp13Menuet@TMutex |
mov eax,Menuet_MutexLockWait |
mov ecx,[esp+4] |
jmp Menuet_MutexLock |
enddef |
define @Menuet@LockTime$qp13Menuet@TMutexi |
mov eax,Menuet_MutexLockWaitTime |
mov ecx,[esp+4] |
jmp Menuet_MutexLock |
enddef |
define @Menuet@UnLock$qp13Menuet@TMutex |
mov ecx,[esp+4] |
shr byte [ecx],1 |
jz Menuet_unlock_pause |
ret |
Menuet_unlock_pause: |
mov byte [ecx],0x40 |
push ebx |
mov eax,5 |
xor ebx,ebx |
int 0x40 |
pop ebx |
ret |
enddef |
define Menuet_MutexLockRec |
shl byte [ecx],1 |
jng Menuet_lock_first |
cmp dword [ecx+4],edx |
jz Menuet_lock_rec_self |
call eax |
Menuet_lock_rec_first: |
mov al,1 |
mov dword [ecx+4],edx |
ret |
Menuet_lock_rec_self: |
mov al,1 |
add dword [ecx],0x100 |
jc Menuet_lock_rec_overflow |
ret |
Menuet_lock_rec_overflow: |
push dword [@Menuet@DebugPrefix] |
call @Menuet@DebugPutString$qpxc |
mov dword [esp],Menuet_try_lock_rec_overflow_string |
call @Menuet@DebugPutString$qpxc |
pop ecx |
jmp @Menuet@Abort$qv |
enddef |
define @Menuet@TryLock$qp16Menuet@TRecMutexui |
mov eax,Menuet_MutexLockNoWait |
mov ecx,[esp+4] |
mov edx,[esp+8] |
jmp Menuet_MutexLockRec |
enddef |
define @Menuet@Lock$qp16Menuet@TRecMutexui |
mov eax,Menuet_MutexLockWait |
mov ecx,[esp+4] |
mov edx,[esp+8] |
jmp Menuet_MutexLockRec |
enddef |
define @Menuet@LockTime$qp16Menuet@TRecMutexiui |
mov eax,Menuet_MutexLockWaitTime |
mov ecx,[esp+4] |
mov edx,[esp+12] |
jmp Menuet_MutexLockRec |
enddef |
define @Menuet@UnLock$qp16Menuet@TRecMutexui |
mov ecx,[esp+4] |
mov edx,[esp+8] |
cmp dword [ecx+4],edx |
jnz Menuet_unlock_rec_notlocked |
sub dword [ecx],0x100 |
jnc Menuet_unlock_rec_end |
add dword [ecx],0x100 |
shl byte [ecx],1 |
shr byte [ecx],2 |
jng Menuet_unlock_rec_pause |
Menuet_unlock_rec_end: |
ret |
Menuet_unlock_rec_pause: |
mov byte [ecx],0x20 |
push ebx |
mov eax,5 |
xor ebx,ebx |
int 0x40 |
pop ebx |
ret |
Menuet_unlock_rec_notlocked: |
push dword [@Menuet@DebugPrefix] |
call @Menuet@DebugPutString$qpxc |
mov dword [esp],Menuet_unlock_rec_notlocked_string |
call @Menuet@DebugPutString$qpxc |
pop ecx |
jmp @Menuet@Abort$qv |
enddef |
define @Menuet@DebugPutChar$qc |
mov cl,byte [esp+4] |
cmp cl,13 |
jz Menuet_debug_put_char_ret |
push ebx |
cmp cl,10 |
jz Menuet_debug_put_char_enter |
Menuet_debug_put_char_after_cmp: |
mov eax,63 |
mov ebx,1 |
int 0x40 |
pop ebx |
Menuet_debug_put_char_ret: |
ret |
Menuet_debug_put_char_enter: |
mov cl,13 |
mov eax,63 |
mov ebx,1 |
int 0x40 |
mov cl,10 |
jmp Menuet_debug_put_char_after_cmp |
enddef |
define @Menuet@DebugPutString$qpxc |
push esi |
push dword 0 |
mov esi,dword [esp+12] |
jmp Menuet_debug_put_string_test |
Menuet_debug_put_string_loop: |
mov dword [esp],eax |
call @Menuet@DebugPutChar$qc |
inc esi |
Menuet_debug_put_string_test: |
xor eax,eax |
or al,[esi] |
test al,al |
jnz Menuet_debug_put_string_loop |
pop ecx |
pop esi |
ret |
enddef |
define @Menuet@GetKey$qv |
mov eax,2 |
int 0x40 |
test al,al |
jnz Menuet_get_key_eof |
movzx eax,ah |
ret |
Menuet_get_key_eof: |
mov eax,-1 |
ret |
enddef |
define @Menuet@GetMouseButton$qv |
push ebx |
mov eax,37 |
mov ebx,2 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetMousePosition$qrst1o |
push ebx |
mov eax,37 |
xor ebx,ebx |
cmp byte [esp+16],0 |
jnz Menuet_get_mouse_pos_absolute |
inc ebx |
Menuet_get_mouse_pos_absolute: |
int 0x40 |
mov ecx,[esp+12] |
mov word [ecx],ax |
mov ecx,[esp+8] |
shr eax,16 |
mov word [ecx],ax |
pop ebx |
ret |
enddef |
define @Menuet@WasThreadCreated$qv |
cmp byte [@Menuet@_ThreadSavedBegProc],0x90 |
setz al |
ret |
enddef |
define @Menuet@CreateThread$qpvuit1 |
push ebx |
mov edx,[esp+16] |
mov ebx,[esp+12] |
test edx,edx |
jnz Menuet_create_thread_after_new |
if defined MenuetHeapAlloc |
cmp ebx,4096 |
jnb Menuet_create_thread_alloc |
mov ebx,STACKSIZE |
Menuet_create_thread_alloc: |
push ebx |
call MenuetHeapAlloc ; Create new dynamic memory of the given size |
pop ecx |
test eax,eax |
jnz Menuet_create_thread_mem_created |
end if |
or eax,-1 |
jmp Menuet_create_thread_end |
Menuet_create_thread_mem_created: |
lea edx,[eax+ebx] |
Menuet_create_thread_after_new: |
neg ebx |
jz Menuet_create_thread_test_first |
add ebx,edx |
Menuet_create_thread_test_first: |
cmp byte [@Menuet@_ThreadSavedBegProc],0x90 |
jnz Menuet_create_thread_init |
Menuet_create_thread_fill_stack: |
lock inc dword [@Menuet@_ThreadNumber] |
and edx,not 3 |
sub edx,12 |
mov ecx,[esp+8] |
mov dword [edx+8],ebx |
mov dword [edx+4],ecx |
mov dword [edx],Menuet_ThreadFinish |
mov eax,51 |
mov ebx,1 |
mov ecx,@Menuet@ThreadMain$qpvt1 |
int 0x40 |
mov ebx,eax |
or bl,15 |
inc ebx |
jnz Menuet_create_thread_end |
lock dec dword [@Menuet@_ThreadNumber] |
if defined MenuetHeapFree |
or ebx,[edx+8] |
jz Menuet_create_thread_end |
push ebx |
call MenuetHeapFree ; Delete the given dynamic memory |
pop ecx |
end if |
Menuet_create_thread_end: |
pop ebx |
ret |
Menuet_create_thread_init: |
push esi |
push edi |
cld |
mov esi,@Menuet@_ThreadSavedBegProc |
mov edi,@Menuet@GetPid$qv |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov edi,@Menuet@GetThreadData$qv |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov eax,0x90909090 |
mov edi,@Menuet@_ThreadSavedBegProc |
stos dword [edi] |
stos dword [edi] |
stos dword [edi] |
stos dword [edi] |
pop edi |
pop esi |
jmp Menuet_create_thread_fill_stack |
enddef |
define @Menuet@_FileAccess$qpv |
push ebx |
mov eax,58 |
mov ebx,[esp+8] |
int 0x40 |
mov ecx,[esp+8] |
mov [ecx],ebx |
pop ebx |
cmp eax,5 |
jz Menuet_file_access_ret_zero |
ret |
Menuet_file_access_ret_zero: |
xor eax,eax |
ret |
enddef |
__pure_error_: |
jmp $ |
define Menuet_abort_string |
db 'Abnormal program termination.',10,0 |
newdef Menuet_try_lock_rec_overflow_string |
db 'Recursive mutex lock count overflow.',10,0 |
newdef Menuet_unlock_rec_notlocked_string |
db 'Recursive mutex unlock error.',10,0 |
enddef |
include "me_lib.inc" |
;/**/ |
/programs/games/checkers/trunk/include/me_heap.h |
---|
0,0 → 1,90 |
#ifndef __MENUET_HEAP_H_INCLUDED_ |
#define __MENUET_HEAP_H_INCLUDED_ |
#include <menuet.h> |
#include <memheap.h> |
// Menuet memory heap interface. |
namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
{ |
void *Alloc(unsigned int size); |
void *ReAlloc(void *mem, unsigned int size); |
void Free(void *mem); |
} |
#ifdef __MENUET__ |
namespace Menuet |
{ |
// Global variables |
MemoryHeap::TFreeSpace _MenuetFreeSpace; |
MemoryHeap::TMemBlock _MenuetMemBlock; |
TMutex _MemHeapMutex = MENUET_MUTEX_INIT; |
// Functions |
void *_HeapInit(void *begin, void *use_end, void *end) |
{ |
MemoryHeap::InitFreeSpace(_MenuetFreeSpace); |
_MenuetMemBlock = MemoryHeap::CreateBlock(begin, end, _MenuetFreeSpace); |
unsigned int use_beg = (unsigned int)MemoryHeap::BlockBegin(_MenuetMemBlock) + |
MemoryHeap::BlockAddSize - MemoryHeap::BlockEndSize; |
unsigned int use_size = (unsigned int)use_end; |
if (use_size <= use_beg) return 0; |
else use_size -= use_beg; |
return MemoryHeap::Alloc(_MenuetFreeSpace, use_size); |
} |
bool _SetUseMemory(unsigned int use_mem); |
int _RecalculateUseMemory(unsigned int use_mem); |
void *Alloc(unsigned int size) |
{ |
if (!size) return 0; |
Lock(&_MemHeapMutex); |
void *res = MemoryHeap::Alloc(_MenuetFreeSpace, size); |
if (!res) |
{ |
unsigned use_mem = (unsigned int)MemoryHeap::BlockEndFor(_MenuetMemBlock, size); |
if (_SetUseMemory(_RecalculateUseMemory(use_mem))) |
{ |
res = MemoryHeap::Alloc(_MenuetFreeSpace, size); |
} |
} |
UnLock(&_MemHeapMutex); |
return res; |
} |
void *ReAlloc(void *mem, unsigned int size) |
{ |
Lock(&_MemHeapMutex); |
void *res = MemoryHeap::ReAlloc(_MenuetFreeSpace, mem, size); |
if (!res && size) |
{ |
unsigned use_mem = (unsigned int)MemoryHeap::BlockEndFor(_MenuetMemBlock, size); |
if (_SetUseMemory(_RecalculateUseMemory(use_mem))) |
{ |
res = MemoryHeap::ReAlloc(_MenuetFreeSpace, mem, size); |
} |
} |
UnLock(&_MemHeapMutex); |
return res; |
} |
void Free(void *mem) |
{ |
Lock(&_MemHeapMutex); |
MemoryHeap::Free(_MenuetFreeSpace, mem); |
UnLock(&_MemHeapMutex); |
} |
void _FreeAndThreadFinish(void *mem, int *exit_proc_now); |
} |
#endif // def __MENUET__ |
#endif // ndef __MENUET_HEAP_H_INCLUDED_ |
/programs/games/checkers/trunk/include/me_heap.inc |
---|
0,0 → 1,284 |
;/*** |
MenuetHeapInit = @@Menuet@_HeapInit$qpvt1t1 |
MenuetHeapAlloc = @@Menuet@Alloc$qui |
MenuetHeapReAlloc = @@Menuet@ReAlloc$qpvui |
MenuetHeapFree = @@Menuet@Free$qpv |
MenuetHeapFreeAndThreadFinish = @Menuet@_FreeAndThreadFinish$qpvpi |
define @Menuet@_SetUseMemory$qui |
push ebx |
mov eax,64 |
mov ebx,1 |
mov ecx,[esp+8] |
int 0x40 |
pop ebx |
test eax,eax |
jnz Menuet_set_use_memory_nomem |
push ecx |
push dword [@Menuet@_MenuetMemBlock] |
call @@MemoryHeap@ResizeBlock$q20MemoryHeap@TMemBlockpv |
add esp,8 |
mov al,1 |
ret |
Menuet_set_use_memory_nomem: |
xor al,al |
ret |
enddef |
define @Menuet@_RecalculateUseMemory$qui |
mov eax,dword [esp+4] |
mov ecx,(U_END + 3) and not 3 |
cmp eax,ecx |
jna Menuet_recalculate_use_memory_min |
push ebx |
sub eax,ecx |
mov ebx,6 |
mul ebx |
dec ebx |
div ebx |
add eax,((U_END + 3) and not 3) + 3 |
and eax,not 3 |
pop ebx |
ret |
Menuet_recalculate_use_memory_min: |
mov eax,ecx |
ret |
enddef |
define @Menuet@_FreeAndThreadFinish$qpvpi |
mov ebx,1 |
mov ecx,[esp+8] |
jmp Menuet_heap_free_tf_wait |
Menuet_heap_free_tf_wait_loop: |
mov eax,5 |
int 0x40 |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_heap_free_tf_wait |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
Menuet_heap_free_tf_wait: |
cmp dword [ecx],0 |
jnz @Menuet@ExitProcess$qv |
lock bts dword [@Menuet@_MemHeapMutex],0 |
jc Menuet_heap_free_tf_wait_loop |
push dword [esp+4] |
push @Menuet@_MenuetFreeSpace |
call @@MemoryHeap@Free$qr21MemoryHeap@TFreeSpacepv |
add esp,8 |
mov byte [@Menuet@_MemHeapMutex],0x40 |
or eax,-1 |
int 0x40 |
enddef |
macro call func |
{ |
if func eq @MemoryHeap@_FirstNotZeroBit$qui |
bsf eax,[esp] |
else if func eq @MemoryHeap@_CopyMemItemArray$quiuiui |
xchg edi,[esp] |
xchg esi,[esp+4] |
mov ecx,[esp+8] |
cld |
sub ecx,esi |
shr ecx,2 |
rep movs dword [edi],[esi] |
xchg edi,[esp] |
xchg esi,[esp+4] |
else |
call func |
end if |
} |
@$bnwa$qui = @@Menuet@Alloc$qui |
@$bnew$qui = @@Menuet@Alloc$qui |
@$bdla$qpv = @@Menuet@Free$qpv |
@$bdele$qpv = @@Menuet@Free$qpv |
define @_vector_new_ldtc_$qpvuiuiuit1uit1 |
.var_2C = -0Ch |
.var_28 = -8 |
.var_24 = -4 |
.arg_0 = 8 |
.arg_4 = 0Ch |
.arg_8 = 10h |
.arg_C = 14h |
.arg_10 = 18h |
push ebp |
mov ebp, esp |
add esp, -0Ch |
push ebx |
push esi |
push edi |
mov edi, [ebp+.arg_10] |
mov esi, [ebp+.arg_C] |
cmp dword [ebp+.arg_0], 0 |
jnz .loc_10070 |
mov edx, [ebp+.arg_4] |
imul edx, [ebp+.arg_8] |
test esi, 10h |
jz @f |
add edx, 4 |
@@: |
push edx |
call @$bnwa$qui |
pop ecx |
mov [ebp+.arg_0], eax |
test eax, eax |
jz .ret |
mov dword [ebp+.var_2C], 1 |
jmp @f |
.loc_10070: |
and dword [ebp+.var_2C], 0 |
@@: |
test esi, 10h |
jz @f |
mov edx, [ebp+.arg_0] |
mov ecx, [ebp+.arg_8] |
mov [edx], ecx |
add dword [ebp+.arg_0], 4 |
@@: |
mov eax, [ebp+.arg_0] |
test edi, edi |
jz .ret |
mov ecx, [ebp+.arg_8] |
mov [ebp+.var_28], ecx |
mov ebx, eax |
jmp .loc_100EF |
.loc_100B0: |
mov eax, esi |
and eax, 7 |
dec eax |
jz .loc_100CB |
dec eax |
jz .loc_100D1 |
dec eax |
jz .loc_100D6 |
dec eax |
dec eax |
jz .loc_100DC |
jmp $ |
.loc_100CB: |
push ebx |
call edi |
pop ecx |
jmp .loc_100EC |
.loc_100D1: |
.loc_100DC: |
push ebx |
call edi |
jmp .loc_100EC |
.loc_100D6: |
mov eax, ebx |
call edi |
.loc_100EC: |
add ebx, [ebp+.arg_4] |
.loc_100EF: |
dec dword [ebp+.var_28] |
jns .loc_100B0 |
mov eax, [ebp+.arg_0] |
.ret: |
pop edi |
pop esi |
pop ebx |
mov esp, ebp |
pop ebp |
ret |
enddef |
define @_vector_delete_ldtc_$qpvuiuiuit1 |
.arg_0 = 8 |
.arg_4 = 0Ch |
.arg_8 = 10h |
.arg_C = 14h |
.arg_10 = 18h |
push ebp |
mov ebp, esp |
push ebx |
push esi |
push edi |
mov edi, [ebp+.arg_C] |
mov esi, edi |
and esi, 10h |
and edi, 8 |
cmp dword [ebp+.arg_0], 0 |
jz .ret |
test esi, esi |
jz @f |
mov ecx, [ebp+.arg_0] |
mov eax, [ecx-4] |
mov [ebp+.arg_8], eax |
@@: |
mov ebx, [ebp+.arg_8] |
dec ebx |
imul ebx, [ebp+.arg_4] |
add ebx, [ebp+.arg_0] |
jmp .loc_100D3 |
.loc_1008B: |
mov eax, [ebp+.arg_C] |
and eax, 7 |
dec eax |
jz .loc_1009E |
dec eax |
jz .loc_100A9 |
dec eax |
jz .loc_100B1 |
dec eax |
dec eax |
jz .loc_100BD |
jmp $ |
.loc_1009E: |
push 2 |
push ebx |
call dword [ebp+.arg_10] |
add esp, 8 |
jmp .loc_100D0 |
.loc_100A9: |
push 2 |
push ebx |
call dword [ebp+.arg_10] |
jmp .loc_100D0 |
.loc_100B1: |
mov edx, 2 |
mov eax, ebx |
call dword [ebp+.arg_10] |
jmp .loc_100D0 |
.loc_100BD: |
push 2 |
push ebx |
call dword [ebp+.arg_10] |
.loc_100D0: |
sub ebx, [ebp+.arg_4] |
.loc_100D3: |
dec dword [ebp+.arg_8] |
jns .loc_1008B |
test esi, esi |
jz @f |
sub dword [ebp+.arg_0], 4 |
@@: |
test edi, edi |
jz @f |
push dword [ebp+.arg_0] |
call @$bdla$qpv |
pop ecx |
jmp .ret |
@@: |
mov eax, [ebp+.arg_0] |
jmp .reteax |
.ret: |
xor eax, eax |
.reteax: |
pop edi |
pop esi |
pop ebx |
mov esp, ebp |
pop ebp |
ret |
enddef |
;/**/ |
/programs/games/checkers/trunk/include/me_lib.h |
---|
0,0 → 1,16 |
#ifndef __MENUET_LIB_H_INCLUDED_ |
#define __MENUET_LIB_H_INCLUDED_ |
// Menuet interface. |
namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
{ |
unsigned int StrLen(const char *str); |
char *StrCopy(char *dest, const char *src); |
void *MemCopy(void *dest, const void *src, unsigned int n); |
void *MemSet(void *s, char c, unsigned int n); |
double Floor(double x); |
} |
#endif // __MENUET_LIB_H_INCLUDED_ |
/programs/games/checkers/trunk/include/me_lib.inc |
---|
0,0 → 1,118 |
define @Menuet@StrLen$qpxc |
push edi |
cld |
mov edi,[esp+8] |
mov ecx,-1 |
xor al,al |
repnz scas byte [edi] |
not ecx |
lea eax,[ecx-1] |
pop edi |
ret |
enddef |
define @Menuet@StrCopy$qpcpxc |
push esi |
push edi |
cld |
mov edi,[esp+16] |
mov ecx,-1 |
mov esi,edi |
xor al,al |
repnz scas byte [edi] |
not ecx |
mov edi,[esp+12] |
mov edx,ecx |
mov eax,edi |
shr ecx,2 |
rep movs dword [edi],[esi] |
mov ecx,edx |
and ecx,3 |
rep movs byte [edi],[esi] |
pop edi |
pop esi |
ret |
enddef |
define @Menuet@MemCopy$qpvpxvui |
push esi |
push edi |
cld |
mov edi,[esp+12] |
mov eax,edi |
mov ecx,[esp+20] |
mov esi,[esp+16] |
mov edx,ecx |
shr ecx,2 |
rep movs dword [edi],[esi] |
mov ecx,edx |
and ecx,3 |
rep movs byte [edi],[esi] |
pop edi |
pop esi |
ret |
enddef |
define @Menuet@MemSet$qpvcui |
push edi |
cld |
mov edi,[esp+8] |
mov al,[esp+12] |
mov ah,al |
mov dx,ax |
shl eax,16 |
mov ax,dx |
mov ecx,[esp+16] |
mov edx,ecx |
shr ecx,2 |
rep stos dword [edi] |
mov ecx,edx |
and ecx,3 |
rep stos byte [edi] |
pop edi |
mov eax,[esp+4] |
ret |
enddef |
define __ftol |
sub esp,12 |
wait |
fstcw word [esp+8] |
wait |
mov al,[esp+9] |
or byte [esp+9],0x0c |
fldcw word [esp+8] |
fistp qword [esp] |
mov [esp+9],al |
fldcw word [esp+8] |
mov eax,[esp] |
mov edx,[esp+4] |
add esp,12 |
ret |
enddef |
define @Menuet@Floor$qd |
fld qword [esp+4] |
mov ax,[esp+10] |
shl ax,1 |
cmp ax,0x8680 |
ja Menuet_floor_end |
mov ch,4 |
sub esp,2 |
wait |
fstcw word [esp] |
mov ax,0xf3ff |
wait |
mov dx,[esp] |
and ax,dx |
or ah,ch |
mov [esp],ax |
fldcw word [esp] |
frndint |
mov [esp],dx |
fldcw word [esp] |
add esp,2 |
Menuet_floor_end: |
ret |
enddef |
/programs/games/checkers/trunk/include/me_start.inc |
---|
0,0 → 1,90 |
use32 |
org 0x0 |
db 'MENUET01' |
dd 0x1 |
dd MenuetEntryPoint |
dd I_END |
dd U_END+STACKSIZE+HEAPSIZE |
dd U_END+STACKSIZE |
dd 0x0,0x0 |
ptr equ |
offset equ |
short equ |
tbyte equ tword |
PTR equ |
OFFSET equ |
SHORT equ |
TBYTE equ TWORD |
macro movsb a,b |
{ |
if a eq & b eq |
movsb |
else |
movsx a,b |
end if |
} |
macro movsw a,b |
{ |
if a eq & b eq |
movsw |
else |
movsx a,b |
end if |
} |
macro segment name {} |
macro endseg name {} |
macro usedef [link] |
{ |
common |
if ~link eq |
virtual at 0 |
forward |
dd link |
common |
end virtual |
end if |
} |
macro define x,[link] |
{ |
common |
if x eq |
else if used x |
x: |
usedef link |
} |
macro enddef [link] |
{ |
common |
usedef link |
end if |
} |
macro newdef x,[link] |
{ |
common |
end if |
if x eq |
else if used x |
x: |
usedef link |
} |
macro nextdef x,[link] |
{ |
common |
usedef x |
end if |
if x eq |
else if used x |
x: |
usedef link |
} |
/programs/games/checkers/trunk/include/memheap.h |
---|
0,0 → 1,626 |
#ifndef __MEMORY_HEAP_RBTREE_H_INCLUDED_ |
#define __MEMORY_HEAP_RBTREE_H_INCLUDED_ |
namespace MemoryHeap |
{ |
typedef unsigned int TMemItem; |
enum {NumTreeSmall = 8 * sizeof(TMemItem)}; |
// Memory heap interface. |
struct TFreeSpace |
{ |
TMemItem Small[NumTreeSmall], Min, SmallMask; |
}; |
struct TMemBlock |
{ |
TMemItem *Begin; |
}; |
bool BlockValid(const TMemBlock &block); // Is the given memory block valid? |
void *BlockBegin(const TMemBlock &block); // Return the beginning address of the block. |
void *BlockEnd(const TMemBlock &block); // Return the ending address of the block. |
TFreeSpace &BlockFreeSpace(const TMemBlock &block); // Return the free space of the block. |
void InitFreeSpace(TFreeSpace &fs); // Initialize the free space. |
TMemBlock NullBlock(); // Return null invalid block. |
TMemBlock CreateBlock(void *begin, void *end, TFreeSpace &fs); |
// Create a memory block with the given begin and end and add free space of it to (fs), |
//_ give (BlockAddSize) bytes of the block for it's data. |
//_ (Program can alloc (end - begin - BlockAddSize) bytes after it, |
//_ that must be not less than (MemMinSize) ). |
TMemBlock CreateBlock(void *begin, void *end); |
// Create a memory block with the given begin and end and new free space for it, |
//_ give (BlockAddSizeFS) bytes of the block for it's data. |
//_ (Program can alloc (end - begin - BlockAddSizeFS) bytes after it, |
//_ that must be not less than (MemMinSize) ). |
void ResizeBlock(TMemBlock block, void *new_end); // Resize the memory block to the given new end. |
void RemoveBlock(TMemBlock block); // Remove the given memory block. |
void *BlockEndFor(TMemBlock block, unsigned int size); |
// Return the new end of the block needed for (ResizeBlock) to alloc the given size of memory. |
unsigned int BlockSize(TMemBlock block); // Return the size of the given block. |
unsigned int MemSize(void *mem); // Return the size of the allocced memory. |
void *Alloc(TFreeSpace &fs, unsigned int size); |
// Alloc a memory in the given free space, give (MemAddSize) bytes for it's data. |
void *ReAlloc(TFreeSpace &fs, unsigned int size, void *mem); |
// ReAlloc the given memory, it must lie in the block with the given free space. |
void Free(TFreeSpace &fs, void *mem); |
// Free the given memory, it must lie in the block with the given free space. |
// Macro definitions. |
#define MEMORY_HEAP_ALIGN_DOWN(s) (MemoryHeap::TMemItem(s) & ~(MemoryHeap::MemAlign - 1)) |
#define MEMORY_HEAP_ALIGN_UP(s) ((MemoryHeap::TMemItem(s) + (MemoryHeap::MemAlign - 1)) & ~(MemoryHeap::MemAlign - 1)) |
#define MEMORY_HEAP_ITEM(s,k) ( ((MemoryHeap::TMemItem*)(s))[(k)] ) |
#define MEMORY_HEAP_NEXT(s) (MEMORY_HEAP_ITEM((s),-1)) |
#define MEMORY_HEAP_PREV(s) (MEMORY_HEAP_ITEM((s),-2)) |
#define MEMORY_HEAP_FREE(s) (MEMORY_HEAP_ITEM((s),-1) & 1) |
// Constants. |
enum {MemAlign = sizeof(TMemItem)}; |
enum {MemAddSize = MEMORY_HEAP_ALIGN_UP(2 * sizeof(TMemItem))}; |
enum {BlockEndSize = MemAddSize}; |
enum {BlockAddSize = MEMORY_HEAP_ALIGN_UP(4 * sizeof(TMemItem)) + BlockEndSize}; |
enum {BlockAddSizeFS = BlockAddSize + BlockEndSize + MEMORY_HEAP_ALIGN_UP(sizeof(TFreeSpace))}; |
enum {MemMinSize = MEMORY_HEAP_ALIGN_UP(2 * sizeof(TMemItem))}; |
// Inline functions. |
inline bool BlockValid(const TMemBlock &block) {return block.Begin != 0;} |
inline void *BlockBegin(const TMemBlock &block) {return (void*)block.Begin;} |
inline void *BlockEnd(const TMemBlock &block) {return block.Begin ? (void*)block.Begin[1] : 0;} |
inline TFreeSpace &BlockFreeSpace(const TMemBlock &block) {return *(TFreeSpace*)block.Begin[0];} |
inline TMemBlock NullBlock() {TMemBlock block; block.Begin = 0; return block;} |
inline void *BlockEndFor(TMemBlock block, unsigned int size) |
{ |
TMemItem last = (TMemItem)block.Begin[1]; |
TMemItem prevlast = MEMORY_HEAP_PREV(last); |
return (void*)( (MEMORY_HEAP_FREE(prevlast) ? prevlast : last) + MemAddSize + |
((size <= MemMinSize) ? MemMinSize : MEMORY_HEAP_ALIGN_UP(size)) ); |
} |
inline unsigned int BlockSize(TMemBlock block) |
{ |
if (!block.Begin) return 0; |
return (unsigned int)(block.Begin[1] - (TMemItem)block.Begin); |
} |
inline unsigned int MemSize(void *mem) |
{ |
if (!mem) return 0; |
TMemItem c = (TMemItem)mem; |
return MEMORY_HEAP_NEXT(c) - c - MemAddSize; |
} |
// Free space item functions. |
TMemItem _FirstNotZeroBit(TMemItem i) |
{ |
TMemItem r = 0; |
while ((i >>= 1) != 0) r++; |
return r; |
} |
void _RBTreeRotate(TMemItem parent, TMemItem item, int side) |
{ |
TMemItem temp = MEMORY_HEAP_ITEM(parent,0); |
MEMORY_HEAP_ITEM(item,0) = temp; |
if (temp) |
{ |
if (MEMORY_HEAP_ITEM(temp,2) == parent) |
{ |
MEMORY_HEAP_ITEM(temp,2) = item; |
} |
else MEMORY_HEAP_ITEM(temp,3) = item; |
} |
temp = MEMORY_HEAP_ITEM(item,side^1); |
if (temp) MEMORY_HEAP_ITEM(temp,0) = parent; |
MEMORY_HEAP_ITEM(parent,side) = temp; |
MEMORY_HEAP_ITEM(parent,0) = item; |
MEMORY_HEAP_ITEM(item,side^1) = parent; |
temp = MEMORY_HEAP_ITEM(parent,1); |
MEMORY_HEAP_ITEM(parent,1) = MEMORY_HEAP_ITEM(item,1); |
MEMORY_HEAP_ITEM(item,1) = temp; |
} |
void InitFreeSpace(TFreeSpace &fs) |
{ |
TMemItem i; |
for (i = 0; i <= NumTreeSmall; i++) fs.Small[i] = 0; |
fs.Min = 0; fs.SmallMask = 0; |
} |
void _FreeAdd(TFreeSpace &fs, TMemItem item) |
{ |
TMemItem size = MEMORY_HEAP_NEXT(item) - item; |
if (size < MemAddSize + MemMinSize + MemAlign * NumTreeSmall) |
{ |
TMemItem s = (size - (MemAddSize + MemMinSize)) / MemAlign; |
TMemItem &addto = fs.Small[s]; |
MEMORY_HEAP_ITEM(item,1) = (TMemItem)(&addto); |
MEMORY_HEAP_ITEM(item,0) = (TMemItem)addto; |
if (addto) MEMORY_HEAP_ITEM(addto,1) = item; |
addto = item; |
fs.SmallMask |= TMemItem(1) << s; |
return; |
} |
TMemItem addto = fs.Min, parent, temp; |
MEMORY_HEAP_ITEM(item,2) = 0; |
MEMORY_HEAP_ITEM(item,3) = 0; |
if (!addto) |
{ |
MEMORY_HEAP_ITEM(item,0) = 0; |
MEMORY_HEAP_ITEM(item,1) = 1; |
fs.Min = item; |
return; |
} |
MEMORY_HEAP_ITEM(item,1) = 0; |
TMemItem side = 2; |
if (MEMORY_HEAP_NEXT(addto) - addto >= size) fs.Min = item; |
else |
{ |
for (;;) |
{ |
parent = MEMORY_HEAP_ITEM(addto,0); |
if (!parent) break; |
if (MEMORY_HEAP_NEXT(parent) - parent < size) addto = parent; |
else break; |
} |
for (;;) |
{ |
if (MEMORY_HEAP_NEXT(addto) - addto < size) |
{ |
temp = MEMORY_HEAP_ITEM(addto,3); |
if (!temp) {side = 3; break;} |
addto = temp; |
} |
else |
{ |
temp = MEMORY_HEAP_ITEM(addto,2); |
if (!temp) break; |
addto = temp; |
} |
} |
} |
MEMORY_HEAP_ITEM(item,0) = addto; |
MEMORY_HEAP_ITEM(addto,side) = item; |
for (;;) |
{ |
if (MEMORY_HEAP_ITEM(addto,1) != 0) return; |
parent = MEMORY_HEAP_ITEM(addto,0); |
temp = MEMORY_HEAP_ITEM(parent,2); |
if (temp == addto) |
{ |
temp = MEMORY_HEAP_ITEM(parent,3); |
side = 2; |
} |
else side = 3; |
if (!temp || MEMORY_HEAP_ITEM(temp,1) != 0) break; |
MEMORY_HEAP_ITEM(addto,1) = 1; |
MEMORY_HEAP_ITEM(temp,1) = 1; |
item = parent; |
addto = MEMORY_HEAP_ITEM(item,0); |
if (!addto) return; |
MEMORY_HEAP_ITEM(item,1) = 0; |
} |
if (MEMORY_HEAP_ITEM(addto,side) != item) |
{ |
temp = MEMORY_HEAP_ITEM(item,side); |
if (temp) MEMORY_HEAP_ITEM(temp,0) = addto; |
MEMORY_HEAP_ITEM(addto,side^1) = temp; |
MEMORY_HEAP_ITEM(addto,0) = item; |
MEMORY_HEAP_ITEM(item,side) = addto; |
MEMORY_HEAP_ITEM(item,0) = parent; |
MEMORY_HEAP_ITEM(parent,side) = item; |
} |
else item = addto; |
_RBTreeRotate(parent, item, side); |
} |
void _FreeDel(TFreeSpace &fs, TMemItem item) |
{ |
TMemItem size = MEMORY_HEAP_NEXT(item) - item; |
if (size < MemAddSize + MemMinSize + MemAlign * NumTreeSmall) |
{ |
TMemItem prev = MEMORY_HEAP_ITEM(item,1); |
TMemItem next = MEMORY_HEAP_ITEM(item,0); |
MEMORY_HEAP_ITEM(prev,0) = next; |
if (next) MEMORY_HEAP_ITEM(next,1) = prev; |
else |
{ |
TMemItem s = (size - (MemAddSize + MemMinSize)) / MemAlign; |
if (!fs.Small[s]) fs.SmallMask &= ~(TMemItem(1) << s); |
} |
return; |
} |
TMemItem parent, temp, second, add; |
TMemItem side = 2; |
temp = MEMORY_HEAP_ITEM(item,3); |
if (temp) |
{ |
for (;;) |
{ |
second = temp; |
temp = MEMORY_HEAP_ITEM(temp,2); |
if (!temp) break; |
} |
if (fs.Min == item) fs.Min = second; |
add = MEMORY_HEAP_ITEM(second,3); |
parent = MEMORY_HEAP_ITEM(second,0); |
if (parent == item) {parent = second; side = 3;} |
else |
{ |
temp = MEMORY_HEAP_ITEM(item,3); |
MEMORY_HEAP_ITEM(second,3) = temp; |
MEMORY_HEAP_ITEM(temp,0) = second; |
} |
temp = MEMORY_HEAP_ITEM(item,2); |
MEMORY_HEAP_ITEM(second,2) = temp; |
if (temp) MEMORY_HEAP_ITEM(temp,0) = second; |
temp = MEMORY_HEAP_ITEM(item,0); |
MEMORY_HEAP_ITEM(second,0) = temp; |
if (temp) |
{ |
if (MEMORY_HEAP_ITEM(temp,2) == item) |
{ |
MEMORY_HEAP_ITEM(temp,2) = second; |
} |
else MEMORY_HEAP_ITEM(temp,3) = second; |
} |
MEMORY_HEAP_ITEM(parent,side) = add; |
if (add) MEMORY_HEAP_ITEM(add,0) = parent; |
bool color = MEMORY_HEAP_ITEM(second,1); |
MEMORY_HEAP_ITEM(second,1) = MEMORY_HEAP_ITEM(item,1); |
if (!color) return; |
} |
else |
{ |
if (fs.Min == item) fs.Min = MEMORY_HEAP_ITEM(item,0); |
add = MEMORY_HEAP_ITEM(item,2); |
parent = MEMORY_HEAP_ITEM(item,0); |
if (add) MEMORY_HEAP_ITEM(add,0) = parent; |
if (parent) |
{ |
if (MEMORY_HEAP_ITEM(parent,2) == item) |
{ |
MEMORY_HEAP_ITEM(parent,2) = add; |
} |
else |
{ |
MEMORY_HEAP_ITEM(parent,3) = add; |
side = 3; |
} |
} |
else |
{ |
if (add) MEMORY_HEAP_ITEM(add,1) = 1; |
return; |
} |
if (!MEMORY_HEAP_ITEM(item,1)) return; |
} |
if (add && !MEMORY_HEAP_ITEM(add,1)) |
{ |
MEMORY_HEAP_ITEM(add,1) = 1; |
return; |
} |
for (;;) |
{ |
second = MEMORY_HEAP_ITEM(parent,side^1); |
if (!MEMORY_HEAP_ITEM(second,1)) |
{ |
_RBTreeRotate(parent, second, side^1); |
second = MEMORY_HEAP_ITEM(parent,side^1); |
} |
temp = MEMORY_HEAP_ITEM(second,side^1); |
if (temp && !MEMORY_HEAP_ITEM(temp,1)) |
{ |
MEMORY_HEAP_ITEM(temp,1) = 1; |
break; |
} |
temp = MEMORY_HEAP_ITEM(second,side); |
if (temp && !MEMORY_HEAP_ITEM(temp,1)) |
{ |
_RBTreeRotate(second, temp, side); |
MEMORY_HEAP_ITEM(second,1) = 1; |
second = temp; |
break; |
} |
MEMORY_HEAP_ITEM(second,1) = 0; |
if (!MEMORY_HEAP_ITEM(parent,1)) |
{ |
MEMORY_HEAP_ITEM(parent,1) = 1; |
return; |
} |
second = parent; |
parent = MEMORY_HEAP_ITEM(second,0); |
if (!parent) return; |
if (MEMORY_HEAP_ITEM(parent,2) == second) side = 2; |
else side = 3; |
} |
_RBTreeRotate(parent, second, side^1); |
} |
TMemItem _FreeFindAfter(TMemItem item, TMemItem size) |
{ |
if (!item) return 0; |
TMemItem paritem, s; |
if (MEMORY_HEAP_NEXT(item) - item >= size) return item; |
for (;;) |
{ |
paritem = MEMORY_HEAP_ITEM(item,0); |
if (!paritem) break; |
s = MEMORY_HEAP_NEXT(paritem) - paritem; |
if (s == size) return paritem; |
if (s < size) item = paritem; |
else break; |
} |
MEMORY_HEAP_ITEM(item,3); |
for (;;) |
{ |
if (!item) return paritem; |
s = MEMORY_HEAP_NEXT(item) - item; |
if (s == size) return item; |
if (s < size) item = MEMORY_HEAP_ITEM(item,3); |
else |
{ |
paritem = item; |
item = MEMORY_HEAP_ITEM(item,2); |
} |
} |
} |
TMemItem _FreeFind(TFreeSpace &fs, TMemItem size) |
{ |
TMemItem item, nextitem, s; |
if (size < MemAddSize + MemMinSize + MemAlign * NumTreeSmall) |
{ |
TMemItem m, t; |
s = (size - (MemAddSize + MemMinSize)) / MemAlign; |
item = fs.Small[s]; |
if (item) return item; |
if (size < MemAlign * NumTreeSmall) |
{ |
t = size / MemAlign; |
m = fs.SmallMask >> t; |
if (m) return fs.Small[t + _FirstNotZeroBit(m)]; |
else if (fs.Min) return fs.Min; |
} |
else |
{ |
item = _FreeFindAfter(fs.Min, size + 1 + MemAddSize + MemMinSize); |
if (item) return item; |
} |
m = fs.SmallMask >> s; |
if (m) return fs.Small[s + _FirstNotZeroBit(m)]; |
else return fs.Min; |
} |
item = _FreeFindAfter(fs.Min, ++size); |
if (!item) return 0; |
s = MEMORY_HEAP_NEXT(item) - item; |
if (s == size) return item; |
size += MemAddSize + MemMinSize; |
if (s >= size) return item; |
nextitem = _FreeFindAfter(item, size); |
return nextitem ? nextitem : item; |
} |
// Block functions. |
inline void _CreateBlockEnd(TMemBlock &block, TFreeSpace &fs, TMemItem c, TMemItem e) |
{ |
block.Begin[0] = (TMemItem)(&fs); |
if (e - c < TMemItem(MemAddSize + MemMinSize)) |
{ |
MEMORY_HEAP_NEXT(c) = 0; |
block.Begin[1] = c; |
} |
else |
{ |
MEMORY_HEAP_NEXT(c) = e + 1; |
_FreeAdd(fs, c); |
MEMORY_HEAP_PREV(e) = c; |
MEMORY_HEAP_NEXT(e) = 0; |
block.Begin[1] = e; |
} |
} |
TMemBlock CreateBlock(void *begin, void *end, TFreeSpace &fs) |
{ |
TMemBlock block = {0}; |
TMemItem b = MEMORY_HEAP_ALIGN_UP(begin); |
TMemItem e = MEMORY_HEAP_ALIGN_DOWN(end); |
if (e <= b || e - b < TMemItem(BlockAddSize - MemAddSize)) return block; |
block.Begin = (TMemItem*)b; |
b += MEMORY_HEAP_ALIGN_UP(4 * sizeof(TMemItem)); |
MEMORY_HEAP_PREV(b) = 0; |
_CreateBlockEnd(block, fs, b, e); |
return block; |
} |
TMemBlock CreateBlock(void *begin, void *end) |
{ |
TMemBlock block = {0}; |
TMemItem b = MEMORY_HEAP_ALIGN_UP(begin); |
TMemItem e = MEMORY_HEAP_ALIGN_DOWN(end); |
if (e <= b || e - b < TMemItem(BlockAddSizeFS - MemAddSize)) return block; |
block.Begin = (TMemItem*)b; |
b += MEMORY_HEAP_ALIGN_UP(4 * sizeof(TMemItem)); |
TMemItem c = b + MemAddSize + MEMORY_HEAP_ALIGN_UP(sizeof(TFreeSpace)); |
MEMORY_HEAP_PREV(b) = 0; |
MEMORY_HEAP_NEXT(b) = c; |
MEMORY_HEAP_PREV(c) = b; |
InitFreeSpace(*(TFreeSpace*)b); |
_CreateBlockEnd(block, *(TFreeSpace*)b, c, e); |
return block; |
} |
void ResizeBlock(TMemBlock block, void *new_end) |
{ |
if (!BlockValid(block)) return; |
TMemItem e = MEMORY_HEAP_ALIGN_DOWN(new_end); |
TMemItem c = block.Begin[1]; |
TFreeSpace &fs = *(TFreeSpace*)block.Begin[0]; |
do |
{ |
if (c == e) return; |
else if (c > e) |
{ |
while ((c = MEMORY_HEAP_PREV(c)) > e) |
{ |
if (MEMORY_HEAP_FREE(c)) _FreeDel(fs, c); |
} |
if (!c) {block.Begin = 0; return;} |
if (MEMORY_HEAP_FREE(c)) |
{ |
_FreeDel(fs, c); |
if (e - c < TMemItem(MemAddSize + MemMinSize)) e = c; |
else |
{ |
MEMORY_HEAP_NEXT(c) = e + 1; |
_FreeAdd(*(TFreeSpace*)block.Begin[0], c); |
break; |
} |
} |
else if (e - c >= TMemItem(MemAddSize + MemMinSize)) |
{ |
MEMORY_HEAP_NEXT(c) = e; break; |
} |
MEMORY_HEAP_NEXT(c) = 0; |
block.Begin[1] = c; |
if (c == e) return; |
} |
TMemItem pc = MEMORY_HEAP_PREV(c); |
if (pc && MEMORY_HEAP_FREE(pc)) _FreeDel(fs, c = pc); |
else if (e - c < TMemItem(MemAddSize + MemMinSize)) return; |
MEMORY_HEAP_NEXT(c) = e + 1; |
_FreeAdd(fs, c); |
} while(false); |
MEMORY_HEAP_PREV(e) = c; |
MEMORY_HEAP_NEXT(e) = 0; |
block.Begin[1] = e; |
} |
void RemoveBlock(TMemBlock block) |
{ |
if (!BlockValid(block)) return; |
TMemItem e = block.Begin[1]; |
TFreeSpace &fs = *(TFreeSpace*)block.Begin[0]; |
while ((e = MEMORY_HEAP_PREV(e)) != 0) |
{ |
if (MEMORY_HEAP_FREE(e)) _FreeDel(fs, e); |
} |
block.Begin = 0; |
} |
// Free space functions. |
void _CopyMemItemArray(TMemItem dest, TMemItem src, TMemItem end) |
{ |
TMemItem k = (end - src) / sizeof(TMemItem); |
TMemItem *d = (TMemItem*)dest; |
TMemItem *s = (TMemItem*)src; |
while (k--) *(d++) = *(s++); |
} |
void *Alloc(TFreeSpace &fs, unsigned int size) |
{ |
if (!size) return 0; |
TMemItem s = MEMORY_HEAP_ALIGN_UP(size) + MemAddSize; |
if (s < MemAddSize + MemMinSize) s = MemAddSize + MemMinSize; |
TMemItem c = _FreeFind(fs, s); |
if (!c) return 0; |
_FreeDel(fs, c); |
TMemItem nc = --MEMORY_HEAP_NEXT(c); |
TMemItem mc = c + s; |
if (nc - (MemAddSize + MemMinSize) >= mc) |
{ |
MEMORY_HEAP_NEXT(c) = mc; |
MEMORY_HEAP_PREV(mc) = c; |
MEMORY_HEAP_NEXT(mc) = nc + 1; |
MEMORY_HEAP_PREV(nc) = mc; |
_FreeAdd(fs, mc); |
} |
return (void*)c; |
} |
void *ReAlloc(TFreeSpace &fs, void *mem, unsigned int size) |
{ |
if (!mem) return Alloc(fs, size); |
if (!size) {Free(fs, mem); return 0;} |
TMemItem s = MEMORY_HEAP_ALIGN_UP(size) + MemAddSize; |
TMemItem c = (TMemItem)mem; |
TMemItem mc = MEMORY_HEAP_NEXT(c); |
TMemItem nc = MEMORY_HEAP_NEXT(mc); |
if (--nc & 1) nc = mc; |
if (s < MemAddSize + MemMinSize) s = MemAddSize + MemMinSize; |
if (nc - c < s) |
{ |
mem = Alloc(fs, size); |
if (mem) |
{ |
_CopyMemItemArray((TMemItem)mem, c, mc - MemAddSize); |
Free(fs, (void*)c); |
return mem; |
} |
else |
{ |
TMemItem pc = MEMORY_HEAP_PREV(c); |
if (pc && MEMORY_HEAP_FREE(pc) && nc - pc >= s) |
{ |
_FreeDel(fs, pc); |
_CopyMemItemArray(pc, c, mc - MemAddSize); |
c = pc; |
} |
else return 0; |
} |
} |
if (mc < nc) _FreeDel(fs, mc); |
mc = c + s; |
if (nc - (MemAddSize + MemMinSize) >= mc) |
{ |
MEMORY_HEAP_NEXT(c) = mc; |
MEMORY_HEAP_PREV(mc) = c; |
MEMORY_HEAP_NEXT(mc) = nc + 1; |
MEMORY_HEAP_PREV(nc) = mc; |
_FreeAdd(fs, mc); |
} |
else |
{ |
MEMORY_HEAP_NEXT(c) = nc; |
MEMORY_HEAP_PREV(nc) = c; |
} |
return (void*)c; |
} |
int free_a = 0; |
void Free(TFreeSpace &fs, void *mem) |
{ |
TMemItem c = (TMemItem)mem; |
if (!c) return; |
TMemItem pc = MEMORY_HEAP_PREV(c); |
TMemItem mc = MEMORY_HEAP_NEXT(c); |
TMemItem nc = MEMORY_HEAP_NEXT(mc); |
if (--nc & 1) nc = mc; |
else _FreeDel(fs, mc); |
if (free_a == 1) return; |
if (pc && MEMORY_HEAP_FREE(pc)) _FreeDel(fs, c = pc); |
MEMORY_HEAP_NEXT(c) = nc + 1; |
MEMORY_HEAP_PREV(nc) = c; |
if (free_a == 2) return; |
_FreeAdd(fs, c); |
} |
} |
#endif // ndef __MEMORY_HEAP_RBTREE_H_INCLUDED_ |
/programs/games/checkers/trunk/include/menuet.h |
---|
0,0 → 1,536 |
#ifndef __MENUET_H_INCLUDED_ |
#define __MENUET_H_INCLUDED_ |
#include <me_lib.h> |
// Menuet interface. |
namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
{ |
const char *DebugPrefix = "User program: "; |
struct TWindowData // Data for drawing a window. |
{ |
unsigned short WindowType, HeaderType; |
unsigned long WindowColor, HeaderColor, BorderColor, TitleColor; |
const char *Title; |
}; |
struct TStartData // This structure is used only for MenuetOnStart function. |
{ |
unsigned short Left, Width, Top, Height; // Initial window rectangle. |
TWindowData WinData; |
}; |
typedef void **TThreadData; // Thread data are the fast identifier of thread, contains user dword in |
//_ the zero element and stack beginning (or zero if it is unknown) in the first element. |
//_ The stack will be deleted from dynamic memory at the finish of the thread if stack beginning is not zero. |
struct TMutex; // Simple mutex can be locked only once at a time. |
#define MENUET_MUTEX_INIT {} // Simple mutex initializer, cat be redefined in a realization of the library |
struct TRecMutex; // Recursive mutex can be locked many times by a single thread at a time. |
#define MENUET_REC_MUTEX_INIT {} // Recursive mutex initializer, cat be redefined in a realization of the library |
// Some functions have two forms: the fast form with (thread_data) parameter and the form without it. |
// Note: pass only thread data of current thread as (thread_data) parameter to these functions. |
void Main(); // Main function is called at program startup. |
void* ThreadMain(void *user = 0, void *stack_begin = 0); |
// Called at thread startup, (user) is placed in thread data as a user dword, |
//_ (stack_begin) is placed in thread data as a stack beginning. |
//_ Return new value of stack beginning that can be changed in the thread data. |
void GetWindowData(TWindowData &win_data); // Write current window data to (win_data). |
void GetWindowData(TWindowData &win_data, TThreadData thread_data); |
void SetWindowData(const TWindowData &win_data); // Replace current window data by (win_data). |
void SetWindowData(const TWindowData &win_data, TThreadData thread_data); |
void CloseWindow(); // Close current window when returning to message loop. |
void CloseWindow(TThreadData thread_data); |
void Redraw(int frame = 0); // Redraw current window immediately, if (frame) is positive redraw the frame too, |
void Redraw(int frame, TThreadData thread_data); //_ if (frame) is negative redraw only invalideted window. |
void Invalidate(int frame = 0); // Redraw current window when no message will be is the queue, |
void Invalidate(int frame, TThreadData thread_data); //_ if (frame) is positive redraw the frame too, |
//_ if (frame) is negative do nothing. |
void MoveWindow(const int window_rect[/* 4 */]); // Move and resize current window. |
void Abort(); // Abnormally terminate a program. |
void ExitProcess(); // Exit from the process, don't call any destructors of global varyables |
void ExitThread(); // Exit from the current thread |
void ExitThread(TThreadData thread_data); |
void ReturnMessageLoop(); // Return to the message loop of the thread. Exit from the thread |
void ReturnMessageLoop(TThreadData thread_data); //_ if it is called from (MenuetOnStart). |
void Delay(unsigned int time); // Delay the execution of the program during (time) hundredth seconds. |
unsigned int Clock(); // Return the time from starting of the system to this moment in hundredth of seconds. |
int GetPackedTime(); // Return the current time of day in binary-decimal format 0x00SSMMHH. |
void GetTime(int t[/* 3 */]); // Write the current time to (t): t[0] = second, t[1] = minute, t[2] = hour. |
int GetPackedDate(); // Return the current date in binary-decimal format 0x00YYDDMM. |
void GetDate(int d[/* 3 */]); // Write the current date to (d): d[0] = day, d[1] = month, d[2] = year. |
void GetTimeDate(int t[/* 6 */]); // Write the current time and date to (t): t[0] = second, |
//_ t[1] = minute, t[2] = hour, t[3] = day, t[4] = month, t[5] = year. |
void ReadCommonColors(unsigned int colors[/* 10 */]); // Writes standart window colors to (colors). |
unsigned int GetProcessInfo(unsigned int *use_cpu, char process_name[/* 13 */], unsigned int *use_memory, |
unsigned int *pid, int window_rect[/* 4 */], unsigned int pid_for = -1); |
// Write (pid_for) process information to variables parameters points, return |
//_ the number of processes. (pid_for) equal to (-1) means current process. |
unsigned int GetPid(); // Return the current thread identifier (pid). |
unsigned int GetPid(TThreadData thread_data); |
TThreadData GetThreadData(); // Return the thread data of the current thread. |
TThreadData GetThreadData(unsigned int pid); // Return the thread data of the thread with the given pid. |
void* GetPicture(unsigned short &width, unsigned short &height); |
void* GetPicture(unsigned short &width, unsigned short &height, TThreadData thread_data); |
// Return the picture on the window and write its width and height to (width) and (height). |
void SetPicture(void *picture, unsigned short width, unsigned short height); |
void SetPicture(void *picture, unsigned short width, unsigned short height, TThreadData thread_data); |
// Replace the picture on the window by the given picture with the given width and height. |
void GetBorderHeader(unsigned short &border_size, unsigned short &header_size); |
void GetBorderHeader(unsigned short &border_size, unsigned short &header_size, TThreadData thread_data); |
// Write the border thickness to (border_size) and header height to (header_size). |
void GetClientSize(unsigned short &width, unsigned short &height); |
void GetClientSize(unsigned short &width, unsigned short &height, TThreadData thread_data); |
// Write the client area width and height to (width) and (height) parameters. |
void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height); |
void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height, TThreadData thread_data); |
// Write the client area size of window with the width (win_width) |
//_ and height (win_height) to (width) and (height) parameters. |
void GetScreenSize(unsigned short &width, unsigned short &height); |
// Write the screen width and height to (width) and (height) parameters. |
void InitMutex(TMutex *mutex); // Initialize the simple mutex. |
void InitRecMutex(TRecMutex *mutex); // Initialize the recursive mutex. |
bool TryLock(TMutex *mutex); // Try to lock the mutex without waitting, return true if lock. |
bool TryLock(TRecMutex *mutex); |
bool TryLock(TRecMutex *mutex, TThreadData thread_data); |
bool TryLock(TRecMutex *mutex, unsigned int pid); |
void Lock(TMutex *mutex); // Lock mutex and wait for it if this necessary. |
void Lock(TRecMutex *mutex); |
void Lock(TRecMutex *mutex, TThreadData thread_data); |
void Lock(TRecMutex *mutex, unsigned int pid); |
bool LockTime(TMutex *mutex, int time); |
bool LockTime(TRecMutex *mutex, int time); // Lock mutex and wait for it during (time) hundredth seconds. |
bool LockTime(TRecMutex *mutex, int time, TThreadData thread_data); |
bool LockTime(TRecMutex *mutex, int time, unsigned int pid); |
void UnLock(TMutex *mutex); // Unlock mutex |
void UnLock(TRecMutex *mutex); |
void UnLock(TRecMutex *mutex, TThreadData thread_data); |
void UnLock(TRecMutex *mutex, unsigned int pid); |
void DebugPutChar(char c); // Put the character to the debug board. |
void DebugPutString(const char *s); // Put the string to the debug board. |
int GetKey(); // Return key pressed by user or -1 if no key was pressed. |
int GetMouseButton(); // Return buttons pressed: 0 - no buttons, 1 - left button, 2 - right button, 3 - both buttons. |
void GetMousePosition(short &x, short &y, bool absolute = false); |
// Write mouse position to (x) and (y): absolute if (absolute) is true and relative the window otherwise. |
void GetMousePosPicture(short &x, short &y); |
int GetThreadNumber(); // Return the number of threads currently executing. |
bool WasThreadCreated(); // Return true if there was created at least one thread except the main thred. |
unsigned int CreateThread(void *user = 0, unsigned int stack_size = 0, void *stack_end = 0); |
// Create a new thread with the user dword (user) and stack pointer (stack_end). |
//_ If (stack_end) is zero, create stack in dynamic memory of size (stack_size) or |
//_ the same size as the main thread if (stack_size) less that 4096. Set the beginning |
//_ of the stack if (stack_end) is zero or (stack_size) is not zero, in this case stack |
//_ will be deleted automaticaly from dynamic memory at the finish of the thread. |
} |
// Function, defined outside. |
bool MenuetOnStart(Menuet::TStartData &me_start, Menuet::TThreadData thread_data); |
// Window will be created iff return value is true. |
bool MenuetOnClose(Menuet::TThreadData thread_data); // Window will be closed iff return value is true. |
int MenuetOnIdle(Menuet::TThreadData thread_data); // Return the time to wait next message. |
void MenuetOnSize(int window_rect[/* 4 */], Menuet::TThreadData thread_data); // When the window is resized. |
void MenuetOnKeyPress(Menuet::TThreadData thread_data); // When user press a key. |
void MenuetOnMouse(Menuet::TThreadData thread_data); // When user move a mouse. |
#ifdef __MENUET__ |
namespace Menuet |
{ |
// Structures. |
struct TMutex // Simple mutex can be locked only once at a time. |
{ |
unsigned int mut; |
}; |
#undef MENUET_MUTEX_INIT |
#define MENUET_MUTEX_INIT {0x40} // Simple mutex initializer, cat be redefined in a realization of the library |
struct TRecMutex // Recursive mutex can be locked many times by a single thread at a time. |
{ |
unsigned int mut, pid; |
}; |
#undef MENUET_REC_MUTEX_INIT |
#define MENUET_REC_MUTEX_INIT {0x20,-1} // Recursive mutex initializer, cat be redefined in a realization of the library |
// Global variables. |
volatile TThreadData _ThreadTable[256]; |
volatile unsigned int _ThreadScanCount[2] = {0, 0}; |
volatile int _ThreadNumber = 1; |
volatile int _ExitProcessNow = 0; |
TMutex _ThreadMutex = MENUET_MUTEX_INIT; |
unsigned int _ThreadSavedBegProc[4]; |
// Inline functions. |
inline void GetWindowData(TWindowData &win_data) {GetWindowData(win_data, GetThreadData());} |
inline void SetWindowData(const TWindowData &win_data) {SetWindowData(win_data, GetThreadData());} |
inline void CloseWindow() {CloseWindow(GetThreadData());} |
inline void Redraw(int frame) {Redraw(frame, GetThreadData());} |
inline void Invalidate(int frame) {Invalidate(frame, GetThreadData());} |
inline void* GetPicture(unsigned short &width, unsigned short &height) |
{ |
return GetPicture(width, height, GetThreadData()); |
} |
inline void SetPicture(void *picture, unsigned short width, unsigned short height) |
{ |
SetPicture(picture, width, height, GetThreadData()); |
} |
inline void GetBorderHeader(unsigned short &border_size, unsigned short &header_size) |
{ |
GetBorderHeader(border_size, header_size, GetThreadData()); |
} |
inline void GetClientSize(unsigned short &width, unsigned short &height) |
{ |
unsigned int pid; |
int rect[4]; |
GetProcessInfo(0, 0, 0, &pid, rect); |
GetClientSize(width, height, rect[2], rect[3], GetThreadData(pid)); |
} |
inline void GetClientSize(unsigned short &width, unsigned short &height, TThreadData thread_data) |
{ |
int rect[4]; |
GetProcessInfo(0, 0, 0, 0, rect); |
GetClientSize(width, height, rect[2], rect[3], thread_data); |
} |
inline void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height) |
{ |
GetClientSize(width, height, win_width, win_height, GetThreadData()); |
} |
inline void GetTimeDate(int t[/* 6 */]) {GetTime(t); GetDate(t + 3);} |
inline void InitMutex(TMutex *mutex) {mutex->mut = 0;} |
inline void InitRecMutex(TRecMutex *mutex) {mutex->mut = 0; mutex->pid = -1;} |
inline bool TryLock(TRecMutex *mutex) {return TryLock(mutex, GetPid());} |
inline bool TryLock(TRecMutex *mutex, TThreadData thread_data) {return TryLock(mutex, GetPid(thread_data));} |
inline void Lock(TRecMutex *mutex) {Lock(mutex, GetPid());} |
inline void Lock(TRecMutex *mutex, TThreadData thread_data) {Lock(mutex, GetPid(thread_data));} |
inline bool LockTime(TRecMutex *mutex, int time) {return LockTime(mutex, time, GetPid());} |
inline bool LockTime(TRecMutex *mutex, int time, TThreadData thread_data) |
{return LockTime(mutex, time, GetPid(thread_data));} |
inline void UnLock(TRecMutex *mutex) {UnLock(mutex, GetPid());} |
inline void UnLock(TRecMutex *mutex, TThreadData thread_data) {UnLock(mutex, GetPid(thread_data));} |
inline int GetThreadNumber() {return _ThreadNumber;} |
// Constants from fasm. |
#include <me_func.inc> |
// Functions. |
unsigned char _HashByte(unsigned int value); |
unsigned short _HashWord(unsigned int value); |
unsigned int _HashDword(unsigned int value); |
void _GetStartData(TStartData &start_data, TThreadData thread_data) |
{ |
start_data.Left = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_X] >> 16); |
start_data.Width = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_X]); |
start_data.Top = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_Y] >> 16); |
start_data.Height = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_Y]); |
GetWindowData(start_data.WinData, thread_data); |
} |
void _SetStartData(const TStartData &start_data, TThreadData thread_data) |
{ |
(unsigned long&)thread_data[MENUET_THREAD_DATA_X] = |
((unsigned int)start_data.Left << 16) | start_data.Width; |
(unsigned long&)thread_data[MENUET_THREAD_DATA_Y] = |
((unsigned int)start_data.Top << 16) | start_data.Height; |
SetWindowData(start_data.WinData, thread_data); |
} |
void _ApplyCommonColors(TWindowData &win_data) |
{ |
unsigned int colors[10]; |
ReadCommonColors(colors); |
win_data.WindowColor = colors[5]; |
win_data.HeaderColor = colors[1]; |
win_data.BorderColor = colors[0]; |
win_data.TitleColor = colors[4]; |
} |
void _SetValueFunctionPriority(void *beg, int n) |
{ |
int k, i; |
unsigned char num[256]; |
for (i = 0; i < 256; i++) num[i] = 0; |
for (k = 0; k < n; k++) |
{ |
i = ((unsigned char*)beg + 6*k)[1]; |
((unsigned char*)beg + 6*k)[0] = num[i]; |
if (num[i] != 255) num[i]++; |
} |
} |
void _CallFunctionPriority(void *beg, void *end, bool reverse = false) |
{ |
struct _Local |
{ |
static int cmp(void *beg, int i, int j) |
{ |
unsigned char *x = (unsigned char*)beg + 6*i; |
unsigned char *y = (unsigned char*)beg + 6*j; |
if (*(unsigned short*)x < *(unsigned short*)y) return -1; |
if (*(unsigned short*)x > *(unsigned short*)y) return 1; |
return 0; |
} |
static void swap(void *beg, int i, int j) |
{ |
unsigned char *x = (unsigned char*)beg + 6*i; |
unsigned char *y = (unsigned char*)beg + 6*j; |
short s; |
int t; |
s = *(short*)x; *(short*)x = *(short*)y; *(short*)y = s; |
x += 2; y += 2; |
t = *(int*)x; *(int*)x = *(int*)y; *(int*)y = t; |
} |
static void call(void *beg, int i) |
{ |
unsigned char *x = (unsigned char*)beg + 6*i; |
(*(void(**)())(x+2))(); |
} |
}; |
if (!beg || !end || end <= beg) return; |
int i, j, k, m, n; |
n = ((unsigned char*)end - (unsigned char*)beg) / 6; |
if (n <= 0) return; |
_SetValueFunctionPriority(beg, n); |
m = n; k = n; |
while (m > 1) |
{ |
if (k > 0) k--; |
else _Local::swap(beg, 0, --m); |
j = k; |
for (;;) |
{ |
i = j; |
if (2*i + 1 >= m) break; |
if (_Local::cmp(beg, 2*i + 1, j) > 0) j = 2*i + 1; |
if (2*i + 2 < m && _Local::cmp(beg, 2*i + 2, j) > 0) j = 2*i + 2; |
if (i == j) break; |
_Local::swap(beg, i, j); |
} |
} |
if (!reverse) |
{ |
for (k = 0; k < n; k++) _Local::call(beg, k); |
} |
else |
{ |
for (k = n-1; k >= 0; k--) _Local::call(beg, k); |
} |
} |
bool _CallStart(TThreadData thread_data, void *init = 0, void *init_end = 0) |
{ |
struct _TThreadDataTemplate |
{ |
unsigned int data[12]; |
}; |
static const _TThreadDataTemplate _ThreadDataTemplate = |
{{3, 0x00320100, 0x00320100, 0x33FFFFFF, 0x806060FF, 0x00000000, 0x00FFFF40, 0, 0, 0, -1, -1}}; |
unsigned int pid = GetPid(); |
volatile TThreadData *thread_table_item; |
Lock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
thread_table_item = &_ThreadTable[_HashByte(pid)]; |
thread_data[MENUET_THREAD_DATA_NEXT] = (void*)*thread_table_item; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_PID] = pid; |
*(_TThreadDataTemplate*)(thread_data + MENUET_THREAD_DATA_FLAG) = _ThreadDataTemplate; |
*thread_table_item = thread_data; |
UnLock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
_CallFunctionPriority(init, init_end, false); |
TStartData start_data; |
_GetStartData(start_data, thread_data); |
// _ApplyCommonColors(start_data.WinData); |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= 0x40000000; |
thread_data[MENUET_THREAD_DATA_TITLE] = (void*)(&start_data); |
if (!MenuetOnStart(start_data, thread_data)) return false; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] &= ~0x40000000; |
_SetStartData(start_data, thread_data); |
return true; |
} |
void _RemoveThreadData(TThreadData thread_data, void *exit = 0, void *exit_end = 0) |
{ |
_CallFunctionPriority(exit, exit_end, true); |
volatile TThreadData *thread_table_item; |
Lock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
thread_table_item = &_ThreadTable[_HashByte(GetPid(thread_data))]; |
while (*thread_table_item) |
{ |
if (*thread_table_item == thread_data) |
{ |
*thread_table_item = (TThreadData)thread_data[MENUET_THREAD_DATA_NEXT]; |
break; |
} |
thread_table_item = (TThreadData*)(*thread_table_item + MENUET_THREAD_DATA_NEXT); |
} |
UnLock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
} |
void GetWindowData(TWindowData &win_data, TThreadData thread_data) |
{ |
if ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) |
{ |
win_data = ((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData; |
return; |
} |
win_data.WindowType = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] >> 24); |
win_data.HeaderType = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_C_HEADER] >> 24); |
win_data.WindowColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] & 0xFFFFFF; |
win_data.HeaderColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_HEADER] & 0xFFFFFF; |
win_data.BorderColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_BORDER] & 0xFFFFFF; |
win_data.TitleColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_TITLE] & 0xFFFFFF; |
win_data.Title = (char*)thread_data[MENUET_THREAD_DATA_TITLE]; |
} |
void SetWindowData(const TWindowData &win_data, TThreadData thread_data) |
{ |
if ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) |
{ |
((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData = win_data; |
return; |
} |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_WINDOW] = |
((unsigned int)win_data.WindowType << 24) | (win_data.WindowColor & 0xFFFFFF); |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_HEADER] = |
((unsigned int)win_data.HeaderType << 24) | (win_data.HeaderColor & 0xFFFFFF); |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_BORDER] = win_data.BorderColor & 0xFFFFFF; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_TITLE] = win_data.TitleColor & 0xFFFFFF; |
thread_data[MENUET_THREAD_DATA_TITLE] = (void*)win_data.Title; |
Invalidate(1, thread_data); |
} |
void CloseWindow(TThreadData thread_data) |
{ |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= 0x80000000; |
} |
void Invalidate(int frame, TThreadData thread_data) |
{ |
if (frame < 0) return; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= (frame ? 3 : 1); |
} |
void* GetPicture(unsigned short &width, unsigned short &height, TThreadData thread_data) |
{ |
width = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_SZ_PICT] >> 16); |
height = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_SZ_PICT]); |
return (void*)thread_data[MENUET_THREAD_DATA_PICTURE]; |
} |
void SetPicture(void *picture, unsigned short width, unsigned short height, TThreadData thread_data) |
{ |
thread_data[MENUET_THREAD_DATA_PICTURE] = (void*)picture; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_SZ_PICT] = |
(width == 0 || height == 0) ? 0 : (((unsigned int)width << 16) | height); |
Invalidate(0, thread_data); |
} |
int _GetSkinHeader(); |
void GetBorderHeader(unsigned short &border_size, unsigned short &header_size, TThreadData thread_data) |
{ |
int win_type = ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) ? |
((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData.WindowType : |
((unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] >> 24); |
border_size = MENUET_BORDER_SIZE; |
header_size = short(((win_type & 15) == 3) ? _GetSkinHeader() : MENUET_HEADER_SIZE); |
} |
void GetClientSize(unsigned short &width, unsigned short &height, |
int win_width, int win_height, TThreadData thread_data) |
{ |
const int MAX_SIZE = 32767; |
unsigned short border_size, header_size; |
GetBorderHeader(border_size, header_size, thread_data); |
win_width -= 2 * border_size; |
win_height -= border_size + header_size; |
if (win_width < 0) win_width = 0; |
else if (win_width > MAX_SIZE) win_width = MAX_SIZE; |
if (win_height < 0) win_height = 0; |
else if (win_height > MAX_SIZE) win_height = MAX_SIZE; |
width = (unsigned short)win_width; |
height = (unsigned short)win_height; |
} |
void GetMousePosPicture(short &x, short &y) |
{ |
unsigned short dx, dy; |
GetMousePosition(x, y); |
GetBorderHeader(dx, dy); |
x -= dx; y -= dy; |
} |
} |
#else // def __MENUET__ |
namespace Menuet |
{ |
struct TMutex |
{ |
unsigned int mut; |
TMutex(); |
~TMutex(); |
}; |
#undef MENUET_MUTEX_INIT |
#define MENUET_MUTEX_INIT TMutex() |
struct TRecMutex |
{ |
unsigned int mut; |
TRecMutex(); |
~TRecMutex(); |
}; |
#undef MENUET_REC_MUTEX_INIT |
#define MENUET_REC_MUTEX_INIT TRecMutex() |
} |
#endif // else: def __MENUET__ |
#endif // ndef __MENUET_H_INCLUDED_ |
/programs/games/checkers/trunk/include/stdarg.h |
---|
0,0 → 1,13 |
#ifndef __STDARG_H |
#define __STDARG_H |
typedef void *va_list; |
#define __size(x) ((sizeof(x)+sizeof(int)-1) & ~(sizeof(int)-1)) |
#define va_start(ap, parmN) ((void)((ap) = (va_list)((char *)(&parmN)+__size(parmN)))) |
#define va_arg(ap, type) (*(type *)(((*(char **)&(ap))+=__size(type))-(__size(type)))) |
#define va_end(ap) ((void)0) |
#endif /* __STDARG_H */ |
/programs/games/checkers/trunk/include/write_macro.inc |
---|
0,0 → 1,49 |
macro writestr [arg] |
{ |
common |
local straddr |
local strend |
pushad |
push straddr |
push strend |
jmp @Menuet@DebugPutString$qpxc |
straddr db arg,0 |
strend: |
pop eax |
popad |
} |
macro writeint arg |
{ |
push dword arg |
xchg eax,[esp] |
pushad |
push eax |
call @DebugPutNumber$qi |
pop eax |
popad |
pop eax |
} |
macro write [arg] |
{ |
forward |
if arg eq |
else if arg eq endline |
writestr 10 |
else if arg eqtype '' |
writestr arg |
else |
writeint arg |
end if |
} |
macro writeln [arg] |
{ |
common |
write arg,endline |
} |
/programs/games/checkers/trunk/include |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |
/programs/games/checkers/trunk/keysym.h |
---|
0,0 → 1,2047 |
#ifndef _INCLUDE_KEY_SYM_H |
#define _INCLUDE_KEY_SYM_H |
/* $Xorg: keysym.h,v 1.4 2001/02/09 02:03:23 xorgcvs Exp $ */ |
/*********************************************************** |
Copyright 1987, 1998 The Open Group |
Permission to use, copy, modify, distribute, and sell this software and its |
documentation for any purpose is hereby granted without fee, provided that |
the above copyright notice appear in all copies and that both that |
copyright notice and this permission notice appear in supporting |
documentation. |
The above copyright notice and this permission notice shall be included in |
all copies or substantial portions of the Software. |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN |
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
Except as contained in this notice, the name of The Open Group shall not be |
used in advertising or otherwise to promote the sale, use or other dealings |
in this Software without prior written authorization from The Open Group. |
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. |
All Rights Reserved |
Permission to use, copy, modify, and distribute this software and its |
documentation for any purpose and without fee is hereby granted, |
provided that the above copyright notice appear in all copies and that |
both that copyright notice and this permission notice appear in |
supporting documentation, and that the name of Digital not be |
used in advertising or publicity pertaining to distribution of the |
software without specific, written prior permission. |
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING |
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL |
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR |
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, |
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
SOFTWARE. |
******************************************************************/ |
/* $XFree86: xc/include/keysym.h,v 1.4 2001/12/14 19:53:26 dawes Exp $ */ |
/* default keysyms */ |
#define XK_MISCELLANY |
#define XK_XKB_KEYS |
#define XK_LATIN1 |
#define XK_LATIN2 |
#define XK_LATIN3 |
#define XK_LATIN4 |
#define XK_LATIN8 |
#define XK_LATIN9 |
#define XK_CAUCASUS |
#define XK_GREEK |
#define XK_KATAKANA |
#define XK_ARABIC |
#define XK_CYRILLIC |
#define XK_HEBREW |
#define XK_THAI |
#define XK_KOREAN |
#define XK_ARMENIAN |
#define XK_GEORGIAN |
#define XK_VIETNAMESE |
#define XK_CURRENCY |
/* keysym definitions */ |
#define XK_VoidSymbol 0xFFFFFF /* void symbol */ |
#ifdef XK_MISCELLANY |
/* |
* TTY Functions, cleverly chosen to map to ascii, for convenience of |
* programming, but could have been arbitrary (at the cost of lookup |
* tables in client code. |
*/ |
#define XK_BackSpace 0xFF08 /* back space, back char */ |
#define XK_Tab 0xFF09 |
#define XK_Linefeed 0xFF0A /* Linefeed, LF */ |
#define XK_Clear 0xFF0B |
#define XK_Return 0xFF0D /* Return, enter */ |
#define XK_Pause 0xFF13 /* Pause, hold */ |
#define XK_Scroll_Lock 0xFF14 |
#define XK_Sys_Req 0xFF15 |
#define XK_Escape 0xFF1B |
#define XK_Delete 0xFFFF /* Delete, rubout */ |
/* International & multi-key character composition */ |
#define XK_Multi_key 0xFF20 /* Multi-key character compose */ |
#define XK_Codeinput 0xFF37 |
#define XK_SingleCandidate 0xFF3C |
#define XK_MultipleCandidate 0xFF3D |
#define XK_PreviousCandidate 0xFF3E |
/* Japanese keyboard support */ |
#define XK_Kanji 0xFF21 /* Kanji, Kanji convert */ |
#define XK_Muhenkan 0xFF22 /* Cancel Conversion */ |
#define XK_Henkan_Mode 0xFF23 /* Start/Stop Conversion */ |
#define XK_Henkan 0xFF23 /* Alias for Henkan_Mode */ |
#define XK_Romaji 0xFF24 /* to Romaji */ |
#define XK_Hiragana 0xFF25 /* to Hiragana */ |
#define XK_Katakana 0xFF26 /* to Katakana */ |
#define XK_Hiragana_Katakana 0xFF27 /* Hiragana/Katakana toggle */ |
#define XK_Zenkaku 0xFF28 /* to Zenkaku */ |
#define XK_Hankaku 0xFF29 /* to Hankaku */ |
#define XK_Zenkaku_Hankaku 0xFF2A /* Zenkaku/Hankaku toggle */ |
#define XK_Touroku 0xFF2B /* Add to Dictionary */ |
#define XK_Massyo 0xFF2C /* Delete from Dictionary */ |
#define XK_Kana_Lock 0xFF2D /* Kana Lock */ |
#define XK_Kana_Shift 0xFF2E /* Kana Shift */ |
#define XK_Eisu_Shift 0xFF2F /* Alphanumeric Shift */ |
#define XK_Eisu_toggle 0xFF30 /* Alphanumeric toggle */ |
#define XK_Kanji_Bangou 0xFF37 /* Codeinput */ |
#define XK_Zen_Koho 0xFF3D /* Multiple/All Candidate(s) */ |
#define XK_Mae_Koho 0xFF3E /* Previous Candidate */ |
/* 0xFF31 thru 0xFF3F are under XK_KOREAN */ |
/* Cursor control & motion */ |
#define XK_Home 0xFF50 |
#define XK_Left 0xFF51 /* Move left, left arrow */ |
#define XK_Up 0xFF52 /* Move up, up arrow */ |
#define XK_Right 0xFF53 /* Move right, right arrow */ |
#define XK_Down 0xFF54 /* Move down, down arrow */ |
#define XK_Prior 0xFF55 /* Prior, previous */ |
#define XK_Page_Up 0xFF55 |
#define XK_Next 0xFF56 /* Next */ |
#define XK_Page_Down 0xFF56 |
#define XK_End 0xFF57 /* EOL */ |
#define XK_Begin 0xFF58 /* BOL */ |
/* Misc Functions */ |
#define XK_Select 0xFF60 /* Select, mark */ |
#define XK_Print 0xFF61 |
#define XK_Execute 0xFF62 /* Execute, run, do */ |
#define XK_Insert 0xFF63 /* Insert, insert here */ |
#define XK_Undo 0xFF65 /* Undo, oops */ |
#define XK_Redo 0xFF66 /* redo, again */ |
#define XK_Menu 0xFF67 |
#define XK_Find 0xFF68 /* Find, search */ |
#define XK_Cancel 0xFF69 /* Cancel, stop, abort, exit */ |
#define XK_Help 0xFF6A /* Help */ |
#define XK_Break 0xFF6B |
#define XK_Mode_switch 0xFF7E /* Character set switch */ |
#define XK_script_switch 0xFF7E /* Alias for mode_switch */ |
#define XK_Num_Lock 0xFF7F |
/* Keypad Functions, keypad numbers cleverly chosen to map to ascii */ |
#define XK_KP_Space 0xFF80 /* space */ |
#define XK_KP_Tab 0xFF89 |
#define XK_KP_Enter 0xFF8D /* enter */ |
#define XK_KP_F1 0xFF91 /* PF1, KP_A, ... */ |
#define XK_KP_F2 0xFF92 |
#define XK_KP_F3 0xFF93 |
#define XK_KP_F4 0xFF94 |
#define XK_KP_Home 0xFF95 |
#define XK_KP_Left 0xFF96 |
#define XK_KP_Up 0xFF97 |
#define XK_KP_Right 0xFF98 |
#define XK_KP_Down 0xFF99 |
#define XK_KP_Prior 0xFF9A |
#define XK_KP_Page_Up 0xFF9A |
#define XK_KP_Next 0xFF9B |
#define XK_KP_Page_Down 0xFF9B |
#define XK_KP_End 0xFF9C |
#define XK_KP_Begin 0xFF9D |
#define XK_KP_Insert 0xFF9E |
#define XK_KP_Delete 0xFF9F |
#define XK_KP_Equal 0xFFBD /* equals */ |
#define XK_KP_Multiply 0xFFAA |
#define XK_KP_Add 0xFFAB |
#define XK_KP_Separator 0xFFAC /* separator, often comma */ |
#define XK_KP_Subtract 0xFFAD |
#define XK_KP_Decimal 0xFFAE |
#define XK_KP_Divide 0xFFAF |
#define XK_KP_0 0xFFB0 |
#define XK_KP_1 0xFFB1 |
#define XK_KP_2 0xFFB2 |
#define XK_KP_3 0xFFB3 |
#define XK_KP_4 0xFFB4 |
#define XK_KP_5 0xFFB5 |
#define XK_KP_6 0xFFB6 |
#define XK_KP_7 0xFFB7 |
#define XK_KP_8 0xFFB8 |
#define XK_KP_9 0xFFB9 |
/* |
* Auxilliary Functions; note the duplicate definitions for left and right |
* function keys; Sun keyboards and a few other manufactures have such |
* function key groups on the left and/or right sides of the keyboard. |
* We've not found a keyboard with more than 35 function keys total. |
*/ |
#define XK_F1 0xFFBE |
#define XK_F2 0xFFBF |
#define XK_F3 0xFFC0 |
#define XK_F4 0xFFC1 |
#define XK_F5 0xFFC2 |
#define XK_F6 0xFFC3 |
#define XK_F7 0xFFC4 |
#define XK_F8 0xFFC5 |
#define XK_F9 0xFFC6 |
#define XK_F10 0xFFC7 |
#define XK_F11 0xFFC8 |
#define XK_L1 0xFFC8 |
#define XK_F12 0xFFC9 |
#define XK_L2 0xFFC9 |
#define XK_F13 0xFFCA |
#define XK_L3 0xFFCA |
#define XK_F14 0xFFCB |
#define XK_L4 0xFFCB |
#define XK_F15 0xFFCC |
#define XK_L5 0xFFCC |
#define XK_F16 0xFFCD |
#define XK_L6 0xFFCD |
#define XK_F17 0xFFCE |
#define XK_L7 0xFFCE |
#define XK_F18 0xFFCF |
#define XK_L8 0xFFCF |
#define XK_F19 0xFFD0 |
#define XK_L9 0xFFD0 |
#define XK_F20 0xFFD1 |
#define XK_L10 0xFFD1 |
#define XK_F21 0xFFD2 |
#define XK_R1 0xFFD2 |
#define XK_F22 0xFFD3 |
#define XK_R2 0xFFD3 |
#define XK_F23 0xFFD4 |
#define XK_R3 0xFFD4 |
#define XK_F24 0xFFD5 |
#define XK_R4 0xFFD5 |
#define XK_F25 0xFFD6 |
#define XK_R5 0xFFD6 |
#define XK_F26 0xFFD7 |
#define XK_R6 0xFFD7 |
#define XK_F27 0xFFD8 |
#define XK_R7 0xFFD8 |
#define XK_F28 0xFFD9 |
#define XK_R8 0xFFD9 |
#define XK_F29 0xFFDA |
#define XK_R9 0xFFDA |
#define XK_F30 0xFFDB |
#define XK_R10 0xFFDB |
#define XK_F31 0xFFDC |
#define XK_R11 0xFFDC |
#define XK_F32 0xFFDD |
#define XK_R12 0xFFDD |
#define XK_F33 0xFFDE |
#define XK_R13 0xFFDE |
#define XK_F34 0xFFDF |
#define XK_R14 0xFFDF |
#define XK_F35 0xFFE0 |
#define XK_R15 0xFFE0 |
/* Modifiers */ |
#define XK_Shift_L 0xFFE1 /* Left shift */ |
#define XK_Shift_R 0xFFE2 /* Right shift */ |
#define XK_Control_L 0xFFE3 /* Left control */ |
#define XK_Control_R 0xFFE4 /* Right control */ |
#define XK_Caps_Lock 0xFFE5 /* Caps lock */ |
#define XK_Shift_Lock 0xFFE6 /* Shift lock */ |
#define XK_Meta_L 0xFFE7 /* Left meta */ |
#define XK_Meta_R 0xFFE8 /* Right meta */ |
#define XK_Alt_L 0xFFE9 /* Left alt */ |
#define XK_Alt_R 0xFFEA /* Right alt */ |
#define XK_Super_L 0xFFEB /* Left super */ |
#define XK_Super_R 0xFFEC /* Right super */ |
#define XK_Hyper_L 0xFFED /* Left hyper */ |
#define XK_Hyper_R 0xFFEE /* Right hyper */ |
#endif /* XK_MISCELLANY */ |
/* |
* ISO 9995 Function and Modifier Keys |
* Byte 3 = 0xFE |
*/ |
#ifdef XK_XKB_KEYS |
#define XK_ISO_Lock 0xFE01 |
#define XK_ISO_Level2_Latch 0xFE02 |
#define XK_ISO_Level3_Shift 0xFE03 |
#define XK_ISO_Level3_Latch 0xFE04 |
#define XK_ISO_Level3_Lock 0xFE05 |
#define XK_ISO_Group_Shift 0xFF7E /* Alias for mode_switch */ |
#define XK_ISO_Group_Latch 0xFE06 |
#define XK_ISO_Group_Lock 0xFE07 |
#define XK_ISO_Next_Group 0xFE08 |
#define XK_ISO_Next_Group_Lock 0xFE09 |
#define XK_ISO_Prev_Group 0xFE0A |
#define XK_ISO_Prev_Group_Lock 0xFE0B |
#define XK_ISO_First_Group 0xFE0C |
#define XK_ISO_First_Group_Lock 0xFE0D |
#define XK_ISO_Last_Group 0xFE0E |
#define XK_ISO_Last_Group_Lock 0xFE0F |
#define XK_ISO_Left_Tab 0xFE20 |
#define XK_ISO_Move_Line_Up 0xFE21 |
#define XK_ISO_Move_Line_Down 0xFE22 |
#define XK_ISO_Partial_Line_Up 0xFE23 |
#define XK_ISO_Partial_Line_Down 0xFE24 |
#define XK_ISO_Partial_Space_Left 0xFE25 |
#define XK_ISO_Partial_Space_Right 0xFE26 |
#define XK_ISO_Set_Margin_Left 0xFE27 |
#define XK_ISO_Set_Margin_Right 0xFE28 |
#define XK_ISO_Release_Margin_Left 0xFE29 |
#define XK_ISO_Release_Margin_Right 0xFE2A |
#define XK_ISO_Release_Both_Margins 0xFE2B |
#define XK_ISO_Fast_Cursor_Left 0xFE2C |
#define XK_ISO_Fast_Cursor_Right 0xFE2D |
#define XK_ISO_Fast_Cursor_Up 0xFE2E |
#define XK_ISO_Fast_Cursor_Down 0xFE2F |
#define XK_ISO_Continuous_Underline 0xFE30 |
#define XK_ISO_Discontinuous_Underline 0xFE31 |
#define XK_ISO_Emphasize 0xFE32 |
#define XK_ISO_Center_Object 0xFE33 |
#define XK_ISO_Enter 0xFE34 |
#define XK_dead_grave 0xFE50 |
#define XK_dead_acute 0xFE51 |
#define XK_dead_circumflex 0xFE52 |
#define XK_dead_tilde 0xFE53 |
#define XK_dead_macron 0xFE54 |
#define XK_dead_breve 0xFE55 |
#define XK_dead_abovedot 0xFE56 |
#define XK_dead_diaeresis 0xFE57 |
#define XK_dead_abovering 0xFE58 |
#define XK_dead_doubleacute 0xFE59 |
#define XK_dead_caron 0xFE5A |
#define XK_dead_cedilla 0xFE5B |
#define XK_dead_ogonek 0xFE5C |
#define XK_dead_iota 0xFE5D |
#define XK_dead_voiced_sound 0xFE5E |
#define XK_dead_semivoiced_sound 0xFE5F |
#define XK_dead_belowdot 0xFE60 |
#define XK_dead_hook 0xFE61 |
#define XK_dead_horn 0xFE62 |
#define XK_First_Virtual_Screen 0xFED0 |
#define XK_Prev_Virtual_Screen 0xFED1 |
#define XK_Next_Virtual_Screen 0xFED2 |
#define XK_Last_Virtual_Screen 0xFED4 |
#define XK_Terminate_Server 0xFED5 |
#define XK_AccessX_Enable 0xFE70 |
#define XK_AccessX_Feedback_Enable 0xFE71 |
#define XK_RepeatKeys_Enable 0xFE72 |
#define XK_SlowKeys_Enable 0xFE73 |
#define XK_BounceKeys_Enable 0xFE74 |
#define XK_StickyKeys_Enable 0xFE75 |
#define XK_MouseKeys_Enable 0xFE76 |
#define XK_MouseKeys_Accel_Enable 0xFE77 |
#define XK_Overlay1_Enable 0xFE78 |
#define XK_Overlay2_Enable 0xFE79 |
#define XK_AudibleBell_Enable 0xFE7A |
#define XK_Pointer_Left 0xFEE0 |
#define XK_Pointer_Right 0xFEE1 |
#define XK_Pointer_Up 0xFEE2 |
#define XK_Pointer_Down 0xFEE3 |
#define XK_Pointer_UpLeft 0xFEE4 |
#define XK_Pointer_UpRight 0xFEE5 |
#define XK_Pointer_DownLeft 0xFEE6 |
#define XK_Pointer_DownRight 0xFEE7 |
#define XK_Pointer_Button_Dflt 0xFEE8 |
#define XK_Pointer_Button1 0xFEE9 |
#define XK_Pointer_Button2 0xFEEA |
#define XK_Pointer_Button3 0xFEEB |
#define XK_Pointer_Button4 0xFEEC |
#define XK_Pointer_Button5 0xFEED |
#define XK_Pointer_DblClick_Dflt 0xFEEE |
#define XK_Pointer_DblClick1 0xFEEF |
#define XK_Pointer_DblClick2 0xFEF0 |
#define XK_Pointer_DblClick3 0xFEF1 |
#define XK_Pointer_DblClick4 0xFEF2 |
#define XK_Pointer_DblClick5 0xFEF3 |
#define XK_Pointer_Drag_Dflt 0xFEF4 |
#define XK_Pointer_Drag1 0xFEF5 |
#define XK_Pointer_Drag2 0xFEF6 |
#define XK_Pointer_Drag3 0xFEF7 |
#define XK_Pointer_Drag4 0xFEF8 |
#define XK_Pointer_Drag5 0xFEFD |
#define XK_Pointer_EnableKeys 0xFEF9 |
#define XK_Pointer_Accelerate 0xFEFA |
#define XK_Pointer_DfltBtnNext 0xFEFB |
#define XK_Pointer_DfltBtnPrev 0xFEFC |
#endif |
/* |
* 3270 Terminal Keys |
* Byte 3 = 0xFD |
*/ |
#ifdef XK_3270 |
#define XK_3270_Duplicate 0xFD01 |
#define XK_3270_FieldMark 0xFD02 |
#define XK_3270_Right2 0xFD03 |
#define XK_3270_Left2 0xFD04 |
#define XK_3270_BackTab 0xFD05 |
#define XK_3270_EraseEOF 0xFD06 |
#define XK_3270_EraseInput 0xFD07 |
#define XK_3270_Reset 0xFD08 |
#define XK_3270_Quit 0xFD09 |
#define XK_3270_PA1 0xFD0A |
#define XK_3270_PA2 0xFD0B |
#define XK_3270_PA3 0xFD0C |
#define XK_3270_Test 0xFD0D |
#define XK_3270_Attn 0xFD0E |
#define XK_3270_CursorBlink 0xFD0F |
#define XK_3270_AltCursor 0xFD10 |
#define XK_3270_KeyClick 0xFD11 |
#define XK_3270_Jump 0xFD12 |
#define XK_3270_Ident 0xFD13 |
#define XK_3270_Rule 0xFD14 |
#define XK_3270_Copy 0xFD15 |
#define XK_3270_Play 0xFD16 |
#define XK_3270_Setup 0xFD17 |
#define XK_3270_Record 0xFD18 |
#define XK_3270_ChangeScreen 0xFD19 |
#define XK_3270_DeleteWord 0xFD1A |
#define XK_3270_ExSelect 0xFD1B |
#define XK_3270_CursorSelect 0xFD1C |
#define XK_3270_PrintScreen 0xFD1D |
#define XK_3270_Enter 0xFD1E |
#endif |
/* |
* Latin 1 |
* Byte 3 = 0 |
*/ |
#ifdef XK_LATIN1 |
#define XK_space 0x020 |
#define XK_exclam 0x021 |
#define XK_quotedbl 0x022 |
#define XK_numbersign 0x023 |
#define XK_dollar 0x024 |
#define XK_percent 0x025 |
#define XK_ampersand 0x026 |
#define XK_apostrophe 0x027 |
#define XK_quoteright 0x027 /* deprecated */ |
#define XK_parenleft 0x028 |
#define XK_parenright 0x029 |
#define XK_asterisk 0x02a |
#define XK_plus 0x02b |
#define XK_comma 0x02c |
#define XK_minus 0x02d |
#define XK_period 0x02e |
#define XK_slash 0x02f |
#define XK_0 0x030 |
#define XK_1 0x031 |
#define XK_2 0x032 |
#define XK_3 0x033 |
#define XK_4 0x034 |
#define XK_5 0x035 |
#define XK_6 0x036 |
#define XK_7 0x037 |
#define XK_8 0x038 |
#define XK_9 0x039 |
#define XK_colon 0x03a |
#define XK_semicolon 0x03b |
#define XK_less 0x03c |
#define XK_equal 0x03d |
#define XK_greater 0x03e |
#define XK_question 0x03f |
#define XK_at 0x040 |
#define XK_A 0x041 |
#define XK_B 0x042 |
#define XK_C 0x043 |
#define XK_D 0x044 |
#define XK_E 0x045 |
#define XK_F 0x046 |
#define XK_G 0x047 |
#define XK_H 0x048 |
#define XK_I 0x049 |
#define XK_J 0x04a |
#define XK_K 0x04b |
#define XK_L 0x04c |
#define XK_M 0x04d |
#define XK_N 0x04e |
#define XK_O 0x04f |
#define XK_P 0x050 |
#define XK_Q 0x051 |
#define XK_R 0x052 |
#define XK_S 0x053 |
#define XK_T 0x054 |
#define XK_U 0x055 |
#define XK_V 0x056 |
#define XK_W 0x057 |
#define XK_X 0x058 |
#define XK_Y 0x059 |
#define XK_Z 0x05a |
#define XK_bracketleft 0x05b |
#define XK_backslash 0x05c |
#define XK_bracketright 0x05d |
#define XK_asciicircum 0x05e |
#define XK_underscore 0x05f |
#define XK_grave 0x060 |
#define XK_quoteleft 0x060 /* deprecated */ |
#define XK_a 0x061 |
#define XK_b 0x062 |
#define XK_c 0x063 |
#define XK_d 0x064 |
#define XK_e 0x065 |
#define XK_f 0x066 |
#define XK_g 0x067 |
#define XK_h 0x068 |
#define XK_i 0x069 |
#define XK_j 0x06a |
#define XK_k 0x06b |
#define XK_l 0x06c |
#define XK_m 0x06d |
#define XK_n 0x06e |
#define XK_o 0x06f |
#define XK_p 0x070 |
#define XK_q 0x071 |
#define XK_r 0x072 |
#define XK_s 0x073 |
#define XK_t 0x074 |
#define XK_u 0x075 |
#define XK_v 0x076 |
#define XK_w 0x077 |
#define XK_x 0x078 |
#define XK_y 0x079 |
#define XK_z 0x07a |
#define XK_braceleft 0x07b |
#define XK_bar 0x07c |
#define XK_braceright 0x07d |
#define XK_asciitilde 0x07e |
#define XK_nobreakspace 0x0a0 |
#define XK_exclamdown 0x0a1 |
#define XK_cent 0x0a2 |
#define XK_sterling 0x0a3 |
#define XK_currency 0x0a4 |
#define XK_yen 0x0a5 |
#define XK_brokenbar 0x0a6 |
#define XK_section 0x0a7 |
#define XK_diaeresis 0x0a8 |
#define XK_copyright 0x0a9 |
#define XK_ordfeminine 0x0aa |
#define XK_guillemotleft 0x0ab /* left angle quotation mark */ |
#define XK_notsign 0x0ac |
#define XK_hyphen 0x0ad |
#define XK_registered 0x0ae |
#define XK_macron 0x0af |
#define XK_degree 0x0b0 |
#define XK_plusminus 0x0b1 |
#define XK_twosuperior 0x0b2 |
#define XK_threesuperior 0x0b3 |
#define XK_acute 0x0b4 |
#define XK_mu 0x0b5 |
#define XK_paragraph 0x0b6 |
#define XK_periodcentered 0x0b7 |
#define XK_cedilla 0x0b8 |
#define XK_onesuperior 0x0b9 |
#define XK_masculine 0x0ba |
#define XK_guillemotright 0x0bb /* right angle quotation mark */ |
#define XK_onequarter 0x0bc |
#define XK_onehalf 0x0bd |
#define XK_threequarters 0x0be |
#define XK_questiondown 0x0bf |
#define XK_Agrave 0x0c0 |
#define XK_Aacute 0x0c1 |
#define XK_Acircumflex 0x0c2 |
#define XK_Atilde 0x0c3 |
#define XK_Adiaeresis 0x0c4 |
#define XK_Aring 0x0c5 |
#define XK_AE 0x0c6 |
#define XK_Ccedilla 0x0c7 |
#define XK_Egrave 0x0c8 |
#define XK_Eacute 0x0c9 |
#define XK_Ecircumflex 0x0ca |
#define XK_Ediaeresis 0x0cb |
#define XK_Igrave 0x0cc |
#define XK_Iacute 0x0cd |
#define XK_Icircumflex 0x0ce |
#define XK_Idiaeresis 0x0cf |
#define XK_ETH 0x0d0 |
#define XK_Eth 0x0d0 /* deprecated */ |
#define XK_Ntilde 0x0d1 |
#define XK_Ograve 0x0d2 |
#define XK_Oacute 0x0d3 |
#define XK_Ocircumflex 0x0d4 |
#define XK_Otilde 0x0d5 |
#define XK_Odiaeresis 0x0d6 |
#define XK_multiply 0x0d7 |
#define XK_Ooblique 0x0d8 |
#define XK_Oslash XK_Ooblique |
#define XK_Ugrave 0x0d9 |
#define XK_Uacute 0x0da |
#define XK_Ucircumflex 0x0db |
#define XK_Udiaeresis 0x0dc |
#define XK_Yacute 0x0dd |
#define XK_THORN 0x0de |
#define XK_Thorn 0x0de /* deprecated */ |
#define XK_ssharp 0x0df |
#define XK_agrave 0x0e0 |
#define XK_aacute 0x0e1 |
#define XK_acircumflex 0x0e2 |
#define XK_atilde 0x0e3 |
#define XK_adiaeresis 0x0e4 |
#define XK_aring 0x0e5 |
#define XK_ae 0x0e6 |
#define XK_ccedilla 0x0e7 |
#define XK_egrave 0x0e8 |
#define XK_eacute 0x0e9 |
#define XK_ecircumflex 0x0ea |
#define XK_ediaeresis 0x0eb |
#define XK_igrave 0x0ec |
#define XK_iacute 0x0ed |
#define XK_icircumflex 0x0ee |
#define XK_idiaeresis 0x0ef |
#define XK_eth 0x0f0 |
#define XK_ntilde 0x0f1 |
#define XK_ograve 0x0f2 |
#define XK_oacute 0x0f3 |
#define XK_ocircumflex 0x0f4 |
#define XK_otilde 0x0f5 |
#define XK_odiaeresis 0x0f6 |
#define XK_division 0x0f7 |
#define XK_oslash 0x0f8 |
#define XK_ooblique XK_oslash |
#define XK_ugrave 0x0f9 |
#define XK_uacute 0x0fa |
#define XK_ucircumflex 0x0fb |
#define XK_udiaeresis 0x0fc |
#define XK_yacute 0x0fd |
#define XK_thorn 0x0fe |
#define XK_ydiaeresis 0x0ff |
#endif /* XK_LATIN1 */ |
/* |
* Latin 2 |
* Byte 3 = 1 |
*/ |
#ifdef XK_LATIN2 |
#define XK_Aogonek 0x1a1 |
#define XK_breve 0x1a2 |
#define XK_Lstroke 0x1a3 |
#define XK_Lcaron 0x1a5 |
#define XK_Sacute 0x1a6 |
#define XK_Scaron 0x1a9 |
#define XK_Scedilla 0x1aa |
#define XK_Tcaron 0x1ab |
#define XK_Zacute 0x1ac |
#define XK_Zcaron 0x1ae |
#define XK_Zabovedot 0x1af |
#define XK_aogonek 0x1b1 |
#define XK_ogonek 0x1b2 |
#define XK_lstroke 0x1b3 |
#define XK_lcaron 0x1b5 |
#define XK_sacute 0x1b6 |
#define XK_caron 0x1b7 |
#define XK_scaron 0x1b9 |
#define XK_scedilla 0x1ba |
#define XK_tcaron 0x1bb |
#define XK_zacute 0x1bc |
#define XK_doubleacute 0x1bd |
#define XK_zcaron 0x1be |
#define XK_zabovedot 0x1bf |
#define XK_Racute 0x1c0 |
#define XK_Abreve 0x1c3 |
#define XK_Lacute 0x1c5 |
#define XK_Cacute 0x1c6 |
#define XK_Ccaron 0x1c8 |
#define XK_Eogonek 0x1ca |
#define XK_Ecaron 0x1cc |
#define XK_Dcaron 0x1cf |
#define XK_Dstroke 0x1d0 |
#define XK_Nacute 0x1d1 |
#define XK_Ncaron 0x1d2 |
#define XK_Odoubleacute 0x1d5 |
#define XK_Rcaron 0x1d8 |
#define XK_Uring 0x1d9 |
#define XK_Udoubleacute 0x1db |
#define XK_Tcedilla 0x1de |
#define XK_racute 0x1e0 |
#define XK_abreve 0x1e3 |
#define XK_lacute 0x1e5 |
#define XK_cacute 0x1e6 |
#define XK_ccaron 0x1e8 |
#define XK_eogonek 0x1ea |
#define XK_ecaron 0x1ec |
#define XK_dcaron 0x1ef |
#define XK_dstroke 0x1f0 |
#define XK_nacute 0x1f1 |
#define XK_ncaron 0x1f2 |
#define XK_odoubleacute 0x1f5 |
#define XK_udoubleacute 0x1fb |
#define XK_rcaron 0x1f8 |
#define XK_uring 0x1f9 |
#define XK_tcedilla 0x1fe |
#define XK_abovedot 0x1ff |
#endif /* XK_LATIN2 */ |
/* |
* Latin 3 |
* Byte 3 = 2 |
*/ |
#ifdef XK_LATIN3 |
#define XK_Hstroke 0x2a1 |
#define XK_Hcircumflex 0x2a6 |
#define XK_Iabovedot 0x2a9 |
#define XK_Gbreve 0x2ab |
#define XK_Jcircumflex 0x2ac |
#define XK_hstroke 0x2b1 |
#define XK_hcircumflex 0x2b6 |
#define XK_idotless 0x2b9 |
#define XK_gbreve 0x2bb |
#define XK_jcircumflex 0x2bc |
#define XK_Cabovedot 0x2c5 |
#define XK_Ccircumflex 0x2c6 |
#define XK_Gabovedot 0x2d5 |
#define XK_Gcircumflex 0x2d8 |
#define XK_Ubreve 0x2dd |
#define XK_Scircumflex 0x2de |
#define XK_cabovedot 0x2e5 |
#define XK_ccircumflex 0x2e6 |
#define XK_gabovedot 0x2f5 |
#define XK_gcircumflex 0x2f8 |
#define XK_ubreve 0x2fd |
#define XK_scircumflex 0x2fe |
#endif /* XK_LATIN3 */ |
/* |
* Latin 4 |
* Byte 3 = 3 |
*/ |
#ifdef XK_LATIN4 |
#define XK_kra 0x3a2 |
#define XK_kappa 0x3a2 /* deprecated */ |
#define XK_Rcedilla 0x3a3 |
#define XK_Itilde 0x3a5 |
#define XK_Lcedilla 0x3a6 |
#define XK_Emacron 0x3aa |
#define XK_Gcedilla 0x3ab |
#define XK_Tslash 0x3ac |
#define XK_rcedilla 0x3b3 |
#define XK_itilde 0x3b5 |
#define XK_lcedilla 0x3b6 |
#define XK_emacron 0x3ba |
#define XK_gcedilla 0x3bb |
#define XK_tslash 0x3bc |
#define XK_ENG 0x3bd |
#define XK_eng 0x3bf |
#define XK_Amacron 0x3c0 |
#define XK_Iogonek 0x3c7 |
#define XK_Eabovedot 0x3cc |
#define XK_Imacron 0x3cf |
#define XK_Ncedilla 0x3d1 |
#define XK_Omacron 0x3d2 |
#define XK_Kcedilla 0x3d3 |
#define XK_Uogonek 0x3d9 |
#define XK_Utilde 0x3dd |
#define XK_Umacron 0x3de |
#define XK_amacron 0x3e0 |
#define XK_iogonek 0x3e7 |
#define XK_eabovedot 0x3ec |
#define XK_imacron 0x3ef |
#define XK_ncedilla 0x3f1 |
#define XK_omacron 0x3f2 |
#define XK_kcedilla 0x3f3 |
#define XK_uogonek 0x3f9 |
#define XK_utilde 0x3fd |
#define XK_umacron 0x3fe |
#endif /* XK_LATIN4 */ |
/* |
* Latin-8 |
* Byte 3 = 18 |
*/ |
#ifdef XK_LATIN8 |
#define XK_Babovedot 0x12a1 |
#define XK_babovedot 0x12a2 |
#define XK_Dabovedot 0x12a6 |
#define XK_Wgrave 0x12a8 |
#define XK_Wacute 0x12aa |
#define XK_dabovedot 0x12ab |
#define XK_Ygrave 0x12ac |
#define XK_Fabovedot 0x12b0 |
#define XK_fabovedot 0x12b1 |
#define XK_Mabovedot 0x12b4 |
#define XK_mabovedot 0x12b5 |
#define XK_Pabovedot 0x12b7 |
#define XK_wgrave 0x12b8 |
#define XK_pabovedot 0x12b9 |
#define XK_wacute 0x12ba |
#define XK_Sabovedot 0x12bb |
#define XK_ygrave 0x12bc |
#define XK_Wdiaeresis 0x12bd |
#define XK_wdiaeresis 0x12be |
#define XK_sabovedot 0x12bf |
#define XK_Wcircumflex 0x12d0 |
#define XK_Tabovedot 0x12d7 |
#define XK_Ycircumflex 0x12de |
#define XK_wcircumflex 0x12f0 |
#define XK_tabovedot 0x12f7 |
#define XK_ycircumflex 0x12fe |
#endif /* XK_LATIN8 */ |
/* |
* Latin-9 (a.k.a. Latin-0) |
* Byte 3 = 19 |
*/ |
#ifdef XK_LATIN9 |
#define XK_OE 0x13bc |
#define XK_oe 0x13bd |
#define XK_Ydiaeresis 0x13be |
#endif /* XK_LATIN9 */ |
/* |
* Katakana |
* Byte 3 = 4 |
*/ |
#ifdef XK_KATAKANA |
#define XK_overline 0x47e |
#define XK_kana_fullstop 0x4a1 |
#define XK_kana_openingbracket 0x4a2 |
#define XK_kana_closingbracket 0x4a3 |
#define XK_kana_comma 0x4a4 |
#define XK_kana_conjunctive 0x4a5 |
#define XK_kana_middledot 0x4a5 /* deprecated */ |
#define XK_kana_WO 0x4a6 |
#define XK_kana_a 0x4a7 |
#define XK_kana_i 0x4a8 |
#define XK_kana_u 0x4a9 |
#define XK_kana_e 0x4aa |
#define XK_kana_o 0x4ab |
#define XK_kana_ya 0x4ac |
#define XK_kana_yu 0x4ad |
#define XK_kana_yo 0x4ae |
#define XK_kana_tsu 0x4af |
#define XK_kana_tu 0x4af /* deprecated */ |
#define XK_prolongedsound 0x4b0 |
#define XK_kana_A 0x4b1 |
#define XK_kana_I 0x4b2 |
#define XK_kana_U 0x4b3 |
#define XK_kana_E 0x4b4 |
#define XK_kana_O 0x4b5 |
#define XK_kana_KA 0x4b6 |
#define XK_kana_KI 0x4b7 |
#define XK_kana_KU 0x4b8 |
#define XK_kana_KE 0x4b9 |
#define XK_kana_KO 0x4ba |
#define XK_kana_SA 0x4bb |
#define XK_kana_SHI 0x4bc |
#define XK_kana_SU 0x4bd |
#define XK_kana_SE 0x4be |
#define XK_kana_SO 0x4bf |
#define XK_kana_TA 0x4c0 |
#define XK_kana_CHI 0x4c1 |
#define XK_kana_TI 0x4c1 /* deprecated */ |
#define XK_kana_TSU 0x4c2 |
#define XK_kana_TU 0x4c2 /* deprecated */ |
#define XK_kana_TE 0x4c3 |
#define XK_kana_TO 0x4c4 |
#define XK_kana_NA 0x4c5 |
#define XK_kana_NI 0x4c6 |
#define XK_kana_NU 0x4c7 |
#define XK_kana_NE 0x4c8 |
#define XK_kana_NO 0x4c9 |
#define XK_kana_HA 0x4ca |
#define XK_kana_HI 0x4cb |
#define XK_kana_FU 0x4cc |
#define XK_kana_HU 0x4cc /* deprecated */ |
#define XK_kana_HE 0x4cd |
#define XK_kana_HO 0x4ce |
#define XK_kana_MA 0x4cf |
#define XK_kana_MI 0x4d0 |
#define XK_kana_MU 0x4d1 |
#define XK_kana_ME 0x4d2 |
#define XK_kana_MO 0x4d3 |
#define XK_kana_YA 0x4d4 |
#define XK_kana_YU 0x4d5 |
#define XK_kana_YO 0x4d6 |
#define XK_kana_RA 0x4d7 |
#define XK_kana_RI 0x4d8 |
#define XK_kana_RU 0x4d9 |
#define XK_kana_RE 0x4da |
#define XK_kana_RO 0x4db |
#define XK_kana_WA 0x4dc |
#define XK_kana_N 0x4dd |
#define XK_voicedsound 0x4de |
#define XK_semivoicedsound 0x4df |
#define XK_kana_switch 0xFF7E /* Alias for mode_switch */ |
#endif /* XK_KATAKANA */ |
/* |
* Arabic |
* Byte 3 = 5 |
*/ |
#ifdef XK_ARABIC |
#define XK_Farsi_0 0x590 |
#define XK_Farsi_1 0x591 |
#define XK_Farsi_2 0x592 |
#define XK_Farsi_3 0x593 |
#define XK_Farsi_4 0x594 |
#define XK_Farsi_5 0x595 |
#define XK_Farsi_6 0x596 |
#define XK_Farsi_7 0x597 |
#define XK_Farsi_8 0x598 |
#define XK_Farsi_9 0x599 |
#define XK_Arabic_percent 0x5a5 |
#define XK_Arabic_superscript_alef 0x5a6 |
#define XK_Arabic_tteh 0x5a7 |
#define XK_Arabic_peh 0x5a8 |
#define XK_Arabic_tcheh 0x5a9 |
#define XK_Arabic_ddal 0x5aa |
#define XK_Arabic_rreh 0x5ab |
#define XK_Arabic_comma 0x5ac |
#define XK_Arabic_fullstop 0x5ae |
#define XK_Arabic_0 0x5b0 |
#define XK_Arabic_1 0x5b1 |
#define XK_Arabic_2 0x5b2 |
#define XK_Arabic_3 0x5b3 |
#define XK_Arabic_4 0x5b4 |
#define XK_Arabic_5 0x5b5 |
#define XK_Arabic_6 0x5b6 |
#define XK_Arabic_7 0x5b7 |
#define XK_Arabic_8 0x5b8 |
#define XK_Arabic_9 0x5b9 |
#define XK_Arabic_semicolon 0x5bb |
#define XK_Arabic_question_mark 0x5bf |
#define XK_Arabic_hamza 0x5c1 |
#define XK_Arabic_maddaonalef 0x5c2 |
#define XK_Arabic_hamzaonalef 0x5c3 |
#define XK_Arabic_hamzaonwaw 0x5c4 |
#define XK_Arabic_hamzaunderalef 0x5c5 |
#define XK_Arabic_hamzaonyeh 0x5c6 |
#define XK_Arabic_alef 0x5c7 |
#define XK_Arabic_beh 0x5c8 |
#define XK_Arabic_tehmarbuta 0x5c9 |
#define XK_Arabic_teh 0x5ca |
#define XK_Arabic_theh 0x5cb |
#define XK_Arabic_jeem 0x5cc |
#define XK_Arabic_hah 0x5cd |
#define XK_Arabic_khah 0x5ce |
#define XK_Arabic_dal 0x5cf |
#define XK_Arabic_thal 0x5d0 |
#define XK_Arabic_ra 0x5d1 |
#define XK_Arabic_zain 0x5d2 |
#define XK_Arabic_seen 0x5d3 |
#define XK_Arabic_sheen 0x5d4 |
#define XK_Arabic_sad 0x5d5 |
#define XK_Arabic_dad 0x5d6 |
#define XK_Arabic_tah 0x5d7 |
#define XK_Arabic_zah 0x5d8 |
#define XK_Arabic_ain 0x5d9 |
#define XK_Arabic_ghain 0x5da |
#define XK_Arabic_tatweel 0x5e0 |
#define XK_Arabic_feh 0x5e1 |
#define XK_Arabic_qaf 0x5e2 |
#define XK_Arabic_kaf 0x5e3 |
#define XK_Arabic_lam 0x5e4 |
#define XK_Arabic_meem 0x5e5 |
#define XK_Arabic_noon 0x5e6 |
#define XK_Arabic_ha 0x5e7 |
#define XK_Arabic_heh 0x5e7 /* deprecated */ |
#define XK_Arabic_waw 0x5e8 |
#define XK_Arabic_alefmaksura 0x5e9 |
#define XK_Arabic_yeh 0x5ea |
#define XK_Arabic_fathatan 0x5eb |
#define XK_Arabic_dammatan 0x5ec |
#define XK_Arabic_kasratan 0x5ed |
#define XK_Arabic_fatha 0x5ee |
#define XK_Arabic_damma 0x5ef |
#define XK_Arabic_kasra 0x5f0 |
#define XK_Arabic_shadda 0x5f1 |
#define XK_Arabic_sukun 0x5f2 |
#define XK_Arabic_madda_above 0x5f3 |
#define XK_Arabic_hamza_above 0x5f4 |
#define XK_Arabic_hamza_below 0x5f5 |
#define XK_Arabic_jeh 0x5f6 |
#define XK_Arabic_veh 0x5f7 |
#define XK_Arabic_keheh 0x5f8 |
#define XK_Arabic_gaf 0x5f9 |
#define XK_Arabic_noon_ghunna 0x5fa |
#define XK_Arabic_heh_doachashmee 0x5fb |
#define XK_Farsi_yeh 0x5fc |
#define XK_Arabic_farsi_yeh XK_Farsi_yeh |
#define XK_Arabic_yeh_baree 0x5fd |
#define XK_Arabic_heh_goal 0x5fe |
#define XK_Arabic_switch 0xFF7E /* Alias for mode_switch */ |
#endif /* XK_ARABIC */ |
/* |
* Cyrillic |
* Byte 3 = 6 |
*/ |
#ifdef XK_CYRILLIC |
#define XK_Cyrillic_GHE_bar 0x680 |
#define XK_Cyrillic_ghe_bar 0x690 |
#define XK_Cyrillic_ZHE_descender 0x681 |
#define XK_Cyrillic_zhe_descender 0x691 |
#define XK_Cyrillic_KA_descender 0x682 |
#define XK_Cyrillic_ka_descender 0x692 |
#define XK_Cyrillic_KA_vertstroke 0x683 |
#define XK_Cyrillic_ka_vertstroke 0x693 |
#define XK_Cyrillic_EN_descender 0x684 |
#define XK_Cyrillic_en_descender 0x694 |
#define XK_Cyrillic_U_straight 0x685 |
#define XK_Cyrillic_u_straight 0x695 |
#define XK_Cyrillic_U_straight_bar 0x686 |
#define XK_Cyrillic_u_straight_bar 0x696 |
#define XK_Cyrillic_HA_descender 0x687 |
#define XK_Cyrillic_ha_descender 0x697 |
#define XK_Cyrillic_CHE_descender 0x688 |
#define XK_Cyrillic_che_descender 0x698 |
#define XK_Cyrillic_CHE_vertstroke 0x689 |
#define XK_Cyrillic_che_vertstroke 0x699 |
#define XK_Cyrillic_SHHA 0x68a |
#define XK_Cyrillic_shha 0x69a |
#define XK_Cyrillic_SCHWA 0x68c |
#define XK_Cyrillic_schwa 0x69c |
#define XK_Cyrillic_I_macron 0x68d |
#define XK_Cyrillic_i_macron 0x69d |
#define XK_Cyrillic_O_bar 0x68e |
#define XK_Cyrillic_o_bar 0x69e |
#define XK_Cyrillic_U_macron 0x68f |
#define XK_Cyrillic_u_macron 0x69f |
#define XK_Serbian_dje 0x6a1 |
#define XK_Macedonia_gje 0x6a2 |
#define XK_Cyrillic_io 0x6a3 |
#define XK_Ukrainian_ie 0x6a4 |
#define XK_Ukranian_je 0x6a4 /* deprecated */ |
#define XK_Macedonia_dse 0x6a5 |
#define XK_Ukrainian_i 0x6a6 |
#define XK_Ukranian_i 0x6a6 /* deprecated */ |
#define XK_Ukrainian_yi 0x6a7 |
#define XK_Ukranian_yi 0x6a7 /* deprecated */ |
#define XK_Cyrillic_je 0x6a8 |
#define XK_Serbian_je 0x6a8 /* deprecated */ |
#define XK_Cyrillic_lje 0x6a9 |
#define XK_Serbian_lje 0x6a9 /* deprecated */ |
#define XK_Cyrillic_nje 0x6aa |
#define XK_Serbian_nje 0x6aa /* deprecated */ |
#define XK_Serbian_tshe 0x6ab |
#define XK_Macedonia_kje 0x6ac |
#define XK_Ukrainian_ghe_with_upturn 0x6ad |
#define XK_Byelorussian_shortu 0x6ae |
#define XK_Cyrillic_dzhe 0x6af |
#define XK_Serbian_dze 0x6af /* deprecated */ |
#define XK_numerosign 0x6b0 |
#define XK_Serbian_DJE 0x6b1 |
#define XK_Macedonia_GJE 0x6b2 |
#define XK_Cyrillic_IO 0x6b3 |
#define XK_Ukrainian_IE 0x6b4 |
#define XK_Ukranian_JE 0x6b4 /* deprecated */ |
#define XK_Macedonia_DSE 0x6b5 |
#define XK_Ukrainian_I 0x6b6 |
#define XK_Ukranian_I 0x6b6 /* deprecated */ |
#define XK_Ukrainian_YI 0x6b7 |
#define XK_Ukranian_YI 0x6b7 /* deprecated */ |
#define XK_Cyrillic_JE 0x6b8 |
#define XK_Serbian_JE 0x6b8 /* deprecated */ |
#define XK_Cyrillic_LJE 0x6b9 |
#define XK_Serbian_LJE 0x6b9 /* deprecated */ |
#define XK_Cyrillic_NJE 0x6ba |
#define XK_Serbian_NJE 0x6ba /* deprecated */ |
#define XK_Serbian_TSHE 0x6bb |
#define XK_Macedonia_KJE 0x6bc |
#define XK_Ukrainian_GHE_WITH_UPTURN 0x6bd |
#define XK_Byelorussian_SHORTU 0x6be |
#define XK_Cyrillic_DZHE 0x6bf |
#define XK_Serbian_DZE 0x6bf /* deprecated */ |
#define XK_Cyrillic_yu 0x6c0 |
#define XK_Cyrillic_a 0x6c1 |
#define XK_Cyrillic_be 0x6c2 |
#define XK_Cyrillic_tse 0x6c3 |
#define XK_Cyrillic_de 0x6c4 |
#define XK_Cyrillic_ie 0x6c5 |
#define XK_Cyrillic_ef 0x6c6 |
#define XK_Cyrillic_ghe 0x6c7 |
#define XK_Cyrillic_ha 0x6c8 |
#define XK_Cyrillic_i 0x6c9 |
#define XK_Cyrillic_shorti 0x6ca |
#define XK_Cyrillic_ka 0x6cb |
#define XK_Cyrillic_el 0x6cc |
#define XK_Cyrillic_em 0x6cd |
#define XK_Cyrillic_en 0x6ce |
#define XK_Cyrillic_o 0x6cf |
#define XK_Cyrillic_pe 0x6d0 |
#define XK_Cyrillic_ya 0x6d1 |
#define XK_Cyrillic_er 0x6d2 |
#define XK_Cyrillic_es 0x6d3 |
#define XK_Cyrillic_te 0x6d4 |
#define XK_Cyrillic_u 0x6d5 |
#define XK_Cyrillic_zhe 0x6d6 |
#define XK_Cyrillic_ve 0x6d7 |
#define XK_Cyrillic_softsign 0x6d8 |
#define XK_Cyrillic_yeru 0x6d9 |
#define XK_Cyrillic_ze 0x6da |
#define XK_Cyrillic_sha 0x6db |
#define XK_Cyrillic_e 0x6dc |
#define XK_Cyrillic_shcha 0x6dd |
#define XK_Cyrillic_che 0x6de |
#define XK_Cyrillic_hardsign 0x6df |
#define XK_Cyrillic_YU 0x6e0 |
#define XK_Cyrillic_A 0x6e1 |
#define XK_Cyrillic_BE 0x6e2 |
#define XK_Cyrillic_TSE 0x6e3 |
#define XK_Cyrillic_DE 0x6e4 |
#define XK_Cyrillic_IE 0x6e5 |
#define XK_Cyrillic_EF 0x6e6 |
#define XK_Cyrillic_GHE 0x6e7 |
#define XK_Cyrillic_HA 0x6e8 |
#define XK_Cyrillic_I 0x6e9 |
#define XK_Cyrillic_SHORTI 0x6ea |
#define XK_Cyrillic_KA 0x6eb |
#define XK_Cyrillic_EL 0x6ec |
#define XK_Cyrillic_EM 0x6ed |
#define XK_Cyrillic_EN 0x6ee |
#define XK_Cyrillic_O 0x6ef |
#define XK_Cyrillic_PE 0x6f0 |
#define XK_Cyrillic_YA 0x6f1 |
#define XK_Cyrillic_ER 0x6f2 |
#define XK_Cyrillic_ES 0x6f3 |
#define XK_Cyrillic_TE 0x6f4 |
#define XK_Cyrillic_U 0x6f5 |
#define XK_Cyrillic_ZHE 0x6f6 |
#define XK_Cyrillic_VE 0x6f7 |
#define XK_Cyrillic_SOFTSIGN 0x6f8 |
#define XK_Cyrillic_YERU 0x6f9 |
#define XK_Cyrillic_ZE 0x6fa |
#define XK_Cyrillic_SHA 0x6fb |
#define XK_Cyrillic_E 0x6fc |
#define XK_Cyrillic_SHCHA 0x6fd |
#define XK_Cyrillic_CHE 0x6fe |
#define XK_Cyrillic_HARDSIGN 0x6ff |
#endif /* XK_CYRILLIC */ |
/* |
* Greek |
* Byte 3 = 7 |
*/ |
#ifdef XK_GREEK |
#define XK_Greek_ALPHAaccent 0x7a1 |
#define XK_Greek_EPSILONaccent 0x7a2 |
#define XK_Greek_ETAaccent 0x7a3 |
#define XK_Greek_IOTAaccent 0x7a4 |
#define XK_Greek_IOTAdieresis 0x7a5 |
#define XK_Greek_IOTAdiaeresis XK_Greek_IOTAdieresis /* old typo */ |
#define XK_Greek_OMICRONaccent 0x7a7 |
#define XK_Greek_UPSILONaccent 0x7a8 |
#define XK_Greek_UPSILONdieresis 0x7a9 |
#define XK_Greek_OMEGAaccent 0x7ab |
#define XK_Greek_accentdieresis 0x7ae |
#define XK_Greek_horizbar 0x7af |
#define XK_Greek_alphaaccent 0x7b1 |
#define XK_Greek_epsilonaccent 0x7b2 |
#define XK_Greek_etaaccent 0x7b3 |
#define XK_Greek_iotaaccent 0x7b4 |
#define XK_Greek_iotadieresis 0x7b5 |
#define XK_Greek_iotaaccentdieresis 0x7b6 |
#define XK_Greek_omicronaccent 0x7b7 |
#define XK_Greek_upsilonaccent 0x7b8 |
#define XK_Greek_upsilondieresis 0x7b9 |
#define XK_Greek_upsilonaccentdieresis 0x7ba |
#define XK_Greek_omegaaccent 0x7bb |
#define XK_Greek_ALPHA 0x7c1 |
#define XK_Greek_BETA 0x7c2 |
#define XK_Greek_GAMMA 0x7c3 |
#define XK_Greek_DELTA 0x7c4 |
#define XK_Greek_EPSILON 0x7c5 |
#define XK_Greek_ZETA 0x7c6 |
#define XK_Greek_ETA 0x7c7 |
#define XK_Greek_THETA 0x7c8 |
#define XK_Greek_IOTA 0x7c9 |
#define XK_Greek_KAPPA 0x7ca |
#define XK_Greek_LAMDA 0x7cb |
#define XK_Greek_LAMBDA 0x7cb |
#define XK_Greek_MU 0x7cc |
#define XK_Greek_NU 0x7cd |
#define XK_Greek_XI 0x7ce |
#define XK_Greek_OMICRON 0x7cf |
#define XK_Greek_PI 0x7d0 |
#define XK_Greek_RHO 0x7d1 |
#define XK_Greek_SIGMA 0x7d2 |
#define XK_Greek_TAU 0x7d4 |
#define XK_Greek_UPSILON 0x7d5 |
#define XK_Greek_PHI 0x7d6 |
#define XK_Greek_CHI 0x7d7 |
#define XK_Greek_PSI 0x7d8 |
#define XK_Greek_OMEGA 0x7d9 |
#define XK_Greek_alpha 0x7e1 |
#define XK_Greek_beta 0x7e2 |
#define XK_Greek_gamma 0x7e3 |
#define XK_Greek_delta 0x7e4 |
#define XK_Greek_epsilon 0x7e5 |
#define XK_Greek_zeta 0x7e6 |
#define XK_Greek_eta 0x7e7 |
#define XK_Greek_theta 0x7e8 |
#define XK_Greek_iota 0x7e9 |
#define XK_Greek_kappa 0x7ea |
#define XK_Greek_lamda 0x7eb |
#define XK_Greek_lambda 0x7eb |
#define XK_Greek_mu 0x7ec |
#define XK_Greek_nu 0x7ed |
#define XK_Greek_xi 0x7ee |
#define XK_Greek_omicron 0x7ef |
#define XK_Greek_pi 0x7f0 |
#define XK_Greek_rho 0x7f1 |
#define XK_Greek_sigma 0x7f2 |
#define XK_Greek_finalsmallsigma 0x7f3 |
#define XK_Greek_tau 0x7f4 |
#define XK_Greek_upsilon 0x7f5 |
#define XK_Greek_phi 0x7f6 |
#define XK_Greek_chi 0x7f7 |
#define XK_Greek_psi 0x7f8 |
#define XK_Greek_omega 0x7f9 |
#define XK_Greek_switch 0xFF7E /* Alias for mode_switch */ |
#endif /* XK_GREEK */ |
/* |
* Technical |
* Byte 3 = 8 |
*/ |
#ifdef XK_TECHNICAL |
#define XK_leftradical 0x8a1 |
#define XK_topleftradical 0x8a2 |
#define XK_horizconnector 0x8a3 |
#define XK_topintegral 0x8a4 |
#define XK_botintegral 0x8a5 |
#define XK_vertconnector 0x8a6 |
#define XK_topleftsqbracket 0x8a7 |
#define XK_botleftsqbracket 0x8a8 |
#define XK_toprightsqbracket 0x8a9 |
#define XK_botrightsqbracket 0x8aa |
#define XK_topleftparens 0x8ab |
#define XK_botleftparens 0x8ac |
#define XK_toprightparens 0x8ad |
#define XK_botrightparens 0x8ae |
#define XK_leftmiddlecurlybrace 0x8af |
#define XK_rightmiddlecurlybrace 0x8b0 |
#define XK_topleftsummation 0x8b1 |
#define XK_botleftsummation 0x8b2 |
#define XK_topvertsummationconnector 0x8b3 |
#define XK_botvertsummationconnector 0x8b4 |
#define XK_toprightsummation 0x8b5 |
#define XK_botrightsummation 0x8b6 |
#define XK_rightmiddlesummation 0x8b7 |
#define XK_lessthanequal 0x8bc |
#define XK_notequal 0x8bd |
#define XK_greaterthanequal 0x8be |
#define XK_integral 0x8bf |
#define XK_therefore 0x8c0 |
#define XK_variation 0x8c1 |
#define XK_infinity 0x8c2 |
#define XK_nabla 0x8c5 |
#define XK_approximate 0x8c8 |
#define XK_similarequal 0x8c9 |
#define XK_ifonlyif 0x8cd |
#define XK_implies 0x8ce |
#define XK_identical 0x8cf |
#define XK_radical 0x8d6 |
#define XK_includedin 0x8da |
#define XK_includes 0x8db |
#define XK_intersection 0x8dc |
#define XK_union 0x8dd |
#define XK_logicaland 0x8de |
#define XK_logicalor 0x8df |
#define XK_partialderivative 0x8ef |
#define XK_function 0x8f6 |
#define XK_leftarrow 0x8fb |
#define XK_uparrow 0x8fc |
#define XK_rightarrow 0x8fd |
#define XK_downarrow 0x8fe |
#endif /* XK_TECHNICAL */ |
/* |
* Special |
* Byte 3 = 9 |
*/ |
#ifdef XK_SPECIAL |
#define XK_blank 0x9df |
#define XK_soliddiamond 0x9e0 |
#define XK_checkerboard 0x9e1 |
#define XK_ht 0x9e2 |
#define XK_ff 0x9e3 |
#define XK_cr 0x9e4 |
#define XK_lf 0x9e5 |
#define XK_nl 0x9e8 |
#define XK_vt 0x9e9 |
#define XK_lowrightcorner 0x9ea |
#define XK_uprightcorner 0x9eb |
#define XK_upleftcorner 0x9ec |
#define XK_lowleftcorner 0x9ed |
#define XK_crossinglines 0x9ee |
#define XK_horizlinescan1 0x9ef |
#define XK_horizlinescan3 0x9f0 |
#define XK_horizlinescan5 0x9f1 |
#define XK_horizlinescan7 0x9f2 |
#define XK_horizlinescan9 0x9f3 |
#define XK_leftt 0x9f4 |
#define XK_rightt 0x9f5 |
#define XK_bott 0x9f6 |
#define XK_topt 0x9f7 |
#define XK_vertbar 0x9f8 |
#endif /* XK_SPECIAL */ |
/* |
* Publishing |
* Byte 3 = a |
*/ |
#ifdef XK_PUBLISHING |
#define XK_emspace 0xaa1 |
#define XK_enspace 0xaa2 |
#define XK_em3space 0xaa3 |
#define XK_em4space 0xaa4 |
#define XK_digitspace 0xaa5 |
#define XK_punctspace 0xaa6 |
#define XK_thinspace 0xaa7 |
#define XK_hairspace 0xaa8 |
#define XK_emdash 0xaa9 |
#define XK_endash 0xaaa |
#define XK_signifblank 0xaac |
#define XK_ellipsis 0xaae |
#define XK_doubbaselinedot 0xaaf |
#define XK_onethird 0xab0 |
#define XK_twothirds 0xab1 |
#define XK_onefifth 0xab2 |
#define XK_twofifths 0xab3 |
#define XK_threefifths 0xab4 |
#define XK_fourfifths 0xab5 |
#define XK_onesixth 0xab6 |
#define XK_fivesixths 0xab7 |
#define XK_careof 0xab8 |
#define XK_figdash 0xabb |
#define XK_leftanglebracket 0xabc |
#define XK_decimalpoint 0xabd |
#define XK_rightanglebracket 0xabe |
#define XK_marker 0xabf |
#define XK_oneeighth 0xac3 |
#define XK_threeeighths 0xac4 |
#define XK_fiveeighths 0xac5 |
#define XK_seveneighths 0xac6 |
#define XK_trademark 0xac9 |
#define XK_signaturemark 0xaca |
#define XK_trademarkincircle 0xacb |
#define XK_leftopentriangle 0xacc |
#define XK_rightopentriangle 0xacd |
#define XK_emopencircle 0xace |
#define XK_emopenrectangle 0xacf |
#define XK_leftsinglequotemark 0xad0 |
#define XK_rightsinglequotemark 0xad1 |
#define XK_leftdoublequotemark 0xad2 |
#define XK_rightdoublequotemark 0xad3 |
#define XK_prescription 0xad4 |
#define XK_minutes 0xad6 |
#define XK_seconds 0xad7 |
#define XK_latincross 0xad9 |
#define XK_hexagram 0xada |
#define XK_filledrectbullet 0xadb |
#define XK_filledlefttribullet 0xadc |
#define XK_filledrighttribullet 0xadd |
#define XK_emfilledcircle 0xade |
#define XK_emfilledrect 0xadf |
#define XK_enopencircbullet 0xae0 |
#define XK_enopensquarebullet 0xae1 |
#define XK_openrectbullet 0xae2 |
#define XK_opentribulletup 0xae3 |
#define XK_opentribulletdown 0xae4 |
#define XK_openstar 0xae5 |
#define XK_enfilledcircbullet 0xae6 |
#define XK_enfilledsqbullet 0xae7 |
#define XK_filledtribulletup 0xae8 |
#define XK_filledtribulletdown 0xae9 |
#define XK_leftpointer 0xaea |
#define XK_rightpointer 0xaeb |
#define XK_club 0xaec |
#define XK_diamond 0xaed |
#define XK_heart 0xaee |
#define XK_maltesecross 0xaf0 |
#define XK_dagger 0xaf1 |
#define XK_doubledagger 0xaf2 |
#define XK_checkmark 0xaf3 |
#define XK_ballotcross 0xaf4 |
#define XK_musicalsharp 0xaf5 |
#define XK_musicalflat 0xaf6 |
#define XK_malesymbol 0xaf7 |
#define XK_femalesymbol 0xaf8 |
#define XK_telephone 0xaf9 |
#define XK_telephonerecorder 0xafa |
#define XK_phonographcopyright 0xafb |
#define XK_caret 0xafc |
#define XK_singlelowquotemark 0xafd |
#define XK_doublelowquotemark 0xafe |
#define XK_cursor 0xaff |
#endif /* XK_PUBLISHING */ |
/* |
* APL |
* Byte 3 = b |
*/ |
#ifdef XK_APL |
#define XK_leftcaret 0xba3 |
#define XK_rightcaret 0xba6 |
#define XK_downcaret 0xba8 |
#define XK_upcaret 0xba9 |
#define XK_overbar 0xbc0 |
#define XK_downtack 0xbc2 |
#define XK_upshoe 0xbc3 |
#define XK_downstile 0xbc4 |
#define XK_underbar 0xbc6 |
#define XK_jot 0xbca |
#define XK_quad 0xbcc |
#define XK_uptack 0xbce |
#define XK_circle 0xbcf |
#define XK_upstile 0xbd3 |
#define XK_downshoe 0xbd6 |
#define XK_rightshoe 0xbd8 |
#define XK_leftshoe 0xbda |
#define XK_lefttack 0xbdc |
#define XK_righttack 0xbfc |
#endif /* XK_APL */ |
/* |
* Hebrew |
* Byte 3 = c |
*/ |
#ifdef XK_HEBREW |
#define XK_hebrew_doublelowline 0xcdf |
#define XK_hebrew_aleph 0xce0 |
#define XK_hebrew_bet 0xce1 |
#define XK_hebrew_beth 0xce1 /* deprecated */ |
#define XK_hebrew_gimel 0xce2 |
#define XK_hebrew_gimmel 0xce2 /* deprecated */ |
#define XK_hebrew_dalet 0xce3 |
#define XK_hebrew_daleth 0xce3 /* deprecated */ |
#define XK_hebrew_he 0xce4 |
#define XK_hebrew_waw 0xce5 |
#define XK_hebrew_zain 0xce6 |
#define XK_hebrew_zayin 0xce6 /* deprecated */ |
#define XK_hebrew_chet 0xce7 |
#define XK_hebrew_het 0xce7 /* deprecated */ |
#define XK_hebrew_tet 0xce8 |
#define XK_hebrew_teth 0xce8 /* deprecated */ |
#define XK_hebrew_yod 0xce9 |
#define XK_hebrew_finalkaph 0xcea |
#define XK_hebrew_kaph 0xceb |
#define XK_hebrew_lamed 0xcec |
#define XK_hebrew_finalmem 0xced |
#define XK_hebrew_mem 0xcee |
#define XK_hebrew_finalnun 0xcef |
#define XK_hebrew_nun 0xcf0 |
#define XK_hebrew_samech 0xcf1 |
#define XK_hebrew_samekh 0xcf1 /* deprecated */ |
#define XK_hebrew_ayin 0xcf2 |
#define XK_hebrew_finalpe 0xcf3 |
#define XK_hebrew_pe 0xcf4 |
#define XK_hebrew_finalzade 0xcf5 |
#define XK_hebrew_finalzadi 0xcf5 /* deprecated */ |
#define XK_hebrew_zade 0xcf6 |
#define XK_hebrew_zadi 0xcf6 /* deprecated */ |
#define XK_hebrew_qoph 0xcf7 |
#define XK_hebrew_kuf 0xcf7 /* deprecated */ |
#define XK_hebrew_resh 0xcf8 |
#define XK_hebrew_shin 0xcf9 |
#define XK_hebrew_taw 0xcfa |
#define XK_hebrew_taf 0xcfa /* deprecated */ |
#define XK_Hebrew_switch 0xFF7E /* Alias for mode_switch */ |
#endif /* XK_HEBREW */ |
/* |
* Thai |
* Byte 3 = d |
*/ |
#ifdef XK_THAI |
#define XK_Thai_kokai 0xda1 |
#define XK_Thai_khokhai 0xda2 |
#define XK_Thai_khokhuat 0xda3 |
#define XK_Thai_khokhwai 0xda4 |
#define XK_Thai_khokhon 0xda5 |
#define XK_Thai_khorakhang 0xda6 |
#define XK_Thai_ngongu 0xda7 |
#define XK_Thai_chochan 0xda8 |
#define XK_Thai_choching 0xda9 |
#define XK_Thai_chochang 0xdaa |
#define XK_Thai_soso 0xdab |
#define XK_Thai_chochoe 0xdac |
#define XK_Thai_yoying 0xdad |
#define XK_Thai_dochada 0xdae |
#define XK_Thai_topatak 0xdaf |
#define XK_Thai_thothan 0xdb0 |
#define XK_Thai_thonangmontho 0xdb1 |
#define XK_Thai_thophuthao 0xdb2 |
#define XK_Thai_nonen 0xdb3 |
#define XK_Thai_dodek 0xdb4 |
#define XK_Thai_totao 0xdb5 |
#define XK_Thai_thothung 0xdb6 |
#define XK_Thai_thothahan 0xdb7 |
#define XK_Thai_thothong 0xdb8 |
#define XK_Thai_nonu 0xdb9 |
#define XK_Thai_bobaimai 0xdba |
#define XK_Thai_popla 0xdbb |
#define XK_Thai_phophung 0xdbc |
#define XK_Thai_fofa 0xdbd |
#define XK_Thai_phophan 0xdbe |
#define XK_Thai_fofan 0xdbf |
#define XK_Thai_phosamphao 0xdc0 |
#define XK_Thai_moma 0xdc1 |
#define XK_Thai_yoyak 0xdc2 |
#define XK_Thai_rorua 0xdc3 |
#define XK_Thai_ru 0xdc4 |
#define XK_Thai_loling 0xdc5 |
#define XK_Thai_lu 0xdc6 |
#define XK_Thai_wowaen 0xdc7 |
#define XK_Thai_sosala 0xdc8 |
#define XK_Thai_sorusi 0xdc9 |
#define XK_Thai_sosua 0xdca |
#define XK_Thai_hohip 0xdcb |
#define XK_Thai_lochula 0xdcc |
#define XK_Thai_oang 0xdcd |
#define XK_Thai_honokhuk 0xdce |
#define XK_Thai_paiyannoi 0xdcf |
#define XK_Thai_saraa 0xdd0 |
#define XK_Thai_maihanakat 0xdd1 |
#define XK_Thai_saraaa 0xdd2 |
#define XK_Thai_saraam 0xdd3 |
#define XK_Thai_sarai 0xdd4 |
#define XK_Thai_saraii 0xdd5 |
#define XK_Thai_saraue 0xdd6 |
#define XK_Thai_sarauee 0xdd7 |
#define XK_Thai_sarau 0xdd8 |
#define XK_Thai_sarauu 0xdd9 |
#define XK_Thai_phinthu 0xdda |
#define XK_Thai_maihanakat_maitho 0xdde |
#define XK_Thai_baht 0xddf |
#define XK_Thai_sarae 0xde0 |
#define XK_Thai_saraae 0xde1 |
#define XK_Thai_sarao 0xde2 |
#define XK_Thai_saraaimaimuan 0xde3 |
#define XK_Thai_saraaimaimalai 0xde4 |
#define XK_Thai_lakkhangyao 0xde5 |
#define XK_Thai_maiyamok 0xde6 |
#define XK_Thai_maitaikhu 0xde7 |
#define XK_Thai_maiek 0xde8 |
#define XK_Thai_maitho 0xde9 |
#define XK_Thai_maitri 0xdea |
#define XK_Thai_maichattawa 0xdeb |
#define XK_Thai_thanthakhat 0xdec |
#define XK_Thai_nikhahit 0xded |
#define XK_Thai_leksun 0xdf0 |
#define XK_Thai_leknung 0xdf1 |
#define XK_Thai_leksong 0xdf2 |
#define XK_Thai_leksam 0xdf3 |
#define XK_Thai_leksi 0xdf4 |
#define XK_Thai_lekha 0xdf5 |
#define XK_Thai_lekhok 0xdf6 |
#define XK_Thai_lekchet 0xdf7 |
#define XK_Thai_lekpaet 0xdf8 |
#define XK_Thai_lekkao 0xdf9 |
#endif /* XK_THAI */ |
/* |
* Korean |
* Byte 3 = e |
*/ |
#ifdef XK_KOREAN |
#define XK_Hangul 0xff31 /* Hangul start/stop(toggle) */ |
#define XK_Hangul_Start 0xff32 /* Hangul start */ |
#define XK_Hangul_End 0xff33 /* Hangul end, English start */ |
#define XK_Hangul_Hanja 0xff34 /* Start Hangul->Hanja Conversion */ |
#define XK_Hangul_Jamo 0xff35 /* Hangul Jamo mode */ |
#define XK_Hangul_Romaja 0xff36 /* Hangul Romaja mode */ |
#define XK_Hangul_Codeinput 0xff37 /* Hangul code input mode */ |
#define XK_Hangul_Jeonja 0xff38 /* Jeonja mode */ |
#define XK_Hangul_Banja 0xff39 /* Banja mode */ |
#define XK_Hangul_PreHanja 0xff3a /* Pre Hanja conversion */ |
#define XK_Hangul_PostHanja 0xff3b /* Post Hanja conversion */ |
#define XK_Hangul_SingleCandidate 0xff3c /* Single candidate */ |
#define XK_Hangul_MultipleCandidate 0xff3d /* Multiple candidate */ |
#define XK_Hangul_PreviousCandidate 0xff3e /* Previous candidate */ |
#define XK_Hangul_Special 0xff3f /* Special symbols */ |
#define XK_Hangul_switch 0xFF7E /* Alias for mode_switch */ |
/* Hangul Consonant Characters */ |
#define XK_Hangul_Kiyeog 0xea1 |
#define XK_Hangul_SsangKiyeog 0xea2 |
#define XK_Hangul_KiyeogSios 0xea3 |
#define XK_Hangul_Nieun 0xea4 |
#define XK_Hangul_NieunJieuj 0xea5 |
#define XK_Hangul_NieunHieuh 0xea6 |
#define XK_Hangul_Dikeud 0xea7 |
#define XK_Hangul_SsangDikeud 0xea8 |
#define XK_Hangul_Rieul 0xea9 |
#define XK_Hangul_RieulKiyeog 0xeaa |
#define XK_Hangul_RieulMieum 0xeab |
#define XK_Hangul_RieulPieub 0xeac |
#define XK_Hangul_RieulSios 0xead |
#define XK_Hangul_RieulTieut 0xeae |
#define XK_Hangul_RieulPhieuf 0xeaf |
#define XK_Hangul_RieulHieuh 0xeb0 |
#define XK_Hangul_Mieum 0xeb1 |
#define XK_Hangul_Pieub 0xeb2 |
#define XK_Hangul_SsangPieub 0xeb3 |
#define XK_Hangul_PieubSios 0xeb4 |
#define XK_Hangul_Sios 0xeb5 |
#define XK_Hangul_SsangSios 0xeb6 |
#define XK_Hangul_Ieung 0xeb7 |
#define XK_Hangul_Jieuj 0xeb8 |
#define XK_Hangul_SsangJieuj 0xeb9 |
#define XK_Hangul_Cieuc 0xeba |
#define XK_Hangul_Khieuq 0xebb |
#define XK_Hangul_Tieut 0xebc |
#define XK_Hangul_Phieuf 0xebd |
#define XK_Hangul_Hieuh 0xebe |
/* Hangul Vowel Characters */ |
#define XK_Hangul_A 0xebf |
#define XK_Hangul_AE 0xec0 |
#define XK_Hangul_YA 0xec1 |
#define XK_Hangul_YAE 0xec2 |
#define XK_Hangul_EO 0xec3 |
#define XK_Hangul_E 0xec4 |
#define XK_Hangul_YEO 0xec5 |
#define XK_Hangul_YE 0xec6 |
#define XK_Hangul_O 0xec7 |
#define XK_Hangul_WA 0xec8 |
#define XK_Hangul_WAE 0xec9 |
#define XK_Hangul_OE 0xeca |
#define XK_Hangul_YO 0xecb |
#define XK_Hangul_U 0xecc |
#define XK_Hangul_WEO 0xecd |
#define XK_Hangul_WE 0xece |
#define XK_Hangul_WI 0xecf |
#define XK_Hangul_YU 0xed0 |
#define XK_Hangul_EU 0xed1 |
#define XK_Hangul_YI 0xed2 |
#define XK_Hangul_I 0xed3 |
/* Hangul syllable-final (JongSeong) Characters */ |
#define XK_Hangul_J_Kiyeog 0xed4 |
#define XK_Hangul_J_SsangKiyeog 0xed5 |
#define XK_Hangul_J_KiyeogSios 0xed6 |
#define XK_Hangul_J_Nieun 0xed7 |
#define XK_Hangul_J_NieunJieuj 0xed8 |
#define XK_Hangul_J_NieunHieuh 0xed9 |
#define XK_Hangul_J_Dikeud 0xeda |
#define XK_Hangul_J_Rieul 0xedb |
#define XK_Hangul_J_RieulKiyeog 0xedc |
#define XK_Hangul_J_RieulMieum 0xedd |
#define XK_Hangul_J_RieulPieub 0xede |
#define XK_Hangul_J_RieulSios 0xedf |
#define XK_Hangul_J_RieulTieut 0xee0 |
#define XK_Hangul_J_RieulPhieuf 0xee1 |
#define XK_Hangul_J_RieulHieuh 0xee2 |
#define XK_Hangul_J_Mieum 0xee3 |
#define XK_Hangul_J_Pieub 0xee4 |
#define XK_Hangul_J_PieubSios 0xee5 |
#define XK_Hangul_J_Sios 0xee6 |
#define XK_Hangul_J_SsangSios 0xee7 |
#define XK_Hangul_J_Ieung 0xee8 |
#define XK_Hangul_J_Jieuj 0xee9 |
#define XK_Hangul_J_Cieuc 0xeea |
#define XK_Hangul_J_Khieuq 0xeeb |
#define XK_Hangul_J_Tieut 0xeec |
#define XK_Hangul_J_Phieuf 0xeed |
#define XK_Hangul_J_Hieuh 0xeee |
/* Ancient Hangul Consonant Characters */ |
#define XK_Hangul_RieulYeorinHieuh 0xeef |
#define XK_Hangul_SunkyeongeumMieum 0xef0 |
#define XK_Hangul_SunkyeongeumPieub 0xef1 |
#define XK_Hangul_PanSios 0xef2 |
#define XK_Hangul_KkogjiDalrinIeung 0xef3 |
#define XK_Hangul_SunkyeongeumPhieuf 0xef4 |
#define XK_Hangul_YeorinHieuh 0xef5 |
/* Ancient Hangul Vowel Characters */ |
#define XK_Hangul_AraeA 0xef6 |
#define XK_Hangul_AraeAE 0xef7 |
/* Ancient Hangul syllable-final (JongSeong) Characters */ |
#define XK_Hangul_J_PanSios 0xef8 |
#define XK_Hangul_J_KkogjiDalrinIeung 0xef9 |
#define XK_Hangul_J_YeorinHieuh 0xefa |
/* Korean currency symbol */ |
#define XK_Korean_Won 0xeff |
#endif /* XK_KOREAN */ |
/* |
* Armenian |
* Byte 3 = 0x14 |
*/ |
#ifdef XK_ARMENIAN |
#define XK_Armenian_eternity 0x14a1 |
#define XK_Armenian_ligature_ew 0x14a2 |
#define XK_Armenian_full_stop 0x14a3 |
#define XK_Armenian_verjaket 0x14a3 |
#define XK_Armenian_parenright 0x14a4 |
#define XK_Armenian_parenleft 0x14a5 |
#define XK_Armenian_guillemotright 0x14a6 |
#define XK_Armenian_guillemotleft 0x14a7 |
#define XK_Armenian_em_dash 0x14a8 |
#define XK_Armenian_dot 0x14a9 |
#define XK_Armenian_mijaket 0x14a9 |
#define XK_Armenian_separation_mark 0x14aa |
#define XK_Armenian_but 0x14aa |
#define XK_Armenian_comma 0x14ab |
#define XK_Armenian_en_dash 0x14ac |
#define XK_Armenian_hyphen 0x14ad |
#define XK_Armenian_yentamna 0x14ad |
#define XK_Armenian_ellipsis 0x14ae |
#define XK_Armenian_exclam 0x14af |
#define XK_Armenian_amanak 0x14af |
#define XK_Armenian_accent 0x14b0 |
#define XK_Armenian_shesht 0x14b0 |
#define XK_Armenian_question 0x14b1 |
#define XK_Armenian_paruyk 0x14b1 |
#define XK_Armenian_AYB 0x14b2 |
#define XK_Armenian_ayb 0x14b3 |
#define XK_Armenian_BEN 0x14b4 |
#define XK_Armenian_ben 0x14b5 |
#define XK_Armenian_GIM 0x14b6 |
#define XK_Armenian_gim 0x14b7 |
#define XK_Armenian_DA 0x14b8 |
#define XK_Armenian_da 0x14b9 |
#define XK_Armenian_YECH 0x14ba |
#define XK_Armenian_yech 0x14bb |
#define XK_Armenian_ZA 0x14bc |
#define XK_Armenian_za 0x14bd |
#define XK_Armenian_E 0x14be |
#define XK_Armenian_e 0x14bf |
#define XK_Armenian_AT 0x14c0 |
#define XK_Armenian_at 0x14c1 |
#define XK_Armenian_TO 0x14c2 |
#define XK_Armenian_to 0x14c3 |
#define XK_Armenian_ZHE 0x14c4 |
#define XK_Armenian_zhe 0x14c5 |
#define XK_Armenian_INI 0x14c6 |
#define XK_Armenian_ini 0x14c7 |
#define XK_Armenian_LYUN 0x14c8 |
#define XK_Armenian_lyun 0x14c9 |
#define XK_Armenian_KHE 0x14ca |
#define XK_Armenian_khe 0x14cb |
#define XK_Armenian_TSA 0x14cc |
#define XK_Armenian_tsa 0x14cd |
#define XK_Armenian_KEN 0x14ce |
#define XK_Armenian_ken 0x14cf |
#define XK_Armenian_HO 0x14d0 |
#define XK_Armenian_ho 0x14d1 |
#define XK_Armenian_DZA 0x14d2 |
#define XK_Armenian_dza 0x14d3 |
#define XK_Armenian_GHAT 0x14d4 |
#define XK_Armenian_ghat 0x14d5 |
#define XK_Armenian_TCHE 0x14d6 |
#define XK_Armenian_tche 0x14d7 |
#define XK_Armenian_MEN 0x14d8 |
#define XK_Armenian_men 0x14d9 |
#define XK_Armenian_HI 0x14da |
#define XK_Armenian_hi 0x14db |
#define XK_Armenian_NU 0x14dc |
#define XK_Armenian_nu 0x14dd |
#define XK_Armenian_SHA 0x14de |
#define XK_Armenian_sha 0x14df |
#define XK_Armenian_VO 0x14e0 |
#define XK_Armenian_vo 0x14e1 |
#define XK_Armenian_CHA 0x14e2 |
#define XK_Armenian_cha 0x14e3 |
#define XK_Armenian_PE 0x14e4 |
#define XK_Armenian_pe 0x14e5 |
#define XK_Armenian_JE 0x14e6 |
#define XK_Armenian_je 0x14e7 |
#define XK_Armenian_RA 0x14e8 |
#define XK_Armenian_ra 0x14e9 |
#define XK_Armenian_SE 0x14ea |
#define XK_Armenian_se 0x14eb |
#define XK_Armenian_VEV 0x14ec |
#define XK_Armenian_vev 0x14ed |
#define XK_Armenian_TYUN 0x14ee |
#define XK_Armenian_tyun 0x14ef |
#define XK_Armenian_RE 0x14f0 |
#define XK_Armenian_re 0x14f1 |
#define XK_Armenian_TSO 0x14f2 |
#define XK_Armenian_tso 0x14f3 |
#define XK_Armenian_VYUN 0x14f4 |
#define XK_Armenian_vyun 0x14f5 |
#define XK_Armenian_PYUR 0x14f6 |
#define XK_Armenian_pyur 0x14f7 |
#define XK_Armenian_KE 0x14f8 |
#define XK_Armenian_ke 0x14f9 |
#define XK_Armenian_O 0x14fa |
#define XK_Armenian_o 0x14fb |
#define XK_Armenian_FE 0x14fc |
#define XK_Armenian_fe 0x14fd |
#define XK_Armenian_apostrophe 0x14fe |
#define XK_Armenian_section_sign 0x14ff |
#endif /* XK_ARMENIAN */ |
/* |
* Georgian |
* Byte 3 = 0x15 |
*/ |
#ifdef XK_GEORGIAN |
#define XK_Georgian_an 0x15d0 |
#define XK_Georgian_ban 0x15d1 |
#define XK_Georgian_gan 0x15d2 |
#define XK_Georgian_don 0x15d3 |
#define XK_Georgian_en 0x15d4 |
#define XK_Georgian_vin 0x15d5 |
#define XK_Georgian_zen 0x15d6 |
#define XK_Georgian_tan 0x15d7 |
#define XK_Georgian_in 0x15d8 |
#define XK_Georgian_kan 0x15d9 |
#define XK_Georgian_las 0x15da |
#define XK_Georgian_man 0x15db |
#define XK_Georgian_nar 0x15dc |
#define XK_Georgian_on 0x15dd |
#define XK_Georgian_par 0x15de |
#define XK_Georgian_zhar 0x15df |
#define XK_Georgian_rae 0x15e0 |
#define XK_Georgian_san 0x15e1 |
#define XK_Georgian_tar 0x15e2 |
#define XK_Georgian_un 0x15e3 |
#define XK_Georgian_phar 0x15e4 |
#define XK_Georgian_khar 0x15e5 |
#define XK_Georgian_ghan 0x15e6 |
#define XK_Georgian_qar 0x15e7 |
#define XK_Georgian_shin 0x15e8 |
#define XK_Georgian_chin 0x15e9 |
#define XK_Georgian_can 0x15ea |
#define XK_Georgian_jil 0x15eb |
#define XK_Georgian_cil 0x15ec |
#define XK_Georgian_char 0x15ed |
#define XK_Georgian_xan 0x15ee |
#define XK_Georgian_jhan 0x15ef |
#define XK_Georgian_hae 0x15f0 |
#define XK_Georgian_he 0x15f1 |
#define XK_Georgian_hie 0x15f2 |
#define XK_Georgian_we 0x15f3 |
#define XK_Georgian_har 0x15f4 |
#define XK_Georgian_hoe 0x15f5 |
#define XK_Georgian_fi 0x15f6 |
#endif /* XK_GEORGIAN */ |
/* |
* Azeri (and other Turkic or Caucasian languages of ex-USSR) |
* Byte 3 = 0x16 |
*/ |
#ifdef XK_CAUCASUS |
/* latin */ |
#define XK_Ccedillaabovedot 0x16a2 |
#define XK_Xabovedot 0x16a3 |
#define XK_Qabovedot 0x16a5 |
#define XK_Ibreve 0x16a6 |
#define XK_IE 0x16a7 |
#define XK_UO 0x16a8 |
#define XK_Zstroke 0x16a9 |
#define XK_Gcaron 0x16aa |
#define XK_Obarred 0x16af |
#define XK_ccedillaabovedot 0x16b2 |
#define XK_xabovedot 0x16b3 |
#define XK_Ocaron 0x16b4 |
#define XK_qabovedot 0x16b5 |
#define XK_ibreve 0x16b6 |
#define XK_ie 0x16b7 |
#define XK_uo 0x16b8 |
#define XK_zstroke 0x16b9 |
#define XK_gcaron 0x16ba |
#define XK_ocaron 0x16bd |
#define XK_obarred 0x16bf |
#define XK_SCHWA 0x16c6 |
#define XK_schwa 0x16f6 |
/* those are not really Caucasus, but I put them here for now */ |
/* For Inupiak */ |
#define XK_Lbelowdot 0x16d1 |
#define XK_Lstrokebelowdot 0x16d2 |
#define XK_lbelowdot 0x16e1 |
#define XK_lstrokebelowdot 0x16e2 |
/* For Guarani */ |
#define XK_Gtilde 0x16d3 |
#define XK_gtilde 0x16e3 |
#endif /* XK_CAUCASUS */ |
/* |
* Vietnamese |
* Byte 3 = 0x1e |
*/ |
#ifdef XK_VIETNAMESE |
#define XK_Abelowdot 0x1ea0 |
#define XK_abelowdot 0x1ea1 |
#define XK_Ahook 0x1ea2 |
#define XK_ahook 0x1ea3 |
#define XK_Acircumflexacute 0x1ea4 |
#define XK_acircumflexacute 0x1ea5 |
#define XK_Acircumflexgrave 0x1ea6 |
#define XK_acircumflexgrave 0x1ea7 |
#define XK_Acircumflexhook 0x1ea8 |
#define XK_acircumflexhook 0x1ea9 |
#define XK_Acircumflextilde 0x1eaa |
#define XK_acircumflextilde 0x1eab |
#define XK_Acircumflexbelowdot 0x1eac |
#define XK_acircumflexbelowdot 0x1ead |
#define XK_Abreveacute 0x1eae |
#define XK_abreveacute 0x1eaf |
#define XK_Abrevegrave 0x1eb0 |
#define XK_abrevegrave 0x1eb1 |
#define XK_Abrevehook 0x1eb2 |
#define XK_abrevehook 0x1eb3 |
#define XK_Abrevetilde 0x1eb4 |
#define XK_abrevetilde 0x1eb5 |
#define XK_Abrevebelowdot 0x1eb6 |
#define XK_abrevebelowdot 0x1eb7 |
#define XK_Ebelowdot 0x1eb8 |
#define XK_ebelowdot 0x1eb9 |
#define XK_Ehook 0x1eba |
#define XK_ehook 0x1ebb |
#define XK_Etilde 0x1ebc |
#define XK_etilde 0x1ebd |
#define XK_Ecircumflexacute 0x1ebe |
#define XK_ecircumflexacute 0x1ebf |
#define XK_Ecircumflexgrave 0x1ec0 |
#define XK_ecircumflexgrave 0x1ec1 |
#define XK_Ecircumflexhook 0x1ec2 |
#define XK_ecircumflexhook 0x1ec3 |
#define XK_Ecircumflextilde 0x1ec4 |
#define XK_ecircumflextilde 0x1ec5 |
#define XK_Ecircumflexbelowdot 0x1ec6 |
#define XK_ecircumflexbelowdot 0x1ec7 |
#define XK_Ihook 0x1ec8 |
#define XK_ihook 0x1ec9 |
#define XK_Ibelowdot 0x1eca |
#define XK_ibelowdot 0x1ecb |
#define XK_Obelowdot 0x1ecc |
#define XK_obelowdot 0x1ecd |
#define XK_Ohook 0x1ece |
#define XK_ohook 0x1ecf |
#define XK_Ocircumflexacute 0x1ed0 |
#define XK_ocircumflexacute 0x1ed1 |
#define XK_Ocircumflexgrave 0x1ed2 |
#define XK_ocircumflexgrave 0x1ed3 |
#define XK_Ocircumflexhook 0x1ed4 |
#define XK_ocircumflexhook 0x1ed5 |
#define XK_Ocircumflextilde 0x1ed6 |
#define XK_ocircumflextilde 0x1ed7 |
#define XK_Ocircumflexbelowdot 0x1ed8 |
#define XK_ocircumflexbelowdot 0x1ed9 |
#define XK_Ohornacute 0x1eda |
#define XK_ohornacute 0x1edb |
#define XK_Ohorngrave 0x1edc |
#define XK_ohorngrave 0x1edd |
#define XK_Ohornhook 0x1ede |
#define XK_ohornhook 0x1edf |
#define XK_Ohorntilde 0x1ee0 |
#define XK_ohorntilde 0x1ee1 |
#define XK_Ohornbelowdot 0x1ee2 |
#define XK_ohornbelowdot 0x1ee3 |
#define XK_Ubelowdot 0x1ee4 |
#define XK_ubelowdot 0x1ee5 |
#define XK_Uhook 0x1ee6 |
#define XK_uhook 0x1ee7 |
#define XK_Uhornacute 0x1ee8 |
#define XK_uhornacute 0x1ee9 |
#define XK_Uhorngrave 0x1eea |
#define XK_uhorngrave 0x1eeb |
#define XK_Uhornhook 0x1eec |
#define XK_uhornhook 0x1eed |
#define XK_Uhorntilde 0x1eee |
#define XK_uhorntilde 0x1eef |
#define XK_Uhornbelowdot 0x1ef0 |
#define XK_uhornbelowdot 0x1ef1 |
#define XK_Ybelowdot 0x1ef4 |
#define XK_ybelowdot 0x1ef5 |
#define XK_Yhook 0x1ef6 |
#define XK_yhook 0x1ef7 |
#define XK_Ytilde 0x1ef8 |
#define XK_ytilde 0x1ef9 |
#define XK_Ohorn 0x1efa /* U+01a0 */ |
#define XK_ohorn 0x1efb /* U+01a1 */ |
#define XK_Uhorn 0x1efc /* U+01af */ |
#define XK_uhorn 0x1efd /* U+01b0 */ |
#define XK_combining_tilde 0x1e9f /* U+0303 */ |
#define XK_combining_grave 0x1ef2 /* U+0300 */ |
#define XK_combining_acute 0x1ef3 /* U+0301 */ |
#define XK_combining_hook 0x1efe /* U+0309 */ |
#define XK_combining_belowdot 0x1eff /* U+0323 */ |
#endif /* XK_VIETNAMESE */ |
#ifdef XK_CURRENCY |
#define XK_EcuSign 0x20a0 |
#define XK_ColonSign 0x20a1 |
#define XK_CruzeiroSign 0x20a2 |
#define XK_FFrancSign 0x20a3 |
#define XK_LiraSign 0x20a4 |
#define XK_MillSign 0x20a5 |
#define XK_NairaSign 0x20a6 |
#define XK_PesetaSign 0x20a7 |
#define XK_RupeeSign 0x20a8 |
#define XK_WonSign 0x20a9 |
#define XK_NewSheqelSign 0x20aa |
#define XK_DongSign 0x20ab |
#define XK_EuroSign 0x20ac |
#endif |
#endif //_INCLUDE_KEY_SYM_H |
/programs/games/checkers/trunk/makefile |
---|
0,0 → 1,4 |
checkers : checkers.o |
g++ -L/usr/X11R6/lib -lX11 -o checkers checkers.o |
checkers.o : checkers.cpp board.h position.h player.h tmplayer.h buttons.h history.h hash.h gr-draw.h gnu-draw.h sysproc.h |
g++ -c checkers.cpp |
/programs/games/checkers/trunk/me_make.inc |
---|
0,0 → 1,10 |
;//NAME// checkers.cpp |
;//COMPILER// bcc32 -S -v- -R- -6 -a4 -O2 -Og -Oi -Ov -OS -k- -D__MENUET__ -Iinclude |
;//UTIL_PATH// . |
STACKSIZE equ 102400 |
HEAPSIZE equ 102400 |
include "include\me_start.inc" |
include "include\me_func.inc" |
include "include\me_heap.inc" |
/programs/games/checkers/trunk/mt-draw.h |
---|
0,0 → 1,79 |
unsigned long cur_color; |
class TKlbrGraphDraw : public TGraphDraw |
{ |
public: |
virtual int SetColor(unsigned long c) {cur_color=c;return 1;} |
virtual int DrawLine(int x0, int y0, int x1, int y1); |
virtual int DrawText(int x0, int y0, char* text); |
virtual int IsDraw(void) {return 1;} |
virtual int DrawClear(); |
virtual unsigned long CreateColor(unsigned short red, |
unsigned short green, unsigned short blue); |
virtual void GetSize(int &w, int &h); |
virtual int GetTextH(const char *s) {return 10;} |
virtual int GetTextW(const char *s) {return 6 * strlen(s);} |
virtual void Quit(int q = 1) {CloseWindow();} |
}; |
int TKlbrGraphDraw::DrawLine(int x0, int y0, int x1, int y1) |
{ |
asm mov ebx, x0 |
asm shl ebx, 16 |
asm add ebx, x1 |
asm mov ecx, y0 |
asm shl ecx, 16 |
asm add ecx, y1 |
asm mov edx, [cur_color] |
asm push 38 |
asm pop eax |
asm int 40h |
return 1; |
} |
int TKlbrGraphDraw::DrawText(int x0, int y0, char* text) |
{ |
asm mov ebx, x0 |
asm shl ebx, 16 |
asm add ebx, y0 |
asm mov ecx, [cur_color] |
asm or ecx, 0xC0000000 |
asm mov edx, text |
asm mov edi, 0xFFFFFF |
asm push 4 |
asm pop eax |
asm int 40h |
return 1; |
} |
int TKlbrGraphDraw::DrawClear(void) |
{ |
int w,h; |
GetSize(w,h); |
asm mov ebx, w |
asm mov ecx, h |
asm mov edx, 0xFFFFFF |
asm push 13 |
asm pop eax |
asm int 40h |
return 1; |
} |
unsigned long TKlbrGraphDraw::CreateColor(unsigned short red, |
unsigned short green, unsigned short blue) |
{ |
return (unsigned long)(blue >> 8) + ((unsigned long)(green >> 8) << 8) + |
((unsigned long)(red >> 8) << 16); |
} |
void TKlbrGraphDraw::GetSize(int &w, int &h) |
{ |
int width, height; |
asm sub esp, 1024 |
asm mov ebx, esp |
asm or ecx, -1 |
asm push 9 |
asm pop eax |
asm int 40h |
asm mov eax, [esp+62] |
asm mov width, eax |
asm mov eax, [esp+66] |
asm mov height, eax |
asm add esp, 1024 |
w = width; |
h = height; |
} |
/programs/games/checkers/trunk/player.h |
---|
0,0 → 1,888 |
#ifndef _HEADER_PLAYER_H |
#define _HEADER_PLAYER_H |
#include "position.h" |
#include "sysproc.h" |
#ifndef __MENUET__ |
#include <stdlib.h> |
#include <stdio.h> |
#include <assert.h> |
#endif |
template <class tvalue> |
class TBaseCompPlayer : public TChPlayer |
{ |
public: |
static const int PKind; |
static const tvalue win_val; |
public: |
TBaseCompPlayer() : draw(0), data(0) {} |
virtual int PlayerID() {return PKind;} |
virtual int Move(PMv &pmv); |
struct PMvv : public PMv |
{ |
tvalue val; |
}; |
struct Z |
{ |
Z(int marr = 400) : narr(0), marr(marr) {array = new PMvv[marr];} |
~Z() {Clear();} |
void Clear() {if (array) {delete[] array; array = 0;} marr = 0; narr = 0;} |
void AddPos(int n); |
void AddPos() {AddPos(narr + 1);} |
int FindAllMoves(PMv pmv, int onlyeat = 0); |
void FindSideEats(PMv &pmv, int k, int sx, int sy); |
static int ComparePMv(const void *v1, const void *v2); |
void Sort(int n0, int n1); |
int marr, narr; |
PMvv *array; |
}; |
static tvalue GetLossValue(const Position &pos); |
virtual tvalue GetValue(const Position &pos, int num = 0); |
tvalue GetFullValue(const Position &pos, int num = 0); |
tvalue FindBMove(Z &z, int num, PMvv *pmv, int zn = -1, |
tvalue a = -2 * win_val, tvalue b = 2 * win_val); |
public: |
void (*draw)(void*, int = 0); |
void *data; |
}; |
template <class tvalue> |
const int TBaseCompPlayer<tvalue>::PKind = 0x2000; |
template <class tvalue> |
const tvalue TBaseCompPlayer<tvalue>::win_val = (tvalue)10000000L; |
template <class tvalue> |
void TBaseCompPlayer<tvalue>::Z::AddPos(int n) |
{ |
if (marr < n) |
{ |
int m0 = marr; |
PMvv *arr0 = array; |
marr = 2*n + 10; |
array = new PMvv[marr]; |
if (arr0) |
{ |
int i; |
for (i = 0; i < m0; i++) array[i] = arr0[i]; |
delete[] arr0; |
} |
} |
} |
template <class tvalue> |
void TBaseCompPlayer<tvalue>::Z::FindSideEats(PMv &pmv, int k, int sx, int sy) |
{ |
int x, y; |
NumToPole(k, x, y); |
if (pmv.pos.SH[k] == pmv.pos.wmove + 1) |
{ |
int xx = x + 2*sx, yy = y + 2*sy; |
if (xx >= 0 && xx < NW_CELL && yy >= 0 && yy < NW_CELL) |
{ |
int kk = PoleToNum(xx, yy); |
if (pmv.pos.SH[kk] == 0) |
{ |
int k1 = PoleToNum(x + sx, y + sy); |
char nk1 = pmv.pos.SH[k1]; |
if (nk1 == 2 - pmv.pos.wmove || nk1 == 4 - pmv.pos.wmove) |
{ |
char SH_k1 = pmv.pos.SH[k1]; |
pmv.pos.Del(k1); pmv.pos.Move(k, kk); |
if (pmv.pos.wmove == 0 && yy == NW_CELL - 1 || |
pmv.pos.wmove == 1 && yy == 0) pmv.pos.SH[kk] += (char)2; |
pmv.mv[++pmv.mv[0]] = (char)kk; |
int nold = narr; |
FindSideEats(pmv, kk, sx, sy); |
FindSideEats(pmv, kk, sy, -sx); |
FindSideEats(pmv, kk, -sy, sx); |
if (narr == nold) |
{ |
AddPos(); |
(PMv&)array[narr] = pmv; |
array[narr].pos.wmove = !pmv.pos.wmove; |
narr++; |
} |
pmv.mv[0]--; |
pmv.pos.SH[k1] = SH_k1; pmv.pos.Del(kk); |
pmv.pos.SH[k] = char(pmv.pos.wmove + 1); |
} |
} |
} |
} |
else if (pmv.pos.SH[k] == pmv.pos.wmove + 3) |
{ |
int i, i0, i1; |
if (sx < 0) i0 = x; |
else i0 = NW_CELL - x - 1; |
if (sy < 0) i1 = y; |
else i1 = NW_CELL - y - 1; |
if (i0 > i1) i0 = i1; |
if (i0 >= 2) |
{ |
pmv.pos.Del(k); |
pmv.mv[0]++; |
i1 = -1; |
int kk, kk1; |
char SH_kk1; |
int nold = narr; |
for (i = 1; i <= i0; i++) |
{ |
kk = PoleToNum(x + i*sx, y + i*sy); |
char chh = pmv.pos.SH[kk]; |
if (chh) |
{ |
if (i1 >= 0 || (chh != 2 - pmv.pos.wmove && chh != 4 - pmv.pos.wmove)) break; |
else |
{ |
i1 = i; kk1 = kk; |
SH_kk1 = chh; |
pmv.pos.Del(kk1); |
} |
} |
else if (i1 >= 0) |
{ |
pmv.pos.SH[kk] = char(pmv.pos.wmove + 3); |
pmv.mv[pmv.mv[0]] = (char)kk; |
if (i == i1+1) FindSideEats(pmv, kk, sx, sy); |
FindSideEats(pmv, kk, sy, -sx); |
FindSideEats(pmv, kk, -sy, sx); |
pmv.pos.Del(kk); |
} |
} |
if (narr == nold && i1 >= 0) |
{ |
while (--i > i1) |
{ |
kk = PoleToNum(x + i*sx, y + i*sy); |
AddPos(); |
(PMv&)array[narr] = pmv; |
array[narr].pos.SH[kk] = char(pmv.pos.wmove + 3); |
array[narr].mv[pmv.mv[0]] = (char)kk; |
array[narr].pos.wmove = !pmv.pos.wmove; |
narr++; |
} |
} |
pmv.mv[0]--; |
pmv.pos.SH[k] = char(pmv.pos.wmove + 3); |
if (i1 >= 0) pmv.pos.SH[kk1] = SH_kk1; |
} |
} |
} |
template <class tvalue> |
int TBaseCompPlayer<tvalue>::Z::FindAllMoves(PMv pmv, int onlyeat) |
{ |
int k, nold = narr, was_eat = 1; |
pmv.mv[0] = 1; |
for (k = 0; k < NUM_CELL; k++) |
{ |
if (pmv.pos.SH[k] == pmv.pos.wmove + 1 || pmv.pos.SH[k] == pmv.pos.wmove + 3) |
{ |
pmv.mv[1] = (char)k; |
FindSideEats(pmv, k, 1, 1); |
FindSideEats(pmv, k, 1, -1); |
FindSideEats(pmv, k, -1, 1); |
FindSideEats(pmv, k, -1, -1); |
} |
} |
if (narr == nold) |
{ |
was_eat = 0; |
if (!onlyeat) |
{ |
pmv.mv[0] = 2; |
for (k = 0; k < NUM_CELL; k++) |
{ |
if (pmv.pos.SH[k] == pmv.pos.wmove + 1) |
{ |
pmv.mv[1] = (char)k; |
int x, x0, x1, y; |
NumToPole(k, x0, y); |
if (pmv.pos.wmove == 1) y--; else y++; |
if (y >= 0 && y < NW_CELL) |
{ |
int kk; |
x1 = (x0--) + 1; |
for (x = x0; x <= x1; x += 2) if (x >= 0 && x < NW_CELL) |
{ |
kk = PoleToNum(x, y); |
if (pmv.pos.SH[kk] == 0) |
{ |
AddPos(); |
(PMv&)array[narr] = pmv; |
array[narr].pos.Del(k); |
if (pmv.pos.wmove == 0 && y == NW_CELL - 1 || |
pmv.pos.wmove == 1 && y == 0) |
{ |
array[narr].pos.Add(kk, char(pmv.pos.wmove + 3)); |
} |
else array[narr].pos.Add(kk, char(pmv.pos.wmove + 1)); |
array[narr].mv[2] = (char)kk; |
array[narr].pos.wmove = !pmv.pos.wmove; |
narr++; |
} |
} |
} |
} |
else if (pmv.pos.SH[k] == pmv.pos.wmove + 3) |
{ |
pmv.mv[1] = (char)k; |
int x, y, sx, sy; |
NumToPole(k, x, y); |
for (sx = -1; sx <= 1; sx += 2) if (x + sx >= 0 && x + sx < NW_CELL) |
{ |
for (sy = -1; sy <= 1; sy += 2) if (y + sy >= 0 && y + sy < NW_CELL) |
{ |
int i, i0, i1; |
if (sx < 0) i0 = x; |
else i0 = NW_CELL - x - 1; |
if (sy < 0) i1 = y; |
else i1 = NW_CELL - y - 1; |
if (i0 > i1) i0 = i1; |
for (i = 1; i <= i0; i++) |
{ |
int kk = PoleToNum(x + i*sx, y + i*sy); |
if (pmv.pos.SH[kk]) break; |
AddPos(); |
(PMv&)array[narr] = pmv; |
array[narr].pos.Move(k, kk); |
array[narr].mv[2] = (char)kk; |
array[narr].pos.wmove = !pmv.pos.wmove; |
narr++; |
} |
} |
} |
} |
} |
} |
} |
pmv.mv[0] = 0; |
return was_eat; |
} |
template <class tvalue> |
int TBaseCompPlayer<tvalue>::Z::ComparePMv(const void *v1, const void *v2) |
{ |
PMvv *pmv1 = (PMvv*)v1, *pmv2 = (PMvv*)v2; |
if (pmv1->val < pmv2->val) return -1; |
else if (pmv1->val > pmv2->val) return 1; |
else return 0; |
} |
template <class tvalue> |
void TBaseCompPlayer<tvalue>::Z::Sort(int n0, int n1) |
{ |
qsort(array + n0, n1 - n0, sizeof(PMvv), ComparePMv); |
} |
template <class tvalue> |
tvalue TBaseCompPlayer<tvalue>::GetLossValue(const Position &pos) |
{ |
tvalue val = -win_val - 1000021L; |
for (int i = 0; i < NUM_CELL; i++) |
{ |
if (pos.SH[i] == 1 + pos.wmove) val -= 10000L; |
else if (pos.SH[i] == 2 - pos.wmove) val -= 100L; |
else if (pos.SH[i] == 3 + pos.wmove) val -= 80000L; |
else if (pos.SH[i] == 4 - pos.wmove) val -= 100L; |
} |
return val; |
} |
template <class tvalue> |
tvalue TBaseCompPlayer<tvalue>::GetValue(const Position &pos, int num) |
{ |
tvalue val = 0; |
if (num == 0) |
{ |
int NumDM0 = 0, NumDM1 = 0; |
for (int i = 0; i < NUM_CELL; i++) |
{ |
short PreimSHPos[32] = {243, 243, 243, 245, |
240, 240, 240, 240, |
244, 244, 244, 244, |
245, 248, 248, 245, |
249, 250, 250, 248, |
256, 260, 260, 256, |
280, 280, 280, 260, |
280, 280, 280, 280}; |
if (pos.SH[i] == 1 + pos.wmove) |
{ |
val += PreimSHPos[pos.wmove ? (NUM_CELL - 1 - i) : i]; |
} |
else if (pos.SH[i] == 2 - pos.wmove) |
{ |
val -= PreimSHPos[pos.wmove ? i : (NUM_CELL - 1 - i)]; |
} |
else if (pos.SH[i] == 3 + pos.wmove) NumDM1++; |
else if (pos.SH[i] == 4 - pos.wmove) NumDM0++; |
} |
if (NumDM1 > 0) |
{ |
val += 560; NumDM1--; |
if (NumDM1 > 0) |
{ |
val += 432; NumDM1--; |
val += NumDM1 * 384; |
} |
} |
if (NumDM0 > 0) |
{ |
val -= 560; NumDM0--; |
if (NumDM0 > 0) |
{ |
val -= 432; NumDM0--; |
val -= NumDM0 * 384; |
} |
} |
} |
if (num == 1) |
{ |
char NSH1 = 0, NSH0 = 0, NDM1 = 0, NDM0 = 0; |
int i; |
for (i = 0; i < 32; i++) |
{ |
if (pos.SH[i] == 1 + pos.wmove) NSH1++; |
else if (pos.SH[i] == 2 - pos.wmove) NSH0++; |
else if (pos.SH[i] == 3 + pos.wmove) NDM1++; |
else if (pos.SH[i] == 4 - pos.wmove) NDM0++; |
} |
if (NDM1 > 0 && NDM0 > 0 && NSH1 + NSH0 < 3) |
{ |
unsigned char HwoBD = 0; |
char Sh0BD = 1, Sh1BD = 1; |
for (i = 0; i < 8; i++) |
{ |
char ShBD = pos.SH[PoleToNum(i, 7 - i)]; |
if (ShBD == 1 + pos.wmove) Sh1BD++; |
else if (ShBD == 2 - pos.wmove) Sh0BD++; |
else if (ShBD == 3 + pos.wmove) HwoBD |= 2; |
else if (ShBD == 4 - pos.wmove) HwoBD |= 1; |
} |
if (HwoBD == 2) val += 128 / Sh0BD; |
if (HwoBD == 1) val -= 128 / Sh1BD; |
if (NDM1 >= 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0 && HwoBD == 1) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (i = 0; i < 4; i++) |
{ |
Add |= char((pos.SH[Best4P[i][0]] == 3 + pos.wmove) * 3 + |
(pos.SH[Best4P[i][1]] == 3 + pos.wmove)); |
} |
if (Add >= 4) val += 32; |
else if (Add == 3) val += 24; |
else if (Add >= 1) val += 16; |
} |
else if (NDM0 >= 3 && NDM1 == 1 && NSH0 == 0 && NSH1 == 0 && HwoBD == 2) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (i = 0; i < 4; i++) |
{ |
Add |= char((pos.SH[Best4P[i][0]] == 4 - pos.wmove) * 3 + |
(pos.SH[Best4P[i][1]] == 4 - pos.wmove)); |
} |
if (Add >= 4) val -= 32; |
else if (Add == 3) val -= 24; |
else if (Add >= 1) val -= 16; |
} |
} |
else |
{ |
for (i = 0; i < NUM_CELL; i++) |
{ |
char Color = char(pos.SH[i] - 1); |
if (Color == 0 || Color == 1) |
{ |
char qi = Color ? char(NUM_CELL - 1 - i) : char(i); |
char Zn = Color ? char(-1) : char(1); |
char PreZ = (Color == pos.wmove) ? char(1) : char(-1); |
if (pos.SH[i + Zn * 8] != 2 - Color) |
{ |
if (qi / 4 == 2) |
{ |
char IsFree = 0; |
if (pos.SH[i - Zn * 4] == 2 - Color) IsFree += (char)2; |
else if (qi != 8) |
{ |
if (pos.SH[i - Zn ] == 2 - Color || |
pos.SH[i - Zn * 9] == 2 - Color) IsFree += (char)2; |
else if (Color != pos.wmove) |
if (pos.SH[i - Zn * 5] == 2 - Color) IsFree++; |
} |
if (qi == 11) IsFree += (char)2; |
else if (pos.SH[i + Zn ] == 2 - Color || |
pos.SH[i - Zn * 3] == 2 - Color || |
pos.SH[i - Zn * 7] == 2 - Color) IsFree += (char)2; |
else if (Color != pos.wmove && qi != 10) |
{ |
if (pos.SH[i - Zn * 2] == 2 - Color) IsFree++; |
} |
if (IsFree < 3) val += PreZ * 176 / (1 + NDM0 + NDM1); |
else if (qi == 9 || qi == 10) |
{ |
val += PreZ * 128 / (1 + NDM0 + NDM1); |
} |
} |
else if (qi / 4 == 3) |
{ |
char IsFree = 0; |
if (pos.SH[i - Zn * 12] == 2 - Color) |
{ |
if (Color == pos.wmove) IsFree += (char)11; |
else IsFree += (char)12; |
} |
else if (pos.SH[i - Zn * 4] == 2 - Color) IsFree += (char)11; |
else if (qi == 15) IsFree += (char)5; |
else if (pos.SH[i - Zn * 7] == 2 - Color) IsFree += (char)9; |
else if (pos.SH[i + Zn] == 2 - Color) IsFree += (char)8; |
else if (pos.SH[i - Zn * 11] == 2 - Color) |
{ |
if (Color == pos.wmove) IsFree += (char)5; |
else IsFree += (char)7; |
} |
else if (pos.SH[i - Zn * 3] == 2 - Color) IsFree += (char)5; |
else if (qi != 14) |
{ |
if (pos.SH[i - Zn * 6] == 2 - Color) IsFree += (char)3; |
else if (Color != pos.wmove) |
{ |
if (pos.SH[i - Zn * 10] == 2 - Color) IsFree++; |
} |
} |
if (qi == 12) IsFree += (char)7; |
else if (pos.SH[i - Zn * 13] == 2 - Color) |
{ |
if (Color == pos.wmove) IsFree += (char)11; |
else IsFree += (char)12; |
} |
else if (pos.SH[i - Zn * 5] == 2 - Color) IsFree += (char)11; |
else if (pos.SH[i - Zn * 9] == 2 - Color) IsFree += (char)9; |
else if (pos.SH[i - Zn] == 2 - Color) IsFree += (char)8; |
else if (qi != 13) |
{ |
if (pos.SH[i - Zn * 14] == 2 - Color) |
{ |
if (Color == pos.wmove) IsFree += (char)5; |
else IsFree += (char)7; |
} |
else if (pos.SH[i - Zn * 6] == 2 - Color) IsFree += (char)5; |
else if (pos.SH[i - Zn * 10] == 2 - Color) IsFree += (char)3; |
else if (Color != pos.wmove && qi != 14) |
{ |
if (pos.SH[i - Zn * 15] == 2 - Color) IsFree++; |
} |
} |
if (IsFree < ((Color == pos.wmove) ? 14 : 12)) |
{ |
val += PreZ * 160 / (1 + NDM0 + NDM1); |
} |
} |
} |
} |
} |
} |
} |
if (num == 2) |
{ |
char NSH1 = 0, NSH0 = 0, NDM1 = 0, NDM0 = 0; |
for (int i = 0; i < NUM_CELL; i++) |
{ |
if (pos.SH[i] == 1 + pos.wmove) NSH1++; |
else if (pos.SH[i] == 2 - pos.wmove) NSH0++; |
else if (pos.SH[i] == 3 + pos.wmove) NDM1++; |
else if (pos.SH[i] == 4 - pos.wmove) NDM0++; |
} |
if (NDM1 > 0 && NDM0 > 0 && NSH1 == 0 && NSH0 == 0) |
{ |
short PrP = 0; |
char Cpos3 = -1; |
if (NDM1 == 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0) Cpos3 = 1; |
else if (NDM1 == 1 && NDM0 == 3 && NSH1 == 0 && NSH0 == 0) Cpos3 = 0; |
if (Cpos3 >= 0) |
{ |
for (int Osm = 0; Osm <= 1; Osm++) for (int Csm = 0; Csm <= 1; Csm++) |
{ |
char PosSH[7][3] = {{13, 17, 18}, {6, 17, 18}, {9, 21, 22}, |
{17, 18, 19}, {9, 10, 15}, {11, 14, 18}, {2, 14, 18}}; |
for (char PosNi = 0; PosNi < 7; PosNi++) |
{ |
bool IsPosR = 1; |
for (char ShNi = 0; ShNi < 3; ShNi++) |
{ |
char DNomSh = (Csm == 1) ? char(31 - PosSH[PosNi][ShNi]) |
: char(PosSH[PosNi][ShNi]); |
if (Osm == 1) |
{ |
int x, y; |
NumToPole(DNomSh, x, y); |
DNomSh = (char)PoleToNum(y, x); |
} |
if (pos.SH[DNomSh] != 3 + (Cpos3 == pos.wmove)) IsPosR = 0; |
} |
if (IsPosR) |
{ |
if (PosNi == 3) |
{ |
if (Cpos3 == 1) |
{ |
if (pos.SH[(Csm == 1) ? 29 : 2] != |
4 - (Cpos3 == pos.wmove) && pos.SH[(Csm == 1) ? 11 : 20] != |
4 - (Cpos3 == pos.wmove)) PrP = 216; |
} |
else |
{ |
bool PrPZ = 1; |
for (int i = 0; i < 6; i++) |
if (pos.SH[PoleToNum((Csm == 1) ? (i + 2) : i, |
(Csm == 1) ? (7 - i) : (5 - i))] == |
4 - (Cpos3 == pos.wmove)) PrPZ = 0; |
if (PrPZ) PrP = -216; |
} |
} |
else if (PosNi == 4) |
{ |
if (Cpos3 == 1) |
{ |
if (pos.SH[ 0] != 4 - (Cpos3 == pos.wmove) && |
pos.SH[ 4] != 4 - (Cpos3 == pos.wmove) && |
pos.SH[27] != 4 - (Cpos3 == pos.wmove) && |
pos.SH[31] != 4 - (Cpos3 == pos.wmove)) |
{ |
PrP = 216; |
} |
} |
else |
{ |
if (pos.SH[(Csm == Osm) ? 4 : 0] != 4 - (Cpos3 == pos.wmove) && |
pos.SH[(Csm == Osm) ? 8 : 5] != 4 - (Cpos3 == pos.wmove) && |
pos.SH[(Csm == Osm) ? 26 : 23] != 4 - (Cpos3 == pos.wmove) && |
pos.SH[(Csm == Osm) ? 31 : 27] != 4 - (Cpos3 == pos.wmove)) |
{ |
PrP = -216; |
} |
} |
} |
else if (PosNi == 5) |
{ |
char DNomSh = (Cpos3 == 1) ? ((Osm == 1) ? (char)16 : (char)6) |
: ((Osm == 1) ? (char)20 : (char)2); |
if (Csm == 1) DNomSh = char(31 - DNomSh); |
if (pos.SH[DNomSh] == 4 - (Cpos3 == pos.wmove)) |
{ |
PrP = (Cpos3 == 1) ? short(160) : short(-160); |
} |
} |
else if (PosNi == 6) |
{ |
if (Cpos3 == 1) |
{ |
if (pos.SH[ 1] == 4 - (Cpos3 == pos.wmove) || |
pos.SH[12] == 4 - (Cpos3 == pos.wmove) || |
pos.SH[19] == 4 - (Cpos3 == pos.wmove) || |
pos.SH[30] == 4 - (Cpos3 == pos.wmove)) |
{ |
PrP = 168; |
} |
} |
else |
{ |
if (pos.SH[(Csm == 1) ? 15 : 6] == 4 - (Cpos3 == pos.wmove) || |
pos.SH[(Csm == 1) ? 25 : 16] == 4 - (Cpos3 == pos.wmove)) |
{ |
PrP = -168; |
} |
} |
} |
else PrP = short(((Cpos3 == 1) ? 1 : -1) * ((PosNi == 0) ? 200 : 208)); |
} |
} |
} |
} |
if (PrP == 0) |
{ |
unsigned char HwoBD = 0; |
char NShSBD = 0; |
for (int i = 0; i < 8; i++) |
{ |
char ShBD = pos.SH[PoleToNum(i, 7 - i)]; |
if (ShBD == 3 + pos.wmove) {HwoBD |= 2; NShSBD++;} |
else if (ShBD == 4 - pos.wmove) {HwoBD |= 1; NShSBD++;} |
} |
if (NDM1 >= 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0 && HwoBD == 2) |
{ |
if (NShSBD >= 1) val -= NShSBD - 1; |
if (pos.SH[ 3] == 3 + pos.wmove) val--; |
if (pos.SH[28] == 3 + pos.wmove) val--; |
char Drg1 = 0, DrgPS = 0; |
bool Drg1p = 0; |
for (int i = 0; i < 7; i++) |
{ |
char Sh7D = pos.SH[PoleToNum(i, i + 1)]; |
if (Sh7D == 3 + pos.wmove) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 4 - pos.wmove) Drg1p = 1; |
Sh7D = pos.SH[PoleToNum(i + 1, i)]; |
if (Sh7D == 3 + pos.wmove) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 4 - pos.wmove) Drg1p = 1; |
} |
if (pos.SH[0] == 3 + pos.wmove || pos.SH[4] == 3 + pos.wmove || |
pos.SH[27] == 3 + pos.wmove || pos.SH[31] == 3 + pos.wmove) |
{if (Drg1p) val += 4; else val -= 1;} |
if ((pos.SH[14] == 3 + pos.wmove) == (pos.SH[17] == 3 + pos.wmove)) |
{if (Drg1 == 1) val += 2;} |
else |
{ |
if (Drg1 >= 2) |
{ |
if (Drg1 > 2) val -= 1; |
if (DrgPS == 3) val += 4; |
if (Drg1p) val += 4; else val += 16; |
if (!Drg1p && DrgPS) |
{ |
Drg1 = 0; Drg1p = 0; DrgPS = 0; |
for (int i = 0; i < 6; i++) |
{ |
char Sh7D = pos.SH[PoleToNum(i, 5 - i)]; |
if (Sh7D == 3 + pos.wmove) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 4 - pos.wmove) Drg1p = 1; |
Sh7D = pos.SH[PoleToNum(i + 2, 7 - i)]; |
if (Sh7D == 3 + pos.wmove) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 4 - pos.wmove) Drg1p = 1; |
} |
if (pos.SH[2] == 3 + pos.wmove || pos.SH[11] == 3 + pos.wmove || |
pos.SH[20] == 3 + pos.wmove || pos.SH[29] == 3 + pos.wmove) |
val += 4; |
if ((pos.SH[14] == 3 + pos.wmove) |
? (pos.SH[13] == 3 + pos.wmove || pos.SH[22] == 3 + pos.wmove) |
: (pos.SH[ 9] == 3 + pos.wmove || pos.SH[18] == 3 + pos.wmove)) |
{ |
if (Drg1 >= 2) |
{ |
if (DrgPS == 3) val += 4; |
if (Drg1p) val += 4; else val += 16; |
} |
else if (Drg1 == 1) val += 1; |
} |
else if (Drg1 == 1) val += 2; |
} |
} |
} |
} |
else if (NDM0 >= 3 && NDM1 == 1 && NSH0 == 0 && NSH1 == 0 && HwoBD == 1) |
{ |
if (NShSBD >= 1) val += NShSBD - 1; |
if (pos.SH[ 3] == 4 - pos.wmove) val++; |
if (pos.SH[28] == 4 - pos.wmove) val++; |
char Drg1 = 0, DrgPS = 0; |
bool Drg1p = 0; |
for (int i = 0; i < 7; i++) |
{ |
char Sh7D = pos.SH[PoleToNum(i, i + 1)]; |
if (Sh7D == 4 - pos.wmove) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 3 + pos.wmove) Drg1p = 1; |
Sh7D = pos.SH[PoleToNum(i + 1, i)]; |
if (Sh7D == 4 - pos.wmove) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 3 + pos.wmove) Drg1p = 1; |
} |
if (pos.SH[0] == 4 - pos.wmove || pos.SH[4] == 4 - pos.wmove || |
pos.SH[27] == 4 - pos.wmove || pos.SH[31] == 4 - pos.wmove) |
{if (Drg1p) val -= 4; else val += 1;} |
if ((pos.SH[14] == 4 - pos.wmove) == (pos.SH[17] == 4 - pos.wmove)) |
{if (Drg1 == 1) val -= 2;} |
else |
{ |
if (Drg1 >= 2) |
{ |
if (Drg1 > 2) val += 1; |
if (DrgPS == 3) val -= 4; |
if (Drg1p) val -= 4; else val -= 16; |
if (!Drg1p && DrgPS) |
{ |
Drg1 = 0; Drg1p = 0; DrgPS = 0; |
for (int i = 0; i < 6; i++) |
{ |
char Sh7D = pos.SH[PoleToNum(i, 5 - i)]; |
if (Sh7D == 4 - pos.wmove) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 3 + pos.wmove) Drg1p = 1; |
Sh7D = pos.SH[PoleToNum(i + 2, 7 - i)]; |
if (Sh7D == 4 - pos.wmove) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 3 + pos.wmove) Drg1p = 1; |
} |
if (pos.SH[2] == 4 - pos.wmove || pos.SH[11] == 4 - pos.wmove || |
pos.SH[20] == 4 - pos.wmove || pos.SH[29] == 4 - pos.wmove) |
{ |
val -= 4; |
} |
if ((pos.SH[14] == 4 - pos.wmove) |
? (pos.SH[13] == 4 - pos.wmove || pos.SH[22] == 4 - pos.wmove) |
: (pos.SH[ 9] == 4 - pos.wmove || pos.SH[18] == 4 - pos.wmove)) |
{ |
if (Drg1 >= 2) |
{ |
if (DrgPS == 3) val -= 4; |
if (Drg1p) val -= 4; else val -= 16; |
} |
else if (Drg1 == 1) val -= 1; |
} |
else if (Drg1 == 1) val -= 2; |
} |
} |
} |
} |
else if (NDM1 >= 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0 && HwoBD == 1) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (int i = 0; i < 4; i++) |
{ |
Add |= char((pos.SH[Best4P[i][0]] == 3 + pos.wmove) * 3 + |
(pos.SH[Best4P[i][1]] == 3 + pos.wmove)); |
} |
if (Add >= 4) val += 3; |
else if (Add == 3) val += 2; |
else if (Add >= 1) val += 1; |
} |
else if (NDM0 >= 3 && NDM1 == 1 && NSH0 == 0 && NSH1 == 0 && HwoBD == 2) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (int i = 0; i < 4; i++) |
{ |
Add |= char((pos.SH[Best4P[i][0]] == 4 - pos.wmove) * 3 + |
(pos.SH[Best4P[i][1]] == 4 - pos.wmove)); |
} |
if (Add >= 4) val -= 3; |
else if (Add == 3) val -= 2; |
else if (Add >= 1) val -= 1; |
} |
} |
else val += PrP; |
} |
} |
return val; |
} |
template <class tvalue> |
tvalue TBaseCompPlayer<tvalue>::GetFullValue(const Position &pos, int num) |
{ |
if (!pos.AllCanMove() && !pos.AllCanEat()) return GetLossValue(pos); |
else return GetValue(pos, num); |
} |
template <class tvalue> |
tvalue TBaseCompPlayer<tvalue>::FindBMove(Z &z, int num, |
PMvv *pmv, int zn, tvalue a, tvalue b) |
{ |
assert(b > a); |
assert(num >= 0); |
if (num >= 3 && draw) draw(data); |
int nlast = z.narr; |
if (zn < 0) {z.AddPos(); z.array[zn = z.narr++] = *pmv;} |
if (pmv) pmv->mv[0] = 0; |
int n0 = z.narr; |
int was_eat = z.FindAllMoves(z.array[zn], num <= 0); |
int n1 = z.narr; |
tvalue val; |
if (n1 == n0) |
{ |
assert(!z.array[zn].pos.AllCanEat()); |
assert(num == 0 || !z.array[zn].pos.AllCanMove()); |
if (num > 0 || !z.array[zn].pos.AllCanMove()) val = GetLossValue(z.array[zn].pos); |
else val = GetValue(z.array[zn].pos, 0); |
} |
else if (pmv && n1 == n0 + 1 && nlast < n0) |
{ |
*pmv = z.array[n0]; |
if (!z.array[n0].pos.AllCanMove() && !z.array[n0].pos.AllCanMove()) |
{ |
val = -1 - GetLossValue(z.array[n0].pos); |
} |
else |
{ |
val = -GetValue(z.array[n0].pos, 0); |
n1 = -1; |
} |
} |
else |
{ |
int k, opt; |
if (num >= 2) |
{ |
if (pmv && n1 > n0 + 1) |
{ |
for (k = 0; k < 2*(n1 - n0); k++) |
{ |
int i0 = n0 + random(n1 - n0), i1 = n0 + random(n1 - n0 - 1); |
if (i1 >= i0) i1++; |
PMvv t_pmv = z.array[i0]; |
z.array[i0] = z.array[i1]; |
z.array[i1] = t_pmv; |
} |
} |
for (k = n0; k < n1; k++) z.array[k].val = GetFullValue(z.array[k].pos); |
z.Sort(n0, n1); |
} |
tvalue cc = 2 * win_val; |
tvalue dval = was_eat ? 0 : GetValue(z.array[zn].pos, num); |
tvalue aa = -b, bb = -a; |
if (aa < -win_val) aa--; |
else if (aa > win_val) aa++; |
else aa += dval; |
if (bb < -win_val) bb--; |
else if (bb > win_val) bb++; |
else bb += dval; |
for (k = n0; k < n1 && bb > aa; k++) |
{ |
tvalue vk; |
vk = FindBMove(z, num-1+was_eat, 0, k, aa, bb); |
if (vk < cc) |
{ |
opt = k; cc = vk; |
if (bb > cc) bb = cc; |
} |
} |
if (cc < -win_val) cc++; |
else if (cc > win_val) cc--; |
else cc -= dval; |
val = -cc; |
assert(opt >= n0 && opt < n1); |
if (pmv) *pmv = z.array[opt]; |
} |
z.array[zn].val = val; |
z.narr = nlast; |
if (pmv) |
{ |
if (n1 >= 0) printf("Checkers: value = %ld\n", val); |
else printf("Checkers: value = ?\n"); |
} |
return val; |
} |
template <class tvalue> |
int TBaseCompPlayer<tvalue>::Move(PMv &pmv) |
{ |
Z z; |
PMvv zpmv; |
(PMv&)zpmv = pmv; |
if (draw) draw(data, 1); |
FindBMove(z, 6, &zpmv); |
if (draw) draw(data, -1); |
if (zpmv.mv[0] == 0) return 0; |
pmv = zpmv; |
return 1; |
} |
typedef TBaseCompPlayer<long> TComputerPlayer; |
#endif //_HEADER_PLAYER_H |
/programs/games/checkers/trunk/position.h |
---|
0,0 → 1,882 |
#ifndef _HEADER_POSITION_H |
#define _HEADER_POSITION_H |
#ifndef __MENUET__ |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include <ctype.h> |
#endif |
#define NELEM(a) (sizeof(a) / sizeof((a)[0])) |
const int NW_CELL = 8; |
const int NUM_CELL = NW_CELL * NW_CELL / 2; |
const int LEN_WPOS = (NUM_CELL + 2) / 3; |
inline int PoleCpos(int i, int j) |
{ |
return (i + j) % 2 != 0; |
} |
inline int PoleToNum(int i, int j) |
{ |
return j * (NW_CELL / 2) + i/2; |
} |
inline void NumToPole(int k, int &i, int &j) |
{ |
j = k / (NW_CELL / 2); |
i = k % (NW_CELL / 2); |
i *= 2; |
if (j % 2 == 0) i++; |
} |
class Position |
{ |
public: |
char SH[NUM_CELL]; |
char wmove; |
Position() {Init();} |
Position(const Position &p); |
Position& operator=(const Position &p); |
void Init(); |
int IsNull() const; |
void Add(int np, char sh) {SH[np] = sh;} |
void Del(int np) {SH[np] = 0;} |
void Move(int np0, int np1) {if (np0 != np1) {SH[np1] = SH[np0]; SH[np0] = 0;}} |
static int BecameD(int np, char ch); |
enum {AWrong = -1, AWColor = -2, AfCell = -3, AnfCell = -4, |
AMustEatMore = -5, AMustEat = -6, ANoMove = -7, AChBack = -8, |
ANotDm = -9, AOnlyDiag = -10, AEatYour = -11, AMoreOne = -12, |
ANotDmE = -13, AMustEatMoreD = -14, ATurnBack = -15}; |
int ScanSide(int x, int y, int sx, int sy, int sh_k = -1) const; |
int CanEat(int k, int psx = 0, int psy = 0, int sh_k = -1) const; |
int CanMove(int k) const; |
int AChCell(int k); |
int AMove(const unsigned char MV[], int k = -1, int &mkmove = *(int*)0); |
int AllCanEat(int w = -1) const; |
int AllCanMove(int w = -1) const; |
char *Write(char WP[], int how = 0) const; |
Position &Read(const char WP[], int how = 0); |
static char *WriteMv(const unsigned char mv[], char WP[], int how = 0); |
int WriteMvEx(const unsigned char mv[], char WP[], int how = 0) const; |
static unsigned char *ReadMv(unsigned char mv[], const char WP[], int how = 0); |
static int GetLenMv(const unsigned char mv[], int how = 0); |
int GetLenMvEx(const unsigned char mv[], int how = 0) const; |
static int GetLenMwr(const char WP[], int how = 0); |
static void SetNullMv(unsigned char mv[]) {mv[0] = 0;} |
void Reverse(); |
}; |
Position::Position(const Position &p) : wmove(p.wmove) |
{ |
for(int i = 0; i < NUM_CELL; i++) SH[i] = p.SH[i]; |
} |
Position& Position::operator=(const Position &p) |
{ |
wmove = p.wmove; |
for(int i = 0; i < NUM_CELL; i++) SH[i] = p.SH[i]; |
return *this; |
} |
void Position::Init() |
{ |
wmove = 0; |
for (int i = 0; i < NUM_CELL; i++) SH[i] = 0; |
} |
int Position::IsNull() const |
{ |
for (int i = 0; i < NUM_CELL; i++) if (SH[i] != 0) return 0; |
return 1; |
} |
inline int Position::BecameD(int np, char ch) |
{ |
int x, y; |
NumToPole(np, x, y); |
return ch == 1 && y == NW_CELL - 1 || ch == 2 && y == 0; |
} |
char *Position::Write(char WP[], int how) const |
{ |
if (how == 0) |
{ |
int i = 0, j; |
for (j = 0; i < NUM_CELL; j++) |
{ |
WP[j] = SH[i++]; |
if (i < NUM_CELL) {WP[j] *= (char)5; WP[j] += SH[i++];} |
if (i < NUM_CELL) {WP[j] *= (char)5; WP[j] += SH[i++];} |
if (i >= NUM_CELL) {WP[j] *= (char)2; WP[j] += wmove;} |
WP[j]++; |
} |
} |
else if (how == 1) |
{ |
int i; |
for (i = NUM_CELL - 1; i >= 0; i--) |
{ |
if (SH[i] < 0 || SH[i] >= 5) return 0; |
} |
for (i = 0; i < NUM_CELL; i++) |
{ |
const char SYMBOL[5] = {'0', 'R', 'B', 'X', 'Z'}; |
WP[i] = SYMBOL[SH[NUM_CELL - 1 - i]]; |
} |
WP[NUM_CELL] = ':'; |
WP[NUM_CELL + 1] = (wmove == 0) ? 'r' : 'b'; |
WP[NUM_CELL + 2] = 0; |
} |
return WP; |
} |
Position &Position::Read(const char WP[], int how) |
{ |
if (how == 0) |
{ |
int i = 0, j, ii; |
for (j = 0; i < NUM_CELL; j++) |
{ |
unsigned int cwp = WP[j] - 1; |
if (i >= NUM_CELL - 3) |
{ |
wmove = char(cwp % 2); |
cwp /= 2; |
ii = NUM_CELL - 1; |
} |
else ii = i + 2; |
while(ii >= i) {SH[ii--] = char(cwp % 5); cwp /= 5;} |
i += 3; |
} |
} |
else if (how == 1) |
{ |
int i; |
wmove = 0; |
for (i = 0; i < NUM_CELL; i++) |
{ |
switch(WP[i]) |
{ |
case '0': |
case '-': case '.': |
case 'F': case 'f': |
SH[NUM_CELL - 1 - i] = 0; |
break; |
case '1': |
case 'A': case 'a': |
case 'R': case 'r': |
SH[NUM_CELL - 1 - i] = 1; |
break; |
case '2': |
case 'B': case 'b': |
case 'S': case 's': |
SH[NUM_CELL - 1 - i] = 2; |
break; |
case '3': |
case 'W': case 'w': |
case 'X': case 'x': |
SH[NUM_CELL - 1 - i] = 3; |
break; |
case '4': |
case 'Y': case 'y': |
case 'Z': case 'z': |
SH[NUM_CELL - 1 - i] = 4; |
break; |
default: |
Init(); |
return *this; |
} |
} |
if (WP[NUM_CELL] == ':') |
{ |
char c = WP[NUM_CELL + 1]; |
if (c == 'B' || c == 'b' || c == 'S' || c == 's' || |
c == 'Y' || c == 'y' || c == 'Z' || c == 'z') |
{ |
wmove = 1; |
} |
} |
} |
return *this; |
} |
char *Position::WriteMv(const unsigned char mv[], char WP[], int how) |
{ |
int i, nmv = 0; |
if (mv) nmv = mv[0]; |
if (how == 0) |
{ |
WP[0] = char(nmv + 1); |
for (i = 1; i <= nmv; i++) WP[i] = char(mv[i] + 1); |
} |
else if (how == 1) |
{ |
int j = 0; |
for (i = 1; i <= nmv; i++) |
{ |
int x, y; |
NumToPole(mv[i], x, y); |
WP[j++] = char('a' + NW_CELL - 1 - x); |
int r = sprintf(WP + j, "%d", 1 + y); |
if (r > 0) j += r; |
if (i != nmv) WP[j++] = '-'; |
} |
WP[j] = 0; |
} |
return WP; |
} |
unsigned char *Position::ReadMv(unsigned char mv[], const char WP[], int how) |
{ |
int i; |
if (how == 0) |
{ |
mv[0] = char(WP[0] - 1); |
for (i = 1; i <= mv[0]; i++) mv[i] = char(WP[i] - 1); |
} |
else if (how == 1) |
{ |
int j = 0, x = -1, y = -1; |
mv[0] = 0; |
for (;;) |
{ |
if (isdigit(WP[j])) |
{ |
y = atoi(WP + j) - 1; |
while (isdigit(WP[j])) j++; |
} |
else if (islower(WP[j])) x = NW_CELL - 1 - (WP[j++] - 'a'); |
else |
{ |
if (x >= 0 && y >= 0 && x < NW_CELL && y < NW_CELL) |
{ |
mv[++mv[0]] = (char)PoleToNum(x, y); |
} |
else if (y >= 0 && y < NUM_CELL) mv[++mv[0]] = (char)(NUM_CELL - 1 - y); |
x = -1; y = -1; |
if (WP[j] == '-' || WP[j] == '*' || WP[j] == ':') j++; |
else break; |
} |
if (x >= 0 && y >= 0 && x < NW_CELL && y < NW_CELL) |
{ |
mv[++mv[0]] = (char)PoleToNum(x, y); |
x = -1; y = -1; |
} |
} |
} |
return mv; |
} |
int Position::GetLenMv(const unsigned char mv[], int how) |
{ |
if (how == 0) return mv ? (1 + mv[0]) : 1; |
else if (how == 1) |
{ |
int i, j = 0; |
if (!mv) return 1; |
for (i = 1; i <= mv[0]; i++) |
{ |
int x, y; |
NumToPole(mv[i], x, y); |
j++; y++; |
while(y > 0) {j++; y /= 10;} |
if (i != mv[0]) j++; |
} |
return ++j; |
} |
else return 0; |
} |
int Position::GetLenMwr(const char WP[], int how) |
{ |
if (how == 0) return (unsigned char)WP[0]; |
else if (how == 1) |
{ |
int j; |
for (j = 0; WP[j] == '-' || WP[j] == '*' || |
WP[j] == ':' || isdigit(j) || islower(j); j++); |
return j + 1; |
} |
else return 0; |
} |
inline int Position::GetLenMvEx(const unsigned char mv[], int how) const |
{ |
return WriteMvEx(mv, 0, how); |
} |
int Position::WriteMvEx(const unsigned char mv[], char WP[], int how) const |
{ |
if (how == 11) |
{ |
Position pos = *this; |
int p, L = 0, was_d = 0; |
for (p = 1; p <= mv[0]; p++) |
{ |
if (!was_d && pos.SH[mv[p]] > 2) |
{ |
if (WP) WP[L] = '*'; |
L++; |
was_d = 1; |
} |
int x0, y0, x1, y1; |
NumToPole(mv[p], x0, y0); |
if (WP) |
{ |
WP[L++] = char('a' + NW_CELL - 1 - x0); |
int r = sprintf(WP + L, "%d", 1 + y0); |
if (r > 0) L += r; |
} |
else |
{ |
L++; |
int g = y0 + 1; |
while(g > 0) {L++; g /= 10;} |
} |
if (p >= mv[0]) break; |
NumToPole(mv[p+1], x1, y1); |
int mi = abs(x1 - x0), i, eat = -1; |
if (mi > 0 && mi == abs(y1 - y0)) |
{ |
int sx = (x1 > x0) ? 1 : -1; |
int sy = (y1 > y0) ? 1 : -1; |
for (i = 1; i < mi; i++) |
{ |
int r = PoleToNum(x0 + i * sx, y0 + i * sy); |
if (pos.SH[r] != 0) |
{ |
eat = r; |
pos.Del(r); |
} |
} |
} |
if (WP) WP[L] = (eat >= 0) ? ':' : '-'; |
L++; |
if (pos.SH[mv[p]] == 1 && y1 == NW_CELL - 1) pos.SH[mv[p]] = 3; |
else if (pos.SH[mv[p]] == 2 && y1 == 0) pos.SH[mv[p]] = 4; |
pos.Move(mv[p], mv[p+1]); |
} |
if (WP) WP[L] = 0; |
L++; |
return L; |
} |
else |
{ |
if (WP) WriteMv(mv, WP, how); |
return GetLenMv(mv, how); |
} |
} |
int Position::ScanSide(int x, int y, int sx, int sy, int sh_k) const |
{ |
if (sh_k < 0) sh_k = SH[PoleToNum(x, y)]; |
if (sh_k < 1 || sh_k > 4) return -2; |
if (sh_k >= 2) sh_k -= 2; |
int i, i0, i1, f = 0, g = 0; |
if (sx < 0) i0 = x; |
else i0 = NW_CELL - x - 1; |
if (sy < 0) i1 = y; |
else i1 = NW_CELL - y - 1; |
if (i0 > i1) i0 = i1; |
for (i = 1; i <= i0; i++) |
{ |
char nk = SH[PoleToNum(x + i*sx, y + i*sy)]; |
if (nk) |
{ |
if (f || (nk != 3 - sh_k && nk != 5 - sh_k)) return g; |
else f = 1; |
} |
else if (f) return (i == 2) ? 4 : (2 + g); |
else if (i == 1) g = 1; |
} |
return g; |
} |
int Position::CanEat(int k, int psx, int psy, int sh_k) const |
{ |
int x, y, sx, sy; |
if (sh_k < 0) sh_k = SH[k]; |
if (sh_k < 1 || sh_k > 6) return 0; |
NumToPole(k, x, y); |
if (sh_k > 4) |
{ |
int i, i0, i1, f = 0; |
if (-psx < 0) i0 = x; |
else i0 = NW_CELL - x - 1; |
if (-psy < 0) i1 = y; |
else i1 = NW_CELL - y - 1; |
if (i0 > i1) i0 = i1; |
for (i = 1; i <= i0; i++) |
{ |
int nk = SH[PoleToNum(x - i*psx, y - i*psy)]; |
if (nk) |
{ |
if (f || (nk != 7 - sh_k && nk != 9 - sh_k)) break; |
else f = 1; |
} |
else |
{ |
if (f) return 1; |
if (ScanSide(x - i*psx, y - i*psy, psy, -psx, sh_k-2) >= 2) return 1; |
if (ScanSide(x - i*psx, y - i*psy, -psy, psx, sh_k-2) >= 2) return 1; |
} |
} |
} |
else for (sx = -1; sx <= 1; sx += 2) if (x + 2*sx >= 0 && x + 2*sx < NW_CELL) |
{ |
for (sy = -1; sy <= 1; sy += 2) |
{ |
if ((sx != psx || sy != psy) && y + 2*sy >= 0 && y + 2*sy < NW_CELL) |
{ |
if (sh_k <= 2) |
{ |
if (SH[PoleToNum(x + 2*sx, y + 2*sy)] == 0) |
{ |
int nk = SH[PoleToNum(x + sx, y + sy)]; |
if (nk == 3 - sh_k || nk == 5 - sh_k) return 1; |
} |
} |
else if (ScanSide(x, y, sx, sy, sh_k) >= 2) return 1; |
} |
} |
} |
return 0; |
} |
int Position::CanMove(int k) const |
{ |
int x, y, xx, yy, y1, y2; |
NumToPole(k, x, y); |
if (SH[k] == 1) y1 = y2 = y + 1; |
else if (SH[k] == 2) y1 = y2 = y - 1; |
else if (SH[k] != 3 && SH[k] != 4) return 0; |
else {y1 = y - 1; y2 = y + 1;} |
for (yy = y1; yy <= y2; yy += 2) if (yy >= 0 && yy < NW_CELL) |
{ |
for (xx = x - 1; xx <= x + 1; xx += 2) if (xx >= 0 && xx < NW_CELL) |
{ |
if (SH[PoleToNum(xx, yy)] == 0) return 1; |
} |
} |
return 0; |
} |
int Position::AChCell(int k) |
{ |
if (k < 0 || k >= NUM_CELL) return AWrong; |
if (SH[k] == 0) return AfCell; |
if (SH[k] != 1 + wmove && SH[k] != 3 + wmove) return AWColor; |
if (CanEat(k)) return 1; |
if (AllCanEat()) return AMustEat; |
if (CanMove(k)) return 1; |
return ANoMove; |
} |
int Position::AMove(const unsigned char MV[], int k, int &mkmove) |
{ |
if (k >= NUM_CELL) return AWrong; |
if (MV[0] <= 0) |
{ |
if (k < 0) return NUM_CELL; |
int s = AChCell(k); |
if (s < 0) return s; |
else return NUM_CELL; |
} |
if (MV[0] == 1 && k < 0) |
{ |
int s = AChCell(MV[1]); |
if (s < 0) return s; |
else return NUM_CELL; |
} |
if (SH[MV[1]] == 0) return AfCell; |
if (SH[MV[1]] != 1 + wmove && SH[MV[1]] != 3 + wmove) return AWColor; |
int i, mi, p, MV_L, MV_N = MV[0], eat = -1, r; |
int psx = 0, psy = 0; |
if (k >= 0) MV_N++; |
Position pos = *this; |
for (p = 1; p < MV_N; p++) |
{ |
int x0, y0, x1, y1, i_eat; |
if (p < MV[0]) MV_L = MV[p+1]; |
else if (k < 0) break; |
else MV_L = k; |
if (pos.SH[MV_L] != 0) return AnfCell; |
NumToPole(MV[p], x0, y0); |
NumToPole(MV_L, x1, y1); |
mi = abs(x1 - x0); |
if (mi <= 0 || mi != abs(y1 - y0)) return AOnlyDiag; |
int sx = (x1 > x0) ? 1 : -1; |
int sy = (y1 > y0) ? 1 : -1; |
if (sx == psx && sy == psy) return ATurnBack; |
psx = -sx; psy = -sy; |
eat = -1; i_eat = -1; |
for (i = 1; i < mi; i++) |
{ |
r = PoleToNum(x0 + i * sx, y0 + i * sy); |
if (pos.SH[r] != 0) |
{ |
if (eat >= 0) return AMoreOne; |
if (pos.SH[r] != 2 - wmove && pos.SH[r] != 4 - wmove) return AEatYour; |
eat = r; i_eat = i; |
pos.Del(r); |
} |
} |
if (eat >= 0) |
{ |
if (pos.SH[MV[p]] <= 2 && mi != 2) return ANotDmE; |
} |
else |
{ |
if (MV_N > 2) return AMustEatMore; |
if (pos.SH[MV[p]] <= 2) |
{ |
if (mi != 1) return ANotDm; |
if (wmove == 0 && y1 < y0 || wmove == 1 && y1 > y0) return AChBack; |
} |
if (AllCanEat()) return AMustEat; |
} |
if (i_eat >= 0 && pos.SH[MV[p]] > 2) |
{ |
if (!pos.CanEat(MV_L, psx, psy, pos.SH[MV[p]])) |
{ |
if (pos.CanEat(PoleToNum(x0 + i_eat*sx, y0 + i_eat*sy), |
psx, psy, pos.SH[MV[p]] + 2)) |
{ |
return AMustEatMoreD; |
} |
} |
} |
if (wmove == 0 && y1 == NW_CELL - 1) pos.SH[MV[p]] = 3; |
else if (wmove == 1 && y1 == 0) pos.SH[MV[p]] = 4; |
pos.Move(MV[p], MV_L); |
} |
if (&mkmove) |
{ |
int end = MV_N > 1 && (eat < 0 || !pos.CanEat(MV_L, psx, psy)); |
if (mkmove == 1 && end) |
{ |
*this = pos; |
wmove = !wmove; |
} |
if (end) mkmove = 0; |
else |
{ |
if (MV_N > 1 && eat >= 0) mkmove = AMustEatMore; |
else mkmove = AWrong; |
} |
} |
if (k < 0 || eat < 0) eat = NUM_CELL; |
return eat; |
} |
int Position::AllCanEat(int w) const |
{ |
int k; |
if (w < 0) w = wmove; |
for (k = 0; k < NUM_CELL; k++) |
{ |
if ((SH[k] == w+1 || SH[k] == w+3) && CanEat(k)) return 1; |
} |
return 0; |
} |
int Position::AllCanMove(int w) const |
{ |
int k; |
if (w < 0) w = wmove; |
for (k = 0; k < NUM_CELL; k++) |
{ |
if ((SH[k] == w+1 || SH[k] == w+3) && CanMove(k)) return 1; |
} |
return 0; |
} |
void Position::Reverse() |
{ |
int i; |
for (i = 0; i <= (NUM_CELL-1) / 2; i++) |
{ |
int sh1 = SH[i], sh2 = SH[NUM_CELL - 1 - i]; |
if (sh1 == 1) sh1 = 2; |
else if (sh1 == 2) sh1 = 1; |
else if (sh1 == 3) sh1 = 4; |
else if (sh1 == 4) sh1 = 3; |
if (sh2 == 1) sh2 = 2; |
else if (sh2 == 2) sh2 = 1; |
else if (sh2 == 3) sh2 = 4; |
else if (sh2 == 4) sh2 = 3; |
SH[i] = (char)sh2; SH[NUM_CELL - 1 - i] = (char)sh1; |
} |
wmove = !wmove; |
} |
class PlayWrite |
{ |
public: |
PlayWrite() : play(0), mplay(0), nplay(0), start(0), mstart(0), nstart(0) {} |
PlayWrite(const PlayWrite &pl) : play(0), mplay(0), nplay(0), |
start(0), mstart(0), nstart(0) {(*this) = pl;} |
~PlayWrite() {Clear();} |
void Clear(); |
PlayWrite &operator=(const PlayWrite &pl); |
int GetN() const {return nstart - 1;} |
int GetLen() const {return nplay - sizeof(int);} |
struct PMv |
{ |
Position pos; |
unsigned char mv[NUM_CELL]; |
}; |
void Add(const unsigned char move[], const Position &pos); |
void Add(const PMv &pmv) {Add(pmv.mv, pmv.pos);} |
int Add(const unsigned char move[]); |
int GetMove(unsigned char move[], int k) const; |
int GetPos(Position &pos, int k) const; |
int GetPMv(PMv &pmv, int k) const; |
int GetMoveL(unsigned char move[], int k = 0) const |
{return GetMove(move, nstart - 2 - k);} |
int GetPosL(Position &pos, int k = 0) const {return GetPos(pos, nstart - 2 - k);} |
int GetPMvL(PMv &pmv, int k = 0) const {return GetPMv(pmv, nstart - 2 - k);} |
int ClearFrom(int k = 0); |
int IsDraw(int nmove = -1); |
protected: |
void IncPlay(int k); |
void IncStart(int k); |
void IncStart() {IncStart(nstart + 1);} |
void AddStart() {IncStart(); start[nstart++] = nplay;} |
void Split(); |
void SplitClear(); |
protected: |
char *play; |
int *start; |
int mplay, nplay, mstart, nstart; |
}; |
void PlayWrite::Clear() |
{ |
if (play) |
{ |
if ((*(int*)play) > 0) (*(int*)play)--; |
else delete[] play; |
} |
play = 0; mplay = 0; nplay = 0; |
if (start) |
{ |
if (start[0] > 0) start[0]--; |
else delete[] start; |
} |
start = 0; mstart = 0; nstart = 0; |
} |
void PlayWrite::Split() |
{ |
if (play && (*(int*)play) > 0) |
{ |
(*(int*)play)--; |
char *play0 = play; |
mplay = nplay; |
play = new char[mplay]; |
memcpy(play, play0, nplay * sizeof(play[0])); |
(*(int*)play) = 0; |
} |
if (start && start[0] > 0) |
{ |
start[0]--; |
int *start0 = start; |
mstart = nstart; |
start = new int[mstart]; |
memcpy(start, start0, nstart * sizeof(start[0])); |
start[0] = 0; |
} |
} |
void PlayWrite::SplitClear() |
{ |
if (play && (*(int*)play) > 0) |
{ |
(*(int*)play)--; |
play = 0; |
nplay = 0; mplay = 0; |
} |
if (start && start[0] > 0) |
{ |
start[0]--; |
start = 0; |
nstart = 0; mstart = 0; |
} |
} |
PlayWrite &PlayWrite::operator=(const PlayWrite &pl) |
{ |
if (&pl != this) |
{ |
play = pl.play; |
(*(int*)play)++; |
nplay = pl.nplay; mplay = pl.mplay; |
start = pl.start; |
start[0]++; |
nstart = pl.nstart; mstart = pl.mstart; |
} |
return *this; |
} |
void PlayWrite::IncPlay(int k) |
{ |
if (mplay < k) |
{ |
int m0 = mplay; |
char *play0 = play; |
mplay = 2*k + 10; |
play = new char[mplay]; |
memcpy(play, play0, m0 * sizeof(play[0])); |
(*(int*)play) = 0; |
if (play0) |
{ |
if ((*(int*)play0) > 0) (*(int*)play0)--; |
else delete[] play0; |
} |
} |
} |
void PlayWrite::IncStart(int k) |
{ |
if (mstart < k) |
{ |
int m0 = mstart; |
int *start0 = start; |
mstart = 2*k + 10; |
start = new int[mstart]; |
memcpy(start, start0, m0 * sizeof(start[0])); |
start[0] = 0; |
if (start0) |
{ |
if (start0[0] > 0) start0[0]--; |
else delete[] start0; |
} |
} |
} |
void PlayWrite::Add(const unsigned char move[], const Position &pos) |
{ |
Split(); |
int k = Position::GetLenMv(move); |
if (nstart < 1) nstart = 1; |
if (nplay < sizeof(int)) nplay = sizeof(int); |
AddStart(); |
IncPlay(nplay + k + LEN_WPOS); |
Position::WriteMv(move, play + nplay, 0); |
nplay += k; |
pos.Write(play + nplay, 0); |
nplay += LEN_WPOS; |
} |
int PlayWrite::Add(const unsigned char move[]) |
{ |
if (nstart <= 1) return 1; |
Position pos; |
GetPosL(pos); |
int mkmove = 1; |
int res = pos.AMove(move, -1, mkmove); |
if (res < 0) return res; |
else if (mkmove != 0) return mkmove; |
Add(move, pos); |
return 0; |
} |
int PlayWrite::GetMove(unsigned char move[], int k) const |
{ |
if (!play || !start) return -1; |
k++; |
if (k <= 0 || k >= nstart) return -1; |
Position::ReadMv(move, play + start[k], 0); |
return Position::GetLenMv(move); |
} |
int PlayWrite::GetPos(Position &pos, int k) const |
{ |
if (!play || !start) return -1; |
k++; |
if (k <= 0 || k >= nstart) return -1; |
int mlen = Position::GetLenMwr(play + start[k], 0); |
pos.Read(play + start[k] + mlen, 0); |
return LEN_WPOS; |
} |
int PlayWrite::GetPMv(PMv &pmv, int k) const |
{ |
if (!play || !start) return -1; |
k++; |
if (k <= 0 || k >= nstart) return -1; |
Position::ReadMv(pmv.mv, play + start[k], 0); |
int mlen = Position::GetLenMv(pmv.mv); |
pmv.pos.Read(play + start[k] + mlen, 0); |
return mlen + LEN_WPOS; |
} |
int PlayWrite::ClearFrom(int k) |
{ |
if (!play || !start) return 0; |
k++; |
if (k >= nstart) return 0; |
if (k <= 1) {Clear(); return 2;} |
nplay = start[k]; |
nstart = k; |
return 1; |
} |
int PlayWrite::IsDraw(int nmove) |
{ |
nmove++; |
if (nmove <= 0 || nmove > nstart) nmove = nstart; |
if (!start || nmove <= 3) return 0; |
int i, j, k, draw = 0; |
for (i = 1; i < nmove; i++) |
{ |
k = 1; |
char *p1 = play + start[i] + Position::GetLenMwr(play + start[i], 0); |
for (j = 1; j < i; j++) |
{ |
char *p2 = play + start[j] + Position::GetLenMwr(play + start[j], 0); |
if (memcmp(p1, p2, LEN_WPOS) == 0) k++; |
} |
if (k >= 3) {draw = 1; break;} |
} |
return draw; |
} |
class TChPlayer |
{ |
public: |
TChPlayer() {} |
typedef struct PlayWrite::PMv PMv; |
virtual int PlayerID() {return 0;} |
virtual int Move(PMv &pmv) = 0; |
int Move(Position &pos, char mv[]); |
}; |
int TChPlayer::Move(Position &pos, char mv[]) |
{ |
PMv pmv; |
pmv.pos = pos; memcpy(pmv.mv, mv, sizeof(pmv.mv)); |
int res = Move(pmv); |
pos = pmv.pos; memcpy(mv, pmv.mv, sizeof(pmv.mv)); |
return res; |
} |
#endif //_HEADER_POSITION_H |
/programs/games/checkers/trunk/qsort.c |
---|
0,0 → 1,331 |
static void shortsort(char *lo, char *hi, unsigned width, |
int (*comp)(const void *, const void *)); |
static void swap(char *p, char *q, unsigned width); |
/* this parameter defines the cutoff between using quick sort and |
insertion sort for arrays; arrays with lengths shorter or equal to the |
below value use insertion sort */ |
#define CUTOFF 8 /* testing shows that this is good value */ |
#define STKSIZ (8*sizeof(void*) - 2) |
/*** |
*qsort(base, num, wid, comp) - quicksort function for sorting arrays |
* |
*Purpose: |
* quicksort the array of elements |
* side effects: sorts in place |
* maximum array size is number of elements times size of elements, |
* but is limited by the virtual address space of the processor |
* |
*Entry: |
* char *base = pointer to base of array |
* unsigned num = number of elements in the array |
* unsigned width = width in bytes of each array element |
* int (*comp)() = pointer to function returning analog of strcmp for |
* strings, but supplied by user for comparing the array elements. |
* it accepts 2 pointers to elements. |
* Returns neg if 1<2, 0 if 1=2, pos if 1>2. |
* |
*Exit: |
* returns void |
* |
*******************************************************************************/ |
void qsort ( |
void *base, |
unsigned num, |
unsigned width, |
int (*comp)(const void *, const void *) |
) |
{ |
/* Note: the number of stack entries required is no more than |
1 + log2(num), so 30 is sufficient for any array */ |
char *lo, *hi; /* ends of sub-array currently sorting */ |
char *mid; /* points to middle of subarray */ |
char *loguy, *higuy; /* traveling pointers for partition step */ |
unsigned size; /* size of the sub-array */ |
char *lostk[STKSIZ], *histk[STKSIZ]; |
int stkptr; /* stack for saving sub-array to be processed */ |
if (num < 2) |
return; /* nothing to do */ |
stkptr = 0; /* initialize stack */ |
lo = (char *)base; |
hi = (char *)base + width * (num-1); /* initialize limits */ |
/* this entry point is for pseudo-recursion calling: setting |
lo and hi and jumping to here is like recursion, but stkptr is |
preserved, locals aren't, so we preserve stuff on the stack */ |
recurse: |
size = (hi - lo) / width + 1; /* number of el's to sort */ |
/* below a certain size, it is faster to use a O(n^2) sorting method */ |
if (size <= CUTOFF) { |
shortsort(lo, hi, width, comp); |
} |
else { |
/* First we pick a partitioning element. The efficiency of the |
algorithm demands that we find one that is approximately the median |
of the values, but also that we select one fast. We choose the |
median of the first, middle, and last elements, to avoid bad |
performance in the face of already sorted data, or data that is made |
up of multiple sorted runs appended together. Testing shows that a |
median-of-three algorithm provides better performance than simply |
picking the middle element for the latter case. */ |
mid = lo + (size / 2) * width; /* find middle element */ |
/* Sort the first, middle, last elements into order */ |
if (comp(lo, mid) > 0) { |
swap(lo, mid, width); |
} |
if (comp(lo, hi) > 0) { |
swap(lo, hi, width); |
} |
if (comp(mid, hi) > 0) { |
swap(mid, hi, width); |
} |
/* We now wish to partition the array into three pieces, one consisting |
of elements <= partition element, one of elements equal to the |
partition element, and one of elements > than it. This is done |
below; comments indicate conditions established at every step. */ |
loguy = lo; |
higuy = hi; |
/* Note that higuy decreases and loguy increases on every iteration, |
so loop must terminate. */ |
for (;;) { |
/* lo <= loguy < hi, lo < higuy <= hi, |
A[i] <= A[mid] for lo <= i <= loguy, |
A[i] > A[mid] for higuy <= i < hi, |
A[hi] >= A[mid] */ |
/* The doubled loop is to avoid calling comp(mid,mid), since some |
existing comparison funcs don't work when passed the same |
value for both pointers. */ |
if (mid > loguy) { |
do { |
loguy += width; |
} while (loguy < mid && comp(loguy, mid) <= 0); |
} |
if (mid <= loguy) { |
do { |
loguy += width; |
} while (loguy <= hi && comp(loguy, mid) <= 0); |
} |
/* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy, |
either loguy > hi or A[loguy] > A[mid] */ |
do { |
higuy -= width; |
} while (higuy > mid && comp(higuy, mid) > 0); |
/* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi, |
either higuy == lo or A[higuy] <= A[mid] */ |
if (higuy < loguy) |
break; |
/* if loguy > hi or higuy == lo, then we would have exited, so |
A[loguy] > A[mid], A[higuy] <= A[mid], |
loguy <= hi, higuy > lo */ |
swap(loguy, higuy, width); |
/* If the partition element was moved, follow it. Only need |
to check for mid == higuy, since before the swap, |
A[loguy] > A[mid] implies loguy != mid. */ |
if (mid == higuy) |
mid = loguy; |
/* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top |
of loop is re-established */ |
} |
/* A[i] <= A[mid] for lo <= i < loguy, |
A[i] > A[mid] for higuy < i < hi, |
A[hi] >= A[mid] |
higuy < loguy |
implying: |
higuy == loguy-1 |
or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */ |
/* Find adjacent elements equal to the partition element. The |
doubled loop is to avoid calling comp(mid,mid), since some |
existing comparison funcs don't work when passed the same value |
for both pointers. */ |
higuy += width; |
if (mid < higuy) { |
do { |
higuy -= width; |
} while (higuy > mid && comp(higuy, mid) == 0); |
} |
if (mid >= higuy) { |
do { |
higuy -= width; |
} while (higuy > lo && comp(higuy, mid) == 0); |
} |
/* OK, now we have the following: |
higuy < loguy |
lo <= higuy <= hi |
A[i] <= A[mid] for lo <= i <= higuy |
A[i] == A[mid] for higuy < i < loguy |
A[i] > A[mid] for loguy <= i < hi |
A[hi] >= A[mid] */ |
/* We've finished the partition, now we want to sort the subarrays |
[lo, higuy] and [loguy, hi]. |
We do the smaller one first to minimize stack usage. |
We only sort arrays of length 2 or more.*/ |
if ( higuy - lo >= hi - loguy ) { |
if (lo < higuy) { |
lostk[stkptr] = lo; |
histk[stkptr] = higuy; |
++stkptr; |
} /* save big recursion for later */ |
if (loguy < hi) { |
lo = loguy; |
goto recurse; /* do small recursion */ |
} |
} |
else { |
if (loguy < hi) { |
lostk[stkptr] = loguy; |
histk[stkptr] = hi; |
++stkptr; /* save big recursion for later */ |
} |
if (lo < higuy) { |
hi = higuy; |
goto recurse; /* do small recursion */ |
} |
} |
} |
/* We have sorted the array, except for any pending sorts on the stack. |
Check if there are any, and do them. */ |
--stkptr; |
if (stkptr >= 0) { |
lo = lostk[stkptr]; |
hi = histk[stkptr]; |
goto recurse; /* pop subarray from stack */ |
} |
else |
return; /* all subarrays done */ |
} |
/*** |
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays |
*shortsort_s(hi, lo, width, comp, context) - insertion sort for sorting short arrays |
* |
*Purpose: |
* sorts the sub-array of elements between lo and hi (inclusive) |
* side effects: sorts in place |
* assumes that lo < hi |
* |
*Entry: |
* char *lo = pointer to low element to sort |
* char *hi = pointer to high element to sort |
* unsigned width = width in bytes of each array element |
* int (*comp)() = pointer to function returning analog of strcmp for |
* strings, but supplied by user for comparing the array elements. |
* it accepts 2 pointers to elements, together with a pointer to a context |
* (if present). Returns neg if 1<2, 0 if 1=2, pos if 1>2. |
* void *context - pointer to the context in which the function is |
* called. This context is passed to the comparison function. |
* |
*Exit: |
* returns void |
* |
*Exceptions: |
* |
*******************************************************************************/ |
static void shortsort ( |
char *lo, |
char *hi, |
unsigned width, |
int (*comp)(const void *, const void *) |
) |
{ |
char *p, *max; |
/* Note: in assertions below, i and j are alway inside original bound of |
array to sort. */ |
while (hi > lo) { |
/* A[i] <= A[j] for i <= j, j > hi */ |
max = lo; |
for (p = lo+width; p <= hi; p += width) { |
/* A[i] <= A[max] for lo <= i < p */ |
if (comp(p, max) > 0) { |
max = p; |
} |
/* A[i] <= A[max] for lo <= i <= p */ |
} |
/* A[i] <= A[max] for lo <= i <= hi */ |
swap(max, hi, width); |
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */ |
hi -= width; |
/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */ |
} |
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j, |
so array is sorted */ |
} |
/*** |
*swap(a, b, width) - swap two elements |
* |
*Purpose: |
* swaps the two array elements of size width |
* |
*Entry: |
* char *a, *b = pointer to two elements to swap |
* unsigned width = width in bytes of each array element |
* |
*Exit: |
* returns void |
* |
*Exceptions: |
* |
*******************************************************************************/ |
static void swap ( |
char *a, |
char *b, |
unsigned width |
) |
{ |
char tmp; |
if ( a != b ) |
/* Do the swap one character at a time to avoid potential alignment |
problems. */ |
while ( width-- ) { |
tmp = *a; |
*a++ = *b; |
*b++ = tmp; |
} |
} |
/programs/games/checkers/trunk/sysproc.h |
---|
0,0 → 1,27 |
#ifndef _HEADER_SYSTEM_PROCESS_H |
#define _HEADER_SYSTEM_PROCESS_H |
#ifndef __MENUET__ |
#include <stdlib.h> |
#include <time.h> |
#endif |
#if defined __GNUC__ |
# include <unistd.h> |
# define DIR_SEPARATOR ('/') |
inline long GetProcessId() {return (long)getpid();} |
inline long DuplicateProcess() {return (long)fork();} |
inline int random(int m) {return ((unsigned long)rand()) % m;} |
inline void randomize() {srand(time(0));} |
#elif defined __TURBOC__ && !defined __MENUET__ |
# include <process.h> |
# define DIR_SEPARATOR ('\\') |
inline long GetProcessId() {return (long)getpid();} |
inline long DuplicateProcess() {return -1;} |
#else |
# define DIR_SEPARATOR ('\\') |
inline long GetProcessId() {return 0;} |
inline long DuplicateProcess() {return -1;} |
#endif |
#endif //_HEADER_SYSTEM_PROCESS_H |
/programs/games/checkers/trunk/t2fasm.exe |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/programs/games/checkers/trunk/tmplayer.h |
---|
0,0 → 1,729 |
#ifndef _HEADER_TMP_PLAYER_H |
#define _HEADER_TMP_PLAYER_H |
#include "player.h" |
class CompPosition : public Position |
{ |
public: |
bool Move; |
CompPosition() : Position() {Move = 1;} |
CompPosition(CompPosition &p, bool IsChange = 0) : Position(p) |
{Move = p.Move + IsChange;} |
CompPosition& operator=(CompPosition &p) |
{for(int i = 0; i < 32; i++) SH[i] = p.SH[i]; Move = p.Move; return *this;} |
CompPosition& Init(Position &p, bool MoveColor = 1) |
{for(int i = 0; i < 32; i++) SH[i] = p.SH[i]; Move = MoveColor; return *this;} |
}; |
namespace ComputerMove |
{ |
#define BCM_START -256 |
#define BCM_ISM1 -257 |
class BestMove; |
bool MoveEat(BestMove* BM); |
bool MovePr(BestMove* BM); |
class BestMove |
{ |
public: |
BestMove (CompPosition &Pos1, BestMove *par = 0) |
{Pos = Pos1; Parent = par; NMax = 0;} |
void StartMove() |
{ |
if (Parent->NomP == BCM_ISM1) return; |
if (Parent->NomP == BCM_START) NomP = 258; else NomP = Parent->NomP; |
if (!MoveEat(this)) |
{ |
bool IsNP256 = 0, IsNP258 = 0; |
if (NomP == 258) IsNP258 = 1; |
if (NomP == 256) |
{ |
IsNP256 = 1; int NSH1 = 0; int NSH0 = 0; |
for (int i = 0; i < 32; i++) |
{ |
if (Pos.SH[i] == 1 + Pos.Move) NSH1 += 1; |
else if (Pos.SH[i] == 2 - Pos.Move) NSH0 += 1; |
else if (Pos.SH[i] == 3 + Pos.Move) NSH1 += 6; |
else if (Pos.SH[i] == 4 - Pos.Move) NSH0 += 6; |
} |
int NSH = NSH0 * NSH1; |
if (NSH > 100) NomP = 0; else if (NSH > 30) NomP = 1; |
else if (NSH > 5) NomP = 2; else NomP = 3; |
} |
else if (NomP == 0) NomP = BCM_ISM1; else NomP--; |
if (!MovePr(this)) |
{ |
NextPreim = -16777472; |
for (int i = 0; i < 32; i++) |
{ |
if (Pos.SH[i] == 1 + Pos.Move) NextPreim -= 512; |
else if (Pos.SH[i] == 2 - Pos.Move) NextPreim -= 32; |
else if (Pos.SH[i] == 3 + Pos.Move) NextPreim -= 4096; |
else if (Pos.SH[i] == 4 - Pos.Move) NextPreim -= 32; |
} |
} |
else if (NomP == BCM_ISM1) |
{ |
char NomDM0 = 0, NomDM1 = 0; |
NextPreim = 0; |
for (int i = 0; i < 32; i++) |
{ |
short PreimSHPos[32] = {243, 243, 243, 245, |
240, 240, 240, 240, |
244, 244, 244, 244, |
245, 248, 248, 245, |
249, 250, 250, 248, |
256, 260, 260, 256, |
280, 280, 280, 260, |
280, 280, 280, 280}; |
if (Pos.SH[i] == 1 + Pos.Move) |
NextPreim += PreimSHPos[Pos.Move ? (31 - i) : i]; |
else if (Pos.SH[i] == 2 - Pos.Move) |
NextPreim -= PreimSHPos[Pos.Move ? i : (31 - i)]; |
else if (Pos.SH[i] == 3 + Pos.Move) NomDM1++; |
else if (Pos.SH[i] == 4 - Pos.Move) NomDM0++; |
} |
if (NomDM1 > 0) |
{ |
NextPreim += 560; NomDM1--; |
if (NomDM1 > 0) |
{ |
NextPreim += 432; NomDM1--; |
NextPreim += long(NomDM1) * 384; |
} |
} |
if (NomDM0 > 0) |
{ |
NextPreim -= 560; NomDM0--; |
if (NomDM0 > 0) |
{ |
NextPreim -= 432; NomDM0--; |
NextPreim -= long(NomDM0) * 384; |
} |
} |
} |
else if (IsNP256 && NextPreim < 16777216 && NextPreim > -16777216) |
{ |
char NSH1 = 0, NSH0 = 0, NDM1 = 0, NDM0 = 0; |
for (int i = 0; i < 32; i++) |
{ |
if (Pos.SH[i] == 1 + Pos.Move) NSH1++; |
else if (Pos.SH[i] == 2 - Pos.Move) NSH0++; |
else if (Pos.SH[i] == 3 + Pos.Move) NDM1++; |
else if (Pos.SH[i] == 4 - Pos.Move) NDM0++; |
} |
if (NDM1 > 0 && NDM0 > 0 && NSH1 + NSH0 < 3) |
{ |
unsigned char HwoBD = 0; char Sh0BD = 1, Sh1BD = 1; |
for (int i = 0; i < 8; i++) |
{ |
char ShBD = Pos.SH[PoleToNum(i, 7 - i)]; |
if (ShBD == 1 + Pos.Move) Sh1BD++; |
else if (ShBD == 2 - Pos.Move) Sh0BD++; |
else if (ShBD == 3 + Pos.Move) HwoBD |= 2; |
else if (ShBD == 4 - Pos.Move) HwoBD |= 1; |
} |
if (HwoBD == 2) NextPreim += 128 / Sh0BD; |
if (HwoBD == 1) NextPreim -= 128 / Sh1BD; |
if (NDM1 >= 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0 && HwoBD == 1) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (int i = 0; i < 4; i++) Add |= |
(char(Pos.SH[Best4P[i][0]] == 3 + Pos.Move) * 3 + |
char(Pos.SH[Best4P[i][1]] == 3 + Pos.Move)); |
if (Add >= 4) NextPreim += 32; else if (Add == 3) NextPreim += 24; |
else if (Add >= 1) NextPreim += 16; |
} |
else if (NDM0 >= 3 && NDM1 == 1 && NSH0 == 0 && NSH1 == 0 && HwoBD == 2) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (int i = 0; i < 4; i++) Add |= |
(char(Pos.SH[Best4P[i][0]] == 4 - Pos.Move) * 3 + |
char(Pos.SH[Best4P[i][1]] == 4 - Pos.Move)); |
if (Add >= 4) NextPreim -= 32; else if (Add == 3) NextPreim -= 24; |
else if (Add >= 1) NextPreim -= 16; |
} |
} |
else |
{ |
for (int i = 0; i < 32; i++) |
{ |
char Color = Pos.SH[i] - 1; |
if (Color == 0 || Color == 1) |
{ |
char qi = Color ? (31 - i) : i; |
char Zn = Color ? -1 : 1; |
char PreZ = (Color == Pos.Move) ? 1 : -1; |
if (Pos.SH[i + Zn * 8] != 2 - Color) |
{ |
if (qi / 4 == 2) |
{ |
char IsFree = 0; |
if (Pos.SH[i - Zn * 4] == 2 - Color) IsFree += 2; |
else if (qi != 8) |
{ |
if (Pos.SH[i - Zn ] == 2 - Color || |
Pos.SH[i - Zn * 9] == 2 - Color) IsFree += 2; |
else if (Color != Pos.Move) |
if (Pos.SH[i - Zn * 5] == 2 - Color) IsFree++; |
} |
if (qi == 11) IsFree += 2; |
else if (Pos.SH[i + Zn ] == 2 - Color || |
Pos.SH[i - Zn * 3] == 2 - Color || |
Pos.SH[i - Zn * 7] == 2 - Color) IsFree += 2; |
else if (Color != Pos.Move && qi != 10) |
if (Pos.SH[i - Zn * 2] == 2 - Color) IsFree++; |
if (IsFree < 3) NextPreim += PreZ * 176 / (1 + NDM0 + NDM1); |
else if (qi == 9 || qi == 10) NextPreim += |
PreZ * 128 / (1 + NDM0 + NDM1); |
} |
else if (qi / 4 == 3) |
{ |
char IsFree = 0; |
if (Pos.SH[i - Zn * 12] == 2 - Color) |
{if (Color == Pos.Move) IsFree += 11; else IsFree += 12;} |
else if (Pos.SH[i - Zn * 4] == 2 - Color) IsFree += 11; |
else if (qi == 15) IsFree += 5; |
else if (Pos.SH[i - Zn * 7] == 2 - Color) IsFree += 9; |
else if (Pos.SH[i + Zn] == 2 - Color) IsFree += 8; |
else if (Pos.SH[i - Zn * 11] == 2 - Color) |
{if (Color == Pos.Move) IsFree += 5; else IsFree += 7;} |
else if (Pos.SH[i - Zn * 3] == 2 - Color) IsFree += 5; |
else if (qi != 14) |
{ |
if (Pos.SH[i - Zn * 6] == 2 - Color) IsFree += 3; |
else if (Color != Pos.Move) |
if (Pos.SH[i - Zn * 10] == 2 - Color) IsFree++; |
} |
if (qi == 12) IsFree += 7; |
else if (Pos.SH[i - Zn * 13] == 2 - Color) |
{if (Color == Pos.Move) IsFree += 11; else IsFree += 12;} |
else if (Pos.SH[i - Zn * 5] == 2 - Color) IsFree += 11; |
else if (Pos.SH[i - Zn * 9] == 2 - Color) IsFree += 9; |
else if (Pos.SH[i - Zn] == 2 - Color) IsFree += 8; |
else if (qi != 13) |
{ |
if (Pos.SH[i - Zn * 14] == 2 - Color) |
{if (Color == Pos.Move) IsFree += 5; else IsFree += 7;} |
else if (Pos.SH[i - Zn * 6] == 2 - Color) IsFree += 5; |
else if (Pos.SH[i - Zn * 10] == 2 - Color) IsFree += 3; |
else if (Color != Pos.Move && qi != 14) |
if (Pos.SH[i - Zn * 15] == 2 - Color) IsFree++; |
} |
if (IsFree < ((Color == Pos.Move) ? 14 : 12)) |
NextPreim += PreZ * 160 / (1 + NDM0 + NDM1); |
} |
} |
} |
} |
} |
} |
else if (IsNP258 && NextPreim < 16777216 && NextPreim > -16777216) |
{ |
char NSH1 = 0, NSH0 = 0, NDM1 = 0, NDM0 = 0; |
for (int i = 0; i < 32; i++) |
{ |
if (Pos.SH[i] == 1 + Pos.Move) NSH1++; |
else if (Pos.SH[i] == 2 - Pos.Move) NSH0++; |
else if (Pos.SH[i] == 3 + Pos.Move) NDM1++; |
else if (Pos.SH[i] == 4 - Pos.Move) NDM0++; |
} |
if (NDM1 > 0 && NDM0 > 0 && NSH1 == 0 && NSH0 == 0) |
{ |
short PrP = 0; char Cpos3 = -1; |
if (NDM1 == 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0) Cpos3 = 1; |
else if (NDM1 == 1 && NDM0 == 3 && NSH1 == 0 && NSH0 == 0) Cpos3 = 0; |
if (Cpos3 >= 0) |
{ |
for (char Osm = 0; Osm <= 1; Osm++) for (char Csm = 0; Csm <= 1; Csm++) |
{ |
char PosSH[7][3] = {{13, 17, 18}, {6, 17, 18}, {9, 21, 22}, |
{17, 18, 19}, {9, 10, 15}, {11, 14, 18}, {2, 14, 18}}; |
for (char PosNi = 0; PosNi < 7; PosNi++) |
{ |
bool IsPosR = 1; |
for (char ShNi = 0; ShNi < 3; ShNi++) |
{ |
char DNomSh = (Csm == 1) ? (31 - PosSH[PosNi][ShNi]) |
: PosSH[PosNi][ShNi]; |
if (Osm == 1) {int x, y; NumToPole(DNomSh, x, y); |
DNomSh = PoleToNum(y, x);} |
if (Pos.SH[DNomSh] != 3 + (Cpos3 == Pos.Move)) IsPosR = 0; |
} |
if (IsPosR) |
{ |
if (PosNi == 3) |
{ |
if (Cpos3 == 1) {if (Pos.SH[(Csm == 1) ? 29 : 2] != |
4 - (Cpos3 == Pos.Move) && Pos.SH[(Csm == 1) ? 11 : 20] |
!= 4 - (Cpos3 == Pos.Move)) PrP = 216;} |
else |
{ |
bool PrPZ = 1; |
for (int i = 0; i < 6; i++) |
if (Pos.SH[PoleToNum((Csm == 1) ? (i + 2) : i, |
(Csm == 1) ? (7 - i) : (5 - i))] == |
4 - (Cpos3 == Pos.Move)) PrPZ = 0; |
if (PrPZ) PrP = -216; |
} |
} |
else if (PosNi == 4) |
{ |
if (Cpos3 == 1) |
{if (Pos.SH[ 0] != 4 - (Cpos3 == Pos.Move) |
&& Pos.SH[ 4] != 4 - (Cpos3 == Pos.Move) |
&& Pos.SH[27] != 4 - (Cpos3 == Pos.Move) |
&& Pos.SH[31] != 4 - (Cpos3 == Pos.Move)) PrP = 216;} |
else {if (Pos.SH[(Csm == Osm) ? 4 : 0] != 4 - (Cpos3 == Pos.Move) |
&& Pos.SH[(Csm == Osm) ? 8 : 5] != 4 - (Cpos3 == Pos.Move) |
&& Pos.SH[(Csm == Osm) ? 26 : 23] != 4 - (Cpos3 == Pos.Move) |
&& Pos.SH[(Csm == Osm) ? 31 : 27] != 4 - (Cpos3 == Pos.Move)) |
PrP = -216;} |
} |
else if (PosNi == 5) |
{ |
char DNomSh = (Cpos3 == 1) ? ((Osm == 1) ? 16 : 6) |
: ((Osm == 1) ? 20 : 2); |
if (Csm == 1) DNomSh = 31 - DNomSh; |
if (Pos.SH[DNomSh] == 4 - (Cpos3 == Pos.Move)) |
PrP = (Cpos3 == 1) ? 160 : -160; |
} |
else if (PosNi == 6) |
{ |
if (Cpos3 == 1) |
{if (Pos.SH[ 1] == 4 - (Cpos3 == Pos.Move) |
|| Pos.SH[12] == 4 - (Cpos3 == Pos.Move) |
|| Pos.SH[19] == 4 - (Cpos3 == Pos.Move) |
|| Pos.SH[30] == 4 - (Cpos3 == Pos.Move)) PrP = 168;} |
else |
{if (Pos.SH[(Csm == 1) ? 15 : 6] == 4 - (Cpos3 == Pos.Move) |
|| Pos.SH[(Csm == 1) ? 25 : 16] == 4 - (Cpos3 == Pos.Move)) |
PrP = -168;} |
} |
else PrP = ((Cpos3 == 1) ? 1 : -1) * ((PosNi == 0) ? 200 : 208); |
} |
} |
} |
} |
if (PrP == 0) |
{ |
unsigned char HwoBD = 0; char NShSBD = 0; |
for (int i = 0; i < 8; i++) |
{ |
char ShBD = Pos.SH[PoleToNum(i, 7 - i)]; |
if (ShBD == 3 + Pos.Move) {HwoBD |= 2; NShSBD++;} |
else if (ShBD == 4 - Pos.Move) {HwoBD |= 1; NShSBD++;} |
} |
if (NDM1 >= 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0 && HwoBD == 2) |
{ |
if (NShSBD >= 1) NextPreim -= NShSBD - 1; |
if (Pos.SH[ 3] == 3 + Pos.Move) NextPreim--; |
if (Pos.SH[28] == 3 + Pos.Move) NextPreim--; |
char Drg1 = 0; bool Drg1p = 0; char DrgPS = 0; |
for (int i = 0; i < 7; i++) |
{ |
char Sh7D = Pos.SH[PoleToNum(i, i + 1)]; |
if (Sh7D == 3 + Pos.Move) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 4 - Pos.Move) Drg1p = 1; |
Sh7D = Pos.SH[PoleToNum(i + 1, i)]; |
if (Sh7D == 3 + Pos.Move) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 4 - Pos.Move) Drg1p = 1; |
} |
if (Pos.SH[0] == 3 + Pos.Move || Pos.SH[4] == 3 + Pos.Move || |
Pos.SH[27] == 3 + Pos.Move || Pos.SH[31] == 3 + Pos.Move) |
{if (Drg1p) NextPreim += 4; else NextPreim -= 1;} |
if ((Pos.SH[14] == 3 + Pos.Move) == (Pos.SH[17] == 3 + Pos.Move)) |
{if (Drg1 == 1) NextPreim += 2;} |
else |
{ |
if (Drg1 >= 2) |
{ |
if (Drg1 > 2) NextPreim -= 1; |
if (DrgPS == 3) NextPreim += 4; |
if (Drg1p) NextPreim += 4; else NextPreim += 16; |
if (!Drg1p && DrgPS) |
{ |
Drg1 = 0; Drg1p = 0; DrgPS = 0; |
for (int i = 0; i < 6; i++) |
{ |
char Sh7D = Pos.SH[PoleToNum(i, 5 - i)]; |
if (Sh7D == 3 + Pos.Move) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 4 - Pos.Move) Drg1p = 1; |
Sh7D = Pos.SH[PoleToNum(i + 2, 7 - i)]; |
if (Sh7D == 3 + Pos.Move) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 4 - Pos.Move) Drg1p = 1; |
} |
if (Pos.SH[2] == 3 + Pos.Move || Pos.SH[11] == 3 + Pos.Move || |
Pos.SH[20] == 3 + Pos.Move || Pos.SH[29] == 3 + Pos.Move) |
NextPreim += 4; |
if ((Pos.SH[14] == 3 + Pos.Move) |
? (Pos.SH[13] == 3 + Pos.Move || Pos.SH[22] == 3 + Pos.Move) |
: (Pos.SH[ 9] == 3 + Pos.Move || Pos.SH[18] == 3 + Pos.Move)) |
{ |
if (Drg1 >= 2) |
{ |
if (DrgPS == 3) NextPreim += 4; |
if (Drg1p) NextPreim += 4; else NextPreim += 16; |
} |
else if (Drg1 == 1) NextPreim += 1; |
} |
else if (Drg1 == 1) NextPreim += 2; |
} |
} |
} |
} |
else if (NDM0 >= 3 && NDM1 == 1 && NSH0 == 0 && NSH1 == 0 && HwoBD == 1) |
{ |
if (NShSBD >= 1) NextPreim += NShSBD - 1; |
if (Pos.SH[ 3] == 4 - Pos.Move) NextPreim++; |
if (Pos.SH[28] == 4 - Pos.Move) NextPreim++; |
char Drg1 = 0; bool Drg1p = 0; char DrgPS = 0; |
for (int i = 0; i < 7; i++) |
{ |
char Sh7D = Pos.SH[PoleToNum(i, i + 1)]; |
if (Sh7D == 4 - Pos.Move) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 3 + Pos.Move) Drg1p = 1; |
Sh7D = Pos.SH[PoleToNum(i + 1, i)]; |
if (Sh7D == 4 - Pos.Move) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 3 + Pos.Move) Drg1p = 1; |
} |
if (Pos.SH[0] == 4 - Pos.Move || Pos.SH[4] == 4 - Pos.Move || |
Pos.SH[27] == 4 - Pos.Move || Pos.SH[31] == 4 - Pos.Move) |
{if (Drg1p) NextPreim -= 4; else NextPreim += 1;} |
if ((Pos.SH[14] == 4 - Pos.Move) == (Pos.SH[17] == 4 - Pos.Move)) |
{if (Drg1 == 1) NextPreim -= 2;} |
else |
{ |
if (Drg1 >= 2) |
{ |
if (Drg1 > 2) NextPreim += 1; |
if (DrgPS == 3) NextPreim -= 4; |
if (Drg1p) NextPreim -= 4; else NextPreim -= 16; |
if (!Drg1p && DrgPS) |
{ |
Drg1 = 0; Drg1p = 0; DrgPS = 0; |
for (int i = 0; i < 6; i++) |
{ |
char Sh7D = Pos.SH[PoleToNum(i, 5 - i)]; |
if (Sh7D == 4 - Pos.Move) {Drg1++; DrgPS |= 1;} |
else if (Sh7D == 3 + Pos.Move) Drg1p = 1; |
Sh7D = Pos.SH[PoleToNum(i + 2, 7 - i)]; |
if (Sh7D == 4 - Pos.Move) {Drg1++; DrgPS |= 2;} |
else if (Sh7D == 3 + Pos.Move) Drg1p = 1; |
} |
if (Pos.SH[2] == 4 - Pos.Move || Pos.SH[11] == 4 - Pos.Move || |
Pos.SH[20] == 4 - Pos.Move || Pos.SH[29] == 4 - Pos.Move) |
NextPreim -= 4; |
if ((Pos.SH[14] == 4 - Pos.Move) |
? (Pos.SH[13] == 4 - Pos.Move || Pos.SH[22] == 4 - Pos.Move) |
: (Pos.SH[ 9] == 4 - Pos.Move || Pos.SH[18] == 4 - Pos.Move)) |
{ |
if (Drg1 >= 2) |
{ |
if (DrgPS == 3) NextPreim -= 4; |
if (Drg1p) NextPreim -= 4; else NextPreim -= 16; |
} |
else if (Drg1 == 1) NextPreim -= 1; |
} |
else if (Drg1 == 1) NextPreim -= 2; |
} |
} |
} |
} |
else if (NDM1 >= 3 && NDM0 == 1 && NSH1 == 0 && NSH0 == 0 && HwoBD == 1) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (int i = 0; i < 4; i++) Add |= |
(char(Pos.SH[Best4P[i][0]] == 3 + Pos.Move) * 3 + |
char(Pos.SH[Best4P[i][1]] == 3 + Pos.Move)); |
if (Add >= 4) NextPreim += 3; else if (Add == 3) NextPreim += 2; |
else if (Add >= 1) NextPreim += 1; |
} |
else if (NDM0 >= 3 && NDM1 == 1 && NSH0 == 0 && NSH1 == 0 && HwoBD == 2) |
{ |
char Best4P[4][2] = {{0,9}, {4,13}, {31,22}, {27,18}}; |
char Add = 0; |
for (int i = 0; i < 4; i++) Add |= |
(char(Pos.SH[Best4P[i][0]] == 4 - Pos.Move) * 3 + |
char(Pos.SH[Best4P[i][1]] == 4 - Pos.Move)); |
if (Add >= 4) NextPreim -= 3; else if (Add == 3) NextPreim -= 2; |
else if (Add >= 1) NextPreim -= 1; |
} |
} |
else NextPreim += PrP; |
} |
} |
} |
Parent->TakeMove(Pos, -NextPreim); |
} |
void TakeMove(CompPosition &Pos1, long Preim) |
{ |
if (Preim >= 16777216) Preim--; else if (Preim <= -16777216) Preim++; |
bool b = (NMax == 0 || Preim > NextPreim); if (NMax == 0) NMax = 1; |
if (!b && Preim == NextPreim) {b = (random(NMax + 1) == 0); NMax++;} |
if (b) {if (NomP == BCM_START) *NextPos = Pos1; NextPreim = Preim;} |
} |
CompPosition Pos; int NomP; BestMove *Parent; |
CompPosition *NextPos; char NMax; long NextPreim; |
}; |
class MoveEatParam |
{ |
public: |
char Home; |
char Eaten[15]; char NomEat; |
BestMove* BM; |
MoveEatParam(){} |
char RealPlase(char N) |
{ |
char RP; |
if (N == Home) RP = 0; else RP = BM->Pos.SH[N]; |
for (int i = 0; i < NomEat; i++) if (N == Eaten[i]) RP = 0; |
return RP; |
} |
}; |
void EatContinue(MoveEatParam& MEP, bool IsDMC, char Start, char Kurs) |
{ |
bool IsCanEat = 0; |
int x, y; NumToPole(Start, x, y); |
if (y == 7 - MEP.BM->Pos.Move * 7) IsDMC = 1; |
if (IsDMC) |
{ |
int KursY = Kurs / abs(Kurs); int KursX = Kurs - KursY * 2; |
for (int i = x, j = y; |
i >= 0 && j >= 0 && i < 8 && j < 8; |
i += KursX, j += KursY) |
{ |
int Shash = MEP.RealPlase(PoleToNum(i, j)); |
if (Shash == 2 - MEP.BM->Pos.Move || Shash == 4 - MEP.BM->Pos.Move) |
{ |
if (i + KursX >= 0 && j + KursY >= 0 && i + KursX < 8 && j + KursY < 8) |
if (MEP.RealPlase(PoleToNum(i + KursX, j + KursY)) == 0) |
{ |
IsCanEat = 1; |
MEP.Eaten[MEP.NomEat++] = PoleToNum(i, j); |
EatContinue(MEP, 1, PoleToNum(i + KursX, j + KursY), |
KursX + 2 * KursY); |
MEP.NomEat--; |
} |
break; |
} |
else if (Shash == 1 + MEP.BM->Pos.Move || Shash == 3 + MEP.BM->Pos.Move) break; |
else for (int Rotate = -1; Rotate <= 1; Rotate += 2) |
for (int i1 = i + KursY * Rotate, j1 = j - KursX * Rotate; |
i1 >= 0 && j1 >= 0 && i1 < 8 && j1 < 8; |
i1 += KursY * Rotate, j1 -= KursX * Rotate) |
{ |
int Shash = MEP.RealPlase(PoleToNum(i1, j1)); |
if (Shash == 2 - MEP.BM->Pos.Move || Shash == 4 - MEP.BM->Pos.Move) |
{ |
if (i1 + KursY * Rotate >= 0 && j1 - KursX * Rotate >= 0 && |
i1 + KursY * Rotate < 8 && j1 - KursX * Rotate < 8) |
if (MEP.RealPlase(PoleToNum(i1 + KursY * Rotate, j1 - KursX * Rotate)) == 0) |
{ |
IsCanEat = 1; |
MEP.Eaten[MEP.NomEat++] = PoleToNum(i1, j1); |
EatContinue(MEP, 1, PoleToNum(i1 + KursY * Rotate, |
j1 - KursX * Rotate), |
KursY * Rotate - 2 * KursX * Rotate); |
MEP.NomEat--; |
} |
break; |
} |
else if (Shash == 1 + MEP.BM->Pos.Move || Shash == 3 + MEP.BM->Pos.Move) break; |
} |
} |
if (!IsCanEat) |
{ |
for (int ii = x, jj = y; ii >= 0 && jj >= 0 && |
ii < 8 && jj < 8; ii += KursX, jj += KursY) |
{ |
if (MEP.RealPlase(PoleToNum(ii, jj)) != 0) break; |
BestMove BMove(MEP.BM->Pos, MEP.BM); BMove.Pos.SH[MEP.Home] = 0; |
for (int i = 0; i < MEP.NomEat; i++) {BMove.Pos.SH[MEP.Eaten[i]] = 0;} |
BMove.Pos.SH[PoleToNum(ii, jj)] = 3 + MEP.BM->Pos.Move; |
BMove.Pos.Move = !BMove.Pos.Move; |
BMove.StartMove(); |
} |
} |
} |
else |
{ |
for (int i = -1; i <= 1; i += 2) for (int j = -1; j <= 1; j += 2) |
if (i + 2 * j != -Kurs) if (x + 2 * i >= 0 |
&& y + 2 * j >= 0 && x + 2*i < 8 && y + 2 * j < 8) |
{ |
char FESH = PoleToNum(x + i, y + j); char FESHrp = MEP.RealPlase(FESH); |
char FMSH = PoleToNum(x + 2 * i, y + 2 * j); |
if ((FESHrp == 2 - MEP.BM->Pos.Move || FESHrp == 4 - MEP.BM->Pos.Move) |
&& MEP.RealPlase(FMSH) == 0) |
{ |
IsCanEat = 1; |
MEP.Eaten[MEP.NomEat++] = FESH; |
EatContinue(MEP, 0, FMSH, i + 2 * j); |
MEP.NomEat--; |
} |
} |
if (!IsCanEat) |
{ |
BestMove BMove(MEP.BM->Pos, MEP.BM); BMove.Pos.SH[MEP.Home] = 0; |
for (int i = 0; i < MEP.NomEat; i++) {BMove.Pos.SH[MEP.Eaten[i]] = 0;} |
BMove.Pos.SH[Start] = 1 + MEP.BM->Pos.Move; |
BMove.Pos.Move = !BMove.Pos.Move; |
BMove.StartMove(); |
} |
} |
} |
bool MoveEat(BestMove* BM) |
{ |
bool IsCanEat = 0; |
MoveEatParam MEP; MEP.BM = BM; |
for (MEP.Home = 0; MEP.Home < 32; MEP.Home++) |
{ |
if (BM->Pos.SH[MEP.Home] == 1 + BM->Pos.Move) |
{ |
int x, y; NumToPole(MEP.Home, x, y); |
for (int i = -1; i <= 1; i += 2) for (int j = -1; j <= 1; j += 2) |
if (x + 2*i >= 0 && y + 2*j >= 0 && x + 2*i < 8 && y + 2*j < 8) |
{ |
int FESH = PoleToNum(x + i, y + j); |
int FMSH = PoleToNum(x + 2 * i, y + 2 * j); |
if ((BM->Pos.SH[FESH] == 2 - BM->Pos.Move || BM->Pos.SH[FESH] == 4 - BM->Pos.Move) |
&& BM->Pos.SH[FMSH] == 0) |
{ |
IsCanEat = 1; |
MEP.NomEat = 1; MEP.Eaten[0] = FESH; |
EatContinue(MEP, 0, FMSH, i + 2 * j); |
} |
} |
} |
else if (BM->Pos.SH[MEP.Home] == 3 + BM->Pos.Move) |
{ |
int x, y; NumToPole(MEP.Home, x, y); |
for (int i = -1; i <= 1; i += 2) for (int j = -1; j <= 1; j += 2) |
for (int a = x + i, b = y + j; |
a >= 0 && b >= 0 && a < 8 && b < 8; |
a += i, b += j) |
{ |
char Shash = PoleToNum(a, b); |
char Shash1 = PoleToNum(a + i, b + j); |
if (BM->Pos.SH[Shash] == 2 - BM->Pos.Move || BM->Pos.SH[Shash] == 4 - BM->Pos.Move) |
{ |
if (a + i >= 0 && b + j >= 0 && a + i < 8 && b + j < 8) |
if (BM->Pos.SH[Shash1] == 0) |
{ |
IsCanEat = 1; |
MEP.NomEat = 1; MEP.Eaten[0] = Shash; |
EatContinue(MEP, 1, Shash1, i + 2 * j); |
} |
break; |
} |
else if (BM->Pos.SH[Shash] == 1 + BM->Pos.Move || BM->Pos.SH[Shash] == 3 + BM->Pos.Move) break; |
} |
} |
} |
return IsCanEat; |
} |
bool MovePr(BestMove* BM) |
{ |
bool IsCanMove = 0; |
for (int N = 0; N < 32; N++) |
{ |
if (BM->Pos.SH[N] == 1 + BM->Pos.Move) |
{ |
int x, y; NumToPole(N, x, y); |
int j = 1 - 2 * BM->Pos.Move; |
for (int i = -1; i <= 1; i += 2) |
if (x + i >= 0 && y + j >= 0 && x + i < 8 && y + j < 8) |
{ |
int FMSH = PoleToNum(x + i, y + j); |
if (BM->Pos.SH[FMSH] == 0) |
{ |
IsCanMove = 1; |
BestMove BMove(BM->Pos, BM); BMove.Pos.SH[N] = 0; |
BMove.Pos.SH[FMSH] = 1 + BM->Pos.Move + 2 * |
(y + j == 7 - BM->Pos.Move * 7); |
BMove.Pos.Move = !BMove.Pos.Move; |
BMove.StartMove(); |
} |
} |
} |
else if (BM->Pos.SH[N] == 3 + BM->Pos.Move) |
{ |
int x, y; NumToPole(N, x, y); |
for (int i = -1; i <= 1; i += 2) for (int j = -1; j <= 1; j += 2) |
for (int a = x + i, b = y + j; |
a >= 0 && b >= 0 && a < 8 && b < 8; |
a += i, b += j) |
{ |
if (BM->Pos.SH[PoleToNum(a, b)] != 0) break; |
IsCanMove = 1; |
BestMove BMove(BM->Pos, BM); BMove.Pos.SH[N] = 0; |
BMove.Pos.SH[PoleToNum(a, b)] = 3 + BM->Pos.Move; |
BMove.Pos.Move = !BMove.Pos.Move; |
BMove.StartMove(); |
} |
} |
} |
return IsCanMove; |
} |
int StartMove(Position& Pos, bool CompColor) |
{ |
CompPosition Pos1; Pos1.Init(Pos, CompColor); |
BestMove MainMove(Pos1); MainMove.NomP = BCM_START; |
MainMove.NextPos = &Pos1; |
if (!MoveEat(&MainMove)) if (!MovePr(&MainMove)) return 1; |
Pos = Pos1; MainMove.Pos = Pos1; |
MainMove.NomP = BCM_ISM1; |
if (!MoveEat(&MainMove)) if (!MovePr(&MainMove)) return -1; |
return 0; |
} |
#undef BCM_ISM1 |
#undef BCM_START |
} |
class TemporaryPlayer : public TChPlayer |
{ |
public: |
TemporaryPlayer() {} |
virtual int Move(PMv &pmv); |
}; |
int TemporaryPlayer::Move(PMv &pmv) |
{ |
TComputerPlayer::Z z; |
z.FindAllMoves(pmv); |
if (z.narr <= 0) return 0; |
int r, s = ComputerMove::StartMove(pmv.pos, pmv.pos.wmove); |
if (s > 0) return 0; |
for (r = 0; r < z.narr; r++) |
{ |
if (memcmp(z.array[r].pos.SH, pmv.pos.SH, sizeof(pmv.pos.SH)) == 0) |
{ |
pmv = z.array[r]; |
return 1; |
} |
} |
return 0; |
} |
#endif //_HEADER_TMP_PLAYER_H |
/programs/games/checkers/trunk/win-chk.rc |
---|
0,0 → 1,106 |
#define IDC_DEBUG 22003 |
#define IDC_COPYRIGHT 22002 |
#define IDC_VERSION 22001 |
#include <windows.h> |
#include "winabout.rh" |
WinDrawIcon ICON |
{ |
'00 00 01 00 01 00 20 20 10 00 00 00 00 00 E8 02' |
'00 00 16 00 00 00 28 00 00 00 20 00 00 00 40 00' |
'00 00 01 00 04 00 00 00 00 00 80 02 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 80 00 00 80 00 00 00 80 80 00 80 00' |
'00 00 80 00 80 00 80 80 00 00 C0 C0 C0 00 80 80' |
'80 00 00 00 FF 00 00 FF 00 00 00 FF FF 00 FF 00' |
'00 00 FF 00 FF 00 FF FF 00 00 FF FF FF 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 11 11 11 11 11 11 00 00 00 00 00 00 00' |
'00 19 11 11 11 11 11 11 11 10 11 00 00 00 00 00' |
'19 11 19 11 11 11 11 11 01 11 01 01 00 00 00 19' |
'11 91 91 11 11 11 11 11 11 01 10 10 11 00 01 91' |
'91 11 19 11 11 11 11 11 11 11 01 11 00 00 01 91' |
'19 91 91 11 11 11 11 11 11 01 10 10 11 00 99 19' |
'91 19 11 99 99 99 99 99 99 10 11 00 00 00 99 11' |
'91 99 99 99 99 99 99 99 99 99 99 11 10 00 99 19' |
'99 99 99 11 11 11 11 11 11 99 99 99 91 00 91 99' |
'99 11 11 11 11 11 11 11 11 11 11 99 99 00 99 99' |
'11 91 11 99 99 99 99 99 99 11 19 11 99 90 19 91' |
'99 19 99 91 11 11 11 11 19 99 91 99 19 91 19 91' |
'91 99 99 19 19 99 99 91 91 99 99 19 19 91 19 91' |
'91 99 99 19 19 99 99 91 91 99 99 19 19 91 19 91' |
'99 19 99 91 11 11 11 11 19 99 91 99 19 91 01 99' |
'11 91 11 99 99 99 99 99 99 11 19 11 99 10 00 19' |
'99 11 11 11 11 11 11 11 11 11 11 99 91 00 00 01' |
'11 99 99 11 11 11 11 11 11 99 99 11 10 00 00 00' |
'00 11 11 99 99 99 99 99 99 11 11 00 00 00 00 00' |
'00 00 00 11 11 11 11 11 11 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF FF' |
'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF' |
'FF FF FF FF FF FF FF C0 03 FF FC 00 00 3F F0 00' |
'00 0F C0 00 00 03 80 00 00 01 80 00 00 01 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00' |
'00 00 80 00 00 01 C0 00 00 03 E0 00 00 07 FC 00' |
'00 3F FF C0 03 FF FF FF FF FF FF FF FF FF FF FF' |
'FF FF FF FF FF FF FF FF FF FF FF FF FF FF' |
} |
1 VERSIONINFO |
FILEVERSION 1, 0, 1, 0 |
PRODUCTVERSION 1, 0, 1, 0 |
FILEFLAGSMASK 0 |
FILEFLAGS VS_FFI_FILEFLAGSMASK |
FILEOS VOS__WINDOWS32 |
FILETYPE VFT_APP |
{ |
BLOCK "StringFileInfo" |
{ |
BLOCK "040904E4" |
{ |
VALUE "FileDescription", "Checkers for Windows\000" |
VALUE "FileVersion", "1.01\000" |
VALUE "InternalName", "Checkers\000" |
VALUE "LegalCopyright", "Copyright © 2003. Rumyantsev Andrey.\000" |
VALUE "OriginalFilename", "WinCheckers.exe\000" |
VALUE "ProductName", "Checkers\000" |
VALUE "ProductVersion", "1.01\000" |
} |
} |
BLOCK "VarFileInfo" |
{ |
VALUE "Translation", 0x0409, 0x04e4 |
} |
} |
IDD_ABOUT1 DIALOG 41, 33, 204, 65 |
EXSTYLE WS_EX_DLGMODALFRAME |
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU |
CAPTION "About Checkers" |
FONT 8, "MS Sans Serif" |
{ |
CONTROL "Version", IDC_VERSION, "STATIC", SS_CENTER | SS_NOPREFIX | WS_CHILD | WS_VISIBLE | WS_GROUP, 28, 14, 174, 8 |
CONTROL "C H E C K E R S", -1, "STATIC", SS_CENTER | SS_NOPREFIX | WS_CHILD | WS_VISIBLE | WS_GROUP, 28, 4, 174, 8 |
CONTROL "", IDC_COPYRIGHT, "STATIC", SS_CENTER | SS_NOPREFIX | WS_CHILD | WS_VISIBLE | WS_GROUP, 28, 27, 174, 17 |
CONTROL "", IDC_DEBUG, "STATIC", SS_RIGHT | SS_NOPREFIX | WS_CHILD | WS_VISIBLE | WS_GROUP, 136, 55, 66, 8 |
CONTROL "WinDrawIcon", -1, "STATIC", SS_ICON | WS_CHILD | WS_VISIBLE, 8, 8, 21, 20 |
CONTROL "OK", IDOK, "BUTTON", BS_DEFPUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 76, 46, 40, 14 |
} |
/programs/games/checkers/trunk/win-chk.res |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/programs/games/checkers/trunk/win-draw.h |
---|
0,0 → 1,530 |
#ifndef _Windows |
# error Can't include this file without windows |
#endif |
#include "gr-draw.h" |
#ifndef _WIN_GRAPHIC_DRAW_H |
#define _WIN_GRAPHIC_DRAW_H |
#include "winabout.h" |
#include "keysym.h" |
#include <windows.h> |
#include <owl\window.h> |
#include <owl\framewin.h> |
#include <owl\dialog.h> |
#include <owl\checkbox.h> |
#include <owl\edit.h> |
#include <owl\applicat.h> |
#define main OwlMain |
class TWinGraphDraw : public TGraphDraw |
{ |
public: |
TWinGraphDraw(const char *s = 0); |
~TWinGraphDraw(); |
public: |
static const int CM_ABOUT; |
static unsigned long GetKeySym(unsigned int key); |
protected: |
class TDrwWindow : public TWindow |
{ |
public: |
TDrwWindow(TWinGraphDraw *drw) : TWindow(), win_draw(drw) |
{ |
Init((TWindow*)NULL, 0, 0); |
} |
TColor GetBkgndColor() const {return BkgndColor;} |
protected: |
void SetupWindow(); |
bool CanClose(); |
void Paint(TDC &dc, bool erase, TRect &rect); |
void EvSize(uint sizeType, TSize &size) {Invalidate();} |
void EvLButtonDblClk(uint modKeys, TPoint& point) {EvLButtonDown(modKeys, point);} |
void EvLButtonDown(uint modKeys, TPoint& point); |
void EvLButtonUp(uint modKeys, TPoint& point); |
void EvRButtonDblClk(uint modKeys, TPoint& point) {EvRButtonDown(modKeys, point);} |
void EvRButtonDown(uint modKeys, TPoint& point); |
void EvRButtonUp(uint modKeys, TPoint& point); |
void EvMButtonDblClk(uint modKeys, TPoint& point) {EvMButtonDown(modKeys, point);} |
void EvMButtonDown(uint modKeys, TPoint& point); |
void EvMButtonUp(uint modKeys, TPoint& point); |
void EvMouseMove(uint modKeys, TPoint& point); |
void EvKeyDown(uint key, uint repeatCount, uint flags); |
void EvKeyUp(uint key, uint repeatCount, uint flags); |
public: |
TWinGraphDraw *win_draw; |
DECLARE_RESPONSE_TABLE(TDrwWindow); |
}; |
class TDrwFrameWindow : public TFrameWindow |
{ |
public: |
TDrwFrameWindow(TWindow *parent, TDrwWindow *client); |
protected: |
virtual void SetupWindow(); |
void EvSysCommand(uint cmdType, TPoint& point); |
public: |
TWinGraphDraw *win_draw; |
DECLARE_RESPONSE_TABLE(TDrwFrameWindow); |
}; |
class TDrwApplication : public TApplication |
{ |
public: |
TDrwApplication(TWinGraphDraw *drw, int w = 0, int h = 0) |
: def_w(w), def_h(h), win_draw(drw) {} |
void InitMainWindow() |
{ |
win_draw->win = new TDrwWindow(win_draw); |
SetMainWindow(new TDrwFrameWindow(0, win_draw->win)); |
GetMainWindow()->SetIcon(this, "WinDrawIcon"); |
GetMainWindow()->SetIconSm(this, "WinDrawIcon"); |
if (def_w > 0 && def_h > 0) |
{ |
GetMainWindow()->Attr.W = def_w + 2*GetSystemMetrics(SM_CXFRAME); |
GetMainWindow()->Attr.H = def_h + |
GetSystemMetrics(SM_CYCAPTION) + 2*GetSystemMetrics(SM_CYFRAME); |
} |
} |
public: |
int def_w, def_h; |
TWinGraphDraw *win_draw; |
}; |
friend class TDrwWindow; |
friend class TDrwApplication; |
protected: |
TDrwApplication app; |
TDrwWindow *win; |
TDC *dc; |
int kind_dc; |
TColor bgcolor; |
int evmask, quit; |
public: |
unsigned long GetBgColor(); |
void SetBgColor(unsigned long c); |
void SetTitle(const char *s); |
int GetStatus() {return win ? 1 : 0;} |
int Init() {return 0;} |
int Run(int evmask = 0, int w = INT_MIN, int h = INT_MIN); |
void GetSize(int &w, int &h); |
int OpenDraw(); |
int IsDraw() {return win && dc;} |
void CloseDraw(); |
int SetColor(unsigned long c); |
int DrawLine(int x0, int y0, int x1, int y1); |
int DrawText(int x0, int y0, char *text); |
int DrawClear(); |
int GetTextH(const char *s); |
int GetTextW(const char *s); |
void Quit(int q = 1); |
}; |
const int TWinGraphDraw::CM_ABOUT = 7128; |
unsigned long TWinGraphDraw::GetKeySym(uint key) |
{ |
switch(key) |
{ |
case 37: return XK_Left; |
case 39: return XK_Right; |
case 38: return XK_Up; |
case 40: return XK_Down; |
case 13: return XK_Return; |
case 32: return XK_space; |
case 27: return XK_Escape; |
case 188: return XK_comma; |
case 190: return XK_period; |
case 189: return XK_minus; |
case 187: return XK_equal; |
case 46: return XK_Delete; |
case 191: return XK_slash; |
case 112: return XK_F1; |
case 113: return XK_F2; |
case 114: return XK_F3; |
case 115: return XK_F4; |
case 116: return XK_F5; |
case 117: return XK_F6; |
case 118: return XK_F7; |
case 119: return XK_F8; |
case 120: return XK_F9; |
case 121: return XK_F10; |
case 122: return XK_F11; |
case 123: return XK_F12; |
case 65: return XK_a; |
case 66: return XK_b; |
case 67: return XK_c; |
case 68: return XK_d; |
case 69: return XK_e; |
case 70: return XK_f; |
case 71: return XK_g; |
case 72: return XK_h; |
case 73: return XK_i; |
case 74: return XK_j; |
case 75: return XK_k; |
case 76: return XK_l; |
case 77: return XK_m; |
case 78: return XK_n; |
case 79: return XK_o; |
case 80: return XK_p; |
case 81: return XK_q; |
case 82: return XK_r; |
case 83: return XK_s; |
case 84: return XK_t; |
case 85: return XK_u; |
case 86: return XK_v; |
case 87: return XK_w; |
case 88: return XK_x; |
case 89: return XK_y; |
case 90: return XK_z; |
default: return XK_VoidSymbol; |
} |
} |
TWinGraphDraw::TWinGraphDraw(const char *s) |
: TGraphDraw(s), app(this), dc(0), kind_dc(0) |
{ |
bgcolor = GetWhiteColor(); |
} |
TWinGraphDraw::~TWinGraphDraw() |
{ |
CloseDraw(); |
dc = 0; kind_dc = 0; win = 0; |
} |
unsigned long TWinGraphDraw::GetBgColor() |
{ |
if (win) bgcolor = win->GetBkgndColor(); |
return bgcolor.GetValue(); |
} |
void TWinGraphDraw::SetBgColor(unsigned long c) |
{ |
bgcolor.SetValue(c); |
if (win) win->SetBkgndColor(bgcolor); |
} |
void TWinGraphDraw::SetTitle(const char *s) |
{ |
TGraphDraw::SetTitle(s); |
if (win) win->SetCaption(s); |
} |
int TWinGraphDraw::Run(int evmask, int w, int h) |
{ |
if (!evfunc) return -2; |
this->evmask = evmask; |
app.def_w = w; app.def_h = h; |
quit = 0; |
app.Run(); |
return quit; |
} |
void TWinGraphDraw::GetSize(int &w, int &h) |
{ |
if (win) |
{ |
TRect rect; |
win->GetWindowRect(rect); |
w = rect.Width(); h = rect.Height(); |
} |
else TGraphDraw::GetSize(w, h); |
} |
int TWinGraphDraw::OpenDraw() |
{ |
if (!win) return 0; |
if (!dc) {dc = new TWindowDC(*win); kind_dc = 1;} |
return 1; |
} |
void TWinGraphDraw::CloseDraw() |
{ |
if (dc && kind_dc == 1) delete dc; |
if (kind_dc <= 2) {dc = 0; kind_dc = 0;} |
} |
int TWinGraphDraw::SetColor(unsigned long c) |
{ |
if (!win || !dc) return 0; |
TColor color(c); |
dc->SelectObject((TPen)color); |
dc->SetTextColor(color); |
return 1; |
} |
int TWinGraphDraw::DrawLine(int x0, int y0, int x1, int y1) |
{ |
if (!win || !dc) return 0; |
dc->MoveTo(x0, y0); |
dc->LineTo(x1, y1); |
return 1; |
} |
int TWinGraphDraw::DrawText(int x0, int y0, char *text) |
{ |
if (!win || !dc) return 0; |
dc->TextOut(x0, y0, text); |
return 1; |
} |
int TWinGraphDraw::DrawClear() |
{ |
if (!win || !dc) return 0; |
dc->FillRect(TRect(TPoint(0, 0), win->GetWindowRect().Size()), bgcolor); |
return 1; |
} |
int TWinGraphDraw::GetTextH(const char *s) |
{ |
if (win) |
{ |
TFont fnt = win->GetWindowFont(); |
return fnt.GetHeight(); |
} |
else return TGraphDraw::GetTextH(s); |
} |
int TWinGraphDraw::GetTextW(const char *s) |
{ |
if (win) |
{ |
TFont fnt = win->GetWindowFont(); |
return fnt.GetMaxWidth() * strlen(s); |
} |
else return TGraphDraw::GetTextW(s); |
} |
void TWinGraphDraw::Quit(int q) |
{ |
quit = q; |
if (quit <= 0) quit = 0; |
else if (win) win->PostMessage(WM_CLOSE); |
} |
DEFINE_RESPONSE_TABLE1(TWinGraphDraw::TDrwFrameWindow, TFrameWindow) |
EV_WM_SYSCOMMAND, |
END_RESPONSE_TABLE; |
TWinGraphDraw::TDrwFrameWindow::TDrwFrameWindow(TWindow *parent, TDrwWindow *client) |
: TFrameWindow(parent, client->win_draw->GetTitle(), client) |
{ |
win_draw = client->win_draw; |
} |
void TWinGraphDraw::TDrwFrameWindow::SetupWindow() |
{ |
TFrameWindow::SetupWindow(); |
if (win_draw->GetAboutInfo() > 0) |
{ |
TMenu menu = GetSystemMenu(false); |
menu.AppendMenu(MF_SEPARATOR); |
menu.AppendMenu(MF_STRING, CM_ABOUT, "&About"); |
} |
} |
void TWinGraphDraw::TDrwFrameWindow::EvSysCommand(uint cmdType, TPoint& point) |
{ |
if (cmdType == CM_ABOUT) |
{ |
char dia_name[50] = "IDD_ABOUT"; |
int dia_num = win_draw->GetAboutInfo(); |
if (dia_num > 0) |
{ |
itoa(dia_num, dia_name + strlen(dia_name), 10); |
TAboutDialog(this, dia_name).Execute(); |
} |
} |
else TFrameWindow::EvSysCommand(cmdType, point); |
} |
DEFINE_RESPONSE_TABLE1(TWinGraphDraw::TDrwWindow, TWindow) |
EV_WM_MOUSEMOVE, |
EV_WM_LBUTTONDBLCLK, |
EV_WM_LBUTTONDOWN, |
EV_WM_LBUTTONUP, |
EV_WM_RBUTTONDBLCLK, |
EV_WM_RBUTTONDOWN, |
EV_WM_RBUTTONUP, |
EV_WM_MBUTTONDBLCLK, |
EV_WM_MBUTTONDOWN, |
EV_WM_MBUTTONUP, |
EV_WM_SIZE, |
EV_WM_KEYDOWN, |
EV_WM_KEYUP, |
END_RESPONSE_TABLE; |
void TWinGraphDraw::TDrwWindow::SetupWindow() |
{ |
TWindow::SetupWindow(); |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0) return; |
event ev; |
ev.type = event::start; |
ev.any.drw = win_draw; |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
bool TWinGraphDraw::TDrwWindow::CanClose() |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 1) return true; |
event ev; |
ev.type = event::close; |
ev.any.drw = win_draw; |
win_draw->quit = win_draw->evfunc(ev); |
if (win_draw->quit <= 0) win_draw->quit = 0; |
win_draw->CloseDraw(); |
return win_draw->quit != 0; |
} |
void TWinGraphDraw::TDrwWindow::Paint(TDC &dc, bool, TRect&) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0) return; |
win_draw->CloseDraw(); |
win_draw->dc = &dc; win_draw->kind_dc = 2; |
event ev; |
ev.type = event::draw; |
ev.any.drw = win_draw; |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvLButtonDown(uint /*modKeys*/, TPoint& point) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & button_down_mask)) return; |
event ev; |
ev.type = event::button_down; |
ev.button.drw = win_draw; |
ev.button.n = 1; |
ev.button.x = point.x; |
ev.button.y = point.y; |
int r = win_draw->evfunc(ev); |
if (r >= 0 && (r & ret_setcapture)) SetCapture(); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvLButtonUp(uint /*modKeys*/, TPoint& point) |
{ |
ReleaseCapture(); |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & button_up_mask)) return; |
event ev; |
ev.type = event::button_up; |
ev.button.drw = win_draw; |
ev.button.n = 1; |
ev.button.x = point.x; |
ev.button.y = point.y; |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvRButtonDown(uint /*modKeys*/, TPoint& point) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & button_down_mask)) return; |
event ev; |
ev.type = event::button_down; |
ev.button.drw = win_draw; |
ev.button.n = 2; |
ev.button.x = point.x; |
ev.button.y = point.y; |
int r = win_draw->evfunc(ev); |
if (r >= 0 && (r & ret_setcapture)) SetCapture(); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvRButtonUp(uint /*modKeys*/, TPoint& point) |
{ |
ReleaseCapture(); |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & button_up_mask)) return; |
event ev; |
ev.type = event::button_up; |
ev.button.drw = win_draw; |
ev.button.n = 2; |
ev.button.x = point.x; |
ev.button.y = point.y; |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvMButtonDown(uint /*modKeys*/, TPoint& point) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & button_down_mask)) return; |
event ev; |
ev.type = event::button_down; |
ev.button.drw = win_draw; |
ev.button.n = 3; |
ev.button.x = point.x; |
ev.button.y = point.y; |
int r = win_draw->evfunc(ev); |
if (r >= 0 && (r & ret_setcapture)) SetCapture(); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvMButtonUp(uint /*modKeys*/, TPoint& point) |
{ |
ReleaseCapture(); |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & button_up_mask)) return; |
event ev; |
ev.type = event::button_up; |
ev.button.drw = win_draw; |
ev.button.n = 3; |
ev.button.x = point.x; |
ev.button.y = point.y; |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvMouseMove(uint /*modKeys*/, TPoint& point) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & (mouse_move_mask | mouse_drag_mask))) return; |
event ev; |
ev.type = event::mouse_move; |
ev.button.drw = win_draw; |
ev.button.n = -1; |
ev.button.x = point.x; |
ev.button.y = point.y; |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvKeyDown(uint key, uint /*repeatCount*/, uint /*flags*/) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & key_down_mask)) return; |
event ev; |
ev.type = event::key_down; |
ev.key.drw = win_draw; |
ev.key.k = GetKeySym(key); |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
void TWinGraphDraw::TDrwWindow::EvKeyUp(uint key, uint /*repeatCount*/, uint /*flags*/) |
{ |
if (!win_draw || !win_draw->evfunc || win_draw->quit > 0 || |
!(win_draw->evmask & key_up_mask)) return; |
event ev; |
ev.type = event::key_up; |
ev.key.drw = win_draw; |
ev.key.k = GetKeySym(key); |
win_draw->evfunc(ev); |
win_draw->CloseDraw(); |
} |
#endif //_WIN_GRAPHIC_DRAW_H |
/programs/games/checkers/trunk/winabout.rh |
---|
0,0 → 1,3 |
#define IDC_DEBUG 22003 |
#define IDC_COPYRIGHT 22002 |
#define IDC_VERSION 22001 |
/programs/games/checkers/trunk |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |
/programs/games/checkers/. |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |