feat: 实现 common 库中的 Terrain 相关方法

common/src/Rpc/RpcClient.ts

@@ -1,7 +1,8 @@
 import { Socket } from "net";
 import { EventEmitter } from "events";
 import { JSONFrameStream } from "@/Rpc/JSONFrameStream";
-import { Defer, Reject, Resolve, RpcClientFrameObj } from "@/types";
+import { Defer, RpcClientFrameObj } from "@/types";
+import { makeDefer } from "@/utils";
 
 export class RpcClient {
   public socket: Socket;
@@ -39,15 +40,6 @@ export class RpcClient {
     this.defers.delete(String(obj.id));
   }
 
-  public static defer(): Defer {
-    let resolve = ((): void => {}) as Resolve,
-      reject = ((): void => {}) as Reject;
-    const defer = new Promise((res, rej) => {
-      [resolve, reject] = [res, rej];
-    });
-    return { defer, reject, resolve };
-  }
-
   public request(method: string, ...args: unknown[]): Defer {
     this.requestId++;
     const request = {
@@ -56,7 +48,7 @@ export class RpcClient {
       args,
     };
     this.socket.write(JSONFrameStream.makeFrame(request));
-    const defered = RpcClient.defer();
+    const defered = makeDefer();
     this.defers.set(String(this.requestId), defered);
     return defered;
   }

common/src/Storage.ts

@@ -2,6 +2,8 @@ import net from "net";
 import { RpcClient } from "@/Rpc/RpcClient";
 import { config } from "@/ConfigManager";
 import { DataBaseStorage, Defer } from "@/types";
+import { makeDefer } from "@/utils";
+
 export let connected = false;
 export let resetAllData: () => Defer;
 export const db: DataBaseStorage = {} as DataBaseStorage;
@@ -33,8 +35,8 @@ export function storageConnect(): Promise<unknown> {
   );
   const rpcClient = new RpcClient(socket);
 
-  const defer = RpcClient.defer();
-  const resetDefer = RpcClient.defer();
+  const defer = makeDefer();
+  const resetDefer = makeDefer();
 
   function resetInterceptor(
     fn: (...args: unknown[]) => Defer,

common/src/index.ts

@@ -1,7 +1,79 @@
 import { ConfigManager } from "@/ConfigManager";
 export { RpcServer } from "@/Rpc/RpcServer";
 export { RpcClient } from "@/Rpc/RpcClient";
+import * as storage from "@/Storage";
+import { JSONFrameStream } from "@/Rpc/JSONFrameStream";
+import { RpcServer } from "@/Rpc/RpcServer";
+import { RpcClient } from "@/Rpc/RpcClient";
+import { Defer, Terrain } from "@/types";
+import { makeDefer } from "@/utils";
+import { createServer } from "net";
+import * as _ from "lodash";
 
-export const common = {
-  configManager: new ConfigManager(),
-};
+export class Common {
+  public configManager = new ConfigManager();
+  public storage = storage;
+  public rpc = {
+    JSONFrameStream,
+    RpcServer,
+    RpcClient,
+  };
+  public findPort(port: number): Defer {
+    const defer = makeDefer();
+    const server = createServer((socket) => socket.end());
+    server.listen(port, (): void => {
+      server.once("close", (): void => {
+        defer.resolve(String(port));
+      });
+      server.close();
+    });
+    server.on("error", (): void => {
+      defer.resolve(String(this.findPort.bind(this)(port + 1)));
+    });
+    return defer;
+  }
+
+  public encodeTerrain(terrain: Terrain[]): string {
+    let result = "";
+    for (let y = 0; y < 50; y++) {
+      for (let x = 0; x < 50; x++) {
+        const objects = _.filter(terrain, { x, y });
+        let code = 0;
+        if (_.some(objects, { type: "wall" })) {
+          code = code | 1;
+        }
+        if (_.some(objects, { type: "swamp" })) {
+          code = code | 2;
+        }
+        result = result + code;
+      }
+    }
+    return result;
+  }
+
+  public decodeTerrain(str: string, room: string): Terrain[] {
+    const result = [];
+
+    for (let y = 0; y < 50; y++) {
+      for (let x = 0; x < 50; x++) {
+        const code = str.charAt(y * 50 + x);
+        if (code && 1) {
+          result.push({ room, x, y, type: "wall" });
+        }
+        if (code && 2) {
+          result.push({ room, x, y, type: "swamp" });
+        }
+      }
+    }
+    return result;
+  }
+
+  public checkTerrain(
+    terrainStr: string,
+    x: number,
+    y: number,
+    mask: number,
+  ): boolean {
+    return (parseInt(terrainStr.charAt(y * 50 + x)) & mask) > 0;
+  }
+}

common/src/types.d.ts

@@ -55,3 +55,5 @@ export type DataBaseMethod =
   | "update"
   | "bulk"
   | "findEx";
+
+export type Terrain = { type: string; x: number; y: number; room?: string };

common/src/utils.ts

@@ -0,0 +1,10 @@
+import { Defer, Reject, Resolve } from "@/types";
+
+export function makeDefer(): Defer {
+  let resolve = ((): void => {}) as Resolve,
+    reject = ((): void => {}) as Reject;
+  const defer = new Promise((res, rej) => {
+    [resolve, reject] = [res, rej];
+  });
+  return { defer, reject, resolve };
+}

common/tests/common.test.ts

@@ -0,0 +1,30 @@
+import { Common } from "@/index";
+
+test("findPort", async () => {
+  const common = new Common();
+  const defer = common.findPort(8080);
+  await defer.defer;
+});
+
+test("decodeTerrain", async () => {
+  const common = new Common();
+  const terrain = [{ type: "wall", x: 0, y: 0 }];
+  const terrainString = common.encodeTerrain(terrain);
+  console.log(terrainString);
+});
+
+test("encodeTerrain", async () => {
+  const common = new Common();
+  const terrain = [{ type: "wall", x: 0, y: 0 }];
+  const terrainString = common.encodeTerrain(terrain);
+  const result = common.decodeTerrain(terrainString, "testRoom");
+  expect(result[0].type).toBe(terrain[0].type);
+});
+
+test("checkTerrain", async () => {
+  const common = new Common();
+  const terrain = [{ type: "wall", x: 0, y: 0 }];
+  const terrainString = common.encodeTerrain(terrain);
+  const result = common.checkTerrain(terrainString, 0, 0, 1);
+  expect(result).toBe(true);
+});

driver/src/runtime/UserVM.ts

@@ -3,7 +3,9 @@ import * as v8 from "v8";
 import fs from "fs";
 import { Metric, NodeJS, StaticTerrainData, VM } from "@/runtime/types";
 import RuntimeGlobal = NodeJS.RuntimeGlobal;
-import { common } from "@neo-screeps/common";
+import { Common } from "@neo-screeps/common";
+
+const common = new Common();
 
 export class UserVM {
   public vms: { [userId: string]: VM } = {};

storage/src/Database.ts

@@ -1,8 +1,9 @@
-import { common } from "@neo-screeps/common";
+import { Common } from "@neo-screeps/common";
 import fs from "fs";
 import _ from "lodash";
 import Loki, { Collection } from "lokijs";
 
+const common = new Common();
 const config = common.configManager.config;
 
 export class DataBase {