update passTower by direction

src/Model/User.ts

@@ -13,6 +13,7 @@ class User {
     public curBlock: v2 = new v2(0,0);
     public nextBlock: v2 = new v2(0,0);
     public screenPos: v2 = new v2(0,0);
+    public position: v2 = new v2(0,0);
 
     public timeStart: number = 0;
     public isEndGame: boolean = true;
@@ -39,6 +40,8 @@ class User {
         this.nextBlock.y = 0;
         this.screenPos.x = 0;
         this.screenPos.y = 0;
+        this.position.x = 0;
+        this.position.y = 0;
     }
 }
 
@@ -50,4 +53,28 @@ class History {
     public score: number = 0;
 }
 
+export interface IDataPassTower {
+    target: v2,
+    score: number,
+    isHead: boolean,
+    heightJump: number,
+    totalScore: number,
+}
+
+// {
+//         nextBlock: user.nextBlock,
+//         screenPos: user.screenPos,
+//         direction: user.direction,
+//         distance2Tower: user.distance2Tower,
+//         towerNumber: user.towerNumber - 1,
+//     };
+
+export interface IDataSpawnTower {
+    nextBlock: v2,
+    screenPos: v2,
+    direction: number,
+    distance2Tower: number,
+    towerNumber: number,
+}
+
 export default User;
\ No newline at end of file

src/Model/v2.ts

@@ -19,7 +19,7 @@ class v2 {
         return new v2(this.x - other.x, this.y - other.y);
     }
 
