Adrien/Riichi
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean the project

Browse source
This commit is contained in:
Didictateur 2025-03-23 23:05:08 +01:00
parent 93a769be29
commit f001879664
7 changed files with 31 additions and 907 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

365
4
View file

@ -1,365 +0,0 @@
import { Deck } from "./deck";
import { Hand } from "./hand";
import { Tile } from "./tile";
import { Group } from "./group";
import { drawButtons, clickAction } from "./button";
export type mousePos = { x: number, y: number};
export class Game {
private deck: Deck;
private hands: Array<Hand>;
private discards: Array<Array<Tile>>;
private lastDiscard: number|undefined;
private groups: Array<Array<Group>>;
// game values
private turn = 0;
private selectedTile: number|undefined = undefined;
private canCall: boolean = false;
private hasPicked: boolean = false;
private hasPlayed: boolean = false;
// display parameter
private BG_RECT = {color: "#007730", x: 0, y: 0, w: 1050, h: 1050};
private sizeHand = 0.7;
private sizeHiddenHand = 0.6;
private sizeDiscard = 0.6;
// canvas
private ctx: CanvasRenderingContext2D;
private cv: HTMLCanvasElement;
private staticCtx: CanvasRenderingContext2D;
private staticCv: HTMLCanvasElement;
public constructor(
ctx: CanvasRenderingContext2D,
cv: HTMLCanvasElement,
staticCtx: CanvasRenderingContext2D,
staticCv: HTMLCanvasElement,
red: boolean = false
) {
this.ctx = ctx;
this.cv = cv;
this.staticCtx = staticCtx;
this.staticCv = staticCv;
this.deck = new Deck(red);
this.hands = [
this.deck.getRandomHand(),
this.deck.getRandomHand(),
this.deck.getRandomHand(),
this.deck.getRandomHand()
];
this.discards = [[], [], [], []];
this.lastDiscard = undefined;
this.groups = [[], [], [], []];
this.pick(0);
}
public draw(mp: mousePos) {
// background
this.staticCtx.clearRect(0, 0, this.cv.width, this.cv.height);
this.staticCtx.fillStyle = this.BG_RECT.color;
this.staticCtx.fillRect(
this.BG_RECT.x,
this.BG_RECT.y,
this.BG_RECT.w,
this.BG_RECT.h
);
this.getSelected(mp);
this.drawGame();
this.ctx.clearRect(0, 0, this.cv.width, this.cv.height);
this.ctx.drawImage(this.staticCv, 0, 0);
}
public getDeck(): Deck {
return this.deck;
}
public getHands(): Array<Hand> {
return this.hands;
}
public click(
mp: mousePos,
): void {
let action = clickAction(
mp.x,
mp.y,
this.canDoAChii().length > 0,
this.canDoAPon(),
false,
false,
false
);
this.getSelected(mp);
if (this.turn === 0 && this.selectedTile !== undefined) {
this.discard(0, this.selectedTile as NonNullable<number>);
this.turn++;
}
if (this.canDoAPon()) {
this.pon(this.turn > 0 ? this.turn-1 : 3);
}
}
private getSelected(
mp: mousePos,
): void {
const rect = this.cv.getBoundingClientRect();
let x = 2.5 * 75 * 0.75;
let y = 1050 - 250 * 0.6;
const mouseX = mp.x - rect.left - x;
const mouseY = mp.y - rect.top;
const s = 83.9;
let q = Math.floor(mouseX / (s * this.sizeHand));
let r = mouseX - q * s * this.sizeHand;
if (
r <= (s - 3) * this.sizeHand &&
q >= 0 &&
q < this.hands[0].length() &&
mouseY >= y &&
mouseY <= y + 100 * this.sizeHand
) {
this.selectedTile = q;
} else {
this.selectedTile = undefined;
}
};
private play(): void {
if (
this.turn !== 0
) {
if (!this.hasPicked) {
this.pick(this.turn);
this.hasPicked = true;
} else if (!this.hasPlayed) {
this.discard(this.turn, 0);
this.hasPlayed = true;
this.canCall = this.canDoAChii().length > 0 || this.canDoAPon();
} else if (!this.canCall) {
if (this.turn === 3) {
this.turn = 0;
this.pick(0);
} else {
this.turn++;
}
this.hasPicked = false;
this.hasPlayed = false;
}
}
}
private pick(player: number): void {
this.hands[player].push(this.deck.pop());
this.hands[player].isolate = true;
}
private discard(player: number, n: number): void {
let tile = this.hands[player].eject(n);
tile.setTilt();
this.discards[player].push(tile);
this.hands[player].isolate = false;
this.hands[player].sort();
this.lastDiscard = player;
}
private canDoAPon(): boolean {
if (this.lastDiscard !== undefined && this.lastDiscard !== 0) {
let t = this.discards[this.lastDiscard][this.discards[this.lastDiscard].length-1];
return this.hands[0].count(t.getFamily(), t.getValue()) >= 2;
} else {
return false;
}
}
private pon(p: number): void {
console.log(p, "\n");
let t = this.discards[p].pop() as NonNullable<Tile>;
this.lastDiscard = undefined;
let t2 = this.hands[0].find(t.getFamily(), t.getValue()) as NonNullable<Tile>;
let t3 = this.hands[0].find(t.getFamily(), t.getValue()) as NonNullable<Tile>;
[t, t2, t3].forEach(t => t.setTilt());
this.groups[0].push(new Group([t, t2, t3], p));
}
private canDoAChii(): Array<number> {
let chii = [] as Array<number>;
if (
this.lastDiscard !== undefined &&
this.lastDiscard === 3 &&
this.discards[this.lastDiscard][this.discards[this.lastDiscard].length-1].getFamily() < 4
) {
let t = this.discards[this.lastDiscard][this.discards[this.lastDiscard].length-1];
let h = this.hands[0];
if (
h.count(t.getFamily(), t.getValue()-2) > 0 &&
h.count(t.getFamily(), t.getValue()-1) > 0
) {
chii.push(t.getValue()-2);
} else if (
h.count(t.getFamily(), t.getValue()-1) > 0 &&
h.count(t.getFamily(), t.getValue()+1) > 0
) {
chii.push(t.getValue()-1);
} else if (
h.count(t.getFamily(), t.getValue()+1) > 0 &&
h.count(t.getFamily(), t.getValue()+2) > 0
) {
chii.push(t.getValue());
}
}
return chii;
}
private chii(minValue: number): void {
}
private drawGame(): void {
// update game
this.play();
// hands
this.drawHands();
// groups
this.drawGroups(0.6);
// discards
for (let i = 0; i < 4; i++) {
this.drawDiscard(
i,
this.hands[0].get(this.selectedTile) as NonNullable<Tile>
);
}
// called
drawButtons(
this.staticCtx,
this.canDoAChii().length > 0,
this.canDoAPon(),
false,
false,
false
);
}
private drawHands() {
const pi = 3.141592;
this.hands[0].drawHand(
this.staticCtx,
2.5 * 75 * 0.75,
1000 - 150 * this.sizeHand,
5 * this.sizeHand,
0.75,
this.selectedTile,
false,
0
);
this.hands[1].drawHand(
this.staticCtx,
1000 - 150 * this.sizeHiddenHand,
1000 - 75 * 5 * this.sizeHiddenHand,
5 * this.sizeHiddenHand,
this.sizeHiddenHand,
undefined,
true,
- pi / 2
);
this.hands[2].drawHand(
this.staticCtx,
1000 - 75 * 5 * this.sizeHiddenHand,
150 * this.sizeHiddenHand,
5 * this.sizeHiddenHand,
this.sizeHiddenHand,
undefined,
true,
- pi
);
this.hands[3].drawHand(
this.staticCtx,
150 * this.sizeHiddenHand,
75 * 5 * this.sizeHiddenHand,
5 * this.sizeHiddenHand,
this.sizeHiddenHand,
undefined,
true,
pi / 2
);
}
private drawGroups(
size: number
): void {
let os = 25;
const pi = 3.141592;
for ( let p = 0; p < 4; p++) {
let rotation = [0, -pi / 2, -pi, pi / 2][p];
if (this.groups[p].length > 0) {
for (let i = this.groups[p].length-1; i >= 0; i--) {
this.groups[p][i].drawGroup(
this.staticCtx,
1050 - 240 - (260 + os) * size * i,
1050 - 62,
5,
0.6,
rotation
);
}
}
}
}
private drawDiscard(
p: number,
highlitedTile: Tile|undefined
): void {
const pi = 3.141592;
this.staticCtx.save();
this.staticCtx.translate(525, 525);
this.staticCtx.rotate([0, -pi/2, -pi, pi/2][p])
let x = - this.sizeDiscard * 475 / 2;
let y = this.sizeDiscard * (475 / 2 + 5);
for (let i = 0; i < this.discards[p].length; i++) {
let tile = this.discards[p][i];
if (i < 12) {
tile.drawTile(
this.staticCtx,
x + (i % 6) * 80 * this.sizeDiscard,
y + Math.floor(i / 6) * 105 * this.sizeDiscard,
this.sizeDiscard,
false,
0,
highlitedTile?.isEqual(tile.getFamily(), tile.getValue())
);
} else {
tile.drawTile(
this.staticCtx,
x + (i - 12) * 80 * this.sizeDiscard,
y + 2 * 105 * this.sizeDiscard,
this.sizeDiscard,
false,
0,
highlitedTile?.isEqual(tile.getFamily(), tile.getValue())
);
}
}
this.staticCtx.restore();
}
public async preload(): Promise<void> {
await this.deck.preload();
await Promise.all(this.hands.map(h => h.preload()));
}
}

