c/app/solitaire.c · 15770 字节 · 下载原文
/* solitaire.c —— 接龙(Klondike,就是 Windows 自带那个纸牌)
* solitaire.c -- Klondike solitaire (the one Windows shipped with)
*
* 玩法(经典 Klondike 规则):
* Rules (classic Klondike):
* ① 7 列牌堆:第 i 列 i+1 张,只有最后一张明着;
* ① seven tableau piles: column i holds i+1 cards, only the last one face up;
* ② 牌堆按**红黑交替、点数递减**叠(红 10 上放黑 9,不能放红 9);空列**只收 K**;
* ② a pile stacks **alternating colors, descending** (a black 9 on a red 10); an empty column
* **takes a King only**;
* ③ 右上 4 个收牌区:同花色从 A 开始往上收,四个都收到 K 就赢;
* ③ four foundations at the top right: same suit ascending from Ace; filling all four to K wins;
* ④ 左上牌堆点一下翻一张到废牌堆,翻完再点就从头循环。
* ④ tapping the stock at the top left turns one card to the waste; when empty, tapping recycles.
*
* 手机没有鼠标拖拽,所以交互是**点选 → 点目标**:
* Phones have no drag, so interaction is **tap to select, tap the target**:
* 点一张明牌(连同它下面连成合法序列的那一摞)= 选中;再点目标列 / 目标收牌区 = 移动;
* tapping a face-up card (with the valid run below it) selects it; tapping a target column or
* foundation moves it;
* 点牌堆 = 翻牌;点已选中的牌 = 取消。
* tapping the stock turns a card; tapping the selection cancels.
*
* 牌编码:`c = suit * 13 + rank`,`suit` 0/1/2/3 = 黑桃/红桃/方块/梅花,`rank` 0..12 = A..K。
* Card encoding: `c = suit * 13 + rank`, suits 0..3 = spades/hearts/diamonds/clubs, rank 0..12 = A..K.
* 花色用字母(S/H/D/C)而不是 ♠♥♦♣:**字形不一定在随包字体里**,缺字形会画成豆腐块。
* Suits are letters (S/H/D/C) rather than pip glyphs: the bundled font may not carry those glyphs,
* and a missing glyph renders as tofu.
*/
#include <vml_ui.h>
#include <stdlib.h>
#include <stdio.h>
#define MAX_FRAMES 60000
#define PILE_MAX 52
#define C_BG 0xFF0C2B1A /* 桌面绿(经典纸牌桌布的颜色关系) */
#define C_SLOT 0xFF10402A
#define C_CARD 0xFFF4F4F0
#define C_BACK 0xFF1E3F8F
#define C_RED 0xFFC02020
#define C_BLACK 0xFF202020
#define C_TEXT 0xFFE8F0E8
#define C_DIM 0xFF9AB0A0
static int SW, SH, g_lang, g_frames;
static int cw, ch, col_w, top_y, tab_y, base_x;
/* 四堆:牌堆 / 废牌 / 收牌区 / 7 列 */
static int stock[PILE_MAX], stock_n;
static int waste[PILE_MAX], waste_n;
static int found[4][13], found_n[4];
static int tab[7][PILE_MAX], tab_up[7][PILE_MAX], tab_n[7];
static int sel_col, sel_idx, sel_waste, won;
static unsigned int seed = 20261124;
static int rnd(int n)
{
seed = seed * 1103515245u + 12345u;
return (int)((seed >> 16) % (unsigned int)n);
}
static int rank_of(int c) { return c % 13; }
static int suit_of(int c) { return c / 13; }
static int is_red(int c) { return suit_of(c) == 1 || suit_of(c) == 2; }
static void relayout(void)
{
SW = ui_scr_get_w();
SH = ui_scr_get_h();
if (SW <= 0) SW = 360;
if (SH <= 0) SH = 620;
col_w = (SW - 8) / 7;
cw = col_w - 3;
ch = cw * 3 / 2;
/* 高度上限:7 张牌最多叠出 4 个卡高(tab_y 里已有 1 个 + 6 段 ch/3) */
/* Height cap: seven cards can stack to four card heights (one in tab_y plus 6 × ch/3). */
{
int maxCh = (SH - 88) / 4;
if (maxCh < 40) maxCh = 40;
if (ch > maxCh) {
ch = maxCh;
cw = ch * 2 / 3;
col_w = cw + 3;
}
}
base_x = (SW - 7 * col_w) / 2;
if (base_x < 4) base_x = 4;
top_y = 64;
tab_y = top_y + ch + 14;
}
/* 列里从上往下的 y(面朝上的牌重叠多一点,看得清点数) */
static int card_y_at(int col, int i)
{
int y = tab_y, k;
for (k = 0; k < i; k++) y += tab_up[col][k] ? ch / 3 : ch / 6;
return y;
}
static void deal(void)
{
int deck[52], n = 52, i, j, c;
for (i = 0; i < 52; i++) deck[i] = i;
for (i = n - 1; i > 0; i--) { /* Fisher–Yates */
j = rnd(i + 1);
c = deck[i]; deck[i] = deck[j]; deck[j] = c;
}
stock_n = 0;
waste_n = 0;
for (i = 0; i < 4; i++) found_n[i] = 0;
for (i = 0; i < 7; i++) tab_n[i] = 0;
c = 0;
for (i = 0; i < 7; i++)
for (j = 0; j <= i; j++) {
tab[i][tab_n[i]] = deck[c];
tab_up[i][tab_n[i]] = (j == i); /* 只有最上面那张明着 */
tab_n[i] = tab_n[i] + 1;
c++;
}
while (c < 52) { stock[stock_n] = deck[c]; stock_n = stock_n + 1; c++; }
sel_col = -1; sel_idx = -1; sel_waste = 0; won = 0;
}
/* 这一摞(从 col 的第 i 张到底)能不能整体搬走:递减 + 红黑交替 */
static int run_ok(int col, int i)
{
int k;
for (k = i; k + 1 < tab_n[col]; k++) {
int a = tab[col][k], b = tab[col][k + 1];
if (!tab_up[col][k] || !tab_up[col][k + 1]) return 0;
if (rank_of(a) != rank_of(b) + 1) return 0;
if (is_red(a) == is_red(b)) return 0;
}
return tab_up[col][i];
}
static int can_place_tab(int col, int card)
{
int top;
if (tab_n[col] == 0) return rank_of(card) == 12; /* 空列只收 K */
top = tab[col][tab_n[col] - 1];
if (!tab_up[col][tab_n[col] - 1]) return 0;
if (rank_of(card) != rank_of(top) - 1) return 0;
return is_red(card) != is_red(top);
}
static int can_place_found(int f, int card)
{
if (suit_of(card) != f) return 0;
if (found_n[f] == 0) return rank_of(card) == 0; /* 收牌区从 A 起 */
return rank_of(card) == found_n[f]; /* 且恰好是下一张 */
}
/* 把 col 从 idx 起到末尾整摞挪到 dst */
static void move_run(int src, int idx, int dst)
{
int k;
for (k = idx; k < tab_n[src]; k++) {
tab[dst][tab_n[dst]] = tab[src][k];
tab_up[dst][tab_n[dst]] = 1;
tab_n[dst] = tab_n[dst] + 1;
}
tab_n[src] = idx;
if (tab_n[src] > 0) tab_up[src][tab_n[src] - 1] = 1; /* 翻出新的明牌 */
}
static void check_win(void)
{
int i;
for (i = 0; i < 4; i++)
if (found_n[i] != 13) return;
won = 1;
}
/* ── 画 ─────────────────────────────────────────────────────────────── */
static void draw_card(int x, int y, int card, int face_up)
{
char r[8];
int color, v = rank_of(card);
ui_2d_rect(x, y, cw, ch, face_up ? C_CARD : C_BACK, 1, 0, 6);
if (!face_up) {
/* 牌背:几条斜线,看着像纹样 */
ui_2d_line(x + 6, y + 6, x + cw - 6, y + ch - 6, 0xFF4A6AB0, 2);
ui_2d_line(x + cw - 6, y + 6, x + 6, y + ch - 6, 0xFF4A6AB0, 2);
return;
}
color = is_red(card) ? C_RED : C_BLACK;
/* 点数:A / 2..10 / J / Q / K(索引 0..12)。⚠ 10 是**两个字符**,别用 p[-1] 那种写法。 */
if (v == 0) { r[0] = 'A'; r[1] = 0; }
else if (v == 9) { r[0] = '1'; r[1] = '0'; r[2] = 0; }
else if (v == 10) { r[0] = 'J'; r[1] = 0; }
else if (v == 11) { r[0] = 'Q'; r[1] = 0; }
else if (v == 12) { r[0] = 'K'; r[1] = 0; }
else { r[0] = (char)('1' + v); r[1] = 0; }
/* 花色:**一个字符**(用 `"SHDC" + n` 那种写法会拿到整串 "SHDC") */
r[3] = "SHDC"[suit_of(card)];
r[4] = 0;
ui_2d_text(x + 5, y + cw / 3, r, color, cw / 3, VML_ANCHOR_LEFT);
ui_2d_text(x + 5, y + cw / 3 + cw / 3, r + 3, color, cw / 4, VML_ANCHOR_LEFT);
/* 选中的牌描一圈亮边(在牌上再画一次细框) */
}
static void draw(void)
{
int i, k;
char buf[16];
ui_2d_clear(C_BG);
/* 顶栏:牌堆 + 废牌 + 4 个收牌区 */
ui_2d_rect(base_x, top_y, cw, ch, C_SLOT, 1, 0, 6);
if (stock_n > 0) draw_card(base_x, top_y, stock[stock_n - 1], 0);
if (waste_n > 0) {
draw_card(base_x + col_w, top_y, waste[waste_n - 1], 1);
if (sel_waste) ui_2d_rect(base_x + col_w, top_y, cw, ch, 0x00000000, 0, 3, 6);
}
for (i = 0; i < 4; i++) {
int x = base_x + 3 * col_w + i * col_w;
ui_2d_rect(x, top_y, cw, ch, C_SLOT, 1, 0, 6);
if (found_n[i] > 0) draw_card(x, top_y, found[i][found_n[i] - 1], 1);
else ui_2d_text(x + cw / 2, top_y + ch / 2, "A", C_DIM, cw / 3, VML_ANCHOR_CENTER);
}
/* 7 列 */
for (i = 0; i < 7; i++) {
int x = base_x + i * col_w;
ui_2d_rect(x, tab_y, cw, ch, C_SLOT, 1, 0, 6);
for (k = 0; k < tab_n[i]; k++)
draw_card(x, card_y_at(i, k), tab[i][k], tab_up[i][k]);
/* 选中:给整摞描一圈(只在最上面那张画个角标,省得满屏线) */
if (sel_col == i && sel_idx >= 0 && sel_idx < tab_n[i]) {
int y = card_y_at(i, sel_idx);
ui_2d_rect(x - 1, y - 1, cw + 2, ch + 2, 0x00000000, 0, 3, 7);
ui_2d_text(x + cw - 4, y + ch - 4, "*", 0xFFFFD040, cw / 3, VML_ANCHOR_RIGHT);
}
}
itoa(g_frames / 120, buf);
ui_2d_text(SW / 2, 22, buf, C_DIM, 12, VML_ANCHOR_CENTER);
if (won)
ui_2d_text(SW / 2, SH / 2, g_lang == 0 ? "全部收完,赢了!ESC 再来一局" : "You win! ESC for a new deal",
C_TEXT, 20, VML_ANCHOR_CENTER);
else
ui_2d_text(SW / 2, SH - 12, g_lang == 0 ? "点牌选中,再点目标;点左上翻牌"
: "Tap a card, then the target; tap the stock to deal",
C_DIM, 11, VML_ANCHOR_CENTER);
ui_2d_present();
}
/* ── 交互 ───────────────────────────────────────────────────────────── */
static void tap_stock(void)
{
if (stock_n > 0) {
stock_n = stock_n - 1;
waste[waste_n] = stock[stock_n];
waste_n = waste_n + 1;
} else if (waste_n > 0) {
int i;
for (i = waste_n - 1; i >= 0; i--) { /* 废牌整体倒回牌堆 */
stock[stock_n] = waste[i];
stock_n = stock_n + 1;
}
waste_n = 0;
}
sel_col = -1; sel_idx = -1; sel_waste = 0;
}
static void tap_foundation(int f)
{
int card;
if (sel_waste) {
card = waste[waste_n - 1];
if (!can_place_found(f, card)) return;
found[f][found_n[f]] = card; found_n[f] = found_n[f] + 1;
waste_n = waste_n - 1;
sel_waste = 0;
check_win();
return;
}
if (sel_col >= 0 && sel_idx == tab_n[sel_col] - 1) {
card = tab[sel_col][sel_idx];
if (!can_place_found(f, card)) return;
found[f][found_n[f]] = card; found_n[f] = found_n[f] + 1;
tab_n[sel_col] = tab_n[sel_col] - 1;
if (tab_n[sel_col] > 0) tab_up[sel_col][tab_n[sel_col] - 1] = 1;
sel_col = -1; sel_idx = -1;
check_win();
}
}
static void tap_column(int col, int card_index, int hit)
{
/* 没选中:点一张明牌就选中它那一摞 */
if (sel_col < 0 && !sel_waste) {
if (!hit || card_index < 0) return;
if (card_index >= tab_n[col]) return;
if (card_index == tab_n[col] - 1 && !tab_up[col][card_index]) {
tab_up[col][card_index] = 1; /* 封面朝下的顶牌 = 翻开 */
return;
}
if (run_ok(col, card_index)) { sel_col = col; sel_idx = card_index; }
return;
}
/* 已选中:点同一列同一张 = 取消 */
if (sel_col == col && sel_idx == card_index) { sel_col = -1; sel_idx = -1; return; }
/* 已选中:尝试落到这一列 */
{
int card;
if (sel_waste) {
card = waste[waste_n - 1];
if (!can_place_tab(col, card)) return;
tab[col][tab_n[col]] = card;
tab_up[col][tab_n[col]] = 1;
tab_n[col] = tab_n[col] + 1;
waste_n = waste_n - 1;
sel_waste = 0;
return;
}
if (sel_col < 0) return;
card = tab[sel_col][sel_idx];
if (!can_place_tab(col, card)) return;
move_run(sel_col, sel_idx, col);
sel_col = -1; sel_idx = -1;
}
}
static void tap(int x, int y)
{
int i, k;
if (won) return;
/* 牌堆 */
if (x < base_x + cw && y >= top_y && y <= top_y + ch) { tap_stock(); return; }
/* 废牌 */
if (x >= base_x + col_w && x < base_x + 2 * col_w && y >= top_y && y <= top_y + ch) {
if (waste_n > 0) { sel_col = -1; sel_idx = -1; sel_waste = sel_waste ? 0 : 1; }
return;
}
/* 收牌区(右侧四格) */
if (y >= top_y && y <= top_y + ch) {
for (i = 0; i < 4; i++) {
int fx = base_x + 3 * col_w + i * col_w;
if (x >= fx && x < fx + cw) { tap_foundation(i); return; }
}
return;
}
/* 7 列:找到点在哪张牌上(从下往上判,重叠的牌上面那张优先) */
for (i = 0; i < 7; i++) {
int colx = base_x + i * col_w;
if (x < colx || x >= colx + cw) continue;
for (k = tab_n[i] - 1; k >= 0; k--) {
int cy = card_y_at(i, k);
if (y >= cy && y < cy + ch) { tap_column(i, k, 1); return; }
}
tap_column(i, -1, 0); /* 点在这一列的空位 */
return;
}
}
int main(void)
{
int msg[4];
int tid;
int done = 0;
/* ⚠ 宿主对**一次物理点击**会同时投递 TOUCHDOWN 与 MOUSEDOWN 两条消息(MAUI 实测:
一次点击队列里连着两条、坐标相同)。本程序两条都处理 ⇒ 第一下选中、第二下立刻取消
⇒ 用户看到的就是「选中纸牌没反应」。⇒ 记住上一条触摸的坐标,紧跟其后、坐标相同的
鼠标按下视为同一手势的重复投递,直接丢掉(纯鼠标的桌面仍走 MOUSEDOWN 那条)。 */
/* The host posts BOTH a TOUCHDOWN and a MOUSEDOWN for one physical tap (measured on MAUI);
handling both selected and immediately deselected the card. Remember the touch position and
drop the identical MOUSEDOWN that follows it (desktop mouse-only input still works). */
int lastX = -1, lastY = -1, sawTouch = 0;
g_lang = ui_scr_get_language();
relayout();
ui_win_open_ex("solitaire.c", 0, 0, VML_WIN_ROTATABLE, VML_WIN_NO_GAMEPAD);
relayout();
deal();
draw();
tid = ui_timer_set(60, 1);
while (!done && ui_win_is_closed() == 0) {
int t = ui_msg_wait(msg, 0);
if (t == VML_MSG_NONE) continue;
if (t == VML_MSG_TOUCHDOWN) { lastX = msg[1]; lastY = msg[2]; sawTouch = 1; tap(msg[1], msg[2]); draw(); continue; }
if (t == VML_MSG_MOUSEDOWN) {
if (sawTouch && msg[1] == lastX && msg[2] == lastY) { sawTouch = 0; continue; }
tap(msg[1], msg[2]); draw(); continue;
}
if (t == VML_MSG_KEYDOWN) {
if (msg[1] == VML_KEY_ESCAPE) { deal(); draw(); }
else if (msg[1] == VML_KEY_SPACE) { tap_stock(); draw(); }
continue;
}
if (t == VML_MSG_TIMER) {
g_frames = g_frames + 1;
if (g_frames >= MAX_FRAMES) done = 1;
if ((g_frames % 120) == 0) draw(); /* 每秒刷一次计时 */
continue;
}
if (t == VML_MSG_WINDOWRESIZE) { relayout(); draw(); continue; }
if (t == VML_MSG_WINDOWCLOSE) break;
}
ui_timer_kill(tid);
ui_win_close();
printf("solitaire: found=%d%d%d%d won=%d done\n", found_n[0], found_n[1], found_n[2], found_n[3], won);
return 0;
}