⚡ 𝙎𝘽𝙂 𝙓 𝙎𝙏𝙊𝙍𝙀 ⚡

# --- NEW /roominfo COMMAND ---
                            if self.inPuTMsG.startswith('/roominfo'):
                                parts = self.inPuTMsG.strip().split()
                                try:
                                    room_info_requester = (uid, chat_id, self.XX)
                                    await self.SEndPacKeT(self.whisper_writer , self.online_writer , 'OnLine', await SendRoomInfo(int(parts[1]), key, iv))
                                except: pass

if self.data2.hex().startswith("0e00"):
                            # NEW LOGIC FOR /ROOMINFO
                            if room_info_requester:
                                try:
                                    info_packet = await DeCode_PackEt(self.data2.hex()[10:])
                                    message = get_room_info(info_packet)
                                    req_uid, req_chat_id, req_type = room_info_requester
                                    P = await self.SEndMsG(req_type, message, req_uid, req_chat_id, key, iv)
                                    await self.SEndPacKeT(self.whisper_writer , self.online_writer , 'ChaT', P)
                                except Exception as e:
                                    print(f"Error processing room info: {e}")
                                finally:
                                    room_info_requester = None
                            else:
                                # ORIGINAL LOGIC
                                info = await DeCode_PackEt(self.data2.hex()[10:])
                                message = get_room_info(info)
                                P = await self.SEndMsG(2 , message , uid , chat_id , key , iv)
                                await self.SEndPacKeT(self.whisper_writer , self.online_writer , 'ChaT' , P)

async def TcPOnLine(self,ip, port, key, iv, AutHToKen, reconnect_delay=0.5):
        global  spam_room , spammer_uid , spam_chat_id , spam_uid , XX , uid , Spy, Chat_Leave , joining_team, room_info_requester, room_spam_requester
        while True:
            try:
                reader , writer = await asyncio.open_connection(ip, int(port))
                self.online_writer = writer
                bytes_payload = bytes.fromhex(AutHToKen)
                self.online_writer.write(bytes_payload)
                await self.online_writer.drain()
                while True:
                    self.data2 = await reader.read(9999)
                    #print(self.data2.hex())
                    data2 = self.data2
                    if not data2: break
                    
                    if self.data2:
                        
                        # --- MODIFIED LOGIC START ---
                        if self.data2.hex().startswith("0f00"):
                            info_packet_data = await DeCode_PackEt(self.data2.hex()[10:])
                            if room_spam_requester:
                                status_result = get_player_status(info_packet_data)
                                target_uid = room_spam_requester['target_uid']
                                requester_uid = room_spam_requester['requester_uid']
                                requester_chat_id = room_spam_requester['requester_chat_id']
                                requester_chat_type = room_spam_requester['requester_chat_type']

                                if isinstance(status_result, dict) and status_result.get("IN_ROOM"):
                                    room_id = status_result['room_uid']
                                    P_start = await self.SEndMsG(requester_chat_type, f"[c]Player is in room {room_id}. Starting spam...", requester_uid, requester_chat_id, key, iv)
                                    await self.SEndPacKeT(self.whisper_writer, self.online_writer, 'ChaT', P_start)
                                    
                                    # Perform the spam
                                    for _ in range(50):  # Spam 50 times
                                        spam_packet = await SPam_Room(requester_uid, room_id, "SPAM", key, iv)
                                        await self.SEndPacKeT(self.whisper_writer, self.online_writer, 'OnLine', spam_packet)
                                        await asyncio.sleep(0.1)
                                    
                                    P_done = await self.SEndMsG(requester_chat_type, f"[c]Spam attack on room {room_id} finished.", requester_uid, requester_chat_id, key, iv)
                                    await self.SEndPacKeT(self.whisper_writer, self.online_writer, 'ChaT', P_done)
                                else:
                                    P_fail = await self.SEndMsG(requester_chat_type, f"[c]Player {target_uid} is not in a custom room.", requester_uid, requester_chat_id, key, iv)
                                    await self.SEndPacKeT(self.whisper_writer, self.online_writer, 'ChaT', P_fail)
                                
                                room_spam_requester = None  # Clear the request
                            else:
                                # Original logic for general status checks
                                self.STATUS = get_player_status(info_packet_data)
                                if "IN_ROOM" in self.STATUS:
                                    room_uid_status = self.STATUS['room_uid']
                                    await self.SEndPacKeT(self.whisper_writer, self.online_writer, 'OnLine', await SendRoomInfo(int(room_uid_status), key, iv))
                                else:
                                    message = self.STATUS
                                    P = await self.SEndMsG(2, message, uid, chat_id, key, iv)
                                    await self.SEndPacKeT(self.whisper_writer, self.online_writer, 'ChaT', P)