« back to all changes in this revision
Viewing changes to xshogi/xshogi.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Javier Fernandez-Sanguino Pen~a
- Date: 2004-01-09 16:06:59 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20040109160659-n26nu7009llm247p
Tags: 1.3-3.1
* NMU
- Minimal testing done and looks quite OK (even if I don't know
how to play the game...)
- Build-Depends move from libxaw-dev to libxaw6-dev (Closes: #169975)
- Included errno.h in gnushogi which makes the binary build properly
now (and is usable with xshogi) (Closes: #226319)
- Minimal testing done and looks quite OK (even if I don't know
how to play the game...)
- Build-Depends move from libxaw-dev to libxaw6-dev (Closes: #169975)
- Included errno.h in gnushogi which makes the binary build properly
now (and is usable with xshogi) (Closes: #226319)
- files added:
- CONTRIB
- gnushogi
- xshogi
- xshogi/eastern_bitmaps
- xshogi/western_bitmaps
- files removed:
- README-1.2p03
- src
- files modified:
- debian/changelog
added
removed
xshogi/xshogi.c
1
/*
2
* FILE: xshogi.c
3
*
4
* Implementation of the X interface for GNU shogi (xshogi).
5
*
6
* ------------------------------------------------------------------------
7
* xshogi is based on XBoard -- an Xt/Athena user interface for GNU Chess.
8
*
9
* Original authors: Dan Sears, Chris Sears
10
* Enhancements (Version 2.0 and following): Tim Mann
11
* Modifications to XShogi (Version 1.0): Matthias Mutz
12
* Enhancements to XShogi (Version 1.1): Matthias Mutz
13
* Modified implementation of ISS mode for XShogi: Matthias Mutz
14
* Current maintainer: Michael C. Vanier
15
*
16
* XShogi borrows its piece bitmaps from CRANES Shogi.
17
*
18
* Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts.
19
* Enhancements Copyright 1992 Free Software Foundation, Inc.
20
* Enhancements for XShogi Copyright 1993, 1994, 1995 Matthias Mutz
21
* Copyright (c) 1999 Michael Vanier and the Free Software Foundation
22
*
23
* The following terms apply to Digital Equipment Corporation's copyright
24
* interest in XBoard:
25
* ------------------------------------------------------------------------
26
* All Rights Reserved
27
*
28
* Permission to use, copy, modify, and distribute this software and its
29
* documentation for any purpose and without fee is hereby granted,
30
* provided that the above copyright notice appear in all copies and that
31
* both that copyright notice and this permission notice appear in
32
* supporting documentation, and that the name of Digital not be
33
* used in advertising or publicity pertaining to distribution of the
34
* software without specific, written prior permission.
35
*
36
* DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
37
* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
38
* DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
39
* ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
40
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
41
* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
42
* SOFTWARE.
43
* ------------------------------------------------------------------------
44
*
45
* This file is part of GNU shogi.
46
*
47
* GNU shogi is free software; you can redistribute it and/or modify
48
* it under the terms of the GNU General Public License as published by
49
* the Free Software Foundation.
50
*
51
* GNU shogi is distributed in the hope that it will be useful,
52
* but WITHOUT ANY WARRANTY; without even the implied warranty of
53
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
54
* GNU General Public License for more details.
55
*
56
* You should have received a copy of the GNU General Public License
57
* along with GNU shogi; see the file COPYING. If not, write to
58
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
59
*
60
* ------------------------------------------------------------------------
61
*
62
*/
63
64
#include "config.h"
65
66
#ifdef X_DISPLAY_MISSING
67
#error You cannot compile xshogi if X windows is unavailable!
68
#endif
69
70
#include "sysdeps.h"
71
72
#define XBOARD_VERSION "2.0/2.1"
73
74
#include <stdio.h>
75
#include <ctype.h>
76
#include <signal.h>
77
#include <sys/ioctl.h>
78
79
#include <time.h>
80
#include <pwd.h>
81
82
#include <X11/Intrinsic.h>
83
#include <X11/StringDefs.h>
84
#include <X11/Shell.h>
85
#include <X11/Xaw/Dialog.h>
86
#include <X11/Xaw/Form.h>
87
#include <X11/Xaw/List.h>
88
#include <X11/Xaw/Label.h>
89
#include <X11/Xaw/SimpleMenu.h>
90
#include <X11/Xaw/SmeBSB.h>
91
#include <X11/Xaw/SmeLine.h>
92
#include <X11/cursorfont.h>
93
94
#include "../version.h"
95
#include "xshogi.h"
96
97
#define BUF_SIZE 1024
98
#define BOARD 1
99
#define MOVES 2
100
101
#include "bitmaps.h" /* Piece bitmaps. */
102
#include "xshogifn.h" /* Forward declarations. */
103
104
#define off_board(x) (x < 2 || x > BOARD_SIZE + 1)
105
106
107
/**********************************************************************
108
*
109
* Global variables, structs etc.
110
*
111
**********************************************************************/
112
113
/*
114
* NOTE: XShogi depends on Xt R4 or higher
115
*/
116
117
int xtVersion = XtSpecificationRelease;
118
119
XtIntervalId firstProgramXID = 0, secondProgramXID = 0,
120
readGameXID = 0, timerXID = 0, blinkSquareXID = 0;
121
122
XtAppContext appContext;
123
124
Boolean (*fileProc) (char *name);
125
126
FILE *fromFirstProgFP, *toFirstProgFP, *fromSecondProgFP,
127
*toSecondProgFP, *gameFileFP, *lastMsgFP;
128
129
int currentMove = 0, forwardMostMove = 0, backwardMostMove = 0,
130
firstProgramPID = 0,
131
secondProgramPID = 0, fromX = -1,
132
fromY = -1, firstMove = True, flipView = False,
133
xshogiDebug = True, commentUp = False, filenameUp = False,
134
whitePlaysFirst = False, startedFromSetupPosition = False,
135
searchTime = 0, pmFromX = -1, pmFromY = -1,
136
blackFlag = False, whiteFlag = False, maybeThinking = False,
137
filemodeUp = False;
138
139
int at_least_gnushogi_1_2p03 = False;
140
141
int firstSendTime = 2, secondSendTime = 2; /* 0 = don't, 1 = do,
142
2 = test first */
143
144
MatchMode matchMode = MatchFalse;
145
GameMode gameMode = BeginningOfGame;
146
GameMode lastGameMode = BeginningOfGame;
147
GameMode pausePreviousMode = BeginningOfGame;
148
149
char moveList[MAX_MOVES][MOVE_LEN], parseList[MAX_MOVES][MOVE_LEN * 2],
150
ptyname[24], *shogiDir, *programName;
151
152
char endMessage[MOVE_LEN * 4];
153
154
long blackTimeRemaining, whiteTimeRemaining, timeControl;
155
long timeRemaining[2][MAX_MOVES];
156
157
extern char currentMoveString[];
158
159
int updateRemotePlayer = False;
160
161
Catched catches[MAX_MOVES];
162
163
#define DIMENSION 100
164
165
Widget blackPieceMenu, whitePieceMenu, commentShell;
166
167
XSetWindowAttributes attr;
168
169
#define pawn 0
170
#define lance 1
171
#define knight 2
172
#define silver 3
173
#define gold 4
174
#define bishop 5
175
#define rook 6
176
#define king 7
177
#define no_piece 8
178
#define ppawn 9
179
#define plance 10
180
#define pknight 11
181
#define psilver 12
182
#define pbishop 13
183
184
#define NO_PIECES 15
185
#define NO_SQUARES 81
186
#define NO_COLS 9
187
#define NO_ROWS 9
188
189
190
char catchedIndexToChar[8] =
191
{
192
'P', 'L', 'N', 'S', 'G', 'B', 'R', 'K'
193
};
194
195
ShogiSquare catchedIndexToPiece[2][8] =
196
{
197
{
198
BlackPawn, BlackLance, BlackKnight, BlackSilver, BlackGold,
199
BlackBishop, BlackRook, BlackKing
200
},
201
{
202
WhitePawn, WhiteLance, WhiteKnight, WhiteSilver, WhiteGold,
203
WhiteBishop, WhiteRook, WhiteKing
204
}
205
};
206
207
208
int pieceToCatchedIndex[] =
209
{
210
pawn, lance, knight, silver, gold, bishop, rook,
211
pawn, lance, knight, silver, bishop, rook, king,
212
pawn, lance, knight, silver, gold, bishop, rook,
213
pawn, lance, knight, silver, bishop, rook, king,
214
no_piece
215
};
216
217
218
219
Board boards[MAX_MOVES];
220
Board initialPosition =
221
{
222
{ BlackLance, BlackKnight, BlackSilver, BlackGold, BlackKing,
223
BlackGold, BlackSilver, BlackKnight, BlackLance },
224
{ EmptySquare, BlackBishop, EmptySquare, EmptySquare, EmptySquare,
225
EmptySquare, EmptySquare, BlackRook, EmptySquare },
226
{ BlackPawn, BlackPawn, BlackPawn, BlackPawn, BlackPawn,
227
BlackPawn, BlackPawn, BlackPawn, BlackPawn },
228
{ EmptySquare, EmptySquare, EmptySquare, EmptySquare, EmptySquare,
229
EmptySquare, EmptySquare, EmptySquare, EmptySquare } ,
230
{ EmptySquare, EmptySquare, EmptySquare, EmptySquare, EmptySquare,
231
EmptySquare, EmptySquare, EmptySquare, EmptySquare } ,
232
{ EmptySquare, EmptySquare, EmptySquare, EmptySquare, EmptySquare,
233
EmptySquare, EmptySquare, EmptySquare, EmptySquare } ,
234
{ WhitePawn, WhitePawn, WhitePawn, WhitePawn, WhitePawn,
235
WhitePawn, WhitePawn, WhitePawn, WhitePawn },
236
{ EmptySquare, WhiteRook, EmptySquare, EmptySquare, EmptySquare,
237
EmptySquare, EmptySquare, WhiteBishop, EmptySquare },
238
{ WhiteLance, WhiteKnight, WhiteSilver, WhiteGold, WhiteKing,
239
WhiteGold, WhiteSilver, WhiteKnight, WhiteLance }
240
};
241
242
String gnuButtonStrings[] =
243
{
244
"Quit", "Load Game", "Machine White", "Forward",
245
"Reset", "Load Position", "Machine Black", "Backward",
246
"Flip View", "Save Game", "Force Moves", "Pause",
247
"Hint", "Save Position", "Two Machines", "Edit Position",
248
"Challenge", "Select Level", "Move NOW",
249
};
250
251
/* must be in same order as buttonStrings! */
252
XtActionProc gnuButtonProcs[] =
253
{
254
QuitProc, LoadGameProc, MachineWhiteProc, ForwardProc,
255
ResetProc, LoadPositionProc, MachineBlackProc, BackwardProc,
256
FlipViewProc, SaveGameProc, ForceProc, PauseProc,
257
HintProc, SavePositionProc, TwoMachinesProc, EditPositionProc,
258
ChallengeProc, SelectLevelProc, MoveNowProc,
259
NULL
260
};
261
262
263
String *buttonStrings;
264
XtActionProc *buttonProcs;
265
int buttonCount;
266
267
#define PIECE_MENU_SIZE 18
268
269
String pieceMenuStrings[PIECE_MENU_SIZE] =
270
{
271
"----", "Pawn", "Lance", "Knight", "Silver",
272
"Gold", "Bishop", "Rook",
273
"PPawn", "PLance", "PKnight", "PSilver",
274
"PBishop", "PRook", "King",
275
"----", "Empty square", "Clear board"
276
};
277
278
/* must be in same order as PieceMenuStrings! */
279
ShogiSquare pieceMenuTranslation[2][PIECE_MENU_SIZE] =
280
{
281
{
282
(ShogiSquare) 0, BlackPawn, BlackLance, BlackKnight,
283
BlackSilver, BlackGold, BlackBishop, BlackRook,
284
BlackPPawn, BlackPLance, BlackPKnight, BlackPSilver,
285
BlackPBishop, BlackPRook, BlackKing,
286
(ShogiSquare) 0, EmptySquare, ClearBoard
287
},
288
{
289
(ShogiSquare) 0, WhitePawn, WhiteLance, WhiteKnight,
290
WhiteSilver, WhiteGold, WhiteBishop, WhiteRook,
291
WhitePPawn, WhitePLance, WhitePKnight, WhitePSilver,
292
WhitePBishop, WhitePRook, WhiteKing,
293
(ShogiSquare) 0, EmptySquare, ClearBoard
294
},
295
};
296
297
298
typedef struct
299
{
300
Pixel blackPieceColor;
301
Pixel whitePieceColor;
302
Pixel lightSquareColor;
303
Pixel darkSquareColor;
304
Pixel charPieceColor;
305
Pixel zeroColor;
306
Pixel oneColor;
307
Boolean westernPieceSet;
308
int movesPerSession;
309
String initString;
310
String blackString;
311
String whiteString;
312
String firstShogiProgram;
313
String secondShogiProgram;
314
Boolean noShogiProgram;
315
String firstHost;
316
String secondHost;
317
String reverseBigSolidBitmap;
318
String reverseSmallSolidBitmap;
319
String normalBigSolidBitmap;
320
String normalSmallSolidBitmap;
321
String reversePawnBitmap;
322
String reverseLanceBitmap;
323
String reverseKnightBitmap;
324
String reverseSilverBitmap;
325
String reverseGoldBitmap;
326
String reverseRookBitmap;
327
String reverseBishopBitmap;
328
String reversePPawnBitmap;
329
String reversePLanceBitmap;
330
String reversePKnightBitmap;
331
String reversePSilverBitmap;
332
String reversePBishopBitmap;
333
String reversePRookBitmap;
334
String reverseKingBitmap;
335
String normalPawnBitmap;
336
String normalLanceBitmap;
337
String normalKnightBitmap;
338
String normalSilverBitmap;
339
String normalGoldBitmap;
340
String normalRookBitmap;
341
String normalBishopBitmap;
342
String normalPPawnBitmap;
343
String normalPLanceBitmap;
344
String normalPKnightBitmap;
345
String normalPSilverBitmap;
346
String normalPBishopBitmap;
347
String normalPRookBitmap;
348
String normalKingBitmap;
349
String remoteShell;
350
float timeDelay;
351
String timeControl;
352
String gameIn;
353
354
Boolean autoSaveGames;
355
String loadGameFile;
356
String loadPositionFile;
357
String saveGameFile;
358
String savePositionFile;
359
String matchMode;
360
String challengeDisplay;
361
Boolean monoMode;
362
Boolean debugMode;
363
Boolean clockMode;
364
String boardSize;
365
Boolean Iconic;
366
String searchTime;
367
int searchDepth;
368
Boolean showCoords;
369
String mainFont;
370
String coordFont;
371
Boolean ringBellAfterMoves;
372
Boolean autoCallFlag;
373
int borderXoffset;
374
int borderYoffset;
375
} AppData, *AppDataPtr;
376
377
378
XtResource clientResources[] =
379
{
380
{
381
"blackPieceColor", "BlackPieceColor", XtRPixel, sizeof(Pixel),
382
XtOffset(AppDataPtr, blackPieceColor), XtRString,
383
BLACK_PIECE_COLOR
384
},
385
{
386
"whitePieceColor", "WhitePieceColor", XtRPixel, sizeof(Pixel),
387
XtOffset(AppDataPtr, whitePieceColor), XtRString,
388
WHITE_PIECE_COLOR
389
},
390
{
391
"charPieceColor", "CharPieceColor", XtRPixel, sizeof(Pixel),
392
XtOffset(AppDataPtr, charPieceColor), XtRString,
393
CHAR_PIECE_COLOR
394
},
395
{
396
"oneColor", "OneColor", XtRPixel, sizeof(Pixel),
397
XtOffset(AppDataPtr, oneColor), XtRString,
398
ONE_COLOR
399
},
400
{
401
"zeroColor", "ZeroColor", XtRPixel, sizeof(Pixel),
402
XtOffset(AppDataPtr, zeroColor), XtRString,
403
ZERO_COLOR
404
},
405
{
406
"lightSquareColor", "LightSquareColor", XtRPixel,
407
sizeof(Pixel), XtOffset(AppDataPtr, lightSquareColor),
408
XtRString, LIGHT_SQUARE_COLOR
409
},
410
{
411
"darkSquareColor", "DarkSquareColor", XtRPixel, sizeof(Pixel),
412
XtOffset(AppDataPtr, darkSquareColor), XtRString,
413
DARK_SQUARE_COLOR
414
},
415
{
416
"westernPieceSet", "WesternPieceSet", XtRBoolean, sizeof(Boolean),
417
XtOffset(AppDataPtr, westernPieceSet), XtRString,
418
(XtPointer) False
419
},
420
{
421
"movesPerSession", "movesPerSession", XtRInt, sizeof(int),
422
XtOffset(AppDataPtr, movesPerSession), XtRImmediate,
423
(XtPointer) MOVES_PER_SESSION
424
},
425
{
426
"initString", "initString", XtRString, sizeof(String),
427
XtOffset(AppDataPtr, initString), XtRString, INIT_STRING
428
},
429
{
430
"blackString", "blackString", XtRString, sizeof(String),
431
XtOffset(AppDataPtr, blackString), XtRString, BLACK_STRING
432
},
433
{
434
"whiteString", "whiteString", XtRString, sizeof(String),
435
XtOffset(AppDataPtr, whiteString), XtRString, WHITE_STRING
436
},
437
{
438
"firstShogiProgram", "firstShogiProgram", XtRString,
439
sizeof(String), XtOffset(AppDataPtr, firstShogiProgram),
440
XtRString, FIRST_SHOGI_PROGRAM
441
},
442
{
443
"secondShogiProgram", "secondShogiProgram", XtRString,
444
sizeof(String), XtOffset(AppDataPtr, secondShogiProgram),
445
XtRString, SECOND_SHOGI_PROGRAM
446
},
447
{
448
"noShogiProgram", "noShogiProgram", XtRBoolean,
449
sizeof(Boolean), XtOffset(AppDataPtr, noShogiProgram),
450
XtRImmediate, (XtPointer) False
451
},
452
{
453
"firstHost", "firstHost", XtRString, sizeof(String),
454
XtOffset(AppDataPtr, firstHost), XtRString, FIRST_HOST
455
},
456
{
457
"secondHost", "secondHost", XtRString, sizeof(String),
458
XtOffset(AppDataPtr, secondHost), XtRString, SECOND_HOST
459
},
460
{
461
"reversePawnBitmap", "reversePawnBitmap", XtRString,
462
sizeof(String), XtOffset(AppDataPtr, reversePawnBitmap),
463
XtRString, NULL
464
},
465
{
466
"reverseLanceBitmap", "reverseLanceBitmap", XtRString,
467
sizeof(String), XtOffset(AppDataPtr, reverseLanceBitmap),
468
XtRString, NULL
469
},
470
{
471
"reverseKnightBitmap", "reverseKnightBitmap", XtRString,
472
sizeof(String), XtOffset(AppDataPtr, reverseKnightBitmap),
473
XtRString, NULL
474
},
475
{
476
"reverseSilverBitmap", "reverseSilverBitmap", XtRString,
477
sizeof(String), XtOffset(AppDataPtr, reverseSilverBitmap),
478
XtRString, NULL
479
},
480
{
481
"reverseGoldBitmap", "reverseGoldBitmap", XtRString,
482
sizeof(String), XtOffset(AppDataPtr, reverseGoldBitmap),
483
XtRString, NULL
484
},
485
{
486
"reverseRookBitmap", "reverseRookBitmap", XtRString,
487
sizeof(String), XtOffset(AppDataPtr, reverseRookBitmap),
488
XtRString, NULL
489
},
490
{
491
"reverseBishopBitmap", "reverseBishopBitmap", XtRString,
492
sizeof(String), XtOffset(AppDataPtr, reverseBishopBitmap),
493
XtRString, NULL
494
},
495
{
496
"reversePPawnBitmap", "reversePPawnBitmap", XtRString,
497
sizeof(String), XtOffset(AppDataPtr, reversePPawnBitmap),
498
XtRString, NULL
499
},
500
{
501
"reversePLanceBitmap", "reversePLanceBitmap", XtRString,
502
sizeof(String), XtOffset(AppDataPtr, reversePLanceBitmap),
503
XtRString, NULL
504
},
505
{
506
"reversePKnightBitmap", "reversePKnightBitmap", XtRString,
507
sizeof(String), XtOffset(AppDataPtr, reversePKnightBitmap),
508
XtRString, NULL
509
},
510
{
511
"reversePSilverBitmap", "reversePSilverBitmap", XtRString,
512
sizeof(String), XtOffset(AppDataPtr, reversePSilverBitmap),
513
XtRString, NULL
514
},
515
{
516
"reversePRookBitmap", "reversePRookBitmap", XtRString,
517
sizeof(String), XtOffset(AppDataPtr, reversePRookBitmap),
518
XtRString, NULL
519
},
520
{
521
"reversePBishopBitmap", "reversePBishopBitmap", XtRString,
522
sizeof(String), XtOffset(AppDataPtr, reversePBishopBitmap),
523
XtRString, NULL
524
},
525
{
526
"reverseKingBitmap", "reverseKingBitmap", XtRString,
527
sizeof(String), XtOffset(AppDataPtr, reverseKingBitmap),
528
XtRString, NULL
529
},
530
{
531
"normalPawnBitmap", "normalPawnBitmap", XtRString,
532
sizeof(String), XtOffset(AppDataPtr, normalPawnBitmap),
533
XtRString, NULL
534
},
535
{
536
"normalLanceBitmap", "normalLanceBitmap", XtRString,
537
sizeof(String), XtOffset(AppDataPtr, normalLanceBitmap),
538
XtRString, NULL
539
},
540
{
541
"normalKnightBitmap", "normalKnightBitmap", XtRString,
542
sizeof(String), XtOffset(AppDataPtr, normalKnightBitmap),
543
XtRString, NULL
544
},
545
{
546
"normalSilverBitmap", "normalSilverBitmap", XtRString,
547
sizeof(String), XtOffset(AppDataPtr, normalSilverBitmap),
548
XtRString, NULL
549
},
550
{
551
"normalGoldBitmap", "normalGoldBitmap", XtRString,
552
sizeof(String), XtOffset(AppDataPtr, normalGoldBitmap),
553
XtRString, NULL
554
},
555
{
556
"normalBishopBitmap", "normalBishopBitmap", XtRString,
557
sizeof(String), XtOffset(AppDataPtr, normalBishopBitmap),
558
XtRString, NULL
559
},
560
{
561
"normalRookBitmap", "normalRookBitmap", XtRString,
562
sizeof(String), XtOffset(AppDataPtr, normalRookBitmap),
563
XtRString, NULL
564
},
565
{
566
"normalPPawnBitmap", "normalPPawnBitmap", XtRString,
567
sizeof(String), XtOffset(AppDataPtr, normalPPawnBitmap),
568
XtRString, NULL
569
},
570
{
571
"normalPLanceBitmap", "normalPLanceBitmap", XtRString,
572
sizeof(String), XtOffset(AppDataPtr, normalPLanceBitmap),
573
XtRString, NULL
574
},
575
{
576
"normalPKnightBitmap", "normalPKnightBitmap", XtRString,
577
sizeof(String), XtOffset(AppDataPtr, normalPKnightBitmap),
578
XtRString, NULL
579
},
580
{
581
"normalPSilverBitmap", "normalPSilverBitmap", XtRString,
582
sizeof(String), XtOffset(AppDataPtr, normalPSilverBitmap),
583
XtRString, NULL
584
},
585
{
586
"normalPBishopBitmap", "normalPBishopBitmap", XtRString,
587
sizeof(String), XtOffset(AppDataPtr, normalPBishopBitmap),
588
XtRString, NULL
589
},
590
{
591
"normalPRookBitmap", "normalPRookBitmap", XtRString,
592
sizeof(String), XtOffset(AppDataPtr, normalPRookBitmap),
593
XtRString, NULL
594
},
595
{
596
"normalKingBitmap", "normalKingBitmap", XtRString,
597
sizeof(String), XtOffset(AppDataPtr, normalKingBitmap),
598
XtRString, NULL
599
},
600
{
601
"remoteShell", "remoteShell", XtRString, sizeof(String),
602
XtOffset(AppDataPtr, remoteShell), XtRString, "rsh"
603
},
604
{
605
"timeDelay", "timeDelay", XtRFloat, sizeof(float),
606
XtOffset(AppDataPtr, timeDelay), XtRString,
607
(XtPointer) TIME_DELAY
608
},
609
{
610
"timeControl", "timeControl", XtRString, sizeof(String),
611
XtOffset(AppDataPtr, timeControl), XtRString,
612
(XtPointer) TIME_CONTROL
613
},
614
{
615
"gameIn", "gameIn",
616
XtRBoolean, sizeof(Boolean),
617
XtOffset(AppDataPtr, gameIn), XtRImmediate,
618
(XtPointer) False
619
},
620
{
621
"autoSaveGames", "autoSaveGames", XtRBoolean,
622
sizeof(Boolean), XtOffset(AppDataPtr, autoSaveGames),
623
XtRImmediate, (XtPointer) False
624
},
625
{
626
"loadGameFile", "loadGameFile", XtRString, sizeof(String),
627
XtOffset(AppDataPtr, loadGameFile), XtRString, NULL
628
},
629
{
630
"loadPositionFile", "loadPositionFile", XtRString,
631
sizeof(String), XtOffset(AppDataPtr, loadPositionFile),
632
XtRString, NULL
633
},
634
{
635
"saveGameFile", "saveGameFile", XtRString, sizeof(String),
636
XtOffset(AppDataPtr, saveGameFile), XtRString, ""
637
},
638
{
639
"savePositionFile", "savePositionFile", XtRString,
640
sizeof(String), XtOffset(AppDataPtr, savePositionFile),
641
XtRString, ""
642
},
643
{
644
"challengeDisplay", "challengeDisplay", XtRString,
645
sizeof(String), XtOffset(AppDataPtr, challengeDisplay),
646
XtRString, NULL
647
},
648
{
649
"matchMode", "matchMode", XtRString, sizeof(String),
650
XtOffset(AppDataPtr, matchMode), XtRString, MATCH_MODE
651
},
652
{
653
"monoMode", "monoMode", XtRBoolean, sizeof(Boolean),
654
XtOffset(AppDataPtr, monoMode), XtRImmediate,
655
(XtPointer) False
656
},
657
{
658
"debugMode", "debugMode", XtRBoolean, sizeof(Boolean),
659
XtOffset(AppDataPtr, debugMode), XtRImmediate,
660
(XtPointer) False
661
},
662
{
663
"Iconic", "Iconic", XtRBoolean, sizeof(Boolean),
664
XtOffset(AppDataPtr, Iconic), XtRImmediate,
665
(XtPointer) False
666
},
667
{
668
"clockMode", "clockMode", XtRBoolean, sizeof(Boolean),
669
XtOffset(AppDataPtr, clockMode), XtRImmediate,
670
(XtPointer) True
671
},
672
{
673
"autoCallFlag", "autoCallFlag", XtRBoolean,
674
sizeof(Boolean), XtOffset(AppDataPtr, autoCallFlag),
675
XtRImmediate, (XtPointer) False
676
},
677
{
678
"boardSize", "boardSize", XtRString, sizeof(String),
679
XtOffset(AppDataPtr, boardSize), XtRString, DEFAULT_SIZE
680
},
681
{
682
"searchTime", "searchTime", XtRString, sizeof(String),
683
XtOffset(AppDataPtr, searchTime), XtRString,
684
(XtPointer) NULL
685
},
686
{
687
"searchDepth", "searchDepth", XtRInt, sizeof(int),
688
XtOffset(AppDataPtr, searchDepth), XtRImmediate,
689
(XtPointer) 0
690
},
691
{
692
"showCoords", "showCoords", XtRBoolean, sizeof(Boolean),
693
XtOffset(AppDataPtr, showCoords), XtRImmediate,
694
(XtPointer) False
695
},
696
{
697
"mainFont", "mainFont", XtRString, sizeof(String),
698
XtOffset(AppDataPtr, mainFont), XtRString, MAIN_FONT
699
},
700
{
701
"coordFont", "coordFont", XtRString, sizeof(String),
702
XtOffset(AppDataPtr, coordFont), XtRString, COORD_FONT
703
},
704
{
705
"ringBellAfterMoves", "ringBellAfterMoves",
706
XtRBoolean, sizeof(Boolean),
707
XtOffset(AppDataPtr, ringBellAfterMoves),
708
XtRImmediate, (XtPointer) False
709
},
710
{
711
"borderXoffset", "borderXoffset", XtRInt, sizeof(int),
712
XtOffset(AppDataPtr, borderXoffset), XtRImmediate,
713
(XtPointer) BORDER_X_OFFSET
714
},
715
{
716
"borderYoffset", "borderYOffset", XtRInt, sizeof(int),
717
XtOffset(AppDataPtr, borderYoffset), XtRImmediate,
718
(XtPointer) BORDER_Y_OFFSET
719
}
720
};
721
722
723
struct DisplayData
724
{
725
726
AppData appData;
727
728
Arg shellArgs[6];
729
Arg boardArgs[3];
730
Arg commandsArgs[7];
731
Arg messageArgs[3];
732
Arg timerArgs[2];
733
Arg titleArgs[2];
734
735
Pixmap reversePawnBitmap, reverseLanceBitmap, reverseKnightBitmap,
736
reverseSilverBitmap,
737
reverseGoldBitmap, reverseBishopBitmap, reverseRookBitmap,
738
reversePPawnBitmap, reversePLanceBitmap, reversePKnightBitmap,
739
reversePSilverBitmap, reversePBishopBitmap, reversePRookBitmap,
740
reverseKingBitmap,
741
reverseBigSolidBitmap, reverseSmallSolidBitmap,
742
normalBigSolidBitmap, normalSmallSolidBitmap,
743
normalPawnBitmap, normalLanceBitmap, normalKnightBitmap,
744
normalSilverBitmap, normalGoldBitmap,
745
normalBishopBitmap, normalRookBitmap,
746
normalPPawnBitmap, normalPLanceBitmap, normalPKnightBitmap,
747
normalPSilverBitmap, normalPBishopBitmap, normalPRookBitmap,
748
normalKingBitmap,
749
iconPixmap;
750
751
Display *xDisplay;
752
int xScreen;
753
Window xBoardWindow;
754
755
GC lightSquareGC, darkSquareGC, lineGC, wdPieceGC, wlPieceGC,
756
woPieceGC, boPieceGC, bdPieceGC, blPieceGC, wbPieceGC,
757
bwPieceGC, coordGC, dropPiece;
758
759
GC charPieceGC;
760
761
Font mainFontID, coordFontID;
762
XFontStruct *mainFontStruct, *coordFontStruct;
763
764
Widget shellWidget, formWidget, boardWidget,
765
commandsWidget, messageWidget,
766
blackTimerWidget, whiteTimerWidget,
767
titleWidget, widgetList[6],
768
promotionShell,
769
filemodeShell, challengeWidget;
770
771
XSegment gridSegments[(BOARD_SIZE + 1) * 2];
772
773
Pixel timerForegroundPixel, timerBackgroundPixel;
774
775
BoardSize boardSize;
776
int squareSize;
777
int black_pixel_is_zero;
778
int flipView;
779
int promotionUp;
780
781
Boolean monoMode, showCoords, Iconic;
782
};
783
784
785
786
struct DisplayData localPlayer, remotePlayer;
787
788
789
typedef struct
790
{
791
ShogiSquare piece;
792
int to_x, to_y;
793
} PromotionMoveInfo;
794
795
static PromotionMoveInfo pmi; /* making this global is gross */
796
797
798
Pixmap *pieceToReverse[2][28] =
799
{
800
{
801
&localPlayer.reversePawnBitmap,
802
&localPlayer.reverseLanceBitmap,
803
&localPlayer.reverseKnightBitmap,
804
&localPlayer.reverseSilverBitmap,
805
&localPlayer.reverseGoldBitmap,
806
&localPlayer.reverseBishopBitmap,
807
&localPlayer.reverseRookBitmap,
808
&localPlayer.reversePPawnBitmap,
809
&localPlayer.reversePLanceBitmap,
810
&localPlayer.reversePKnightBitmap,
811
&localPlayer.reversePSilverBitmap,
812
&localPlayer.reversePBishopBitmap,
813
&localPlayer.reversePRookBitmap,
814
&localPlayer.reverseKingBitmap,
815
&localPlayer.reversePawnBitmap,
816
&localPlayer.reverseLanceBitmap,
817
&localPlayer.reverseKnightBitmap,
818
&localPlayer.reverseSilverBitmap,
819
&localPlayer.reverseGoldBitmap,
820
&localPlayer.reverseBishopBitmap,
821
&localPlayer.reverseRookBitmap,
822
&localPlayer.reversePPawnBitmap,
823
&localPlayer.reversePLanceBitmap,
824
&localPlayer.reversePKnightBitmap,
825
&localPlayer.reversePSilverBitmap,
826
&localPlayer.reversePBishopBitmap,
827
&localPlayer.reversePRookBitmap,
828
&localPlayer.reverseKingBitmap
829
},
830
{
831
&remotePlayer.reversePawnBitmap,
832
&remotePlayer.reverseLanceBitmap,
833
&remotePlayer.reverseKnightBitmap,
834
&remotePlayer.reverseSilverBitmap,
835
&remotePlayer.reverseGoldBitmap,
836
&remotePlayer.reverseBishopBitmap,
837
&remotePlayer.reverseRookBitmap,
838
&remotePlayer.reversePPawnBitmap,
839
&remotePlayer.reversePLanceBitmap,
840
&remotePlayer.reversePKnightBitmap,
841
&remotePlayer.reversePSilverBitmap,
842
&remotePlayer.reversePBishopBitmap,
843
&remotePlayer.reversePRookBitmap,
844
&remotePlayer.reverseKingBitmap,
845
&remotePlayer.reversePawnBitmap,
846
&remotePlayer.reverseLanceBitmap,
847
&remotePlayer.reverseKnightBitmap,
848
&remotePlayer.reverseSilverBitmap,
849
&remotePlayer.reverseGoldBitmap,
850
&remotePlayer.reverseBishopBitmap,
851
&remotePlayer.reverseRookBitmap,
852
&remotePlayer.reversePPawnBitmap,
853
&remotePlayer.reversePLanceBitmap,
854
&remotePlayer.reversePKnightBitmap,
855
&remotePlayer.reversePSilverBitmap,
856
&remotePlayer.reversePBishopBitmap,
857
&remotePlayer.reversePRookBitmap,
858
&remotePlayer.reverseKingBitmap
859
}
860
};
861
862
863
864
Pixmap *pieceToNormal[2][28] =
865
{
866
{
867
&localPlayer.normalPawnBitmap,
868
&localPlayer.normalLanceBitmap,
869
&localPlayer.normalKnightBitmap,
870
&localPlayer.normalSilverBitmap,
871
&localPlayer.normalGoldBitmap,
872
&localPlayer.normalBishopBitmap,
873
&localPlayer.normalRookBitmap,
874
&localPlayer.normalPPawnBitmap,
875
&localPlayer.normalPLanceBitmap,
876
&localPlayer.normalPKnightBitmap,
877
&localPlayer.normalPSilverBitmap,
878
&localPlayer.normalPBishopBitmap,
879
&localPlayer.normalPRookBitmap,
880
&localPlayer.normalKingBitmap,
881
&localPlayer.normalPawnBitmap,
882
&localPlayer.normalLanceBitmap,
883
&localPlayer.normalKnightBitmap,
884
&localPlayer.normalSilverBitmap,
885
&localPlayer.normalGoldBitmap,
886
&localPlayer.normalBishopBitmap,
887
&localPlayer.normalRookBitmap,
888
&localPlayer.normalPPawnBitmap,
889
&localPlayer.normalPLanceBitmap,
890
&localPlayer.normalPKnightBitmap,
891
&localPlayer.normalPSilverBitmap,
892
&localPlayer.normalPBishopBitmap,
893
&localPlayer.normalPRookBitmap,
894
&localPlayer.normalKingBitmap
895
},
896
{
897
&remotePlayer.normalPawnBitmap,
898
&remotePlayer.normalLanceBitmap,
899
&remotePlayer.normalKnightBitmap,
900
&remotePlayer.normalSilverBitmap,
901
&remotePlayer.normalGoldBitmap,
902
&remotePlayer.normalBishopBitmap,
903
&remotePlayer.normalRookBitmap,
904
&remotePlayer.normalPPawnBitmap,
905
&remotePlayer.normalPLanceBitmap,
906
&remotePlayer.normalPKnightBitmap,
907
&remotePlayer.normalPSilverBitmap,
908
&remotePlayer.normalPBishopBitmap,
909
&remotePlayer.normalPRookBitmap,
910
&remotePlayer.normalKingBitmap,
911
&remotePlayer.normalPawnBitmap,
912
&remotePlayer.normalLanceBitmap,
913
&remotePlayer.normalKnightBitmap,
914
&remotePlayer.normalSilverBitmap,
915
&remotePlayer.normalGoldBitmap,
916
&remotePlayer.normalBishopBitmap,
917
&remotePlayer.normalRookBitmap,
918
&remotePlayer.normalPPawnBitmap,
919
&remotePlayer.normalPLanceBitmap,
920
&remotePlayer.normalPKnightBitmap,
921
&remotePlayer.normalPSilverBitmap,
922
&remotePlayer.normalPBishopBitmap,
923
&remotePlayer.normalPRookBitmap,
924
&remotePlayer.normalKingBitmap
925
}
926
};
927
928
929
930
Pixmap *pieceToReverseSolid[2][28] =
931
{
932
{
933
&localPlayer.reverseSmallSolidBitmap,
934
&localPlayer.reverseSmallSolidBitmap,
935
&localPlayer.reverseSmallSolidBitmap,
936
&localPlayer.reverseBigSolidBitmap,
937
&localPlayer.reverseBigSolidBitmap,
938
&localPlayer.reverseBigSolidBitmap,
939
&localPlayer.reverseBigSolidBitmap,
940
&localPlayer.reverseSmallSolidBitmap,
941
&localPlayer.reverseSmallSolidBitmap,
942
&localPlayer.reverseSmallSolidBitmap,
943
&localPlayer.reverseBigSolidBitmap,
944
&localPlayer.reverseBigSolidBitmap,
945
&localPlayer.reverseBigSolidBitmap,
946
&localPlayer.reverseBigSolidBitmap,
947
&localPlayer.reverseSmallSolidBitmap,
948
&localPlayer.reverseSmallSolidBitmap,
949
&localPlayer.reverseSmallSolidBitmap,
950
&localPlayer.reverseBigSolidBitmap,
951
&localPlayer.reverseBigSolidBitmap,
952
&localPlayer.reverseBigSolidBitmap,
953
&localPlayer.reverseBigSolidBitmap,
954
&localPlayer.reverseSmallSolidBitmap,
955
&localPlayer.reverseSmallSolidBitmap,
956
&localPlayer.reverseSmallSolidBitmap,
957
&localPlayer.reverseBigSolidBitmap,
958
&localPlayer.reverseBigSolidBitmap,
959
&localPlayer.reverseBigSolidBitmap,
960
&localPlayer.reverseBigSolidBitmap
961
},
962
{
963
&remotePlayer.reverseSmallSolidBitmap,
964
&remotePlayer.reverseSmallSolidBitmap,
965
&remotePlayer.reverseSmallSolidBitmap,
966
&remotePlayer.reverseBigSolidBitmap,
967
&remotePlayer.reverseBigSolidBitmap,
968
&remotePlayer.reverseBigSolidBitmap,
969
&remotePlayer.reverseBigSolidBitmap,
970
&remotePlayer.reverseSmallSolidBitmap,
971
&remotePlayer.reverseSmallSolidBitmap,
972
&remotePlayer.reverseSmallSolidBitmap,
973
&remotePlayer.reverseBigSolidBitmap,
974
&remotePlayer.reverseBigSolidBitmap,
975
&remotePlayer.reverseBigSolidBitmap,
976
&remotePlayer.reverseBigSolidBitmap,
977
&remotePlayer.reverseSmallSolidBitmap,
978
&remotePlayer.reverseSmallSolidBitmap,
979
&remotePlayer.reverseSmallSolidBitmap,
980
&remotePlayer.reverseBigSolidBitmap,
981
&remotePlayer.reverseBigSolidBitmap,
982
&remotePlayer.reverseBigSolidBitmap,
983
&remotePlayer.reverseBigSolidBitmap,
984
&remotePlayer.reverseSmallSolidBitmap,
985
&remotePlayer.reverseSmallSolidBitmap,
986
&remotePlayer.reverseSmallSolidBitmap,
987
&remotePlayer.reverseBigSolidBitmap,
988
&remotePlayer.reverseBigSolidBitmap,
989
&remotePlayer.reverseBigSolidBitmap,
990
&remotePlayer.reverseBigSolidBitmap
991
}
992
};
993
994
995
996
Pixmap *pieceToNormalSolid[2][28] =
997
{
998
{
999
&localPlayer.normalSmallSolidBitmap,
1000
&localPlayer.normalSmallSolidBitmap,
1001
&localPlayer.normalSmallSolidBitmap,
1002
&localPlayer.normalBigSolidBitmap,
1003
&localPlayer.normalBigSolidBitmap,
1004
&localPlayer.normalBigSolidBitmap,
1005
&localPlayer.normalBigSolidBitmap,
1006
&localPlayer.normalSmallSolidBitmap,
1007
&localPlayer.normalSmallSolidBitmap,
1008
&localPlayer.normalSmallSolidBitmap,
1009
&localPlayer.normalBigSolidBitmap,
1010
&localPlayer.normalBigSolidBitmap,
1011
&localPlayer.normalBigSolidBitmap,
1012
&localPlayer.normalBigSolidBitmap,
1013
&localPlayer.normalSmallSolidBitmap,
1014
&localPlayer.normalSmallSolidBitmap,
1015
&localPlayer.normalSmallSolidBitmap,
1016
&localPlayer.normalBigSolidBitmap,
1017
&localPlayer.normalBigSolidBitmap,
1018
&localPlayer.normalBigSolidBitmap,
1019
&localPlayer.normalBigSolidBitmap,
1020
&localPlayer.normalSmallSolidBitmap,
1021
&localPlayer.normalSmallSolidBitmap,
1022
&localPlayer.normalSmallSolidBitmap,
1023
&localPlayer.normalBigSolidBitmap,
1024
&localPlayer.normalBigSolidBitmap,
1025
&localPlayer.normalBigSolidBitmap,
1026
&localPlayer.normalBigSolidBitmap
1027
},
1028
{
1029
&remotePlayer.normalSmallSolidBitmap,
1030
&remotePlayer.normalSmallSolidBitmap,
1031
&remotePlayer.normalSmallSolidBitmap,
1032
&remotePlayer.normalBigSolidBitmap,
1033
&remotePlayer.normalBigSolidBitmap,
1034
&remotePlayer.normalBigSolidBitmap,
1035
&remotePlayer.normalBigSolidBitmap,
1036
&remotePlayer.normalSmallSolidBitmap,
1037
&remotePlayer.normalSmallSolidBitmap,
1038
&remotePlayer.normalSmallSolidBitmap,
1039
&remotePlayer.normalBigSolidBitmap,
1040
&remotePlayer.normalBigSolidBitmap,
1041
&remotePlayer.normalBigSolidBitmap,
1042
&remotePlayer.normalBigSolidBitmap,
1043
&remotePlayer.normalSmallSolidBitmap,
1044
&remotePlayer.normalSmallSolidBitmap,
1045
&remotePlayer.normalSmallSolidBitmap,
1046
&remotePlayer.normalBigSolidBitmap,
1047
&remotePlayer.normalBigSolidBitmap,
1048
&remotePlayer.normalBigSolidBitmap,
1049
&remotePlayer.normalBigSolidBitmap,
1050
&remotePlayer.normalSmallSolidBitmap,
1051
&remotePlayer.normalSmallSolidBitmap,
1052
&remotePlayer.normalSmallSolidBitmap,
1053
&remotePlayer.normalBigSolidBitmap,
1054
&remotePlayer.normalBigSolidBitmap,
1055
&remotePlayer.normalBigSolidBitmap,
1056
&remotePlayer.normalBigSolidBitmap
1057
}
1058
};
1059
1060
1061
1062
int pieceIsPromoted[] =
1063
{
1064
False, False, False, False, False, False, False,
1065
True, True, True, True, True, True, False,
1066
False, False, False, False, False, False, False,
1067
True, True, True, True, True, True, False,
1068
False
1069
};
1070
1071
1072
int piecePromotable[] =
1073
{
1074
True, True, True, True, False, True, True,
1075
False, False, False, False, False, False, False,
1076
True, True, True, True, False, True, True,
1077
False, False, False, False, False, False, False,
1078
False
1079
};
1080
1081
1082
char pieceToChar[] =
1083
{
1084
'P', 'L', 'N', 'S', 'G', 'B', 'R', 'P', 'L', 'N', 'S', 'B', 'R', 'K',
1085
'p', 'l', 'n', 's', 'g', 'b', 'r', 'p', 'l', 'n', 's', 'b', 'r', 'k',
1086
'.'
1087
};
1088
1089
1090
int pieceisWhite[] =
1091
{
1092
False, False, False, False, False, False, False,
1093
False, False, False, False, False, False, False,
1094
True, True, True, True, True, True, True,
1095
True, True, True, True, True, True, True,
1096
False
1097
};
1098
1099
1100
1101
ShogiSquare pieceToPromoted[] =
1102
{
1103
BlackPPawn, BlackPLance, BlackPKnight, BlackPSilver, BlackGold,
1104
BlackPBishop, BlackPRook,
1105
BlackPPawn, BlackPLance, BlackPKnight, BlackPSilver,
1106
BlackPBishop, BlackPRook, BlackKing,
1107
WhitePPawn, WhitePLance, WhitePKnight, WhitePSilver, WhiteGold,
1108
WhitePBishop, WhitePRook,
1109
WhitePPawn, WhitePLance, WhitePKnight, WhitePSilver,
1110
WhitePBishop, WhitePRook, WhiteKing
1111
};
1112
1113
1114
1115
XrmOptionDescRec shellOptions[] =
1116
{
1117
{ "-blackPieceColor", "blackPieceColor", XrmoptionSepArg, NULL },
1118
{ "-bpc", "blackPieceColor", XrmoptionSepArg, NULL },
1119
{ "-whitePieceColor", "whitePieceColor", XrmoptionSepArg, NULL },
1120
{ "-wpc", "whitePieceColor", XrmoptionSepArg, NULL },
1121
{ "-charPieceColor", "charPieceColor", XrmoptionSepArg, NULL },
1122
{ "-cpc", "charPieceColor", XrmoptionSepArg, NULL },
1123
{ "-zeroColor", "zeroColor", XrmoptionSepArg, NULL },
1124
{ "-zc", "zeroColor", XrmoptionSepArg, NULL },
1125
{ "-oneColor", "oneColor", XrmoptionSepArg, NULL },
1126
{ "-oc", "oneColor", XrmoptionSepArg, NULL },
1127
{ "-lightSquareColor", "lightSquareColor", XrmoptionSepArg, NULL },
1128
{ "-lsc", "lightSquareColor", XrmoptionSepArg, NULL },
1129
{ "-darkSquareColor", "darkSquareColor", XrmoptionSepArg, NULL },
1130
{ "-dsc", "darkSquareColor", XrmoptionSepArg, NULL },
1131
{ "-westernPieceSet", "westernPieceSet", XrmoptionSepArg, NULL },
1132
{ "-wps", "westernPieceSet", XrmoptionSepArg, NULL },
1133
{ "-movesPerSession", "movesPerSession", XrmoptionSepArg, NULL },
1134
{ "-mps", "movesPerSession", XrmoptionSepArg, NULL },
1135
{ "-firstShogiProgram", "firstShogiProgram", XrmoptionSepArg, NULL },
1136
{ "-fsp", "firstShogiProgram", XrmoptionSepArg, NULL },
1137
{ "-secondShogiProgram", "secondShogiProgram", XrmoptionSepArg, NULL },
1138
{ "-ssp", "secondShogiProgram", XrmoptionSepArg, NULL },
1139
{ "-noShogiProgram", "noShogiProgram", XrmoptionSepArg, NULL },
1140
{ "-nsp", "noShogiProgram", XrmoptionSepArg, NULL },
1141
{ "-firstHost", "firstHost", XrmoptionSepArg, NULL },
1142
{ "-fh", "firstHost", XrmoptionSepArg, NULL },
1143
{ "-secondHost", "secondHost", XrmoptionSepArg, NULL },
1144
{ "-sh", "secondHost", XrmoptionSepArg, NULL },
1145
{ "-reversePawnBitmap", "reversePawnBitmap", XrmoptionSepArg, NULL },
1146
{ "-rpb", "reversePawnBitmap", XrmoptionSepArg, NULL },
1147
{ "-reverseLanceBitmap", "reverseLanceBitmap", XrmoptionSepArg, NULL },
1148
{ "-rlb", "reverseLanceBitmap", XrmoptionSepArg, NULL },
1149
{ "-reverseKnightBitmap", "reverseKnightBitmap", XrmoptionSepArg, NULL },
1150
{ "-rnb", "reverseKnightBitmap", XrmoptionSepArg, NULL },
1151
{ "-reverseSilverBitmap", "reverseSilverBitmap", XrmoptionSepArg, NULL },
1152
{ "-rsb", "reverseSilverBitmap", XrmoptionSepArg, NULL },
1153
{ "-reverseGoldBitmap", "reverseGoldBitmap", XrmoptionSepArg, NULL },
1154
{ "-rgb", "reverseGoldBitmap", XrmoptionSepArg, NULL },
1155
{ "-reverseRookBitmap", "reverseRookBitmap", XrmoptionSepArg, NULL },
1156
{ "-rrb", "reverseRookBitmap", XrmoptionSepArg, NULL },
1157
{ "-reverseBishopBitmap", "reverseBishopBitmap", XrmoptionSepArg, NULL },
1158
{ "-rbb", "reverseBishopBitmap", XrmoptionSepArg, NULL },
1159
{ "-reversePPawnBitmap", "reversePPawnBitmap",
1160
XrmoptionSepArg, NULL },
1161
{ "-rppb", "reversePPawnBitmap", XrmoptionSepArg, NULL },
1162
{ "-reversePLanceBitmap", "reversePLanceBitmap",
1163
XrmoptionSepArg, NULL },
1164
{ "-rplb", "reversePLanceBitmap", XrmoptionSepArg, NULL },
1165
{ "-reversePKnightBitmap", "reversePKnightBitmap",
1166
XrmoptionSepArg, NULL },
1167
{ "-rpnb", "reversePKnightBitmap", XrmoptionSepArg, NULL },
1168
{ "-reversePSilverBitmap", "reversePSilverBitmap",
1169
XrmoptionSepArg, NULL },
1170
{ "-rpsb", "reversePSilverBitmap", XrmoptionSepArg, NULL },
1171
{ "-reversePRookBitmap", "reversePRookBitmap",
1172
XrmoptionSepArg, NULL },
1173
{ "-rprb", "reversePRookBitmap", XrmoptionSepArg, NULL },
1174
{ "-reversePBishopBitmap", "reversePBishopBitmap",
1175
XrmoptionSepArg, NULL },
1176
{ "-rpbb", "reversePBishopBitmap", XrmoptionSepArg, NULL },
1177
{ "-reverseKingBitmap", "reverseKingBitmap", XrmoptionSepArg, NULL },
1178
{ "-rkb", "reverseKingBitmap", XrmoptionSepArg, NULL },
1179
{ "-outlinePawnBitmap", "outlinePawnBitmap", XrmoptionSepArg, NULL },
1180
{ "-opb", "normalPawnBitmap", XrmoptionSepArg, NULL },
1181
{ "-normalLanceBitmap", "normalLanceBitmap", XrmoptionSepArg, NULL },
1182
{ "-olb", "normalLanceBitmap", XrmoptionSepArg, NULL },
1183
{ "-normalKnightBitmap", "normalKnightBitmap", XrmoptionSepArg, NULL },
1184
{ "-onb", "normalKnightBitmap", XrmoptionSepArg, NULL },
1185
{ "-normalSilverBitmap", "normalSilverBitmap", XrmoptionSepArg, NULL },
1186
{ "-osb", "normalSilverBitmap", XrmoptionSepArg, NULL },
1187
{ "-normalGoldBitmap", "normalGoldBitmap", XrmoptionSepArg, NULL },
1188
{ "-ogb", "normalGoldBitmap", XrmoptionSepArg, NULL },
1189
{ "-normalRookBitmap", "normalRookBitmap", XrmoptionSepArg, NULL },
1190
{ "-orb", "normalRookBitmap", XrmoptionSepArg, NULL },
1191
{ "-normalBishopBitmap", "normalBishopBitmap", XrmoptionSepArg, NULL },
1192
{ "-obb", "normalBishopBitmap", XrmoptionSepArg, NULL },
1193
{ "-normalPPawnBitmap", "normalPPawnBitmap", XrmoptionSepArg, NULL },
1194
{ "-oppb", "normalPPawnBitmap", XrmoptionSepArg, NULL },
1195
{ "-normalPLanceBitmap", "normalPLanceBitmap", XrmoptionSepArg, NULL },
1196
{ "-oplb", "normalPLanceBitmap", XrmoptionSepArg, NULL },
1197
{ "-normalPKnightBitmap", "normalPKnightBitmap", XrmoptionSepArg, NULL },
1198
{ "-opnb", "normalPKnightBitmap", XrmoptionSepArg, NULL },
1199
{ "-normalPSilverBitmap", "normalPSilverBitmap", XrmoptionSepArg, NULL },
1200
{ "-opsb", "normalPSilverBitmap", XrmoptionSepArg, NULL },
1201
{ "-normalPRookBitmap", "normalPRookBitmap", XrmoptionSepArg, NULL },
1202
{ "-oprb", "normalPRookBitmap", XrmoptionSepArg, NULL },
1203
{ "-normalPBishopBitmap", "normalPBishopBitmap", XrmoptionSepArg, NULL },
1204
{ "-opbb", "normalPBishopBitmap", XrmoptionSepArg, NULL },
1205
{ "-normalKingBitmap", "normalKingBitmap", XrmoptionSepArg, NULL },
1206
{ "-okb", "outlineKingBitmap", XrmoptionSepArg, NULL },
1207
{ "-remoteShell", "remoteShell", XrmoptionSepArg, NULL },
1208
{ "-rsh", "remoteShell", XrmoptionSepArg, NULL },
1209
{ "-timeDelay", "timeDelay", XrmoptionSepArg, NULL },
1210
{ "-td", "timeDelay", XrmoptionSepArg, NULL },
1211
{ "-timeControl", "timeControl", XrmoptionSepArg, NULL },
1212
{ "-tc", "timeControl", XrmoptionSepArg, NULL },
1213
{ "-gameIn", "gameIn", XrmoptionSepArg, NULL },
1214
{ "-gi", "gameIn", XrmoptionSepArg, NULL },
1215
{ "-loadGameFile", "loadGameFile", XrmoptionSepArg, NULL },
1216
{ "-lgf", "loadGameFile", XrmoptionSepArg, NULL },
1217
{ "-loadPositionFile", "loadPositionFile", XrmoptionSepArg, NULL },
1218
{ "-lpf", "loadPositionFile", XrmoptionSepArg, NULL },
1219
{ "-saveGameFile", "saveGameFile", XrmoptionSepArg, NULL },
1220
{ "-sgf", "saveGameFile", XrmoptionSepArg, NULL },
1221
{ "-savePositionFile", "savePositionFile", XrmoptionSepArg, NULL },
1222
{ "-spf", "savePositionFile", XrmoptionSepArg, NULL },
1223
{ "-challengeDisplay", "challengeDisplay", XrmoptionSepArg, NULL },
1224
{ "-cd", "challengeDisplay", XrmoptionSepArg, NULL },
1225
{ "-matchMode", "matchMode", XrmoptionSepArg, NULL },
1226
{ "-mm", "matchMode", XrmoptionSepArg, NULL },
1227
{ "-monoMode", "monoMode", XrmoptionSepArg, NULL },
1228
{ "-mono", "monoMode", XrmoptionSepArg, NULL },
1229
{ "-debugMode", "debugMode", XrmoptionSepArg, NULL },
1230
{ "-debug", "debugMode", XrmoptionSepArg, NULL },
1231
{ "-clockMode", "clockMode", XrmoptionSepArg, NULL },
1232
{ "-clock", "clockMode", XrmoptionSepArg, NULL },
1233
{ "-boardSize", "boardSize", XrmoptionSepArg, NULL },
1234
{ "-size", "boardSize", XrmoptionSepArg, NULL },
1235
{ "-searchTime", "searchTime", XrmoptionSepArg, NULL },
1236
{ "-st", "searchTime", XrmoptionSepArg, NULL },
1237
{ "-searchDepth", "searchDepth", XrmoptionSepArg, NULL },
1238
{ "-sd", "searchDepth", XrmoptionSepArg, NULL },
1239
{ "-showCoords", "showCoords", XrmoptionSepArg, NULL },
1240
{ "-coords", "showCoords", XrmoptionSepArg, NULL },
1241
{ "-iconic", "Iconic", XrmoptionNoArg, "True" }
1242
};
1243
1244
1245
1246
XtActionsRec boardActions[] =
1247
{
1248
{ "DrawPosition", (XtActionProc) DrawPosition },
1249
{ "HandleUserMove", (XtActionProc) HandleUserMove },
1250
{ "ResetProc", (XtActionProc) ResetProc },
1251
{ "ResetFileProc", (XtActionProc) ResetFileProc },
1252
{ "LoadGameProc", (XtActionProc) LoadGameProc },
1253
{ "QuitProc", (XtActionProc) QuitProc },
1254
{ "ForwardProc", (XtActionProc) ForwardProc },
1255
{ "BackwardProc", (XtActionProc) BackwardProc },
1256
{ "PauseProc", (XtActionProc) PauseProc },
1257
{ "Iconify", (XtActionProc) Iconify },
1258
{ "FileNameAction", (XtActionProc) FileNameAction },
1259
{ "PieceMenuPopup", (XtActionProc) PieceMenuPopup },
1260
{ "SetBlackToPlay", (XtActionProc) SetBlackToPlay },
1261
{ "SetWhiteToPlay", (XtActionProc) SetWhiteToPlay }
1262
};
1263
1264
1265
char translationsTable[] =
1266
"<Expose>: DrawPosition() \n \
1267
<Btn1Down>: HandleUserMove() \n \
1268
<Btn1Up>: HandleUserMove() \n \
1269
<Btn2Down>: XawPositionSimpleMenu(menuW) PieceMenuPopup(menuW) \n \
1270
<Btn3Down>: XawPositionSimpleMenu(menuB) PieceMenuPopup(menuB) \n \
1271
<Key>r: ResetFileProc() ResetProc() \n \
1272
<Key>R: ResetFileProc() ResetProc() \n \
1273
<Key>g: LoadGameProc() \n \
1274
<Key>G: LoadGameProc() \n \
1275
<Key>q: QuitProc() \n \
1276
<Key>Q: QuitProc() \n \
1277
<Message>WM_PROTOCOLS: QuitProc() \n \
1278
<Key>f: ForwardProc() \n \
1279
<Key>F: ForwardProc() \n \
1280
<Key>b: BackwardProc() \n \
1281
<Key>B: BackwardProc() \n \
1282
<Key>p: PauseProc() \n \
1283
<Key>P: PauseProc() \n \
1284
<Key>i: Iconify() \n \
1285
<Key>I: Iconify() \n \
1286
<Key>c: Iconify() \n \
1287
<Key>C: Iconify() \n";
1288
1289
1290
char translationsTableReduced[] =
1291
"<Expose>: DrawPosition() \n \
1292
<Btn1Down>: HandleUserMove() \n \
1293
<Btn1Up>: HandleUserMove() \n \
1294
<Message>WM_PROTOCOLS: QuitProc() \n";
1295
1296
1297
char blackTranslations[] = "<BtnDown>: SetBlackToPlay()\n";
1298
char whiteTranslations[] = "<BtnDown>: SetWhiteToPlay()\n";
1299
1300
String xshogiResources[] =
1301
{
1302
DEFAULT_FONT,
1303
"*Dialog*value.translations: #override "
1304
"\\n <Key>Return: FileNameAction()",
1305
NULL
1306
};
1307
1308
1309
int global_argc; /* number of command args */
1310
char *global_argv[10]; /* pointers to up to 10 command args */
1311
1312
1313
1314
static struct DisplayData *player;
1315
1316
1317
typedef struct
1318
{
1319
char mode[2];
1320
char name[100];
1321
} FileModeInfo;
1322
1323
static FileModeInfo fmi;
1324
1325
1326
/**********************************************************************
1327
*
1328
* End of globals.
1329
*
1330
**********************************************************************/
1331
1332
1333
void
1334
CreatePlayerWindow(void)
1335
{
1336
int mainFontPxlSize, coordFontPxlSize;
1337
int min, sec, matched;
1338
XSetWindowAttributes window_attributes;
1339
char buf[MSG_SIZ];
1340
Arg args[10];
1341
Dimension timerWidth, boardWidth, commandsWidth, w, h;
1342
int local;
1343
int fromRemotePlayer = (player == &remotePlayer);
1344
1345
player->monoMode = player->appData.monoMode;
1346
player->showCoords = player->appData.showCoords;
1347
1348
/*
1349
* Parse timeControl resource.
1350
*/
1351
1352
if (player->appData.timeControl != NULL)
1353
{
1354
matched = sscanf(player->appData.timeControl, "%d:%d", &min, &sec);
1355
1356
if (matched == 1)
1357
{
1358
timeControl = min * 60 * 1000;
1359
}
1360
else if (matched == 2)
1361
{
1362
timeControl = (min * 60 + sec) * 1000;
1363
}
1364
else
1365
{
1366
fprintf(stderr, "%s: bad timeControl option %s\n",
1367
programName, player->appData.timeControl);
1368
Usage();
1369
}
1370
}
1371
1372
/*
1373
* Parse searchTime resource
1374
*/
1375
1376
if (player->appData.searchTime != NULL)
1377
{
1378
matched = sscanf(player->appData.searchTime, "%d:%d", &min, &sec);
1379
1380
if (matched == 1)
1381
{
1382
searchTime = min * 60;
1383
}
1384
else if (matched == 2)
1385
{
1386
searchTime = min * 60 + sec;
1387
}
1388
else
1389
{
1390
fprintf(stderr, "%s: bad searchTime option %s\n",
1391
programName, player->appData.searchTime);
1392
Usage();
1393
}
1394
}
1395
1396
if ((player->appData.searchTime != NULL)
1397
|| (player->appData.searchDepth > 0)
1398
|| player->appData.noShogiProgram)
1399
{
1400
player->appData.clockMode = False;
1401
}
1402
1403
player->Iconic = False;
1404
player->boardSize = Small;
1405
player->squareSize = SMALL_SQUARE_SIZE;
1406
player->flipView = (player == &remotePlayer);
1407
player->promotionUp = False;
1408
1409
/*
1410
* Determine boardSize.
1411
*/
1412
1413
if (strcasecmp(player->appData.boardSize, "Large") == 0)
1414
{
1415
player->boardSize = Large;
1416
}
1417
else if (strcasecmp(player->appData.boardSize, "Medium") == 0)
1418
{
1419
player->boardSize = Medium;
1420
}
1421
else if (strcasecmp(player->appData.boardSize, "Small") == 0)
1422
{
1423
player->boardSize = Small;
1424
}
1425
else
1426
{
1427
fprintf(stderr, "%s: bad boardSize option %s\n",
1428
programName, player->appData.boardSize);
1429
Usage();
1430
}
1431
1432
if ((local = (player == &localPlayer)))
1433
{
1434
player->xDisplay = XtDisplay(player->shellWidget);
1435
player->xScreen = DefaultScreen(player->xDisplay);
1436
}
1437
1438
if (((DisplayWidth(player->xDisplay, player->xScreen) < 800)
1439
|| (DisplayHeight(player->xDisplay, player->xScreen) < 800))
1440
&& (player->boardSize == Large))
1441
{
1442
player->boardSize = Medium;
1443
}
1444
1445
switch (player->boardSize)
1446
{
1447
case Small:
1448
player->squareSize = SMALL_SQUARE_SIZE;
1449
mainFontPxlSize = 11;
1450
coordFontPxlSize = 10;
1451
break;
1452
1453
case Medium:
1454
player->squareSize = MEDIUM_SQUARE_SIZE;
1455
mainFontPxlSize = 17;
1456
coordFontPxlSize = 12;
1457
break;
1458
1459
default:
1460
case Large:
1461
player->squareSize = LARGE_SQUARE_SIZE;
1462
mainFontPxlSize = 17;
1463
coordFontPxlSize = 14;
1464
break;
1465
}
1466
1467
/*
1468
* Detect if there are not enough colors are available and adapt.
1469
*/
1470
1471
if (DefaultDepth(player->xDisplay, player->xScreen) <= 2)
1472
player->monoMode = True;
1473
1474
/*
1475
* Determine what fonts to use.
1476
*/
1477
1478
player->appData.mainFont
1479
= FindFont(player->appData.mainFont, mainFontPxlSize);
1480
player->mainFontID
1481
= XLoadFont(player->xDisplay, player->appData.mainFont);
1482
player->mainFontStruct
1483
= XQueryFont(player->xDisplay, player->mainFontID);
1484
player->appData.coordFont
1485
= FindFont(player->appData.coordFont, coordFontPxlSize);
1486
player->coordFontID
1487
= XLoadFont(player->xDisplay, player->appData.coordFont);
1488
player->coordFontStruct
1489
= XQueryFont(player->xDisplay, player->coordFontID);
1490
1491
/*
1492
* Set default arguments.
1493
*/
1494
1495
XtSetArg(player->shellArgs[0], XtNwidth, 0);
1496
XtSetArg(player->shellArgs[1], XtNheight, 0);
1497
XtSetArg(player->shellArgs[2], XtNminWidth, 0);
1498
XtSetArg(player->shellArgs[3], XtNminHeight, 0);
1499
XtSetArg(player->shellArgs[4], XtNmaxWidth, 0);
1500
XtSetArg(player->shellArgs[5], XtNmaxHeight, 0);
1501
1502
XtSetArg(player->boardArgs[0], XtNborderWidth, 0);
1503
XtSetArg(player->boardArgs[1], XtNwidth,
1504
LINE_GAP + (BOARD_SIZE + 4)
1505
* (SMALL_SQUARE_SIZE + LINE_GAP));
1506
XtSetArg(player->boardArgs[2], XtNheight,
1507
LINE_GAP + BOARD_SIZE
1508
* (SMALL_SQUARE_SIZE + LINE_GAP));
1509
1510
XtSetArg(player->commandsArgs[0], XtNborderWidth, 0);
1511
XtSetArg(player->commandsArgs[1], XtNdefaultColumns, 4);
1512
XtSetArg(player->commandsArgs[2], XtNforceColumns, True);
1513
XtSetArg(player->commandsArgs[3], XtNcolumnSpacing, 12);
1514
XtSetArg(player->commandsArgs[4], XtNlist, (XtArgVal) buttonStrings);
1515
XtSetArg(player->commandsArgs[5], XtNnumberStrings, buttonCount);
1516
XtSetArg(player->commandsArgs[6], XtNfont, player->mainFontStruct);
1517
1518
XtSetArg(player->messageArgs[0], XtNborderWidth, 0);
1519
XtSetArg(player->messageArgs[1], XtNjustify, (XtArgVal) XtJustifyLeft);
1520
XtSetArg(player->messageArgs[2], XtNlabel, (XtArgVal) "starting...");
1521
1522
XtSetArg(player->timerArgs[0], XtNborderWidth, 0);
1523
XtSetArg(player->timerArgs[1], XtNjustify, (XtArgVal) XtJustifyLeft);
1524
1525
XtSetArg(player->titleArgs[0], XtNborderWidth, 0);
1526
XtSetArg(player->titleArgs[1], XtNjustify, (XtArgVal) XtJustifyLeft);
1527
1528
boardWidth = LINE_GAP
1529
+ (BOARD_SIZE + 4) * (player->squareSize + LINE_GAP);
1530
1531
XtSetArg(player->boardArgs[1], XtNwidth, boardWidth);
1532
XtSetArg(player->boardArgs[2], XtNheight,
1533
LINE_GAP + BOARD_SIZE * (player->squareSize + LINE_GAP));
1534
1535
/*
1536
* widget hierarchy
1537
*/
1538
1539
player->formWidget = XtCreateManagedWidget("form",
1540
formWidgetClass,
1541
player->shellWidget, NULL, 0);
1542
1543
player->widgetList[0] = player->blackTimerWidget
1544
= XtCreateWidget((local ? "black time:" : "rblack time:"),
1545
labelWidgetClass,
1546
player->formWidget, player->timerArgs,
1547
XtNumber(player->timerArgs));
1548
1549
XtSetArg(args[0], XtNfont, player->mainFontStruct);
1550
XtSetValues(player->blackTimerWidget, args, 1);
1551
1552
player->widgetList[1] = player->whiteTimerWidget
1553
= XtCreateWidget((local ? "white time:" : "rwhite time:"),
1554
labelWidgetClass,
1555
player->formWidget, player->timerArgs,
1556
XtNumber(player->timerArgs));
1557
1558
XtSetArg(args[0], XtNfont, player->mainFontStruct);
1559
XtSetValues(player->whiteTimerWidget, args, 1);
1560
1561
player->widgetList[2] = player->titleWidget
1562
= XtCreateWidget((local ? "" : "r"), labelWidgetClass,
1563
player->formWidget, player->titleArgs,
1564
XtNumber(player->titleArgs));
1565
1566
XtSetArg(args[0], XtNfont, player->mainFontStruct);
1567
XtSetValues(player->titleWidget, args, 1);
1568
1569
player->widgetList[3] = player->messageWidget
1570
= XtCreateWidget((local ? "message" : "rmessage"),
1571
labelWidgetClass, player->formWidget,
1572
player->messageArgs,
1573
XtNumber(player->messageArgs));
1574
1575
XtSetArg(args[0], XtNfont, player->mainFontStruct);
1576
XtSetValues(player->messageWidget, args, 1);
1577
1578
player->widgetList[4] = player->commandsWidget
1579
= XtCreateWidget((local ? "commands" : "rcommand"),
1580
listWidgetClass, player->formWidget,
1581
player->commandsArgs,
1582
XtNumber(player->commandsArgs));
1583
1584
player->widgetList[5] = player->boardWidget
1585
= XtCreateWidget((local ? "board" : "rboard"),
1586
widgetClass, player->formWidget,
1587
player->boardArgs,
1588
XtNumber(player->boardArgs));
1589
1590
XtManageChildren(player->widgetList, XtNumber(player->widgetList));
1591
1592
/*
1593
* Calculate the width of the timer labels.
1594
*/
1595
1596
XtSetArg(args[0], XtNfont, &player->mainFontStruct);
1597
XtGetValues(player->blackTimerWidget, args, 1);
1598
1599
if (player->appData.clockMode)
1600
{
1601
/* sprintf(buf, "Black: %s ", TimeString(timeControl));
1602
timerWidth = XTextWidth(player->mainFontStruct,
1603
buf, strlen(buf)); */
1604
timerWidth = XTextWidth(player->mainFontStruct,
1605
"Black: 8:88:88 ", 15);
1606
}
1607
else
1608
{
1609
timerWidth = XTextWidth(player->mainFontStruct, "Black ", 7);
1610
}
1611
1612
XtSetArg(args[0], XtNwidth, timerWidth);
1613
XtSetValues(player->blackTimerWidget, args, 1);
1614
XtSetValues(player->whiteTimerWidget, args, 1);
1615
1616
XtSetArg(args[0], XtNbackground, &player->timerForegroundPixel);
1617
XtSetArg(args[1], XtNforeground, &player->timerBackgroundPixel);
1618
XtGetValues(player->blackTimerWidget, args, 2);
1619
1620
/*
1621
* Calculate the width of the name and message labels.
1622
*/
1623
1624
XtSetArg(args[0], XtNwidth, &commandsWidth);
1625
XtGetValues(player->commandsWidget, args, 1);
1626
w = ((commandsWidth > boardWidth) ? commandsWidth : boardWidth);
1627
XtSetArg(args[0], XtNwidth, w - timerWidth*2 - 12);
1628
XtSetValues(player->titleWidget, args, 1);
1629
XtSetArg(args[0], XtNwidth, w - 8);
1630
XtSetValues(player->messageWidget, args, 1);
1631
1632
/*
1633
* formWidget uses these constraints but they are stored
1634
* in the children.
1635
*/
1636
1637
XtSetArg(args[0], XtNfromHoriz, player->blackTimerWidget);
1638
XtSetValues(player->whiteTimerWidget, args, 1);
1639
XtSetArg(args[0], XtNfromHoriz, player->whiteTimerWidget);
1640
XtSetValues(player->titleWidget, args, 1);
1641
XtSetArg(args[0], XtNfromVert, player->blackTimerWidget);
1642
XtSetValues(player->messageWidget, args, 1);
1643
XtSetArg(args[0], XtNfromVert, player->messageWidget);
1644
XtSetValues(player->commandsWidget, args, 1);
1645
XtSetArg(args[0], XtNfromVert, player->commandsWidget);
1646
XtSetValues(player->boardWidget, args, 1);
1647
1648
XtRealizeWidget(player->shellWidget);
1649
1650
player->xBoardWindow = XtWindow(player->boardWidget);
1651
1652
/*
1653
* Create an icon.
1654
*/
1655
1656
player->iconPixmap =
1657
XCreateBitmapFromData(player->xDisplay,
1658
XtWindow(player->shellWidget),
1659
icon_bits, icon_width, icon_height);
1660
1661
XtSetArg(args[0], XtNiconPixmap, player->iconPixmap);
1662
XtSetValues(player->shellWidget, args, 1);
1663
1664
/*
1665
* Create a cursor for the board widget.
1666
*/
1667
1668
window_attributes.cursor = XCreateFontCursor(player->xDisplay, XC_hand2);
1669
XChangeWindowAttributes(player->xDisplay, player->xBoardWindow,
1670
CWCursor, &window_attributes);
1671
1672
/*
1673
* Inhibit shell resizing.
1674
*/
1675
1676
player->shellArgs[0].value = (XtArgVal) &w;
1677
player->shellArgs[1].value = (XtArgVal) &h;
1678
XtGetValues(player->shellWidget, player->shellArgs, 2);
1679
player->shellArgs[4].value = player->shellArgs[2].value = w;
1680
player->shellArgs[5].value = player->shellArgs[3].value = h;
1681
XtSetValues(player->shellWidget, &player->shellArgs[2], 4);
1682
1683
/*
1684
* Determine value of black pixel.
1685
*/
1686
1687
player->black_pixel_is_zero =
1688
(XBlackPixel(player->xDisplay, player->xScreen) == 0);
1689
1690
CreateGCs();
1691
CreateGrid();
1692
CreatePieces();
1693
1694
if (!fromRemotePlayer)
1695
CreatePieceMenus();
1696
1697
XtAddCallback(player->commandsWidget, XtNcallback, SelectCommand,
1698
(XtPointer)fromRemotePlayer);
1699
1700
if (!fromRemotePlayer)
1701
XtAppAddActions(appContext, boardActions, XtNumber(boardActions));
1702
1703
if (fromRemotePlayer)
1704
{
1705
XtSetArg(args[0], XtNtranslations,
1706
XtParseTranslationTable(translationsTableReduced));
1707
/* Disable key commands because often keys are pressed
1708
in the board window if using another talk window. */
1709
XtSetValues(player->boardWidget, &args[0], 1);
1710
XtSetValues(localPlayer.boardWidget, &args[0], 1);
1711
}
1712
else
1713
{
1714
XtSetArg(args[0], XtNtranslations,
1715
XtParseTranslationTable(translationsTable));
1716
XtSetValues(player->boardWidget, &args[0], 1);
1717
XtSetArg(args[0], XtNtranslations,
1718
XtParseTranslationTable(blackTranslations));
1719
XtSetValues(player->blackTimerWidget, &args[0], 1);
1720
XtSetArg(args[0], XtNtranslations,
1721
XtParseTranslationTable(whiteTranslations));
1722
XtSetValues(player->whiteTimerWidget, &args[0], 1);
1723
}
1724
1725
XtAddEventHandler(player->boardWidget, ExposureMask | ButtonPressMask
1726
| ButtonReleaseMask | Button1MotionMask | KeyPressMask,
1727
False, (XtEventHandler)EventProc,
1728
(XtPointer)(player == &remotePlayer));
1729
1730
sprintf(buf, "xshogi version %s, patchlevel %s based on "
1731
"xboard version %s",
1732
version, patchlevel, XBOARD_VERSION);
1733
1734
/*
1735
* If there is to be a machine match, set it up.
1736
*/
1737
1738
if (matchMode != MatchFalse && player != &remotePlayer)
1739
{
1740
if (player->appData.noShogiProgram)
1741
{
1742
fprintf(stderr,
1743
"%s: can't have a match with no shogi programs!\n",
1744
programName);
1745
exit(1);
1746
}
1747
1748
DisplayMessage(buf, fromRemotePlayer);
1749
TwoMachinesProc(NULL, NULL, NULL, NULL);
1750
}
1751
else
1752
{
1753
Reset(True);
1754
DisplayMessage(buf, fromRemotePlayer);
1755
}
1756
}
1757
1758
1759
1760
1761
int
1762
main(int argc, char **argv)
1763
{
1764
setbuf(stdout, NULL);
1765
setbuf(stderr, NULL);
1766
1767
/*
1768
* Copy pointers to command line arguments and number of such pointers.
1769
* (argc, argv will be destroyed by XtAppInitialize)
1770
*/
1771
1772
for (global_argc = 0; global_argc < argc; global_argc++)
1773
global_argv[global_argc] = argv[global_argc];
1774
1775
programName = strrchr(argv[0], '/');
1776
1777
if (programName == NULL)
1778
programName = argv[0];
1779
else
1780
programName++;
1781
1782
localPlayer.shellWidget
1783
= XtAppInitialize(&appContext, "XShogi", shellOptions,
1784
XtNumber(shellOptions), &argc, argv,
1785
xshogiResources, NULL, 0);
1786
1787
if (argc > 1)
1788
Usage();
1789
1790
if ((shogiDir = (char *)getenv("SHOGIDIR")) == NULL)
1791
{
1792
shogiDir = ".";
1793
}
1794
else
1795
{
1796
if (chdir(shogiDir) != 0)
1797
{
1798
fprintf(stderr, "%s: can't cd to SHOGIDIR\n",
1799
programName);
1800
perror(shogiDir);
1801
exit(1);
1802
}
1803
}
1804
1805
XtGetApplicationResources(localPlayer.shellWidget,
1806
&localPlayer.appData, clientResources,
1807
XtNumber(clientResources), NULL, 0);
1808
1809
xshogiDebug = localPlayer.appData.debugMode;
1810
1811
/*
1812
* Determine matchMode state -- poor man's resource converter
1813
*/
1814
1815
if (strcasecmp(localPlayer.appData.matchMode, "Init") == 0)
1816
{
1817
matchMode = MatchInit;
1818
}
1819
else if (strcasecmp(localPlayer.appData.matchMode, "Position") == 0)
1820
{
1821
matchMode = MatchPosition;
1822
}
1823
else if (strcasecmp(localPlayer.appData.matchMode, "Opening") == 0)
1824
{
1825
matchMode = MatchOpening;
1826
}
1827
else if (strcasecmp(localPlayer.appData.matchMode, "False") == 0)
1828
{
1829
matchMode = MatchFalse;
1830
}
1831
else
1832
{
1833
fprintf(stderr, "%s: bad matchMode option %s\n",
1834
programName, localPlayer.appData.matchMode);
1835
Usage();
1836
}
1837
1838
buttonStrings = gnuButtonStrings;
1839
buttonProcs = gnuButtonProcs;
1840
buttonCount = XtNumber(gnuButtonStrings);
1841
1842
player = &localPlayer;
1843
1844
CreatePlayerWindow();
1845
1846
XtAppMainLoop(appContext);
1847
1848
return 0;
1849
}
1850
1851
1852
1853
/*
1854
* Find a font that matches "pattern" that is as close as
1855
* possible to the targetPxlSize. Prefer fonts that are k
1856
* pixels smaller to fonts that are k pixels larger. The
1857
* pattern must be in the X Consortium standard format,
1858
* e.g. "-*-helvetica-bold-r-normal--*-*-*-*-*-*-*-*".
1859
* The return value should be freed with XtFree when no
1860
* longer needed.
1861
*/
1862
1863
char *
1864
FindFont(char *pattern, int targetPxlSize)
1865
{
1866
char **fonts, *p, *best;
1867
int i, j, nfonts, minerr, err, pxlSize;
1868
1869
fonts = XListFonts(player->xDisplay, pattern, 999999, &nfonts);
1870
1871
if (nfonts < 1)
1872
{
1873
fprintf(stderr, "%s: No fonts match pattern %s\n",
1874
programName, pattern);
1875
exit(1);
1876
}
1877
1878
best = "";
1879
minerr = 999999;
1880
1881
for (i = 0; i < nfonts; i++)
1882
{
1883
j = 0;
1884
p = fonts[i];
1885
1886
if (*p != '-')
1887
continue;
1888
1889
while (j < 7)
1890
{
1891
if (*p == NULLCHAR)
1892
break;
1893
1894
if (*p++ == '-')
1895
j++;
1896
}
1897
1898
if (j < 7)
1899
continue;
1900
1901
pxlSize = atoi(p);
1902
1903
if (pxlSize == targetPxlSize)
1904
{
1905
best = fonts[i];
1906
break;
1907
}
1908
1909
err = pxlSize - targetPxlSize;
1910
1911
if (abs(err) < abs(minerr)
1912
|| ((minerr > 0) && (err < 0) && (-err == minerr)))
1913
{
1914
best = fonts[i];
1915
minerr = err;
1916
}
1917
}
1918
1919
p = (char *)XtMalloc(strlen(best) + 1);
1920
strcpy(p, best);
1921
XFreeFontNames(fonts);
1922
return p;
1923
}
1924
1925
1926
1927
1928
void
1929
CreateGCs(void)
1930
{
1931
XtGCMask value_mask = GCLineWidth | GCLineStyle | GCForeground
1932
| GCBackground | GCFunction | GCPlaneMask;
1933
XGCValues gc_values;
1934
1935
gc_values.plane_mask = AllPlanes;
1936
gc_values.line_width = LINE_GAP;
1937
gc_values.line_style = LineSolid;
1938
gc_values.function = GXcopy;
1939
1940
gc_values.foreground = XBlackPixel(player->xDisplay, player->xScreen);
1941
gc_values.background = XBlackPixel(player->xDisplay, player->xScreen);
1942
player->lineGC = XtGetGC(player->shellWidget, value_mask, &gc_values);
1943
1944
gc_values.background = XWhitePixel(player->xDisplay, player->xScreen);
1945
player->coordGC = XtGetGC(player->shellWidget, value_mask, &gc_values);
1946
XSetFont(player->xDisplay, player->coordGC, player->coordFontID);
1947
1948
if (player->monoMode)
1949
{
1950
gc_values.foreground
1951
= XWhitePixel(player->xDisplay, player->xScreen);
1952
gc_values.background
1953
= XBlackPixel(player->xDisplay, player->xScreen);
1954
player->lightSquareGC = player->darkSquareGC = player->wbPieceGC
1955
= XtGetGC(player->shellWidget, value_mask, &gc_values);
1956
gc_values.foreground
1957
= XBlackPixel(player->xDisplay, player->xScreen);
1958
gc_values.background
1959
= XWhitePixel(player->xDisplay, player->xScreen);
1960
player->bwPieceGC
1961
= XtGetGC(player->shellWidget, value_mask, &gc_values);
1962
}
1963
else
1964
{
1965
/* white piece black background */
1966
gc_values.foreground
1967
= XWhitePixel(player->xDisplay, player->xScreen);
1968
gc_values.background
1969
= XBlackPixel(player->xDisplay, player->xScreen);
1970
player->wbPieceGC
1971
= XtGetGC(player->shellWidget, value_mask, &gc_values);
1972
1973
/* black piece white background */
1974
gc_values.foreground
1975
= XBlackPixel(player->xDisplay, player->xScreen);
1976
gc_values.background
1977
= XWhitePixel(player->xDisplay, player->xScreen);
1978
player->bwPieceGC
1979
= XtGetGC(player->shellWidget, value_mask, &gc_values);
1980
1981
/* light empty square */
1982
gc_values.foreground
1983
= player->appData.lightSquareColor;
1984
gc_values.background
1985
= player->appData.darkSquareColor;
1986
player->lightSquareGC
1987
= XtGetGC(player->shellWidget, value_mask, &gc_values);
1988
1989
/* dark empty square */
1990
gc_values.foreground
1991
= player->appData.darkSquareColor;
1992
gc_values.background
1993
= player->appData.lightSquareColor;
1994
player->darkSquareGC
1995
= XtGetGC(player->shellWidget, value_mask, &gc_values);
1996
1997
/* black piece on dark square */
1998
gc_values.background
1999
= player->appData.blackPieceColor;
2000
gc_values.foreground
2001
= player->appData.darkSquareColor;
2002
player->bdPieceGC
2003
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2004
2005
/* black piece on light square */
2006
gc_values.background
2007
= player->appData.blackPieceColor;
2008
gc_values.foreground
2009
= player->appData.lightSquareColor;
2010
player->blPieceGC
2011
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2012
2013
/* white piece on dark square */
2014
gc_values.background
2015
= player->appData.whitePieceColor;
2016
gc_values.foreground
2017
= player->appData.darkSquareColor;
2018
player->wdPieceGC
2019
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2020
2021
/* white piece on dark square */
2022
gc_values.background
2023
= player->appData.whitePieceColor;
2024
gc_values.foreground
2025
= player->appData.lightSquareColor;
2026
player->wlPieceGC
2027
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2028
2029
/* black piece off board */
2030
gc_values.background
2031
= player->appData.blackPieceColor;
2032
gc_values.foreground
2033
= XWhitePixel(player->xDisplay, player->xScreen);
2034
player->boPieceGC
2035
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2036
2037
/* white piece off board */
2038
gc_values.background
2039
= player->appData.whitePieceColor;
2040
gc_values.foreground
2041
= XWhitePixel(player->xDisplay, player->xScreen);
2042
player->woPieceGC
2043
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2044
2045
/* piece symbol */
2046
gc_values.function = (player->black_pixel_is_zero ? GXand : GXor);
2047
2048
gc_values.foreground
2049
= XBlackPixel(player->xDisplay, player->xScreen);
2050
gc_values.background
2051
= XWhitePixel(player->xDisplay, player->xScreen);
2052
player->charPieceGC
2053
= XtGetGC(player->shellWidget, value_mask, &gc_values);
2054
}
2055
}
2056
2057
2058
2059
2060
void
2061
CreatePieces(void)
2062
{
2063
XSynchronize(player->xDisplay, True); /* Work-around for xlib/xt
2064
buffering bug */
2065
2066
if (player->appData.westernPieceSet)
2067
{
2068
ReadBitmap(player->appData.reverseBigSolidBitmap,
2069
&player->reverseBigSolidBitmap,
2070
NULL,
2071
bigsolidR_bits, bigsolidR_bits, bigsolidR_bits);
2072
2073
ReadBitmap(player->appData.reverseSmallSolidBitmap,
2074
&player->reverseSmallSolidBitmap,
2075
NULL,
2076
smallsolidR_bits, smallsolidR_bits, smallsolidR_bits);
2077
2078
ReadBitmap(player->appData.normalBigSolidBitmap,
2079
&player->normalBigSolidBitmap,
2080
NULL,
2081
bigsolid_bits, bigsolid_bits, bigsolid_bits);
2082
2083
ReadBitmap(player->appData.normalSmallSolidBitmap,
2084
&player->normalSmallSolidBitmap,
2085
NULL,
2086
smallsolid_bits, smallsolid_bits, smallsolid_bits);
2087
2088
ReadBitmap(player->appData.reversePawnBitmap,
2089
&player->reversePawnBitmap,
2090
&player->reverseSmallSolidBitmap,
2091
pawnRW_bits, pawnRW_bits, pawnRW_bits);
2092
2093
ReadBitmap(player->appData.reverseLanceBitmap,
2094
&player->reverseLanceBitmap,
2095
&player->reverseSmallSolidBitmap,
2096
lanceRW_bits, lanceRW_bits, lanceRW_bits);
2097
2098
ReadBitmap(player->appData.reverseKnightBitmap,
2099
&player->reverseKnightBitmap,
2100
&player->reverseSmallSolidBitmap,
2101
knightRW_bits, knightRW_bits, knightRW_bits);
2102
2103
ReadBitmap(player->appData.reverseSilverBitmap,
2104
&player->reverseSilverBitmap,
2105
&player->reverseBigSolidBitmap,
2106
silverRW_bits, silverRW_bits, silverRW_bits);
2107
2108
ReadBitmap(player->appData.reverseGoldBitmap,
2109
&player->reverseGoldBitmap,
2110
&player->reverseBigSolidBitmap,
2111
goldRW_bits, goldRW_bits, goldRW_bits);
2112
2113
ReadBitmap(player->appData.reverseRookBitmap,
2114
&player->reverseRookBitmap,
2115
&player->reverseBigSolidBitmap,
2116
rookRW_bits, rookRW_bits, rookRW_bits);
2117
2118
ReadBitmap(player->appData.reverseBishopBitmap,
2119
&player->reverseBishopBitmap,
2120
&player->reverseBigSolidBitmap,
2121
bishopRW_bits, bishopRW_bits, bishopRW_bits);
2122
2123
ReadBitmap(player->appData.reversePPawnBitmap,
2124
&player->reversePPawnBitmap,
2125
&player->reverseSmallSolidBitmap,
2126
pawnPRW_bits, pawnPRW_bits, pawnPRW_bits);
2127
2128
ReadBitmap(player->appData.reversePLanceBitmap,
2129
&player->reversePLanceBitmap,
2130
&player->reverseSmallSolidBitmap,
2131
lancePRW_bits, lancePRW_bits, lancePRW_bits);
2132
2133
ReadBitmap(player->appData.reversePKnightBitmap,
2134
&player->reversePKnightBitmap,
2135
&player->reverseSmallSolidBitmap,
2136
knightPRW_bits, knightPRW_bits, knightPRW_bits);
2137
2138
ReadBitmap(player->appData.reversePSilverBitmap,
2139
&player->reversePSilverBitmap,
2140
&player->reverseBigSolidBitmap,
2141
silverPRW_bits, silverPRW_bits, silverPRW_bits);
2142
2143
ReadBitmap(player->appData.reversePRookBitmap,
2144
&player->reversePRookBitmap,
2145
&player->reverseBigSolidBitmap,
2146
rookPRW_bits, rookPRW_bits, rookPRW_bits);
2147
2148
ReadBitmap(player->appData.reversePBishopBitmap,
2149
&player->reversePBishopBitmap,
2150
&player->reverseBigSolidBitmap,
2151
bishopPRW_bits, bishopPRW_bits, bishopPRW_bits);
2152
2153
ReadBitmap(player->appData.reverseKingBitmap,
2154
&player->reverseKingBitmap,
2155
&player->reverseBigSolidBitmap,
2156
kingRW_bits, kingRW_bits, kingRW_bits);
2157
2158
ReadBitmap(player->appData.normalPawnBitmap,
2159
&player->normalPawnBitmap,
2160
&player->normalSmallSolidBitmap,
2161
pawnW_bits, pawnW_bits, pawnW_bits);
2162
2163
ReadBitmap(player->appData.normalLanceBitmap,
2164
&player->normalLanceBitmap,
2165
&player->normalSmallSolidBitmap,
2166
lanceW_bits, lanceW_bits, lanceW_bits);
2167
2168
ReadBitmap(player->appData.normalKnightBitmap,
2169
&player->normalKnightBitmap,
2170
&player->normalSmallSolidBitmap,
2171
knightW_bits, knightW_bits, knightW_bits);
2172
2173
ReadBitmap(player->appData.normalSilverBitmap,
2174
&player->normalSilverBitmap,
2175
&player->normalBigSolidBitmap,
2176
silverW_bits, silverW_bits, silverW_bits);
2177
2178
ReadBitmap(player->appData.normalGoldBitmap,
2179
&player->normalGoldBitmap,
2180
&player->normalBigSolidBitmap,
2181
goldW_bits, goldW_bits, goldW_bits);
2182
2183
ReadBitmap(player->appData.normalRookBitmap,
2184
&player->normalRookBitmap,
2185
&player->normalBigSolidBitmap,
2186
rookW_bits, rookW_bits, rookW_bits);
2187
2188
ReadBitmap(player->appData.normalBishopBitmap,
2189
&player->normalBishopBitmap,
2190
&player->normalBigSolidBitmap,
2191
bishopW_bits, bishopW_bits, bishopW_bits);
2192
2193
ReadBitmap(player->appData.normalPPawnBitmap,
2194
&player->normalPPawnBitmap,
2195
&player->normalSmallSolidBitmap,
2196
pawnPW_bits, pawnPW_bits, pawnPW_bits);
2197
2198
ReadBitmap(player->appData.normalPLanceBitmap,
2199
&player->normalPLanceBitmap,
2200
&player->normalSmallSolidBitmap,
2201
lancePW_bits, lancePW_bits, lancePW_bits);
2202
2203
ReadBitmap(player->appData.normalPKnightBitmap,
2204
&player->normalPKnightBitmap,
2205
&player->normalSmallSolidBitmap,
2206
knightPW_bits, knightPW_bits, knightPW_bits);
2207
2208
ReadBitmap(player->appData.normalPSilverBitmap,
2209
&player->normalPSilverBitmap,
2210
&player->normalBigSolidBitmap,
2211
silverPW_bits, silverPW_bits, silverPW_bits);
2212
2213
ReadBitmap(player->appData.normalPRookBitmap,
2214
&player->normalPRookBitmap,
2215
&player->normalBigSolidBitmap,
2216
rookPW_bits, rookPW_bits, rookPW_bits);
2217
2218
ReadBitmap(player->appData.normalPBishopBitmap,
2219
&player->normalPBishopBitmap,
2220
&player->normalBigSolidBitmap,
2221
bishopPW_bits, bishopPW_bits, bishopPW_bits);
2222
2223
ReadBitmap(player->appData.normalKingBitmap,
2224
&player->normalKingBitmap,
2225
&player->normalBigSolidBitmap,
2226
kingW_bits, kingW_bits, kingW_bits);
2227
}
2228
else
2229
{
2230
ReadBitmap(player->appData.reverseBigSolidBitmap,
2231
&player->reverseBigSolidBitmap,
2232
NULL,
2233
bigsolidR_bits, bigsolidR_m_bits, bigsolidR_l_bits);
2234
2235
ReadBitmap(player->appData.reverseSmallSolidBitmap,
2236
&player->reverseSmallSolidBitmap,
2237
NULL,
2238
smallsolidR_bits, smallsolidR_m_bits, smallsolidR_l_bits);
2239
2240
ReadBitmap(player->appData.normalBigSolidBitmap,
2241
&player->normalBigSolidBitmap,
2242
NULL,
2243
bigsolid_bits, bigsolid_m_bits, bigsolid_l_bits);
2244
2245
ReadBitmap(player->appData.normalSmallSolidBitmap,
2246
&player->normalSmallSolidBitmap,
2247
NULL,
2248
smallsolid_bits, smallsolid_m_bits, smallsolid_l_bits);
2249
2250
ReadBitmap(player->appData.reversePawnBitmap,
2251
&player->reversePawnBitmap,
2252
&player->reverseSmallSolidBitmap,
2253
pawnR_bits, pawnR_m_bits, pawnR_l_bits);
2254
2255
ReadBitmap(player->appData.reverseLanceBitmap,
2256
&player->reverseLanceBitmap,
2257
&player->reverseSmallSolidBitmap,
2258
lanceR_bits, lanceR_m_bits, lanceR_l_bits);
2259
2260
ReadBitmap(player->appData.reverseKnightBitmap,
2261
&player->reverseKnightBitmap,
2262
&player->reverseSmallSolidBitmap,
2263
knightR_bits, knightR_m_bits, knightR_l_bits);
2264
2265
ReadBitmap(player->appData.reverseSilverBitmap,
2266
&player->reverseSilverBitmap,
2267
&player->reverseBigSolidBitmap,
2268
silverR_bits, silverR_m_bits, silverR_l_bits);
2269
2270
ReadBitmap(player->appData.reverseGoldBitmap,
2271
&player->reverseGoldBitmap,
2272
&player->reverseBigSolidBitmap,
2273
goldR_bits, goldR_m_bits, goldR_l_bits);
2274
2275
ReadBitmap(player->appData.reverseRookBitmap,
2276
&player->reverseRookBitmap,
2277
&player->reverseBigSolidBitmap,
2278
rookR_bits, rookR_m_bits, rookR_l_bits);
2279
2280
ReadBitmap(player->appData.reverseBishopBitmap,
2281
&player->reverseBishopBitmap,
2282
&player->reverseBigSolidBitmap,
2283
bishopR_bits, bishopR_m_bits, bishopR_l_bits);
2284
2285
ReadBitmap(player->appData.reversePPawnBitmap,
2286
&player->reversePPawnBitmap,
2287
&player->reverseSmallSolidBitmap,
2288
pawnPR_bits, pawnPR_m_bits, pawnPR_l_bits);
2289
2290
ReadBitmap(player->appData.reversePLanceBitmap,
2291
&player->reversePLanceBitmap,
2292
&player->reverseSmallSolidBitmap,
2293
lancePR_bits, lancePR_m_bits, lancePR_l_bits);
2294
2295
ReadBitmap(player->appData.reversePKnightBitmap,
2296
&player->reversePKnightBitmap,
2297
&player->reverseSmallSolidBitmap,
2298
knightPR_bits, knightPR_m_bits, knightPR_l_bits);
2299
2300
ReadBitmap(player->appData.reversePSilverBitmap,
2301
&player->reversePSilverBitmap,
2302
&player->reverseBigSolidBitmap,
2303
silverPR_bits, silverPR_m_bits, silverPR_l_bits);
2304
2305
ReadBitmap(player->appData.reversePRookBitmap,
2306
&player->reversePRookBitmap,
2307
&player->reverseBigSolidBitmap,
2308
rookPR_bits, rookPR_m_bits, rookPR_l_bits);
2309
2310
ReadBitmap(player->appData.reversePBishopBitmap,
2311
&player->reversePBishopBitmap,
2312
&player->reverseBigSolidBitmap,
2313
bishopPR_bits, bishopPR_m_bits, bishopPR_l_bits);
2314
2315
ReadBitmap(player->appData.reverseKingBitmap,
2316
&player->reverseKingBitmap,
2317
&player->reverseBigSolidBitmap,
2318
kingR_bits, kingR_m_bits, kingR_l_bits);
2319
2320
ReadBitmap(player->appData.normalPawnBitmap,
2321
&player->normalPawnBitmap,
2322
&player->normalSmallSolidBitmap,
2323
pawn_bits, pawn_m_bits, pawn_l_bits);
2324
2325
ReadBitmap(player->appData.normalLanceBitmap,
2326
&player->normalLanceBitmap,
2327
&player->normalSmallSolidBitmap,
2328
lance_bits, lance_m_bits, lance_l_bits);
2329
2330
ReadBitmap(player->appData.normalKnightBitmap,
2331
&player->normalKnightBitmap,
2332
&player->normalSmallSolidBitmap,
2333
knight_bits, knight_m_bits, knight_l_bits);
2334
2335
ReadBitmap(player->appData.normalSilverBitmap,
2336
&player->normalSilverBitmap,
2337
&player->normalBigSolidBitmap,
2338
silver_bits, silver_m_bits, silver_l_bits);
2339
2340
ReadBitmap(player->appData.normalGoldBitmap,
2341
&player->normalGoldBitmap,
2342
&player->normalBigSolidBitmap,
2343
gold_bits, gold_m_bits, gold_l_bits);
2344
2345
ReadBitmap(player->appData.normalRookBitmap,
2346
&player->normalRookBitmap,
2347
&player->normalBigSolidBitmap,
2348
rook_bits, rook_m_bits, rook_l_bits);
2349
2350
ReadBitmap(player->appData.normalBishopBitmap,
2351
&player->normalBishopBitmap,
2352
&player->normalBigSolidBitmap,
2353
bishop_bits, bishop_m_bits, bishop_l_bits);
2354
2355
ReadBitmap(player->appData.normalPPawnBitmap,
2356
&player->normalPPawnBitmap,
2357
&player->normalSmallSolidBitmap,
2358
pawnP_bits, pawnP_m_bits, pawnP_l_bits);
2359
2360
ReadBitmap(player->appData.normalPLanceBitmap,
2361
&player->normalPLanceBitmap,
2362
&player->normalSmallSolidBitmap,
2363
lanceP_bits, lanceP_m_bits, lanceP_l_bits);
2364
2365
ReadBitmap(player->appData.normalPKnightBitmap,
2366
&player->normalPKnightBitmap,
2367
&player->normalSmallSolidBitmap,
2368
knightP_bits, knightP_m_bits, knightP_l_bits);
2369
2370
ReadBitmap(player->appData.normalPSilverBitmap,
2371
&player->normalPSilverBitmap,
2372
&player->normalBigSolidBitmap,
2373
silverP_bits, silverP_m_bits, silverP_l_bits);
2374
2375
ReadBitmap(player->appData.normalPRookBitmap,
2376
&player->normalPRookBitmap,
2377
&player->normalBigSolidBitmap,
2378
rookP_bits, rookP_m_bits, rookP_l_bits);
2379
2380
ReadBitmap(player->appData.normalPBishopBitmap,
2381
&player->normalPBishopBitmap,
2382
&player->normalBigSolidBitmap,
2383
bishopP_bits, bishopP_m_bits, bishopP_l_bits);
2384
2385
ReadBitmap(player->appData.normalKingBitmap,
2386
&player->normalKingBitmap,
2387
&player->normalBigSolidBitmap,
2388
king_bits, king_m_bits, king_l_bits);
2389
2390
}
2391
2392
XSynchronize(player->xDisplay, False); /* Work-around for xlib/xt
2393
buffering bug */
2394
}
2395
2396
2397
2398
2399
int
2400
ReadBitmapFile(Display *display, Drawable d, char *filename,
2401
unsigned int *width_return,
2402
unsigned int *height_return,
2403
Pixmap *bitmap_return,
2404
int *x_hot_return, int *y_hot_return)
2405
{
2406
int n;
2407
2408
if ((n = XReadBitmapFile(display, d, filename,
2409
width_return, height_return,
2410
bitmap_return, x_hot_return, y_hot_return))
2411
!= BitmapSuccess)
2412
{
2413
return n;
2414
}
2415
else
2416
{
2417
/* transform a 1 plane pixmap to a k plane pixmap */
2418
return BitmapSuccess;
2419
}
2420
}
2421
2422
2423
2424
2425
/*
2426
* Create the X pixmap from .xbm file bitmap data. This may
2427
* have to be revised considerably.
2428
*/
2429
2430
void
2431
ReadBitmap(String name, Pixmap *pm, Pixmap *qm,
2432
char *small_bits, char *medium_bits, char *large_bits)
2433
{
2434
int x_hot, y_hot;
2435
u_int w, h;
2436
2437
if ((name == NULL)
2438
|| (ReadBitmapFile(player->xDisplay, player->xBoardWindow, name,
2439
&w, &h, pm, &x_hot, &y_hot) != BitmapSuccess)
2440
|| (w != player->squareSize)
2441
|| (h != player->squareSize))
2442
{
2443
unsigned long fg, bg;
2444
unsigned int depth;
2445
2446
depth = DisplayPlanes(player->xDisplay, player->xScreen);
2447
2448
if (player->monoMode)
2449
{
2450
fg = XBlackPixel(player->xDisplay, player->xScreen);
2451
bg = XWhitePixel(player->xDisplay, player->xScreen);
2452
}
2453
else if (qm == NULL)
2454
{
2455
fg = player->appData.oneColor;
2456
bg = player->appData.zeroColor;
2457
}
2458
else
2459
{
2460
fg = (player->black_pixel_is_zero ? 0 : ~0);
2461
bg = (player->black_pixel_is_zero ? ~0 : 0);
2462
}
2463
2464
switch (player->boardSize)
2465
{
2466
case Large:
2467
*pm = XCreatePixmapFromBitmapData(player->xDisplay,
2468
player->xBoardWindow,
2469
large_bits,
2470
player->squareSize,
2471
player->squareSize,
2472
fg, bg, depth);
2473
break;
2474
2475
case Medium:
2476
*pm = XCreatePixmapFromBitmapData(player->xDisplay,
2477
player->xBoardWindow,
2478
medium_bits,
2479
player->squareSize,
2480
player->squareSize,
2481
fg, bg, depth);
2482
break;
2483
2484
case Small:
2485
*pm = XCreatePixmapFromBitmapData(player->xDisplay,
2486
player->xBoardWindow,
2487
small_bits,
2488
player->squareSize,
2489
player->squareSize,
2490
fg, bg, depth);
2491
break;
2492
}
2493
}
2494
}
2495
2496
2497
2498
2499
void
2500
CreateGrid(void)
2501
{
2502
int i, offset;
2503
2504
offset = 2 * (player->squareSize + LINE_GAP);
2505
2506
for (i = 0; i < BOARD_SIZE + 1; i++)
2507
{
2508
player->gridSegments[i].x1 = offset;
2509
player->gridSegments[i + BOARD_SIZE + 1].y1 = 0;
2510
player->gridSegments[i].y1 = player->gridSegments[i].y2
2511
= LINE_GAP / 2 + (i * (player->squareSize + LINE_GAP));
2512
player->gridSegments[i].x2 = LINE_GAP + BOARD_SIZE *
2513
(player->squareSize + LINE_GAP) + offset;
2514
player->gridSegments[i + BOARD_SIZE + 1].x1
2515
= player->gridSegments[i + BOARD_SIZE + 1].x2 = LINE_GAP / 2
2516
+ (i * (player->squareSize + LINE_GAP)) + offset;
2517
player->gridSegments[i + BOARD_SIZE + 1].y2
2518
= BOARD_SIZE * (player->squareSize + LINE_GAP);
2519
}
2520
}
2521
2522
2523
2524
2525
void
2526
CreatePieceMenus(void)
2527
{
2528
int i;
2529
Widget entry;
2530
Arg args[1];
2531
ShogiSquare selection;
2532
2533
XtSetArg(args[0], XtNlabel, "Black");
2534
blackPieceMenu = XtCreatePopupShell("menuW", simpleMenuWidgetClass,
2535
localPlayer.boardWidget, args, 1);
2536
2537
for (i = 0; i < PIECE_MENU_SIZE; i++)
2538
{
2539
String item = pieceMenuStrings[i];
2540
2541
if (strcmp(item, "----") == 0)
2542
{
2543
entry = XtCreateManagedWidget(item, smeLineObjectClass,
2544
blackPieceMenu, NULL, 0);
2545
}
2546
else
2547
{
2548
entry = XtCreateManagedWidget(item, smeBSBObjectClass,
2549
blackPieceMenu, NULL, 0);
2550
selection = pieceMenuTranslation[0][i];
2551
XtAddCallback(entry, XtNcallback,
2552
(XtCallbackProc) PieceMenuSelect,
2553
(caddr_t)selection);
2554
2555
if (selection == BlackPawn)
2556
{
2557
XtSetArg(args[0], XtNpopupOnEntry, entry);
2558
XtSetValues(blackPieceMenu, args, 1);
2559
}
2560
}
2561
}
2562
2563
XtSetArg(args[0], XtNlabel, "White");
2564
whitePieceMenu = XtCreatePopupShell("menuB", simpleMenuWidgetClass,
2565
localPlayer.boardWidget, args, 1);
2566
2567
for (i = 0; i < PIECE_MENU_SIZE; i++)
2568
{
2569
String item = pieceMenuStrings[i];
2570
2571
if (strcmp(item, "----") == 0)
2572
{
2573
entry = XtCreateManagedWidget(item, smeLineObjectClass,
2574
whitePieceMenu, NULL, 0);
2575
}
2576
else
2577
{
2578
entry = XtCreateManagedWidget(item, smeBSBObjectClass,
2579
whitePieceMenu, NULL, 0);
2580
selection = pieceMenuTranslation[1][i];
2581
XtAddCallback(entry, XtNcallback,
2582
(XtCallbackProc) PieceMenuSelect,
2583
(caddr_t)selection);
2584
2585
if (selection == WhitePawn)
2586
{
2587
XtSetArg(args[0], XtNpopupOnEntry, entry);
2588
XtSetValues(whitePieceMenu, args, 1);
2589
}
2590
}
2591
}
2592
2593
XtRegisterGrabAction(PieceMenuPopup, True,
2594
(unsigned)(ButtonPressMask|ButtonReleaseMask),
2595
GrabModeAsync, GrabModeAsync);
2596
}
2597
2598
2599
2600
2601
void
2602
PieceMenuPopup(Widget w, XEvent *event, String *params, Cardinal *num_params)
2603
{
2604
if (event->type != ButtonPress)
2605
return;
2606
2607
if (gameMode != EditPosition)
2608
return;
2609
2610
if (((pmFromX = EventToXSquare(event->xbutton.x)) < 1)
2611
|| (pmFromX > BOARD_SIZE + 2)
2612
|| ((pmFromY = EventToSquare(event->xbutton.y)) < 0))
2613
{
2614
pmFromX = pmFromY = -1;
2615
return;
2616
}
2617
2618
if (localPlayer.flipView)
2619
pmFromX = BOARD_SIZE + 3 - pmFromX;
2620
else
2621
pmFromY = BOARD_SIZE - 1 - pmFromY;
2622
2623
XtPopupSpringLoaded(XtNameToWidget(localPlayer.boardWidget, params[0]));
2624
}
2625
2626
2627
2628
2629
static void
2630
PieceMenuSelect(Widget w, ShogiSquare piece, caddr_t junk)
2631
{
2632
if ((pmFromX < 0) || (pmFromY < 0))
2633
return;
2634
2635
if (off_board(pmFromX))
2636
{
2637
int i, c;
2638
switch (piece)
2639
{
2640
case ClearBoard:
2641
break;
2642
2643
case BlackPlay:
2644
break;
2645
2646
case WhitePlay:
2647
break;
2648
2649
default:
2650
i = pieceToCatchedIndex[piece];
2651
c = (piece >= WhitePawn);
2652
catches[0][c][i]++;
2653
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
2654
XSync(localPlayer.xDisplay, False);
2655
return;
2656
}
2657
}
2658
2659
pmFromX -= 2;
2660
2661
switch (piece)
2662
{
2663
case ClearBoard:
2664
for (pmFromY = 0; pmFromY < BOARD_SIZE; pmFromY++)
2665
for (pmFromX = 0; pmFromX < BOARD_SIZE; pmFromX++)
2666
boards[0][pmFromY][pmFromX] = EmptySquare;
2667
2668
ClearCatches(catches[0]);
2669
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
2670
break;
2671
2672
case BlackPlay: /* not currently on menu */
2673
SetBlackToPlay();
2674
break;
2675
2676
case WhitePlay: /* not currently on menu */
2677
SetWhiteToPlay();
2678
break;
2679
2680
default:
2681
boards[0][pmFromY][pmFromX] = piece;
2682
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
2683
break;
2684
}
2685
2686
XSync(localPlayer.xDisplay, False);
2687
}
2688
2689
2690
2691
2692
static void
2693
SetBlackToPlay(void)
2694
{
2695
int saveCM;
2696
2697
if (gameMode != EditPosition)
2698
return;
2699
2700
whitePlaysFirst = False;
2701
saveCM = currentMove;
2702
currentMove = 0; /* kludge */
2703
DisplayClocks(ReDisplayTimers);
2704
currentMove = saveCM;
2705
}
2706
2707
2708
2709
2710
static void
2711
SetWhiteToPlay(void)
2712
{
2713
int saveCM;
2714
2715
if (gameMode != EditPosition)
2716
return;
2717
2718
whitePlaysFirst = True;
2719
saveCM = currentMove;
2720
currentMove = 1; /* kludge */
2721
DisplayClocks(ReDisplayTimers);
2722
currentMove = saveCM;
2723
}
2724
2725
2726
2727
2728
/*
2729
* If the user selects on a border boundary or off the board, return failure.
2730
* Otherwise map the event coordinate to the square.
2731
*/
2732
2733
int
2734
EventToSquare(int x)
2735
{
2736
if (x < LINE_GAP)
2737
return -1;
2738
2739
x -= LINE_GAP;
2740
2741
if ((x % (player->squareSize + LINE_GAP)) >= player->squareSize)
2742
return -1;
2743
2744
x /= (player->squareSize + LINE_GAP);
2745
2746
if (x >= BOARD_SIZE)
2747
return -1;
2748
2749
return x;
2750
}
2751
2752
2753
2754
2755
int
2756
EventToXSquare(int x)
2757
{
2758
if (x < LINE_GAP)
2759
return -1;
2760
2761
x -= LINE_GAP;
2762
2763
if ((x % (player->squareSize + LINE_GAP)) >= player->squareSize)
2764
return -1;
2765
2766
x /= (player->squareSize + LINE_GAP);
2767
2768
if (x >= BOARD_SIZE + 4)
2769
return -1;
2770
2771
return x;
2772
}
2773
2774
2775
2776
2777
ShogiSquare
2778
CharToPiece(int c, int p)
2779
{
2780
if (p)
2781
{
2782
switch (c)
2783
{
2784
default:
2785
case '.': return EmptySquare;
2786
case 'P': return BlackPPawn;
2787
case 'L': return BlackPLance;
2788
case 'N': return BlackPKnight;
2789
case 'S': return BlackPSilver;
2790
case 'G': return BlackGold;
2791
case 'R': return BlackPRook;
2792
case 'B': return BlackPBishop;
2793
case 'K': return BlackKing;
2794
case 'p': return WhitePPawn;
2795
case 'l': return WhitePLance;
2796
case 'n': return WhitePKnight;
2797
case 's': return WhitePSilver;
2798
case 'g': return WhiteGold;
2799
case 'r': return WhitePRook;
2800
case 'b': return WhitePBishop;
2801
case 'k': return WhiteKing;
2802
}
2803
}
2804
else
2805
{
2806
switch (c)
2807
{
2808
default:
2809
case '.': return EmptySquare;
2810
case 'P': return BlackPawn;
2811
case 'L': return BlackLance;
2812
case 'N': return BlackKnight;
2813
case 'S': return BlackSilver;
2814
case 'G': return BlackGold;
2815
case 'R': return BlackRook;
2816
case 'B': return BlackBishop;
2817
case 'K': return BlackKing;
2818
case 'p': return WhitePawn;
2819
case 'l': return WhiteLance;
2820
case 'n': return WhiteKnight;
2821
case 's': return WhiteSilver;
2822
case 'g': return WhiteGold;
2823
case 'r': return WhiteRook;
2824
case 'b': return WhiteBishop;
2825
case 'k': return WhiteKing;
2826
}
2827
}
2828
}
2829
2830
2831
2832
2833
/*
2834
* Convert coordinates to normal algebraic notation.
2835
* promoPiece must be NULLCHAR if not a promotion.
2836
*/
2837
2838
ShogiMove
2839
MakeAlg(int fromX, int fromY, int toX, int toY,
2840
char promoPiece, int currentBoardIndex, char *out)
2841
{
2842
ShogiSquare piece;
2843
char *outp = out;
2844
2845
if (fromX > 80)
2846
{
2847
piece = (fromX - 81);
2848
*outp++ = catchedIndexToChar[piece];
2849
*outp++ = '*';
2850
*outp++ = '9' - toX;
2851
*outp++ = 'i' - toY;
2852
*outp++ = NULLCHAR;
2853
return (BlackOnMove(forwardMostMove) ? BlackDrop : WhiteDrop);
2854
}
2855
else
2856
{
2857
*outp++ = '9' - fromX;
2858
*outp++ = 'i' - fromY;
2859
*outp++ = '9' - toX;
2860
*outp++ = 'i' - toY;
2861
*outp++ = promoPiece;
2862
*outp++ = NULLCHAR;
2863
2864
if (promoPiece == NULLCHAR)
2865
{
2866
return NormalMove;
2867
}
2868
else
2869
{
2870
return (BlackOnMove(forwardMostMove)
2871
? BlackPromotion : WhitePromotion);
2872
}
2873
}
2874
}
2875
2876
2877
2878
2879
void
2880
DrawSquare(int row, int column, ShogiSquare piece)
2881
{
2882
int square_color, x, y, direction, font_ascent, font_descent;
2883
char string[2];
2884
XCharStruct overall;
2885
struct DisplayData *player;
2886
2887
for (player = &localPlayer; True; player = &remotePlayer)
2888
{
2889
int offset, remote;
2890
2891
remote = (player == &remotePlayer);
2892
offset = 2 * (player->squareSize + LINE_GAP);
2893
2894
if (player->flipView)
2895
{
2896
x = LINE_GAP + ((BOARD_SIZE - 1) - column) *
2897
(player->squareSize + LINE_GAP) + offset;
2898
y = LINE_GAP + row * (player->squareSize + LINE_GAP);
2899
}
2900
else
2901
{
2902
x = LINE_GAP + column * (player->squareSize + LINE_GAP) + offset;
2903
y = LINE_GAP + ((BOARD_SIZE - 1) - row) *
2904
(player->squareSize + LINE_GAP);
2905
}
2906
2907
square_color = (((column + row) % 2) ? LIGHT : DARK);
2908
2909
if (piece == EmptySquare)
2910
{
2911
if (column < 0 || column >= BOARD_SIZE)
2912
{
2913
/* empty square off board */
2914
XFillRectangle(player->xDisplay, player->xBoardWindow,
2915
player->wbPieceGC,
2916
x, y, player->squareSize,
2917
player->squareSize);
2918
}
2919
else
2920
{
2921
/* empty square on board */
2922
XFillRectangle(player->xDisplay, player->xBoardWindow,
2923
((square_color == LIGHT)
2924
? player->lightSquareGC
2925
: player->darkSquareGC),
2926
x, y, player->squareSize,
2927
player->squareSize);
2928
}
2929
}
2930
else if (player->monoMode)
2931
{
2932
/* in mono mode */
2933
if (square_color == LIGHT)
2934
{
2935
XCopyArea(player->xDisplay,
2936
((((((int)piece) < ((int)WhitePawn)))
2937
^ player->flipView)
2938
? *pieceToNormal[remote][(int)piece]
2939
: *pieceToReverse[remote][(int)piece]),
2940
player->xBoardWindow,
2941
(player->monoMode
2942
? player->wbPieceGC
2943
: player->wlPieceGC),
2944
0, 0,
2945
player->squareSize, player->squareSize, x, y);
2946
}
2947
else
2948
{
2949
XCopyArea(player->xDisplay,
2950
((((((int)piece) < ((int)WhitePawn)))
2951
^ player->flipView)
2952
? *pieceToNormal[remote][(int)piece]
2953
: *pieceToReverse[remote][(int)piece]),
2954
player->xBoardWindow,
2955
(player->monoMode
2956
? player->bwPieceGC
2957
: player->blPieceGC),
2958
0, 0,
2959
player->squareSize, player->squareSize, x, y);
2960
}
2961
}
2962
else
2963
{
2964
/* in color mode */
2965
if ((column < 0) || (column >= BOARD_SIZE))
2966
{
2967
/* off board */
2968
XCopyPlane(player->xDisplay,
2969
((((((int)piece) < ((int)WhitePawn)))
2970
^ player->flipView)
2971
? *pieceToNormalSolid[remote][(int)piece]
2972
: *pieceToReverseSolid[remote][(int)piece]),
2973
player->xBoardWindow,
2974
(pieceisWhite[(int)piece]
2975
? player->woPieceGC
2976
: player->boPieceGC),
2977
0, 0,
2978
player->squareSize, player->squareSize, x, y, 1);
2979
2980
XCopyArea(player->xDisplay,
2981
((((((int)piece) < ((int)WhitePawn)))
2982
^ player->flipView)
2983
? *pieceToNormal[remote][(int)piece]
2984
: *pieceToReverse[remote][(int)piece]),
2985
player->xBoardWindow,
2986
player->charPieceGC,
2987
0, 0,
2988
player->squareSize, player->squareSize, x, y);
2989
}
2990
else if (square_color == LIGHT)
2991
{
2992
/* on board, light square */
2993
XCopyPlane(player->xDisplay,
2994
((((((int)piece) < ((int)WhitePawn)))
2995
^ player->flipView)
2996
? *pieceToNormalSolid[remote][(int)piece]
2997
: *pieceToReverseSolid[remote][(int)piece]),
2998
player->xBoardWindow,
2999
pieceisWhite[(int)piece]
3000
? player->wlPieceGC
3001
: player->blPieceGC,
3002
0, 0,
3003
player->squareSize, player->squareSize, x, y, 1);
3004
3005
XCopyArea(player->xDisplay,
3006
((((((int)piece) < ((int)WhitePawn)))
3007
^ player->flipView)
3008
? *pieceToNormal[remote][(int)piece]
3009
: *pieceToReverse[remote][(int)piece]),
3010
player->xBoardWindow,
3011
player->charPieceGC,
3012
0, 0,
3013
player->squareSize, player->squareSize, x, y);
3014
}
3015
else
3016
{
3017
/* on board, dark square */
3018
XCopyPlane(player->xDisplay,
3019
((((((int)piece) < ((int)WhitePawn)))
3020
^ player->flipView)
3021
? *pieceToNormalSolid[remote][(int)piece]
3022
: *pieceToReverseSolid[remote][(int)piece]),
3023
player->xBoardWindow,
3024
(pieceisWhite[(int)piece]
3025
? player->wdPieceGC
3026
: player->bdPieceGC),
3027
0, 0,
3028
player->squareSize, player->squareSize, x, y, 1);
3029
3030
XCopyArea(player->xDisplay,
3031
((((((int)piece) < ((int)WhitePawn)))
3032
^ player->flipView)
3033
? *pieceToNormal[remote][(int)piece]
3034
: *pieceToReverse[remote][(int)piece]),
3035
player->xBoardWindow,
3036
player->charPieceGC,
3037
0, 0,
3038
player->squareSize, player->squareSize, x, y);
3039
}
3040
}
3041
string[1] = NULLCHAR;
3042
3043
if (player->showCoords
3044
&& (column >= 0) && (column < 9)
3045
&& (row == (player->flipView ? 8 : 0)))
3046
{
3047
string[0] = '9' - column;
3048
XTextExtents(player->coordFontStruct, string, 1, &direction,
3049
&font_ascent, &font_descent, &overall);
3050
3051
if (player->monoMode)
3052
{
3053
XDrawImageString(player->xDisplay,
3054
player->xBoardWindow, player->coordGC,
3055
x + player->squareSize - overall.width - 2,
3056
y + player->squareSize - font_descent - 1,
3057
string, 1);
3058
}
3059
else
3060
{
3061
XDrawString(player->xDisplay, player->xBoardWindow,
3062
player->coordGC,
3063
x + player->squareSize - overall.width - 2,
3064
y + player->squareSize - font_descent - 1,
3065
string, 1);
3066
}
3067
}
3068
3069
if (player->showCoords
3070
&& (row >= 0) && (row < 9)
3071
&& (column == (player->flipView ? 8 : 0)))
3072
{
3073
string[0] = 'i' - row;
3074
XTextExtents(player->coordFontStruct, string, 1, &direction,
3075
&font_ascent, &font_descent, &overall);
3076
3077
if (player->monoMode)
3078
{
3079
XDrawImageString(player->xDisplay,
3080
player->xBoardWindow, player->coordGC,
3081
x + 2, y + font_ascent + 1, string, 1);
3082
}
3083
else
3084
{
3085
XDrawString(player->xDisplay, player->xBoardWindow,
3086
player->coordGC,
3087
x + 2, y + font_ascent + 1, string, 1);
3088
}
3089
}
3090
3091
if (!updateRemotePlayer || (player == &remotePlayer))
3092
break;
3093
}
3094
}
3095
3096
3097
3098
3099
void
3100
EventProc(Widget widget, caddr_t client_data, XEvent *event)
3101
{
3102
if (event->type == MappingNotify)
3103
{
3104
XRefreshKeyboardMapping((XMappingEvent *) event);
3105
return;
3106
}
3107
3108
if (!XtIsRealized(widget))
3109
return;
3110
3111
if ((event->type == ButtonPress) || (event->type == ButtonRelease))
3112
{
3113
if (event->xbutton.button != Button1)
3114
return;
3115
}
3116
3117
switch (event->type)
3118
{
3119
case Expose:
3120
DrawPosition(widget, event, NULL, NULL);
3121
break;
3122
3123
default:
3124
return;
3125
}
3126
}
3127
3128
3129
3130
3131
/*
3132
* event handler for redrawing the board
3133
*/
3134
3135
void
3136
DrawPosition(Widget w, XEvent *event, String *prms, Cardinal *nprms)
3137
{
3138
Arg args[1];
3139
int i, j;
3140
static Board lastBoard;
3141
static Catched lastCatches;
3142
static int lastBoardValid = 0;
3143
static int lastFlipView = 0, lastRemoteFlipView = 1;
3144
3145
if (!player->Iconic)
3146
{
3147
XtSetArg(args[0], XtNiconic, False);
3148
XtSetValues(localPlayer.shellWidget, args, 1);
3149
}
3150
3151
/*
3152
* It would be simpler to clear the window with XClearWindow()
3153
* but this causes a very distracting flicker.
3154
*/
3155
3156
if ((w == localPlayer.boardWidget)
3157
&& (event == NULL)
3158
&& lastBoardValid
3159
&& (lastFlipView == localPlayer.flipView)
3160
&& (!updateRemotePlayer
3161
|| (lastRemoteFlipView == remotePlayer.flipView)))
3162
{
3163
for (i = 0; i < BOARD_SIZE; i++)
3164
{
3165
for (j = 0; j < BOARD_SIZE; j++)
3166
{
3167
if (boards[currentMove][i][j] != lastBoard[i][j])
3168
DrawSquare(i, j, boards[currentMove][i][j]);
3169
}
3170
}
3171
3172
for (i = 0; i < 2; i++)
3173
{
3174
for (j = 0; j < 8; j++)
3175
{
3176
if (catches[currentMove][i][j] != lastCatches[i][j])
3177
{
3178
UpdateCatched(i, 0, False, True, currentMove);
3179
break;
3180
}
3181
}
3182
}
3183
}
3184
else
3185
{
3186
XDrawSegments(localPlayer.xDisplay,
3187
localPlayer.xBoardWindow, localPlayer.lineGC,
3188
localPlayer.gridSegments, (BOARD_SIZE + 1) * 2);
3189
3190
if (updateRemotePlayer)
3191
{
3192
XDrawSegments(remotePlayer.xDisplay,
3193
remotePlayer.xBoardWindow, remotePlayer.lineGC,
3194
remotePlayer.gridSegments, (BOARD_SIZE + 1) * 2);
3195
}
3196
3197
for (i = 0; i < BOARD_SIZE; i++)
3198
for (j = 0; j < BOARD_SIZE; j++)
3199
DrawSquare(i, j, boards[currentMove][i][j]);
3200
3201
UpdateCatched(0, 0, False, True, currentMove);
3202
UpdateCatched(1, 0, False, True, currentMove);
3203
}
3204
3205
CopyBoard(lastBoard, boards[currentMove]);
3206
CopyCatches(lastCatches, catches[currentMove]);
3207
lastBoardValid = 1;
3208
lastFlipView = localPlayer.flipView;
3209
3210
if (updateRemotePlayer)
3211
lastRemoteFlipView = remotePlayer.flipView;
3212
3213
XSync(localPlayer.xDisplay, False);
3214
3215
if (updateRemotePlayer)
3216
XSync(remotePlayer.xDisplay, False);
3217
}
3218
3219
3220
3221
3222
void
3223
InitPosition(int redraw)
3224
{
3225
currentMove = forwardMostMove = backwardMostMove = 0;
3226
CopyBoard(boards[0], initialPosition);
3227
ClearCatches(catches[0]);
3228
3229
if (redraw)
3230
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
3231
}
3232
3233
3234
3235
3236
void
3237
CopyBoard(Board to, Board from)
3238
{
3239
int i, j;
3240
3241
for (i = 0; i < BOARD_SIZE; i++)
3242
for (j = 0; j < BOARD_SIZE; j++)
3243
to[i][j] = from[i][j];
3244
}
3245
3246
3247
3248
3249
void
3250
CopyCatches(Catched to, Catched from)
3251
{
3252
int i, j;
3253
3254
for (i = 0; i < 2; i++)
3255
for (j = 0; j < 8; j++)
3256
to[i][j] = from[i][j];
3257
}
3258
3259
3260
3261
3262
void
3263
SendCurrentBoard(FILE *fp)
3264
{
3265
SendBoard(fp, boards[currentMove], catches[currentMove]);
3266
}
3267
3268
3269
3270
3271
void
3272
SendBoard(FILE *fp, Board board, Catched catches)
3273
{
3274
char message[MSG_SIZ];
3275
ShogiSquare *bp;
3276
int i, j;
3277
3278
SendToProgram("edit\n", fp);
3279
SendToProgram("#\n", fp);
3280
3281
for (i = BOARD_SIZE - 1; i >= 0; i--)
3282
{
3283
bp = &board[i][0];
3284
3285
for (j = 0; j < BOARD_SIZE; j++, bp++)
3286
{
3287
if (((int) *bp) < (int)WhitePawn)
3288
{
3289
sprintf(message, "%c%c%c%s\n",
3290
pieceToChar[(int) *bp],
3291
'9' - j, 'i' - i,
3292
(pieceIsPromoted[(int) *bp] ? "+" : ""));
3293
SendToProgram(message, fp);
3294
}
3295
}
3296
}
3297
3298
for (i = 0; i <= 7; i++)
3299
{
3300
int n;
3301
3302
for (n = catches[0][i]; n > 0; n--)
3303
{
3304
sprintf(message, "%c*\n",
3305
catchedIndexToChar[i]);
3306
SendToProgram(message, fp);
3307
}
3308
}
3309
3310
SendToProgram("c\n", fp);
3311
3312
for (i = BOARD_SIZE - 1; i >= 0; i--)
3313
{
3314
bp = &board[i][0];
3315
3316
for (j = 0; j < BOARD_SIZE; j++, bp++)
3317
{
3318
if ((((int) *bp) != ((int)EmptySquare))
3319
&& (((int) *bp) >= ((int)WhitePawn)))
3320
{
3321
sprintf(message, "%c%c%c%s\n",
3322
pieceToChar[((int) *bp) - ((int)WhitePawn)],
3323
'9' - j, 'i' - i,
3324
(pieceIsPromoted[(int) *bp] ? "+" : ""));
3325
SendToProgram(message, fp);
3326
}
3327
}
3328
}
3329
3330
for (i = 0; i <= 7; i++)
3331
{
3332
int n;
3333
3334
for (n = catches[1][i]; n > 0; n--)
3335
{
3336
sprintf(message, "%c*\n",
3337
catchedIndexToChar[i]);
3338
SendToProgram(message, fp);
3339
}
3340
}
3341
3342
SendToProgram(".\n", fp);
3343
}
3344
3345
3346
3347
3348
static int
3349
PromotionPossible(int fromY, int toY, ShogiSquare piece)
3350
{
3351
if (((int)piece) < ((int)WhitePawn))
3352
{
3353
if ((fromY < 6) && (toY < 6))
3354
return False;
3355
}
3356
else
3357
{
3358
if ((fromY > 2) && (toY > 2))
3359
return False;
3360
}
3361
3362
return piecePromotable[(int)piece];
3363
3364
}
3365
3366
3367
3368
3369
static void
3370
ShowCount(int row, int column, int n)
3371
{
3372
int offset = 2 * (player->squareSize + LINE_GAP);
3373
int x, y, direction, font_ascent, font_descent;
3374
char string[2];
3375
XCharStruct overall;
3376
struct DisplayData *player;
3377
3378
DrawSquare(row, column, EmptySquare);
3379
3380
if (n <= 1)
3381
return;
3382
3383
for (player = &localPlayer; True; player = &remotePlayer)
3384
{
3385
if (player->flipView)
3386
{
3387
x = LINE_GAP + ((BOARD_SIZE - 1) - column) *
3388
(player->squareSize + LINE_GAP) + offset;
3389
y = LINE_GAP + row * (player->squareSize + LINE_GAP);
3390
}
3391
else
3392
{
3393
x = LINE_GAP + column * (player->squareSize + LINE_GAP) + offset;
3394
y = LINE_GAP + ((BOARD_SIZE - 1) - row) *
3395
(player->squareSize + LINE_GAP);
3396
}
3397
3398
x -= player->squareSize / 2;
3399
3400
string[1] = NULLCHAR;
3401
3402
if (n > 9)
3403
string[0] = '*';
3404
else
3405
string[0] = '0' + n;
3406
3407
XTextExtents(player->coordFontStruct, string, 1, &direction,
3408
&font_ascent, &font_descent, &overall);
3409
3410
if (player->monoMode)
3411
{
3412
XDrawImageString(player->xDisplay, player->xBoardWindow,
3413
player->coordGC,
3414
x + player->squareSize - overall.width - 2,
3415
y + player->squareSize - font_descent - 1,
3416
string, 1);
3417
}
3418
else
3419
{
3420
XDrawString(player->xDisplay, player->xBoardWindow,
3421
player->coordGC,
3422
x + player->squareSize - overall.width - 2,
3423
y + player->squareSize - font_descent - 1,
3424
string, 1);
3425
}
3426
3427
if (!updateRemotePlayer || (player == &remotePlayer))
3428
break;
3429
}
3430
}
3431
3432
3433
3434
3435
void
3436
UpdateCatched(int Color, int Figure, int Drop, int DropAll, int currentMove)
3437
{
3438
int n, F;
3439
int x, y;
3440
3441
/* Determine first row and column. */
3442
3443
if (Color)
3444
{
3445
x = -1;
3446
y = BOARD_SIZE - 1;
3447
}
3448
else
3449
{
3450
x = BOARD_SIZE;
3451
y = 0;
3452
}
3453
3454
if (DropAll)
3455
n = 0;
3456
else
3457
n = catches[currentMove][Color][Figure];
3458
3459
/* Update the display for captured pieces
3460
if no piece of the dropped type is there (Drop && n==1)
3461
or if a piece type is removed (NOT Drop && n==0).
3462
In the other cases update only the count. */
3463
3464
if (DropAll || (Drop && (n == 1)) || (!Drop && (n == 0)))
3465
{
3466
/* show all captured pieces */
3467
n = 0;
3468
3469
for (F = pawn; F <= king; F++)
3470
{
3471
int c;
3472
3473
if ((c = catches[currentMove][Color][F]) > 0)
3474
{
3475
n++;
3476
DrawSquare(y, x, catchedIndexToPiece[Color][F]);
3477
ShowCount(y, (Color ? (x - 1) : (x + 1)), c);
3478
3479
if (Color)
3480
y--;
3481
else
3482
y++;
3483
}
3484
}
3485
3486
if (DropAll)
3487
{
3488
for (; n < 9; n++)
3489
{
3490
DrawSquare(y, x, EmptySquare);
3491
ShowCount(y, (Color ? (x - 1) : (x + 1)), 0);
3492
3493
if (Color)
3494
y--;
3495
else
3496
y++;
3497
}
3498
}
3499
else if (!Drop)
3500
{
3501
/* remove one line! */
3502
DrawSquare(y, x, EmptySquare);
3503
ShowCount(y, (Color ? (x - 1) : (x + 1)), 0);
3504
}
3505
}
3506
else
3507
{
3508
/* show the actual count */
3509
for (F = pawn; F <= Figure - 1; F++)
3510
{
3511
if (catches[currentMove][Color][F] > 0)
3512
{
3513
if (Color)
3514
y--;
3515
else
3516
y++;
3517
}
3518
}
3519
3520
ShowCount(y, (Color ? (x - 1) : (x + 1)), n);
3521
}
3522
}
3523
3524
3525
3526
3527
#ifdef BLINK_COUNT
3528
3529
static int BlinkCount = 0;
3530
static int BlinkRow, BlinkCol;
3531
static ShogiSquare BlinkPiece;
3532
3533
3534
void
3535
BlinkSquareProc(void)
3536
{
3537
if (BlinkCount > 0)
3538
{
3539
BlinkCount--;
3540
DrawSquare (BlinkRow, BlinkCol,
3541
((BlinkCount & 1) ? EmptySquare : BlinkPiece));
3542
3543
if (BlinkCount > 0)
3544
{
3545
blinkSquareXID
3546
= XtAppAddTimeOut(appContext,
3547
150,
3548
(XtTimerCallbackProc)BlinkSquareProc,
3549
NULL);
3550
}
3551
}
3552
else
3553
{
3554
BlinkCount = 0;
3555
}
3556
}
3557
3558
3559
3560
3561
void
3562
BlinkSquare(int row, int col, ShogiSquare piece)
3563
{
3564
BlinkCount = 2 * BLINK_COUNT + 1;
3565
BlinkRow = row;
3566
BlinkCol = col;
3567
BlinkPiece = piece;
3568
BlinkSquareProc();
3569
}
3570
3571
3572
#endif /* BLINK_COUNT */
3573
3574
3575
3576
3577
static int
3578
PieceOfCatched(int color, int x, int y, int currentMove)
3579
{
3580
int F, n;
3581
3582
if (color)
3583
{
3584
if (x != 1)
3585
return (no_piece);
3586
3587
y = 8 - y;
3588
}
3589
else
3590
{
3591
if (x != 11)
3592
return no_piece;
3593
}
3594
3595
for (F = pawn, n = 0; F <= king; F++)
3596
{
3597
if (catches[currentMove][color][F] > 0)
3598
{
3599
if (n == y)
3600
return F;
3601
3602
n++;
3603
}
3604
}
3605
3606
return no_piece;
3607
}
3608
3609
3610
3611
3612
/*
3613
* event handler for parsing user moves
3614
*/
3615
3616
void
3617
HandleUserMove(Widget w, XEvent *event)
3618
{
3619
ShogiMove move_type;
3620
ShogiSquare from_piece;
3621
int to_x, to_y, fromRemotePlayer;
3622
3623
if (updateRemotePlayer)
3624
{
3625
if (((w != localPlayer.boardWidget)
3626
&& (w != remotePlayer.boardWidget))
3627
|| (matchMode != MatchFalse))
3628
{
3629
return;
3630
}
3631
3632
fromRemotePlayer = (w == remotePlayer.boardWidget);
3633
}
3634
else
3635
{
3636
if ((w != localPlayer.boardWidget) || (matchMode != MatchFalse))
3637
return;
3638
3639
fromRemotePlayer = False;
3640
}
3641
3642
player = (fromRemotePlayer ? &remotePlayer : &localPlayer);
3643
3644
if (player->promotionUp)
3645
{
3646
XtPopdown(player->promotionShell);
3647
XtDestroyWidget(player->promotionShell);
3648
player->promotionUp = False;
3649
fromX = fromY = -1;
3650
}
3651
3652
switch (gameMode)
3653
{
3654
case EndOfGame:
3655
case PlayFromGameFile:
3656
case TwoMachinesPlay:
3657
return;
3658
3659
case MachinePlaysBlack:
3660
if (BlackOnMove(forwardMostMove))
3661
{
3662
DisplayMessage("It is not your turn", fromRemotePlayer);
3663
return;
3664
}
3665
3666
break;
3667
3668
case MachinePlaysWhite:
3669
if (!BlackOnMove(forwardMostMove))
3670
{
3671
DisplayMessage("It is not your turn", fromRemotePlayer);
3672
return;
3673
}
3674
3675
break;
3676
3677
case ForceMoves:
3678
forwardMostMove = currentMove;
3679
break;
3680
3681
default:
3682
break;
3683
}
3684
3685
if (currentMove != forwardMostMove)
3686
{
3687
DisplayMessage("Displayed position is not current",
3688
fromRemotePlayer);
3689
return;
3690
}
3691
3692
switch (event->type)
3693
{
3694
case ButtonPress:
3695
if ((fromX >= 0) || (fromY >= 0))
3696
return;
3697
3698
if (((fromX = EventToXSquare(event->xbutton.x)) < 1)
3699
|| (fromX > BOARD_SIZE + 2)
3700
|| ((fromY = EventToSquare(event->xbutton.y)) < 0))
3701
{
3702
fromX = fromY = -1;
3703
return;
3704
}
3705
3706
if (player->flipView)
3707
fromX = BOARD_SIZE + 3 - fromX;
3708
else
3709
fromY = BOARD_SIZE - 1 - fromY;
3710
3711
break;
3712
3713
case ButtonRelease:
3714
if ((fromX < 0) || (fromY < 0))
3715
return;
3716
3717
if (((to_x = EventToXSquare(event->xbutton.x)) < 1)
3718
|| (to_x > BOARD_SIZE + 2)
3719
|| ((to_y = EventToSquare(event->xbutton.y)) < 0))
3720
{
3721
if (gameMode == EditPosition && !off_board(fromX))
3722
{
3723
fromX -= 2;
3724
boards[0][fromY][fromX] = EmptySquare;
3725
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
3726
XSync(localPlayer.xDisplay, False);
3727
3728
if (updateRemotePlayer)
3729
XSync(remotePlayer.xDisplay, False);
3730
}
3731
3732
fromX = fromY = -1;
3733
return;
3734
}
3735
3736
if (player->flipView)
3737
to_x = BOARD_SIZE + 3 - to_x;
3738
else
3739
to_y = BOARD_SIZE - 1 - to_y;
3740
3741
if ((fromX == to_x) && (fromY == to_y))
3742
{
3743
fromX = fromY = -1;
3744
return;
3745
}
3746
3747
if (gameMode == EditPosition)
3748
{
3749
ShogiSquare piece;
3750
3751
if (off_board(fromX))
3752
{
3753
/* Remove a catched piece */
3754
int i, c;
3755
c = ((fromX < 5) ^ player->flipView);
3756
i = PieceOfCatched(c, fromX, fromY, 0);
3757
3758
if (i == no_piece)
3759
{
3760
fromX = fromY = -1;
3761
return;
3762
}
3763
else
3764
{
3765
piece = catchedIndexToPiece[c][i];
3766
catches[0][c][i]--;
3767
}
3768
}
3769
else
3770
{
3771
/* remove piece from board field */
3772
fromX -= 2;
3773
piece = boards[0][fromY][fromX];
3774
boards[0][fromY][fromX] = EmptySquare;
3775
}
3776
3777
if (!off_board(to_x))
3778
{
3779
/* drop piece to board field */
3780
ShogiSquare catched_piece;
3781
to_x -= 2;
3782
catched_piece = boards[0][to_y][to_x];
3783
3784
if (catched_piece != EmptySquare)
3785
{
3786
/* put piece to catched pieces */
3787
int i = pieceToCatchedIndex[catched_piece];
3788
int c = (catched_piece < WhitePawn);
3789
catches[0][c][i]++;
3790
}
3791
3792
/* place moved piece */
3793
boards[0][to_y][to_x] = piece;
3794
}
3795
3796
fromX = fromY = -1;
3797
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
3798
XSync(localPlayer.xDisplay, False);
3799
3800
if (updateRemotePlayer)
3801
XSync(remotePlayer.xDisplay, False);
3802
3803
return;
3804
}
3805
3806
if (off_board(fromX))
3807
{
3808
int c = (BlackOnMove(forwardMostMove) ? 0 : 1);
3809
int piece = PieceOfCatched(c, fromX, fromY, currentMove);
3810
3811
if (piece == no_piece)
3812
{
3813
fromX = fromY = -1;
3814
return;
3815
}
3816
else
3817
{
3818
if (updateRemotePlayer
3819
&& (BlackOnMove(forwardMostMove) == fromRemotePlayer))
3820
{
3821
DisplayMessage("do not drop opponent pieces",
3822
fromRemotePlayer);
3823
fromX = fromY = -1;
3824
return;
3825
}
3826
3827
fromX = fromY = piece + 81;
3828
to_x -= 2;
3829
move_type = (BlackOnMove(forwardMostMove)
3830
? BlackDrop : WhiteDrop);
3831
MakeMove(&move_type, fromX, fromY, to_x, to_y);
3832
3833
#ifdef BLINK_COUNT
3834
if (updateRemotePlayer)
3835
BlinkSquare(to_y, to_x, boards[currentMove][to_y][to_x]);
3836
#endif
3837
3838
FinishUserMove(move_type, to_x, to_y);
3839
break;
3840
}
3841
}
3842
else if (off_board(to_x))
3843
{
3844
fromX = fromY = -1;
3845
return;
3846
}
3847
else
3848
{
3849
fromX -= 2;
3850
to_x -= 2;
3851
from_piece = boards[currentMove][fromY][fromX];
3852
3853
if ((from_piece != EmptySquare)
3854
&& updateRemotePlayer
3855
&& ((from_piece < WhitePawn) == fromRemotePlayer))
3856
{
3857
DisplayMessage("do not move opponent pieces",
3858
fromRemotePlayer);
3859
fromX = fromY = -1;
3860
return;
3861
}
3862
3863
if (PromotionPossible(fromY, to_y, from_piece))
3864
{
3865
PromotionPopUp(from_piece, to_x, to_y, fromRemotePlayer);
3866
return;
3867
}
3868
3869
move_type = NormalMove;
3870
MakeMove(&move_type, fromX, fromY, to_x, to_y);
3871
3872
#ifdef BLINK_COUNT
3873
if (updateRemotePlayer)
3874
BlinkSquare(to_y, to_x, boards[currentMove][to_y][to_x]);
3875
#endif
3876
3877
FinishUserMove(move_type, to_x, to_y);
3878
break;
3879
}
3880
}
3881
}
3882
3883
3884
3885
3886
void
3887
FinishUserMove(ShogiMove move_type, int to_x, int to_y)
3888
{
3889
char user_move[MSG_SIZ];
3890
3891
/* output move for gnushogi */
3892
switch (move_type)
3893
{
3894
case BlackPromotion:
3895
case WhitePromotion:
3896
sprintf(user_move, "%c%c%c%c+\n",
3897
'9' - fromX, 'i' - fromY, '9' - to_x, 'i' - to_y);
3898
break;
3899
3900
case BlackDrop:
3901
case WhiteDrop:
3902
sprintf(user_move, "%c*%c%c\n",
3903
catchedIndexToChar[fromX - 81], '9' - to_x, 'i' - to_y);
3904
break;
3905
3906
case NormalMove:
3907
sprintf(user_move, "%c%c%c%c\n",
3908
'9' - fromX, 'i' - fromY, '9' - to_x, 'i' - to_y);
3909
break;
3910
3911
default:
3912
fprintf(stderr, "%s: internal error; bad move_type\n",
3913
(char *)programName);
3914
break;
3915
}
3916
3917
Attention(firstProgramPID);
3918
3919
if (firstSendTime)
3920
SendTimeRemaining(toFirstProgFP);
3921
3922
SendToProgram(user_move, toFirstProgFP);
3923
strcpy(moveList[currentMove - 1], user_move);
3924
3925
fromX = fromY = -1;
3926
3927
if (gameMode == PauseGame)
3928
{
3929
/* a user move restarts a paused game*/
3930
PauseProc(NULL, NULL, NULL, NULL);
3931
}
3932
3933
switch (gameMode)
3934
{
3935
case ForceMoves:
3936
break;
3937
3938
case BeginningOfGame:
3939
if (localPlayer.appData.noShogiProgram)
3940
lastGameMode = gameMode = ForceMoves;
3941
else
3942
lastGameMode = gameMode = MachinePlaysWhite;
3943
3944
ModeHighlight();
3945
break;
3946
3947
case MachinePlaysWhite:
3948
case MachinePlaysBlack:
3949
default:
3950
break;
3951
}
3952
}
3953
3954
3955
3956
3957
/* Simple parser for moves from gnushogi. */
3958
void
3959
ParseMachineMove(char *machine_move, ShogiMove *move_type,
3960
int *from_x, int *from_y, int *to_x, int *to_y)
3961
{
3962
#define no_digit(c) (c < '0' || c > '9')
3963
{
3964
if (no_digit(machine_move[0]))
3965
{
3966
switch (machine_move[0])
3967
{
3968
case 'P':
3969
*from_x = 81;
3970
break;
3971
3972
case 'L':
3973
*from_x = 82;
3974
break;
3975
3976
case 'N':
3977
*from_x = 83;
3978
break;
3979
3980
case 'S':
3981
*from_x = 84;
3982
break;
3983
3984
case 'G':
3985
*from_x = 85;
3986
break;
3987
3988
case 'B':
3989
*from_x = 86;
3990
break;
3991
3992
case 'R':
3993
*from_x = 87;
3994
break;
3995
3996
case 'K':
3997
*from_x = 88;
3998
break;
3999
4000
default:
4001
*from_x = -1;
4002
}
4003
4004
*from_y = *from_x;
4005
*to_x = '9' - machine_move[2];
4006
*to_y = 'i' - machine_move[3];
4007
}
4008
else
4009
{
4010
*from_x = '9' - machine_move[0] ;
4011
*from_y = 'i' - machine_move[1];
4012
*to_x = '9' - machine_move[2];
4013
*to_y = 'i' - machine_move[3];
4014
4015
switch (machine_move[4])
4016
{
4017
case '+':
4018
*move_type = (BlackOnMove(forwardMostMove)
4019
? BlackPromotion : WhitePromotion);
4020
break;
4021
4022
default:
4023
*move_type = NormalMove;
4024
break;
4025
}
4026
}
4027
}
4028
}
4029
4030
4031
4032
4033
void
4034
SkipString(char **mpr)
4035
{
4036
while (**mpr == ' ')
4037
(*mpr)++;
4038
4039
while ((**mpr != ' ') && (**mpr != NULLCHAR) && (**mpr != '\n'))
4040
(*mpr)++;
4041
4042
while (**mpr == ' ')
4043
(*mpr)++;
4044
}
4045
4046
4047
4048
4049
void
4050
HandleMachineMove(char *message, FILE *fp)
4051
{
4052
char machine_move[MSG_SIZ], buf1[MSG_SIZ], buf2[MSG_SIZ];
4053
int from_x, from_y, to_x, to_y;
4054
ShogiMove move_type;
4055
char *mpr;
4056
4057
#ifdef SYNCHTIME
4058
long time_remaining;
4059
#endif
4060
4061
maybeThinking = False;
4062
4063
if (strncmp(message, "warning:", 8) == 0)
4064
{
4065
DisplayMessage(message, False);
4066
4067
if (updateRemotePlayer)
4068
DisplayMessage(message, True);
4069
4070
return;
4071
}
4072
4073
/*
4074
* If shogi program startup fails, exit with an error message.
4075
* Attempts to recover here are futile.
4076
*/
4077
4078
if ((strstr(message, "unknown host") != NULL)
4079
|| (strstr(message, "No remote directory") != NULL)
4080
|| (strstr(message, "not found") != NULL)
4081
|| (strstr(message, "No such file") != NULL)
4082
|| (strstr(message, "Permission denied") != NULL))
4083
{
4084
fprintf(stderr,
4085
"%s: failed to start shogi program %s on %s: %s\n",
4086
programName,
4087
((fp == fromFirstProgFP)
4088
? localPlayer.appData.firstShogiProgram
4089
: localPlayer.appData.secondShogiProgram),
4090
((fp == fromFirstProgFP)
4091
? localPlayer.appData.firstHost
4092
: localPlayer.appData.secondHost),
4093
message);
4094
ShutdownShogiPrograms(message);
4095
exit(1);
4096
}
4097
4098
/*
4099
* If the move is illegal, cancel it and redraw the board.
4100
*/
4101
4102
if (strncmp(message, "Illegal move", 12) == 0)
4103
{
4104
if (fp == fromFirstProgFP && firstSendTime == 2)
4105
{
4106
/* First program doesn't have the "time" command */
4107
firstSendTime = 0;
4108
return;
4109
}
4110
else if (fp == fromSecondProgFP && secondSendTime == 2)
4111
{
4112
/* Second program doesn't have the "time" command */
4113
secondSendTime = 0;
4114
return;
4115
}
4116
4117
if (forwardMostMove <= backwardMostMove)
4118
return;
4119
4120
if (gameMode == PauseGame)
4121
PauseProc(NULL, NULL, NULL, NULL);
4122
4123
if (gameMode == PlayFromGameFile)
4124
{
4125
/* Stop reading this game file */
4126
gameMode = ForceMoves;
4127
ModeHighlight();
4128
}
4129
4130
currentMove = --forwardMostMove;
4131
4132
if ((gameMode == PlayFromGameFile)
4133
|| (gameMode == ForceMoves))
4134
DisplayClocks(ReDisplayTimers);
4135
else
4136
DisplayClocks(SwitchTimers);
4137
4138
sprintf(buf1, "Illegal move: %s", parseList[currentMove]);
4139
DisplayMessage(buf1, False);
4140
4141
if (updateRemotePlayer)
4142
DisplayMessage(buf1, True);
4143
4144
#ifdef BLINK_COUNT
4145
/*
4146
* Disable blinking of the target square.
4147
*/
4148
4149
if (BlinkCount > 0)
4150
{
4151
/* If BlinkCount is even, the piece is currently displayed. */
4152
if (!(BlinkCount & 1))
4153
DrawSquare (BlinkRow, BlinkCol, EmptySquare);
4154
4155
/* BlinkCount = 0 will force the next blink timeout
4156
* to do nothing. */
4157
BlinkCount = 0;
4158
}
4159
#endif
4160
4161
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
4162
4163
XSync(localPlayer.xDisplay, False);
4164
4165
if (updateRemotePlayer)
4166
XSync(remotePlayer.xDisplay, False);
4167
4168
return;
4169
}
4170
4171
if (strstr(message, "GNU Shogi") != NULL)
4172
{
4173
at_least_gnushogi_1_2p03 = True;
4174
return;
4175
}
4176
4177
if (strncmp(message, "Hint:", 5) == 0)
4178
{
4179
char promoPiece;
4180
sscanf(message, "Hint: %s", machine_move);
4181
ParseMachineMove(machine_move, &move_type,
4182
&from_x, &from_y, &to_x, &to_y);
4183
4184
if (move_type == WhitePromotion || move_type == BlackPromotion)
4185
promoPiece = '+';
4186
else
4187
promoPiece = NULLCHAR;
4188
4189
move_type = MakeAlg(from_x, from_y, to_x, to_y, promoPiece,
4190
currentMove, buf1);
4191
sprintf(buf2, "Hint: %s", buf1);
4192
DisplayMessage(buf2, False);
4193
4194
if (updateRemotePlayer)
4195
DisplayMessage(buf2, True);
4196
4197
return;
4198
}
4199
4200
if (strncmp(message, "Clocks:", 7) == 0)
4201
{
4202
sscanf(message, "Clocks: %ld %ld",
4203
&blackTimeRemaining, &whiteTimeRemaining);
4204
DisplayClocks(ReDisplayTimers);
4205
4206
return;
4207
}
4208
4209
/*
4210
* win, lose or draw
4211
*/
4212
4213
if (strncmp(message, "Black", 5) == 0)
4214
{
4215
ShutdownShogiPrograms("Black wins");
4216
return;
4217
}
4218
else if (strncmp(message, "White", 5) == 0)
4219
{
4220
ShutdownShogiPrograms("White wins");
4221
return;
4222
}
4223
else if (strncmp(message, "Repetition", 10) == 0)
4224
{
4225
ShutdownShogiPrograms("Repetition");
4226
return;
4227
}
4228
else if (strncmp(message, "opponent mates!", 15) == 0)
4229
{
4230
switch ((gameMode == PauseGame) ? pausePreviousMode : gameMode)
4231
{
4232
case MachinePlaysWhite:
4233
ShutdownShogiPrograms("Black wins");
4234
break;
4235
4236
case MachinePlaysBlack:
4237
ShutdownShogiPrograms("White wins");
4238
break;
4239
4240
case TwoMachinesPlay:
4241
ShutdownShogiPrograms((fp == fromFirstProgFP)
4242
? "Black wins" : "White wins");
4243
break;
4244
4245
default:
4246
/* can't happen */
4247
break;
4248
}
4249
4250
return;
4251
}
4252
else if (strncmp(message, "computer mates!", 15) == 0)
4253
{
4254
switch ((gameMode == PauseGame) ? pausePreviousMode : gameMode)
4255
{
4256
case MachinePlaysWhite:
4257
ShutdownShogiPrograms("White wins");
4258
break;
4259
4260
case MachinePlaysBlack:
4261
ShutdownShogiPrograms("Black wins");
4262
break;
4263
4264
case TwoMachinesPlay:
4265
ShutdownShogiPrograms((fp == fromFirstProgFP)
4266
? "White wins" : "Black wins");
4267
break;
4268
4269
default:
4270
/* can't happen */
4271
break;
4272
}
4273
4274
return;
4275
}
4276
else if (strncmp(message, "Draw", 4) == 0)
4277
{
4278
ShutdownShogiPrograms("Draw");
4279
return;
4280
}
4281
4282
/*
4283
* normal machine reply move
4284
*/
4285
maybeThinking = True;
4286
4287
if (strstr(message, "...") != NULL)
4288
{
4289
sscanf(message, "%s %s %s", buf1, buf2, machine_move);
4290
4291
#ifdef SYNCHTIME
4292
mpr = message;
4293
SkipString(&mpr); /* skip move number */
4294
SkipString(&mpr); /* skip ... */
4295
SkipString(&mpr); /* skip move */
4296
4297
if ((gameMode != TwoMachinesPlay) && (gameMode != ForceMoves)
4298
&& ((*mpr == '-') || ((*mpr >= '0') && (*mpr <= '9'))))
4299
{
4300
/* synchronize with shogi program clock */
4301
sscanf(mpr, "%ld", &time_remaining);
4302
4303
if (xshogiDebug)
4304
{
4305
printf("from '%s' synchronize %s clock %ld\n",
4306
message,
4307
(BlackOnMove(forwardMostMove)
4308
? "Black's"
4309
: "White's"),
4310
time_remaining);
4311
}
4312
4313
if (BlackOnMove(forwardMostMove))
4314
blackTimeRemaining = time_remaining;
4315
else
4316
whiteTimeRemaining = time_remaining;
4317
}
4318
#endif
4319
4320
if (machine_move[0] == NULLCHAR)
4321
return;
4322
}
4323
else
4324
{
4325
mpr = message;
4326
4327
#ifdef SYNCHTIME
4328
if (strstr(message, "time") == NULL)
4329
{
4330
/* remaining time will be determined from move */
4331
SkipString(&mpr); /* skip move number */
4332
SkipString(&mpr); /* skip move */
4333
}
4334
4335
if ((gameMode != TwoMachinesPlay) && (gameMode != ForceMoves)
4336
&& ((*mpr == '-') || ((*mpr >= '0') && (*mpr <= '9'))))
4337
{
4338
/* synchronize with shogi program clock */
4339
sscanf(mpr, "%ld", &time_remaining);
4340
4341
if (xshogiDebug)
4342
{
4343
printf("from '%s' synchronize %s clock %ld\n",
4344
message,
4345
((!BlackOnMove(forwardMostMove))
4346
? "Black's" : "White's"),
4347
time_remaining);
4348
}
4349
4350
if (!BlackOnMove(forwardMostMove))
4351
blackTimeRemaining = time_remaining;
4352
else
4353
whiteTimeRemaining = time_remaining;
4354
}
4355
else
4356
#endif
4357
4358
if (xshogiDebug)
4359
printf("ignore noise: '%s'\n", message);
4360
4361
return; /* ignore noise */
4362
}
4363
4364
strcpy(moveList[forwardMostMove], machine_move);
4365
4366
ParseMachineMove(machine_move, &move_type, &from_x, &from_y,
4367
&to_x, &to_y);
4368
4369
if (gameMode != PauseGame)
4370
currentMove = forwardMostMove; /* display latest move */
4371
4372
MakeMove(&move_type, from_x, from_y, to_x, to_y);
4373
4374
#ifdef BLINK_COUNT
4375
if (gameMode != TwoMachinesPlay)
4376
BlinkSquare(to_y, to_x, boards[currentMove][to_y][to_x]);
4377
#endif
4378
4379
if ((gameMode != PauseGame) && localPlayer.appData.ringBellAfterMoves)
4380
putc(BELLCHAR, stderr);
4381
4382
if ((gameMode == TwoMachinesPlay)
4383
|| ((gameMode == PauseGame)
4384
&& (pausePreviousMode == TwoMachinesPlay)))
4385
{
4386
strcat(machine_move, "\n");
4387
4388
if (BlackOnMove(forwardMostMove))
4389
{
4390
Attention(secondProgramPID);
4391
4392
if (secondSendTime)
4393
SendTimeRemaining(toSecondProgFP);
4394
4395
SendToProgram(machine_move, toSecondProgFP);
4396
4397
if (firstMove)
4398
{
4399
firstMove = False;
4400
SendToProgram(localPlayer.appData.blackString,
4401
toSecondProgFP);
4402
}
4403
}
4404
else
4405
{
4406
Attention(firstProgramPID);
4407
4408
if (firstSendTime)
4409
SendTimeRemaining(toFirstProgFP);
4410
4411
SendToProgram(machine_move, toFirstProgFP);
4412
4413
if (firstMove)
4414
{
4415
firstMove = False;
4416
SendToProgram(localPlayer.appData.blackString,
4417
toFirstProgFP);
4418
}
4419
}
4420
}
4421
}
4422
4423
4424
4425
4426
void
4427
ReadGameFile(void)
4428
{
4429
for (;;)
4430
{
4431
if (!ReadGameFileProc())
4432
return;
4433
4434
if (matchMode == MatchOpening)
4435
continue;
4436
4437
readGameXID
4438
= XtAppAddTimeOut(appContext,
4439
(int)(1000 * localPlayer.appData.timeDelay),
4440
(XtTimerCallbackProc) ReadGameFile, NULL);
4441
break;
4442
}
4443
}
4444
4445
4446
4447
/*
4448
* FIXME: there is a naming inconsistency: here ReadGameFileProc() is
4449
* called by ReadGameFile() while in other places XXXProc() calls XXX().
4450
*/
4451
4452
int
4453
ReadGameFileProc(void)
4454
{
4455
ShogiMove move_type;
4456
char move[MSG_SIZ], buf[MSG_SIZ];
4457
4458
if (gameFileFP == NULL)
4459
return (int)False;
4460
4461
if (gameMode == PauseGame)
4462
return True;
4463
4464
if (gameMode != PlayFromGameFile)
4465
{
4466
fclose(gameFileFP);
4467
gameFileFP = NULL;
4468
return (int)False;
4469
}
4470
4471
if (commentUp)
4472
{
4473
XtPopdown(commentShell);
4474
XtDestroyWidget(commentShell);
4475
commentUp = False;
4476
}
4477
4478
fgets(move, MSG_SIZ, gameFileFP);
4479
move[strlen(move) - 1] = NULLCHAR;
4480
sprintf(buf, "# %s game file", programName);
4481
4482
if (strncmp(move, buf, strlen(buf)))
4483
{
4484
strcat(move, ": no xshogi game file");
4485
DisplayMessage(move, False);
4486
return (int)False;
4487
}
4488
4489
DisplayName(move);
4490
rewind(gameFileFP);
4491
4492
parseGameFile();
4493
4494
move_type = (ShogiMove)0;
4495
4496
lastGameMode = gameMode;
4497
gameMode = ForceMoves;
4498
ModeHighlight();
4499
DisplayMessage("End of game file", False);
4500
4501
if (readGameXID != 0)
4502
{
4503
XtRemoveTimeOut(readGameXID);
4504
readGameXID = 0;
4505
}
4506
4507
fclose(gameFileFP);
4508
gameFileFP = NULL;
4509
4510
return (int)False;
4511
}
4512
4513
4514
4515
4516
/*
4517
* Apply a move to the given board. Oddity: move_type is ignored on input
4518
* unless the move is seen to be a pawn promotion, in which case move_type
4519
* tells us what to promote to.
4520
*/
4521
4522
void
4523
ApplyMove(ShogiMove *move_type, int from_x, int from_y,
4524
int to_x, int to_y, int currentMove)
4525
{
4526
ShogiSquare piece, cpiece;
4527
char pieceChar;
4528
int i, c;
4529
4530
if (from_x > 80)
4531
{
4532
i = from_x - 81;
4533
c = (BlackOnMove(currentMove) ? 1 : 0);
4534
cpiece = catchedIndexToPiece[c][i];
4535
boards[currentMove][to_y][to_x] = cpiece;
4536
catches[currentMove][c][i]--;
4537
}
4538
else if (PromotionPossible(from_y, to_y,
4539
piece = boards[currentMove][from_y][from_x]))
4540
{
4541
cpiece = boards[currentMove][to_y][to_x];
4542
4543
if (cpiece != EmptySquare)
4544
{
4545
i = pieceToCatchedIndex[cpiece];
4546
c = (cpiece < WhitePawn);
4547
catches[currentMove][c][i]++;
4548
}
4549
4550
if (*move_type == NormalMove)
4551
{
4552
boards[currentMove][to_y][to_x] = piece;
4553
}
4554
else
4555
{
4556
boards[currentMove][to_y][to_x] = piece = pieceToPromoted[piece];
4557
pieceChar = '+';
4558
}
4559
4560
boards[currentMove][from_y][from_x] = EmptySquare;
4561
}
4562
else
4563
{
4564
ShogiSquare piece = boards[currentMove][to_y][to_x];
4565
4566
if (piece != EmptySquare)
4567
{
4568
i = pieceToCatchedIndex[piece];
4569
c = (piece < WhitePawn);
4570
catches[currentMove][c][i]++;
4571
}
4572
4573
*move_type = NormalMove;
4574
boards[currentMove][to_y][to_x] =
4575
boards[currentMove][from_y][from_x];
4576
boards[currentMove][from_y][from_x] = EmptySquare;
4577
}
4578
}
4579
4580
4581
4582
4583
/*
4584
* MakeMove() displays moves. If they are illegal, GNU shogi will detect
4585
* this and send an Illegal move message. XShogi will then retract the move.
4586
* The clockMode False case is tricky because it displays the player on move.
4587
*/
4588
4589
void
4590
MakeMove(ShogiMove *move_type, int from_x, int from_y, int to_x, int to_y)
4591
{
4592
char message[MSG_SIZ], movestr[MSG_SIZ];
4593
char promoPiece = NULLCHAR;
4594
4595
forwardMostMove++;
4596
4597
CopyBoard(boards[forwardMostMove], boards[forwardMostMove - 1]);
4598
CopyCatches(catches[forwardMostMove], catches[forwardMostMove - 1]);
4599
4600
ApplyMove(move_type, from_x, from_y, to_x, to_y, forwardMostMove);
4601
4602
endMessage[0] = NULLCHAR;
4603
4604
timeRemaining[0][forwardMostMove] = blackTimeRemaining;
4605
timeRemaining[1][forwardMostMove] = whiteTimeRemaining;
4606
4607
if ((gameMode == PauseGame) && (pausePreviousMode != PlayFromGameFile))
4608
return;
4609
4610
currentMove = forwardMostMove;
4611
4612
if (gameMode == PlayFromGameFile)
4613
{
4614
sprintf(message, "%d. %s%s",
4615
((currentMove + 1) / 2),
4616
(BlackOnMove(currentMove) ? "... " : ""),
4617
currentMoveString);
4618
strcpy(parseList[currentMove - 1], currentMoveString);
4619
}
4620
else
4621
{
4622
if ((*move_type == WhitePromotion) || (*move_type == BlackPromotion))
4623
promoPiece = '+';
4624
else
4625
promoPiece = NULLCHAR;
4626
4627
MakeAlg(from_x, from_y, to_x, to_y, promoPiece,
4628
currentMove - 1, movestr);
4629
sprintf(message, "%d. %s%s",
4630
((currentMove + 1) / 2),
4631
(BlackOnMove(currentMove) ? "... " : ""),
4632
movestr);
4633
strcpy(parseList[currentMove - 1], movestr);
4634
}
4635
4636
DisplayMessage(message, False);
4637
4638
if ((gameMode == PlayFromGameFile) || (gameMode == ForceMoves)
4639
|| ((gameMode == PauseGame)
4640
&& (pausePreviousMode == PlayFromGameFile)))
4641
{
4642
DisplayClocks(ReDisplayTimers);
4643
}
4644
else
4645
{
4646
DisplayClocks(SwitchTimers);
4647
}
4648
4649
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
4650
4651
XSync(localPlayer.xDisplay, False);
4652
4653
if (updateRemotePlayer)
4654
{
4655
DisplayMessage(message, True);
4656
XSync(remotePlayer.xDisplay, False);
4657
}
4658
}
4659
4660
4661
4662
4663
void
4664
InitShogiProgram(char *host_name, char *program_name, int *pid,
4665
FILE **to, FILE **from, XtIntervalId *xid, int *sendTime)
4666
{
4667
char arg_buf[10];
4668
char *arg1, *arg2;
4669
int to_prog[2], from_prog[2];
4670
FILE *from_fp, *to_fp;
4671
int dummy_source;
4672
XtInputId dummy_id;
4673
4674
if (localPlayer.appData.noShogiProgram)
4675
return;
4676
4677
signal(SIGPIPE, CatchPipeSignal);
4678
pipe(to_prog);
4679
pipe(from_prog);
4680
4681
if ((*pid = fork()) == 0)
4682
{
4683
signal(SIGPIPE, CatchPipeSignal);
4684
4685
dup2(to_prog[0], 0);
4686
dup2(from_prog[1], 1);
4687
close(to_prog[0]);
4688
close(to_prog[1]);
4689
close(from_prog[0]);
4690
close(from_prog[1]);
4691
dup2(1, fileno(stderr)); /* force stderr to the pipe */
4692
4693
if (localPlayer.appData.searchTime != NULL)
4694
{
4695
sprintf(arg_buf, "%d", searchTime);
4696
arg1 = arg_buf;
4697
arg2 = (char *)NULL;
4698
}
4699
else if (localPlayer.appData.searchDepth > 0)
4700
{
4701
sprintf(arg_buf, "%d", localPlayer.appData.searchDepth);
4702
arg1 = "1";
4703
arg2 = "9999";
4704
}
4705
else
4706
{
4707
sprintf(arg_buf, "%d", localPlayer.appData.movesPerSession);
4708
arg1 = arg_buf;
4709
arg2 = localPlayer.appData.timeControl;
4710
}
4711
4712
if (strcmp(host_name, "localhost") == 0)
4713
{
4714
execlp(program_name, program_name, arg1, arg2,
4715
(char *)NULL);
4716
}
4717
else
4718
{
4719
execlp(localPlayer.appData.remoteShell,
4720
localPlayer.appData.remoteShell,
4721
host_name, program_name, arg1, arg2,
4722
(char *)NULL);
4723
}
4724
4725
perror(program_name);
4726
exit(1);
4727
}
4728
4729
close(to_prog[0]);
4730
close(from_prog[1]);
4731
4732
*from = from_fp = fdopen(from_prog[0], "r");
4733
*to = to_fp = fdopen(to_prog[1], "w");
4734
setbuf(from_fp, NULL);
4735
setbuf(to_fp, NULL);
4736
4737
ReceiveFromProgram(from_fp, &dummy_source, &dummy_id); /* "GNU Shogi"*/
4738
4739
if (!at_least_gnushogi_1_2p03)
4740
{
4741
fprintf(stderr, "you must have at least gnushogi-1.2p03\n");
4742
exit(1);
4743
}
4744
4745
if (*pid == 0)
4746
return;
4747
4748
*xid = XtAppAddInput(appContext, fileno(from_fp),
4749
(XtPointer)XtInputReadMask,
4750
(XtInputCallbackProc)ReceiveFromProgram,
4751
(XtPointer)from_fp);
4752
4753
SendToProgram(localPlayer.appData.initString, *to);
4754
4755
if (localPlayer.appData.gameIn)
4756
SendToProgram("gamein\n", *to);
4757
4758
SendSearchDepth(*to);
4759
4760
if (*sendTime == 2)
4761
{
4762
/* Does program have "time" command? */
4763
char buf[MSG_SIZ];
4764
4765
sprintf(buf, "time %ld\n", blackTimeRemaining / 10);
4766
SendToProgram(buf, to_fp);
4767
ReceiveFromProgram(from_fp, &dummy_source, &dummy_id);
4768
4769
if (*sendTime == 2)
4770
{
4771
*sendTime = 1; /* yes! */
4772
sprintf(buf, "otime %ld\n", whiteTimeRemaining / 10);
4773
SendToProgram(buf, to_fp);
4774
ReceiveFromProgram(from_fp, &dummy_source, &dummy_id);
4775
}
4776
}
4777
}
4778
4779
4780
4781
4782
void
4783
ShutdownShogiPrograms(char *why)
4784
{
4785
lastGameMode = gameMode;
4786
gameMode = EndOfGame;
4787
ModeHighlight();
4788
CopyBoard(boards[currentMove + 1], boards[currentMove]);
4789
CopyCatches(catches[currentMove + 1], catches[currentMove]);
4790
strncpy(parseList[currentMove], why, MOVE_LEN);
4791
parseList[currentMove][MOVE_LEN - 1] = NULLCHAR;
4792
currentMove++;
4793
DisplayMessage(why, False);
4794
4795
if (readGameXID != 0)
4796
XtRemoveTimeOut(readGameXID);
4797
4798
readGameXID = 0;
4799
4800
if (firstProgramPID != 0)
4801
{
4802
fclose(fromFirstProgFP);
4803
fclose(toFirstProgFP);
4804
fromFirstProgFP = toFirstProgFP = NULL;
4805
4806
if (kill(firstProgramPID, SIGTERM) == 0)
4807
WAIT0;
4808
}
4809
4810
firstProgramPID = 0;
4811
4812
if (firstProgramXID != 0)
4813
XtRemoveInput(firstProgramXID);
4814
4815
firstProgramXID = 0;
4816
4817
if (secondProgramPID != 0)
4818
{
4819
fclose(fromSecondProgFP);
4820
fclose(toSecondProgFP);
4821
fromSecondProgFP = toSecondProgFP = NULL;
4822
4823
if (kill(secondProgramPID, SIGTERM) == 0)
4824
WAIT0;
4825
}
4826
4827
secondProgramPID = 0;
4828
4829
if (secondProgramXID != 0)
4830
XtRemoveInput(secondProgramXID);
4831
4832
secondProgramXID = 0;
4833
4834
DisplayClocks(StopTimers);
4835
4836
if (matchMode != MatchFalse)
4837
{
4838
if (localPlayer.appData.saveGameFile[0] != NULLCHAR)
4839
SaveGame(localPlayer.appData.saveGameFile);
4840
4841
exit(0);
4842
}
4843
}
4844
4845
4846
4847
4848
void
4849
CommentPopUp(char *label)
4850
{
4851
Arg args[2];
4852
Position x, y;
4853
Dimension bw_width, pw_width;
4854
4855
if (commentUp)
4856
{
4857
XtPopdown(commentShell);
4858
XtDestroyWidget(commentShell);
4859
commentUp = False;
4860
}
4861
4862
DisplayMessage("Comment", False);
4863
4864
XtSetArg(args[0], XtNwidth, &bw_width);
4865
XtGetValues(localPlayer.formWidget, args, 1);
4866
4867
XtSetArg(args[0], XtNresizable, True);
4868
XtSetArg(args[1], XtNwidth, bw_width - 8);
4869
4870
commentShell = XtCreatePopupShell("Comment",
4871
transientShellWidgetClass,
4872
localPlayer.commandsWidget, args, 2);
4873
4874
XtSetArg(args[0], XtNlabel, label);
4875
4876
(void)XtCreateManagedWidget("commentLabel", labelWidgetClass,
4877
commentShell, args, 1);
4878
4879
XtRealizeWidget(commentShell);
4880
4881
XtSetArg(args[0], XtNwidth, &pw_width);
4882
XtGetValues(commentShell, args, 1);
4883
4884
XtTranslateCoords(localPlayer.shellWidget,
4885
(bw_width - pw_width) / 2, -50, &x, &y);
4886
4887
XtSetArg(args[0], XtNx, x);
4888
XtSetArg(args[1], XtNy, y);
4889
XtSetValues(commentShell, args, 2);
4890
4891
XtPopup(commentShell, XtGrabNone);
4892
commentUp = True;
4893
}
4894
4895
4896
4897
4898
void
4899
FileNamePopUp(char *label, Boolean (*proc) (char *))
4900
{
4901
Arg args[2];
4902
Widget popup, dialog;
4903
Position x, y;
4904
Dimension bw_width, pw_width;
4905
4906
fileProc = proc;
4907
4908
XtSetArg(args[0], XtNwidth, &bw_width);
4909
XtGetValues(localPlayer.boardWidget, args, 1);
4910
4911
XtSetArg(args[0], XtNresizable, True);
4912
XtSetArg(args[1], XtNwidth, DIALOG_SIZE);
4913
4914
popup = XtCreatePopupShell("File Name Prompt",
4915
transientShellWidgetClass,
4916
localPlayer.commandsWidget, args, 2);
4917
4918
XtSetArg(args[0], XtNlabel, label);
4919
XtSetArg(args[1], XtNvalue, "");
4920
4921
dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
4922
popup, args, 2);
4923
4924
XawDialogAddButton(dialog, "ok", FileNameCallback, (XtPointer) dialog);
4925
XawDialogAddButton(dialog, "cancel", FileNameCallback,
4926
(XtPointer) dialog);
4927
4928
XtRealizeWidget(popup);
4929
4930
XtSetArg(args[0], XtNwidth, &pw_width);
4931
XtGetValues(popup, args, 1);
4932
4933
XtTranslateCoords(localPlayer.boardWidget,
4934
(bw_width - pw_width) / 2, 10, &x, &y);
4935
4936
XtSetArg(args[0], XtNx, x);
4937
XtSetArg(args[1], XtNy, y);
4938
XtSetValues(popup, args, 2);
4939
4940
XtPopup(popup, XtGrabExclusive);
4941
filenameUp = True;
4942
4943
XtSetKeyboardFocus(localPlayer.shellWidget, popup);
4944
}
4945
4946
4947
4948
4949
void
4950
FileNameCallback(Widget w, XtPointer client_data, XtPointer call_data)
4951
{
4952
String name;
4953
Arg args[1];
4954
4955
XtSetArg(args[0], XtNlabel, &name);
4956
XtGetValues(w, args, 1);
4957
4958
if (strcmp(name, "cancel") == 0)
4959
{
4960
XtPopdown(w = XtParent(XtParent(w)));
4961
XtDestroyWidget(w);
4962
filenameUp = False;
4963
ModeHighlight();
4964
return;
4965
}
4966
4967
FileNameAction(w, NULL, NULL, NULL);
4968
}
4969
4970
4971
4972
4973
void
4974
FileNameAction(Widget w, XEvent *event, String *prms, Cardinal *nprms)
4975
{
4976
char buf[MSG_SIZ];
4977
String name;
4978
4979
name = XawDialogGetValueString(w = XtParent(w));
4980
4981
if ((name != NULL) && (*name != NULLCHAR))
4982
{
4983
strcpy(buf, name);
4984
XtPopdown(w = XtParent(w));
4985
XtDestroyWidget(w);
4986
filenameUp = False;
4987
(*fileProc)(buf); /* I can't see a way not
4988
to use a global here */
4989
ModeHighlight();
4990
return;
4991
}
4992
4993
XtPopdown(w = XtParent(w));
4994
XtDestroyWidget(w);
4995
filenameUp = False;
4996
ModeHighlight();
4997
}
4998
4999
5000
5001
5002
void
5003
PromotionPopUp(ShogiSquare piece, int to_x, int to_y, int fromRemotePlayer)
5004
{
5005
Arg args[2];
5006
Widget dialog;
5007
Position x, y;
5008
Dimension bw_width, bw_height, pw_width, pw_height;
5009
5010
player = (fromRemotePlayer ? &remotePlayer : &localPlayer);
5011
5012
pmi.piece = piece;
5013
pmi.to_x = to_x;
5014
pmi.to_y = to_y;
5015
5016
XtSetArg(args[0], XtNwidth, &bw_width);
5017
XtSetArg(args[1], XtNheight, &bw_height);
5018
XtGetValues(player->boardWidget, args, 2);
5019
5020
XtSetArg(args[0], XtNresizable, True);
5021
5022
player->promotionShell
5023
= XtCreatePopupShell("Promotion",
5024
transientShellWidgetClass,
5025
player->commandsWidget, args, 1);
5026
5027
XtSetArg(args[0], XtNlabel, "Promote piece?");
5028
dialog = XtCreateManagedWidget("promotion", dialogWidgetClass,
5029
player->promotionShell, args, 1);
5030
5031
XawDialogAddButton(dialog, "Yes", PromotionCallback,
5032
(XtPointer) dialog);
5033
XawDialogAddButton(dialog, "No", PromotionCallback,
5034
(XtPointer) dialog);
5035
XawDialogAddButton(dialog, "cancel", PromotionCallback,
5036
(XtPointer) dialog);
5037
5038
XtRealizeWidget(player->promotionShell);
5039
5040
XtSetArg(args[0], XtNwidth, &pw_width);
5041
XtSetArg(args[1], XtNheight, &pw_height);
5042
XtGetValues(player->promotionShell, args, 2);
5043
5044
XtTranslateCoords(player->boardWidget,
5045
((bw_width - pw_width) / 2),
5046
(LINE_GAP
5047
+ player->squareSize / 3
5048
+ (((piece == BlackPawn) ^ (player->flipView))
5049
? 0
5050
: (6 * (player->squareSize + LINE_GAP)))),
5051
&x, &y);
5052
5053
XtSetArg(args[0], XtNx, x);
5054
XtSetArg(args[1], XtNy, y);
5055
XtSetValues(player->promotionShell, args, 2);
5056
5057
XtPopup(player->promotionShell, XtGrabNone);
5058
5059
player->promotionUp = True;
5060
}
5061
5062
5063
5064
5065
void
5066
PromotionCallback(Widget w, XtPointer client_data, XtPointer call_data)
5067
{
5068
String name;
5069
Arg args[1];
5070
ShogiMove move_type;
5071
struct DisplayData *player;
5072
5073
XtSetArg(args[0], XtNlabel, &name);
5074
XtGetValues(w, args, 1);
5075
5076
w = XtParent(XtParent(w));
5077
player = ((w == remotePlayer.promotionShell)
5078
? &remotePlayer : &localPlayer);
5079
XtPopdown(w);
5080
XtDestroyWidget(w);
5081
player->promotionUp = False;
5082
5083
if (fromX == -1)
5084
return;
5085
5086
if (strcmp(name, "Yes") == 0)
5087
{
5088
if ((int)pmi.piece < (int)WhitePawn)
5089
move_type = BlackPromotion;
5090
else
5091
move_type = WhitePromotion;
5092
}
5093
else if (strcmp(name, "No") == 0)
5094
{
5095
move_type = NormalMove;
5096
}
5097
else /* strcmp(name, "cancel") == 0 */
5098
{
5099
fromX = fromY = -1;
5100
return;
5101
}
5102
5103
MakeMove(&move_type, fromX, fromY, pmi.to_x, pmi.to_y);
5104
5105
#ifdef BLINK_COUNT
5106
if (updateRemotePlayer)
5107
{
5108
BlinkSquare(pmi.to_y, pmi.to_x,
5109
boards[currentMove][pmi.to_y][pmi.to_x]);
5110
}
5111
#endif
5112
5113
FinishUserMove(move_type, pmi.to_x, pmi.to_y);
5114
}
5115
5116
5117
5118
5119
void
5120
FileModePopUp(char *name)
5121
{
5122
Arg args[2];
5123
Widget dialog;
5124
Position x, y;
5125
Dimension bw_width, bw_height, pw_width, pw_height;
5126
5127
struct DisplayData *player = &localPlayer;
5128
5129
strcpy(fmi.name, name);
5130
5131
XtSetArg(args[0], XtNwidth, &bw_width);
5132
XtSetArg(args[1], XtNheight, &bw_height);
5133
XtGetValues(player->boardWidget, args, 2);
5134
5135
XtSetArg(args[0], XtNresizable, True);
5136
player->filemodeShell
5137
= XtCreatePopupShell("FileMode",
5138
transientShellWidgetClass,
5139
player->commandsWidget, args, 1);
5140
5141
XtSetArg(args[0], XtNlabel, "Append to existing file?");
5142
dialog = XtCreateManagedWidget("filemode", dialogWidgetClass,
5143
player->filemodeShell, args, 1);
5144
5145
XawDialogAddButton(dialog, "Yes", FileModeCallback,
5146
(XtPointer) dialog);
5147
XawDialogAddButton(dialog, "No", FileModeCallback,
5148
(XtPointer) dialog);
5149
XawDialogAddButton(dialog, "cancel", FileModeCallback,
5150
(XtPointer) dialog);
5151
5152
XtRealizeWidget(player->filemodeShell);
5153
5154
XtSetArg(args[0], XtNwidth, &pw_width);
5155
XtSetArg(args[1], XtNheight, &pw_height);
5156
XtGetValues(player->filemodeShell, args, 2);
5157
5158
XtTranslateCoords(player->boardWidget, (bw_width - pw_width) / 2,
5159
LINE_GAP + player->squareSize/3 +
5160
(6*(player->squareSize + LINE_GAP)),
5161
&x, &y);
5162
5163
XtSetArg(args[0], XtNx, x);
5164
XtSetArg(args[1], XtNy, y);
5165
XtSetValues(player->filemodeShell, args, 2);
5166
5167
XtPopup(player->filemodeShell, XtGrabNone);
5168
5169
filemodeUp = True;
5170
}
5171
5172
5173
5174
5175
void
5176
FileModeCallback(Widget w, XtPointer client_data, XtPointer call_data)
5177
{
5178
String name;
5179
Arg args[1];
5180
5181
XtSetArg(args[0], XtNlabel, &name);
5182
XtGetValues(w, args, 1);
5183
5184
XtPopdown(w = XtParent(XtParent(w)));
5185
XtDestroyWidget(w);
5186
5187
if (strcmp(name, "Yes") == 0)
5188
{
5189
strcpy(fmi.mode, "a");
5190
}
5191
else if (strcmp(name, "No") == 0)
5192
{
5193
strcpy(fmi.mode, "w");
5194
}
5195
else /* strcmp(name, "cancel") == 0 */
5196
{
5197
filemodeUp = False;
5198
return;
5199
}
5200
5201
XtPopdown(localPlayer.filemodeShell);
5202
XtDestroyWidget(localPlayer.filemodeShell);
5203
5204
SaveGame(fmi.name);
5205
5206
filemodeUp = False;
5207
}
5208
5209
5210
5211
5212
void
5213
SelectCommand(Widget w, XtPointer client_data, XtPointer call_data)
5214
{
5215
Cardinal fromRemotePlayer = (Cardinal)client_data;
5216
5217
XawListReturnStruct *list_return = XawListShowCurrent(w);
5218
5219
player = fromRemotePlayer ? &remotePlayer : &localPlayer;
5220
5221
fromX = fromY = -1;
5222
5223
if (player->promotionUp)
5224
{
5225
XtPopdown(player->promotionShell);
5226
XtDestroyWidget(player->promotionShell);
5227
player->promotionUp = False;
5228
}
5229
5230
(*buttonProcs[list_return->list_index])
5231
(w, NULL, NULL, &fromRemotePlayer);
5232
5233
if (!filenameUp)
5234
ModeHighlight();
5235
}
5236
5237
5238
5239
5240
void
5241
HighlightProcButton(XtActionProc proc)
5242
{
5243
int i = 0;
5244
5245
if (proc == NULL)
5246
{
5247
XawListUnhighlight(localPlayer.commandsWidget);
5248
5249
if (updateRemotePlayer)
5250
XawListUnhighlight(remotePlayer.commandsWidget);
5251
5252
return;
5253
}
5254
5255
for (;;)
5256
{
5257
if (buttonProcs[i] == NULL)
5258
{
5259
XawListUnhighlight(localPlayer.commandsWidget);
5260
5261
if (updateRemotePlayer)
5262
XawListUnhighlight(remotePlayer.commandsWidget);
5263
5264
return;
5265
}
5266
5267
if (buttonProcs[i] == proc)
5268
{
5269
XawListHighlight(localPlayer.commandsWidget, i);
5270
5271
if (updateRemotePlayer)
5272
XawListHighlight(remotePlayer.commandsWidget, i);
5273
5274
return;
5275
}
5276
5277
i++;
5278
}
5279
}
5280
5281
5282
5283
5284
void
5285
ModeHighlight(void)
5286
{
5287
switch (gameMode)
5288
{
5289
case BeginningOfGame:
5290
if (localPlayer.appData.noShogiProgram)
5291
HighlightProcButton(ForceProc);
5292
else
5293
HighlightProcButton(MachineBlackProc);
5294
5295
break;
5296
5297
case MachinePlaysBlack:
5298
HighlightProcButton(MachineBlackProc);
5299
break;
5300
5301
case MachinePlaysWhite:
5302
HighlightProcButton(MachineWhiteProc);
5303
break;
5304
5305
case TwoMachinesPlay:
5306
HighlightProcButton(TwoMachinesProc);
5307
break;
5308
5309
case ForceMoves:
5310
HighlightProcButton(ForceProc);
5311
5312
break;
5313
5314
case PlayFromGameFile:
5315
HighlightProcButton(LoadGameProc);
5316
break;
5317
5318
case PauseGame:
5319
HighlightProcButton(PauseProc);
5320
break;
5321
5322
case EditPosition:
5323
HighlightProcButton(EditPositionProc);
5324
break;
5325
5326
case EndOfGame:
5327
default:
5328
HighlightProcButton(NULL);
5329
break;
5330
}
5331
}
5332
5333
5334
5335
5336
/*
5337
* Button procedures
5338
*/
5339
5340
void
5341
QuitRemotePlayerProc(void)
5342
{
5343
/* This should be modified... */
5344
XCloseDisplay(remotePlayer.xDisplay);
5345
/* XtDestroyWidget(remotePlayer.shellWidget); */
5346
updateRemotePlayer = False;
5347
DisplayMessage("Remote player has pressed Quit", False);
5348
fromX = fromY = -1;
5349
}
5350
5351
5352
5353
void
5354
QuitProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5355
{
5356
if (updateRemotePlayer)
5357
QuitRemotePlayerProc();
5358
5359
ShutdownShogiPrograms("Quitting");
5360
exit(0);
5361
}
5362
5363
5364
5365
void
5366
LoadGameProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5367
{
5368
int fromRemotePlayer = *nprms;
5369
5370
if (fromRemotePlayer)
5371
{
5372
DisplayMessage("only opponent may load game", fromRemotePlayer);
5373
return;
5374
}
5375
5376
if (gameMode != BeginningOfGame)
5377
{
5378
DisplayMessage("Press Reset first", False);
5379
return;
5380
}
5381
5382
if (localPlayer.appData.loadGameFile == NULL)
5383
FileNamePopUp("Game file name?", LoadGame);
5384
else
5385
(void) LoadGame(localPlayer.appData.loadGameFile);
5386
}
5387
5388
5389
5390
5391
Boolean
5392
LoadGame(char *name)
5393
{
5394
char buf[MSG_SIZ];
5395
5396
if (gameMode != BeginningOfGame)
5397
{
5398
DisplayMessage("Press Reset first", False);
5399
return (int)False;
5400
}
5401
5402
if (localPlayer.appData.loadGameFile != name)
5403
{
5404
if (localPlayer.appData.loadGameFile)
5405
XtFree(localPlayer.appData.loadGameFile);
5406
5407
localPlayer.appData.loadGameFile = XtMalloc(strlen(name) + 1);
5408
strcpy(localPlayer.appData.loadGameFile, name);
5409
}
5410
5411
if ((gameFileFP = fopen(name, "r")) == NULL)
5412
{
5413
sprintf(buf, "Can't open %s", name);
5414
DisplayMessage(buf, False);
5415
XtFree(localPlayer.appData.loadGameFile);
5416
localPlayer.appData.loadGameFile = NULL;
5417
return (int)False;
5418
}
5419
5420
lastGameMode = gameMode = PlayFromGameFile;
5421
ModeHighlight();
5422
InitPosition(True);
5423
DisplayClocks(StopTimers);
5424
5425
if (firstProgramXID == 0)
5426
{
5427
InitShogiProgram(localPlayer.appData.firstHost,
5428
localPlayer.appData.firstShogiProgram,
5429
&firstProgramPID, &toFirstProgFP,
5430
&fromFirstProgFP, &firstProgramXID,
5431
&firstSendTime);
5432
}
5433
5434
SendToProgram(localPlayer.appData.initString, toFirstProgFP);
5435
SendSearchDepth(toFirstProgFP);
5436
SendToProgram("force\n", toFirstProgFP);
5437
5438
currentMove = forwardMostMove = backwardMostMove = 0;
5439
5440
ReadGameFile();
5441
5442
return True;
5443
}
5444
5445
5446
5447
5448
/*
5449
* Restart the shogi program and feed it all the moves made so far.
5450
* Used when the user wants to back up from end of game, when gnushogi
5451
* has already exited. Assumes gameMode == EndOfGame.
5452
*/
5453
5454
void
5455
ResurrectShogiProgram(void)
5456
{
5457
char buf[MSG_SIZ];
5458
int i;
5459
5460
if (currentMove > 0)
5461
currentMove--; /* delete "Black wins" or the like */
5462
5463
InitShogiProgram(localPlayer.appData.firstHost,
5464
localPlayer.appData.firstShogiProgram,
5465
&firstProgramPID, &toFirstProgFP, &fromFirstProgFP,
5466
&firstProgramXID, &firstSendTime);
5467
5468
SendToProgram(localPlayer.appData.initString, toFirstProgFP);
5469
SendSearchDepth(toFirstProgFP);
5470
SendToProgram("force\n", toFirstProgFP);
5471
gameMode = lastGameMode = ForceMoves;
5472
ModeHighlight();
5473
5474
i = (whitePlaysFirst ? 1 : 0);
5475
5476
if (startedFromSetupPosition)
5477
SendBoard(toFirstProgFP, boards[i], catches[i]);
5478
5479
for (; i < currentMove; i++)
5480
{
5481
strcpy(buf, moveList[i]);
5482
SendToProgram(buf, toFirstProgFP);
5483
}
5484
5485
if (!firstSendTime)
5486
{
5487
/* can't tell gnushogi what its clock should read,
5488
so we bow to its notion. */
5489
DisplayClocks(ResetTimers);
5490
timeRemaining[0][currentMove] = blackTimeRemaining;
5491
timeRemaining[1][currentMove] = whiteTimeRemaining;
5492
}
5493
}
5494
5495
5496
5497
5498
void
5499
MachineWhiteProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5500
{
5501
int fromRemotePlayer = *nprms;
5502
5503
if (updateRemotePlayer)
5504
{
5505
DisplayMessage("no machine moves in challenge mode",
5506
fromRemotePlayer);
5507
5508
return;
5509
}
5510
5511
if (gameMode == PauseGame)
5512
PauseProc(w, event, prms, nprms);
5513
5514
if (gameMode == PlayFromGameFile)
5515
ForceProc(w, event, prms, nprms);
5516
5517
if (gameMode == EditPosition)
5518
EditPositionDone();
5519
5520
if ((gameMode == EndOfGame)
5521
|| (gameMode == PlayFromGameFile)
5522
|| (gameMode == TwoMachinesPlay)
5523
|| localPlayer.appData.noShogiProgram
5524
|| (gameMode == MachinePlaysWhite))
5525
{
5526
return;
5527
}
5528
5529
if (BlackOnMove((gameMode == ForceMoves)
5530
? currentMove
5531
: forwardMostMove))
5532
{
5533
DisplayMessage("It is not White's turn", False);
5534
return;
5535
}
5536
5537
if (gameMode == ForceMoves)
5538
forwardMostMove = currentMove;
5539
5540
lastGameMode = gameMode = MachinePlaysWhite;
5541
ModeHighlight();
5542
SendToProgram(localPlayer.appData.whiteString, toFirstProgFP);
5543
DisplayClocks(StartTimers);
5544
}
5545
5546
5547
5548
5549
void
5550
MachineBlackProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5551
{
5552
int fromRemotePlayer = *nprms;
5553
5554
if (updateRemotePlayer)
5555
{
5556
DisplayMessage("no machine moves in challenge mode",
5557
fromRemotePlayer);
5558
return;
5559
}
5560
5561
if (gameMode == PauseGame)
5562
PauseProc(w, event, prms, nprms);
5563
5564
if (gameMode == PlayFromGameFile)
5565
ForceProc(w, event, prms, nprms);
5566
5567
if (gameMode == EditPosition)
5568
EditPositionDone();
5569
5570
if ((gameMode == EndOfGame)
5571
|| (gameMode == PlayFromGameFile)
5572
|| (gameMode == TwoMachinesPlay)
5573
|| localPlayer.appData.noShogiProgram
5574
|| (gameMode == MachinePlaysBlack))
5575
{
5576
return;
5577
}
5578
5579
if (!BlackOnMove((gameMode == ForceMoves)
5580
? currentMove
5581
: forwardMostMove))
5582
{
5583
DisplayMessage("It is not Black's turn", False);
5584
return;
5585
}
5586
5587
if (gameMode == ForceMoves)
5588
forwardMostMove = currentMove;
5589
5590
lastGameMode = gameMode = MachinePlaysBlack;
5591
ModeHighlight();
5592
SendToProgram(localPlayer.appData.blackString, toFirstProgFP);
5593
DisplayClocks(StartTimers);
5594
}
5595
5596
5597
5598
5599
void
5600
ForwardProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5601
{
5602
char buf[MSG_SIZ];
5603
int target;
5604
unsigned int state;
5605
5606
int fromRemotePlayer = *nprms;
5607
5608
if (updateRemotePlayer)
5609
{
5610
DisplayMessage("Forward button disabled", fromRemotePlayer);
5611
return;
5612
}
5613
5614
if ((gameMode == EndOfGame) || (gameMode == EditPosition))
5615
return;
5616
5617
if (gameMode == PlayFromGameFile)
5618
PauseProc(w, event, prms, nprms);
5619
5620
if (currentMove >= forwardMostMove)
5621
return;
5622
5623
if (event == NULL)
5624
{
5625
/* Kludge */
5626
Window root, child;
5627
int root_x, root_y;
5628
int win_x, win_y;
5629
XQueryPointer(localPlayer.xDisplay, localPlayer.xBoardWindow,
5630
&root, &child, &root_x, &root_y,
5631
&win_x, &win_y, &state);
5632
}
5633
else
5634
{
5635
state = event->xkey.state;
5636
}
5637
5638
if (state & ShiftMask)
5639
target = forwardMostMove;
5640
else
5641
target = currentMove + 1;
5642
5643
if (gameMode == ForceMoves)
5644
{
5645
while (currentMove < target)
5646
{
5647
strcpy(buf, moveList[currentMove++]);
5648
SendToProgram(buf, toFirstProgFP);
5649
}
5650
}
5651
else
5652
{
5653
currentMove = target;
5654
}
5655
5656
if (gameMode == ForceMoves)
5657
{
5658
blackTimeRemaining = timeRemaining[0][currentMove];
5659
whiteTimeRemaining = timeRemaining[1][currentMove];
5660
}
5661
5662
DisplayClocks(ReDisplayTimers);
5663
DisplayMove(currentMove - 1);
5664
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
5665
}
5666
5667
5668
5669
5670
void
5671
ResetFileProc(void)
5672
{
5673
char *buf = "";
5674
5675
if (updateRemotePlayer)
5676
return;
5677
5678
if (localPlayer.appData.loadGameFile)
5679
XtFree(localPlayer.appData.loadGameFile);
5680
5681
if (localPlayer.appData.loadPositionFile)
5682
XtFree(localPlayer.appData.loadPositionFile);
5683
5684
localPlayer.appData.loadGameFile
5685
= localPlayer.appData.loadPositionFile = NULL;
5686
DisplayName(buf);
5687
5688
if (gameFileFP != NULL)
5689
{
5690
fclose(gameFileFP);
5691
gameFileFP = NULL;
5692
}
5693
}
5694
5695
5696
5697
5698
void
5699
ResetChallenge(void)
5700
{
5701
char *buf = "";
5702
5703
if (localPlayer.appData.challengeDisplay)
5704
XtFree(localPlayer.appData.challengeDisplay);
5705
5706
localPlayer.appData.challengeDisplay = NULL;
5707
DisplayName(buf);
5708
}
5709
5710
5711
5712
5713
void
5714
ResetProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5715
{
5716
int fromRemotePlayer = *nprms;
5717
5718
if (fromRemotePlayer)
5719
{
5720
DisplayMessage("only your opponent may reset the game",
5721
fromRemotePlayer);
5722
return;
5723
}
5724
5725
Reset(True);
5726
}
5727
5728
5729
5730
5731
void
5732
Reset(int redraw) /* Boolean */
5733
{
5734
ResetFileProc();
5735
ResetChallenge();
5736
5737
localPlayer.flipView = False;
5738
remotePlayer.flipView = True;
5739
startedFromSetupPosition = whitePlaysFirst = False;
5740
matchMode = MatchFalse;
5741
firstMove = True;
5742
blackFlag = whiteFlag = False;
5743
maybeThinking = False;
5744
5745
endMessage[0] = NULLCHAR;
5746
5747
ShutdownShogiPrograms("");
5748
lastGameMode = gameMode = BeginningOfGame;
5749
ModeHighlight();
5750
InitPosition(redraw);
5751
DisplayClocks(ResetTimers);
5752
timeRemaining[0][0] = blackTimeRemaining;
5753
timeRemaining[1][0] = whiteTimeRemaining;
5754
InitShogiProgram(localPlayer.appData.firstHost,
5755
localPlayer.appData.firstShogiProgram,
5756
&firstProgramPID, &toFirstProgFP,
5757
&fromFirstProgFP, &firstProgramXID,
5758
&firstSendTime);
5759
5760
if (commentUp)
5761
{
5762
XtPopdown(commentShell);
5763
XtDestroyWidget(commentShell);
5764
commentUp = False;
5765
}
5766
5767
if (localPlayer.promotionUp)
5768
{
5769
XtPopdown(localPlayer.promotionShell);
5770
XtDestroyWidget(localPlayer.promotionShell);
5771
localPlayer.promotionUp = False;
5772
}
5773
5774
if (updateRemotePlayer && remotePlayer.promotionUp)
5775
{
5776
XtPopdown(remotePlayer.promotionShell);
5777
XtDestroyWidget(remotePlayer.promotionShell);
5778
remotePlayer.promotionUp = False;
5779
}
5780
}
5781
5782
5783
5784
5785
void
5786
ClearCatches(int (*catches)[8])
5787
{
5788
int c, p;
5789
5790
for (c = 0; c <= 1; c++)
5791
for (p = 0; p <= 7; p++)
5792
catches[c][p] = 0;
5793
}
5794
5795
5796
5797
5798
Boolean
5799
Challenge(char *name)
5800
{
5801
char buf[MSG_SIZ];
5802
int argc;
5803
char **argv;
5804
XrmDatabase database;
5805
5806
if (gameMode != BeginningOfGame)
5807
{
5808
DisplayMessage("Press Reset first", False);
5809
return (int)False;
5810
}
5811
5812
if (localPlayer.appData.challengeDisplay != name)
5813
{
5814
if (localPlayer.appData.challengeDisplay)
5815
XtFree(localPlayer.appData.challengeDisplay);
5816
5817
localPlayer.appData.challengeDisplay = XtMalloc(strlen(name) + 1);
5818
strcpy(localPlayer.appData.challengeDisplay, name);
5819
}
5820
5821
sprintf(buf, "trying to connect to %s.....", name);
5822
DisplayMessage(buf, False);
5823
5824
argc = global_argc;
5825
argv = global_argv;
5826
5827
if ((remotePlayer.xDisplay
5828
= XtOpenDisplay(appContext, name, "XShogi",
5829
"XShogi", 0, 0, &argc, argv)) == NULL)
5830
{
5831
sprintf(buf, "Can't open display %s", name);
5832
DisplayMessage(buf, False);
5833
XtFree(localPlayer.appData.challengeDisplay);
5834
localPlayer.appData.challengeDisplay = NULL;
5835
return (int)False;
5836
}
5837
5838
DisplayMessage("connected! creating remote window...", False);
5839
5840
remotePlayer.xScreen = DefaultScreen(remotePlayer.xDisplay);
5841
5842
remotePlayer.shellWidget
5843
= XtAppCreateShell(NULL, "XShogi",
5844
applicationShellWidgetClass,
5845
remotePlayer.xDisplay, NULL, 0);
5846
5847
database = XtDatabase(remotePlayer.xDisplay);
5848
5849
XrmParseCommand(&database,
5850
shellOptions, XtNumber(shellOptions),
5851
"XShogi", &argc, argv);
5852
5853
XtGetApplicationResources(remotePlayer.shellWidget,
5854
&remotePlayer.appData, clientResources,
5855
XtNumber(clientResources), NULL, 0);
5856
5857
player = &remotePlayer;
5858
5859
CreatePlayerWindow();
5860
5861
updateRemotePlayer = True;
5862
5863
DisplayName("REMOTE");
5864
DrawPosition(remotePlayer.boardWidget, NULL, NULL, NULL);
5865
DisplayClocks(ReDisplayTimers);
5866
5867
DisplayMessage("ready to play", False);
5868
DisplayMessage("ready to play", True);
5869
5870
return True;
5871
}
5872
5873
5874
5875
5876
void
5877
ChallengeProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5878
{
5879
int fromRemotePlayer = *nprms;
5880
5881
if (updateRemotePlayer)
5882
{
5883
DisplayMessage("you are already in challenge mode",
5884
fromRemotePlayer);
5885
return;
5886
}
5887
5888
if (gameMode != BeginningOfGame)
5889
{
5890
DisplayMessage("Press Reset first", False);
5891
return;
5892
}
5893
5894
if (localPlayer.appData.challengeDisplay == NULL)
5895
FileNamePopUp("Challenge display?", Challenge);
5896
else
5897
(void) Challenge(localPlayer.appData.challengeDisplay);
5898
}
5899
5900
5901
5902
5903
Boolean
5904
SelectLevel(char *command)
5905
{
5906
char buf[MSG_SIZ];
5907
5908
sprintf(buf, "level %s\n", command);
5909
SendToProgram(buf, toFirstProgFP);
5910
5911
return True;
5912
}
5913
5914
5915
5916
5917
void
5918
SelectLevelProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5919
{
5920
if ((BlackOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack))
5921
|| (!BlackOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite)))
5922
{
5923
DisplayMessage("Wait until your turn", False);
5924
}
5925
else
5926
{
5927
FileNamePopUp("#moves #minutes", SelectLevel);
5928
}
5929
}
5930
5931
5932
5933
5934
void
5935
MoveNowProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5936
{
5937
if ((!BlackOnMove(forwardMostMove) && (gameMode == MachinePlaysBlack))
5938
|| (BlackOnMove(forwardMostMove) && (gameMode == MachinePlaysWhite)))
5939
{
5940
DisplayMessage("Wait until machines turn", False);
5941
}
5942
else
5943
{
5944
Attention(firstProgramPID);
5945
}
5946
}
5947
5948
5949
5950
5951
void
5952
LoadPositionProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
5953
{
5954
int fromRemotePlayer = *nprms;
5955
5956
if (fromRemotePlayer)
5957
{
5958
DisplayMessage("only opponent may load position", fromRemotePlayer);
5959
return;
5960
}
5961
5962
if (gameMode != BeginningOfGame)
5963
{
5964
DisplayMessage("Press Reset first", False);
5965
return;
5966
}
5967
5968
FileNamePopUp("Position file name?", LoadPosition);
5969
}
5970
5971
5972
5973
5974
Boolean
5975
LoadPosition(char *name)
5976
{
5977
char *p, line[MSG_SIZ], buf[MSG_SIZ];
5978
Board initial_position;
5979
Catched initial_catches;
5980
FILE *fp;
5981
int i, j;
5982
5983
if (gameMode != BeginningOfGame)
5984
{
5985
DisplayMessage("Press Reset first", False);
5986
return False;
5987
}
5988
5989
if (localPlayer.appData.loadPositionFile != name)
5990
{
5991
if (localPlayer.appData.loadPositionFile)
5992
XtFree(localPlayer.appData.loadPositionFile);
5993
5994
localPlayer.appData.loadPositionFile = XtMalloc(strlen(name) + 1);
5995
strcpy(localPlayer.appData.loadPositionFile, name);
5996
}
5997
5998
if ((fp = fopen(name, "r")) == NULL)
5999
{
6000
sprintf(buf, "Can't open %s", name);
6001
DisplayMessage(buf, False);
6002
XtFree(localPlayer.appData.loadPositionFile);
6003
localPlayer.appData.loadPositionFile = NULL;
6004
return False;
6005
}
6006
6007
lastGameMode = gameMode = ForceMoves;
6008
ModeHighlight();
6009
startedFromSetupPosition = True;
6010
6011
if (firstProgramXID == 0)
6012
{
6013
InitShogiProgram(localPlayer.appData.firstHost,
6014
localPlayer.appData.firstShogiProgram,
6015
&firstProgramPID, &toFirstProgFP,
6016
&fromFirstProgFP, &firstProgramXID,
6017
&firstSendTime);
6018
}
6019
6020
/*
6021
* Check and skip header information in position file.
6022
*/
6023
6024
fgets(line, MSG_SIZ, fp);
6025
line[strlen(line) - 1] = NULLCHAR;
6026
sprintf(buf, "# %s position file", programName);
6027
6028
if (strncmp(line, buf, strlen(buf)))
6029
{
6030
strcat(line, ": no xshogi position file");
6031
DisplayMessage(line, False);
6032
return False;
6033
}
6034
6035
DisplayName(line);
6036
fgets(line, MSG_SIZ, fp); /* skip opponents */
6037
6038
for (i = BOARD_SIZE - 1; i >= 0; i--)
6039
{
6040
fgets(line, MSG_SIZ, fp);
6041
6042
for (p = line, j = 0; j < BOARD_SIZE; p++)
6043
{
6044
int promoted = False; /* CHECKME: is this valid? */
6045
6046
if (*p == '+')
6047
promoted = True;
6048
6049
if (*p == ' ')
6050
promoted = False;
6051
6052
p++;
6053
initial_position[i][j++] = CharToPiece(*p, promoted);
6054
}
6055
}
6056
6057
{
6058
int color;
6059
6060
for (color = 0; color <= 1; color++)
6061
{
6062
fscanf(fp, "%i%i%i%i%i%i%i%i\n",
6063
&initial_catches[color][pawn],
6064
&initial_catches[color][lance],
6065
&initial_catches[color][knight],
6066
&initial_catches[color][silver],
6067
&initial_catches[color][gold],
6068
&initial_catches[color][bishop],
6069
&initial_catches[color][rook],
6070
&initial_catches[color][king]);
6071
}
6072
}
6073
6074
whitePlaysFirst = False;
6075
6076
if (!feof(fp))
6077
{
6078
fgets(line, MSG_SIZ, fp);
6079
6080
if (strncmp(line, "white", strlen("white")) == 0)
6081
whitePlaysFirst = True;
6082
}
6083
6084
fclose(fp);
6085
6086
if (whitePlaysFirst)
6087
{
6088
CopyBoard(boards[0], initial_position);
6089
CopyCatches(catches[0], initial_catches);
6090
strcpy(moveList[0], " ...\n");
6091
strcpy(parseList[0], " ...\n");
6092
currentMove = forwardMostMove = backwardMostMove = 1;
6093
CopyBoard(boards[1], initial_position);
6094
CopyCatches(catches[1], initial_catches);
6095
SendToProgram("white\n", toFirstProgFP);
6096
SendToProgram("force\n", toFirstProgFP);
6097
SendCurrentBoard(toFirstProgFP);
6098
DisplayMessage("White to play", False);
6099
}
6100
else
6101
{
6102
currentMove = forwardMostMove = backwardMostMove = 0;
6103
CopyBoard(boards[0], initial_position);
6104
CopyCatches(catches[0], initial_catches);
6105
SendCurrentBoard(toFirstProgFP);
6106
SendToProgram("force\n", toFirstProgFP);
6107
DisplayMessage("Black to play", False);
6108
}
6109
6110
DisplayClocks(ResetTimers);
6111
timeRemaining[0][1] = blackTimeRemaining;
6112
timeRemaining[1][1] = whiteTimeRemaining;
6113
6114
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
6115
return True;
6116
}
6117
6118
6119
6120
6121
void
6122
EditPositionProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6123
{
6124
int fromRemotePlayer = *nprms;
6125
6126
if (updateRemotePlayer)
6127
{
6128
DisplayMessage("Edit button disabled", fromRemotePlayer);
6129
return;
6130
}
6131
6132
if (gameMode == EditPosition)
6133
return;
6134
6135
ForceProc(w, event, prms, nprms);
6136
6137
if (gameMode != ForceMoves)
6138
return;
6139
6140
DisplayName("<-- Press to set side to play next");
6141
DisplayMessage("Mouse: 1=drag, 2=black, 3=white", False);
6142
6143
lastGameMode = gameMode = EditPosition;
6144
ModeHighlight();
6145
6146
if (currentMove > 0)
6147
CopyBoard(boards[0], boards[currentMove]);
6148
6149
whitePlaysFirst = !BlackOnMove(forwardMostMove);
6150
currentMove = forwardMostMove = backwardMostMove = 0;
6151
}
6152
6153
6154
6155
6156
void
6157
EditPositionDone(void)
6158
{
6159
startedFromSetupPosition = True;
6160
SendToProgram(localPlayer.appData.initString, toFirstProgFP);
6161
SendSearchDepth(toFirstProgFP);
6162
6163
if (whitePlaysFirst)
6164
{
6165
strcpy(moveList[0], " ...\n");
6166
strcpy(parseList[0], " ...\n");
6167
currentMove = forwardMostMove = backwardMostMove = 1;
6168
CopyBoard(boards[1], boards[0]);
6169
CopyCatches(catches[1], catches[0]);
6170
SendToProgram("force\n", toFirstProgFP);
6171
SendCurrentBoard(toFirstProgFP);
6172
DisplayName(" ");
6173
DisplayMessage("White to play", False);
6174
}
6175
else
6176
{
6177
currentMove = forwardMostMove = backwardMostMove = 0;
6178
SendCurrentBoard(toFirstProgFP);
6179
SendToProgram("force\n", toFirstProgFP);
6180
DisplayName(" ");
6181
DisplayMessage("Black to play", False);
6182
}
6183
6184
lastGameMode = gameMode = ForceMoves;
6185
}
6186
6187
6188
6189
/*
6190
* FUNCTION
6191
* BackwardProc
6192
*
6193
* DESCRIPTION
6194
* This function executes when undoing a move.
6195
* FIXME: this function is totally hosed!!!
6196
*
6197
* ARGUMENTS
6198
* Widget w
6199
* XEvent *event
6200
* String *prms
6201
* Cardinal *nprms
6202
*
6203
* RETURN VALUE
6204
* void
6205
*
6206
*/
6207
6208
void
6209
BackwardProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6210
{
6211
int target;
6212
unsigned int state;
6213
6214
int fromRemotePlayer = *nprms;
6215
6216
if (updateRemotePlayer)
6217
{
6218
DisplayMessage("Backward button disabled", fromRemotePlayer);
6219
return;
6220
}
6221
6222
/*
6223
* Why do we need this here?
6224
*/
6225
6226
ForceProc(w, event, prms, nprms);
6227
6228
if ((currentMove <= backwardMostMove) || (gameMode == EditPosition))
6229
return;
6230
6231
if (gameMode == EndOfGame)
6232
ResurrectShogiProgram();
6233
6234
if (gameMode == PlayFromGameFile)
6235
PauseProc(w, event, prms, nprms);
6236
6237
if (event == NULL)
6238
{
6239
/* Kludge */
6240
Window root, child;
6241
int root_x, root_y;
6242
int win_x, win_y;
6243
6244
XQueryPointer(localPlayer.xDisplay, localPlayer.xBoardWindow,
6245
&root, &child, &root_x, &root_y,
6246
&win_x, &win_y, &state);
6247
}
6248
else
6249
{
6250
state = event->xkey.state;
6251
}
6252
6253
if (state & ShiftMask)
6254
{
6255
target = backwardMostMove;
6256
}
6257
else
6258
{
6259
target = currentMove - 1;
6260
}
6261
6262
if (gameMode == ForceMoves)
6263
{
6264
Attention(firstProgramPID);
6265
6266
while (currentMove > target)
6267
{
6268
SendToProgram("undo\n", toFirstProgFP);
6269
currentMove--;
6270
}
6271
}
6272
else
6273
{
6274
currentMove = target;
6275
}
6276
6277
if (gameMode == ForceMoves)
6278
{
6279
whiteTimeRemaining = timeRemaining[0][currentMove];
6280
blackTimeRemaining = timeRemaining[1][currentMove];
6281
}
6282
6283
DisplayClocks(ReDisplayTimers);
6284
DisplayMove(currentMove - 1);
6285
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
6286
}
6287
6288
6289
6290
6291
void
6292
FlipViewProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6293
{
6294
struct DisplayData *player = (*nprms ? &remotePlayer : &localPlayer);
6295
6296
player->flipView = !player->flipView;
6297
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
6298
}
6299
6300
6301
6302
6303
void
6304
SaveGameProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6305
{
6306
char def[MSG_SIZ];
6307
6308
int fromRemotePlayer = *nprms;
6309
6310
if (fromRemotePlayer)
6311
{
6312
DisplayMessage("only opponent may save game", fromRemotePlayer);
6313
return;
6314
}
6315
6316
def[0] = NULLCHAR;
6317
6318
FileNamePopUp("Filename for saved game?", SaveGame);
6319
}
6320
6321
6322
6323
6324
Boolean
6325
SaveGame(char *name)
6326
{
6327
char buf[MSG_SIZ];
6328
int i, len, move = 0;
6329
time_t tm;
6330
6331
if (!filemodeUp) /* if called via FileModeCallback avoid recursion */
6332
{
6333
if ((gameFileFP = fopen(name, "r")) == NULL)
6334
{
6335
strcpy(fmi.mode, "w");
6336
}
6337
else
6338
{
6339
fclose(gameFileFP);
6340
FileModePopUp(name);
6341
return False; /* CHECKME: what should the return value be? */
6342
}
6343
}
6344
6345
if ((gameFileFP = fopen(name, fmi.mode)) == NULL)
6346
{
6347
sprintf(buf, "Can't open %s (mode %s)", name, fmi.mode);
6348
DisplayMessage(buf, False);
6349
return False;
6350
}
6351
6352
tm = time((time_t *) NULL);
6353
6354
fprintf(gameFileFP, "# %s game file -- %s", programName, ctime(&tm));
6355
PrintOpponents(gameFileFP);
6356
6357
for (i = 0; i < currentMove;)
6358
{
6359
if ((i % 5) == 0)
6360
fprintf(gameFileFP, "\n");
6361
6362
fprintf(gameFileFP, "%d. %s ", ++move, parseList[i++]);
6363
6364
if (i >= currentMove)
6365
{
6366
fprintf(gameFileFP, "\n");
6367
break;
6368
}
6369
6370
if ((len = strlen(parseList[i])) == 0)
6371
break;
6372
6373
fprintf(gameFileFP, "%s ", parseList[i++]);
6374
}
6375
6376
fprintf(gameFileFP, "\n");
6377
6378
fclose(gameFileFP);
6379
gameFileFP = NULL;
6380
6381
return True;
6382
}
6383
6384
6385
6386
6387
void
6388
SwitchProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6389
{
6390
if (localPlayer.appData.noShogiProgram)
6391
return;
6392
6393
switch (gameMode)
6394
{
6395
default:
6396
return;
6397
6398
case MachinePlaysBlack:
6399
if (BlackOnMove(forwardMostMove))
6400
{
6401
DisplayMessage("Wait until your turn", False);
6402
return;
6403
}
6404
6405
lastGameMode = gameMode = MachinePlaysWhite;
6406
ModeHighlight();
6407
break;
6408
6409
case BeginningOfGame:
6410
6411
case MachinePlaysWhite:
6412
if (!BlackOnMove(forwardMostMove))
6413
{
6414
DisplayMessage("Wait until your turn", False);
6415
return;
6416
}
6417
6418
if (forwardMostMove == 0)
6419
{
6420
MachineBlackProc(w, event, prms, nprms);
6421
return;
6422
}
6423
6424
lastGameMode = gameMode = MachinePlaysBlack;
6425
ModeHighlight();
6426
break;
6427
}
6428
6429
Attention(firstProgramPID);
6430
SendToProgram("switch\n", toFirstProgFP);
6431
}
6432
6433
6434
6435
6436
void
6437
ForceProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6438
{
6439
int i;
6440
6441
switch (gameMode)
6442
{
6443
case MachinePlaysBlack:
6444
if (BlackOnMove(forwardMostMove))
6445
{
6446
DisplayMessage("Wait until your turn", False);
6447
return;
6448
}
6449
6450
Attention(firstProgramPID);
6451
SendToProgram("force\n", toFirstProgFP);
6452
break;
6453
6454
case MachinePlaysWhite:
6455
if (!BlackOnMove(forwardMostMove))
6456
{
6457
DisplayMessage("Wait until your turn", False);
6458
return;
6459
}
6460
6461
Attention(firstProgramPID);
6462
SendToProgram("force\n", toFirstProgFP);
6463
break;
6464
6465
case BeginningOfGame:
6466
SendToProgram("force\n", toFirstProgFP);
6467
break;
6468
6469
case PlayFromGameFile:
6470
if (readGameXID != 0)
6471
{
6472
XtRemoveTimeOut(readGameXID);
6473
readGameXID = 0;
6474
}
6475
6476
if (gameFileFP != NULL)
6477
{
6478
fclose(gameFileFP);
6479
gameFileFP = NULL;
6480
}
6481
6482
break;
6483
6484
case EndOfGame:
6485
ResurrectShogiProgram();
6486
break;
6487
6488
case EditPosition:
6489
EditPositionDone();
6490
break;
6491
6492
case TwoMachinesPlay:
6493
ShutdownShogiPrograms("");
6494
ResurrectShogiProgram();
6495
return;
6496
6497
default:
6498
return;
6499
}
6500
6501
if ((gameMode == MachinePlaysWhite)
6502
|| (gameMode == MachinePlaysBlack)
6503
|| (gameMode == TwoMachinesPlay)
6504
|| (gameMode == PlayFromGameFile))
6505
{
6506
i = forwardMostMove;
6507
6508
while (i > currentMove)
6509
{
6510
SendToProgram("undo\n", toFirstProgFP);
6511
i--;
6512
}
6513
6514
blackTimeRemaining = timeRemaining[0][currentMove];
6515
whiteTimeRemaining = timeRemaining[1][currentMove];
6516
6517
if (whiteFlag || blackFlag)
6518
{
6519
whiteFlag = blackFlag = 0;
6520
}
6521
6522
DisplayTitle("");
6523
}
6524
6525
lastGameMode = gameMode = ForceMoves;
6526
ModeHighlight();
6527
DisplayClocks(StopTimers);
6528
}
6529
6530
6531
6532
void
6533
HintProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6534
{
6535
int fromRemotePlayer = *nprms;
6536
6537
if (updateRemotePlayer)
6538
{
6539
DisplayMessage("no hints in challenge mode", fromRemotePlayer);
6540
return;
6541
}
6542
6543
if (localPlayer.appData.noShogiProgram)
6544
return;
6545
6546
switch (gameMode)
6547
{
6548
case MachinePlaysBlack:
6549
if (BlackOnMove(forwardMostMove))
6550
{
6551
DisplayMessage("Wait until your turn", False);
6552
return;
6553
}
6554
6555
break;
6556
6557
case BeginningOfGame:
6558
case MachinePlaysWhite:
6559
if (!BlackOnMove(forwardMostMove))
6560
{
6561
DisplayMessage("Wait until your turn", False);
6562
return;
6563
}
6564
6565
break;
6566
6567
default:
6568
DisplayMessage("No hint available", False);
6569
return;
6570
}
6571
6572
Attention(firstProgramPID);
6573
SendToProgram("hint\n", toFirstProgFP);
6574
}
6575
6576
6577
6578
6579
void
6580
PrintPosition(FILE *fp, int move)
6581
{
6582
int i, j, color;
6583
6584
for (i = BOARD_SIZE - 1; i >= 0; i--)
6585
{
6586
for (j = 0; j < BOARD_SIZE; j++)
6587
{
6588
if (pieceIsPromoted[(int)boards[currentMove][i][j]])
6589
fprintf(fp, "%c", '+');
6590
else
6591
fprintf(fp, "%c", ' ');
6592
6593
fprintf(fp, "%c",
6594
pieceToChar[(int)boards[currentMove][i][j]]);
6595
6596
if (j == BOARD_SIZE - 1)
6597
fputc('\n', fp);
6598
}
6599
}
6600
6601
for (color = 0; color <= 1; color++)
6602
{
6603
fprintf(fp, "%i %i %i %i %i %i %i %i\n",
6604
catches[currentMove][color][pawn],
6605
catches[currentMove][color][lance],
6606
catches[currentMove][color][knight],
6607
catches[currentMove][color][silver],
6608
catches[currentMove][color][gold],
6609
catches[currentMove][color][bishop],
6610
catches[currentMove][color][rook],
6611
catches[currentMove][color][king]);
6612
}
6613
6614
if ((gameMode == EditPosition)
6615
? !whitePlaysFirst
6616
: BlackOnMove(forwardMostMove))
6617
{
6618
fprintf(fp, "black to play\n");
6619
}
6620
else
6621
{
6622
fprintf(fp, "white to play\n");
6623
}
6624
}
6625
6626
6627
6628
6629
void
6630
PrintOpponents(FILE *fp)
6631
{
6632
char host_name[MSG_SIZ];
6633
6634
#ifdef HAVE_GETHOSTNAME
6635
gethostname(host_name, MSG_SIZ);
6636
#else
6637
strncpy(host_name, "hostname not available", MSG_SIZ);
6638
#endif
6639
6640
switch (lastGameMode)
6641
{
6642
case MachinePlaysWhite:
6643
fprintf(fp, "# %s@%s vs. %s@%s\n",
6644
localPlayer.appData.firstShogiProgram,
6645
localPlayer.appData.firstHost,
6646
getpwuid(getuid())->pw_name,
6647
host_name);
6648
break;
6649
6650
case MachinePlaysBlack:
6651
fprintf(fp, "# %s@%s vs. %s@%s\n",
6652
getpwuid(getuid())->pw_name,
6653
host_name,
6654
localPlayer.appData.firstShogiProgram,
6655
localPlayer.appData.firstHost);
6656
break;
6657
6658
case TwoMachinesPlay:
6659
fprintf(fp, "# %s@%s vs. %s@%s\n",
6660
localPlayer.appData.secondShogiProgram,
6661
localPlayer.appData.secondHost,
6662
localPlayer.appData.firstShogiProgram,
6663
localPlayer.appData.firstHost);
6664
break;
6665
6666
default:
6667
fprintf(fp, "#\n");
6668
break;
6669
}
6670
}
6671
6672
6673
6674
6675
void
6676
SavePositionProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6677
{
6678
char def[MSG_SIZ];
6679
6680
int fromRemotePlayer = *nprms;
6681
6682
if (fromRemotePlayer)
6683
{
6684
DisplayMessage("only opponent may save game", fromRemotePlayer);
6685
return;
6686
}
6687
6688
def[0] = NULLCHAR;
6689
6690
FileNamePopUp("Filename for saved position?", SavePosition);
6691
}
6692
6693
6694
6695
6696
Boolean
6697
SavePosition(char *name)
6698
{
6699
char buf[MSG_SIZ];
6700
FILE *fp;
6701
time_t tm;
6702
6703
if ((fp = fopen(name, "w")) == NULL)
6704
{
6705
sprintf(buf, "Can't open %s", name);
6706
DisplayMessage(buf, False);
6707
return False;
6708
}
6709
6710
tm = time((time_t *) NULL);
6711
6712
fprintf(fp, "# %s position file -- %s", programName, ctime(&tm));
6713
PrintOpponents(fp);
6714
PrintPosition(fp, currentMove);
6715
fclose(fp);
6716
6717
return True;
6718
}
6719
6720
6721
6722
6723
void
6724
TwoMachinesProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6725
{
6726
int i;
6727
MatchMode matchKind;
6728
6729
int fromRemotePlayer = *nprms;
6730
6731
if (updateRemotePlayer)
6732
{
6733
DisplayMessage("no machine moves in challenge mode",
6734
fromRemotePlayer);
6735
return;
6736
}
6737
6738
if (gameMode == PauseGame)
6739
PauseProc(w, event, prms, nprms);
6740
6741
if (gameMode == PlayFromGameFile)
6742
ForceProc(w, event, prms, nprms);
6743
6744
if ((gameMode == EndOfGame)
6745
|| (gameMode == TwoMachinesPlay)
6746
|| localPlayer.appData.noShogiProgram)
6747
{
6748
return;
6749
}
6750
6751
if (matchMode == MatchFalse)
6752
{
6753
switch (gameMode)
6754
{
6755
case PauseGame:
6756
case PlayFromGameFile:
6757
return;
6758
6759
case MachinePlaysBlack:
6760
case MachinePlaysWhite:
6761
ForceProc(w, event, prms, nprms);
6762
6763
if (gameMode != ForceMoves)
6764
return;
6765
6766
matchKind = MatchOpening;
6767
break;
6768
6769
case ForceMoves:
6770
matchKind = MatchOpening;
6771
break;
6772
6773
case EditPosition:
6774
EditPositionDone();
6775
matchKind = MatchPosition;
6776
break;
6777
6778
case BeginningOfGame:
6779
default:
6780
matchKind = MatchInit;
6781
break;
6782
}
6783
}
6784
else
6785
{
6786
matchKind = matchMode;
6787
}
6788
6789
forwardMostMove = currentMove;
6790
6791
localPlayer.flipView = False;
6792
remotePlayer.flipView = True;
6793
firstMove = False;
6794
DisplayClocks(ResetTimers);
6795
DisplayClocks(StartTimers);
6796
6797
switch (matchKind)
6798
{
6799
case MatchOpening:
6800
if (firstProgramXID == 0)
6801
{
6802
if (localPlayer.appData.loadGameFile == NULL)
6803
{
6804
DisplayMessage("Select game file first", False);
6805
return;
6806
}
6807
6808
InitShogiProgram(localPlayer.appData.firstHost,
6809
localPlayer.appData.firstShogiProgram,
6810
&firstProgramPID, &toFirstProgFP,
6811
&fromFirstProgFP, &firstProgramXID,
6812
&firstSendTime);
6813
6814
if (!LoadGame(localPlayer.appData.loadGameFile))
6815
{
6816
ShutdownShogiPrograms("Bad game file");
6817
return;
6818
}
6819
6820
DrawPosition(localPlayer.boardWidget, NULL, NULL, NULL);
6821
}
6822
6823
InitShogiProgram(localPlayer.appData.secondHost,
6824
localPlayer.appData.secondShogiProgram,
6825
&secondProgramPID, &toSecondProgFP,
6826
&fromSecondProgFP, &secondProgramXID,
6827
&secondSendTime);
6828
6829
if (startedFromSetupPosition)
6830
{
6831
if (whitePlaysFirst)
6832
{
6833
i = 1;
6834
SendToProgram("force\n", toSecondProgFP);
6835
SendBoard(toSecondProgFP, boards[i], catches[i]);
6836
}
6837
else
6838
{
6839
i = 0;
6840
SendBoard(toSecondProgFP, boards[i], catches[i]);
6841
SendToProgram("force\n", toSecondProgFP);
6842
}
6843
}
6844
else
6845
{
6846
i = 0;
6847
SendToProgram("force\n", toSecondProgFP);
6848
}
6849
6850
for (i = backwardMostMove; i < forwardMostMove; i++)
6851
SendToProgram(moveList[i], toSecondProgFP);
6852
6853
lastGameMode = gameMode = TwoMachinesPlay;
6854
ModeHighlight();
6855
firstMove = True;
6856
6857
if (BlackOnMove(forwardMostMove))
6858
SendToProgram(localPlayer.appData.blackString, toSecondProgFP);
6859
else
6860
SendToProgram(localPlayer.appData.whiteString, toFirstProgFP);
6861
6862
break;
6863
6864
case MatchPosition:
6865
if (firstProgramXID == 0)
6866
{
6867
if (localPlayer.appData.loadPositionFile == NULL)
6868
{
6869
DisplayMessage("Select position file first", False);
6870
return;
6871
}
6872
6873
InitShogiProgram(localPlayer.appData.firstHost,
6874
localPlayer.appData.firstShogiProgram,
6875
&firstProgramPID, &toFirstProgFP,
6876
&fromFirstProgFP, &firstProgramXID,
6877
&firstSendTime);
6878
6879
if (!LoadPosition(localPlayer.appData.loadPositionFile))
6880
return;
6881
}
6882
6883
InitShogiProgram(localPlayer.appData.secondHost,
6884
localPlayer.appData.secondShogiProgram,
6885
&secondProgramPID, &toSecondProgFP,
6886
&fromSecondProgFP, &secondProgramXID,
6887
&secondSendTime);
6888
6889
if (whitePlaysFirst)
6890
SendToProgram("force\n", toSecondProgFP);
6891
6892
SendCurrentBoard(toSecondProgFP);
6893
lastGameMode = gameMode = TwoMachinesPlay;
6894
ModeHighlight();
6895
firstMove = True;
6896
6897
if (BlackOnMove(forwardMostMove))
6898
SendToProgram(localPlayer.appData.blackString, toSecondProgFP);
6899
else
6900
SendToProgram(localPlayer.appData.whiteString, toFirstProgFP);
6901
6902
break;
6903
6904
case MatchInit:
6905
InitPosition(True);
6906
6907
if (firstProgramXID == 0)
6908
{
6909
InitShogiProgram(localPlayer.appData.firstHost,
6910
localPlayer.appData.firstShogiProgram,
6911
&firstProgramPID, &toFirstProgFP,
6912
&fromFirstProgFP, &firstProgramXID,
6913
&firstSendTime);
6914
}
6915
6916
InitShogiProgram(localPlayer.appData.secondHost,
6917
localPlayer.appData.secondShogiProgram,
6918
&secondProgramPID, &toSecondProgFP,
6919
&fromSecondProgFP, &secondProgramXID,
6920
&secondSendTime);
6921
6922
lastGameMode = gameMode = TwoMachinesPlay;
6923
ModeHighlight();
6924
SendToProgram(localPlayer.appData.blackString, toSecondProgFP);
6925
6926
default:
6927
break;
6928
}
6929
6930
if (!firstSendTime || !secondSendTime)
6931
{
6932
DisplayClocks(ResetTimers);
6933
timeRemaining[0][forwardMostMove] = blackTimeRemaining;
6934
timeRemaining[1][forwardMostMove] = whiteTimeRemaining;
6935
}
6936
6937
DisplayClocks(StartTimers);
6938
}
6939
6940
6941
6942
6943
void
6944
PauseProc(Widget w, XEvent *event, String *prms, Cardinal *nprms)
6945
{
6946
static GameMode previous_mode = PauseGame;
6947
6948
switch (gameMode)
6949
{
6950
case ForceMoves:
6951
case EndOfGame:
6952
case EditPosition:
6953
default:
6954
return;
6955
6956
case PauseGame:
6957
gameMode = previous_mode;
6958
ModeHighlight();
6959
previous_mode = PauseGame;
6960
DisplayClocks(StartTimers);
6961
DisplayMessage("", False);
6962
6963
if (updateRemotePlayer)
6964
DisplayMessage("", True);
6965
break;
6966
6967
case PlayFromGameFile:
6968
if (readGameXID == 0)
6969
{
6970
readGameXID =
6971
XtAppAddTimeOut(appContext,
6972
(int)(1000 * localPlayer.appData.timeDelay),
6973
(XtTimerCallbackProc) ReadGameFile, NULL);
6974
}
6975
else
6976
{
6977
XtRemoveTimeOut(readGameXID);
6978
readGameXID = 0;
6979
}
6980
6981
DisplayMessage("Pausing", False);
6982
6983
if (updateRemotePlayer)
6984
DisplayMessage("Pausing", True);
6985
6986
break;
6987
6988
case BeginningOfGame:
6989
case MachinePlaysBlack:
6990
case MachinePlaysWhite:
6991
case TwoMachinesPlay:
6992
if (forwardMostMove == 0) /* Don't pause if no one has moved. */
6993
return;
6994
6995
if (((gameMode == MachinePlaysWhite)
6996
&& !BlackOnMove(forwardMostMove))
6997
|| ((gameMode == MachinePlaysBlack) &&
6998
BlackOnMove(forwardMostMove)))
6999
{
7000
DisplayClocks(StopTimers);
7001
}
7002
7003
previous_mode = gameMode;
7004
gameMode = PauseGame;
7005
ModeHighlight();
7006
DisplayClocks(StopTimers);
7007
DisplayMessage("Pausing", False);
7008
7009
if (updateRemotePlayer)
7010
DisplayMessage("Pausing", True);
7011
7012
break;
7013
}
7014
}
7015
7016
7017
7018
7019
void
7020
Iconify(Widget w, XEvent *event, String *prms, Cardinal *nprms)
7021
{
7022
Arg args[1];
7023
7024
fromX = fromY = -1;
7025
7026
XtSetArg(args[0], XtNiconic, True);
7027
XtSetValues(localPlayer.shellWidget, args, 1);
7028
}
7029
7030
7031
7032
7033
void
7034
SendToProgram(char *message, FILE *fp)
7035
{
7036
if (fp == NULL)
7037
return;
7038
7039
lastMsgFP = fp;
7040
7041
if (xshogiDebug)
7042
{
7043
fprintf(stderr, "Sending to %s: %s\n",
7044
((fp == toFirstProgFP) ? "first" : "second"), message);
7045
}
7046
7047
if (message[strlen(message) - 1] != '\n')
7048
fprintf(fp, "\n%s\n", message);
7049
else
7050
fputs(message, fp);
7051
7052
fflush(fp);
7053
}
7054
7055
7056
7057
7058
void
7059
ReceiveFromProgram(FILE *fp, int *source, XtInputId *id)
7060
{
7061
char message[MSG_SIZ], *end_str, *number, *name;
7062
extern const char *const sys_errlist[];
7063
7064
if (fgets(message, MSG_SIZ, fp) == NULL)
7065
{
7066
if (fp == fromFirstProgFP)
7067
{
7068
number = "first";
7069
name = localPlayer.appData.firstShogiProgram;
7070
}
7071
else if (fp == fromSecondProgFP)
7072
{
7073
number = "second";
7074
name = localPlayer.appData.secondShogiProgram;
7075
}
7076
else
7077
{
7078
return;
7079
}
7080
7081
if (ferror(fp) == 0)
7082
{
7083
sprintf(message, "%s shogi program (%s) exited unexpectedly",
7084
number, name);
7085
fprintf(stderr, "%s: %s\n", programName, message);
7086
}
7087
else
7088
{
7089
sprintf(message,
7090
"error reading from %s shogi program (%s): %s",
7091
number, name, sys_errlist[ferror(fp)]);
7092
fprintf(stderr, "%s: %s\n", programName, message);
7093
}
7094
7095
return;
7096
}
7097
7098
if ((end_str = (char *)strchr(message, '\r')) != NULL)
7099
*end_str = NULLCHAR;
7100
7101
if ((end_str = (char *)strchr(message, '\n')) != NULL)
7102
*end_str = NULLCHAR;
7103
7104
if (xshogiDebug || localPlayer.appData.debugMode)
7105
{
7106
fprintf(stderr, "Received from %s: %s\n",
7107
((fp == fromFirstProgFP) ? "first" : "second"), message);
7108
}
7109
7110
HandleMachineMove(message, fp);
7111
}
7112
7113
7114
7115
7116
void
7117
SendSearchDepth(FILE *fp)
7118
{
7119
char message[MSG_SIZ];
7120
7121
if (localPlayer.appData.searchDepth <= 0)
7122
return;
7123
7124
sprintf(message, "depth\n%d\nhelp\n", localPlayer.appData.searchDepth);
7125
/* Note kludge: "help" command forces gnushogi to print
7126
* out something that ends with a newline. */
7127
SendToProgram(message, fp);
7128
}
7129
7130
7131
7132
7133
void
7134
DisplayMessage(char *message, int toRemotePlayer)
7135
{
7136
Arg arg;
7137
7138
XtSetArg(arg, XtNlabel, message);
7139
7140
if (!toRemotePlayer)
7141
XtSetValues(localPlayer.messageWidget, &arg, 1);
7142
7143
if (updateRemotePlayer && toRemotePlayer)
7144
XtSetValues(remotePlayer.messageWidget, &arg, 1);
7145
}
7146
7147
7148
7149
7150
void
7151
DisplayName(char *name)
7152
{
7153
Arg arg;
7154
7155
XtSetArg(arg, XtNlabel, name);
7156
XtSetValues(localPlayer.titleWidget, &arg, 1);
7157
7158
if (updateRemotePlayer)
7159
XtSetValues(remotePlayer.titleWidget, &arg, 1);
7160
}
7161
7162
7163
7164
7165
void SendTimeRemaining(FILE *fp)
7166
{
7167
char message[MSG_SIZ];
7168
long comtime, opptime;
7169
7170
if (BlackOnMove(forwardMostMove) == (fp == toFirstProgFP))
7171
{
7172
comtime = blackTimeRemaining;
7173
opptime = whiteTimeRemaining;
7174
}
7175
else
7176
{
7177
comtime = whiteTimeRemaining;
7178
opptime = blackTimeRemaining;
7179
}
7180
7181
if (comtime <= 0)
7182
comtime = 1000;
7183
7184
if (opptime <= 0)
7185
opptime = 1000;
7186
7187
sprintf(message, "time %ld\n", comtime / 10);
7188
SendToProgram(message, fp);
7189
sprintf(message, "otime %ld\n", opptime / 10);
7190
SendToProgram(message, fp);
7191
}
7192
7193
7194
7195
7196
void DisplayMove(int moveNumber)
7197
{
7198
char message[MSG_SIZ];
7199
7200
if (moveNumber < 0)
7201
{
7202
if (moveNumber == forwardMostMove - 1)
7203
DisplayMessage(endMessage, False);
7204
else
7205
DisplayMessage("", False);
7206
}
7207
else
7208
{
7209
sprintf(message, "%d. %s%s %s",
7210
(moveNumber / 2 + 1),
7211
(BlackOnMove(moveNumber) ? "" : "... "),
7212
parseList[moveNumber],
7213
(moveNumber == (forwardMostMove - 1)) ? endMessage : "");
7214
DisplayMessage(message, False);
7215
}
7216
}
7217
7218
7219
7220
7221
void DisplayTitle(char *title)
7222
{
7223
Arg arg;
7224
7225
XtSetArg(arg, XtNlabel, title);
7226
XtSetValues(localPlayer.titleWidget, &arg, 1);
7227
}
7228
7229
7230
7231
7232
/* CHECKME: does this work?
7233
* This routine sends a SIGINT (^C interrupt) to gnushogi to awaken it
7234
* if it might be busy thinking on our time. This normally isn't needed,
7235
* but is useful on systems where the FIONREAD ioctl doesn't work since
7236
* on those systems the gnushogi feature that lets you interrupt its thinking
7237
* just by typing a command does not work.
7238
*
7239
* In the future, similar code could be used to stop gnushogi and make
7240
* it move immediately when it is thinking about its own move; this could
7241
* be useful if we want to make Backward or ForceMoves work while gnushogi
7242
* is thinking.
7243
*/
7244
7245
void
7246
Attention(int pid)
7247
{
7248
#if !defined(FIONREAD)
7249
if (localPlayer.appData.noShogiProgram || (pid == 0))
7250
return;
7251
7252
switch (gameMode)
7253
{
7254
case MachinePlaysBlack:
7255
case MachinePlaysWhite:
7256
case TwoMachinesPlay:
7257
if ((forwardMostMove > backwardMostMove + 1) && maybeThinking)
7258
{
7259
if (xshogiDebug || localPlayer.appData.debugMode)
7260
{
7261
fprintf(stderr, "Sending SIGINT to %s\n",
7262
((pid == firstProgramPID) ? "first" : "second"));
7263
}
7264
7265
(void)kill(pid, SIGINT); /* stop it thinking */
7266
}
7267
break;
7268
7269
default:
7270
break; /* CHECKME: is this OK? */
7271
}
7272
#endif /* !defined(FIONREAD) */
7273
}
7274
7275
7276
7277
7278
void
7279
CheckFlags(void)
7280
{
7281
if (blackTimeRemaining <= 0)
7282
{
7283
if (!blackFlag)
7284
{
7285
blackFlag = True;
7286
7287
if (whiteFlag)
7288
DisplayName(" Both flags have fallen");
7289
else
7290
DisplayName(" Black's flag has fallen");
7291
}
7292
}
7293
7294
if (whiteTimeRemaining <= 0)
7295
{
7296
if (!whiteFlag)
7297
{
7298
whiteFlag = True;
7299
7300
if (blackFlag)
7301
DisplayName(" Both flags have fallen");
7302
else
7303
DisplayName(" White's flag has fallen");
7304
}
7305
}
7306
}
7307
7308
7309
7310
7311
void
7312
CheckTimeControl(void)
7313
{
7314
if (!localPlayer.appData.clockMode)
7315
return;
7316
7317
if (forwardMostMove == 0)
7318
return;
7319
7320
/*
7321
* Add time to clocks when time control is achieved.
7322
*/
7323
7324
if ((forwardMostMove % (localPlayer.appData.movesPerSession * 2)) == 0)
7325
{
7326
blackTimeRemaining += timeControl;
7327
whiteTimeRemaining += timeControl;
7328
}
7329
}
7330
7331
7332
7333
7334
void
7335
DisplayLabels(void)
7336
{
7337
DisplayTimerLabel(localPlayer.blackTimerWidget, "Black",
7338
blackTimeRemaining);
7339
DisplayTimerLabel(localPlayer.whiteTimerWidget, "White",
7340
whiteTimeRemaining);
7341
7342
if (updateRemotePlayer)
7343
{
7344
DisplayTimerLabel(remotePlayer.blackTimerWidget, "Black",
7345
blackTimeRemaining);
7346
DisplayTimerLabel(remotePlayer.whiteTimerWidget, "White",
7347
whiteTimeRemaining);
7348
}
7349
}
7350
7351
7352
7353
7354
#ifdef HAVE_GETTIMEOFDAY
7355
static struct timeval tickStartTV;
7356
static int tickLength;
7357
7358
int
7359
PartialTickLength(void)
7360
{
7361
struct timeval tv;
7362
struct timezone tz;
7363
int ptl;
7364
7365
gettimeofday(&tv, &tz);
7366
ptl = ((tv.tv_sec - tickStartTV.tv_sec) * 1000000 +
7367
(tv.tv_usec - tickStartTV.tv_usec) + 500) / 1000;
7368
7369
if (ptl > tickLength)
7370
ptl = tickLength;
7371
7372
return ptl;
7373
}
7374
#else /* !HAVE_GETTIMEOFDAY */
7375
#define tickLength 1000
7376
#endif /* HAVE_GETTIMEOFDAY */
7377
7378
7379
7380
7381
/*
7382
* DisplayClocks manages the game clocks.
7383
*
7384
* In tournament play, white starts the clock and then black makes a move.
7385
* We give the human user a slight advantage if he is playing black---the
7386
* clocks don't run until he makes his first move, so it takes zero time.
7387
* Also, DisplayClocks doesn't account for network lag so it could get out
7388
* of sync with GNU Shogi's clock -- but then, referees are always right.
7389
*/
7390
7391
void
7392
DisplayClocks(int clock_mode)
7393
{
7394
#ifdef HAVE_GETTIMEOFDAY
7395
struct timezone tz;
7396
#endif /* HAVE_GETTIMEOFDAY */
7397
7398
long timeRemaining;
7399
7400
switch (clock_mode)
7401
{
7402
case ResetTimers:
7403
/* Stop clocks and reset to a fresh time control */
7404
if (timerXID != 0)
7405
{
7406
XtRemoveTimeOut(timerXID);
7407
timerXID = 0;
7408
}
7409
7410
blackTimeRemaining = timeControl;
7411
whiteTimeRemaining = timeControl;
7412
7413
if (blackFlag || whiteFlag)
7414
{
7415
DisplayName("");
7416
blackFlag = whiteFlag = False;
7417
}
7418
7419
DisplayLabels();
7420
break;
7421
7422
case DecrementTimers:
7423
/* Decrement running clock to next 1-second boundary */
7424
if (gameMode == PauseGame)
7425
return;
7426
7427
timerXID = 0;
7428
7429
if (!localPlayer.appData.clockMode)
7430
return;
7431
7432
if (BlackOnMove(forwardMostMove))
7433
{
7434
timeRemaining = (blackTimeRemaining -= tickLength);
7435
}
7436
else
7437
{
7438
timeRemaining = (whiteTimeRemaining -= tickLength);
7439
}
7440
7441
DisplayLabels();
7442
CheckFlags();
7443
7444
#ifdef HAVE_GETTIMEOFDAY
7445
tickLength = (((timeRemaining <= 1000) && (timeRemaining > 0))
7446
? 100 : 1000);
7447
gettimeofday(&tickStartTV, &tz);
7448
#endif /* HAVE_GETTIMEOFDAY */
7449
7450
timerXID =
7451
XtAppAddTimeOut(appContext, tickLength,
7452
(XtTimerCallbackProc) DisplayClocks,
7453
(XtPointer) DecrementTimers);
7454
break;
7455
7456
case SwitchTimers:
7457
/* A player has just moved, so stop the previously running
7458
clock and start the other one. */
7459
7460
if (timerXID != 0)
7461
{
7462
XtRemoveTimeOut(timerXID);
7463
timerXID = 0;
7464
7465
#ifdef HAVE_GETTIMEOFDAY
7466
if (localPlayer.appData.clockMode)
7467
{
7468
if (BlackOnMove(forwardMostMove))
7469
whiteTimeRemaining -= PartialTickLength();
7470
else
7471
blackTimeRemaining -= PartialTickLength();
7472
CheckFlags();
7473
}
7474
#endif /* HAVE_GETTIMEOFDAY */
7475
}
7476
7477
CheckTimeControl();
7478
DisplayLabels();
7479
7480
if (!localPlayer.appData.clockMode)
7481
return;
7482
7483
if ((gameMode == PauseGame)
7484
&& ((pausePreviousMode == MachinePlaysBlack)
7485
|| (pausePreviousMode == MachinePlaysWhite)))
7486
{
7487
return;
7488
}
7489
7490
timeRemaining = (BlackOnMove(forwardMostMove)
7491
? blackTimeRemaining : whiteTimeRemaining);
7492
7493
#ifdef HAVE_GETTIMEOFDAY
7494
tickLength = (((timeRemaining <= 1000) && (timeRemaining > 0))
7495
? (((timeRemaining - 1) % 100) + 1)
7496
: (((timeRemaining - 1) % 1000) + 1));
7497
7498
if (tickLength <= 0)
7499
tickLength += 1000;
7500
7501
gettimeofday(&tickStartTV, &tz);
7502
7503
#endif /* HAVE_GETTIMEOFDAY */
7504
timerXID =
7505
XtAppAddTimeOut(appContext, tickLength,
7506
(XtTimerCallbackProc) DisplayClocks,
7507
(XtPointer) DecrementTimers);
7508
break;
7509
7510
case ReDisplayTimers:
7511
/* Display current clock values */
7512
DisplayLabels();
7513
break;
7514
7515
case StopTimers:
7516
/* Stop both clocks */
7517
if (timerXID == 0)
7518
return;
7519
7520
XtRemoveTimeOut(timerXID);
7521
timerXID = 0;
7522
7523
if (!localPlayer.appData.clockMode)
7524
return;
7525
7526
#ifdef HAVE_GETTIMEOFDAY
7527
if (BlackOnMove(forwardMostMove))
7528
blackTimeRemaining -= PartialTickLength();
7529
else
7530
whiteTimeRemaining -= PartialTickLength();
7531
CheckFlags();
7532
DisplayLabels();
7533
#endif /* HAVE_GETTIMEOFDAY */
7534
break;
7535
7536
case StartTimers:
7537
/* Start clock of player on move, if not already running. */
7538
if (timerXID != 0)
7539
return;
7540
7541
DisplayLabels();
7542
7543
if (!localPlayer.appData.clockMode)
7544
return;
7545
7546
timeRemaining = (BlackOnMove(forwardMostMove)
7547
? blackTimeRemaining : whiteTimeRemaining);
7548
7549
if (timeRemaining == 0)
7550
return;
7551
7552
#ifdef HAVE_GETTIMEOFDAY
7553
tickLength = (((timeRemaining <= 1000) && (timeRemaining > 0))
7554
? (((timeRemaining - 1) % 100) + 1)
7555
: (((timeRemaining - 1) % 1000) + 1));
7556
7557
if (tickLength <= 0)
7558
tickLength += 1000;
7559
7560
gettimeofday(&tickStartTV, &tz);
7561
#endif /* HAVE_GETTIMEOFDAY */
7562
7563
timerXID =
7564
XtAppAddTimeOut(appContext, tickLength,
7565
(XtTimerCallbackProc) DisplayClocks,
7566
(XtPointer)DecrementTimers);
7567
break;
7568
}
7569
}
7570
7571
7572
7573
7574
void
7575
DisplayTimerLabel(Widget w, char *color, long int timer)
7576
{
7577
char buf[MSG_SIZ];
7578
Arg args[3];
7579
struct DisplayData *player;
7580
7581
player = (((w == localPlayer.blackTimerWidget)
7582
|| (w == localPlayer.whiteTimerWidget))
7583
? &localPlayer : &remotePlayer);
7584
7585
if (localPlayer.appData.clockMode)
7586
{
7587
sprintf(buf, "%s: %s", color, TimeString(timer));
7588
XtSetArg(args[0], XtNlabel, buf);
7589
}
7590
else
7591
{
7592
XtSetArg(args[0], XtNlabel, color);
7593
}
7594
7595
if (((color[0] == 'W') && BlackOnMove(forwardMostMove))
7596
|| ((color[0] == 'B') && !BlackOnMove(forwardMostMove)))
7597
{
7598
XtSetArg(args[1], XtNbackground, player->timerForegroundPixel);
7599
XtSetArg(args[2], XtNforeground, player->timerBackgroundPixel);
7600
}
7601
else
7602
{
7603
XtSetArg(args[1], XtNbackground, player->timerBackgroundPixel);
7604
XtSetArg(args[2], XtNforeground, player->timerForegroundPixel);
7605
}
7606
7607
XtSetValues(w, args, 3);
7608
}
7609
7610
7611
7612
7613
char *
7614
TimeString(long tm)
7615
{
7616
int second, minute, hour, day;
7617
char *sign = "";
7618
static char buf[32];
7619
7620
if ((tm > 0) && (tm <= 900))
7621
{
7622
/* convert milliseconds to tenths, rounding up */
7623
sprintf(buf, " 0.%1ld ", (tm + 99) / 100);
7624
return buf;
7625
}
7626
7627
/* convert milliseconds to seconds, rounding up */
7628
tm = (tm + 999) / 1000;
7629
7630
if (tm < 0)
7631
{
7632
sign = "-";
7633
tm = -tm;
7634
}
7635
7636
if (tm >= (60 * 60 * 24))
7637
{
7638
day = (int)(tm / (60 * 60 * 24));
7639
tm -= day * 60 * 60 * 24;
7640
}
7641
else
7642
{
7643
day = 0;
7644
}
7645
7646
if (tm >= (60 * 60))
7647
{
7648
hour = (int)(tm / (60 * 60));
7649
tm -= hour * 60 * 60;
7650
}
7651
else
7652
{
7653
hour = 0;
7654
}
7655
7656
if (tm >= 60)
7657
{
7658
minute = (int)(tm / 60);
7659
tm -= minute * 60;
7660
}
7661
else
7662
{
7663
minute = 0;
7664
}
7665
7666
second = tm % 60;
7667
7668
if (day > 0)
7669
{
7670
sprintf(buf, " %s%d:%02d:%02d:%02d ",
7671
sign, day, hour, minute, second);
7672
}
7673
else if (hour > 0)
7674
{
7675
sprintf(buf, " %s%d:%02d:%02d ",
7676
sign, hour, minute, second);
7677
}
7678
else
7679
{
7680
sprintf(buf, " %s%2d:%02d ",
7681
sign, minute, second);
7682
}
7683
7684
return buf;
7685
}
7686
7687
7688
7689
7690
void
7691
Usage(void)
7692
{
7693
fprintf(stderr, "Usage: %s\n", programName);
7694
fprintf(stderr, "\tstandard Xt options\n");
7695
fprintf(stderr, "\t-iconic\n");
7696
fprintf(stderr, "\t-tc or -timeControl minutes[:seconds]\n");
7697
fprintf(stderr, "\t-gi or -gameIn (True | False)\n");
7698
fprintf(stderr, "\t-mps or -movesPerSession moves\n");
7699
fprintf(stderr, "\t-st or -searchTime minutes[:seconds]\n");
7700
fprintf(stderr, "\t-sd or -searchDepth number\n");
7701
fprintf(stderr, "\t-clock or -clockMode (True | False)\n");
7702
fprintf(stderr, "\t-td or -timeDelay seconds\n");
7703
7704
fprintf(stderr, "\t-nsp or -noShogiProgram (True | False)\n");
7705
fprintf(stderr, "\t-fsp or -firstShogiProgram program_name\n");
7706
fprintf(stderr, "\t-ssp or -secondShogiProgram program_name\n");
7707
fprintf(stderr, "\t-fh or -firstHost host_name\n");
7708
fprintf(stderr, "\t-sh or -secondHost host_name\n");
7709
fprintf(stderr, "\t-rsh or -remoteShell shell_name\n");
7710
fprintf(stderr,
7711
"\t-mm or -matchMode (False | Init | Position | Opening)\n");
7712
fprintf(stderr, "\t-lgf or -loadGameFile file_name\n");
7713
fprintf(stderr, "\t-lpf or -loadPositionFile file_name\n");
7714
fprintf(stderr, "\t-sgf or -saveGameFile file_name\n");
7715
fprintf(stderr, "\t-spf or -savePositionFile file_name\n");
7716
fprintf(stderr, "\t-size or -boardSize (Large | Medium | Small)\n");
7717
fprintf(stderr, "\t-coords or -showCoords (True | False)\n");
7718
fprintf(stderr, "\t-mono or -monoMode (True | False)\n");
7719
fprintf(stderr, "\t-bpc or -blackPieceColor color\n");
7720
fprintf(stderr, "\t-wpc or -whitePieceColor color\n");
7721
fprintf(stderr, "\t-lsc or -lightSquareColor color\n");
7722
fprintf(stderr, "\t-dsc or -darkSquareColor color\n");
7723
fprintf(stderr, "\t-wps or -westernPieceSet (True | False)\n");
7724
fprintf(stderr, "\t-debug or -debugMode (True | False)\n");
7725
exit(2);
7726
}
7727
7728
7729
7730
void
7731
CatchPipeSignal(int dummy)
7732
{
7733
char message[MSG_SIZ];
7734
7735
sprintf(message,
7736
"%s shogi program (%s) exited unexpectedly",
7737
((lastMsgFP == toFirstProgFP) ? "first" : "second"),
7738
((lastMsgFP == toFirstProgFP)
7739
? localPlayer.appData.firstShogiProgram
7740
: localPlayer.appData.secondShogiProgram));
7741
fprintf(stderr, "%s: %s\n", programName, message);
7742
ShutdownShogiPrograms(message);
7743
return;
7744
}
7745
Loggerhead is a web-based interface for Breezy
Version: 2.0.1