弹幕显示作业

color.py

from random import randint


class Color:
    """颜色类"""
    white = 255, 255, 255

    @staticmethod
    def rand_color():
        return randint(0, 255), randint(0, 255), randint(0, 255)

server.py

"""
注意：
1.想要结束一个进程就是让它里面的所有的线程都结束，进程才会结束
2.想要关闭一个子线程，就是想方设法让子线程中的任务结束(就是让run方法结束)
3.如果一个线程崩溃(发生异常)，不会影响其他线程
"""

"""
写一个服务器，可以和多个客户端同时通信，并且把接收到的消息显示在屏幕上
"""

import socket
import pygame
from random import randint
from color import Color
import myThread

def creat_server():
    """创建服务器"""
    server = socket.socket()
    server.bind(('10.7.181.117', 8050))
    server.listen(512)

    # 在一个子线程中去监听客户端的请求
    server_thread = myThread.AcceptThread(server)
    server_thread.start()
    
    return server_thread


if __name__ == '__main__':

    # 0. 创建服务器
    t1 = creat_server()

    # 1.准备显示信息的屏幕
    pygame.init()
    screen = pygame.display.set_mode((600, 400))
    screen.fill(Color.white)
    pygame.display.flip()

    # 2.让屏幕可以一直存在
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                exit()

        # 获取每条信息，显示在屏幕上
        screen.fill(Color.white)
        for message in myThread.ConversationThread.all_message[:]:
            if message.alive:
                # 显示信息
                font = pygame.font.SysFont('Times', 30)
                text = font.render(message.text, True, message.color)
                screen.blit(text, (message.x, message.y))
                # 动起来
                message.move()
            else:
                myThread.ConversationThread.all_message.remove(message)

        pygame.display.update()

    print('退出1')

My_Thread.py

from threading import Thread
import socket
from random import randint
from color import Color



class Massage:
    """文字信息类"""
    def __init__(self, text):
        self.text = text
        self.x = -50
        self.y = randint(0, 380)
        self.color = Color.rand_color()
        self.speed = randint(2, 5)
        self.alive = True

    def move(self):
        self.x += self.speed
        # 越界处理
        if self.x > 600 + 50:
            self.alive = False

class ConversationThread(Thread):
    """处理不同的客户端信息"""
    all_message = []

    def __init__(self, conversation:socket.socket):
        super().__init__()
        self.conversation = conversation

    def run(self):
        """让服务器和客户端一直保持通话"""
        while True:
            # 接收客户端发来的消息
            try:
                re_message = self.conversation.recv(1024).decode(encoding='utf-8')
                # 接收到一条消息就创建一个消息对象
                message = Massage(re_message)
                # 保存所有的消息
                ConversationThread.all_message.append(message)
                print('=====')

            except ConnectionResetError:
                print('[XXX已下线]')
                break

            # 给客户端发送消息
            self.conversation.send(' '.encode())


class AcceptThread(Thread):
    """接收请求的线程类"""
    all_client = []   # 保存所有的客户端
    def __init__(self, server:socket.socket):
        super().__init__()
        self.server = server
        self.flag = True

    def run(self):
        """不断接收客户端的请求"""
        while self.flag:
            conversation, addr = self.server.accept()
            # print('接收到客户端的请求')

            # 来了一个客户端请求，就给他创建一个子线程，来处理对应的消息
            9+99            t1.start()
            AcceptThread.all_client.append(t1)

        # 在关闭服务器之前，给所有的客户端发送消息
        for tt in AcceptThread.all_client:
            try:
                tt.conversation.send('exit'.encode())
            except:
                pass
        print('退出2')

client.py

import socket

if __name__ == '__main__':
    client = socket.socket()
    client.connect(('10.7.181.117', 8050))
    while True:
        # 接收服务器返回的信息
        re_message = client.recv(1024).decode(encoding='utf-8')
        print(re_message)

        # 发送消息
        message = input('>>>')
        # message = '好吧abc'
        client.send(message.encode())