[add] rs 還要調整

src/NetConnector1.ts

@@ -1,6 +0,0 @@
-// src/electron/NetConnector1.ts
-export class NetConnector1 {
-	constructor() {
-		console.log("NetConnector instance created");
-	}
-}

src/Utils/tools.ts

@@ -1,5 +1,7 @@
 import path from 'path';
 
+export const slotJsons: Map<number, any> = new Map();
+
 export function getExternalJsonPath(filename: string): string {
 	if (process.env.NODE_ENV === 'dev') {
 		// 开发模式下使用相对路径

src/api/slot/SlotFgSpinBase.ts

@@ -2,21 +2,48 @@ import { INetRequest } from "../../script/Engine/CatanEngine/NetManagerV2/Core/I
 import { INetResponse } from "../../script/Engine/CatanEngine/NetManagerV2/Core/INetResponse";
 import { ClientData } from "../../shared/protocols/define/interface";
 import { RpcSlot1SpinRequest, RpcSlot1SpinResponse } from "../../shared/protocols/Slot1Request";
+import SlotSpinBase from "./SlotSpinBase";
 
 
-export default abstract class SlotFgSpinBase {
+export default abstract class SlotFgSpinBase extends SlotSpinBase {
 	public *fgspin(clientData: ClientData, req: INetRequest<RpcSlot1SpinRequest>): IterableIterator<any> {
 		const data: RpcSlot1SpinRequest = req.Data
-		const { count, freeData } = clientData.free;
+		yield* this.init(clientData);
+
+		// if (clientData.reqFree) {
+		// 	const { count, freeData } = clientData.free;
+		// 	const slotData: any = freeData[count];
+
+		// 	const response: INetResponse<RpcSlot1SpinResponse> = {
+		// 		Status: 0,
+		// 		Method: req.Method,
+		// 		Data: slotData,
+		// 		IsValid: true
+		// 	};
+		// 	clientData.free.count++;
+		// 	return response;
+		// }
+		const { nowFree, freeData } = clientData.free;
+		const { count, totalGet } = clientData.reqFree;
 		const slotData: any = freeData[count];
 
+		if (clientData.reqFree && nowFree === count - 1) {
+			if (totalGet) {
+				slotData.get = [[1, totalGet]];
+			}
+			if (slotData.get) {
+				clientData.money += slotData.get[0][1];
+			}
+			slotData["money"] = clientData.money;
+		}
+
 		const response: INetResponse<RpcSlot1SpinResponse> = {
 			Status: 0,
 			Method: req.Method,
 			Data: slotData,
 			IsValid: true
 		};
-		clientData.free.count++;
+		clientData.free.nowFree++;
 		return response;
 	}
 }

src/api/slot/SlotInBase.ts

@@ -7,16 +7,19 @@ export default abstract class SlotInBase {
 	protected ver: string = "";
 	protected abstract db: number;
 	protected abstract br: number[];
-	protected abstract jp: { [key: string]: number; };
+	protected jp: { [key: string]: number; };
 
 	public *in(clientData: ClientData, req: INetRequest<RpcSlotInRequest>): IterableIterator<any> {
 		const data: RpcSlotInRequest = req.Data;
 		const { ver, db, br, jp } = this;
 
+		const respData = { ver, db, br };
+		if (jp) respData["jp"] = jp;
+
 		const response: INetResponse<RpcSlotInResponse> = {
 			Status: 0,
 			Method: req.Method,
-			Data: { ver, db, br, jp },
+			Data: respData,
 			IsValid: true
 		};
 		return response;

src/api/slot/SlotSetting.ts

@@ -0,0 +1,8 @@
+
+export default abstract class SlotSetting {
+	public IsHaveFreeSpin: boolean = false;
+	public IsHaveReSpin: boolean = false;
+	public IsHaveRetriggerFreeSpin: boolean = false;
+	public IsHaveReq: boolean = false;
+	public FreeMax: number = 50;
+}

src/api/slot/SlotSpinBase.ts

@@ -4,62 +4,66 @@ import { INetResponse } from "../../script/Engine/CatanEngine/NetManagerV2/Core/
 import { ClientData } from "../../shared/protocols/define/interface";
 import { RpcSlot1SpinRequest, RpcSlot1SpinResponse } from "../../shared/protocols/Slot1Request";
 import { RandomEx } from "../../Utils/Number/RandomEx";
-import { getExternalJsonPath } from "../../Utils/tools";
+import { getExternalJsonPath, slotJsons } from "../../Utils/tools";
+import SlotSetting from './SlotSetting';
 
 export default abstract class SlotSpinBase {
-	protected abstract ID: number;
-	protected IsHaveFreeSpin: boolean = false;
-	protected IsHaveReSpin: boolean = false;
-	protected IsHaveRetriggerFreeSpin: boolean = false;
-	protected FreeMax: number = 50;
+	protected setting: SlotSetting;
+	protected ID: number;
+	protected get IsHaveFreeSpin(): boolean { return this.setting.IsHaveFreeSpin };
+	protected get IsHaveReSpin(): boolean { return this.setting.IsHaveReSpin };
+	protected get IsHaveRetriggerFreeSpin(): boolean { return this.setting.IsHaveRetriggerFreeSpin };
+	protected get IsHaveReq(): boolean { return this.setting.IsHaveReq };
+	protected get FreeMax(): number { return this.setting.FreeMax };
+
 	protected JsonData: any;
-	protected get Temps(): string[] { return this.JsonData.slotData };
-	protected get FreeTemps(): string[] { return this.JsonData.slotFreeData };
+	protected get Temps(): JSON[] { return this.JsonData.slotData };
+	protected get FreeTemps(): JSON[] { return this.JsonData.slotFreeData };
 
 	public *spin(clientData: ClientData, req: INetRequest<RpcSlot1SpinRequest>): IterableIterator<any> {
-		const self = this;
 		const data: RpcSlot1SpinRequest = req.Data
-
-		if (!clientData.jsons[this.ID]) {
-			let slotData: any;
-			let AsyncFunction = async function () {
-				slotData = await self.GetTemps();
-			};
-			AsyncFunction();
-			while (!slotData) {
-				yield;
-			}
-			clientData.jsons[this.ID] = slotData;
-		}
-		this.JsonData = clientData.jsons[this.ID];
-
+		yield* this.init(clientData);
 		clientData.free = null;
+		clientData.reqFree = null;
 
 		const slotData: any = this.Temps[RandomEx.GetInt(0, this.Temps.length)];
+		delete slotData.get;
+		delete slotData.money;
 
 		let totalGet: number = 0;
 		if (slotData.line) {
-			totalGet += this.getLineGet(slotData.line);
+			totalGet += this.getLineMoney(slotData.line);
+		}
+		if (slotData.way) {
+			totalGet += this.getWayMoney(slotData.way);
 		}
 		if (slotData.scatter) {
-			totalGet += this.getScatterGet(slotData.scatter);
+			totalGet += this.getScatterMoney(slotData.scatter);
+			if (this.IsHaveReq && this.isHasReqFree(slotData.scatter)) {
+				clientData.reqFree = { count: 0, totalGet };
+			}
 		}
 		if (this.IsHaveFreeSpin && slotData.free) {
 			const count = slotData.free[1];
 			const { freeData, totalFreeGet } = this.getFree(count);
 			totalGet += totalFreeGet;
-			clientData.free = { count: 0, freeData };
+			clientData.free = { nowFree: 0, freeData };
 		}
 		if (totalGet) {
 			slotData.get = [[1, totalGet]];
 		}
 
 		clientData.money -= data.pay;
-		if (slotData.get) {
-			clientData.money += slotData.get[0][1];
+
+		if (clientData.reqFree) {
+			slotData["rs"] = 0;
+		} else {
+			if (slotData.get) {
+				clientData.money += slotData.get[0][1];
+			}
+			slotData["money"] = clientData.money;
 		}
 		slotData["pay"] = [[1, -data.pay]];
-		slotData["money"] = clientData.money;
 
 		const response: INetResponse<RpcSlot1SpinResponse> = {
 			Status: 0,
@@ -70,17 +74,19 @@ export default abstract class SlotSpinBase {
 		return response;
 	}
 
-	protected getFree(count: number) {
+	public getFree(count: number) {
 		let freeData = [];
 		let totalFreeGet = 0;
 		for (let i: number = 0; i < count; i++) {
 			const slotData: any = this.FreeTemps[RandomEx.GetInt(0, this.FreeTemps.length)];
+			delete slotData.get;
+			delete slotData.money;
 			freeData.push(slotData);
 			if (slotData.line) {
-				totalFreeGet += this.getLineGet(slotData.line);
+				totalFreeGet += this.getLineMoney(slotData.line);
 			}
 			if (slotData.scatter) {
-				totalFreeGet += this.getScatterGet(slotData.scatter);
+				totalFreeGet += this.getScatterMoney(slotData.scatter);
 				if (this.IsHaveRetriggerFreeSpin && slotData.free && freeData.length < this.FreeMax) {
 					const count = slotData.free[1] + freeData.length > this.FreeMax
 						? slotData.free[1] + freeData.length - this.FreeMax
@@ -94,7 +100,7 @@ export default abstract class SlotSpinBase {
 		return { freeData, totalFreeGet }
 	}
 
-	getLineGet(lines: number[][]): number {
+	private getLineMoney(lines: any[][]): number {
 		let totalGet: number = 0;
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
@@ -103,11 +109,38 @@ export default abstract class SlotSpinBase {
 		return totalGet;
 	}
 
-	getScatterGet(scatter: number[][]): number {
-		let totalGet: number = scatter[0][1];
+	private getWayMoney(ways: any[][]): number {
+		let totalGet: number = 0;
+		for (let i = 0; i < ways.length; i++) {
+			const way = ways[i];
+			totalGet += way[1]
+		}
 		return totalGet;
 	}
 
+	private getScatterMoney(scatters: any[][]): number {
+		let totalGet: number = 0;
+		let hasReqFree: boolean = false;
+		for (let i = 0; i < scatters.length; i++) {
+			const scatter = scatters[i];
+			totalGet += scatter[1]
+			if (this.IsHaveReq && scatter[0].length >= 3) {
+				hasReqFree = true;
+			}
+		}
+		return totalGet;
+	}
+
+	private isHasReqFree(scatters: any[][]): boolean {
+		for (let i = 0; i < scatters.length; i++) {
+			const scatter = scatters[i];
+			if (this.IsHaveReq && scatter[0].length >= 3) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	protected async GetTemps(): Promise<any> {
 		const filePath = getExternalJsonPath(`slot${this.ID}.json`);
 		// console.log('filePath', filePath);
@@ -115,6 +148,32 @@ export default abstract class SlotSpinBase {
 		const jsonData = JSON.parse(data);
 		return jsonData;
 	}
+
+	public *init(clientData: ClientData): IterableIterator<any> {
+		const self = this;
+		this.ID = clientData.slotId;
+		let AsyncFunction = async function () {
+			let module = await import(`../slot${self.ID}/setting`);
+			self.setting = new module.default();
+		};
+		AsyncFunction();
+		while (!this.setting) {
+			yield;
+		}
+
+		if (!slotJsons.has(this.ID)) {
+			let slotData: any;
+			let AsyncFunction = async function () {
+				slotData = await self.GetTemps();
+			};
+			AsyncFunction();
+			while (!slotData) {
+				yield;
+			}
+			slotJsons.set(this.ID, slotData);
+		}
+		this.JsonData = slotJsons.get(this.ID);
+	}
 }
 
 

src/api/slot/in.ts

@@ -7,6 +7,7 @@ import SlotIn1 from "../slot1/in";
 export default function* (clientData: ClientData, req: INetRequest<RpcSlotInRequest>): IterableIterator<any> {
 	const data: RpcSlotInRequest = req.Data;
 	const { id } = data;
+	clientData.slotId = id;
 
 	let moduleClass: SlotIn1;
 	let AsyncFunction = async function () {

src/api/slot/req.ts

@@ -0,0 +1,35 @@
+import { INetRequest } from "../../script/Engine/CatanEngine/NetManagerV2/Core/INetRequest";
+import { INetResponse } from "../../script/Engine/CatanEngine/NetManagerV2/Core/INetResponse";
+import { ClientData } from "../../shared/protocols/define/interface";
+import { RpcSlotReqRequest, RpcSlotReqResponse } from "../../shared/protocols/SlotRequest";
+import SlotFgSpinBase from "./SlotFgSpinBase";
+
+export default function* (clientData: ClientData, req: INetRequest<RpcSlotReqRequest>): IterableIterator<any> {
+	const count = req.Data
+	const { slotId } = clientData;
+	let totalGet = clientData.reqFree.totalGet;
+
+	let fgspin: SlotFgSpinBase;
+	let AsyncFunction = async function () {
+		let module = await import(`../slot${slotId}/fgspin`);
+		fgspin = new module.default();
+	};
+	AsyncFunction();
+	while (!fgspin) {
+		yield;
+	}
+
+	yield* fgspin.init(clientData);
+	const { freeData, totalFreeGet } = fgspin.getFree(count);
+	totalGet += totalFreeGet;
+	clientData.free = { nowFree: 0, freeData };
+	clientData.reqFree = { count: count, totalGet };
+
+	const response: INetResponse<RpcSlotReqResponse> = {
+		Status: 0,
+		Method: req.Method,
+		Data: req.Data,
+		IsValid: true
+	};
+	return response;
+}

src/api/slot1/setting.ts

@@ -0,0 +1,6 @@
+import SlotSetting from "../slot/SlotSetting";
+
+export default class SlotSetting1 extends SlotSetting {
+	public IsHaveFreeSpin: boolean = true;
+	public IsHaveRetriggerFreeSpin: boolean = true;
+}

src/api/slot1/spin.ts

@@ -1,7 +1,3 @@
 import SlotSpinBase from "../slot/SlotSpinBase";
 
-export default class SlotSpin1 extends SlotSpinBase {
-	protected ID: number = 1;
-	protected IsHaveFreeSpin: boolean = true;
-	protected IsHaveRetriggerFreeSpin: boolean = true;
-}
+export default class SlotSpin1 extends SlotSpinBase { }

src/api/slot70/fgspin.ts

@@ -0,0 +1,4 @@
+import SlotFgSpinBase from "../slot/SlotFgSpinBase";
+
+
+export default class SlotFgSpin70 extends SlotFgSpinBase { }

src/api/slot70/in.ts

@@ -0,0 +1,6 @@
+import SlotInBase from "../slot/SlotInBase";
+
+export default class SlotIn70 extends SlotInBase {
+	protected db: number = 5;
+	protected br: number[] = [4, 12, 20, 40, 80, 120, 160, 200, 240, 400, 600, 800, 1000, 1200, 1600, 2000, 4000, 10000, 20000, 30000];
+}

src/api/slot70/setting.ts

@@ -0,0 +1,7 @@
+import SlotSetting from "../slot/SlotSetting";
+
+export default class SlotSetting70 extends SlotSetting {
+	public IsHaveFreeSpin: boolean = true;
+	public IsHaveRetriggerFreeSpin: boolean = true;
+	public IsHaveReq: boolean = true;
+}

src/api/slot70/spin.ts

@@ -0,0 +1,3 @@
+import SlotSpinBase from "../slot/SlotSpinBase";
+
+export default class SlotSpin70 extends SlotSpinBase { }

src/electron/main.ts

@@ -12,6 +12,7 @@ import * as path from 'path';
 import { WebSocketServer } from 'ws';
 import { BaseEnumerator } from "../CatanEngine/CoroutineV2/Core/BaseEnumerator";
 import { NetConnector } from "../script/Engine/CatanEngine/NetManagerV2/NetConnector";
+import { slotJsons } from "../Utils/tools";
 
 onload();
 
@@ -39,8 +40,6 @@ function createWindow() {
 			preload: path.join(__dirname, 'preload.js'),
 			contextIsolation: true,
 			nodeIntegration: false,
-			// contextIsolation: false, // 使渲染進程能夠使用 Node.js
-			// nodeIntegration: true, // 使渲染進程可以使用 Node.js 模組
 		},
 	});
 
@@ -91,7 +90,7 @@ ipcMain.on('stop-websocket', (event: Electron.IpcMainEvent) => {
 // 打开开发者工具
 ipcMain.on('json-reload', () => {
 	NetConnector.clients.forEach(client => {
-		client.jsons = {};
+		slotJsons.clear();
 	});
 	console.log(`重載成功`);
 });

src/script/Engine/CatanEngine/NetManagerV2/NetConnector.ts

@@ -19,7 +19,7 @@ export class NetConnector {
 		const ip = request.socket.remoteAddress.replace("::ffff:", "") || 'Unknown IP';
 		console.log(`Client connected from IP: ${ip}`);
 
-		NetConnector.clients.set(socket, { socket, id: id, name: "", money: 0, jsons: {} });
+		NetConnector.clients.set(socket, { socket, id: id, name: "", money: 0 });
 		id++;
 
 		socket.on('message', (message: Buffer) => NetConnector.OnWebSocketMessage(socket, message));
@@ -57,7 +57,7 @@ export class NetConnector {
 			// 动态导入处理函数
 			try {
 				// 动态导入文件
-				const module = await import(`../../../../api/${req.Method.replace(".", "/")}`);
+				let module = await import(`../../../../api/${req.Method.replace(".", "/")}`);
 				const isClass = typeof module.default === 'function' && module.default.prototype && Object.getOwnPropertyNames(module.default.prototype).includes('constructor');
 
 				// 调用导入模块中的处理函数
@@ -76,6 +76,7 @@ export class NetConnector {
 								console.error(`Error handling request ${req.Method}: ${error.message}`);
 								NetConnector.sendError(socket, req);
 							}
+							module = null;
 						};
 						CoroutineV2.Single(AsyncFunction()).Start();
 					} else {
@@ -85,6 +86,7 @@ export class NetConnector {
 							if (response) {
 								NetConnector.Send(socket, response);
 							}
+							module = null;
 						};
 						CoroutineV2.Single(AsyncFunction()).Start();
 					}

src/shared/protocols/SlotRequest.ts

@@ -1,6 +1,9 @@
 // #region Request
 
 export type RpcSlotInRequest = { id: number }
-export type RpcSlotInResponse = { "ver": string, "db": number, "br": number[], "jp": { [key: string]: number } }
+export type RpcSlotInResponse = { ver: string, db: number, br: number[], jp?: { [key: string]: number } }
+
+export type RpcSlotReqRequest = number
+export type RpcSlotReqResponse = number
 
 // #endregion

src/shared/protocols/define/interface.ts

@@ -6,6 +6,7 @@ export interface ClientData {
 	id: number;
 	name: string;
 	money: number;
-	jsons: { [key: number]: any; };
-	free?: { count: number, freeData: any[] };
+	slotId?: number;
+	free?: { nowFree: number, freeData: any[] };
+	reqFree?: { count: number, totalGet: number };
 }