[Refactor] Refactor for link play

- Refactor simply for link play subprogram
- Fix a logic bug that the room without anyone can be entered

latest version/linkplay_server/config.py

@@ -15,6 +15,8 @@ class Config:
     --------------------------------------------------
     '''
 
+    IS_DEBUG = False
+
     TIME_LIMIT = 3600000
 
     COMMAND_INTERVAL = 1000000

latest version/linkplay_server/main.py

@@ -1,93 +1,18 @@
-import base64
+import binascii
 import logging
-import random
 import socketserver
 import threading
-import time
-from os import urandom
 
-# import binascii
 from .aes import decrypt, encrypt
 from .config import Config
-from .udp_class import Player, Room, bi
+from .store import Store, TCPRouter, clear_player, clear_room
+from .udp_class import bi
 from .udp_parser import CommandParser
 
-# token: {'key': key, 'room': Room, 'player_index': player_index, 'player_id': player_id}
-link_play_data = {}
-room_id_dict = {}  # 'room_id': Room
-room_code_dict = {}  # 'room_code': Room
-player_dict = {}  # 'player_id' : Player
-clean_timer = 0
-lock = threading.RLock()
-
 logging.basicConfig(format='[%(asctime)s] %(levelname)s in %(module)s: %(message)s',
                     level=logging.INFO)
 
 
-def random_room_code():
-    # 随机生成房间号
-    re = ''
-    for _ in range(4):
-        re += chr(random.randint(65, 90))
-    for _ in range(2):
-        re += str(random.randint(0, 9))
-
-    return re
-
-
-def unique_random(dataset, length=8, random_func=None):
-    '''无重复随机，且默认非0'''
-    if random_func is None:
-        x = bi(urandom(length))
-        while x in dataset or x == 0:
-            x = bi(urandom(length))
-    else:
-        x = random_func()
-        while x in dataset:
-            x = random_func()
-    return x
-
-
-def clear_player(token):
-    # 清除玩家信息和token
-    del player_dict[link_play_data[token]['player_id']]
-    del link_play_data[token]
-
-
-def clear_room(room):
-    # 清除房间信息
-    room_id = room.room_id
-    room_code = room.room_code
-    del room_id_dict[room_id]
-    del room_code_dict[room_code]
-    del room
-
-
-def memory_clean(now):
-    # 内存清理
-    with lock:
-        clean_room_list = []
-        clean_player_list = []
-        for token in link_play_data:
-            room = link_play_data[token]['room']
-            if now - room.timestamp >= Config.TIME_LIMIT:
-                clean_room_list.append(room.room_id)
-
-            if now - room.players[link_play_data[token]['player_index']].last_timestamp // 1000 >= Config.TIME_LIMIT:
-                clean_player_list.append(token)
-
-        for room_id in room_id_dict:
-            if now - room_id_dict[room_id].timestamp >= Config.TIME_LIMIT:
-                clean_room_list.append(room_id)
-
-        for room_id in clean_room_list:
-            if room_id in room_id_dict:
-                clear_room(room_id_dict[room_id])
-
-        for token in clean_player_list:
-            clear_player(token)
-
-
 class UDP_handler(socketserver.BaseRequestHandler):
     def handle(self):
         client_msg, server = self.request
@@ -96,32 +21,34 @@ class UDP_handler(socketserver.BaseRequestHandler):
             iv = client_msg[8:20]
             tag = client_msg[20:32]
             ciphertext = client_msg[32:]
-            if int.from_bytes(token, byteorder='little') in link_play_data:
-                user = link_play_data[bi(token)]
-            else:
+            if bi(token) not in Store.link_play_data:
                 return None
+            user = Store.link_play_data[bi(token)]
 
             plaintext = decrypt(user['key'], b'', iv, ciphertext, tag)
         except Exception as e:
             logging.error(e)
             return None
-        # print(binascii.b2a_hex(plaintext))
+
+        if Config.IS_DEBUG:
+            logging.info(
+                f'UDP-From-{self.client_address[0]}-{binascii.b2a_hex(plaintext)}')
 
         commands = CommandParser(
             user['room'], user['player_index']).get_commands(plaintext)
 
         if user['room'].players[user['player_index']].player_id == 0:
             clear_player(bi(token))
-            temp = []
-            for i in commands:
-                if i[:3] == b'\x06\x16\x12':
-                    temp.append(i)
-            commands = temp
+            if user['room'].player_num == 0:
+                clear_room(user['room'])
+            commands = [i for i in commands if i[2] == 0x12]
             # 处理不能正确被踢的问题
 
         for i in commands:
             iv, ciphertext, tag = encrypt(user['key'], i, b'')
-            # print(binascii.b2a_hex(i))
+            if Config.IS_DEBUG:
+                logging.info(
+                    f'UDP-To-{self.client_address[0]}-{binascii.b2a_hex(i)}')
 
             server.sendto(token + iv + tag[:12] +
                           ciphertext, self.client_address)
@@ -140,118 +67,7 @@ class TCP_handler(socketserver.StreamRequestHandler):
                             self.client_address[0])
             return None
 
-        global clean_timer
-        now = round(time.time() * 1000)
-        if now - clean_timer >= Config.TIME_LIMIT:
-            logging.info('Start cleaning memory...')
-            clean_timer = now
-            memory_clean(now)
-
-        self.wfile.write(data_swap(data[1:]).encode('utf-8'))
-
-
-def data_swap(data: list) -> str:
-    # data: list[str] = [command, ...]
-    if data[0] == '1':
-        # 开房
-        # data = ['1', name, song_unlock, ]
-        # song_unlock: base64 str
-        name = data[1]
-        song_unlock = base64.b64decode(data[2])
-
-        key = urandom(16)
-        with lock:
-            room_id = unique_random(room_id_dict)
-
-            room = Room()
-            room.room_id = room_id
-            room_id_dict[room_id] = room
-
-            player_id = unique_random(player_dict, 3)
-            player = Player()
-            player.player_id = player_id
-            player.set_player_name(name)
-            player_dict[player_id] = player
-
-            player.song_unlock = song_unlock
-            room.song_unlock = song_unlock
-            room.host_id = player_id
-            room.players[0] = player
-            room.player_num = 1
-
-            room_code = unique_random(
-                room_code_dict, random_func=random_room_code)
-            room.room_code = room_code
-            room_code_dict[room_code] = room
-
-            token = room_id
-            player.token = token
-
-            link_play_data[token] = {'key': key,
-                                     'room': room,
-                                     'player_index': 0,
-                                     'player_id': player_id}
-
-        logging.info('TCP-Create room `%s` by player `%s`' % (room_code, name))
-        return '|'.join([str(x) for x in (0, room_code, room_id, token, base64.b64encode(key).decode('utf-8'), player_id)])
-
-    elif data[0] == '2':
-        # 入房
-        # data = ['2', name, song_unlock, room_code]
-        # song_unlock: base64 str
-        room_code = data[3].upper()
-        with lock:
-            if room_code not in room_code_dict:
-                # 房间号错误
-                return '1202'
-            room = room_code_dict[room_code]
-
-            if room.player_num == 4:
-                # 满人
-                return '1201'
-            elif room.state != 2:
-                # 无法加入
-                return '1205'
-
-        name = data[1]
-        song_unlock = base64.b64decode(data[2])
-
-        key = urandom(16)
-        with lock:
-            token = unique_random(link_play_data)
-            player_id = unique_random(player_dict, 3)
-
-            player = Player()
-            player.player_id = player_id
-            player.set_player_name(name)
-            player.token = token
-            player_dict[player_id] = player
-            player.song_unlock = song_unlock
-            room.update_song_unlock()
-            for i in range(4):
-                if room.players[i].player_id == 0:
-                    room.players[i] = player
-                    player_index = i
-                    break
-            link_play_data[token] = {'key': key,
-                                     'room': room,
-                                     'player_index': player_index,
-                                     'player_id': player_id}
-
-        logging.info('TCP-Player `%s` joins room `%s`' % (name, room_code))
-        return '|'.join([str(x) for x in (0, room_code, room.room_id, token, base64.b64encode(key).decode('utf-8'), player_id, base64.b64encode(room.song_unlock).decode('utf-8'))])
-
-    elif data[0] == '3':
-        # 房间信息更新
-        # data = ['3', token]
-        token = int(data[1])
-        with lock:
-            if token in link_play_data:
-                r = link_play_data[token]
-                logging.info('TCP-Room `%s` info update' % room_code)
-                return '|'.join([str(x) for x in (0, r['room'].room_code, r['room'].room_id, base64.b64encode(r['key']).decode('utf-8'), r['room'].players[r['player_index']].player_id, base64.b64encode(r['room'].song_unlock).decode('utf-8'))])
-            else:
-                return '108'
+        self.wfile.write(TCPRouter(data[1:]).handle().encode('utf-8'))
 
 
 def link_play(ip: str = Config.HOST, udp_port: int = Config.UDP_PORT, tcp_port: int = Config.TCP_PORT):

latest version/linkplay_server/store.py

@@ -0,0 +1,227 @@
+import logging
+from base64 import b64decode, b64encode
+from os import urandom
+from random import randint
+from threading import RLock
+from time import time
+
+from .config import Config
+from .udp_class import Player, Room, bi
+
+
+class Store:
+    # token: {'key': key, 'room': Room, 'player_index': player_index, 'player_id': player_id}
+    link_play_data = {}
+    room_id_dict = {}  # 'room_id': Room
+    room_code_dict = {}  # 'room_code': Room
+    player_dict = {}  # 'player_id' : Player
+
+    lock = RLock()
+
+
+def random_room_code():
+    re = ''
+    for _ in range(4):
+        re += chr(randint(65, 90))
+    for _ in range(2):
+        re += str(randint(0, 9))
+    return re
+
+
+def unique_random(dataset, length=8, random_func=None):
+    '''无重复随机，且默认非0，没处理可能的死循环'''
+    if random_func is None:
+        x = bi(urandom(length))
+        while x in dataset or x == 0:
+            x = bi(urandom(length))
+    else:
+        x = random_func()
+        while x in dataset:
+            x = random_func()
+    return x
+
+
+def clear_player(token):
+    # 清除玩家信息和token
+    del Store.player_dict[Store.link_play_data[token]['player_id']]
+    del Store.link_play_data[token]
+
+
+def clear_room(room):
+    # 清除房间信息
+    room_id = room.room_id
+    room_code = room.room_code
+    del Store.room_id_dict[room_id]
+    del Store.room_code_dict[room_code]
+    del room
+
+
+def memory_clean(now):
+    # 内存清理，应对玩家不正常退出
+    with Store.lock:
+        clean_room_list = []
+        clean_player_list = []
+        for token in Store.link_play_data:
+            room = Store.link_play_data[token]['room']
+            if now - room.timestamp >= Config.TIME_LIMIT:
+                clean_room_list.append(room.room_id)
+
+            if now - room.players[Store.link_play_data[token]['player_index']].last_timestamp // 1000 >= Config.TIME_LIMIT:
+                clean_player_list.append(token)
+
+        for room_id in Store.room_id_dict:
+            if now - Store.room_id_dict[room_id].timestamp >= Config.TIME_LIMIT:
+                clean_room_list.append(room_id)
+
+        for room_id in clean_room_list:
+            if room_id in Store.room_id_dict:
+                clear_room(Store.room_id_dict[room_id])
+
+        for token in clean_player_list:
+            clear_player(token)
+
+
+class TCPRouter:
+    clean_timer = 0
+    router = {
+        '0': 'debug',
+        '1': 'create_room',
+        '2': 'join_room',
+        '3': 'update_room',
+    }
+
+    def __init__(self, data: list):
+        self.data = data  # data: list[str] = [command, ...]
+
+    def debug(self):
+        if Config.IS_DEBUG:
+            return eval(self.data[1])
+        return 'ok'
+
+    @staticmethod
+    def clean_check():
+        now = round(time() * 1000)
+        if now - TCPRouter.clean_timer >= Config.TIME_LIMIT:
+            logging.info('Start cleaning memory...')
+            TCPRouter.clean_timer = now
+            memory_clean(now)
+
+    def handle(self) -> str:
+        self.clean_check()
+        if self.data[0] not in self.router:
+            return None
+        r = getattr(self, self.router[self.data[0]])()
+        if isinstance(r, tuple):
+            return '|'.join(map(str, r))
+        return str(r)
+
+    @staticmethod
+    def generate_player(name: str) -> Player:
+        player_id = unique_random(Store.player_dict, 3)
+        player = Player()
+        player.player_id = player_id
+        player.set_player_name(name)
+
+        Store.player_dict[player_id] = player
+
+        return player
+
+    @staticmethod
+    def generate_room() -> Room:
+        room_id = unique_random(Store.room_id_dict)
+        room = Room()
+        room.room_id = room_id
+        room.timestamp = round(time() * 1000)
+        Store.room_id_dict[room_id] = room
+
+        room_code = unique_random(
+            Store.room_code_dict, random_func=random_room_code)
+        room.room_code = room_code
+        Store.room_code_dict[room_code] = room
+
+        return room
+
+    def create_room(self) -> tuple:
+        # 开房
+        # data = ['1', name, song_unlock, ]
+        # song_unlock: base64 str
+        name = self.data[1]
+        song_unlock = b64decode(self.data[2])
+
+        key = urandom(16)
+        with Store.lock:
+            room = self.generate_room()
+            player = self.generate_player(name)
+
+            player.song_unlock = song_unlock
+            room.song_unlock = song_unlock
+            room.host_id = player.player_id
+            room.players[0] = player
+
+            token = room.room_id
+            player.token = token
+
+            Store.link_play_data[token] = {
+                'key': key,
+                'room': room,
+                'player_index': 0,
+                'player_id': player.player_id
+            }
+
+        logging.info(f'TCP-Create room `{room.room_code}` by player `{name}`')
+        return (0, room.room_code, room.room_id, token, b64encode(key).decode('utf-8'), player.player_id)
+
+    def join_room(self) -> tuple:
+        # 入房
+        # data = ['2', name, song_unlock, room_code]
+        # song_unlock: base64 str
+        room_code = self.data[3].upper()
+        key = urandom(16)
+        name = self.data[1]
+        song_unlock = b64decode(self.data[2])
+
+        with Store.lock:
+            if room_code not in Store.room_code_dict:
+                # 房间号错误 / 房间不存在
+                return '1202'
+            room: Room = Store.room_code_dict[room_code]
+
+            if room.player_num == 4:
+                # 满人
+                return '1201'
+            elif room.state != 2:
+                # 无法加入
+                return '1205'
+
+            token = unique_random(Store.link_play_data)
+
+            player = self.generate_player(name)
+            player.token = token
+            player.song_unlock = song_unlock
+            room.update_song_unlock()
+            for i in range(4):
+                if room.players[i].player_id == 0:
+                    room.players[i] = player
+                    player_index = i
+                    break
+            Store.link_play_data[token] = {
+                'key': key,
+                'room': room,
+                'player_index': player_index,
+                'player_id': player.player_id
+            }
+
+        logging.info(f'TCP-Player `{name}` joins room `{room_code}`')
+        return (0, room_code, room.room_id, token, b64encode(key).decode('utf-8'), player.player_id, b64encode(room.song_unlock).decode('utf-8'))
+
+    def update_room(self) -> tuple:
+        # 房间信息更新
+        # data = ['3', token]
+        token = int(self.data[1])
+        with Store.lock:
+            if token not in Store.link_play_data:
+                return '108'
+            r = Store.link_play_data[token]
+            room = r['room']
+            logging.info(f'TCP-Room `{room.room_code}` info update')
+            return (0, room.room_code, room.room_id, b64encode(r['key']).decode('utf-8'), room.players[r['player_index']].player_id, b64encode(room.song_unlock).decode('utf-8'))

latest version/linkplay_server/udp_class.py

@@ -61,11 +61,10 @@ class Room:
         self.song_idx = 0xffff
         self.last_song_idx = 0xffff
 
-        self.song_unlock = b'\x00' * Config.LINK_PLAY_UNLOCK_LENGTH
+        self.song_unlock = b'\xFF' * Config.LINK_PLAY_UNLOCK_LENGTH
 
         self.host_id = 0
         self.players = [Player(), Player(), Player(), Player()]
-        self.player_num = 0
 
         self.interval = 1000
         self.times = 100
@@ -73,7 +72,14 @@ class Room:
         self.round_switch = 0
 
         self.command_queue = []
-        self.command_queue_length = 0
+
+    @property
+    def command_queue_length(self) -> int:
+        return len(self.command_queue)
+
+    @property
+    def player_num(self) -> int:
+        return sum(i.player_id != 0 for i in self.players)
 
     def get_players_info(self):
         # 获取所有玩家信息
@@ -113,7 +119,6 @@ class Room:
 
     def delete_player(self, player_index: int):
         # 删除某个玩家
-        self.player_num -= 1
         if self.players[player_index].player_id == self.host_id:
             self.make_round()
 

latest version/linkplay_server/udp_parser.py

@@ -6,31 +6,23 @@ from .udp_sender import CommandSender
 
 
 class CommandParser:
+    route = [None, 'command_01', 'command_02', 'command_03', 'command_04', 'command_05',
+             'command_06', 'command_07', 'command_08', 'command_09', 'command_0a', 'command_0b']
+
     def __init__(self, room: Room, player_index: int = 0) -> None:
         self.room = room
         self.player_index = player_index
+        self.s = CommandSender(self.room)
 
     def get_commands(self, command):
         self.command = command
-        l = {b'\x06\x16\x01': self.command_01,
-             b'\x06\x16\x02': self.command_02,
-             b'\x06\x16\x03': self.command_03,
-             b'\x06\x16\x04': self.command_04,
-             b'\x06\x16\x05': self.command_05,
-             b'\x06\x16\x06': self.command_06,
-             b'\x06\x16\x07': self.command_07,
-             b'\x06\x16\x08': self.command_08,
-             b'\x06\x16\x09': self.command_09,
-             b'\x06\x16\x0a': self.command_0a,
-             b'\x06\x16\x0b': self.command_0b
-             }
-        r = l[command[:3]]()
+        r = getattr(self, self.route[self.command[2]])()
 
         re = []
 
         flag_13 = False
         for i in range(max(bi(self.command[12:16]), self.room.players[self.player_index].start_command_num), self.room.command_queue_length):
-            if self.room.command_queue[i][:3] == b'\x06\x16\x13':
+            if self.room.command_queue[i][2] == 0x13:
                 if flag_13:
                     break
                 flag_13 = True
@@ -52,16 +44,13 @@ class CommandParser:
             if i.player_id == player_id and i.online == 1:
                 self.room.host_id = player_id
 
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_10())
+        self.s.random_code = self.command[16:24]
+        self.room.command_queue.append(self.s.command_10())
 
         return None
 
     def command_02(self):
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
+        self.s.random_code = self.command[16:24]
         song_idx = bi(self.command[24:26])
 
         flag = 2
@@ -69,17 +58,14 @@ class CommandParser:
             flag = 0
             self.room.state = 3
             self.room.song_idx = song_idx
-            self.room.command_queue_length += 1
-            self.room.command_queue.append(x.command_11())
-            self.room.command_queue_length += 1
-            self.room.command_queue.append(x.command_13())
+            self.room.command_queue.append(self.s.command_11())
+            self.room.command_queue.append(self.s.command_13())
 
-        return [x.command_0d(flag)]
+        return [self.s.command_0d(flag)]
 
     def command_03(self):
         # 尝试进入结算
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
+        self.s.random_code = self.command[16:24]
         player = self.room.players[self.player_index]
         player.score = bi(self.command[24:28])
         player.cleartype = self.command[28]
@@ -89,20 +75,17 @@ class CommandParser:
         player.last_timestamp -= Config.COMMAND_INTERVAL
         self.room.last_song_idx = self.room.song_idx
 
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_12(self.player_index))
+        self.room.command_queue.append(self.s.command_12(self.player_index))
 
         if self.room.is_finish():
             self.room.make_finish()
-            self.room.command_queue_length += 1
-            self.room.command_queue.append(x.command_13())
+            self.room.command_queue.append(self.s.command_13())
 
         return None
 
     def command_04(self):
         # 踢人
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
+        self.s.random_code = self.command[16:24]
         player_id = bi(self.command[24:32])
         flag = 2
         if self.room.players[self.player_index].player_id == self.room.host_id and player_id != self.room.host_id:
@@ -110,51 +93,42 @@ class CommandParser:
                 if self.room.players[i].player_id == player_id:
                     flag = 1
                     self.room.delete_player(i)
-                    self.room.command_queue_length += 1
-                    self.room.command_queue.append(x.command_12(i))
+                    self.room.command_queue.append(self.s.command_12(i))
                     self.room.update_song_unlock()
-                    self.room.command_queue_length += 1
-                    self.room.command_queue.append(x.command_14())
+                    self.room.command_queue.append(self.s.command_14())
                     break
 
-        return [x.command_0d(flag)]
+        return [self.s.command_0d(flag)]
 
     def command_05(self):
         pass
 
     def command_06(self):
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
+        self.s.random_code = self.command[16:24]
         self.room.state = 1
         self.room.song_idx = 0xffff
 
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_13())
+        self.room.command_queue.append(self.s.command_13())
         return None
 
     def command_07(self):
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
+        self.s.random_code = self.command[16:24]
         self.room.players[self.player_index].song_unlock = self.command[24:536]
         self.room.update_song_unlock()
 
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_14())
+        self.room.command_queue.append(self.s.command_14())
         return None
 
     def command_08(self):
         self.room.round_switch = bi(self.command[24:25])
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_13())
+        self.s.random_code = self.command[16:24]
+        self.room.command_queue.append(self.s.command_13())
 
         return None
 
     def command_09(self):
         re = []
-        x = CommandSender(self.room)
-        x.random_code = self.command[16:24]
+        self.s.random_code = self.command[16:24]
         player = self.room.players[self.player_index]
 
         if bi(self.command[12:16]) == 0:
@@ -162,12 +136,11 @@ class CommandParser:
             self.room.state = 1
             self.room.update_song_unlock()
             player.start_command_num = self.room.command_queue_length
-            self.room.command_queue_length += 1
-            self.room.command_queue.append(x.command_15())
+            self.room.command_queue.append(self.s.command_15())
         else:
-            if x.timestamp - player.last_timestamp >= Config.COMMAND_INTERVAL:
-                re.append(x.command_0c())
-                player.last_timestamp = x.timestamp
+            if self.s.timestamp - player.last_timestamp >= Config.COMMAND_INTERVAL:
+                re.append(self.s.command_0c())
+                player.last_timestamp = self.s.timestamp
 
             flag_13 = False
             # 离线判断
@@ -176,14 +149,14 @@ class CommandParser:
                     t = self.room.players[i]
                     if t.player_id != 0:
                         if t.last_timestamp != 0:
-                            if t.online == 1 and x.timestamp - t.last_timestamp >= Config.PLAYER_PRE_TIMEOUT:
+                            if t.online == 1 and self.s.timestamp - t.last_timestamp >= Config.PLAYER_PRE_TIMEOUT:
                                 t.online = 0
-                                self.room.command_queue_length += 1
-                                self.room.command_queue.append(x.command_12(i))
-                            elif t.online == 0 and x.timestamp - t.last_timestamp >= Config.PLAYER_TIMEOUT:
+                                self.room.command_queue.append(
+                                    self.s.command_12(i))
+                            elif t.online == 0 and self.s.timestamp - t.last_timestamp >= Config.PLAYER_TIMEOUT:
                                 self.room.delete_player(i)
-                                self.room.command_queue_length += 1
-                                self.room.command_queue.append(x.command_12(i))
+                                self.room.command_queue.append(
+                                    self.s.command_12(i))
                                 flag_13 = True
 
             flag_11 = False
@@ -276,7 +249,7 @@ class CommandParser:
                 if player.timer != 0 or self.room.state != 8:
                     for i in self.room.players:
                         i.extra_command_queue.append(
-                            x.command_0e(self.player_index))
+                            self.s.command_0e(self.player_index))
 
                 if self.room.is_ready(8, 1):
                     flag_13 = True
@@ -293,14 +266,12 @@ class CommandParser:
                     flag_13 = True
 
             if flag_11:
-                self.room.command_queue_length += 1
-                self.room.command_queue.append(x.command_11())
+                self.room.command_queue.append(self.s.command_11())
             if flag_12:
-                self.room.command_queue_length += 1
-                self.room.command_queue.append(x.command_12(self.player_index))
+                self.room.command_queue.append(
+                    self.s.command_12(self.player_index))
             if flag_13:
-                self.room.command_queue_length += 1
-                self.room.command_queue.append(x.command_13())
+                self.room.command_queue.append(self.s.command_13())
 
         return re
 
@@ -308,28 +279,22 @@ class CommandParser:
         # 退出房间
         self.room.delete_player(self.player_index)
 
-        x = CommandSender(self.room)
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_12(self.player_index))
+        self.room.command_queue.append(self.s.command_12(self.player_index))
 
         if self.room.state == 3 or self.room.state == 2:
             self.room.state = 1
             self.room.song_idx = 0xffff
-        # self.room.command_queue_length += 1
-        # self.room.command_queue.append(x.command_11())
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_13())
-        self.room.command_queue_length += 1
-        self.room.command_queue.append(x.command_14())
+        # self.room.command_queue.append(self.s.command_11())
+        self.room.command_queue.append(self.s.command_13())
+        self.room.command_queue.append(self.s.command_14())
         return None
 
     def command_0b(self):
         # 推荐歌曲
         song_idx = bi(self.command[16:18])
-        x = CommandSender(self.room)
         for i in range(4):
             if self.player_index != i and self.room.players[i].online == 1:
                 self.room.players[i].extra_command_queue.append(
-                    x.command_0f(self.player_index, song_idx))
+                    self.s.command_0f(self.player_index, song_idx))
 
         return None

latest version/linkplay_server/udp_sender.py

@@ -1,46 +1,64 @@
-import time
+from time import time
+
 from .udp_class import Room, b
 
 
 class CommandSender:
-    def __init__(self, room: Room = Room()) -> None:
+
+    PROTOCOL_NAME = b'\x06\x16'
+    PROTOCOL_VERSION = b'\x09'
+
+    def __init__(self, room: Room = None) -> None:
         self.room = room
-        self.timestamp = round(time.time() * 1000000)
+        self.timestamp = round(time() * 1000000)
 
         self.random_code = b'\x11\x11\x11\x11\x00\x00\x00\x00'
 
+    @staticmethod
+    def command_encode(t: tuple):
+        r = b''.join(t)
+        x = 16 - len(r) % 16
+        return r + b(x) * x
+
+    def command_prefix(self, command: bytes):
+        length = self.room.command_queue_length
+        if command >= b'\x10':
+            length += 1
+
+        return (self.PROTOCOL_NAME, command, self.PROTOCOL_VERSION, b(self.room.room_id, 8), b(length, 4))
+
     def command_0c(self):
-        return b'\x06\x16\x0c\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + b(self.room.state) + b(self.room.countdown, 4) + b(self.timestamp, 8) + b'\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b'
+        return self.command_encode((*self.command_prefix(b'\x0c'), self.random_code, b(self.room.state), b(self.room.countdown, 4), b(self.timestamp, 8)))
 
     def command_0d(self, code: int):
-        return b'\x06\x16\x0d\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + b(code) + b'\x07\x07\x07\x07\x07\x07\x07'
+        return self.command_encode((*self.command_prefix(b'\x0d'), self.random_code, b(code)))
 
     def command_0e(self, player_index: int):
         # 分数广播
         player = self.room.players[player_index]
-        return b'\x06\x16\x0e\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + b(player.player_id, 8) + b(player.character_id) + b(player.is_uncapped) + b(player.difficulty) + b(player.score, 4) + b(player.timer, 4) + b(player.cleartype) + b(player.player_state) + b(player.download_percent) + b'\x01' + b(player.last_score, 4) + b(player.last_timer, 4) + b(player.online)
+        return self.command_encode((*self.command_prefix(b'\x0e'), b(player.player_id, 8), b(player.character_id), b(player.is_uncapped), b(player.difficulty), b(player.score, 4), b(player.timer, 4), b(player.cleartype), b(player.player_state), b(player.download_percent), b'\x01', b(player.last_score, 4), b(player.last_timer, 4), b(player.online)))
 
     def command_0f(self, player_index: int, song_idx: int):
         # 歌曲推荐
         player = self.room.players[player_index]
-        return b'\x06\x16\x0f\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + b(player.player_id, 8) + b(song_idx, 2) + b'\x06\x06\x06\x06\x06\x06'
+        return self.command_encode((*self.command_prefix(b'\x0f'), b(player.player_id, 8), b(song_idx, 2)))
 
     def command_10(self):
         # 房主宣告
-        return b'\x06\x16\x10\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + b(self.room.host_id, 8)
+        return self.command_encode((*self.command_prefix(b'\x10'), self.random_code, b(self.room.host_id, 8)))
 
     def command_11(self):
-        return b'\x06\x16\x11\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + self.room.get_players_info() + b'\x08\x08\x08\x08\x08\x08\x08\x08'
+        return self.command_encode((*self.command_prefix(b'\x11'), self.random_code, self.room.get_players_info()))
 
     def command_12(self, player_index: int):
         player = self.room.players[player_index]
-        return b'\x06\x16\x12\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + b(player_index) + b(player.player_id, 8) + b(player.character_id) + b(player.is_uncapped) + b(player.difficulty) + b(player.score, 4) + b(player.timer, 4) + b(player.cleartype) + b(player.player_state) + b(player.download_percent) + b(player.online)
+        return self.command_encode((*self.command_prefix(b'\x12'), self.random_code, b(player_index), b(player.player_id, 8), b(player.character_id), b(player.is_uncapped), b(player.difficulty), b(player.score, 4), b(player.timer, 4), b(player.cleartype), b(player.player_state), b(player.download_percent), b(player.online)))
 
     def command_13(self):
-        return b'\x06\x16\x13\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + b(self.room.host_id, 8) + b(self.room.state) + b(self.room.countdown, 4) + b(self.timestamp, 8) + b(self.room.song_idx, 2) + b(self.room.interval, 2) + b(self.room.times, 7) + self.room.get_player_last_score() + b(self.room.last_song_idx, 2) + b(self.room.round_switch, 1) + b'\x01'
+        return self.command_encode((*self.command_prefix(b'\x13'), self.random_code, b(self.room.host_id, 8), b(self.room.state), b(self.room.countdown, 4), b(self.timestamp, 8), b(self.room.song_idx, 2), b(self.room.interval, 2), b(self.room.times, 7), self.room.get_player_last_score(), b(self.room.last_song_idx, 2), b(self.room.round_switch, 1)))
 
     def command_14(self):
-        return b'\x06\x16\x14\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.random_code + self.room.song_unlock + b'\x08\x08\x08\x08\x08\x08\x08\x08'
+        return self.command_encode((*self.command_prefix(b'\x14'), self.random_code, self.room.song_unlock))
 
     def command_15(self):
-        return b'\x06\x16\x15\x09' + b(self.room.room_id, 8) + b(self.room.command_queue_length, 4) + self.room.get_players_info() + self.room.song_unlock + b(self.room.host_id, 8) + b(self.room.state) + b(self.room.countdown, 4) + b(self.timestamp, 8) + b(self.room.song_idx, 2) + b(self.room.interval, 2) + b(self.room.times, 7) + self.room.get_player_last_score() + b(self.room.last_song_idx, 2) + b(self.room.round_switch, 1) + b'\x09\x09\x09\x09\x09\x09\x09\x09\x09'
+        return self.command_encode((*self.command_prefix(b'\x15'), self.room.get_players_info(), self.room.song_unlock, b(self.room.host_id, 8), b(self.room.state), b(self.room.countdown, 4), b(self.timestamp, 8), b(self.room.song_idx, 2), b(self.room.interval, 2), b(self.room.times, 7), self.room.get_player_last_score(), b(self.room.last_song_idx, 2), b(self.room.round_switch, 1)))