Small fixes
[vchess.git] / client / src / variants / Wormhole1.js
1 import { ChessRules } from "@/base_rules";
2 import { Wormhole2Rules } from "@/variants/Wormhole2";
3
4 export class Wormhole1Rules extends Wormhole2Rules {
5
6 static get PawnSpecs() {
7 return Object.assign(
8 {},
9 ChessRules.PawnSpecs,
10 { promotions: [V.LION, V.CHAMPION, V.WIZARD, V.KNIGHT] }
11 );
12 }
13
14 static get LION() {
15 return 'm';
16 }
17 static get WIZARD() {
18 return 'w';
19 }
20 static get CHAMPION() {
21 return 'c';
22 }
23
24 static get PIECES() {
25 return [V.PAWN, V.CHAMPION, V.KNIGHT, V.WIZARD, V.LION, V.KING];
26 }
27
28 getPpath(b) {
29 if (b[0] == 'x') return "Wormhole/hole";
30 if ([V.LION, V.CHAMPION, V.WIZARD].includes(b[1]))
31 return "Wormhole/" + b;
32 return b;
33 }
34
35 static get steps() {
36 return {
37 w: [
38 [ [-2, 0], [-1, -1] ],
39 [ [-2, 0], [-1, 1] ],
40 [ [0, -2], [-1, -1] ],
41 [ [0, 2], [-1, 1] ],
42 [ [0, -2], [1, -1] ],
43 [ [0, 2], [1, 1] ],
44 [ [2, 0], [1, -1] ],
45 [ [2, 0], [1, 1] ]
46 ],
47 d: [
48 [-2, 0],
49 [0, -2],
50 [2, 0],
51 [0, 2]
52 ],
53 a: [
54 [2, 2],
55 [2, -2],
56 [-2, 2],
57 [-2, -2]
58 ],
59 f: [
60 [-1, -1],
61 [-1, 1],
62 [1, -1],
63 [1, 1]
64 ],
65 z: [
66 [-1, 0],
67 [1, 0],
68 [0, -1],
69 [0, 1]
70 ],
71 n: Wormhole2Rules.steps[V.KNIGHT],
72 k: Wormhole2Rules.steps[V.KING]
73 };
74 }
75
76 static GenRandInitFen(options) {
77 if (options.randomness == 0)
78 return "cnwmkwnc/pppppppp/8/8/8/8/PPPPPPPP/CNWMKWNC w 0";
79
80 // Mapping new --> standard:
81 const piecesMap = {
82 'r': 'c',
83 'n': 'n',
84 'b': 'w',
85 'q': 'm',
86 'k': 'k'
87 };
88
89 const baseFen = ChessRules.GenRandInitFen(options);
90 return (
91 baseFen.substr(0, 8).split('').map(p => piecesMap[p]).join('') +
92 baseFen.substr(8, 27) +
93 baseFen.substr(35, 8).toLowerCase().split('')
94 .map(p => piecesMap[p]).join('').toUpperCase() +
95 " w 0"
96 );
97 }
98
99 getPotentialMovesFrom(sq) {
100 switch (this.getPiece(sq[0], sq[1])) {
101 case V.PAWN: return super.getPotentialPawnMoves(sq);
102 case V.CHAMPION: return this.getPotentialChampionMoves(sq);
103 case V.KNIGHT: return super.getPotentialKnightMoves(sq);
104 case V.WIZARD: return this.getPotentialWizardMoves(sq);
105 case V.LION: return this.getPotentialLionMoves(sq);
106 case V.KING: return super.getPotentialKingMoves(sq);
107 }
108 return [];
109 }
110
111 getJumpMoves([x, y], steps, onlyTake) {
112 let moves = [];
113 for (let step of steps) {
114 const sq = this.getSquareAfter([x,y], step);
115 if (sq &&
116 (
117 (!onlyTake && this.board[sq[0]][sq[1]] == V.EMPTY) ||
118 (this.board[sq[0]][sq[1]] != V.EMPTY && this.canTake([x, y], sq))
119 )
120 ) {
121 moves.push(this.getBasicMove([x, y], sq));
122 }
123 }
124 return moves;
125 }
126
127 getPotentialChampionMoves(sq) {
128 const steps = V.steps['d'].concat(V.steps['a']).concat(V.steps['z']);
129 return this.getJumpMoves(sq, steps);
130 }
131
132 getPotentialWizardMoves(sq) {
133 const steps = V.steps['w'].concat(V.steps['f']);
134 return this.getJumpMoves(sq, steps);
135 }
136
137 getPotentialLionMoves(sq) {
138 let steps = V.steps['d'].concat(V.steps['a']);
139 const moves1 = this.getJumpMoves(sq, steps);
140 steps = V.steps['f'].concat(V.steps['z']);
141 const moves2 = this.getJumpMoves(sq, steps, "onlyTake");
142 return moves1.concat(moves2);
143 }
144
145 isAttacked(sq, color) {
146 return (
147 super.isAttackedByPawn(sq, color) ||
148 this.isAttackedByChampion(sq, color) ||
149 super.isAttackedByKnight(sq, color) ||
150 this.isAttackedByWizard(sq, color) ||
151 this.isAttackedByLion(sq, color) ||
152 super.isAttackedByKing(sq, color)
153 );
154 }
155
156 isAttackedByWizard(sq, color) {
157 return (
158 this.isAttackedByJump(sq, color, V.WIZARD, V.steps['f']) ||
159 // NOTE: wizard attack is not symmetric in this variant:
160 // steps order need to be reversed.
161 this.isAttackedByJump(
162 sq,
163 color,
164 V.WIZARD,
165 V.steps['w'].map(s => s.reverse())
166 )
167 );
168 }
169
170 isAttackedByChampion(sq, color) {
171 const steps = V.steps['d'].concat(V.steps['a']).concat(V.steps['z']);
172 return this.isAttackedByJump(sq, color, V.CHAMPION, steps);
173 }
174
175 isAttackedByLion(sq, color) {
176 const steps = V.steps['d'].concat(V.steps['a'])
177 .concat(V.steps['f']).concat(V.steps['z']);
178 return this.isAttackedByJump(sq, color, V.LION, steps);
179 }
180
181 static get VALUES() {
182 return {
183 p: 1,
184 n: 3,
185 c: 8,
186 m: 9,
187 w: 3,
188 k: 1000
189 };
190 }
191
192 };