-    public scale(s: number): v2 {
+    public mul(s: number): v2 {
         return new v2(this.x * s, this.y * s);
     }
 
@@ -27,6 +27,15 @@ class v2 {
         const length = this.distanceTo(new v2(0, 0));
         return new v2(this.x / length, this.y / length);
     }
+
+    public clone(): v2 {
+        return new v2(this.x, this.y);
+    }
+
+    public mag(): number {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+   
 }
 
 export default v2;
\ No newline at end of file

src/socket.ts

 import { Server, Socket } from "socket.io";
 import CONFIG from "./Config/config";
-import User from "./Model/User";
+import User, { IDataPassTower, IDataSpawnTower } from "./Model/User";
 import v2 from "./Model/v2";
 import { endGameApi, startGameApi } from "./Controller/networkCtrl";
 
 const users: Map<string, User> = new Map<string, User>();
-const Y_RATIO: number = 0.5560472;
-const HALF_SIZE_BLOCK: number = 56.43580423808985;
+const Y_RADIO: number = 0.5560472;
+const HALF_SIZE_TOWER: number = 56.43580423808985;
 
 
 export function setupSocket(io: Server) {
     io.use((socket: Socket, next) => {
         const token = String(socket.handshake.query.token);
+        if (!token) {
+            return;
+        }
         if (!users.has(token)) {
             users.set(token, new User(token));
         }
@@ -48,7 +51,7 @@ async function getHistory(socket: Socket) {
 async function startGame(socket: Socket, data: any) {
     const user = getUserBySocket(socket);
     const result = await startGameApi(data);
-    // const result = false;
+    // const result = true;
     if (result) {
         socket.emit(CONFIG.EVT.REQUEST_START_GAME, true);
         user.isEndGame = false;
@@ -59,36 +62,43 @@ async function startGame(socket: Socket, data: any) {
     }
 }
 
-async function passTower(socket: Socket, data: { playerPos: v2, distance: number }) {
-    console.log('distance', data.distance, 'playerPos', data.playerPos)
+async function passTower(socket: Socket, data: { distance: number }) {
     const user = getUserBySocket(socket);
+    console.log('distance', data.distance.toFixed(), user.distance2Tower.toFixed());
+
+    const xDistance_ = data.distance;
+    const { direction, nextBlock, towerNumber, position } = user;
+
+    const point = new v2(xDistance_ * direction, xDistance_ * Y_RADIO);
+    const nextTowerPos = nextBlock;
+    const distancePlayer2NextTower = nextTowerPos.clone().sub(position).mag();
+    const minDistance = Math.abs(xDistance_ - distancePlayer2NextTower);
+    const isHead = distancePlayer2NextTower > xDistance_;
 
-    let score = 0
-    const distancePlayer2NextBlock = new v2(data.playerPos.x, data.playerPos.y).distanceTo(user.nextBlock);
-    console.log('distancePlayer2NextBlock', distancePlayer2NextBlock, 'user.distance2Tower', user.distance2Tower)
-    const distance = Math.abs(data.distance - user.distance2Tower);
-    // const distance = Math.abs(data.distance - distancePlayer2NextBlock);
+    let score = -1;
 
-    if (distance < HALF_SIZE_BLOCK * 0.8) {
+    const pointEdge = new v2(HALF_SIZE_TOWER * direction, HALF_SIZE_TOWER * Y_RADIO);
+    let target = position.clone().add(point);
+
+    if (minDistance < HALF_SIZE_TOWER * 1.5) {
+        target = nextTowerPos.clone().sub(isHead ? pointEdge : pointEdge.clone().mul(-1));
+        score = 0;
+    }
+    if (minDistance < HALF_SIZE_TOWER * 0.8) {
+        target = nextTowerPos.clone().sub(pointEdge.clone().mul(0.6));
         score = 1;
     }
-    if (distance <= HALF_SIZE_BLOCK / 3) {
+    if (minDistance < HALF_SIZE_TOWER * 0.3) {
+        target = nextTowerPos.clone();
         score = 2;
     }
-    if (distance > HALF_SIZE_BLOCK * 0.8 && distance <= HALF_SIZE_BLOCK * 1.2) {
-        score = -1;
-    }
 
-    // if (user.towerNumber > 2) {
-    //     score = 0;//test
-    // }
+    const heightJump = nextBlock.y + 100 - position.y;
 
     if (score <= 0) {
         user.isEndGame = true;
     }
 
-    console.log('score', score)
-    
     if (score == 2) {
         user.combo = Math.min(user.combo + 1, 2);
         score *= user.combo;
@@ -96,35 +106,34 @@ async function passTower(socket: Socket, data: { playerPos: v2, distance: number
         user.combo = 0;
     }
 
-    let pointJump;
-
     user.totalScore += score;
-    const jumpDirection = (data.distance > user.distance2Tower ? 1 : -1) * user.direction;
-    const dataSend = {
+
+    const dataSocket: IDataPassTower = {
+        target,
+        score,
+        isHead,
+        heightJump,
         totalScore: user.totalScore,
-        tower: user.towerNumber,
-        jumpScore: score,
-        jumpDirection,
-        pointJump
     };
 
     const history = {
-        ...dataSend,
+        totalScore: user.totalScore,
+        tower: towerNumber,
         score: Math.max(score, 0),
         timeStart: user.timeStart,
         timePlayed: Date.now() - user.timeStart,
     }
 
     user.history.unshift(history);
+    user.position = target;
 
-    socket.emit(CONFIG.EVT.REQUEST_PASS_TOWER, dataSend);
-
+    socket.emit(CONFIG.EVT.REQUEST_PASS_TOWER, dataSocket);
 
     if (score > 0) {
         addBlock(socket);
     } else {
         socket.emit(CONFIG.EVT.REQUEST_HISTORY, user.history);
-        // await endGameApi(user);
+        await endGameApi(user);
         user.reset();
         console.log('END');
     }
@@ -133,10 +142,9 @@ async function passTower(socket: Socket, data: { playerPos: v2, distance: number
 async function addBlock(socket: Socket) {
     const user = getUserBySocket(socket);
     const towerNumber = ++user.towerNumber;
-    console.log('towerNumber ////', towerNumber)
 
     const xDistance = ((Math.min(towerNumber, 100) / 100 + 1) + Math.random() * (towerNumber <= 10 ? 0.5 : 1)) * 150;
-    const yDistance = xDistance * Y_RATIO;
+    const yDistance = xDistance * Y_RADIO;
 
     user.curBlock = new v2(user.nextBlock.x, user.nextBlock.y);
     if (towerNumber > 1) {
@@ -145,14 +153,14 @@ async function addBlock(socket: Socket) {
     user.nextBlock.x = user.curBlock.x + (xDistance * user.direction);
     user.nextBlock.y = user.curBlock.y + yDistance;
     user.distance2Tower = user.nextBlock.distanceTo(user.curBlock);
-    user.screenPos = user.nextBlock.add(user.curBlock).scale(0.5).sub(new v2(0, 100));
+    user.screenPos = user.nextBlock.add(user.curBlock).mul(0.5).sub(new v2(0, 100));
 
-    const data = {
+    const data: IDataSpawnTower = {
         nextBlock: user.nextBlock,
         screenPos: user.screenPos,
         direction: user.direction,
         distance2Tower: user.distance2Tower,
-        towerNumber: user.towerNumber - 1,
+        towerNumber: user.towerNumber,
     };
     user.timeStart = Date.now();
     socket.emit(CONFIG.EVT.REQUEST_SPAWN_TOWER, data);