126
build/dp1.js
View file

File diff suppressed because one or more lines are too long

126
build/dp2.js
View file

File diff suppressed because one or more lines are too long

126
build/dp3.js
View file

File diff suppressed because one or more lines are too long

146
build/dp4.js
View file

File diff suppressed because one or more lines are too long

7
src/button.ts
View file

@ -25,8 +25,6 @@ export function clickAction(
} else { } else {
return -1; return -1;
} }
let dx = 0;
let size = 0.6;
let xmin = 960 - buttons.filter(c => c[0]).length * 120; let xmin = 960 - buttons.filter(c => c[0]).length * 120;
let inside = 492 < y && y < 544; let inside = 492 < y && y < 544;
let q = Math.floor((x - xmin) / 120); let q = Math.floor((x - xmin) / 120);
@ -34,7 +32,8 @@ export function clickAction(
if ( if (
q >= 0 && q >= 0 &&
q < buttons.filter(c => c[0]).length && q < buttons.filter(c => c[0]).length &&
r > 10 r > 10 &&
inside
) { ) {
return buttons.filter(c => c[0])[q][1] as number; return buttons.filter(c => c[0])[q][1] as number;
} }
@ -113,7 +112,7 @@ function buttonPass(
button(ctx, x, y, r, w, h, "#FF9030"); button(ctx, x, y, r, w, h, "#FF9030");
ctx.fillStyle = "black"; ctx.fillStyle = "black";
ctx.font = "30px garamond"; ctx.font = "30px garamond";
ctx.fillText("Ignorer",x + w * 0.1, y + h/2 * 1.3); ctx.fillText("Ignorer", x + w * 0.1, y + h/2 * 1.3);
} }
function buttonPon( function buttonPon(

42
src/game.ts
View file

@ -8,12 +8,14 @@ export type mousePos = { x: number, y: number};
export class Game { export class Game {
private deck: Deck; private deck: Deck;
private hands: Array<Hand>; private deadWall: Array<Tile> = [];
private hands: Array<Hand> = [];
private discards: Array<Array<Tile>>; private discards: Array<Array<Tile>>;
private lastDiscard: number|undefined; private lastDiscard: number|undefined;
private groups: Array<Array<Group>>; private groups: Array<Array<Group>>;
// game values // game values
private level: number;
private turn = 0; private turn = 0;
private selectedTile: number|undefined = undefined; private selectedTile: number|undefined = undefined;
private canCall: boolean = false; private canCall: boolean = false;
@ -38,19 +40,22 @@ export class Game {
cv: HTMLCanvasElement, cv: HTMLCanvasElement,
staticCtx: CanvasRenderingContext2D, staticCtx: CanvasRenderingContext2D,
staticCv: HTMLCanvasElement, staticCv: HTMLCanvasElement,
red: boolean = false red: boolean = false,
level: number = 0
) { ) {
this.ctx = ctx; this.ctx = ctx;
this.cv = cv; this.cv = cv;
this.staticCtx = staticCtx; this.staticCtx = staticCtx;
this.staticCv = staticCv; this.staticCv = staticCv;
this.level = level;
this.deck = new Deck(red); this.deck = new Deck(red);
this.hands = [ this.deck.shuffle();
this.deck.getRandomHand(), for (let i = 0; i < 14; i++) {
this.deck.getRandomHand(), this.deadWall.push(this.deck.pop());
this.deck.getRandomHand(), }
this.deck.getRandomHand() for (let i = 0; i < 4; i++) {
]; this.hands.push(this.deck.getRandomHand());
}
this.discards = [[], [], [], []]; this.discards = [[], [], [], []];
this.lastDiscard = undefined; this.lastDiscard = undefined;
this.groups = [[], [], [], []]; this.groups = [[], [], [], []];
@ -93,9 +98,9 @@ export class Game {
mp.y, mp.y,
this.canDoAChii().length > 0, this.canDoAChii().length > 0,
this.canDoAPon(), this.canDoAPon(),
false, false && this.level > 1,
false, false && this.level > 0,
false false && this.level > 0
); );
if (this.canCall && action !== -1) { // can call if (this.canCall && action !== -1) { // can call
@ -256,6 +261,9 @@ export class Game {
// update game // update game
this.play(); this.play();
// draw winds, discard, riichi etc...
this.drawDiscardSize();
// hands // hands
this.drawHands(); this.drawHands();
@ -275,9 +283,9 @@ export class Game {
this.staticCtx, this.staticCtx,
this.canDoAChii().length > 0, this.canDoAChii().length > 0,
this.canDoAPon(), this.canDoAPon(),
false, false && this.level > 1,
false, false && this.level > 0,
false false && this.level > 0
); );
} }
@ -413,6 +421,12 @@ export class Game {
this.staticCtx.restore(); this.staticCtx.restore();
} }
private drawDiscardSize() {
this.staticCtx.fillStyle = "#f070f0";
this.staticCtx.font = "40px garamond";
this.staticCtx.fillText(this.deck.length().toString(), 520, 520);
}
public async preload(): Promise<void> { public async preload(): Promise<void> {
await this.deck.preload(); await this.deck.preload();
await Promise.all(this.hands.map(h => h.preload())); await Promise.all(this.hands.map(h => h.preload()));