After base_rules refactoring. Still a few issues (Dark...)
[xogo.git] / variants / Absorption / class.js
1 import ChessRules from "/base_rules.js";
2
3 export default class AbsorptionRules extends ChessRules {
4
5 static get Options() {
6 return {
7 select: C.Options.select,
8 check: [],
9 styles: [
10 "balance",
11 "capture",
12 "cylinder",
13 "dark",
14 "doublemove",
15 "progressive",
16 "recycle",
17 "rifle",
18 "teleport",
19 "zen"
20 ]
21 };
22 }
23
24 pieces(color) {
25 let fusions = {
26 // amazon
27 'a': {
28 "class": "amazon",
29 moves: [
30 {
31 steps: [
32 [0, 1], [0, -1], [1, 0], [-1, 0],
33 [1, 1], [1, -1], [-1, 1], [-1, -1]
34 ]
35 },
36 {
37 steps: [
38 [1, 2], [1, -2], [-1, 2], [-1, -2],
39 [2, 1], [-2, 1], [2, -1], [-2, -1]
40 ],
41 range: 1
42 }
43 ]
44 },
45 // empress
46 'e': {
47 "class": "empress",
48 steps: [
49 [1, 2], [1, -2], [-1, 2], [-1, -2],
50 [2, 1], [-2, 1], [2, -1], [-2, -1]
51 ],
52 },
53 // princess
54 'b': {
55 "class": "bishop",
56 steps: [[1, 1], [1, -1], [-1, 1], [-1, -1]]
57 }
58 };
59 return Object.assign(fusions, super.pieces(color));
60 }
61
62 static get MergeComposed() {
63 return {
64 "be": "a",
65 "bs": "s",
66 "er": "e",
67 "rs": "a",
68 "eq": "a",
69 "qs": "a",
70 "ee": "e",
71 "es": "a",
72 "ss": "s"
73 };
74 }
75
76 static Fusion(p1, p2) {
77 if (p1 == V.KING) return p1;
78 if (p1 == V.PAWN) return p2;
79 if (p2 == V.PAWN) return p1;
80 if ([p1, p2].includes(V.KNIGHT)) {
81 if ([p1, p2].includes(V.QUEEN)) return V.QN;
82 if ([p1, p2].includes(V.ROOK)) return V.RN;
83 if ([p1, p2].includes(V.BISHOP)) return V.BN;
84 // p1 or p2 already have knight + other piece
85 return (p1 == V.KNIGHT ? p2 : p1);
86 }
87 if ([p1, p2].includes(V.QN)) return V.QN;
88 for (let p of [p1, p2]) {
89 if ([V.BN, V.RN].includes(p))
90 return V.MergeComposed[[p1, p2].sort().join("")];
91 }
92 // bishop + rook, or queen + [bishop or rook]
93 return V.QUEEN;
94 }
95
96 getPotentialMovesFrom(sq) {
97 let moves = [];
98 const piece = this.getPiece(sq[0], sq[1]);
99 switch (piece) {
100 case V.RN:
101 moves =
102 super.getPotentialRookMoves(sq).concat(
103 super.getPotentialKnightMoves(sq));
104 break;
105 case V.BN:
106 moves =
107 super.getPotentialBishopMoves(sq).concat(
108 super.getPotentialKnightMoves(sq));
109 break;
110 case V.QN:
111 moves =
112 super.getPotentialQueenMoves(sq).concat(
113 super.getPotentialKnightMoves(sq));
114 break;
115 default:
116 moves = super.getPotentialMovesFrom(sq);
117 }
118 // Filter out capturing promotions (except one),
119 // because they are all the same.
120 moves = moves.filter(m => {
121 return (
122 m.vanish.length == 1 ||
123 m.vanish[0].p != V.PAWN ||
124 [V.PAWN, V.QUEEN].includes(m.appear[0].p)
125 );
126 });
127 moves.forEach(m => {
128 if (
129 m.vanish.length == 2 &&
130 m.appear.length == 1 &&
131 piece != m.vanish[1].p
132 ) {
133 // Augment pieces abilities in case of captures
134 m.appear[0].p = V.Fusion(piece, m.vanish[1].p);
135 }
136 });
137 return moves;
138 }
139
140 isAttacked(sq, color) {
141 return (
142 super.isAttacked(sq, color) ||
143 this.isAttackedByBN(sq, color) ||
144 this.isAttackedByRN(sq, color) ||
145 this.isAttackedByQN(sq, color)
146 );
147 }
148
149 isAttackedByBN(sq, color) {
150 return (
151 this.isAttackedBySlideNJump(sq, color, V.BN, V.steps[V.BISHOP]) ||
152 this.isAttackedBySlideNJump(
153 sq, color, V.BN, V.steps[V.KNIGHT], 1)
154 );
155 }
156
157 isAttackedByRN(sq, color) {
158 return (
159 this.isAttackedBySlideNJump(sq, color, V.RN, V.steps[V.ROOK]) ||
160 this.isAttackedBySlideNJump(
161 sq, color, V.RN, V.steps[V.KNIGHT], 1)
162 );
163 }
164
165 isAttackedByQN(sq, color) {
166 return (
167 this.isAttackedBySlideNJump(
168 sq, color, V.QN, V.steps[V.BISHOP].concat(V.steps[V.ROOK])) ||
169 this.isAttackedBySlideNJump(
170 sq, color, V.QN, V.steps[V.KNIGHT], 1)
171 );
172 }
173
174 static get VALUES() {
175 return Object.assign(
176 { a: 12, e: 7, s: 5 },
177 ChessRules.VALUES
178 );
179 }
180
181 getNotation(move) {
182 let notation = super.getNotation(move);
183 if (move.vanish[0].p != V.PAWN && move.appear[0].p != move.vanish[0].p)
184 // Fusion (not from a pawn: handled in ChessRules)
185 notation += "=" + move.appear[0].p.toUpperCase();
186 return notation;
187 }
188
189 };