235 lines
8.4 KiB
Python
235 lines
8.4 KiB
Python
# -------------------------------
|
|
# Difficult Rocket
|
|
# Copyright © 2021 by shenjackyuanjie
|
|
# All rights reserved
|
|
# -------------------------------
|
|
|
|
"""
|
|
writen by shenjackyuanjie
|
|
mail: 3695888@qq.com
|
|
github: @shenjackyuanjie
|
|
gitee: @shenjackyuanjie
|
|
"""
|
|
|
|
# system function
|
|
import os
|
|
import sys
|
|
import time
|
|
import random
|
|
import logging
|
|
import threading
|
|
import configparser
|
|
import multiprocessing
|
|
|
|
from decimal import Decimal
|
|
from multiprocessing import Pipe
|
|
from multiprocessing.connection import Connection
|
|
|
|
if __name__ == '__main__': # been start will not run this
|
|
sys.path.append('/bin/libs')
|
|
sys.path.append('/bin')
|
|
|
|
# Difficult_Rocket function
|
|
from Difficult_Rocket import crash
|
|
from Difficult_Rocket.api.Exp import *
|
|
from Difficult_Rocket.api.translate import tr
|
|
from Difficult_Rocket.drag_sprite import DragSprite
|
|
from Difficult_Rocket.api import tools, load_file, new_thread, thread
|
|
|
|
# libs function
|
|
local_lib = True
|
|
if local_lib:
|
|
from libs import pyglet
|
|
from libs.pyglet.window import key, mouse
|
|
else:
|
|
import pyglet
|
|
from pyglet.window import key, mouse
|
|
|
|
|
|
class Client:
|
|
def __init__(self, net_mode='local'):
|
|
# logging
|
|
self.logger = logging.getLogger('client')
|
|
# config
|
|
self.config = tools.load_file('configs/main.config')
|
|
# lang
|
|
self.lang = tools.load_file('configs/lang/%s.json5' % self.config['runtime']['language'], 'client')
|
|
# value
|
|
self.process_id = 'Client'
|
|
self.process_name = 'Client process'
|
|
self.process_pid = os.getpid()
|
|
self.net_mode = net_mode
|
|
self.caption = tools.name_handler(self.config['window']['caption'], {'version': self.config['runtime']['version']})
|
|
self.window = ClientWindow(net_mode=self.net_mode,
|
|
width=int(self.config['window']['width']),
|
|
height=int(self.config['window']['height']),
|
|
fullscreen=tools.format_bool(self.config['window']['full_screen']),
|
|
caption=self.caption,
|
|
resizable=tools.format_bool(self.config['window']['resizable']),
|
|
visible=tools.format_bool(self.config['window']['visible']))
|
|
self.logger.info(tr['client']['setup.done'])
|
|
|
|
def start(self):
|
|
self.window.start_game() # 游戏启动
|
|
# TODO 写一下服务端启动相关，还是需要服务端啊
|
|
|
|
|
|
class ClientWindow(pyglet.window.Window):
|
|
|
|
def __init__(self, net_mode='local', *args, **kwargs):
|
|
self.times = [time.time()]
|
|
super().__init__(*args, **kwargs)
|
|
"""
|
|
:param dev_list: 共享内存
|
|
:param dev_dic: 共享内存
|
|
:param logger: logger
|
|
:param net_mode: 网络模式 # local / ip
|
|
"""
|
|
# logging
|
|
self.logger = logging.getLogger('client')
|
|
# value
|
|
self.net_mode = net_mode
|
|
self.run_input = False
|
|
# configs
|
|
pyglet.resource.path = ['textures']
|
|
pyglet.resource.reindex()
|
|
self.config_file = tools.load_file('configs/main.config')
|
|
self.FPS = Decimal(int(self.config_file['runtime']['fps']))
|
|
self.SPF = Decimal('1') / self.FPS
|
|
# lang
|
|
self.lang = tools.load_file('configs/lang/%s.json5' % self.config_file['runtime']['language'], 'client')
|
|
# dic
|
|
self.environment = {}
|
|
self.textures = {} # all textures
|
|
self.runtime = {}
|
|
# FPS
|
|
self.max_fps = [self.FPS, time.time()]
|
|
self.min_fps = [self.FPS, time.time()]
|
|
self.fps_wait = 5
|
|
# batch
|
|
self.part_batch = pyglet.graphics.Batch()
|
|
self.label_batch = pyglet.graphics.Batch()
|
|
# frame
|
|
self.frame = pyglet.gui.Frame(self)
|
|
self.M_frame = pyglet.gui.MovableFrame(self)
|
|
# setup
|
|
self.setup()
|
|
self.info_label = pyglet.text.Label(x=10, y=self.height - 10,
|
|
anchor_x='left', anchor_y='top',
|
|
batch=self.label_batch)
|
|
pyglet.clock.schedule_interval(self.update, float(self.SPF))
|
|
self.logger.info(self.lang['setup.done'])
|
|
|
|
@new_thread('client_load_environment')
|
|
def load_environment(self) -> None:
|
|
# load parts info
|
|
self.environment['parts'] = load_file('configs/sys_value/parts.json5')
|
|
try:
|
|
self.load_textures()
|
|
except TexturesError:
|
|
raise
|
|
|
|
@new_thread('client_load_textures')
|
|
def load_textures(self) -> None:
|
|
# load parts
|
|
self.textures['parts'] = {}
|
|
for part in self.environment['parts']:
|
|
pass
|
|
|
|
def setup(self):
|
|
self.logger.info(tr.lang('window', 'os.pid_is').format(os.getpid(), os.getppid()))
|
|
image = pyglet.image.load('textures/Editor/PartButton.png')
|
|
self.textures['test'] = DragSprite(10, 20, image, batch=self.label_batch, drag_by_all=False, drag_out_window=True)
|
|
self.load_environment()
|
|
|
|
def start_game(self) -> None:
|
|
self.run_input = True
|
|
# self.input_line = threading.Thread(target=self.read_input, name='client_read_line', daemon=True)
|
|
# self.input_line.start()
|
|
pyglet.app.run()
|
|
|
|
def read_input(self):
|
|
self.logger.debug('read_input start')
|
|
while self.run_input:
|
|
get = input('<<<')
|
|
self.logger.info(get)
|
|
if get == 'stop':
|
|
self.run_input = False
|
|
self.logger.debug('read_input end')
|
|
|
|
"""
|
|
draws and some event
|
|
"""
|
|
|
|
def update(self, tick: float):
|
|
self.FPS_update(tick)
|
|
|
|
def FPS_update(self, tick: float):
|
|
now_FPS = pyglet.clock.get_fps()
|
|
if now_FPS > self.max_fps[0]:
|
|
self.max_fps = [now_FPS, time.time()]
|
|
elif now_FPS < self.min_fps[0]:
|
|
self.min_fps = [now_FPS, time.time()]
|
|
else:
|
|
if (time.time() - self.max_fps[1]) > self.fps_wait:
|
|
self.max_fps = [self.FPS, time.time()]
|
|
elif (time.time() - self.min_fps[1]) > self.fps_wait:
|
|
self.min_fps = [self.FPS, time.time()]
|
|
self.info_label.text = 'FPS: {:.1f} {:.1f} ({:.1f}/{:.1f}) | MSPF: {:.5f} '.format(now_FPS, 1 / tick, self.max_fps[0], self.min_fps[0], tick)
|
|
|
|
def on_draw(self):
|
|
self.clear()
|
|
self.draw_batch()
|
|
|
|
def on_resize(self, width: int, height: int):
|
|
super().on_resize(width, height)
|
|
self.info_label.y = height - 10
|
|
|
|
def draw_batch(self):
|
|
self.part_batch.draw()
|
|
self.label_batch.draw()
|
|
|
|
"""
|
|
keyboard and mouse input
|
|
"""
|
|
|
|
def on_mouse_motion(self, x, y, dx, dy) -> None:
|
|
# self.logger.debug('按键移动 %s %s %s %s' % (x, y, dx, dy))
|
|
pass
|
|
|
|
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers) -> None:
|
|
# self.logger.debug('按键拖拽 %s %s %s %s %s %s' % (x, y, dx, dy, buttons, modifiers))
|
|
self.textures['test'].on_mouse_drag(x, y, dx, dy, buttons, modifiers)
|
|
pass
|
|
|
|
def on_mouse_press(self, x, y, button, modifiers) -> None:
|
|
if button == mouse.LEFT:
|
|
self.logger.debug(self.lang['mouse.press'].format([x, y], self.lang['mouse.left']))
|
|
elif button == mouse.RIGHT:
|
|
self.logger.debug(self.lang['mouse.press'].format([x, y], self.lang['mouse.right']))
|
|
self.textures['test']._sprite.rotation = random.randint(0, 360)
|
|
self.textures['test'].on_mouse_press(x, y, button, modifiers)
|
|
|
|
def on_mouse_release(self, x, y, button, modifiers) -> None:
|
|
self.logger.debug(tr.lang('window', 'mouse.release').format([x, y], tr.lang('window', 'mouse.right')))
|
|
self.textures['test'].on_mouse_release(x, y, button, modifiers)
|
|
|
|
def on_key_press(self, symbol, modifiers) -> None:
|
|
if symbol == key.ESCAPE and not (modifiers & ~(key.MOD_NUMLOCK |
|
|
key.MOD_CAPSLOCK |
|
|
key.MOD_SCROLLLOCK)):
|
|
self.dispatch_event('on_close')
|
|
|
|
def on_key_release(self, symbol, modifiers) -> None:
|
|
pass
|
|
|
|
def on_close(self) -> None:
|
|
self.run_input = False
|
|
# self.input_line.join()
|
|
config_file = configparser.ConfigParser()
|
|
config_file.read('configs/main.config')
|
|
config_file['window']['width'] = str(self.width)
|
|
config_file['window']['height'] = str(self.height)
|
|
config_file.write(open('configs/main.config', 'w', encoding='utf-8'))
|
|
super(ClientWindow, self).on_close()
|