def __init__(self, buffer_size=65535,
threads_count=os.cpu_count() * 2,
verbose=False,
show_logs=True):
self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.buffer_size = buffer_size
self.threads_count = threads_count
self.stats = Statistics()
self.stats_lock = threading.RLock()
self.show_logs = show_logs
self.verbose = verbose
self.executor = ThreadPoolExecutor(max_workers=self.threads_count - 1)
def __init__(self):
# other
super().__init__()
self.oneUse = True
# _modules
self.iConfigParser = ConfigParser()
self.config = self.iConfigParser.parser()
self.iGlobalTimer = GlobalTimer()
self.iCommands = Commands(self)
# modules
self.iAntiSpam = AntiSpam(self)
self.iServerStatus = ServerStatus(self)
self.iGiveRoles = GiveRoles(self)
self.iAdmMSG = AdmMSG(self)
self.iChecks = Checks(self)
self.iTimeVoice = TimeVoice(self)
self.iDuels = Duels(self)
self.iNullCheck = NullCheck(self)
self.iLevels = Levels(self)
self.iStatistics = Statistics(self)
self.iEconomy = Economy(self)
self.iBuyRole = BuyRole(self)
self.iPVC = PersonalVoiceChannels(self)
self.iTimeRoles = TimeRoles(self)
self.iLaV = LevelsAndVoiceRewards(self)
self.iMusic = Music(self)
def test_saving_the_winner_of_a_game(save_path):
"""Test the saving and retrieval of game rankings."""
# First, create a completely new statistics object
stats = Statistics(save_path=save_path)
# Save the results of two consecutive games
stats.save(ranking=["gold1", "bronze1", "silver1", "loser1"])
stats.save(ranking=["gold2", "bronze2", "silver2", "loser2"])
# Check if the results are immediatly retrievable
expected_rankings = [
["gold1", "bronze1", "silver1", "loser1"],
["gold2", "bronze2", "silver2", "loser2"],
]
assert stats.data.all_rankings == expected_rankings
# And then check if the same data can be retrieved after a "restart"
del stats
new_stats = Statistics(save_path=save_path)
assert new_stats.data.all_rankings == expected_rankings
def test_creation_of_save_file(save_path):
"""Statistics object should automatically create save file."""
stats = Statistics(save_path=save_path)
save_path = stats.save_path
assert save_path.exists()
def stats(save_path):
"""Return a statistics object which will be recycled after the test."""
return Statistics(save_path=save_path)
def __init__(self, generator_code, prev_screen):
self.generator = self.GENERATOR_MAPPER[generator_code]
self.result = dict()
self.prev_screen = prev_screen
self.statistics = Statistics()
class Manager:
GENERATOR_MAPPER = {
"1": SumGenerator(),
"2": SubGenerator(),
"3": MultGenerator()
}
def __init__(self, generator_code, prev_screen):
self.generator = self.GENERATOR_MAPPER[generator_code]
self.result = dict()
self.prev_screen = prev_screen
self.statistics = Statistics()
def requestInput(self):
c = input("")
if c.lower() == "sair":
self.prev_screen["reference"].print()
else:
self.execute()
self.statistics.saveRecords(self.result["correct"],
self.result["incorrect"],
self.result["duration"])
time.sleep(5)
self.prev_screen["reference"].print()
def execute(self):
questions = self.generator.generate_question(5)
self.init_result()
start_time = time.time()
for question in questions:
question.print()
self.check_answer(question)
time.sleep(1)
self.result["duration"] = time.time() - start_time
os.system("clear")
self.print_result()
def init_result(self):
self.result = {"correct": 0,
"incorrect": 0,
"duration": 0}
def check_answer(self, question):
print("")
ans = int(input("Resultado a operação: "))
if question.alternatives["ans"] == ans:
self.result["correct"] += 1
print("\nResposta CORRETA")
else:
self.result["incorrect"] += 1
print("\nResposta incorreta")
def print_result(self):
print("Parabéns! Você completou a partida. \n")
print("Acertos: {}".format(self.result["correct"]))
print("Erros: {}".format(self.result["incorrect"]))
print("Duração: {:.1f} segundos".format(self.result["duration"]))
def print(self):
os.system("clear")
print("Preparado para iniciar uma nova partida? \n")
print("- Digite sempre o valor do resultado da questão.")
print("- Pressione qualquer tecla para INICIAR.")
print("- Digite SAIR para voltar a tela anterior.")
self.requestInput()
def __init__(self) -> None:
"""Initialize the game with all the components."""
pg.init()
pg.font.init()
self.screen: graphics.Screen = graphics.Screen()
# Statistics
self.statistics = Statistics()
# Sliders
self.slides: List[graphics.Slider] = [
graphics.Slider(Slider("Drag coefficient", 50, 0, 100, 1150, 820)),
graphics.Slider(Slider("Friction", 10000, 0, 30000, 1150, 880)),
graphics.Slider(Slider('Player 1 mass', 1, 0.01, 2, 1300, 820)),
graphics.Slider(Slider('Player 2 mass', 1, 0.01, 2, 1300, 880)),
]
# Players
self.players: List[player.Player] = [
player.Player(200,
200,
ps.Player1Settings,
mass=self.slides[2],
phone=ConnectPhone()),
player.Player(300, 300, ps.Player2Settings, mass=self.slides[3]),
]
# Plots
self.graphs: List[graphics.Graph] = [
graphics.Graph(self.players, "v"),
graphics.Graph(self.players, "a", position=(1100, 400))
]
# Buttons
self.buttons: List[graphics.Button] = [
graphics.Button(
Button("Start!", 700, 600, 100, 50, Colors.GREEN.value,
Colors.BLUE.value))
]
# End screen buttons
self.end_btn: List[graphics.Button] = [
graphics.Button(
Button("Retry", 600, 600, 100, 50, Colors.GREEN.value,
Colors.BLUE.value)),
graphics.Button(
Button("Quit", 800, 600, 100, 50, Colors.RED.value,
Colors.BLUE.value)),
]
# Layers
self.layers: List[arena.ArenaLayer] = [
arena.FrictionLayer(np.ones((ArenaSettings.x, ArenaSettings.y)),
self.slides[1].get_value),
arena.AirResistanceLayer(self.slides[0].get_value),
]
# Arena
self.arena: arena.Arena = arena.Arena(ArenaSettings.x,
ArenaSettings.y,
layers=self.layers)
# Physic engine
self.physics: Physics = Physics(self)
# Input boxes
self.input_boxes = [
graphics.InputBox(500, 400, 200, 32, text='player 1 name'),
graphics.InputBox(800, 400, 200, 32, text='player 2 name')
]
# Score
self.score_table = [
graphics.Text(
Texts("Win and draw probabilities", ScreenSettings.width / 2,
200, 115)),
graphics.Text(Texts('', ScreenSettings.width / 2, 260, 80)),
graphics.Text(Texts('', ScreenSettings.width / 2, 320, 80)),
graphics.Text(Texts('', ScreenSettings.width / 2, 380, 80)),
]
class Game:
"""This class represents the whole game."""
def __init__(self) -> None:
"""Initialize the game with all the components."""
pg.init()
pg.font.init()
self.screen: graphics.Screen = graphics.Screen()
# Statistics
self.statistics = Statistics()
# Sliders
self.slides: List[graphics.Slider] = [
graphics.Slider(Slider("Drag coefficient", 50, 0, 100, 1150, 820)),
graphics.Slider(Slider("Friction", 10000, 0, 30000, 1150, 880)),
graphics.Slider(Slider('Player 1 mass', 1, 0.01, 2, 1300, 820)),
graphics.Slider(Slider('Player 2 mass', 1, 0.01, 2, 1300, 880)),
]
# Players
self.players: List[player.Player] = [
player.Player(200,
200,
ps.Player1Settings,
mass=self.slides[2],
phone=ConnectPhone()),
player.Player(300, 300, ps.Player2Settings, mass=self.slides[3]),
]
# Plots
self.graphs: List[graphics.Graph] = [
graphics.Graph(self.players, "v"),
graphics.Graph(self.players, "a", position=(1100, 400))
]
# Buttons
self.buttons: List[graphics.Button] = [
graphics.Button(
Button("Start!", 700, 600, 100, 50, Colors.GREEN.value,
Colors.BLUE.value))
]
# End screen buttons
self.end_btn: List[graphics.Button] = [
graphics.Button(
Button("Retry", 600, 600, 100, 50, Colors.GREEN.value,
Colors.BLUE.value)),
graphics.Button(
Button("Quit", 800, 600, 100, 50, Colors.RED.value,
Colors.BLUE.value)),
]
# Layers
self.layers: List[arena.ArenaLayer] = [
arena.FrictionLayer(np.ones((ArenaSettings.x, ArenaSettings.y)),
self.slides[1].get_value),
arena.AirResistanceLayer(self.slides[0].get_value),
]
# Arena
self.arena: arena.Arena = arena.Arena(ArenaSettings.x,
ArenaSettings.y,
layers=self.layers)
# Physic engine
self.physics: Physics = Physics(self)
# Input boxes
self.input_boxes = [
graphics.InputBox(500, 400, 200, 32, text='player 1 name'),
graphics.InputBox(800, 400, 200, 32, text='player 2 name')
]
# Score
self.score_table = [
graphics.Text(
Texts("Win and draw probabilities", ScreenSettings.width / 2,
200, 115)),
graphics.Text(Texts('', ScreenSettings.width / 2, 260, 80)),
graphics.Text(Texts('', ScreenSettings.width / 2, 320, 80)),
graphics.Text(Texts('', ScreenSettings.width / 2, 380, 80)),
]
def run(self) -> None:
"""Run the whole game loop."""
clock: pg.time.Clock = pg.time.Clock()
while 1:
if self.run_intro():
break
# Set player name
self.players[0].name = self.input_boxes[0].text
self.players[1].name = self.input_boxes[1].text
self.cont_game: bool = True
while self.cont_game:
if not self.run_game(clock):
# Give the winner points
if self.players[0].health_bar.health > self.players[
1].health_bar.health:
self.players[0].score += 1
else:
self.players[1].score += 1
stats = [
player.name
for player in sorted(self.players,
key=lambda x: x.health_bar.health,
reverse=True)
]
self.statistics.save(stats)
stats = self.statistics.win_probability(
[self.players[0].name, self.players[1].name])
# Add highscore
self.score_table[
1].msg = f"{self.players[0].name}: {stats['player_1']:.2f}"
self.score_table[
2].msg = f"{self.players[1].name}: {stats['player_2']:.2f}"
self.score_table[3].msg = f"Draw: {stats['draw']:.2f}"
while 1:
if self.run_end():
self.end_btn[0].clicked = False
break
self.reset_game()
pg.quit()
def run_intro(self) -> bool:
"""Run the game introduction."""
for event in pg.event.get():
if event.type == pg.QUIT:
pg.quit()
quit()
for box in self.input_boxes:
box.handle_event(event)
for box in self.input_boxes:
box.update()
# Fill the screen with white
self.screen.screen.fill(Colors.WHITE.value)
# Draw text onto the screen
graphics.Text(
Texts(
"EiT gruppe rød",
ScreenSettings.width / 2,
300,
115,
)).draw(self.screen.screen)
# Draw the buttions
list(map(lambda x: x.draw(self.screen.screen), self.buttons))
# Input boxes
for box in self.input_boxes:
box.draw(self.screen.screen)
pg.display.update()
return self.buttons[0].clicked
def run_game(self, clock: pg.time.Clock) -> bool:
"""Run the game."""
run: bool = True
# Check for events
for event in pg.event.get():
if event.type == pg.QUIT:
run = False
# Code for slides
elif event.type == pg.MOUSEBUTTONDOWN:
pos = pg.mouse.get_pos()
for s in self.slides:
if s.button_rect.collidepoint(pos):
s.hit = True
elif event.type == pg.MOUSEBUTTONUP:
for s in self.slides:
s.hit = False
# Fill the screen with black to remove old drawings
self.screen.screen.fill(Colors.BLACK.value)
# Draw arena
self.arena.draw(self.screen.screen)
# Move players
self.physics.move_players()
# Draw players
for p in self.players:
p.update_health()
p.draw(self.screen.screen)
# Draw plots
for graph in self.graphs:
graph.draw(self.screen.screen)
# Move sliders
for s in self.slides:
if s.hit:
pass
s.move()
# Draw sliders
for s in self.slides:
s.draw(self.screen.screen)
pg.display.flip()
clock.tick(60)
if True in [p.health_bar.health <= 0 for p in self.players]:
return False
return run
def run_end(self) -> bool:
"""Run when one player dies."""
for event in pg.event.get():
if event.type == pg.QUIT:
pg.quit()
quit()
# Fill the screen with white
self.screen.screen.fill(Colors.WHITE.value)
# Draw text onto the screen
list(map(lambda x: x.draw(self.screen.screen), self.score_table))
# Draw the buttions
list(map(lambda x: x.draw(self.screen.screen), self.end_btn))
if self.end_btn[1].clicked:
self.cont_game = False
pg.display.update()
return self.end_btn[0].clicked or self.end_btn[1].clicked
def get_players(self) -> List[player.Player]:
"""Return all player in game."""
return self.players
def get_arena(self) -> arena.Arena:
"""Return game arena."""
return self.arena
def reset_game(self):
list(map(lambda x: x.reset_position(), self.players))
list(map(lambda x: x.health_bar.reset(), self.players))
class ProxyServer:
def __init__(self, buffer_size=65535,
threads_count=os.cpu_count() * 2,
verbose=False,
show_logs=True):
self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.buffer_size = buffer_size
self.threads_count = threads_count
self.stats = Statistics()
self.stats_lock = threading.RLock()
self.show_logs = show_logs
self.verbose = verbose
self.executor = ThreadPoolExecutor(max_workers=self.threads_count - 1)
def start(self, host='0.0.0.0', port=0):
self.server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
self.server_sock.bind((host, port))
self.server_sock.listen()
host, port = self.get_server_addr()
print('Прокси работает на ', '{}:{}'.format(host, port))
while self.executor:
client_sock, addr = self.server_sock.accept()
self.executor.submit(self.__handle_client,
client_sock, addr)
def stop(self):
self.server_sock.settimeout(0)
self.server_sock.close()
self.executor.shutdown()
self.executor = None
def show_final_stats(self):
print('Получено байт: ', self.stats.received_bytes)
print('Байт отправлено: ', self.stats.sent_bytes)
def get_server_addr(self):
curr_ip = socket.gethostbyname(socket.gethostname())
curr_port = self.server_sock.getsockname()[1]
return curr_ip, curr_port
def __handle_client(self, client_sock, addr):
conn_ip = addr[0]
package = self.__receive_data(client_sock, 1.5)
host, port, is_https = self.get_conn_info(package)
conn = Connection(client_sock, conn_ip, host, port)
if not package:
return None
if is_https:
self.__handle_https(conn)
else:
self.__handle_http(conn, package)
def __handle_http(self, conn, package):
remote_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if self.show_logs:
log = self.get_log_info(conn, package.decode())
if log:
print(log)
try:
remote_sock.connect((conn.remote_host, conn.remote_port))
remote_sock.sendall(package)
self.update_stats(0, len(package))
self.transfer_http_data(remote_sock.makefile('rb'), conn.socket)
finally:
conn.socket.close()
remote_sock.close()
def __handle_https(self, conn):
remote_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
remote_sock.connect((conn.remote_host, conn.remote_port))
conn.socket.sendall(RESPONSE_MESSAGE)
try:
self.__communicate(conn, remote_sock)
except:
pass
def __communicate(self, conn, remote_sock):
#conn.socket.setblocking(0)
#remote_sock.setblocking(0)
with conn.socket:
with remote_sock:
while True:
readers, _, _ = select.select([conn.socket, remote_sock], [], [])
has_data = False
for i, reader in enumerate(readers):
data = reader.recv(self.buffer_size)
if data:
has_data = True
if reader is conn.socket:
remote_sock.sendall(data)
else:
conn.socket.sendall(data)
if not has_data:
break
def get_header_info(self, src):
content_len = 0
resp_header = b''
is_chunked = False
while True:
line = src.readline()
resp_header += line
if line == TRANSFER_ENCODING_HEADER:
is_chunked = True
if line[:15] == CONTENT_LEN_HEADER:
content_len = int(line[15:-2].decode())
if line == b'\r\n' or not line:
break
return resp_header, is_chunked, content_len
def transfer_http_data(self, remote_sock_file, client_sock):
response, is_chunked, content_len = self.get_header_info(remote_sock_file)
if is_chunked:
client_sock.sendall(response)
self.update_stats(len(response), 0)
response = b''
while True:
line = remote_sock_file.readline()
response += line
if line == b'0\r\n':
response += b'\r\n'
break
if not line:
break
num = int(line[:-2].decode(), 16)
chunk = remote_sock_file.read(num + 2)
response += chunk
client_sock.sendall(response)
self.update_stats(len(response), 0)
response = b''
if content_len != 0:
body = remote_sock_file.read(content_len)
response += body
client_sock.sendall(response)
self.update_stats(len(response), 0)
def get_log_info(self, conn, package):
if self.verbose:
return package
request_row = package.split('\n')[0]
components = request_row.split()
protocol = 'https:/' if conn.secure_sock else ''
method = components[0]
url = conn.remote_host + components[1] \
if conn.secure_sock else components[1]
formatted_request = '{} {}{}'.format(method, protocol, url)
return '{} {}'.format(conn.ip, formatted_request)
def update_stats(self, recv, sent):
with self.stats_lock:
self.stats.update(recv, sent)
def __receive_data(self, sock, timeout=None):
result = b''
if timeout:
sock.settimeout(timeout)
while True:
try:
data = sock.recv(self.buffer_size)
except socket.error:
return result
if not data:
result += data
break
result += data
return result
@staticmethod
def get_conn_info(package):
package = package.decode()
package_lines = package.split('\n')
is_https = package_lines[0].find('http') == -1
host_line = next((line for line in package_lines
if line.find('Host') >= 0), None)
full_url = host_line.split()[1]
port = 80
host = full_url
if ':' in full_url:
host, port = full_url.split(':')
return host, int(port), is_https