repo stringlengths 7 90 | file_url stringlengths 81 315 | file_path stringlengths 4 228 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 14:38:15 2026-01-05 02:33:18 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/tilebox.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/tilebox.py | import logging
from functools import cache
from pyglet.gl import (
GL_BLEND,
GL_CLAMP_TO_EDGE,
GL_NEAREST,
GL_ONE_MINUS_SRC_ALPHA,
GL_SRC_ALPHA,
GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER,
GL_TEXTURE_MIN_FILTER,
GL_TEXTURE_WRAP_S,
GL_TEXTURE_WRAP_T,
GL_TRIANGLES,
glBlendFunc,
glDisable,
glEnable,
glTexParameteri,
)
from pyglet.graphics import Group
from pyglet.graphics.shader import Shader, ShaderProgram
from client.game.ui import get_ui_image
TILE_SIZE_X = 16
TILE_SIZE_Y = 16
VERTEX_SOURCE = """#version 330 core
in vec2 tex_coords;
in vec2 position;
out vec2 texture_pos;
out vec3 vertex_colors;
uniform vec2 translation;
uniform vec2 scale;
uniform vec3 color_add;
uniform bool center;
uniform WindowBlock
{ // This UBO is defined on Window creation, and available
mat4 projection; // in all Shaders. You can modify these matrixes with the
mat4 view; // Window.view and Window.projection properties.
} window;
mat4 m_translate = mat4(1.0);
mat4 m_scale = mat4(1.0);
void main()
{
m_translate[3][0] = translation.x;
m_translate[3][1] = translation.y;
m_scale[0][0] = scale.x;
m_scale[1][1] = scale.y;
gl_Position = window.projection * window.view * m_translate * m_scale * vec4(position, 0, 1);
texture_pos = tex_coords;
vertex_colors = color_add;
}
"""
FRAGMENT_SOURCE = """#version 330 core
in vec2 texture_pos;
in vec3 vertex_colors;
out vec4 final_color;
uniform sampler2D texture_atlas;
void main()
{
vec4 tex_color = texture(texture_atlas, texture_pos);
final_color = tex_color + vec4(vertex_colors, 0) *tex_color.w;
}
"""
@cache
def get_tile_box_shader() -> ShaderProgram:
logging.debug("Map Shader Recalc")
vert_shader = Shader(VERTEX_SOURCE, "vertex")
frag_shader = Shader(FRAGMENT_SOURCE, "fragment")
return ShaderProgram(vert_shader, frag_shader)
def create_quad(
x: float, y: float, ts: int
) -> tuple[float, float, float, float, float, float, float, float]:
x = x * ts
y = y * ts
x2 = x + ts
y2 = y + ts
return (x, y, x2, y, x2, y2, x, y2)
def create_quad_tex(
x: float, y: float, w: float, h: float
) -> tuple[float, float, float, float, float, float, float, float]:
x = x * TILE_SIZE_X
y = y * TILE_SIZE_Y
x2 = x + TILE_SIZE_X
y2 = y + TILE_SIZE_Y
x /= w
x2 /= w
y /= h
y2 /= h
y = 1 - y
y2 = 1 - y2
return (x, y2, x2, y2, x2, y, x, y)
def gen_quad_indices(n: int) -> tuple[int, int, int, int, int, int]:
offset = n * 4
return (0 + offset, 1 + offset, 2 + offset, 0 + offset, 2 + offset, 3 + offset)
class TileStrip(Group):
def __init__(
self,
x: float,
y: float,
width: int,
height: int,
tile_size: int = 32,
tile_offset_x: int = 0,
tile_offset_y: int = 0,
scale_x: float = 1,
scale_y: float = 1,
group: Group | None = None,
horizontal: bool = True,
):
self.color_add: tuple[float, float, float] = (0, 0, 0)
self.scale_x = scale_x
self.scale_y = scale_y
self.tile_offset_x = tile_offset_x
self.tile_offset_y = tile_offset_y
self.tile_size = tile_size
self.width = width - width % -tile_size
self.width = max(tile_size * 3, self.width)
self.height = height - height % -tile_size
self.x = x
self.y = y
self.horizontal = horizontal
self.vlist = None
self.program = get_tile_box_shader()
super().__init__(parent=group)
def set_state(self):
# glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
self.program.use()
self.texture.bind(0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def unset_state(self):
glDisable(GL_BLEND)
self.program.stop()
# glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
def draw(self):
if self.vlist is None:
image = get_ui_image()
self.texture = image.get_texture()
position: list[float] = []
indices: list[int] = []
tex_coords: list[float] = []
match self.horizontal:
case True:
for x in range(int(self.width // self.tile_size)):
position += create_quad(
x=x - (self.width // self.tile_size) / 2,
y=-0.5,
ts=self.tile_size,
)
indices += gen_quad_indices(x)
tile_offset_x = 0
if x > 0:
tile_offset_x += 1
if x == self.width // self.tile_size - 1:
tile_offset_x += 1
tex_coords += create_quad_tex(
self.tile_offset_x + tile_offset_x,
self.tile_offset_y,
image.width,
image.height,
)
case False:
for y in range(int(self.height // self.tile_size)):
position += create_quad(
x=-0.5,
y=y - (self.height // self.tile_size) / 2,
ts=self.tile_size,
)
indices += gen_quad_indices(y)
tile_offset_y = 0
if y > 0:
tile_offset_y -= 1
if y == self.height // self.tile_size - 1:
tile_offset_y -= 1
tex_coords += create_quad_tex(
self.tile_offset_x,
self.tile_offset_y + tile_offset_y,
image.width,
image.height,
)
self.vlist = self.program.vertex_list_indexed(
4 * (self.width // self.tile_size) * (self.height // self.tile_size),
GL_TRIANGLES,
indices,
position=("f", position),
tex_coords=("f", tex_coords),
)
self.program["translation"] = (
self.x + self.width / 2,
self.y + self.height / 2,
)
self.program["scale"] = (self.scale_x, self.scale_y)
self.program["color_add"] = self.color_add
# self.program["center"] = center
self.set_state_recursive()
self.vlist.draw(GL_TRIANGLES)
self.unset_state_recursive()
class TileBox(Group):
def __init__(
self,
x: float,
y: float,
width: float,
height: float,
color: tuple[int, int, int, int] = (80, 0, 80, 255),
tile_size: int = 32,
tile_offset_x: int = 0,
tile_offset_y: int = 0,
scale_x: float = 1,
scale_y: float = 1,
group: Group | None = None,
):
self.scale_x = scale_y
self.scale_y = scale_x
self.tile_size = tile_size
self.width = (width // tile_size) * tile_size
self.height = (height // tile_size) * tile_size
self.x = x
self.y = y
self.vlist = None
self.tile_offset_x = tile_offset_x
self.tile_offset_y = tile_offset_y
self.program = get_tile_box_shader()
super().__init__(parent=group)
def set_state(self):
# glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
self.program.use()
self.texture.bind(0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def unset_state(self):
glDisable(GL_BLEND)
self.program.stop()
# glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
def draw(self):
if self.vlist is None:
image = get_ui_image()
self.texture = image.get_texture()
position: list[float] = []
indices: list[int] = []
tex_coords: list[float] = []
for x in range(int(self.width // self.tile_size)):
for y in range(int(self.height // self.tile_size)):
position += create_quad(x, y, self.tile_size)
indices += gen_quad_indices(
int(self.width // self.tile_size) * y + x
)
tile_offset_x = 0
tile_offset_y = 2
if x > 0:
tile_offset_x += 1
if x == self.width // self.tile_size - 1:
tile_offset_x += 1
if y > 0:
tile_offset_y -= 1
if y == self.height // self.tile_size - 1:
tile_offset_y -= 1
tex_coords += create_quad_tex(
self.tile_offset_x + tile_offset_x,
self.tile_offset_y + tile_offset_y,
image.width,
image.height,
)
self.vlist = self.program.vertex_list_indexed(
int(
4 * (self.width // self.tile_size) * (self.height // self.tile_size)
),
GL_TRIANGLES,
indices,
position=("f", position),
tex_coords=("f", tex_coords),
)
self.program["translation"] = (self.x, self.y)
self.program["scale"] = (self.scale_x, self.scale_y)
self.program["color_add"] = (0, 0, 0)
# self.program["center"] = center
self.set_state_recursive()
self.vlist.draw(GL_TRIANGLES)
self.unset_state_recursive()
def delete(self):
if self.vlist:
self.vlist.delete()
self.vlist = None
def __del__(self):
if self.vlist:
self.vlist.delete()
self.vlist = None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/__init__.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/__init__.py | from functools import cache
from pathlib import Path
from typing import cast
import pyglet
from pyglet.image import ImageData, TextureGrid
import client
@cache
def get_ui_image() -> ImageData:
return cast(
ImageData,
pyglet.image.load(Path(client.PATH, "assets/ui/16x16/Modern_UI_Style_1.png")),
)
@cache
def get_ui_grid() -> TextureGrid:
rows = 43
columns = 61
image_grid = pyglet.image.ImageGrid(get_ui_image(), rows=rows, columns=columns)
texture_grid = image_grid.get_texture_sequence()
# for some reason the grid is upside down, ouch
texture_grid.items = [
x
for i in range(rows)
for x in cast(list[int], texture_grid.items[i * columns :][:columns][::-1])
][::-1]
return texture_grid
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/dropdown.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/dropdown.py | from typing import cast
from pyglet.graphics import Batch, Group
from pyglet.gui.widgets import WidgetBase
from pyglet.shapes import Rectangle
from pyglet.text import Label
class DropdownEntry(WidgetBase):
def __init__(self, x: int, y: int, text: str, batch: Batch, group: Group):
padding = 0
self._label = Label(
text,
x=x + padding,
y=y + padding,
batch=batch,
anchor_y="bottom",
color=(255, 255, 255, 255),
group=group,
)
label_width = self._label.content_width
label_height = cast(int, self._label.content_height)
width = label_width + padding * 2
height = label_height + padding * 2
super().__init__(x, y, width, height)
class Dropdown(WidgetBase):
def __init__(
self,
x: int,
y: int,
entries: list[str],
batch: Batch,
) -> None:
self.group = Group()
self.entries: list[DropdownEntry] = []
height = 0
width = 0
for entry in entries[::-1]:
dentry = DropdownEntry(
x=x, y=y + height, text=entry, batch=batch, group=self.group
)
height += dentry.height
width = max(width, dentry.width)
self.entries.append(dentry)
self._outline = Rectangle(
x, y, width, height, color=(80, 0, 80, 255), batch=batch
)
self._selector = Rectangle(
x, y, width, 0, color=(255, 255, 255, 255), batch=batch
)
self._selector.opacity = 0
self.selected_entry = None
super().__init__(x, y, width, height)
def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
if self._check_hit(x, y):
for entry in self.entries:
if entry.y < y < entry.y + entry.height:
break
else:
self._selector.opacity = 0
if self.selected_entry:
self.selected_entry._label.color = ( # pyright: ignore[reportPrivateUsage]
255,
255,
255,
255,
)
self.selected_entry = None
return
self._selector.x = entry.x
self._selector.y = entry.y
self._selector.height = entry.height
self._selector.opacity = 255
if self.selected_entry:
self.selected_entry._label.color = ( # pyright: ignore[reportPrivateUsage]
255,
255,
255,
255,
)
entry._label.color = (0, 0, 0, 255) # pyright: ignore[reportPrivateUsage]
self.selected_entry = entry
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/button.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/client/client/game/ui/button.py | from typing import cast
from pyglet.graphics import Batch, Group
from pyglet.gui.widgets import WidgetBase
from pyglet.image import Animation, AnimationFrame, Texture
from pyglet.text import Label
from client.game.nearest_sprite import NearestSprite
from client.game.ui.tilebox import TileStrip
class ButtonBase(WidgetBase):
def __init__(self, x: float, y: float, width: float, height: float) -> None:
self._pressed = False
self.enabled = True
self._hover = False
super().__init__(x, y, width, height)
def pressed(self) -> None:
pass
def released(self) -> None:
pass
def on_mouse_press(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled or not self._check_hit(x, y):
return
self._pressed = True
self.pressed()
self.dispatch_event("on_press")
def on_mouse_release(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled or not self._pressed:
return
self._pressed = False
self.released()
self.dispatch_event("on_release")
def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
if not self.enabled or not self._check_hit(x, y):
self._hover = False
return
self._hover = True
def _update_position(self) -> None:
pass
ButtonBase.register_event_type("on_press")
ButtonBase.register_event_type("on_release")
class Button(ButtonBase):
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
batch: Batch,
group: Group | None = None,
color: tuple[int, int, int, int] = (80, 0, 80, 255),
) -> None:
self._outline = TileStrip(
x + 24,
y,
width + 16 * 3,
height=height,
tile_offset_x=3,
tile_offset_y=23,
scale_y=1.2,
scale_x=1.2,
group=group,
)
self._outline.x -= 32
super().__init__(
x + 8 * self._outline.scale_x,
y - 8,
(self._outline.width - 16 * 3) * self._outline.scale_x,
(self._outline.height) * self._outline.scale_y,
)
def _update_position(self) -> None:
self._outline.x = self._x
self._outline.y = self._y
def draw(self) -> None:
if self._hover:
self._outline.color_add = (0.1, 0.1, 0.1)
else:
self._outline.color_add = (0, 0, 0)
self._outline.draw()
class TextButton(Button):
def __init__(
self, text: str, x: int, y: int, batch: Batch, group: Group | None = None
) -> None:
self._label = Label(
text,
x=x,
y=y + 4,
batch=batch,
group=group,
anchor_y="bottom",
color=(0, 0, 0, 255),
)
label_width = self._label.content_width
label_height = cast(int, self._label.content_height)
width = label_width
height = label_height
super().__init__(x, y, width, height, batch, group=group)
self._label.x += label_width / 2 - 4
def draw(self) -> None:
super().draw()
def _update_position(self) -> None:
self._label.x = self._x
self._label.y = self._y
super()._update_position()
class ImageButton(ButtonBase):
def __init__(
self,
img: Texture | Animation,
x: int,
y: int,
group: Group | None = None,
scale_x: float = 1.0,
scale_y: float = 1.0,
) -> None:
match img:
case Texture() as t:
width = t.width
height = t.height
self._animate = False
case Animation():
width = cast(int, img.get_max_width())
height = cast(int, img.get_max_height())
self._animate = True
cast(AnimationFrame, img.frames[-1]).duration = None
self._image = NearestSprite(
img=img,
x=x,
y=y,
group=group,
origin=(width // 2, height // 2),
)
if self._animate:
self._image.paused = True
self._image.scale_x = scale_x
self._image.scale_y = scale_y
self._w = width
self._h = height
super().__init__(
x - (self._w * (self._image.scale_x - 1)) / 2,
y - (self._h * (self._image.scale_y - 1)) / 2,
width * scale_x,
height * scale_y,
)
@property
def x(self) -> float:
return self._x
@x.setter
def x(self, value: float) -> None:
self._image.x = value + (self._w * (self._image.scale_x - 1)) / 2
self._x = value
@property
def y(self) -> float:
return self._y
@y.setter
def y(self, value: float) -> None:
self._image.y = value + (self._h * (self._image.scale_y - 1)) / 2
self._y = value
def pressed(self) -> None:
if self._animate:
self._image.paused = False
def released(self) -> None:
if self._animate:
self._image._next_dt = 0 # pyright: ignore[reportPrivateUsage]
self._image._animate(0) # pyright: ignore[reportPrivateUsage]
self._image.paused = True
def draw(self) -> None:
self._image.draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/constants.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/constants.py | CHUNK_SIZE_X: int = 32
CHUNK_SIZE_Y: int = 32
TILE_SIZE_X: int = 16
TILE_SIZE_Y: int = 16
NUM_TILES_PER_COLUM: int = 16
PLAYER_SPEED: int = 100
PLAYER_WIDTH: int = 16
PLAYER_HEIGHT: int = 16
PLAYER_DEATH_TIMEOUT = 60 * 5 # 5 minutes
VIEW_DISTANCE: int = 500
VIEW_DISTANCE_SQ: int = pow(VIEW_DISTANCE, 2)
SERVER_TICK_RATE: int = 30
TARGET_FPS: int = 30
TARGET_UPS: int = 60
START_X = 80
START_Y = 80
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/collison.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/collison.py | import functools
import operator
from typing import Iterator, Tuple
import collision
from shared.gen.messages.v1 import Polygon
from shared.map import Map
def bb(x: float, y: float, w: float, h: float) -> Iterator[Tuple[float, float]]:
yield x, y
yield x + w, y
yield x + w, y + h
yield x, y + h
cached_polys: dict[int, collision.Concave_Poly] = {}
def to_poly(poly: Polygon) -> collision.Concave_Poly:
id_ = id(poly)
if id_ in cached_polys:
return cached_polys[id_]
p = collision.Concave_Poly(
collision.Vector(0, 0),
[collision.Vector(p.x, p.y) for p in poly.points],
)
cached_polys[id_] = p
return p
def point_in_poly(x: float, y: float, poly: Polygon) -> bool:
to_test = to_poly(poly=poly)
return collision.point_in_poly(collision.Vector(x, y), to_test)
class CollisionManager:
def __init__(self, width: int, height: int) -> None:
self.width = width
self.height = height
# handle different collision types so that we only cancel direction of collision
def _do_edge_detection(
self,
map: Map,
old_x: float,
old_y: float,
new_x: float,
new_y: float,
offset_x: int,
offset_y: int,
user_id: str,
) -> Tuple[float, float] | None:
player = collision.Poly(
collision.Vector(new_x, old_y),
[
collision.Vector(x, y)
for x, y in [
(0, 0),
(0, self.height),
(self.width, self.height),
(self.width, 0),
]
],
)
player2 = collision.Poly(
collision.Vector(old_x, new_y),
[
collision.Vector(x, y)
for x, y in [
(0, 0),
(0, self.height),
(self.width, self.height),
(self.width, 0),
]
],
)
match map.get_tiles(new_x + offset_x, old_y + offset_y, user_id):
case None:
return
case tiles, tx, ty:
pass
for col in functools.reduce(
operator.iconcat, [tile.collision for tile in tiles], []
):
poly = collision.Concave_Poly(
collision.Vector(tx, ty),
[collision.Vector(p.x, p.y) for p in col.points],
)
c = collision.collide(poly, player)
if c:
break
else:
return (new_x, old_y)
match map.get_tiles(old_x + offset_x, new_y + offset_y, user_id):
case None:
return
case tiles2, tx2, ty2:
pass
for col in functools.reduce(
operator.iconcat, [tile.collision for tile in tiles2], []
):
poly = collision.Concave_Poly(
collision.Vector(tx2, ty2),
[collision.Vector(p.x, p.y) for p in col.points],
)
c = collision.collide(poly, player2)
if c:
break
else:
return (old_x, new_y)
return (old_x, old_y)
def check_collisons(
self,
map: Map,
old_x: float,
old_y: float,
new_x: float,
new_y: float,
user_id: str = "",
) -> Tuple[float, float] | None:
entity = collision.Poly(
collision.Vector(new_x, new_y),
[
collision.Vector(x, y)
for x, y in [
(0, 0),
(0, self.height),
(self.width, self.height),
(self.width, 0),
]
],
)
colls: set[int] = set()
for idx, (x, y) in enumerate(bb(new_x, new_y, self.width, -self.height)):
match map.get_tiles(x=x, y=y, user_id=user_id):
case None:
return None
case tiles, tx, ty:
pass
for tile in tiles:
for col in tile.collision:
poly = collision.Concave_Poly(
collision.Vector(tx, ty),
[collision.Vector(p.x, p.y) for p in col.points],
)
resp = collision.Response()
c = collision.collide(poly, entity, resp)
if c:
colls.add(idx)
match list(colls):
case []:
return (new_x, new_y)
case [0, 1]:
return (new_x, old_y)
case [0, 3]:
return (old_x, new_y)
case [2, 3]:
return (new_x, old_y)
case [1, 2]:
return (old_x, new_y)
case [0]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, 0, 0, user_id
)
case [1]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, self.width, 0, user_id
)
case [2]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, self.width, -self.height, user_id
)
case [3]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, 0, -self.height, user_id
)
case _:
pass
return (old_x, old_y)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/lazy.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/lazy.py | import builtins
from collections.abc import Iterator
from enum import EnumMeta
from typing import Any
import betterproto
class Lazy:
cls: type
def __init__(self, cls: type) -> None:
self.cls = cls
def get_default(self, sub_cls: type) -> Any:
match sub_cls:
case builtins.str:
return ""
case builtins.int:
return 0
case builtins.float:
return 0.0
case builtins.bool:
return False
case builtins.bytes:
return b""
case builtins.list:
return LazyList([], cls=sub_cls)
case EnumMeta():
return list(sub_cls)[0]
case _:
return LazyDict({}, cls=sub_cls)
class LazyList(list[Any], Lazy):
def __init__(self, a: list[Any], cls: type) -> None:
Lazy.__init__(self=self, cls=cls)
super().__init__(a)
def __getitem__(self, items: Any) -> Any:
ret = super().__getitem__(items)
match ret:
case dict():
new_value = LazyDict(ret, cls=self.cls)
case list():
new_value = LazyList(ret, cls=self.cls)
case _:
new_value = ret
super().__setitem__(items, new_value)
return new_value
def __iter__(self) -> Iterator[Any]:
for ret in super().__iter__():
match ret:
case dict():
yield LazyDict(ret, cls=self.cls)
case list():
yield LazyList(ret, cls=self.cls)
case _:
yield ret
class LazyDict(dict[str, Any], Lazy):
def __init__(self, a: dict[str, Any], cls: type) -> None:
Lazy.__init__(self=self, cls=cls)
super().__init__(a)
self.object = None
def __getattr__(self, __name: str) -> Any:
if self.object:
return self.object.__getattribute__(__name)
key = betterproto.casing.camel_case(__name)
sub_cls: Any = self.cls._cls_for(self.cls.__dataclass_fields__[__name]) # type: ignore
if key in self:
ret = self[key]
match sub_cls:
case EnumMeta():
new_value = sub_cls(ret)
case _:
match ret:
case dict():
new_value = LazyDict(ret, cls=sub_cls)
case list():
new_value = LazyList(ret, cls=sub_cls)
case _:
new_value = ret
else:
new_value = self.get_default(sub_cls)
self[key] = new_value
return new_value
@property # type: ignore
def __class__(self) -> type:
return self.cls
def to_dict(
self,
casing: betterproto.Casing = betterproto.Casing.CAMEL,
include_default_values: bool = False,
) -> dict[str, Any]:
if not self.object:
value = self.cls().from_dict(self)
self.object = value
return self.object.to_dict(casing, include_default_values)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/bidict.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/bidict.py | from __future__ import annotations
from typing import Generic, TypeVar
_KT = TypeVar("_KT")
_VT = TypeVar("_VT")
class BijectionError(Exception, Generic[_VT]):
"""Must set a unique value in a BijectiveMap."""
def __init__(self, value: _VT) -> None:
self.value = value
msg = 'The value "{}" is already in the mapping.'
super().__init__(msg.format(value))
class BijectiveMap(dict[_KT, _VT]):
"""Invertible map."""
inverse: BijectiveMap[_VT, _KT]
def __init__(self, inverse: BijectiveMap[_VT, _KT] | None = None) -> None:
if inverse is None:
inverse = self.__class__(inverse=self)
self.inverse = inverse
def __setitem__(self, key: _KT, value: _VT) -> None:
if value in self.inverse:
raise BijectionError(value)
self.inverse._set_item(value, key)
self._set_item(key, value)
def __delitem__(self, key: _KT) -> None:
self.inverse._del_item(self[key])
self._del_item(key)
def _del_item(self, key: _KT) -> None:
super().__delitem__(key)
def _set_item(self, key: _KT, value: _VT) -> None:
super().__setitem__(key, value)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/utils.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/utils.py | from __future__ import annotations
from asyncio import Lock
from threading import Timer
from typing import Any, Awaitable, Callable, List
class AsyncLockEventHandler(object):
lock: Lock
def __init__(
self, handlers: List[Callable[[Lock, *Any], Awaitable[None]]] | None = None
) -> None:
self.lock = Lock()
if handlers is None:
self.__eventhandlers = []
else:
self.__eventhandlers = handlers
def __iadd__(
self, handler: Callable[[Lock, *Any], Awaitable[None]]
) -> AsyncLockEventHandler:
self.__eventhandlers.append(handler)
return self
def __isub__(
self, handler: Callable[[Lock, *Any], Awaitable[None]]
) -> AsyncLockEventHandler:
self.__eventhandlers.remove(handler)
return self
async def __call__(self, *args: Any, **keywargs: Any) -> None:
for eventhandler in self.__eventhandlers:
await eventhandler(self.lock, *args, **keywargs)
class AsyncEventHandler(object):
def __init__(
self, handlers: List[Callable[..., Awaitable[None]]] | None = None
) -> None:
if handlers is None:
self.__eventhandlers = []
else:
self.__eventhandlers = handlers
def __iadd__(self, handler: Callable[..., Awaitable[None]]) -> AsyncEventHandler:
self.__eventhandlers.append(handler)
return self
def __isub__(self, handler: Callable[..., Awaitable[None]]) -> AsyncEventHandler:
self.__eventhandlers.remove(handler)
return self
async def __call__(self, *args: Any, **keywargs: Any) -> None:
for eventhandler in self.__eventhandlers:
await eventhandler(*args, **keywargs)
class EventHandler(object):
def __init__(self, handlers: List[Callable[..., None]] | None = None) -> None:
if handlers is None:
self.__eventhandlers = []
else:
self.__eventhandlers = handlers
def __iadd__(self, handler: Callable[..., None]) -> EventHandler:
self.__eventhandlers.append(handler)
return self
def __isub__(self, handler: Callable[..., None]) -> EventHandler:
self.__eventhandlers.remove(handler)
return self
def __call__(self, *args: Any, **keywargs: Any) -> None:
for eventhandler in self.__eventhandlers:
eventhandler(*args, **keywargs)
class RepeatedTimer(object):
def __init__(
self, interval: int, function: Callable[..., None], *args: Any, **kwargs: Any
) -> None:
self._timer = None
self.interval = interval
self.function = function
self.args = args
self.kwargs = kwargs
self.is_running = False
self.start()
def _run(self) -> None:
self.is_running = False
self.start()
self.function(*self.args, **self.kwargs)
def start(self) -> None:
if not self.is_running:
self._timer = Timer(self.interval, self._run)
self._timer.start()
self.is_running = True
def stop(self) -> None:
if self._timer:
self._timer.cancel()
self._timer.join()
self.is_running = False
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/__init__.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/map.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/map.py | from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import List, Tuple
from shared.gen.messages.v1 import Polygon
@dataclass
class Tile:
chunk_atlas_offset: int
collision: List[Polygon]
class Map(ABC):
@abstractmethod
def get_tiles(
self, x: float, y: float, user_id: str
) -> Tuple[List[Tile], float, float] | None:
pass
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/gen/__init__.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/gen/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/gen/messages/__init__.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/gen/messages/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/gen/messages/v1/__init__.py | ctfs/CCCamp/2023/game/Race_to_the_Top/src/shared/shared/gen/messages/v1/__init__.py | # Generated by the protocol buffer compiler. DO NOT EDIT!
# sources: messages/v1/entity.proto, messages/v1/messages.proto, messages/v1/tile.proto
# plugin: python-betterproto
# This file has been @generated
from dataclasses import dataclass
from datetime import datetime
from typing import List
import betterproto
class Direction(betterproto.Enum):
DIRECTION_UNSPECIFIED = 0
DIRECTION_NORTH = 1
DIRECTION_EAST = 2
DIRECTION_SOUTH = 3
DIRECTION_WEST = 4
class Activity(betterproto.Enum):
ACTIVITY_UNSPECIFIED = 0
ACTIVITY_IDLE = 1
ACTIVITY_WALKING = 2
ACTIVITY_ATTACKING = 3
ACTIVITY_DEATH = 4
class ObjectType(betterproto.Enum):
OBJECT_TYPE_UNSPECIFIED = 0
OBJECT_TYPE_NPC = 1
OBJECT_TYPE_ENEMY = 2
OBJECT_TYPE_AREA = 3
OBJECT_TYPE_PICKUPABLE = 4
class InteractStatus(betterproto.Enum):
INTERACT_STATUS_UNSPECIFIED = 0
INTERACT_STATUS_START = 1
INTERACT_STATUS_UPDATE = 2
INTERACT_STATUS_STOP = 3
class InteractType(betterproto.Enum):
INTERACT_TYPE_UNSPECIFIED = 0
INTERACT_TYPE_TEXT = 1
INTERACT_TYPE_SHOP = 2
INTERACT_TYPE_DIG = 3
INTERACT_TYPE_RUNNER = 4
INTERACT_TYPE_CUT_OUT = 5
INTERACT_TYPE_LICENSE = 6
class ShopInteractType(betterproto.Enum):
SHOP_INTERACT_TYPE_UNSPECIFIED = 0
SHOP_INTERACT_TYPE_BUY = 1
SHOP_INTERACT_TYPE_SELL = 2
SHOP_INTERACT_TYPE_TRADE = 3
class RunnerAction(betterproto.Enum):
RUNNER_ACTION_UNSPECIFIED = 0
RUNNER_ACTION_JUMP = 1
RUNNER_ACTION_MAYBE_ADD_OBSTACLE = 2
RUNNER_ACTION_DIE = 3
class SessionType(betterproto.Enum):
SESSION_TYPE_UNSPECIFIED = 0
SESSION_TYPE_NORMAL = 1
SESSION_TYPE_FREE_CAM = 2
class ErrorType(betterproto.Enum):
ERROR_TYPE_UNSPECIFIED = 0
ERROR_TYPE_UNAUTHORIZED = 1
ERROR_TYPE_INVALID_CHUNK = 2
ERROR_TYPE_INVALID_OBJECT = 3
ERROR_TYPE_TIMEOUT = 4
ERROR_TYPE_ALREADY_LOGGED_IN = 5
@dataclass(eq=False, repr=False)
class Point(betterproto.Message):
x: float = betterproto.double_field(1)
y: float = betterproto.double_field(2)
@dataclass(eq=False, repr=False)
class Polygon(betterproto.Message):
points: List["Point"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class TileCollision(betterproto.Message):
polygons: List["Polygon"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class AnimationStep(betterproto.Message):
id: int = betterproto.int32_field(1)
duration: int = betterproto.int32_field(2)
@dataclass(eq=False, repr=False)
class Animation(betterproto.Message):
id: int = betterproto.int32_field(1)
animation_setps: List["AnimationStep"] = betterproto.message_field(2)
@dataclass(eq=False, repr=False)
class Tileset(betterproto.Message):
tileset: bytes = betterproto.bytes_field(1)
width: int = betterproto.int32_field(2)
height: int = betterproto.int32_field(3)
animations: List["Animation"] = betterproto.message_field(4)
@dataclass(eq=False, repr=False)
class Object(betterproto.Message):
uuid: str = betterproto.string_field(1)
coords: "Coords" = betterproto.message_field(2)
type: "ObjectType" = betterproto.enum_field(3)
remove: bool = betterproto.bool_field(4)
enemy_info: "EnemyInfo" = betterproto.message_field(5)
area: "Polygon" = betterproto.message_field(6)
pickupable: "Item" = betterproto.message_field(7)
@dataclass(eq=False, repr=False)
class EnemyInfo(betterproto.Message):
health: int = betterproto.int32_field(1)
health_max: int = betterproto.int32_field(2)
name: str = betterproto.string_field(3)
last_attack: float = betterproto.double_field(4)
@dataclass(eq=False, repr=False)
class Objects(betterproto.Message):
objects: List["Object"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class ObjectAssetRequest(betterproto.Message):
uuid: str = betterproto.string_field(1)
@dataclass(eq=False, repr=False)
class EntityAsset(betterproto.Message):
id: int = betterproto.int32_field(1)
direction: "Direction" = betterproto.enum_field(2)
activity: "Activity" = betterproto.enum_field(3)
@dataclass(eq=False, repr=False)
class EntityAssets(betterproto.Message):
height: int = betterproto.int32_field(1)
width: int = betterproto.int32_field(2)
tileset: "Tileset" = betterproto.message_field(3)
entity_assets: List["EntityAsset"] = betterproto.message_field(4)
collisions: List["TileCollision"] = betterproto.message_field(5)
@dataclass(eq=False, repr=False)
class ObjectAsset(betterproto.Message):
object_uuid: str = betterproto.string_field(1)
assets: "EntityAssets" = betterproto.message_field(2)
name: str = betterproto.string_field(3)
type: "ObjectType" = betterproto.enum_field(4)
interactable: bool = betterproto.bool_field(5)
interact_distance: float = betterproto.double_field(6)
@dataclass(eq=False, repr=False)
class Interact(betterproto.Message):
uuid: str = betterproto.string_field(1)
text: str = betterproto.string_field(2)
status: "InteractStatus" = betterproto.enum_field(3)
type: "InteractType" = betterproto.enum_field(4)
shop: List["ShopInteract"] = betterproto.message_field(5)
progress: float = betterproto.double_field(6)
runner: "Runner" = betterproto.message_field(7)
@dataclass(eq=False, repr=False)
class ShopInteract(betterproto.Message):
item: "Item" = betterproto.message_field(1)
cost: int = betterproto.int32_field(2)
type: "ShopInteractType" = betterproto.enum_field(3)
trade_in: "Item" = betterproto.message_field(4)
@dataclass(eq=False, repr=False)
class Item(betterproto.Message):
name: str = betterproto.string_field(1)
description: str = betterproto.string_field(2)
icon: int = betterproto.int32_field(3)
quantity: int = betterproto.int32_field(4)
@dataclass(eq=False, repr=False)
class RunnerEvent(betterproto.Message):
time: float = betterproto.double_field(1)
action: "RunnerAction" = betterproto.enum_field(2)
@dataclass(eq=False, repr=False)
class Runner(betterproto.Message):
events: List["RunnerEvent"] = betterproto.message_field(1)
dts: List[float] = betterproto.double_field(2)
@dataclass(eq=False, repr=False)
class Coords(betterproto.Message):
x: float = betterproto.double_field(1)
y: float = betterproto.double_field(2)
rotation: float = betterproto.double_field(3)
@dataclass(eq=False, repr=False)
class User(betterproto.Message):
uuid: str = betterproto.string_field(1)
username: str = betterproto.string_field(2)
coords: "Coords" = betterproto.message_field(3)
money: int = betterproto.int32_field(4)
inventory: List["Item"] = betterproto.message_field(5)
health: int = betterproto.int32_field(6)
last_death: float = betterproto.float_field(7)
@dataclass(eq=False, repr=False)
class Users(betterproto.Message):
users: List["User"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class Login(betterproto.Message):
username: str = betterproto.string_field(1)
password: str = betterproto.string_field(2)
@dataclass(eq=False, repr=False)
class LoggedIn(betterproto.Message):
success: bool = betterproto.bool_field(1)
self: "User" = betterproto.message_field(2)
assets: "EntityAssets" = betterproto.message_field(3)
interact_distance: float = betterproto.double_field(4)
type: "SessionType" = betterproto.enum_field(5)
error: "ErrorType" = betterproto.enum_field(6)
@dataclass(eq=False, repr=False)
class Ping(betterproto.Message):
time: datetime = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class MapChunk(betterproto.Message):
x: int = betterproto.int32_field(1)
y: int = betterproto.int32_field(2)
height: int = betterproto.int32_field(3)
width: int = betterproto.int32_field(4)
tiles: List[int] = betterproto.int32_field(5)
tileset: "Tileset" = betterproto.message_field(6)
collisions: List["TileCollision"] = betterproto.message_field(7)
@dataclass(eq=False, repr=False)
class MapChunkRequest(betterproto.Message):
x: int = betterproto.int32_field(1)
y: int = betterproto.int32_field(2)
@dataclass(eq=False, repr=False)
class Error(betterproto.Message):
type: "ErrorType" = betterproto.enum_field(1)
message: str = betterproto.string_field(2)
@dataclass(eq=False, repr=False)
class Logout(betterproto.Message):
user: "User" = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class GiveDamage(betterproto.Message):
"""Message related to fighting"""
damage: int = betterproto.int32_field(1)
@dataclass(eq=False, repr=False)
class AcknowledgeDamage(betterproto.Message):
damage: int = betterproto.int32_field(1)
@dataclass(eq=False, repr=False)
class AttackEnemy(betterproto.Message):
time: datetime = betterproto.message_field(1)
uuid: str = betterproto.string_field(2)
damage: int = betterproto.int32_field(3)
@dataclass(eq=False, repr=False)
class ClientMessage(betterproto.Message):
ping: "Ping" = betterproto.message_field(1, group="message")
login: "Login" = betterproto.message_field(2, group="message")
coords: "Coords" = betterproto.message_field(3, group="message")
chunk_request: "MapChunkRequest" = betterproto.message_field(4, group="message")
object_asset_request: "ObjectAssetRequest" = betterproto.message_field(
5, group="message"
)
interact: "Interact" = betterproto.message_field(6, group="message")
acknowledge_damage: "AcknowledgeDamage" = betterproto.message_field(
7, group="message"
)
attack_enemy: "AttackEnemy" = betterproto.message_field(8, group="message")
logout: "Logout" = betterproto.message_field(9, group="message")
uuid: str = betterproto.string_field(100)
@dataclass(eq=False, repr=False)
class MapChunkResponse(betterproto.Message):
chunks: List["MapChunk"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class ServerMessage(betterproto.Message):
ping: "Ping" = betterproto.message_field(1, group="message")
logged_in: "LoggedIn" = betterproto.message_field(2, group="message")
users: "Users" = betterproto.message_field(3, group="message")
chunk: "MapChunkResponse" = betterproto.message_field(4, group="message")
error: "Error" = betterproto.message_field(5, group="message")
logout: "Logout" = betterproto.message_field(6, group="message")
objects: "Objects" = betterproto.message_field(7, group="message")
object_asset: "ObjectAsset" = betterproto.message_field(8, group="message")
interact: "Interact" = betterproto.message_field(9, group="message")
give_damage: "GiveDamage" = betterproto.message_field(10, group="message")
uuid: str = betterproto.string_field(100)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/server_runner.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/server_runner.py | from __future__ import annotations
import struct
import time
import traceback
from asyncio import (
Queue,
StreamReader,
StreamWriter,
as_completed,
create_task,
sleep,
start_server,
)
from copy import deepcopy
from datetime import datetime, timedelta
from threading import Event
from typing import Awaitable, Callable, Dict, Tuple, TypeVar, cast
from uuid import uuid4
from betterproto import which_one_of
import server
from server.game.auth import auth
from server.game.entity.area import AreaObject
from server.game.entity.enemy import Enemy
from server.game.entity.npc import NPC
from server.game.map.properties import CustomInteraction, InteractionOn
from shared.collison import point_in_poly
from shared.constants import PLAYER_DEATH_TIMEOUT, SERVER_TICK_RATE, START_X, START_Y
from shared.gen.messages.v1 import (
AcknowledgeDamage,
AttackEnemy,
ClientMessage,
Coords,
EnemyInfo,
Error,
ErrorType,
GiveDamage,
Interact,
InteractStatus,
InteractType,
LoggedIn,
Login,
Logout,
MapChunkRequest,
MapChunkResponse,
Object,
ObjectAsset,
ObjectAssetRequest,
Objects,
ObjectType,
Ping,
ServerMessage,
SessionType,
User,
Users,
)
from shared.utils import AsyncEventHandler
ServerMessageOneOfType = (
Ping
| Login
| Coords
| MapChunkRequest
| ObjectAssetRequest
| Interact
| AcknowledgeDamage
| AttackEnemy
| Logout
)
ServerMessageOneOfTypeVar = TypeVar(
"ServerMessageOneOfTypeVar",
Ping,
Login,
Coords,
MapChunkRequest,
ObjectAssetRequest,
Interact,
AcknowledgeDamage,
AttackEnemy,
Logout,
)
class Connection:
reader: StreamReader
writer: StreamWriter
# (ServerMessage, Handler)
network_queue: Queue[
Tuple[ServerMessage, Callable[[ServerMessageOneOfType], None] | None]
]
handlers: Dict[str, Callable[[ServerMessageOneOfType], None]]
peer: str
def __init__(self, reader: StreamReader, writer: StreamWriter) -> None:
self.reader = reader
self.writer = writer
self.network_queue = Queue()
self.handlers = {}
self.peer = reader._transport.get_extra_info("peername") # type: ignore
self.ping_handler = AsyncEventHandler([self._ping])
self.login_handler = AsyncEventHandler([self._login])
self.move_handler = AsyncEventHandler([self._move])
self.map_chunk_handler = AsyncEventHandler([self._chunk_request])
self.object_asset_handler = AsyncEventHandler([self._object_asset_request])
self.interact_handler = AsyncEventHandler([self._interact])
self.acknowledge_damage_handler = AsyncEventHandler([self._acknowledge_damage])
self.attack_enemy_handler = AsyncEventHandler([self._attack_enemy])
self.logout_handler = AsyncEventHandler([self._logout])
async def read_message_loop(self) -> None:
try:
while not self.reader.at_eof():
size_buf = await self.reader.readexactly(4)
size = struct.unpack("!i", size_buf)[0]
data_buf = await self.reader.readexactly(size)
message = ClientMessage().parse(data_buf)
message_id = message.uuid
_, inner_message = which_one_of(message=message, group_name="message")
match inner_message:
case Ping():
await self.ping_handler(message_id, inner_message)
case Login():
await self.login_handler(message_id, inner_message)
case Coords():
await self.move_handler(message_id, inner_message)
case MapChunkRequest():
await self.map_chunk_handler(message_id, inner_message)
case ObjectAssetRequest():
await self.object_asset_handler(message_id, inner_message)
case Interact():
await self.interact_handler(message_id, inner_message)
case AcknowledgeDamage():
await self.acknowledge_damage_handler(message_id, inner_message)
case AttackEnemy():
await self.attack_enemy_handler(message_id, inner_message)
case Logout():
await self.logout_handler(message_id, inner_message)
case default:
raise Exception(f"Unkown message_type: {default}")
except Exception:
traceback.print_exc()
if server.game_state.is_authenticated(self.peer):
await self.logout()
async def send_message_loop(self) -> None:
try:
while True:
message, handler = await self.network_queue.get()
if message.uuid == "":
message_id = str(uuid4())
message.uuid = message_id
if handler is not None:
self.handlers[message.uuid] = handler
self._send_message(message)
except Exception:
traceback.print_exc()
if server.game_state.is_authenticated(self.peer):
await self.logout()
def _send_message(self, client_message: ServerMessage) -> None:
message_bytes = client_message.SerializeToString()
message = struct.pack("!i", len(message_bytes)) + message_bytes
self.writer.write(message)
@staticmethod
def authenticated(
func: Callable[[Connection, str, ServerMessageOneOfTypeVar], Awaitable[None]]
) -> Callable[[Connection, str, ServerMessageOneOfTypeVar], Awaitable[None]]:
async def inner(
self: Connection, uuid: str, message: ServerMessageOneOfTypeVar
) -> None:
if server.game_state.is_authenticated(self.peer):
await func(self, uuid, message)
else:
response = ServerMessage(
error=Error(
type=ErrorType.ERROR_TYPE_UNAUTHORIZED,
message="Not logged in yet.",
),
uuid=uuid,
)
await self.network_queue.put((response, None))
return inner
@authenticated
async def _logout(self, uuid: str, message: Logout) -> None:
await self.logout()
async def logout(self) -> None:
session = server.game_state.peer_sessions[self.peer]
user = server.game_state.get_user(session.user_id)
if user is None:
return
if session.type != SessionType.SESSION_TYPE_FREE_CAM:
response = ServerMessage(logout=Logout(user=user))
await server.global_server.broadcast(response)
await server.game_state.logout(self.peer)
@authenticated
async def _ping(self, uuid: str, message: Ping) -> None:
await server.game_state.ping(self.peer, message)
response = ServerMessage(ping=Ping(time=datetime.now()), uuid=uuid)
await self.network_queue.put((response, None))
async def _login(self, uuid: str, message: Login) -> None:
res = auth(message.username, message.password)
error_msg = ErrorType.ERROR_TYPE_UNSPECIFIED
if res == None: # Invalid auth
error_msg = ErrorType.ERROR_TYPE_UNAUTHORIZED
user_uuid = server.game_state.get_user_uuid(message.username)
user = server.game_state.get_user(user_uuid)
if user is None:
user = await server.game_state.get_remote_fulluser(message.username)
if user:
user.coords.timestamp = datetime.now()
if user is None:
user_id = str(uuid4())
start_coords = Coords(x=START_X, y=START_Y)
start_coords.timestamp = datetime.now()
user = User(
username=message.username,
uuid=user_id,
coords=start_coords,
money=1000,
health=100,
last_death=0,
)
elif (
user.last_death != 0
and (time.time() - user.last_death)
< PLAYER_DEATH_TIMEOUT # Check if user is still in timeout
):
res = None
error_msg = ErrorType.ERROR_TYPE_TIMEOUT
else:
if server.game_state.is_logged_in(message.username):
res = None
error_msg = ErrorType.ERROR_TYPE_ALREADY_LOGGED_IN
if await server.game_state.is_logged_in_remote(message.username):
res = None
error_msg = ErrorType.ERROR_TYPE_ALREADY_LOGGED_IN
response = ServerMessage(
logged_in=LoggedIn(
success=res is not None,
type=res if res is not None else SessionType.SESSION_TYPE_UNSPECIFIED,
error=error_msg,
),
uuid=uuid,
)
if res:
response.logged_in.self = user
response.logged_in.assets = server.game_state.map.player_asset
response.logged_in.interact_distance = 14
await self.network_queue.put((response, None))
if res:
await server.game_state.login(self.peer, user.uuid, user, res)
if res != SessionType.SESSION_TYPE_FREE_CAM:
response = ServerMessage(users=Users(users=[user]))
await server.global_server.broadcast(response, exclude=[self.peer])
users = server.game_state.get_online_users(self.peer)
response = ServerMessage(
users=Users(users=users),
)
await self.network_queue.put((response, None))
await self._send_new_objects_view_distance(user)
@authenticated
async def _move(self, uuid: str, message: Coords) -> None:
message.timestamp = datetime.now()
valid = await server.game_state.move(self.peer, message)
session = server.game_state.peer_sessions[self.peer]
user_uuid = session.user_id
user = server.game_state.get_user(user_uuid)
if user is None:
return
await self._send_new_objects_view_distance(user)
if session.type != SessionType.SESSION_TYPE_FREE_CAM:
if not valid:
response = ServerMessage(users=Users(users=[user]))
await server.global_server.broadcast(response, include=[self.peer])
objects = server.game_state.get_objects_view_distance(
user_uuid, user.coords.x, user.coords.y
)
for o in objects:
match o:
case AreaObject():
if o.interaction_on != InteractionOn.COLLIDE:
continue
if point_in_poly(user.coords.x, user.coords.y, o.area):
if not o.actice:
interact = o.in_range(user_uuid)
if interact:
resp = ServerMessage()
resp.interact = interact
await server.global_server.broadcast(
resp, include=[self.peer]
)
elif o.actice:
interact = o.out_of_range(user_uuid)
if interact:
resp = ServerMessage()
resp.interact = interact
await server.global_server.broadcast(
resp, include=[self.peer]
)
case _:
pass
@authenticated
async def _chunk_request(self, uuid: str, message: MapChunkRequest) -> None:
session = server.game_state.peer_sessions[self.peer]
chunks = server.game_state.map.get_chunks(message.x, message.y, session.user_id)
response = ServerMessage(uuid=uuid)
if len(chunks) == 0:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_CHUNK,
message="Invalid Chunk requested",
)
else:
print("Sending Chunk", chunks[0].x, chunks[0].y)
response.chunk = MapChunkResponse(chunks=chunks)
await self.network_queue.put((response, None))
@authenticated
async def _acknowledge_damage(self, uuid: str, message: AcknowledgeDamage) -> None:
user_uuid = server.game_state.peer_sessions[self.peer].user_id
user = server.game_state.get_user(uuid=user_uuid)
if user is None:
return
response = ServerMessage(uuid=uuid)
if (
server.game_state.fight_manager.can_take_damage_user(
username=user.username, cooldown_ticks=30
)
and message.damage > 0
):
user.health -= message.damage
await self.network_queue.put((response, None))
await server.global_server.update_self(user.uuid)
@authenticated
async def _attack_enemy(self, uuid: str, message: AttackEnemy) -> None:
session = server.game_state.peer_sessions[self.peer]
if session.type != SessionType.SESSION_TYPE_NORMAL:
return
user = server.game_state.get_user(uuid=session.user_id)
if user is None:
print("User not found")
return
enemy = server.game_state.enemy_manager.get_enemy_for_user_by_uuid(
user_uuid=session.user_id, enemy_uuid=message.uuid
)
if enemy is None:
return # TODO: Enemy not found message to client?
if not server.game_state.fight_manager.is_plausible_attack(
user=user, enemy=enemy, attack_msg=message
):
print("not plausible attack")
return # TODO: Not plausible message to client?
if not server.game_state.fight_manager.can_take_damage_enemy(
enemy_uuid=enemy.uuid, cooldown_ticks=30
): # TODO: Dynamic cooldown for attacks
print("Enemy can't get damage again, cooldown not reached")
return # TODO: Not plausible message to client?
await enemy.take_damage(message.damage)
# We use `move_enemy_object` here to send the enemy update to the client. Lazy, but good enough
await server.global_server.move_enemy_object(
uuid=enemy.uuid,
x=enemy.x,
y=enemy.y,
health=enemy.health,
health_max=enemy.health_max,
last_attack=enemy.last_attack,
name=enemy.name,
include_user_ids=[user.uuid],
)
@authenticated
async def _object_asset_request(
self, uuid: str, message: ObjectAssetRequest
) -> None:
response = ServerMessage(uuid=uuid)
o = server.game_state.object_manager.get_object_by_uuid(message.uuid)
match o:
case NPC():
response.object_asset = ObjectAsset(
object_uuid=o.uuid,
assets=o.entity_assets,
name=o.name,
type=ObjectType.OBJECT_TYPE_NPC,
interactable=o.interactable,
interact_distance=o.interact_distance,
)
case Enemy():
response.object_asset = ObjectAsset(
object_uuid=o.uuid,
assets=o.entity_assets,
name=o.name,
type=ObjectType.OBJECT_TYPE_ENEMY,
interactable=False,
interact_distance=0,
)
case _:
if message.uuid in server.game_state.users:
response.object_asset = ObjectAsset(
object_uuid=message.uuid,
assets=server.game_state.map.player_asset,
)
elif (
await server.game_state.get_remote_userid(message.uuid) is not None
):
response.object_asset = ObjectAsset(
object_uuid=message.uuid,
assets=server.game_state.map.player_asset,
)
else:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
await self.network_queue.put((response, None))
@authenticated
async def _interact(self, uuid: str, message: Interact) -> None:
response = ServerMessage(uuid=uuid)
obj = server.game_state.object_manager.get_object_by_uuid(message.uuid)
if obj is None:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
else:
session = server.game_state.peer_sessions[self.peer]
user_id = session.user_id
if session.type != SessionType.SESSION_TYPE_NORMAL:
return
user = server.game_state.get_user(user_id)
match obj:
case AreaObject():
o = server.game_state.area_manager.get_areas_for_user_by_uuid(
user_uuid=user_id, area_uuid=message.uuid
)
if user is None or o is None:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
else:
if o.interaction_on != InteractionOn.INTERACT:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid interaction requested",
)
else:
if point_in_poly(user.coords.x, user.coords.y, o.area):
interact = await o.interact(user_id, message)
if not interact:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid interaction requested",
)
else:
response.interact = interact
case NPC():
o = server.game_state.npc_manager.get_npc_for_user_by_uuid(
user_uuid=user_id, npc_uuid=message.uuid
)
player_asset = server.game_state.map.player_asset
if user is None or o is None:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
else:
if not o.interactable:
return
dx = (user.coords.x + player_asset.width / 2) - (
(o.x + o.entity_assets.width / 2)
)
dy = (user.coords.y - player_asset.height / 2) - (
(o.y - o.entity_assets.height / 2)
)
distance_sq = dx**2 + dy**2
if distance_sq < (o.interact_distance + 14) ** 2:
status = message.status
text = ""
interaction_type = InteractType.INTERACT_TYPE_UNSPECIFIED
shop = []
progress = 0.0
if (
o.interactions[o.interaction_step].custom_interaction
== CustomInteraction.RUNNER
):
interaction = await o.interact(
user_id=user_id, interact=message
)
if o.runner_seed is not None:
progress = o.runner_seed
interaction_type = interaction.interaction_type
elif message.status != InteractStatus.INTERACT_STATUS_STOP:
interaction = await o.interact(
user_id=user_id, interact=message
)
text = await interaction.text
shop = interaction.shop
if (
text == ""
and len(shop) == 0
and interaction.interaction_type
!= InteractType.INTERACT_TYPE_RUNNER
):
status = InteractStatus.INTERACT_STATUS_STOP
interaction_type = interaction.interaction_type
for s in shop:
if s.item:
s.item.description = ""
if s.trade_in:
s.trade_in.description = ""
response.interact = Interact(
status=status,
uuid=message.uuid,
text=text,
type=interaction_type,
shop=shop,
progress=progress,
)
case _:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
await self.network_queue.put((response, None))
async def _send_new_objects_view_distance(self, user: User) -> None:
objects: list[Object] = []
session = server.game_state.user_sessions[user.uuid]
for e in server.game_state.get_objects_view_distance(
uuid=user.uuid, x=user.coords.x, y=user.coords.y
):
if e.uuid in session.known_objects:
continue
obj_to_add = e.to_proto()
if e.type == ObjectType.OBJECT_TYPE_PICKUPABLE:
obj_to_add = deepcopy(obj_to_add)
obj_to_add.pickupable.description = ""
assert obj_to_add.type != ObjectType.OBJECT_TYPE_UNSPECIFIED, obj_to_add
objects.append(obj_to_add)
if len(objects) > 0:
session.known_objects |= set([o.uuid for o in objects])
response = ServerMessage(
objects=Objects(objects=objects),
)
await self.network_queue.put((response, None))
class Server:
connections: Dict[str, Connection]
def __init__(self, clickhouse_url: str) -> None:
self.connections = {}
self.clickhouse_url = clickhouse_url
async def start(self, host: str, port: int, running: Event) -> None:
self.running = running
await server.game_state.init(self.clickhouse_url)
s = await start_server(self.hande_cb, host=host, port=port)
update_loop_task = create_task(self.update_loop())
for coro in as_completed([update_loop_task]):
await coro
running.clear()
break
s.close()
# This is needed to give execution back to the control loop during the connection awaits
async def update_loop(self) -> None:
last_time = datetime.now()
while self.running.is_set():
current_time = datetime.now()
dt = (current_time - last_time).total_seconds()
if dt > (1 / (SERVER_TICK_RATE)) * 1.2:
print("REEE Server Lag")
await server.game_state.npc_manager.update(dt=dt)
await server.game_state.enemy_manager.update(dt=dt)
await server.game_state.pickupable_manager.update(dt=dt)
await server.game_state.object_manager.update(dt=dt)
# Check for user death and set timeout
for user in server.game_state.users.values():
if user.health < 0:
await server.game_state.die(user)
if user.uuid in server.game_state.user_sessions:
peer = server.game_state.user_sessions[user.uuid].peer
if (
peer in server.global_server.connections
and server.game_state.is_authenticated(peer)
):
await server.global_server.connections[peer].logout()
online_time = current_time - timedelta(minutes=1)
for s in list(server.game_state.peer_sessions.values()):
if s.last_ping.timestamp() < online_time.timestamp():
await server.global_server.connections[s.peer].logout()
await self.update_other_player_position()
last_time = datetime.now()
await sleep(1 / SERVER_TICK_RATE)
async def hande_cb(self, reader: StreamReader, writer: StreamWriter) -> None:
connection = Connection(reader, writer)
peer = cast(str, reader._transport.get_extra_info("peername")) # type: ignore
self.connections[peer] = connection
read_task = create_task(connection.read_message_loop())
send_task = create_task(connection.send_message_loop())
for coro in as_completed([read_task, send_task]):
await coro
break
del self.connections[peer]
def broadcast_sync(
self,
message: ServerMessage,
handler: Callable[[ServerMessageOneOfType], None] | None = None,
exclude: list[str] = [],
include: list[str] | None = None,
) -> None:
for peer, c in self.connections.items():
if not server.game_state.is_authenticated(peer):
continue
if peer in exclude:
continue
if include is not None and peer not in include:
continue
c.network_queue.put_nowait((message, handler))
async def broadcast(
self,
message: ServerMessage,
handler: Callable[[ServerMessageOneOfType], None] | None = None,
exclude: list[str] = [],
include: list[str] | None = None,
) -> None:
for peer, c in self.connections.items():
if not server.game_state.is_authenticated(peer):
continue
if peer in exclude:
continue
if include is not None and peer not in include:
continue
await c.network_queue.put((message, handler))
async def move_object(
self,
uuid: str,
x: float,
y: float,
include_user_ids: list[str] | None = None,
) -> None:
# No type specified, as this should be an object already known to the client
r = ServerMessage(objects=Objects([Object(uuid=uuid, coords=Coords(x=x, y=y))]))
users = server.game_state.get_local_users_distance(x, y)
users = [u.uuid for u in users]
if include_user_ids is not None:
users = [u for u in users if u in include_user_ids]
users_sessions = [
server.game_state.user_sessions[u].peer
for u in users
if u in server.game_state.user_sessions
]
if len(users_sessions) == 0:
return
await self.broadcast(r, include=users_sessions)
# This also includes enemy specific information
async def move_enemy_object(
self,
uuid: str,
x: float,
y: float,
health: int,
health_max: int,
last_attack: float,
name: str,
include_user_ids: list[str] | None = None,
) -> None:
# No type specified, as this should be an object already known to the client
r = ServerMessage(
objects=Objects(
[
Object(
uuid=uuid,
coords=Coords(x=x, y=y),
enemy_info=EnemyInfo(
health=health,
health_max=health_max,
name=name,
last_attack=last_attack,
),
)
]
)
)
users = server.game_state.get_local_users_distance(x, y)
users = [u.uuid for u in users]
if include_user_ids is not None:
users = [u for u in users if u in include_user_ids]
users_sessions = [
server.game_state.user_sessions[u].peer
for u in users
if u in server.game_state.user_sessions
]
if len(users_sessions) == 0:
return
await self.broadcast(r, include=users_sessions)
async def give_damage(
self, uuid: str, damage: int, include_user_ids: list[str] | None = None
) -> None:
r = ServerMessage(give_damage=GiveDamage(damage=damage))
users = server.game_state.users
if include_user_ids is not None:
users = [u for u in users if u in include_user_ids]
users_sessions = [
server.game_state.user_sessions[u].peer
for u in users
if u in server.game_state.user_sessions
]
if len(users_sessions) == 0:
return
await self.broadcast(r, include=users_sessions)
async def update_self(
self,
uuid: str,
) -> None:
user = server.game_state.users[uuid]
session = server.game_state.get_session(uuid)
r = ServerMessage(users=Users(users=[user]))
await server.game_state.update_remote_user(user)
if session:
await self.broadcast(r, include=[session])
async def update_other_player_position(self) -> None:
sessions = list(server.game_state.peer_sessions.values())
for s in sessions:
self_user = server.game_state.users.get(s.user_id, None)
if self_user is None:
continue
users = await server.game_state.get_online_users_distance(
self_user.coords.x, self_user.coords.y, s
)
new_known_users = set([u.uuid for u in users])
old_known_users = s.known_users - new_known_users
s.known_users = new_known_users
for u in old_known_users:
response = ServerMessage(logout=Logout(user=User(uuid=u)))
await server.global_server.broadcast(response, include=[s.peer])
message = ServerMessage(users=Users(users=users))
await self.broadcast(message, include=[s.peer])
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/models.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/models.py | from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Any
from shared.gen.messages.v1 import Coords, MapChunk, SessionType
@dataclass
class Position:
coords: Coords
time: datetime
@dataclass
class Session:
type: SessionType = field(default=SessionType.SESSION_TYPE_NORMAL)
peer: str = field(default_factory=str)
user_id: str = field(default_factory=str)
known_objects: set[str] = field(default_factory=set)
last_positions: list[Position] = field(default_factory=list[Position])
maze: list[list[MapChunk]] = field(default_factory=list)
waiting_maze_chunks: list[tuple[int, int]] = field(default_factory=list)
last_ping: datetime = field(default=datetime.now())
known_users: set[str] = field(default_factory=set)
logout: bool = field(default_factory=bool)
def __getstate__(self) -> None:
return None
def __setstate__(self, state: Any) -> None:
self.__dict__ = Session().__dict__
@dataclass
class ScoreboardEntry:
user_id: str
username: str | None = None
start: datetime | None = None
end: datetime | None = None
@property
def time(self) -> timedelta:
if self.start and self.end:
return self.end - self.start
return timedelta.max
def reset(self) -> None:
self.start = None
self.end = None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/main.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/main.py | import argparse
import logging
import os
import sys
import tempfile
from asyncio import get_event_loop
from concurrent.futures import ProcessPoolExecutor
from datetime import datetime
from threading import Event
from typing import cast
import dill
from rpyc.core import SlaveService
from rpyc.utils.server import ThreadedServer
import server
from server.game import auth
from server.game.state import Game
from server.server_runner import Server
def save_thread(file: str | None) -> None:
if file is None:
file = "backups/state.pickle"
state = server.game_state
with tempfile.NamedTemporaryFile(delete=False) as f:
dill.dump(state, f)
os.rename(f.name, file)
logging.info(msg=f"Backup saved in {file}")
def debug_server(path: str):
server = ThreadedServer(service=SlaveService, auto_register=False, socket_path=path)
import threading
thread = threading.Thread(target=server.start)
thread.daemon = True
thread.start()
def run() -> None:
# tracer = VizTracer(
# log_async=True, tracer_entries=10000000, output_file="result.json"
# )
# tracer.enable_thread_tracing()
# tracer.start()
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="Verbose", action="store_true")
parser.add_argument("-p", "--port", help="Port Default 1337", default=1337)
parser.add_argument("--host", help="Host Default 0.0.0.0", default="0.0.0.0")
parser.add_argument(
"--backup_file", help="Server backup file and auto restore", default=None
)
parser.add_argument("--debug_socket", help="Debug socket for server", default=None)
parser.add_argument("--auth_path", help="Path for credentials file", default=None)
parser.add_argument(
"--clickhouse_url", help="Clickhouse URL", default="http://localhost:8123/"
)
args = parser.parse_args()
log = logging.getLogger()
log.handlers.clear()
log.setLevel(level=logging.INFO)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
log.addHandler(handler)
assert args.auth_path, "Auth Path Needed"
auth.auth_path = args.auth_path
if args.debug_socket:
debug_server(args.debug_socket)
if args.verbose:
log.setLevel(level=logging.DEBUG)
server.executor = ProcessPoolExecutor(max_workers=4)
if args.backup_file and os.path.isfile(args.backup_file):
with open(args.backup_file, "rb") as f:
state = cast(Game, dill.load(f))
state.user_sessions = {}
state.peer_sessions = {}
for u in state.users.values():
u.coords.timestamp = datetime.now()
server.game_state = state
else:
server.game_state = Game()
server.global_server = Server(args.clickhouse_url)
log.info(f"Listening on {args.host}:{args.port}")
running = Event()
running.set()
loop = get_event_loop()
server_coro = server.global_server.start(
host=args.host, port=args.port, running=running
)
# Backups are now done via db
# save_timer = RepeatedTimer(
# interval=60,
# function=save_thread,
# file=args.backup_file,
# )
# save_timer.start()
try:
server_task = loop.run_until_complete(server_coro)
loop.run_forever()
except KeyboardInterrupt:
pass
print("BYE")
# tracer.stop()
# tracer.save()
# Close the server
server_task.close() # type: ignore
loop.run_until_complete(server_task.wait_closed()) # type: ignore
loop.close()
running.clear()
# save_timer.stop()
def debug():
parser = argparse.ArgumentParser()
parser.add_argument("--debug_socket", help="Debug socket for server", default=None)
args = parser.parse_args()
assert args.debug_socket
from rpyc.utils.classic import unix_connect # type: ignore
conn = unix_connect(args.debug_socket) # type: ignore
modules = conn.modules # type: ignore
from IPython.terminal.embed import embed # type: ignore
server = modules["server"] # type: ignore
embed(local_ns=locals(), colors="neutral")
if __name__ == "__main__":
run()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/__init__.py | from concurrent.futures import ProcessPoolExecutor
from pathlib import Path
from server.game.state import Game
from server.server_runner import Server
game_state: Game
global_server: Server
executor: ProcessPoolExecutor
PATH = Path(__file__).parent
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/fight.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/fight.py | import time
from typing import Dict
from server.game.entity.enemy import Enemy
from shared.constants import SERVER_TICK_RATE
from shared.gen.messages.v1 import AttackEnemy, User
class FightManager:
user_damage_cooldowns: Dict[str, float]
enemy_damage_cooldowns: Dict[str, float]
def __init__(self) -> None:
self.user_damage_cooldowns = {}
self.enemy_damage_cooldowns = {}
def can_take_damage_user(self, username: str, cooldown_ticks: int = 30) -> bool:
# User not in list => Store and allow to take damage
if not username in self.user_damage_cooldowns:
self.user_damage_cooldowns[username] = time.time()
return True
last_damage_timestamp = self.user_damage_cooldowns[username]
ticks_passed = (time.time() - last_damage_timestamp) * SERVER_TICK_RATE
# Cooldown did not pass yet
if ticks_passed < cooldown_ticks:
return False
self.user_damage_cooldowns[username] = time.time()
return True
def can_take_damage_enemy(self, enemy_uuid: str, cooldown_ticks: int = 30) -> bool:
# User not in list => Store and allow to take damage
if not enemy_uuid in self.user_damage_cooldowns:
self.enemy_damage_cooldowns[enemy_uuid] = time.time()
return True
last_damage_timestamp = self.enemy_damage_cooldowns[enemy_uuid]
ticks_passed = (time.time() - last_damage_timestamp) * SERVER_TICK_RATE
# Cooldown did not pass yet
if ticks_passed < cooldown_ticks:
return False
self.enemy_damage_cooldowns[enemy_uuid] = time.time()
return True
def is_plausible_attack(self, user: User, enemy: Enemy, attack_msg: AttackEnemy):
# Check if attack direction is plausible:
# TODO
# Check if damage is plausible
if attack_msg.damage > 11:
return False
if attack_msg.damage < 0:
return False
# Check if enemy is in range of weapon
dist_x = (user.coords.x - enemy.x) ** 2
dist_y = (user.coords.y - enemy.y) ** 2
max_attack_distance = 400 # TODO: Find good value, maybe dynamic from weapon
if dist_x + dist_y > max_attack_distance:
return False
attack_timestamp = time.mktime(attack_msg.time.timetuple())
if not enemy.uuid in self.enemy_damage_cooldowns:
self.enemy_damage_cooldowns[enemy.uuid] = attack_timestamp
return True
# TODO: Get dynamic from current user weapon
weapon_cooldown_ticks = 30
last_damage_timestamp = self.enemy_damage_cooldowns[enemy.uuid]
ticks_passed = (attack_timestamp - last_damage_timestamp) * SERVER_TICK_RATE
if ticks_passed > weapon_cooldown_ticks:
self.enemy_damage_cooldowns[enemy.uuid] = time.mktime(
attack_msg.time.timetuple()
)
return True
return False
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/state.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/state.py | import json
import math
import time
from collections import defaultdict
from copy import deepcopy
from datetime import datetime, timedelta
from pathlib import Path
from typing import Any, Dict, List, Literal, cast
from aiochclient import ChClient
from aiohttp import ClientSession
from aiohttp_retry import ExponentialRetry, RetryClient
import server
from server.game.entity.area import AreaObject
from server.game.entity.enemy import Enemy
from server.game.entity.npc import NPC
from server.game.entity.object import Object
from server.game.entity.pickupable import Pickupable
from server.game.fight import FightManager
from server.game.map.map import Map
from server.game.secret import ITEMS
from server.models import Position, ScoreboardEntry, Session
from shared.collison import CollisionManager, point_in_poly
from shared.constants import (
CHUNK_SIZE_X,
CHUNK_SIZE_Y,
PLAYER_HEIGHT,
PLAYER_SPEED,
PLAYER_WIDTH,
START_X,
START_Y,
TILE_SIZE_X,
TILE_SIZE_Y,
VIEW_DISTANCE_SQ,
)
from shared.gen.messages.v1 import (
Coords,
Item,
Ping,
SessionType,
ShopInteract,
ShopInteractType,
User,
)
def sign(x: float) -> Literal[-1, 1, 0]:
if x < 0:
return -1
elif x > 0:
return 1
else:
return 0
class PrefixMatch:
index: int
expected: List[Any]
def __init__(self, expected: List[Any]):
self.index = 0
self.expected = expected
def check_next(self, obj: Any) -> bool:
if self.expected[self.index] == obj:
self.index += 1
if self.index == len(self.expected):
self.index = 0
return True
elif self.index > 0 and self.expected[self.index - 1] != obj:
self.index = 0
return False
class ObjectManager:
static_objects: Dict[str, Object]
def __init__(self):
self.static_objects = {}
def get_objects_dict(self) -> Dict[str, Object]:
return self.static_objects
def get_objects_list(self) -> List[Object]:
return list(self.static_objects.values())
def get_object_by_uuid(self, uuid: str) -> Object | None:
if not uuid in self.static_objects:
return None
return self.static_objects[uuid]
async def update(self, dt: float):
for object in self.static_objects.values():
await object.update(dt=dt)
class EnemyManager:
enemies: Dict[str, Dict[str, Enemy]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.enemies = defaultdict(lambda: {})
self.object_manager = object_manager
# Helper classes
def get_enemies_for_user_dict(self, user_uuid: str) -> Dict[str, Enemy]:
return self.enemies[user_uuid]
def get_enemies_for_user_list(self, user_uuid: str) -> List[Enemy]:
return list(self.enemies[user_uuid].values())
def get_enemy_for_user_by_uuid(
self, user_uuid: str, enemy_uuid: str
) -> Enemy | None:
if not user_uuid in self.enemies:
return None
if not enemy_uuid in self.enemies[user_uuid]:
return None
return self.enemies[user_uuid][enemy_uuid]
def new_login(self, user_uuid: str):
if user_uuid not in self.enemies:
self.enemies[user_uuid] = {}
def deepcopy_add(self, user_uuid: str, enemy: Enemy):
tmp = deepcopy(enemy)
tmp.user_uuid = user_uuid
self.enemies[user_uuid][enemy.uuid] = tmp
async def update(self, dt: float):
for _, user_enemies in self.enemies.items():
for enemy in user_enemies.values():
await enemy.update(dt)
class AreaManager:
area_objects: Dict[str, Dict[str, AreaObject]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.area_objects = defaultdict(lambda: {})
self.object_manager = object_manager
def get_areas_for_user_dict(self, user_uuid: str) -> Dict[str, AreaObject]:
return self.area_objects[user_uuid]
def get_areas_for_user_list(self, user_uuid: str) -> List[AreaObject]:
return list(self.area_objects[user_uuid].values())
async def update(self, dt: float):
for user_areas in self.area_objects.values():
for npc in user_areas.values():
await npc.update(dt=dt)
def get_areas_for_user_by_uuid(
self, user_uuid: str, area_uuid: str
) -> AreaObject | None:
if not user_uuid in self.area_objects:
return None
if not area_uuid in self.area_objects[user_uuid]:
return None
return self.area_objects[user_uuid][area_uuid]
def deepcopy_add(self, user_uuid: str, area: AreaObject):
tmp = deepcopy(area)
tmp.user_uuid = user_uuid
self.area_objects[user_uuid][area.uuid] = tmp
class NPCManager:
npc_objects: Dict[str, Dict[str, NPC]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.npc_objects = defaultdict(lambda: {})
self.object_manager = object_manager
def get_npcs_for_user_dict(self, user_uuid: str) -> Dict[str, NPC]:
return self.npc_objects[user_uuid]
def get_npcs_for_user_list(self, user_uuid: str) -> List[NPC]:
return list(self.npc_objects[user_uuid].values())
async def update(self, dt: float):
for user_npcs in self.npc_objects.values():
for npc in user_npcs.values():
await npc.update(dt=dt)
def get_npc_for_user_by_uuid(self, user_uuid: str, npc_uuid: str) -> NPC | None:
if not user_uuid in self.npc_objects:
return None
if not npc_uuid in self.npc_objects[user_uuid]:
return None
return self.npc_objects[user_uuid][npc_uuid]
def deepcopy_add(self, user_uuid: str, npc: NPC):
tmp = deepcopy(npc)
tmp.user_uuid = user_uuid
self.npc_objects[user_uuid][npc.uuid] = tmp
class PickupableManager:
pickupable_objects: Dict[str, Dict[str, Pickupable]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.pickupable_objects = defaultdict(lambda: {})
self.object_manager = object_manager
def get_pickupable_for_user_dict(self, user_uuid: str) -> Dict[str, Pickupable]:
return self.pickupable_objects[user_uuid]
def get_pickupable_for_user_list(self, user_uuid: str) -> List[Pickupable]:
return list(self.pickupable_objects[user_uuid].values())
def get_pickupable_for_user_by_uuid(
self, user_uuid: str, pickupable_uuid: str
) -> Pickupable | None:
if not user_uuid in self.pickupable_objects:
return None
if not pickupable_uuid in self.pickupable_objects[user_uuid]:
return None
return self.pickupable_objects[user_uuid][pickupable_uuid]
def deepcopy_add(self, user_uuid: str, pickupable: Pickupable) -> None:
tmp = deepcopy(pickupable)
tmp.user_uuid = user_uuid
self.pickupable_objects[user_uuid][pickupable.uuid] = tmp
async def update(self, dt: float) -> None:
for _, pickupables in self.pickupable_objects.items():
for pickupable in list(pickupables.values()):
if pickupable.pickedup and pickupable.garbage_collect_on_pickup:
del pickupables[pickupable.uuid]
continue
await pickupable.update(dt)
class Game:
peer_sessions: Dict[str, Session]
user_sessions: Dict[str, Session]
users: Dict[str, User]
recent_moves: Dict[str, PrefixMatch]
user_collision_manager: CollisionManager
objects: Dict[str, Dict[str, Object]]
fight_manager: FightManager
scoreboard: dict[str, ScoreboardEntry]
running_scoreboard: dict[str, ScoreboardEntry]
enemy_manager: EnemyManager
object_manager: ObjectManager
npc_manager: NPCManager
area_manager: AreaManager
pickupable_manager: PickupableManager
def __init__(self) -> None:
self.peer_sessions = {}
self.user_sessions = {}
self.users = {}
self.recent_moves = {}
self.user_collision_manager = CollisionManager(PLAYER_WIDTH, PLAYER_HEIGHT)
# Manager
self.fight_manager = FightManager()
self.object_manager = ObjectManager()
self.enemy_manager = EnemyManager(self.object_manager)
self.npc_manager = NPCManager(self.object_manager)
self.area_manager = AreaManager(self.object_manager)
self.pickupable_manager = PickupableManager(self.object_manager)
self.map = Map(Path(server.PATH, "./map/testmap.json"))
self.object_manager.static_objects = self.map.initialize()
self.scoreboard = {}
self.running_scoreboard = {}
async def init(self, clickhouse_url: str) -> None:
self.session = ClientSession()
retry_options = ExponentialRetry(attempts=2)
self.retry_client = RetryClient(
client_session=self.session, retry_options=retry_options
)
self.ch_client = ChClient(session=self.session, url=clickhouse_url)
async def update_remote_user(self, user: User) -> None:
session = self.user_sessions[user.uuid]
await self.ch_client.execute(
"INSERT INTO game.users VALUES",
(
user.uuid,
user.username,
user.coords.x,
user.coords.y,
user.coords.rotation,
user.money,
json.dumps([i.to_json() for i in user.inventory]),
user.health,
user.last_death,
session.last_ping.timestamp(),
),
)
async def update_scoreboard(self, entry: ScoreboardEntry) -> None:
user = self.users[entry.user_id]
if entry.start is None:
return
if entry.end is None:
return
await self.ch_client.execute(
"INSERT INTO game.scoreboard VALUES",
(
user.username,
entry.start.timestamp(),
entry.end.timestamp(),
),
)
async def get_remote_scoreboard(self) -> list[ScoreboardEntry]:
res = await self.ch_client.fetch(
"SELECT uuid, username, start, end FROM game.scoreboard FINAL INNER JOIN (SELECT * FROM game.users FINAL) users USING username"
)
return [
ScoreboardEntry(
user_id=r["uuid"],
username=r["username"],
start=datetime.fromtimestamp(r["start"]),
end=datetime.fromtimestamp(r["end"]),
)
for r in res
]
def is_authenticated(self, client: str) -> bool:
return client in self.peer_sessions
def is_logged_in(self, username: str) -> bool:
return next(
(
True
for u in self.user_sessions.keys()
if self.users[u].username == username
),
False,
)
async def is_logged_in_remote(self, username: str) -> bool:
online_time = datetime.now() - timedelta(minutes=1)
user = await self.ch_client.fetchrow(
"SELECT * FROM game.users FINAL WHERE username = {username} AND last_ping >= {last_ping}",
params={"username": username, "last_ping": online_time.timestamp()},
)
return user is not None
def get_user_uuid(self, username: str) -> str | None:
return next(
(u.uuid for u in self.users.values() if u.username == username), None
)
def get_user(self, uuid: str | None) -> User | None:
if uuid is None:
return None
return self.users[uuid]
def get_session(self, user_id: str) -> str | None:
return self.user_sessions[user_id].peer
async def login(
self, client: str, user_id: str, user: User, type: SessionType
) -> Session:
await self.ch_client.is_alive()
chunk_x = user.coords.x // (CHUNK_SIZE_X * TILE_SIZE_X)
chunk_y = user.coords.y // (CHUNK_SIZE_Y * TILE_SIZE_Y)
if self.map.is_dynamic_chunk(chunk_x, chunk_y):
user.coords = Coords(x=START_X, y=START_Y)
user.coords.timestamp = datetime.now()
session = Session(peer=client, user_id=user_id, type=type)
session.last_ping = datetime.now()
self.peer_sessions[client] = session
self.user_sessions[user_id] = session
if user_id not in self.users:
self.users[user_id] = user
self.recent_moves[user_id] = PrefixMatch(
[
(-1, 0),
(1, 0),
(1, -1),
(0, -1),
(-1, 1),
(0, -1),
(1, -1),
(-1, 0),
(1, 1),
(1, -1),
(0, -1),
(1, 0),
]
)
await self.update_remote_user(user)
return session
async def logout(self, client: str) -> None:
if client in self.peer_sessions:
session = self.peer_sessions[client]
session.logout = True
user = self.users[session.user_id]
session.last_ping = datetime.fromtimestamp(0)
await self.update_remote_user(user)
self.peer_sessions.pop(client)
self.user_sessions.pop(session.user_id)
self.users.pop(session.user_id)
async def move(self, client: str, coords: Coords) -> bool:
if client in self.peer_sessions:
session = self.peer_sessions[client]
user_id = session.user_id
user = self.users[user_id]
if session.type == SessionType.SESSION_TYPE_FREE_CAM:
user.coords = coords
return True
user_coords_timestamp = cast(datetime, user.coords.timestamp) # type: ignore
coords_timestamp = cast(datetime, coords.timestamp) # type: ignore
distance_time = coords_timestamp - user_coords_timestamp
distance_x = user.coords.x - coords.x
distance_y = user.coords.y - coords.y
distance_sq = distance_x**2 + distance_y**2
max_distance_sq = (
min(distance_time.total_seconds(), 0.2) * PLAYER_SPEED
) ** 2
if max_distance_sq < distance_sq:
# maybe we found a hacker, check average over last positions
check_time = 0.2 # check for the last 200 ms
new_pos: list[Position] = []
k = -1
while len(session.last_positions) > 0:
pos = session.last_positions.pop()
new_pos.append(pos)
k = (coords_timestamp - pos.time).total_seconds()
if k >= check_time:
break
toff = (
coords_timestamp - new_pos[-1].time
).total_seconds() - check_time
session.last_positions = new_pos[::-1]
if len(new_pos) < 2:
user.coords.timestamp = coords_timestamp
return False
# does this interpolation to exactly 0.2s anything? or would comparison to 0.2+toff also be fine?
dt = (new_pos[-2].time - new_pos[-1].time).total_seconds()
dx = (new_pos[-2].coords.x - new_pos[-1].coords.x) * (toff / dt)
dy = (new_pos[-2].coords.y - new_pos[-1].coords.y) * (toff / dt)
pos_at_50 = new_pos[-1].coords.x + dx, new_pos[-1].coords.y + dy
distance_x_at_50 = coords.x - pos_at_50[0]
distance_y_at_50 = coords.y - pos_at_50[1]
distance_sq_50 = distance_x_at_50**2 + distance_y_at_50**2
# with this change PLAYER_SPEED (not *1.2) should be fine, but it isn't, why?
#
if math.sqrt(distance_sq_50) > check_time * PLAYER_SPEED * 1.2:
print(distance_time.total_seconds())
# print(math.sqrt(distance_sq_50), check_time * PLAYER_SPEED, k)
if math.sqrt(distance_sq_50) > check_time * PLAYER_SPEED * 1.2:
user.coords.timestamp = coords_timestamp
return False
match self.user_collision_manager.check_collisons(
self.map, user.coords.x, user.coords.y, coords.x, coords.y, user_id
):
case None:
return False
case x, y:
pass
valid = True
if x != coords.x or y != coords.y:
valid = False
coords.x = x
coords.y = y
user.coords = coords
if valid:
await self.update_remote_user(user)
session.last_positions.append(Position(coords, coords_timestamp))
if self.recent_moves[user_id].check_next(
(sign(distance_x), sign(distance_y))
):
await self.give_item(
user_id,
ITEMS["flag_cheat"],
True,
)
return valid
return False
async def give_item(self, user_id: str, item: Item, once: bool = False) -> bool:
user = self.users[user_id]
res = True
for i in user.inventory:
if i.name == item.name:
if once:
res = False
break
else:
i.quantity += item.quantity
res = True
break
else:
user.inventory.append(item)
if res:
await server.global_server.update_self(user_id)
return res
def shop(self, user_id: str, shop_interact: ShopInteract) -> bool:
user = self.users[user_id]
match shop_interact.type:
case ShopInteractType.SHOP_INTERACT_TYPE_BUY:
item = None
for i in user.inventory:
if i.name == shop_interact.item.name:
item = i
break
else:
return False
if item.quantity >= shop_interact.item.quantity:
item.quantity -= shop_interact.item.quantity
if item.quantity == 0:
user.inventory.remove(item)
user.money += shop_interact.cost
return True
case ShopInteractType.SHOP_INTERACT_TYPE_SELL:
if user.money >= shop_interact.cost:
user.money -= shop_interact.cost
for i in user.inventory:
if i.name == shop_interact.item.name:
i.quantity += shop_interact.item.quantity
break
else:
user.inventory.append(shop_interact.item)
return True
case ShopInteractType.SHOP_INTERACT_TYPE_TRADE:
item = None
for i in user.inventory:
if i.name == shop_interact.item.name:
item = i
break
else:
return False
if item.quantity >= shop_interact.item.quantity:
item.quantity -= shop_interact.item.quantity
if item.quantity == 0:
user.inventory.remove(item)
for i in user.inventory:
if i.name == shop_interact.trade_in.name:
i.quantity += shop_interact.trade_in.quantity
break
else:
user.inventory.append(shop_interact.trade_in)
return True
case _:
pass
return False
def get_users(self, client: str | None = None) -> List[User]:
if client in self.peer_sessions:
return [u for c, u in self.users.items() if c != self.peer_sessions[client]]
return list(self.users.values())
def get_online_users(self, client: str | None = None) -> List[User]:
if client in self.peer_sessions:
return [
self.users[user_id]
for user_id, session in self.user_sessions.items()
if session.peer != client
and session.type != SessionType.SESSION_TYPE_FREE_CAM
]
return list(self.users.values())
async def get_remote_username(self, username: str) -> User | None:
user = await self.ch_client.fetchrow(
"SELECT uuid, username, x, y, rotation FROM game.users FINAL WHERE username = {username}",
params={"username": username},
)
if user:
return User(
uuid=str(user["uuid"]),
username=user["username"],
last_death=user["last_death"],
coords=Coords(x=user["x"], y=user["y"], rotation=user["rotation"]),
)
else:
return None
async def get_remote_userid(self, user_id: str) -> User | None:
user = await self.ch_client.fetchrow(
"SELECT uuid, username, x, y, rotation, last_death FROM game.users FINAL WHERE uuid = {uuid}",
params={"uuid": user_id},
)
if user:
return User(
uuid=str(user["uuid"]),
username=user["username"],
last_death=user["last_death"],
coords=Coords(x=user["x"], y=user["y"], rotation=user["rotation"]),
)
else:
return None
async def get_remote_fulluser(self, username: str) -> User | None:
user = await self.ch_client.fetchrow(
"SELECT * FROM game.users FINAL WHERE username = {username}",
params={"username": username},
)
if user:
return User(
uuid=str(user["uuid"]),
username=user["username"],
coords=Coords(x=user["x"], y=user["y"], rotation=user["rotation"]),
money=user["money"],
inventory=[Item().from_json(i) for i in json.loads(user["inventory"])],
health=user["health"],
last_death=user["last_death"],
)
else:
return None
async def get_remote_online_users(
self, exclude_user_id: str | None = None
) -> List[User]:
online_time = datetime.now() - timedelta(minutes=1)
res = []
if exclude_user_id is None:
res = await self.ch_client.fetch(
"SELECT uuid, username, x, y, rotation, last_death FROM game.users FINAL WHERE last_ping >= {last_ping}",
params={"last_ping": online_time.timestamp()},
)
else:
res = await self.ch_client.fetch(
"SELECT uuid, username, x, y, rotation, last_death FROM game.users FINAL WHERE uuid != {uuid} AND last_ping >= {last_ping}",
params={"uuid": exclude_user_id, "last_ping": online_time.timestamp()},
)
users = [
User(
uuid=str(r["uuid"]),
username=r["username"],
last_death=r["last_death"],
coords=Coords(x=r["x"], y=r["y"], rotation=r["rotation"]),
)
for r in res
]
return users
def get_local_users_distance(
self, x: float, y: float, user_session: Session | None = None
) -> List[User]:
peer = None
if user_session:
peer = user_session.peer
users = self.get_online_users(peer)
objects = filter(
lambda e: (abs(x - e.coords.x) ** 2) + (abs(y - e.coords.y) ** 2)
<= VIEW_DISTANCE_SQ,
users,
)
return list(objects)
async def get_online_users_distance(
self, x: float, y: float, user_session: Session | None = None
) -> List[User]:
peer = None
user_id = None
if user_session:
peer = user_session.peer
user_id = user_session.user_id
users = self.get_online_users(peer) + await self.get_remote_online_users(
user_id
)
objects = filter(
lambda e: (abs(x - e.coords.x) ** 2) + (abs(y - e.coords.y) ** 2)
<= VIEW_DISTANCE_SQ,
users,
)
return list(objects)
@staticmethod
def is_in_view(x: float, y: float, object: Object) -> bool:
match object:
case AreaObject():
return point_in_poly(x, y, object.area)
case _:
return ((x - object.x) ** 2) + ((y - object.y) ** 2) <= VIEW_DISTANCE_SQ
def get_objects_view_distance(self, uuid: str, x: float, y: float) -> List[Object]:
original_objects = filter(
lambda obj: self.is_in_view(x, y, obj),
self.object_manager.get_objects_list(),
)
# A list to store all the different object types as Object
objects: Dict[str, Object] = {}
# Get map values. Those are Enemies, NPCs, Items etc. Depending on the type, we have to handle them per user
# TODO: Maybe better perf to add the deepcopied object directly
for o in original_objects:
match o:
case AreaObject():
if o.uuid not in self.area_manager.get_areas_for_user_dict(
user_uuid=uuid
):
self.area_manager.deepcopy_add(user_uuid=uuid, area=o)
objects[o.uuid] = self.area_manager.get_areas_for_user_dict(
user_uuid=uuid
)[o.uuid]
case NPC():
if o.interactable:
if o.uuid not in self.npc_manager.get_npcs_for_user_dict(
user_uuid=uuid
):
self.npc_manager.deepcopy_add(user_uuid=uuid, npc=o)
objects[o.uuid] = self.npc_manager.get_npcs_for_user_dict(
user_uuid=uuid
)[o.uuid]
else:
objects[o.uuid] = o
case Enemy():
if o.uuid not in self.enemy_manager.get_enemies_for_user_dict(
user_uuid=uuid
):
self.enemy_manager.deepcopy_add(user_uuid=uuid, enemy=o)
objects[o.uuid] = self.enemy_manager.get_enemies_for_user_dict(
user_uuid=uuid
)[o.uuid]
case Pickupable():
if o.pickedup:
continue
if (
o.uuid
not in self.pickupable_manager.get_pickupable_for_user_dict(
user_uuid=uuid
)
):
self.pickupable_manager.deepcopy_add(
user_uuid=uuid, pickupable=o
)
object = self.pickupable_manager.get_pickupable_for_user_dict(
user_uuid=uuid
)[o.uuid]
if not object.pickedup:
objects[o.uuid] = object
# Fallback for unknown objects
case _:
objects[o.uuid] = o
objects.update(
{
p.uuid: p
for p in self.area_manager.get_areas_for_user_list(user_uuid=uuid)
if p.uuid not in objects
}
)
objects.update(
{
p.uuid: p
for p in self.npc_manager.get_npcs_for_user_list(user_uuid=uuid)
if p.uuid not in objects
}
)
objects.update(
{
p.uuid: p
for p in self.enemy_manager.get_enemies_for_user_list(user_uuid=uuid)
if p.uuid not in objects
}
)
objects.update(
{
p.uuid: p
for p in self.pickupable_manager.get_pickupable_for_user_list(
user_uuid=uuid
)
if p.uuid not in objects and not p.pickedup
}
)
# objects += self.object_manager.get_static_objects()
return list(objects.values())
def start_timer(self, user_id: str) -> None:
scoreboard_entry = self.running_scoreboard.get(user_id)
if scoreboard_entry is None:
scoreboard_entry = ScoreboardEntry(user_id=user_id)
self.running_scoreboard[user_id] = scoreboard_entry
scoreboard_entry.reset()
scoreboard_entry.start = datetime.now()
async def stop_timer(self, user_id: str) -> ScoreboardEntry | None:
scoreboard_entry = self.running_scoreboard.get(user_id)
if scoreboard_entry is None:
return
if scoreboard_entry.end:
return
scoreboard_entry.end = datetime.now()
del self.running_scoreboard[user_id]
last_best_entry = self.scoreboard.get(user_id)
if last_best_entry is None or last_best_entry.time > scoreboard_entry.time:
self.scoreboard[user_id] = scoreboard_entry
await self.update_scoreboard(scoreboard_entry)
return scoreboard_entry
async def die(self, user: User) -> None:
print(f"Player {user.username} died :( Resetting")
user.last_death = time.time()
start_coords = Coords(x=START_X, y=START_Y)
start_coords.timestamp = datetime.now()
user.health = 100
user.coords = start_coords
await self.update_remote_user(user)
async def ping(self, peer: str, ping: Ping) -> None:
session = self.peer_sessions[peer]
if session.logout:
return
user = self.users[session.user_id]
session.last_ping = datetime.now()
await self.update_remote_user(user)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/secret.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/secret.py | from shared.gen.messages.v1 import Item
ITEMS = {
"shovel": Item(name="Shovel", description="DIGGY DIGGY", quantity=1, icon=2501),
"flag_dig": Item(
name="Dig Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2562,
),
"flag_runner": Item(
name="Runner Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2563,
),
"flag_license": Item(
name="License check Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2564,
),
"localo": Item(
name="localo",
description="This could have been a flag, but instead you found localo. And you won't get rid of him, since nobody bothered to implement a the functionality to delete items from your inventory.",
quantity=1,
icon=2379,
),
"flag_sanity": Item(
name="Sanity Flag",
description="Everyone has to start somewhere. ALLES!{REDACTED}",
quantity=1,
icon=2565,
),
"flag_race_to_top": Item(
name="Race to Top Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2566,
),
"flag_merchant": Item(
name="Merchant Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2567,
),
# 2568 Maze flag
"flag_boss": Item(
name="Boss Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2569,
),
"flag_cheat": Item(
name="Cheat Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2570,
),
# 2571 unreachable flag
}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/auth.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/auth.py | import json
from pathlib import Path
from shared.gen.messages.v1 import SessionType
auth_path: str
def auth(username: str, password: str) -> SessionType | None:
with open(Path(auth_path), "r") as f:
users = json.load(f)
for u, p in users["users"].items():
if username[:-1] == u and username[-1].isnumeric():
if p == password:
return SessionType.SESSION_TYPE_NORMAL
for u, p in users["freecam"].items():
if username[:-1] == u and username[-1].isnumeric():
if p == password:
return SessionType.SESSION_TYPE_FREE_CAM
return None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/statemachine.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/statemachine.py | from dataclasses import dataclass
from typing import Dict
STATE_CONTINUE = "STATE_CONTINUE"
@dataclass
class BaseState:
DEBUG = False
name: str
parameter: object
def __init__(self, name: str = "none", param: object = None):
self.name = name
self.parameter = param
def enter(self):
if BaseState.DEBUG:
print("Entering state: " + self.name)
pass
def leave(self):
if BaseState.DEBUG:
print("Entering state: " + self.name)
pass
async def update(self, dt: float) -> str:
return STATE_CONTINUE
@dataclass
class StateMachine:
current_state: BaseState
previous_state: BaseState
_states: Dict[str, BaseState]
def __init__(self):
self.current_state = BaseState()
self.previous_state = BaseState()
self._states = {}
pass
async def update(self, dt: float):
next_state: str = await self.current_state.update(dt=dt)
if next_state == STATE_CONTINUE:
return
# State transition
self.change_state(next_state)
def change_state(self, name: str):
assert name in self._states.keys(), "State not found: " + name
self.current_state.leave()
self.previous_state = self.current_state
self.current_state = self._states[name]
self.current_state.enter()
def add_state(self, state: BaseState):
assert state.name not in self._states.keys(), (
"State already in state list" + state.name
)
self._states[state.name] = state
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/npc.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/npc.py | import json
import logging
import math
import random
from copy import copy
from dataclasses import dataclass
from datetime import timedelta
from pathlib import Path
from typing import Any, List, Tuple, cast
import server
from server.game.entity.dino_runner import Engine
from server.game.entity.object import Object
from server.game.map.properties import CustomInteraction
from server.game.secret import ITEMS
from server.models import ScoreboardEntry
from shared.gen.messages.v1 import (EntityAsset, EntityAssets, Interact,
InteractStatus, InteractType, Item)
from shared.gen.messages.v1 import Object as ObjectProto
from shared.gen.messages.v1 import (ObjectType, Polygon, ShopInteract,
ShopInteractType)
# This comes from the native python module, redacted here
# from license_checker import check_license # type: ignore
shop_items: Any = None
def get_random_shop_item(exclude: Item | None = None) -> Item:
global shop_items
if shop_items is None:
with open(Path(server.PATH, "./map/items.json")) as f:
shop_items = json.load(f)["items"]
possibilities = shop_items.copy()
if exclude:
possibilities = [p for p in possibilities if p["name"] != exclude.name]
item = random.choice(possibilities)
item_proto = Item().from_dict(item)
item_proto.quantity = random.randint(1, 3)
return item_proto
@dataclass
class NPCPath:
path: Polygon
current_path_step: int
speed: float
loop: bool
def __init__(self, path: Polygon | None, speed: float, loop: bool = False):
match path:
case None:
self.path = Polygon()
case p:
self.path = p
self.current_path_step = 0
self.speed = speed
self.loop = loop
def reset(self):
self.current_path_step = 0
def get_next_position(self, dt: float, x: float, y: float) -> Tuple[float, float]:
if self.current_path_step > len(self.path.points) or len(self.path.points) == 0:
return (x, y)
next_point = self.path.points[self.current_path_step % len(self.path.points)]
if x == next_point.x and y == next_point.y:
self.current_path_step += 1
if self.loop:
self.current_path_step %= len(self.path.points)
next_point = self.path.points[
self.current_path_step % len(self.path.points)
]
dx = next_point.x - x
dy = next_point.y - y
l = math.sqrt(dx**2 + dy**2)
dx *= 1 / l
dy *= 1 / l
distance_x = dx * self.speed * dt
distance_y = dy * self.speed * dt
max_l = math.sqrt(distance_x**2 + distance_y**2)
if max_l > l:
distance_x = dx * l
distance_y = dy * l
next_x = x + distance_x
next_y = y + distance_y
x = next_x
y = next_y
return (x, y)
@dataclass
class Interaction:
id: int
_text: str
path: NPCPath
speed: float
loop: bool
current_path_step: int
next_interaction: int
custom_interaction: CustomInteraction
custom_attribute: str
def __init__(
self,
id: int,
text: str,
path: Polygon | None,
speed: float,
loop: bool,
custom_interaction: CustomInteraction,
custom_attribute: str,
current_path_step: int = 0,
next_interaction: int = -1,
) -> None:
match path:
case None:
self.path = NPCPath(path=None, speed=speed, loop=loop)
case p:
self.path = NPCPath(path=p, speed=speed, loop=loop)
self.id = id
self._text = text
self.speed = speed
self.loop = loop
self.custom_interaction = custom_interaction
self.custom_attribute = custom_attribute
self.current_path_step = current_path_step
self.next_interaction = next_interaction
if self.custom_interaction == CustomInteraction.TALKY:
with open(Path(server.PATH, custom_attribute), "r") as f:
self._text = f.read()
@property
async def text(self) -> str:
match self.custom_interaction:
case CustomInteraction.REQUIRE_ITEMS:
# this is fine :mildpanic:
req = eval(self.custom_attribute)
return self._text.replace(
r"%items",
",".join([f"{y}x {x}" for (x, y) in req.items()]),
)
case CustomInteraction.TALKY:
if len(self._text) == 0:
with open(Path(server.PATH, self.custom_attribute), "r") as f:
self._text = f.read()
return ""
split = self._text.split("\n", 1)
passage = split[0]
if len(passage) <= 200:
if len(split) > 1:
self._text = split[1]
else:
self._text = ""
else:
passage = passage[:200].rsplit(" ", 1)[0]
self._text = self._text[len(passage) :]
passage = passage.lstrip()
return passage
case CustomInteraction.SCOREBOARD:
# scoreboard: list[ScoreboardEntry] = [
# e for e in server.game_state.scoreboard.values() if e.time
# ]
scoreboard: list[ScoreboardEntry] = [
e for e in await server.game_state.get_remote_scoreboard() if e.time
]
scoreboard.sort(key=lambda e: e.time if e.time else timedelta.max)
return "\n".join(
[
f"#{i} {user} {time} "
for i, (time, user) in enumerate(
(
e.time,
e.username,
)
for e in scoreboard
)
if user
]
)
case _:
return self._text
@text.setter
def text(self, text: str) -> None:
self._text = text
@property
def interaction_type(self) -> InteractType:
match self.custom_interaction:
case CustomInteraction.SHOP:
return InteractType.INTERACT_TYPE_SHOP
case CustomInteraction.RUNNER:
return InteractType.INTERACT_TYPE_RUNNER
case CustomInteraction.LICENSE:
return InteractType.INTERACT_TYPE_LICENSE
case _:
return InteractType.INTERACT_TYPE_TEXT
@property
def shop(self) -> list[ShopInteract]:
shop: list[ShopInteract] = []
match self.custom_interaction:
case CustomInteraction.SHOP:
pass
case _:
return shop
shop.append(
ShopInteract(
item=copy(ITEMS["flag_merchant"]),
cost=1000000,
type=ShopInteractType.SHOP_INTERACT_TYPE_SELL,
)
)
for _ in range(random.randrange(1, 11)):
match random.randrange(3):
case 0:
shop.append(
ShopInteract(
item=get_random_shop_item(),
type=ShopInteractType.SHOP_INTERACT_TYPE_BUY,
cost=random.randrange(750, 1000),
)
)
case 1:
shop.append(
ShopInteract(
item=get_random_shop_item(),
type=ShopInteractType.SHOP_INTERACT_TYPE_SELL,
cost=random.randrange(750, 1000),
)
)
case 2:
item = get_random_shop_item()
shop.append(
ShopInteract(
item=item,
type=ShopInteractType.SHOP_INTERACT_TYPE_TRADE,
trade_in=get_random_shop_item(item),
)
)
case _:
pass
return shop
def reset(self) -> None:
self.current_path_step = 0
def move(self, dt: float, x: float, y: float) -> Tuple[float, float]:
if self.path:
x, y = self.path.get_next_position(dt, x, y)
return (x, y)
@dataclass(kw_only=True)
class NPC(Object):
interactable: bool
interact_distance: float
interaction_step: int
interactions: List[Interaction]
entity_asset: EntityAsset
user_uuid: str | None
def __init__(
self,
interactable: bool,
interact_distance: float,
interactions: List[Interaction],
entity_assets: EntityAssets,
user_uuid: str | None = None,
interaction_step: int = 0,
*args: Any,
**kwargs: Any,
) -> None:
self.interactable = interactable
self.interact_distance = interact_distance
self.interactions = interactions
self.user_uuid = user_uuid
self.interaction_step = interaction_step
self.entity_assets = entity_assets
self.runner_seed = None
super().__init__(*args, **kwargs)
self.type = ObjectType.OBJECT_TYPE_NPC
async def update(self, dt: float) -> None:
await super().update(dt=dt)
current_interaction = (
self.interactions[self.interaction_step]
if self.interaction_step < len(self.interactions)
else None
)
if current_interaction is not None:
next_x, next_y = current_interaction.move(dt, self.x, self.y)
moved = True if self.x != next_x or self.y != next_y else False
self.x = next_x
self.y = next_y
if self.user_uuid is not None:
await server.global_server.move_object(
self.uuid, self.x, self.y, include_user_ids=[self.user_uuid]
)
elif moved:
await server.global_server.move_object(self.uuid, self.x, self.y)
def _step_interact(self) -> None:
current_interaction = self.interactions[self.interaction_step]
if current_interaction.next_interaction == -1:
next_interaction_id = (self.interaction_step + 1) % len(self.interactions)
else:
next_interaction_id = current_interaction.next_interaction
self.interaction_step = next_interaction_id
interaction = self.interactions[next_interaction_id]
interaction.reset()
# This is actually in the native build module. Just a placeholder here
def check_license(
self, _num
):
return 1
async def interact(self, user_id: str, interact: Interact) -> Interaction:
current_interaction = self.interactions[self.interaction_step]
should_skip = False
match current_interaction.interaction_type:
case InteractType.INTERACT_TYPE_LICENSE:
try:
val = int(interact.text, 16) & 0xFFFFFFFFFFFFFFFF
ret = cast(int, check_license(val))
match ret:
case 1:
should_skip = True
self.interaction_step += 2
self.interaction = self.interactions[self.interaction_step]
self.interaction.reset()
self.interaction.text = (
await self.interaction.text
).replace(r"%item", r"LOCALO")
success = await server.game_state.give_item(
user_id, ITEMS["localo"], True
)
if success:
await server.global_server.update_self(user_id)
case 2:
should_skip = True
self.interaction_step += 2
self.interaction = self.interactions[self.interaction_step]
self.interaction.reset()
self.interaction.text = (
await self.interaction.text
).replace(r"%item", r"FLAG")
success = await server.game_state.give_item(
user_id, ITEMS["flag_license"], True
)
if success:
await server.global_server.update_self(user_id)
case _:
pass
except:
pass
pass
case InteractType.INTERACT_TYPE_SHOP:
if len(interact.shop) > 0:
flag = ITEMS["flag_merchant"]
i = interact.shop[0]
for item in shop_items:
if item["name"] == i.item.name:
i.item.description = item["description"]
break
if i.item.name == flag.name:
i.item.description = flag.description
if i.trade_in:
for item in shop_items:
if item["name"] == i.trade_in.name:
i.trade_in.description = item["description"]
break
if i.trade_in.name == flag.name:
i.trade_in.description = flag.description
success = server.game_state.shop(user_id, i)
if success:
await server.global_server.update_self(user_id)
case _:
pass
if not should_skip:
self._step_interact()
interaction = self.interactions[self.interaction_step]
match interaction.custom_interaction:
case CustomInteraction.REQUIRE_ITEMS:
reqs = eval(interaction.custom_attribute)
user = server.game_state.get_user(user_id)
assert user
for i, q in reqs.items():
item = next((x for x in user.inventory if x.name == i), None)
if item is None:
break
if item.quantity < q:
break
else:
for i, q in reqs.items():
item = next((x for x in user.inventory if x.name == i))
item.quantity -= q
if item.quantity == 0:
user.inventory.remove(item)
await server.global_server.update_self(user_id)
self.interaction_step += 2
self.interaction = self.interactions[self.interaction_step]
self.interaction.reset()
case CustomInteraction.RUNNER:
if (
interact.status == InteractStatus.INTERACT_STATUS_STOP
and self.runner_seed is not None
):
runner = interact.runner
sim = Engine()
sim.seed = self.runner_seed
result, _time, score = sim.run(runner)
if result and score > 1337:
success = await server.game_state.give_item(
user_id, ITEMS["flag_runner"], True
)
if success:
await server.global_server.update_self(user_id)
self.runner_seed = None
if interact.status == InteractStatus.INTERACT_STATUS_UPDATE:
if self.runner_seed == None:
self.runner_seed = random.random() * 31337
case CustomInteraction.RACE_START:
server.game_state.start_timer(user_id=user_id)
self._step_interact()
case CustomInteraction.RACE_STOP:
entry = await server.game_state.stop_timer(user_id=user_id)
race_to_reach = timedelta(minutes=1, seconds=20, milliseconds=750)
if entry is None:
self._step_interact()
elif entry.time < race_to_reach:
interaction._text = f"Your found me, in {entry.time}. Good job, I gave you a flag to keep."
success = await server.game_state.give_item(
user_id, ITEMS["flag_race_to_top"], True
)
if success:
await server.global_server.update_self(user_id)
else:
interaction._text = f"You found me, but it took {entry.time}, try again and get faster than {race_to_reach}."
case CustomInteraction.GIVE_ITEM:
if interaction.custom_attribute not in ITEMS:
logging.warn(f"Unknown ITEM {interaction.custom_attribute}")
else:
success = await server.game_state.give_item(
user_id, ITEMS[interaction.custom_attribute], True
)
if success:
await server.global_server.update_self(user_id)
case _:
pass
interaction = self.interactions[self.interaction_step]
return interaction
def to_proto(self) -> ObjectProto:
return super().to_proto()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/dino_runner.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/dino_runner.py | import random
from collections import defaultdict
from shared.constants import TARGET_UPS
from shared.gen.messages.v1 import Runner, RunnerAction
class Obstacle:
x: float = 0
width: float
height: float
class SmallObstacle(Obstacle):
width = 17
height = 35
class BigObstacle(Obstacle):
width = 25
height = 50 - 2
class LongObstacle(Obstacle):
width = 75
height = 50 - 2
class Engine:
time: float
acc: float
speed: float
game_width: float
obstacles: list[Obstacle]
dino_y: float = 0
dino_width: float = 44
dino_v: float = 0
stop: bool
seed: float = 0
rng: random.Random
def update(self, dt: float):
self.offset -= self.speed * dt
self.speed += self.acc * dt
self.dino_v -= self.g * dt
self.dino_y += self.dino_v * dt
if self.dino_y < 0:
self.dino_y = 0
self.dino_v = 0
for obstacle in self.obstacles:
obstacle.x -= dt * self.speed
if (
obstacle.x + obstacle.width >= 0
and obstacle.x + obstacle.width < self.dino_width
):
if self.dino_y < obstacle.height:
self.stop = True
obstacles = sorted(self.obstacles, key=lambda x: x.x)
last = obstacles[-1]
if last.x + last.width < self.game_width:
if self.rng.random() < 0.04:
free = [x for x in obstacles if x.x + x.width <= 0]
if len(free) > 0:
obs = self.rng.choice(free)
obs.x = self.game_width
def run(self, runner: Runner):
self.rng = random.Random(self.seed)
self.time = 0
self.acc = 20
self.speed = 400
self.game_width = 1200
self.jump_duration = 0.5
self.jump_height = 100
self.offset = 0
self.g = self.jump_height / (2 * pow(self.jump_duration / 4, 2))
self.v0 = pow(2 * self.jump_height * self.g, 1 / 2)
self.obstacles = [
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
BigObstacle(),
BigObstacle(),
LongObstacle(),
]
for obs in self.obstacles:
obs.x = -obs.width
self.stop = False
events: dict[float, list[RunnerAction]] = defaultdict(lambda: [])
for event in runner.events:
events[event.time].append(event.action)
for dt in runner.dts:
# TODO check that client doesn't cheat by sending weird dts
if dt > 1 / (10) or dt < 1 / (TARGET_UPS * 1.2):
return False, self.time, int(-self.offset // 100)
self.time += dt
self.update(dt)
if self.stop:
if RunnerAction.RUNNER_ACTION_DIE in events[self.time]:
break
return False, self.time, int(-self.offset // 100)
for action in events[self.time]:
if action == RunnerAction.RUNNER_ACTION_JUMP:
if self.dino_y == 0:
self.dino_v = self.v0
return True, self.time, int(-self.offset // 100)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/area.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/area.py | import math
import operator
import random
import uuid
from dataclasses import dataclass
from functools import reduce
from typing import Any
import server
from server.game.entity.object import Object as EntityObject
from server.game.entity.pickupable import Pickupable
from server.game.map.properties import CustomInteraction, Interaction, InteractionOn
from shared.gen.messages.v1 import Interact, InteractStatus, InteractType, Item
from shared.gen.messages.v1 import Object as ObjectProto
from shared.gen.messages.v1 import Objects, ObjectType, Polygon, ServerMessage
ORES = [
(
Item(
name="Common ore",
description="",
quantity=1,
icon=2440,
),
3,
),
(
Item(
name="Medium rare ore",
description="",
quantity=1,
icon=2441,
),
181,
),
(
Item(
name="Rare ore",
description="",
quantity=1,
icon=2442,
),
691,
),
(
Item(
name="Epic ore",
description="",
quantity=1,
icon=2443,
),
4943,
),
(
Item(
name="Legendary ore",
description="",
quantity=1,
icon=2444,
),
31337,
),
]
class Rng:
state: int
def __init__(self, seed: int) -> None:
self.state = seed
self.p = [x[1] for x in ORES]
self.m = reduce(operator.mul, self.p)
def next(self, offset: int) -> Item | None:
offset %= self.m
if offset == 0:
return None
r = math.gcd(self.m, offset)
self.state += 1
print("on offset", offset, r, self.state)
if r == 1 or r not in self.p:
return None
# TODO with which propability? should we get the ore at the coord?
# if ((self.state * offset)) % self.m == 0:
return ORES[self.p.index(r)][0]
# return -1
@dataclass(kw_only=True)
class AreaObject(EntityObject):
area: Polygon
user_uuid: str | None
def __init__(
self,
interaction: Interaction,
area: Polygon,
interaction_on: InteractionOn,
*args: Any,
**kwargs: Any,
):
super().__init__(*args, **kwargs)
self.area = area
self.user_uuid = None
self.interaction = interaction
self.interaction_on = interaction_on
self.type = ObjectType.OBJECT_TYPE_AREA
self.dig = None
self.actice = False
def to_proto(self) -> ObjectProto:
o = super().to_proto()
o.area = self.area
return o
async def interact(self, user_id: str, interact: Interact) -> Interact | None:
return None
def in_range(self, user_id: str) -> Interact | None:
self.actice = True
return Interact(
str(uuid.uuid4()),
status=InteractStatus.INTERACT_STATUS_START,
type=InteractType.INTERACT_TYPE_CUT_OUT,
)
def out_of_range(self, user_id: str) -> Interact | None:
self.actice = False
return Interact(
str(uuid.uuid4()),
status=InteractStatus.INTERACT_STATUS_STOP,
type=InteractType.INTERACT_TYPE_CUT_OUT,
)
class DigProgress:
def __init__(self, x: float, y: float) -> None:
self.x = x
self.y = y
self.progress = 0.0
pass
class DigArea(AreaObject):
def __init__(
self,
interaction: Interaction,
area: Polygon,
interaction_on: InteractionOn,
*args: Any,
**kwargs: Any,
):
super().__init__(interaction, area, interaction_on, *args, **kwargs)
self.dig = None
self.rng = Rng(random.randint(1, 31337))
async def interact(self, user_id: str, interact: Interact) -> Interact | None:
assert self.interaction.custom_interaction == CustomInteraction.DIG
user = server.game_state.get_user(user_id)
assert user
if next((x for x in user.inventory if x.name == "Shovel"), None) is None:
return None
match interact.status:
case InteractStatus.INTERACT_STATUS_START:
self.dig = DigProgress(user.coords.x, user.coords.y)
return Interact(
interact.uuid,
"",
status=InteractStatus.INTERACT_STATUS_START,
progress=self.dig.progress,
type=InteractType.INTERACT_TYPE_DIG,
)
case InteractStatus.INTERACT_STATUS_UPDATE:
assert self.dig
if self.dig.x != user.coords.x or self.dig.y != user.coords.y:
return None
self.dig.progress += 1 / 10
if self.dig.progress >= 0.999:
val = self.rng.next(int(self.dig.x + self.dig.y * 1337))
if val is not None:
ore = Pickupable(
x=self.dig.x,
y=self.dig.y + 20,
item=val,
name="ore",
direction=0,
for_everyone=False,
garbage_collect_on_pickup=True,
)
server.game_state.pickupable_manager.deepcopy_add(user_id, ore)
session = server.game_state.get_session(user_id)
assert session
server.game_state.user_sessions[user.uuid].known_objects |= set(
[ore.uuid]
)
response = ServerMessage(
objects=Objects(objects=[ore.to_proto()]),
)
await server.global_server.broadcast(
response, include=[session]
)
return Interact(
interact.uuid,
text=f"You found {val}",
status=InteractStatus.INTERACT_STATUS_STOP,
progress=self.dig.progress,
type=InteractType.INTERACT_TYPE_DIG,
)
return Interact(
uuid=interact.uuid,
text="",
status=InteractStatus.INTERACT_STATUS_UPDATE,
progress=self.dig.progress,
type=InteractType.INTERACT_TYPE_DIG,
)
case _:
pass
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/object.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/object.py | from dataclasses import dataclass
from uuid import uuid4
from shared.gen.messages.v1 import Coords
from shared.gen.messages.v1 import Object as ObjectProto
from shared.gen.messages.v1 import ObjectType
@dataclass(kw_only=True)
class Object:
name: str
type: ObjectType
def __init__(
self,
x: float,
y: float,
direction: float,
name: str,
uuid: str | None = None,
type: ObjectType = ObjectType.OBJECT_TYPE_UNSPECIFIED,
) -> None:
coords = Coords(x=x, y=y, rotation=direction)
self.name = name
if uuid is None:
uuid = str(uuid4())
self.uuid = uuid
self.coords = coords
self.type = type
async def update(self, dt: float) -> None:
pass
@property
def x(self) -> float:
return self.coords.x
@x.setter
def x(self, x: float) -> None:
self.coords.x = x
@property
def y(self) -> float:
return self.coords.y
@y.setter
def y(self, y: float) -> None:
self.coords.y = y
@property
def direction(self) -> float:
return self.coords.rotation
@direction.setter
def direction(self, direction: float) -> None:
self.coords.rotation = direction
def to_proto(self) -> ObjectProto:
return ObjectProto(
uuid=self.uuid,
coords=self.coords,
type=self.type,
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/enemy.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/enemy.py | import math
import sys
import time
from dataclasses import dataclass
from typing import Any, cast
import server
from server.game.entity.npc import NPCPath
from server.game.entity.object import Object
from server.game.entity.statemachine import STATE_CONTINUE, BaseState, StateMachine
from server.game.secret import ITEMS
from shared.gen.messages.v1 import EnemyInfo, EntityAssets
from shared.gen.messages.v1 import Object as ObjectProto
from shared.gen.messages.v1 import ObjectType, Polygon, SessionType, User
STATE_ALIVE = 0
STATE_DEAD = 1
@dataclass(kw_only=True)
class Enemy(Object):
health: int
speed: float
last_attack: float
# UUID of the user this enemy object belongs to
user_uuid: str | None
state_machine: StateMachine
def __init__(
self,
entity_assets: EntityAssets,
health: int = 10,
health_max: int = 100,
user_uuid: str | None = None,
*args: Any,
**kwargs: Any,
) -> None:
self.health = health
self.health_max = health_max
self.user_uuid = user_uuid
self.entity_assets = entity_assets
super().__init__(*args, **kwargs)
self.type = ObjectType.OBJECT_TYPE_ENEMY
self.state_machine = StateMachine()
self.last_attack = 0
async def update(self, dt: float) -> None:
await super().update(dt=dt)
await self.state_machine.update(dt)
# TODO: update if dead?
# TODO: Pathing, state machine for attacking
if self.user_uuid is not None:
await server.global_server.move_enemy_object(
uuid=self.uuid,
health=self.health,
health_max=self.health_max,
last_attack=self.last_attack,
name=self.name,
x=self.x,
y=self.y,
include_user_ids=[self.user_uuid],
)
async def take_damage(self, damage: int) -> None:
self.health -= damage
def is_alive(self):
return self.health > 0
def get_distance_to_player(self, user: User) -> float:
if (
user.uuid not in server.game_state.user_sessions
or server.game_state.user_sessions[user.uuid].type
== SessionType.SESSION_TYPE_FREE_CAM
):
return sys.float_info.max
player_asset = server.game_state.map.player_asset
dx = (user.coords.x + player_asset.width / 2) - (
(self.x + self.entity_assets.width / 2)
)
dy = (user.coords.y - player_asset.height / 2) - (
(self.y - self.entity_assets.height / 2)
)
dist_sqrt = math.sqrt(dx**2 + dy**2)
return dist_sqrt
def to_proto(self) -> ObjectProto:
o = super().to_proto()
o.enemy_info = EnemyInfo(
health=self.health,
health_max=self.health_max,
last_attack=self.last_attack,
name=self.name,
)
return o
class PatrolState(BaseState):
AGGRO_RADIUS = 80
def __init__(self, param: object):
super().__init__(name="patrol", param=param)
async def update(self, dt: float) -> str:
self_obj = cast(PatrolEnemy, self.parameter)
x, y = self_obj.patrol_path.get_next_position(dt, self_obj.x, self_obj.y)
self_obj.x = x
self_obj.y = y
if (
not self_obj.user_uuid is None
and self_obj.user_uuid in server.game_state.users
):
clostest_player = server.game_state.users[self_obj.user_uuid]
dist = self_obj.get_distance_to_player(clostest_player)
if dist < PatrolState.AGGRO_RADIUS:
return "aggro"
return STATE_CONTINUE
class AggroState(BaseState):
DEAGGRO_RADIUS = 80
def __init__(self, param: object):
super().__init__(name="aggro", param=param)
async def update(self, dt: float) -> str:
self_obj = cast(PatrolEnemy, self.parameter)
assert self_obj.user_uuid
if self_obj.user_uuid not in server.game_state.users:
return STATE_CONTINUE
clostest_player = server.game_state.users[self_obj.user_uuid]
dist = self_obj.get_distance_to_player(clostest_player)
if dist > AggroState.DEAGGRO_RADIUS:
return "patrol"
if dist < AttackingState.ATTACK_RADIUS:
return "attacking"
direction_x = clostest_player.coords.x - self_obj.x
direction_y = clostest_player.coords.y - self_obj.y
direction_len = math.sqrt(direction_x**2 + direction_y**2)
direction_x_norm = direction_x / direction_len
direction_y_norm = direction_y / direction_len
self_obj.x += direction_x_norm * self_obj.speed * dt
self_obj.y += direction_y_norm * self_obj.speed * dt
return STATE_CONTINUE
class AttackingState(BaseState):
ATTACK_RADIUS = 20
ATTACK_SPEED = 3
def __init__(self, param: object):
super().__init__(name="attacking", param=param)
self.last_attack = 0
async def update(self, dt: float) -> str:
self_obj = cast(PatrolEnemy, self.parameter)
assert self_obj.user_uuid is not None
if self_obj.user_uuid not in server.game_state.users:
return STATE_CONTINUE
clostest_player = server.game_state.users[self_obj.user_uuid]
dist = self_obj.get_distance_to_player(clostest_player)
if dist > AttackingState.ATTACK_RADIUS:
return "aggro"
if time.time() > self.last_attack + AttackingState.ATTACK_SPEED:
await server.global_server.give_damage(
self_obj.uuid, 7, include_user_ids=[self_obj.user_uuid]
)
self.last_attack = time.time()
self_obj.last_attack = time.time()
if not self_obj.is_alive():
return "dead"
return STATE_CONTINUE
class DeadState(BaseState):
DEAD_SECONDS = 20 # Enemy should stay 60 seconds dead
def __init__(self, param: object):
super().__init__(name="dead", param=param)
def enter(self):
self.death_ts = time.time()
async def update(self, dt: float) -> str:
self_obj = cast(PatrolEnemy, self.parameter)
assert self_obj.user_uuid is not None
if time.time() > self.death_ts + DeadState.DEAD_SECONDS:
self_obj.health = self_obj.health_max
return "patrol"
return STATE_CONTINUE
class PatrolEnemy(Enemy):
patrol_path: NPCPath
speed: float
def __init__(
self, path: Polygon | None, speed: float, *args: Any, **kwargs: Any
) -> None:
super().__init__(*args, **kwargs)
self.speed = speed
self.patrol_path = NPCPath(path=path, speed=speed, loop=True)
self.state_machine.add_state(PatrolState(self))
self.state_machine.add_state(AggroState(self))
self.state_machine.add_state(AttackingState(self))
self.state_machine.add_state(DeadState(self))
self.state_machine.change_state("patrol")
class BossPatrolEnemy(PatrolEnemy):
def __init__(self, *args: Any, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
async def take_damage(self, damage: int) -> None:
self.health -= damage
if self.user_uuid is None:
return
if self.health <= 0:
success = await server.game_state.give_item(
user_id=self.user_uuid,
item=ITEMS["flag_boss"],
once=True,
)
if success:
await server.global_server.update_self(self.user_uuid)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/pickupable.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/entity/pickupable.py | from dataclasses import dataclass
from typing import Any
import server
from server.game.entity.object import Object
from shared.gen.messages.v1 import Item
from shared.gen.messages.v1 import Object as ObjectProto
from shared.gen.messages.v1 import Object as ProtoObject
from shared.gen.messages.v1 import Objects, ObjectType, ServerMessage, SessionType, User
@dataclass(kw_only=True)
class Pickupable(Object):
user_uuid: str | None
def __init__(
self,
item: Item,
for_everyone: bool,
garbage_collect_on_pickup: bool,
*args: Any,
**kwargs: Any
) -> None:
super().__init__(*args, **kwargs)
self.pickupable = item
self.type = ObjectType.OBJECT_TYPE_PICKUPABLE
self.user_uuid = None
self.pickedup = False
self.for_everyone = for_everyone
self.garbage_collect_on_pickup = garbage_collect_on_pickup
def in_distance_to_player(self, user: User) -> bool:
player_asset = server.game_state.map.player_asset
dx = (user.coords.x + player_asset.width / 2) - ((self.x + 16 / 2))
dy = (user.coords.y - player_asset.height / 2) - ((self.y - 16 / 2))
distance_sq = dx**2 + dy**2
return distance_sq < 14**2
async def update(self, dt: float) -> None:
if not self.pickedup:
if self.user_uuid and self.user_uuid in server.game_state.users:
user = server.game_state.users[self.user_uuid]
if user.uuid not in server.game_state.user_sessions:
return
session = server.game_state.user_sessions[user.uuid]
if session.type == SessionType.SESSION_TYPE_FREE_CAM:
return
if self.in_distance_to_player(user):
self.pickedup = True
await server.game_state.give_item(self.user_uuid, self.pickupable)
await server.global_server.broadcast(
ServerMessage(
objects=Objects(
objects=[
ProtoObject(
self.uuid,
remove=True,
type=ObjectType.OBJECT_TYPE_PICKUPABLE,
)
]
)
),
include=[session.peer],
)
elif self.for_everyone:
for user_id in server.game_state.user_sessions.keys():
if user_id not in server.game_state.users:
continue
user = server.game_state.users[user_id]
session = server.game_state.user_sessions[user.uuid]
if session.type == SessionType.SESSION_TYPE_FREE_CAM:
continue
if self.in_distance_to_player(user):
self.pickedup = True
await server.game_state.give_item(user_id, self.pickupable)
await server.global_server.broadcast(
ServerMessage(
objects=Objects(
objects=[
ProtoObject(
self.uuid,
remove=True,
type=ObjectType.OBJECT_TYPE_PICKUPABLE,
)
]
)
),
include=[session.peer],
)
break
return await super().update(dt)
def to_proto(self) -> ObjectProto:
proto = super().to_proto()
proto.pickupable = self.pickupable
return proto
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/map/properties.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/map/properties.py | from dataclasses import dataclass, field
from enum import Enum
from typing import Any, NewType
from dataclasses_jsonschema import JsonSchemaMixin
from dataclasses_jsonschema.field_types import FieldEncoder
ObjectType = NewType("ObjectType", int)
class ObjectTypeField(FieldEncoder[int, int]):
@property
def json_schema(self) -> dict[str, str]:
return {"type_": "object"}
JsonSchemaMixin.register_field_encoders({ObjectType: ObjectTypeField()})
class Activity(Enum):
IDLE = "IDLE"
WALKING = "WALKING"
ATTACKING = "ATTACKING"
DEATH = "DEATH"
class Direction(Enum):
NORTH = "NORTH"
EAST = "EAST"
SOUTH = "SOUTH"
WEST = "WEST"
@dataclass
class Tile(JsonSchemaMixin):
activity: Activity = Activity.IDLE
direction: Direction = Direction.NORTH
@dataclass
class NPC(JsonSchemaMixin):
interact_distance: int = 0
interactable: bool = False
@dataclass
class Enemy(JsonSchemaMixin):
speed: float = 0.0
health: int = 100
max_health: int = 100
@dataclass
class PatrolEnemy(Enemy, JsonSchemaMixin):
patrol_path: ObjectType = ObjectType(-1)
class CustomInteraction(Enum):
NONE = "NONE"
TALKY = "TALKY"
SHOP = "SHOP"
RACE_START = "RACE_START"
SCOREBOARD = "SCOREBOARD"
RACE_STOP = "RACE_STOP"
GIVE_ITEM = "GIVE_ITEM"
DIG = "DIG"
REQUIRE_ITEMS = "REQUIRE_ITEMS"
RUNNER = "RUNNER"
CUT_OUT = "CUT_OUT"
LICENSE = "LICENSE"
@dataclass
class Interaction(JsonSchemaMixin):
custom_attribute: str = ""
custom_interaction: CustomInteraction = CustomInteraction.NONE
loop: bool = False
next_interaction: int = -1
path: ObjectType = ObjectType(-1)
speed: float = 0.0
text: str = ""
class InteractionOn(Enum):
NONE = "NONE"
INTERACT = "INTERACT"
COLLIDE = "COLLIDE"
@dataclass
class AreaObject(JsonSchemaMixin):
area: ObjectType = ObjectType(-1)
interaction_on: InteractionOn = InteractionOn.NONE
interaction: Interaction = field(default_factory=lambda: Interaction())
@dataclass
class Pickupable(JsonSchemaMixin):
description: str = ""
quantity: int = 1
icon: int = -1
class CustomLayerType(Enum):
NONE = "NONE"
DYNAMIC = "DYNAMIC"
@dataclass
class Layer(JsonSchemaMixin):
type: CustomLayerType = CustomLayerType.NONE
class MazeTileType(Enum):
NONE = "NONE"
START_END = "START_END"
CORNER_NE = "CORNER_NE"
CORNER_SE = "CORNER_SE"
CORNER_SW = "CORNER_SW"
CORNER_NW = "CORNER_NW"
MISSING = "MISSING"
@dataclass
class Maze(JsonSchemaMixin):
type: MazeTileType = MazeTileType.NONE
def parse_additional_activities(properties: dict[str, Any]) -> list[Activity]:
activities: list[Activity] = []
i = 0
while True:
key = f"additional_activity_{i}"
i += 1
if key not in properties:
break
activities.append(Activity(properties[key]))
return activities
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/map/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/map/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/map/map.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/game/map/map.py | from __future__ import annotations
import logging
from functools import cache
from pathlib import Path
from typing import Any, Dict, List, Tuple, cast
import numpy as np
import pytiled_parser
from mazelib import Maze
from mazelib.generate.DungeonRooms import DungeonRooms
from PIL import Image
from pytiled_parser import ObjectLayer, TileLayer, tiled_object
from pytiled_parser.common_types import OrderedPair
import server
from server.game.entity.area import AreaObject, DigArea
from server.game.entity.enemy import BossPatrolEnemy, Enemy, PatrolEnemy
from server.game.entity.npc import NPC, Interaction
from server.game.entity.object import Object
from server.game.entity.pickupable import Pickupable
from server.game.map.properties import NPC as PropertyNpc
from server.game.map.properties import AreaObject as PropertyAreaObject
from server.game.map.properties import CustomInteraction, CustomLayerType
from server.game.map.properties import Enemy as PropertyEnemy
from server.game.map.properties import Interaction as PropertyInteraction
from server.game.map.properties import Layer as PropertyLayer
from server.game.map.properties import Maze as PropertyMaze
from server.game.map.properties import MazeTileType
from server.game.map.properties import PatrolEnemy as PropertyPatrolEnemy
from server.game.map.properties import Pickupable as PropertyPickupable
from server.game.map.properties import Tile as PropertyTile
from server.game.map.properties import parse_additional_activities
from server.models import Session
from shared.constants import (
CHUNK_SIZE_X,
CHUNK_SIZE_Y,
NUM_TILES_PER_COLUM,
TILE_SIZE_X,
TILE_SIZE_Y,
)
from shared.gen.messages.v1 import (
Activity,
Animation,
AnimationStep,
Direction,
EntityAsset,
EntityAssets,
Item,
MapChunk,
MapChunkResponse,
Point,
Polygon,
ServerMessage,
TileCollision,
Tileset,
)
from shared.map import Map as SharedMap
from shared.map import Tile
class Map(SharedMap):
player_asset: EntityAssets
objects: Dict[str, Object]
def __init__(self, map_file: Path) -> None:
self.map = pytiled_parser.parse_map(map_file)
assert self.map.infinite, "Map in not inifite. Wrong map loaded?"
def initialize(self):
logging.debug(
f"[Map] Loading map with size: {self.map.map_size} Tile size: {self.map.tile_size}"
)
self._parse_player()
objs = self._parse_objects()
self._preload_chunks()
for tileset in self.map.tilesets.values():
if tileset.name == "LLB-LandTileset":
self.llb_tileset = tileset
if tileset.name == "Colors":
self.colors = tileset
if tileset.name == "Maze":
self.maze_tileset = tileset
# assert self.llb_tileset, 'No tileset "CB-LandTileset" found.'
# assert self.colors, 'No tileset "Colors" found.'
# assert self.maze_tileset, 'No tileset "Maze" found.'
return objs
def _preload_chunks(self) -> None:
for x, y in set(
(
[
(c.coordinates.x // CHUNK_SIZE_X, c.coordinates.y // CHUNK_SIZE_Y)
for l in self.map.layers
if isinstance(l, TileLayer) and l.chunks
for c in l.chunks
]
)
):
self.get_chunks(x, y, "")
def _parse_player(self) -> None:
for tileset in self.map.tilesets.values():
if tileset.name != "player":
continue
if tileset.tiles is None:
continue
tile_ids = [k + tileset.firstgid for k in tileset.tiles.keys()]
self.player_asset = self.get_entity_assets(tileset, tile_ids=tile_ids)
def _parse_polygon_by_id(
self, layer: ObjectLayer, polygon_id: int
) -> Polygon | None:
polygon = next(
(o for o in layer.tiled_objects if o.id == polygon_id),
None,
)
if polygon is None:
return None
coll = self._parse_form(polygon)[0]
return Polygon(points=[Point(x=p[0], y=p[1]) for p in coll])
def _parse_objects(self) -> Dict[str, Object]:
objs: Dict[str, Object] = {}
for layer in self.map.layers:
if not isinstance(layer, ObjectLayer):
continue
if layer.draw_order != "topdown":
continue
entity_assets = None
for t in layer.tiled_objects:
match t:
case tiled_object.Tile():
tileset_id = self._find_tileset_id(t.gid)
if tileset_id is None:
continue
tileset = self.map.tilesets[tileset_id]
tile_ids = set([t.gid])
additional_activities = parse_additional_activities(
t.properties
)
if tileset.tiles:
root_tile = tileset.tiles.get(t.gid - tileset_id, None)
if (
root_tile
and root_tile.class_ == "Tile"
and root_tile.properties
):
root_tile_properties = PropertyTile().from_dict(
root_tile.properties
)
for tile in tileset.tiles.values():
if tile.id == t.gid:
continue
if tile.class_ != "Tile":
continue
properties = tile.properties
if properties:
properties = PropertyTile().from_dict(
properties
)
if (
properties.activity
== root_tile_properties.activity
or properties.activity
in additional_activities
):
tile_ids.add(tile.id + tileset_id)
entity_assets = self.get_entity_assets(tileset, list(tile_ids))
case tiled_object.Point():
pass
case _:
continue
properties = t.properties
coords = t.coordinates
match t.class_:
case "Npc":
assert entity_assets
interactions: List[Interaction] = []
i = 0
while True:
key = f"interaction_{i}"
i += 1
if key not in properties:
break
interaction_properties = PropertyInteraction().from_dict(
properties[key] # type: ignore
)
path = None
if interaction_properties.path != -1:
path_id = interaction_properties.path
path = self._parse_polygon_by_id(
layer=layer, polygon_id=path_id
)
interactions.append(
Interaction(
id=i,
text=interaction_properties.text,
path=path,
speed=interaction_properties.speed,
loop=interaction_properties.loop,
next_interaction=interaction_properties.next_interaction,
custom_interaction=interaction_properties.custom_interaction,
custom_attribute=interaction_properties.custom_attribute,
)
)
npc_properties = PropertyNpc().from_dict(properties)
o = NPC(
x=coords.x,
y=coords.y,
direction=0, # TODO: make direction right
entity_assets=entity_assets,
name=t.name,
interactable=npc_properties.interactable,
interact_distance=npc_properties.interact_distance,
interactions=interactions,
)
case "Enemy":
assert entity_assets
enemy_properties = PropertyEnemy().from_dict(properties)
o = Enemy(
x=coords.x,
y=coords.y,
direction=0, # TODO: make direction right
entity_assets=entity_assets,
name=t.name,
health=enemy_properties.health,
health_max=enemy_properties.max_health,
speed=enemy_properties.speed,
)
case "PatrolEnemy":
assert entity_assets
enemy_properties = PropertyPatrolEnemy().from_dict(properties)
path = None
if enemy_properties.patrol_path != -1:
path_id = enemy_properties.patrol_path
path = self._parse_polygon_by_id(
layer=layer, polygon_id=path_id
)
o = PatrolEnemy(
path=path,
speed=enemy_properties.speed,
x=coords.x,
y=coords.y,
direction=0, # TODO: make direction right
entity_assets=entity_assets,
name=t.name,
health=enemy_properties.health,
health_max=enemy_properties.max_health,
)
case "BossPatrolEnemy":
assert entity_assets
enemy_properties = PropertyPatrolEnemy().from_dict(properties)
path = None
if enemy_properties.patrol_path != -1:
path_id = enemy_properties.patrol_path
path = self._parse_polygon_by_id(
layer=layer, polygon_id=path_id
)
o = BossPatrolEnemy(
path=path,
speed=enemy_properties.speed,
x=coords.x,
y=coords.y,
direction=0, # TODO: make direction right
entity_assets=entity_assets,
name=t.name,
health=enemy_properties.health,
health_max=enemy_properties.max_health,
)
print("Added BossPatrolEnemy")
case "Areaobject":
area_properties = PropertyAreaObject().from_dict(properties)
path = None
if area_properties.area != -1:
area_id = area_properties.area
path = self._parse_polygon_by_id(
layer=layer, polygon_id=area_id
)
assert path
match area_properties.interaction.custom_interaction:
case CustomInteraction.DIG:
o = DigArea(
area=path,
interaction=area_properties.interaction,
interaction_on=area_properties.interaction_on,
name="area",
x=coords.x,
y=coords.y,
direction=0,
)
case _:
o = AreaObject(
area=path,
interaction=area_properties.interaction,
interaction_on=area_properties.interaction_on,
name="area",
x=coords.x,
y=coords.y,
direction=0,
)
case "Pickupable":
pickupable_properties = PropertyPickupable().from_dict(
properties
)
item = Item(
description=pickupable_properties.description,
icon=pickupable_properties.icon,
name=t.name,
quantity=pickupable_properties.quantity,
)
o = Pickupable(
x=coords.x,
y=coords.y,
item=item,
name=t.name,
direction=0,
for_everyone=False,
garbage_collect_on_pickup=False,
)
case _:
o = Object(
x=coords.x,
y=coords.y,
direction=0, # TODO: make direction right
name=t.name,
)
objs[o.uuid] = o
return objs
def get_entity_assets(
self, tileset: pytiled_parser.tileset.Tileset, tile_ids: List[int]
) -> EntityAssets:
entity_asset = EntityAssets(
height=tileset.tile_height,
width=tileset.tile_width,
)
logging.debug(
f"Getting tileset for ids: {str(tile_ids)} Tileset: {str(tileset)} Width: {tileset.tile_width} "
)
tileset_, new_tile_mapping, collisions = self.get_tileset(
tileset.tile_width, tileset.tile_height, tile_ids
)
entity_asset.tileset = tileset_
if tileset.tiles is None:
return entity_asset
for tile in tileset.tiles.values():
if tile.id + tileset.firstgid not in tile_ids:
continue
properties = tile.properties
if properties is None:
properties = {}
properties = PropertyTile.from_dict(properties)
entity_asset.entity_assets.append(
EntityAsset(
id=new_tile_mapping[tile.id + tileset.firstgid],
activity=Activity[f"ACTIVITY_{properties.activity.name}"],
direction=Direction[f"DIRECTION_{properties.direction.name}"],
)
)
for tile_col in collisions:
tile_collision = TileCollision(polygons=[])
for col in tile_col:
if col:
tile_collision.polygons.append(
Polygon(points=[Point(x=p[0], y=p[1]) for p in col])
)
entity_asset.collisions.append(tile_collision)
return entity_asset
@cache
def get_tileset_image(self, id: int) -> Image.Image:
tileset = self.map.tilesets[id]
tileset_png = Image.open(Path(server.PATH, f"./map/{tileset.image}")) # type: ignore
return tileset_png # type: ignore
def _create_tileset_image(
self, rows: int, cols: int, tile_width: int, tile_height: int
) -> Image.Image:
return Image.new("RGBA", (rows * tile_width, cols * tile_height))
def _find_tileset_id(self, tile_id: int) -> int | None:
gids = list(self.map.tilesets.keys())
gids.sort(reverse=True)
return next((gid for gid in gids if gid <= tile_id), None)
def _parse_form(
self, form: tiled_object.TiledObject
) -> List[List[Tuple[float, float]]]:
coll: List[List[Tuple[float, float]]] = []
match form:
case tiled_object.Polygon():
assert form.rotation == 0
origin = form.coordinates
points = [(p.x + origin.x, p.y + origin.y) for p in form.points]
coll.append(points)
case tiled_object.Rectangle():
assert form.rotation == 0
origin = form.coordinates
points = [
(p.x + origin.x, p.y + origin.y)
for p in [
OrderedPair(0, 0),
OrderedPair(0, form.size.height),
OrderedPair(
form.size.width,
form.size.height,
),
OrderedPair(form.size.width, 0),
]
]
coll.append(points)
case _:
logging.warning("Unknown object", form)
return coll
def get_tileset(
self, tile_width: int, tile_height: int, tile_ids: List[int]
) -> Tuple[Tileset, Dict[int, int], List[List[List[Tuple[float, float]]]]]:
old_id_mapping: Dict[int, int] = {}
result_tileset = Tileset()
result_image = self._create_tileset_image(
NUM_TILES_PER_COLUM, 1, tile_width, tile_height
)
tile_collisions: List[List[List[Tuple[float, float]]]] = []
for tile_id in tile_ids:
new_tile_index = len(old_id_mapping)
if new_tile_index != 0 and new_tile_index % NUM_TILES_PER_COLUM == 0:
tmp_image = result_image
result_image = self._create_tileset_image(
NUM_TILES_PER_COLUM,
(new_tile_index // NUM_TILES_PER_COLUM) + 1,
tile_width,
tile_height,
)
result_image.paste(tmp_image)
coll: List[List[Tuple[float, float]]] = []
tileset_id = self._find_tileset_id(tile_id=tile_id)
if tileset_id is not None:
tileset = self.map.tilesets[tileset_id]
tileset_image = self.get_tileset_image(tileset_id)
local_id = tile_id - tileset.firstgid
if tileset.tiles is not None and local_id in tileset.tiles:
tile = tileset.tiles[local_id]
if tile.animation is not None:
animation = Animation(id=tile_id)
for frame in tile.animation:
t_id = frame.tile_id + tileset.firstgid
animation.animation_setps.append(
AnimationStep(id=t_id, duration=frame.duration)
)
if t_id not in tile_ids:
tile_ids.append(t_id)
result_tileset.animations.append(animation)
match tile.objects:
case pytiled_parser.layer.ObjectLayer() as object_layer:
for collision_object in object_layer.tiled_objects:
coll += self._parse_form(collision_object)
case _:
pass
assert (
tileset.tile_width == tile_width
and tileset.tile_height == tile_height
), f"Tiles have to be the same size! {tileset.name} {tileset.tile_width} != {tile_width} or {tileset.tile_height} != {tile_height}"
x_start = (local_id % tileset.columns) * tileset.tile_width
y_start = (local_id // tileset.columns) * tileset.tile_height
x_end = x_start + tileset.tile_width
y_end = y_start + tileset.tile_height
new_tile_x = (new_tile_index % NUM_TILES_PER_COLUM) * tileset.tile_width
new_tile_y = (
new_tile_index // NUM_TILES_PER_COLUM
) * tileset.tile_height
# Crop tile from the global tileset to the local tileset
result_image.paste(
tileset_image.crop((x_start, y_start, x_end, y_end)),
(new_tile_x, new_tile_y),
)
tile_collisions.append(coll)
old_id_mapping[tile_id] = new_tile_index
for animation in result_tileset.animations:
animation.id = old_id_mapping[animation.id]
for step in animation.animation_setps:
step.id = old_id_mapping[step.id]
img_byte_arr = result_image.tobytes()
result_tileset.tileset = img_byte_arr
result_tileset.width = result_image.width
result_tileset.height = result_image.height
return result_tileset, old_id_mapping, tile_collisions
# Gets a new tileset for a given chunk
# Returns a tuple of:
# - the new tileset as raw image bytes
# - the tile mapping of old to new tile ids
def get_tileset_for_chunk(
self, chunk: pytiled_parser.layer.Chunk
) -> Tuple[Tileset, Dict[int, int], List[List[List[Tuple[float, float]]]]]:
gids = list(self.map.tilesets.keys())
gids.sort(reverse=True)
# Get number of unique tiles to estimate result tilset size
unique_tiles: List[int] = []
for row in chunk.data:
for col in row:
if not col in unique_tiles:
unique_tiles.append(col)
num_unique_tiles = len(unique_tiles)
logging.debug(f"Number of unique tiles in chunk: {num_unique_tiles}")
return self.get_tileset(TILE_SIZE_X, TILE_SIZE_Y, unique_tiles)
def get_tile_layers(
self, layers: List[pytiled_parser.Layer]
) -> List[pytiled_parser.TileLayer]:
layers_ret: List[pytiled_parser.TileLayer] = []
for layer in layers:
if isinstance(layer, pytiled_parser.TileLayer):
layers_ret.append(layer)
if isinstance(layer, pytiled_parser.LayerGroup):
if layer.layers:
layers_ret += self.get_tile_layers(layer.layers)
return layers_ret
def is_dynamic_chunk(self, x: float, y: float) -> bool:
for layer in self.get_tile_layers(self.map.layers):
if layer.properties:
properties = PropertyLayer().from_dict(layer.properties)
if properties.type != CustomLayerType.DYNAMIC:
continue
else:
continue
match layer.chunks:
case None:
continue
case chunks:
pass
# Find the chunk the client requested
chunk = next(
(
item
for item in chunks
if (
item.coordinates.x == x * CHUNK_SIZE_X
and item.coordinates.y == y * CHUNK_SIZE_Y
)
),
None,
)
if chunk:
return True
return False
def get_chunks(self, x: float, y: float, user_id: str) -> List[MapChunk]:
if self.is_dynamic_chunk(x=x, y=y):
return self.get_dynamic_chunk(
requested_chunk_block_x=x, requested_chunk_block_y=y, user_id=user_id
)
else:
return self.get_static_chunks(x=x, y=y)
def _get_neighbouring_chunks(
self,
start: pytiled_parser.Chunk,
chunks: List[pytiled_parser.Chunk],
visited: List[pytiled_parser.Chunk],
) -> None:
queue: List[pytiled_parser.Chunk] = [start]
while len(queue) > 0:
current = queue.pop()
visited.append(current)
for x, y in [
(0, 1),
(0, -1),
(-1, 0),
(1, 0),
]:
chunk = next(
(
item
for item in chunks
if (
item.coordinates.x
== current.coordinates.x + x * CHUNK_SIZE_X
and item.coordinates.y
== current.coordinates.y + y * CHUNK_SIZE_Y
and item not in visited
and item not in queue
)
),
None,
)
if chunk:
queue.append(chunk)
def get_dynamic_chunk(
self,
requested_chunk_block_x: float,
requested_chunk_block_y: float,
user_id: str,
) -> List[MapChunk]:
if user_id == "":
return []
session = server.game_state.user_sessions[user_id]
if len(session.maze) == 0:
for layer in self.get_tile_layers(self.map.layers):
if layer.properties:
properties = PropertyLayer().from_dict(layer.properties)
if properties.type != CustomLayerType.DYNAMIC:
continue
else:
continue
match layer.chunks:
case None:
continue
case chunks:
pass
# Find the chunk the client requested
chunk = next(
(
item
for item in chunks
if (
item.coordinates.x == requested_chunk_block_x * CHUNK_SIZE_X
and item.coordinates.y
== requested_chunk_block_y * CHUNK_SIZE_Y
)
),
None,
)
if not chunk:
continue
if len(session.waiting_maze_chunks) == 0:
maze_future = server.executor.submit(
self.generate_maze, chunk, chunks
)
maze_future.add_done_callback(
lambda res: self.generate_maze_result(session, res.result())
)
session.waiting_maze_chunks.append(
(int(chunk.coordinates.x), int(chunk.coordinates.y))
)
data = np.full(
shape=(32, 32), fill_value=self.maze_tileset.firstgid + 8
)
c = pytiled_parser.Chunk(
coordinates=pytiled_parser.OrderedPair(
x=int(chunk.coordinates.x),
y=int(chunk.coordinates.y),
),
size=pytiled_parser.Size(CHUNK_SIZE_X, CHUNK_SIZE_Y),
data=data.tolist(),
)
chunk = self._get_chunk(chunk=c)
return [chunk]
c = next(
(
c
for c in session.maze
if c[0].x == requested_chunk_block_x
and c[0].y == requested_chunk_block_y
),
None,
)
if c:
return c
else:
return []
def generate_maze_result(
self, session: Session, maze: list[list[MapChunk]]
) -> None:
session.maze = maze
for x, y in session.waiting_maze_chunks:
c = next(
(
c
for c in session.maze
if c[0].x == x // CHUNK_SIZE_X and c[0].y == y // CHUNK_SIZE_Y
),
None,
)
if c is None:
continue
server.global_server.broadcast_sync(
message=ServerMessage(chunk=MapChunkResponse(chunks=c)),
include=[session.peer],
)
session.waiting_maze_chunks.clear()
def generate_maze(
self, chunk: pytiled_parser.Chunk, chunks: List[pytiled_parser.Chunk]
) -> list[list[MapChunk]]:
all_chunks: List[List[MapChunk]] = []
chunk_block: list[pytiled_parser.Chunk] = []
self._get_neighbouring_chunks(chunk, chunks, chunk_block)
x_coordinates = [c.coordinates.x for c in chunk_block]
y_coordinates = [c.coordinates.y for c in chunk_block]
width = abs(max(x_coordinates) - min(x_coordinates)) + CHUNK_SIZE_X
height = abs(max(y_coordinates) - min(y_coordinates)) + CHUNK_SIZE_Y
chunk_block_x = min(x_coordinates)
chunk_block_y = min(y_coordinates)
assert (width // CHUNK_SIZE_X) * (height // CHUNK_SIZE_Y) == len(
chunk_block
), "Maze has to be in a rectangle!"
start_end: list[tuple[int, int]] = []
for c in chunk_block:
for y, row in enumerate(c.data):
for x, tile_id in enumerate(row):
tileset_id = self._find_tileset_id(tile_id)
if not tileset_id:
continue
tileset = self.map.tilesets[tileset_id]
if not tileset.tiles:
continue
tile = tileset.tiles[tile_id - tileset.firstgid]
if not tile.properties:
continue
properties = PropertyMaze().from_dict(tile.properties)
if properties.type == MazeTileType.START_END:
mx = (c.coordinates.x + x) - chunk_block_x + 1
my = (c.coordinates.y + y) - chunk_block_y
# account for odd size and room size
if mx == width:
mx -= 2
if my == height:
my -= 2
start_end.append(
(
int(mx // 3),
int(my // 3),
)
)
assert (
len(start_end) == 2
), f"There must be 2 Start/Ends but there are {len(start_end)}"
maze = Maze()
maze.generator = DungeonRooms( # type: ignore
(width // 3 - 1) // 2,
(height // 3 - 1) // 2,
[
[
a,
(
a[0] + 1,
a[1] + 1,
),
]
for a in start_end
],
)
maze.generate()
if maze.grid is None:
return all_chunks
grid: Any = maze.grid.astype("int32")
grid = np.repeat(a=grid, repeats=3, axis=0)
grid = np.repeat(a=grid, repeats=3, axis=1)
grid_shape = grid.shape
grid_shape = (
((grid_shape[0] // CHUNK_SIZE_X) + 1) * CHUNK_SIZE_X - grid_shape[0],
((grid_shape[1] // CHUNK_SIZE_Y) + 1) * CHUNK_SIZE_Y - grid_shape[1],
)
grid = np.pad(
array=grid,
pad_width=((0, grid_shape[0]), (0, grid_shape[1])),
constant_values=1,
)
grid = np.where(grid == 1, 0, 1)
maze.grid = grid
for s in start_end:
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | true |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/map/merge_dino_tileset.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/map/merge_dino_tileset.py | from PIL import Image
import sys
import glob
TILE_SIZE = 24
if len(sys.argv) < 2:
print("Usage: merge_dino_tileset.py <path_to_to_dino>")
print("Example: merge_dino_tileset.py assets/dinos/male/mono")
exit(-1)
base_path = sys.argv[1] + "/base/"
images = sorted(glob.glob(base_path + "*.*"))
print(f"Found Images: {len(images)}")
result_image = Image.new("RGBA", (20*TILE_SIZE, len(images)*TILE_SIZE))
# Process each tiled image
for index, img_path in enumerate(images):
img = Image.open(img_path)
num_tiles_in_image = int(img.width / TILE_SIZE)
for i in range(num_tiles_in_image):
tmp_img = img.crop((TILE_SIZE*i,0,TILE_SIZE*i+24,24))
transposed = tmp_img.transpose(Image.FLIP_LEFT_RIGHT)
result_image.paste(tmp_img, (TILE_SIZE*i, TILE_SIZE*index))
result_image.paste(transposed, (TILE_SIZE*i+num_tiles_in_image*TILE_SIZE, TILE_SIZE*index))
result_image.save(sys.argv[1] + "/combined_tileset.png") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/map/generate_properties.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/server/server/map/generate_properties.py | import hashlib
import json
from typing import Any
from dataclasses_jsonschema import JsonSchemaMixin
from server.game.map.properties import * # type: ignore
def get_class(name: str, properties: dict[str, Any]) -> dict[str, dict[str, Any]]:
m = hashlib.md5()
m.update(name.encode())
id = int(m.hexdigest(), 16)
member_types = {}
members = []
for n, p in properties["properties"].items():
propertyType = None
default = None
type = None
if "type" in p:
match p["type"]:
case "string":
type = "string"
case "integer":
type = "int"
case "boolean":
type = "bool"
case "number":
type = "float"
case _:
raise NotImplementedError(p["type"])
assert "default" in p, p
elif "$ref" in p:
ref = p["$ref"]
ref = ref.rsplit("/", 1)[1]
type = "class"
default = {}
propertyType = ref
elif "type_" in p:
match p["type_"]:
case "object":
type = "object"
case _:
raise NotImplementedError(p["type_"])
if "default" in p:
default = p["default"]
assert type is not None
assert default is not None
member: dict[str, Any] = {
"name": n,
"type": type,
"value": default,
}
if "enum" in p:
m = hashlib.md5()
m.update(n.encode())
member_types[n] = {
"id": int(m.hexdigest(), 16),
"name": n.title(),
"storageType": "string",
"type": "enum",
"values": p["enum"],
}
propertyType = n.title()
if propertyType:
member["propertyType"] = propertyType
members.append(member)
property_types = {
name: {
"id": id,
"name": name.title(),
"type": "class",
"useAs": [
"property",
"map",
"layer",
"object",
"tile",
"tileset",
"wangcolor",
"wangset",
],
"color": "#ffa0a0a4",
"drawFill": True,
"members": members,
}
}
property_types |= member_types
return property_types
def parse_properties(
name: str, properties: dict[str, Any]
) -> dict[str, dict[str, Any]]:
match properties["type"]:
case "object":
return get_class(name, properties)
case _:
raise NotImplementedError()
properties = JsonSchemaMixin.all_json_schemas()
property_types: dict[str, Any] = {}
for key, value in properties.items():
if "type" in value:
property_types |= parse_properties(key, value)
elif "allOf" in value:
value = value["allOf"]
ref = value[0]["$ref"]
ref = ref.rsplit("/", 1)[1]
assert ref in property_types
property_types |= parse_properties(key, value[1])
property_types[key]["members"] += property_types[ref]["members"]
else:
raise NotImplementedError()
with open("src/server/server/map/map.tiled-project", "r") as f:
tiled_project = json.load(f)
tiled_project["propertyTypes"] = list(property_types.values())
# print(json.dumps(tiled_project))
with open("src/server/server/map/map.tiled-project", "w") as f:
json.dump(obj=tiled_project, fp=f, indent=4)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/main.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/main.py | import argparse
import asyncio
import logging
import multiprocessing
import sys
import threading
import traceback
from multiprocessing.synchronize import Event as MultiprocessingEventClass
import aioprocessing
import pyglet
import client
from client.game.state import GameState
from client.networking.network import Connection
from client.networking.runner import Runner
from client.scenes.dino_runner import DinoRunner
from client.scenes.game import Game
from client.scenes.game_over import GameOver
from client.scenes.globals import Globals
from client.scenes.intro import Intro
from client.scenes.mainmenu import MainMenu
from client.scenes.scenemanager import SceneManager
from client.scenes.test import TestScene
# from client.scenes.game import Game
from shared.constants import TARGET_FPS, TARGET_UPS
def background_thread(connection: Connection, running: threading.Event) -> None:
loop = asyncio.new_event_loop()
async def run() -> None:
loop_task = loop.create_task(connection.ping_loop(running))
send_loop_task = loop.create_task(connection.send_message_loop(running))
message_loop_task = loop.create_task(connection.read_message_loop(running))
for coro in asyncio.as_completed(
[loop_task, send_loop_task, message_loop_task]
):
await coro
running.clear()
break
try:
loop.run_until_complete(run())
except Exception:
traceback.print_exc()
pyglet.app.exit()
def background_process(runner: Runner, running: MultiprocessingEventClass):
loop = asyncio.new_event_loop()
async def run() -> None:
send_loop_task = loop.create_task(runner.send_message_loop(running))
message_loop_task = loop.create_task(runner.read_message_loop(running))
for coro in asyncio.as_completed([send_loop_task, message_loop_task]):
await coro
running.clear()
break
try:
loop.run_until_complete(run())
except Exception:
traceback.print_exc()
pyglet.app.exit()
def run() -> None:
# tracer = VizTracer(log_async=True, tracer_entries=10000000, output_file="result.gz")
# tracer.enable_thread_tracing()
# tracer.start()
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="Verbose", action="store_true")
parser.add_argument("-p", "--port", help="Port Default 1337", default=1337)
parser.add_argument("--host", help="Host Default 127.0.0.1", default="127.0.0.1")
parser.add_argument("--ssl", help="Use ssl", action="store_true")
parser.add_argument("--username", help="Username prefill", default="")
parser.add_argument("--password", help="Password prefill", default="")
args = parser.parse_args()
log = logging.getLogger()
log.handlers.clear()
log.setLevel(level=logging.INFO)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
log.addHandler(handler)
if args.verbose:
log.setLevel(level=logging.DEBUG)
running = threading.Event()
running.set()
config = pyglet.gl.Config(
double_buffer=True,
depth_size=16,
major_version=3,
minor_version=3,
stencil_size=8,
)
window = pyglet.window.Window(width=960, height=544, config=config, vsync=False)
global_overlay = Globals(window)
client.game_state = GameState()
runner_con = aioprocessing.AioQueue()
thread_con = aioprocessing.AioQueue()
runner = Runner(
runner_con=runner_con,
thread_con=thread_con,
host=args.host,
port=args.port,
ssl=args.ssl,
)
client.global_connection = Connection(
runner_con=runner_con,
thread_con=thread_con,
error_handler=global_overlay.on_error,
game_state=client.game_state,
)
client.global_connection.login_handler += client.game_state.login
client.scene_manager = SceneManager(window)
scene_manager = client.scene_manager
pyglet.clock.schedule_interval(scene_manager.update, 1 / TARGET_UPS)
game = Game(window)
scene_manager.add_scene("game", game)
mainmenu = MainMenu(window, args.username, args.password)
scene_manager.add_scene("mainmenu", mainmenu)
game_over = GameOver(window)
scene_manager.add_scene("game_over", game_over)
intro = Intro(window=window)
scene_manager.add_scene("intro", intro)
test = TestScene(window)
scene_manager.add_scene("test", test)
scene_manager.add_scene("globals", global_overlay)
# scene_manager.set_scene("mainmenu")
scene_manager.set_scene("intro")
dino_runner = DinoRunner(window)
scene_manager.add_scene("dino_runner", dino_runner)
# scene_manager.set_scene("game")
scene_manager.set_overlay_scene(scene="globals")
th = threading.Thread(
target=background_thread, args=[client.global_connection, running]
)
th.start()
process_running = multiprocessing.Event()
process_running.set()
p = aioprocessing.AioProcess(
target=background_process, args=[runner, process_running]
)
p.start() # type: ignore
try:
pyglet.app.run(1 / TARGET_FPS)
except:
traceback.print_exc()
print("BEFORE BYE")
# tracer.stop()
# print("SAVING")
# tracer.save()
# print("SAVED")
running.clear()
process_running.clear()
th.join()
p.join() # type: ignore
print("BYE")
if __name__ == "__main__":
run()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/__init__.py | MOTION_SELECT_ALL = 0xFF
MOTION_DELETE_REST = 0xFE
from pathlib import Path
import pyglet
from pyglet.window import key
from client.game.state import GameState
from client.networking.network import Connection
from client.scenes.scenemanager import SceneManager
if hasattr(pyglet.window, "xlib"):
pyglet.window.xlib._motion_map[(key.A, True)] = MOTION_SELECT_ALL # type: ignore
pyglet.window.xlib._motion_map[(key.DELETE, True)] = MOTION_DELETE_REST # type: ignore
if hasattr(pyglet.window, "win32"):
pyglet.window.win32._motion_map[(key.A, True)] = MOTION_SELECT_ALL # type: ignore
pyglet.window.win32._motion_map[(key.DELETE, True)] = MOTION_DELETE_REST # type: ignore
MAP_SHADER = None
TILE_BOX_SHADER = None
global_connection: Connection
scene_manager: SceneManager
game_state: GameState
PATH = Path(__file__).parent
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/inventory.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/inventory.py | from typing import TYPE_CHECKING, Callable, cast
from pyglet.gl import GL_SCISSOR_TEST, glDisable, glEnable, glScissor
from pyglet.graphics import Batch, Group
from pyglet.gui import Frame
from pyglet.image import Animation, Texture
from pyglet.text import Label
from pyglet.window import Window
import client
from client.game.nearest_sprite import NearestSprite
from client.game.ui import get_ui_grid
from client.game.ui.button import ImageButton
from client.game.ui.slider import Slider
from client.game.ui.tilebox import TileBox
from client.game.ui.utils import Exit
from client.scenes.scenemanager import Scene
from shared.gen.messages.v1 import Item
if TYPE_CHECKING:
from client.scenes.game import Game
class SmallItem(Group):
icon: int
name: str
description: str
quantity: int
def __init__(
self,
x: int,
y: int,
icon: int,
name: str,
description: str,
quantity: int,
order: int = 0,
batch: Batch | None = None,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self._x = x
self._y = y
self.icon = icon
self.name = name
self.description = description
self.quantity = quantity
self._image = NearestSprite(
cast(Texture, get_ui_grid()[self.icon]),
x=x + cast(int, get_ui_grid().item_width) * 3,
y=y - (cast(int, get_ui_grid().item_height) // 2),
origin=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
group=self,
)
self._image.scale = 3
self._name_label = Label(
text=f"{self.quantity}x {self.name}",
x=x + cast(int, get_ui_grid().item_width) * 3 + 50,
y=y,
batch=batch,
group=self,
anchor_y="center",
color=(0, 0, 0, 255),
font_size=20,
)
@property
def x(self) -> int:
return self._x
@x.setter
def x(self, x: int) -> None:
self._x = x
@property
def y(self) -> int:
return self._y
@y.setter
def y(self, y: int) -> None:
offset = self._y - y
self._image.y -= offset
if self._name_label:
self._name_label.y -= offset
self._y = y
def draw(self) -> None:
self._image.draw()
def __del__(self) -> None:
self._name_label.__del__()
class InventoryItem:
item: Item
width: int
height: int
_x: int
_y: int
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
item: Item,
batch: Batch,
group: Group,
frame: Frame,
cb: Callable[[Item], None],
) -> None:
self.item = item
self._x = x
self._y = y
self.width = width
self.height = height
self.frame = frame
self.cb = cb
self._first_item = SmallItem(
x=x,
y=y + height // 2,
icon=self.item.icon,
name=self.item.name,
description=self.item.description,
quantity=self.item.quantity,
batch=batch,
parent=group,
)
self._outline = TileBox(
x,
y,
width,
height,
tile_offset_x=3,
tile_offset_y=15,
group=group,
)
self._show_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 7 + 54 : 61 * 7 + 57],
duration=0.01,
),
x=x + 300,
y=y + height // 2 - cast(int, get_ui_grid().item_height) // 2,
group=group,
scale_x=3,
scale_y=3,
)
self.frame.add_widget(self._show_button)
self._show_button.set_handler("on_press", self.show)
def __del__(self) -> None:
try:
self.frame.remove_widget(self._show_button)
except KeyError:
pass
self._first_item.__del__()
def show(self) -> None:
self.cb(self.item)
@property
def x(self) -> int:
return self._x
@x.setter
def x(self, x: int) -> None:
self._x = x
self._outline.x = x
@property
def y(self) -> int:
return self._y
@y.setter
def y(self, y: int) -> None:
offset = self._y - y
self._outline.y += offset
if self._first_item:
self._first_item.y += offset
self.frame.remove_widget(widget=self._show_button)
self._show_button.y += offset
self.frame.add_widget(widget=self._show_button)
self._y = y
def draw(self) -> None:
self._outline.draw()
self._show_button.draw()
if self._first_item:
self._first_item.draw()
class ShowItem(Group):
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
order: int = 0,
batch: Batch | None = None,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self.x = x
self.y = y
self.width = width
self.height = height
self._outline = TileBox(
x,
y,
width,
height,
tile_offset_x=3,
tile_offset_y=15,
)
self._image = NearestSprite(
img=cast(Texture, get_ui_grid()[61 * 3 + 16]),
x=x + width // 2 - (cast(int, get_ui_grid().item_width)) // 2,
y=y + 275,
origin=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
group=self,
)
self._image.scale = 15
self._description_label = Label(
text="",
x=x + cast(int, get_ui_grid().item_width) * 3,
y=y + 150,
width=width - +cast(int, get_ui_grid().item_width) * 7,
multiline=True,
batch=batch,
group=self,
color=(0, 0, 0, 255),
font_size=10,
)
def draw(self) -> None:
self._outline.draw()
self._image.draw()
def set_item(self, item: Item) -> None:
self._image.image = cast(Texture, get_ui_grid()[item.icon])
self._description_label.text = item.description
def reset(self) -> None:
self._image.image = cast(Texture, get_ui_grid()[61 * 3 + 16])
self._description_label.text = ""
class InnerInventory(Group):
items_ui: list[InventoryItem]
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
batch: Batch,
frame: Frame,
) -> None:
self.x = x
self.y = y
self.width = width
self.height = height
self.batch = batch
self.frame = frame
self.items_ui = []
self.item_height = 128
self._show_item = ShowItem(
x=x + self.width // 2,
y=y,
height=self.height,
width=self.width // 2,
batch=batch,
)
super().__init__()
def recreate(self, items: list[Item]) -> None:
for item in self.items_ui:
item.__del__()
self.items_ui = []
self._show_item.reset()
for i, item in enumerate(items):
s = InventoryItem(
x=self.x,
y=self.height + self.y - self.item_height * (i + 1),
width=self.width // 2,
height=self.item_height,
item=item,
batch=self.batch,
group=self,
frame=self.frame,
cb=self._show_item.set_item,
)
self.items_ui.append(s)
def draw(self) -> None:
self._show_item.draw()
for item in self.items_ui:
item.draw()
def set_state(self) -> None:
glEnable(GL_SCISSOR_TEST)
glScissor(self.x, self.y, self.width, self.height)
def unset_state(self) -> None:
glDisable(GL_SCISSOR_TEST)
class Inventory(Scene):
def __init__(
self,
window: Window,
) -> None:
super().__init__(window=window)
x = 0
y = 0
width = window.width
height = window.height
self.items: list[Item] = []
self._outline = TileBox(x, y, width, height)
self.inner_width = (width // self._outline.tile_size) * self._outline.tile_size
self.inner_height = (
height // self._outline.tile_size
) * self._outline.tile_size
self.batch = Batch()
self.frame = Frame(window, order=4)
self.uuid = ""
self.slider = 0
self._up_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 13 + 54 : 61 * 13 + 57],
duration=0.01,
),
x=x + self.inner_width - cast(int, get_ui_grid().item_width) * 2 - 40,
y=y + self.inner_height - cast(int, get_ui_grid().item_height) * 2 - 40,
scale_x=3,
scale_y=3,
)
self._up_button.set_handler("on_press", self._slide_up)
self._down_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 13 + 51 : 61 * 13 + 54],
duration=0.01,
),
x=x + self.inner_width - cast(int, get_ui_grid().item_width) * 2 - 40,
y=y + 40 + cast(int, get_ui_grid().item_height),
scale_x=3,
scale_y=3,
)
self._down_button.set_handler("on_press", self._slide_down)
self._slider = Slider(
x=x + self.inner_width - cast(int, get_ui_grid().item_width) * 3 - 40,
y=y + 40 + cast(int, get_ui_grid().item_height) * 3,
batch=self.batch,
width=cast(int, get_ui_grid().item_width) * 3,
height=self.inner_height - cast(int, get_ui_grid().item_width) * 6 - 40 * 2,
)
self._slider.set_handler("on_change", self._slide)
self.inner_shop = InnerInventory(
x=x + self._outline.tile_size,
y=y + self._outline.tile_size,
width=(
self.inner_width
- 2 * self._outline.tile_size
- cast(int, get_ui_grid().item_width) * 3
- 25
),
height=self.inner_height - 2 * self._outline.tile_size,
batch=self.batch,
frame=self.frame,
)
self._exit = Exit(
x=-10,
y=int(height - 32 * 2.75),
exit_func=self._close,
batch=self.batch,
frame=self.frame,
)
self.dirty = True
self.sider_step_size = self.inner_shop.item_height
self._update_slider()
def _close(self) -> None:
cast("Game", client.scene_manager.current_scene).remove_inventory()
def _max_slider(self) -> int:
return (len(self.inner_shop.items_ui) - 1) * self.inner_shop.item_height
def _slide(self, value: float) -> None:
y = int((100 - value) / 100 * self._max_slider())
step = self.slider - y
self.slider = y
self._update_item_y(step)
def _update_slider(self) -> None:
val = 100
if self._max_slider() != 0:
val = 100 - (self.slider / self._max_slider()) * 100
self._slider.value = val
def _slide_up(self) -> None:
step = self.sider_step_size
if self.slider - step < 0:
step = self.slider % self.sider_step_size
if step == self.sider_step_size:
return
self.slider -= step
self._update_slider()
self._update_item_y(step)
def _slide_down(self) -> None:
step = self.sider_step_size
if self.slider + step > self._max_slider():
step = self.sider_step_size - (self.slider % self.sider_step_size)
if step == self.sider_step_size:
return
self.slider += step
self._update_slider()
self._update_item_y(-step)
def _update_item_y(self, step: int) -> None:
for item in self.inner_shop.items_ui:
item.y += step
def draw(self) -> None:
if self.dirty:
# TODO: Reuse old textures
self.slider = 0
self._update_slider()
self.inner_shop.recreate(self.items)
self.dirty = False
self._outline.draw()
self.inner_shop.draw()
self.batch.draw()
self._up_button.draw()
self._down_button.draw()
self._slider.draw()
self._exit.draw()
def set_inventory_items(self, items: list[Item]) -> None:
self.items = items
self.dirty = True
def activate(self) -> None:
self.frame.add_widget(widget=self._up_button)
self.frame.add_widget(widget=self._down_button)
self.frame.add_widget(widget=self._slider)
self._exit.activate()
def deactivate(self) -> None:
self.reset()
self.cb = None
self.frame.remove_widget(widget=self._up_button)
self.frame.remove_widget(widget=self._down_button)
self.frame.remove_widget(widget=self._slider)
self._exit.__del__()
def reset(self) -> None:
self.text = []
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/dialog.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/dialog.py | from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.window import Window
from client.game.ui.dialog import Dialog, DialogCallback
from client.scenes.scenemanager import Scene
class DialogScene(Scene):
def __init__(
self,
window: Window,
) -> None:
super().__init__(window=window)
self.batch = Batch()
self.frame = Frame(window=window)
self.dialog = Dialog(
0,
0,
self.window.width,
200,
[],
batch=self.batch,
)
def draw(self) -> None:
self.dialog.draw()
self.batch.draw()
return super().draw()
@property
def callback(self) -> DialogCallback:
return self.dialog.cb
@callback.setter
def callback(self, cb: DialogCallback) -> None:
self.dialog.cb = cb
def append_text(self, text: str) -> None:
self.dialog.append_text(text)
def set_text(self, text: list[str]) -> None:
self.dialog.text = text
def next_text(self) -> None:
self.dialog.next_text()
def activate(self) -> None:
self.frame.add_widget(widget=self.dialog)
self.dialog.start(self.dialog.text, self.callback)
def deactivate(self) -> None:
self.cb = None
self.frame.remove_widget(widget=self.dialog)
self.dialog.stop()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/game_over.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/game_over.py | from pathlib import Path
from typing import cast
from pyglet import image
from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.image import ImageData
from pyglet.sprite import Sprite
from pyglet.text import Label
from pyglet.window import Window
import client
from client.scenes.scenemanager import Scene
from shared.constants import PLAYER_DEATH_TIMEOUT
class GameOver(Scene):
status: str
def get_background_image(self) -> ImageData:
return cast(
ImageData,
image.load(Path(client.PATH, "assets/game_over_background.png")),
)
def __init__(self, window: Window) -> None:
super().__init__(window)
self.frame = Frame(window, order=4)
self.batch = Batch()
self.status = ""
self.background_image = self.get_background_image()
self.background = Sprite(
img=self.background_image, x=200, y=280, batch=self.batch
)
self.press_key_label = Label(
text=f"You have to wait for {int(PLAYER_DEATH_TIMEOUT / 60)} minutes before you can respawn",
font_name="Consolas",
font_size=14,
x=550,
y=100,
anchor_x="center",
anchor_y="center",
multiline=True,
width=700,
batch=self.batch,
)
def activate(self) -> None:
super().activate()
def deactivate(self) -> None:
super().deactivate()
def draw(self) -> None:
self.batch.draw()
def on_key_press(self, symbol: int, modifiers: int) -> bool | None:
pass
def update(self, dt: float) -> None:
pass
# self.status_label.text = self.status
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/dino_runner.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/dino_runner.py | import random
from collections import defaultdict
from functools import cache
from pathlib import Path
from typing import cast
import pyglet
from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.image import ImageData
from pyglet.text import Label
from pyglet.window import Window
from pyglet.window.key import SPACE
import client
from client.game.nearest_sprite import NearestSprite
from client.scenes.scenemanager import Scene
from shared.gen.messages.v1 import Interact, InteractStatus
from shared.gen.messages.v1 import Runner as Runner
from shared.gen.messages.v1 import RunnerAction, RunnerEvent
@cache
def get_dino_image() -> ImageData:
return cast(
ImageData,
pyglet.image.load(Path(client.PATH, "assets/google/100-offline-sprite.png")),
)
class Background:
def activate(self, batch: Batch) -> None:
self.background_image = get_dino_image().get_region(2, 100 - 54 - 12, 1200, 12)
self.background = pyglet.sprite.Sprite(
self.background_image, 0, 200, batch=batch
)
self.background2 = pyglet.sprite.Sprite(
self.background_image, self.background_image.width, 200, batch=batch
)
def update(self, dt: float, offset: float):
self.background2.x = offset % self.background.width
self.background.x = self.background2.x - self.background2.width
class Obstacle:
sprite: NearestSprite
x: float = 0
width: float
height: float
def activate(self, batch: Batch) -> None:
pass
def update(self, dt: float, speed: float):
pass
def draw(self):
pass
class LongObstacle(Obstacle):
width = 75
height = 50 - 2
def activate(self, batch: Batch) -> None:
self.sprite = NearestSprite(
cast(
pyglet.image.Texture,
get_dino_image().get_region(407, 100 - 2 - 50, 75, height=50),
),
-75,
200 - 2,
)
def update(self, dt: float, speed: float):
self.x -= dt * speed
self.sprite.x = self.x
def draw(self):
self.sprite.draw()
class BigObstacle(Obstacle):
width = 25
height = 50 - 2
def activate(self, batch: Batch) -> None:
self.image = pyglet.image.ImageGrid(
get_dino_image().get_region(332, 100 - 2 - 50, 25 * 3, height=50), 1, 3
).get_texture_sequence()
self.sprite = NearestSprite(
cast(pyglet.image.Texture, random.choice(self.image)),
-self.image.item_width,
200 - 2,
)
def update(self, dt: float, speed: float):
self.x -= dt * speed
self.sprite.x = self.x
def draw(self):
self.sprite.draw()
class SmallObstacle(Obstacle):
width = 17
height = 35
def activate(self, batch: Batch) -> None:
self.image = pyglet.image.ImageGrid(
get_dino_image().get_region(228, 100 - 2 - 35, 17 * 6, 35), 1, 6
).get_texture_sequence()
self.sprite = NearestSprite(
cast(pyglet.image.Texture, random.choice(self.image)),
-self.image.item_width,
200,
)
def update(self, dt: float, speed: float):
self.x -= dt * speed
self.sprite.x = self.x
def draw(self):
self.sprite.draw()
class Dino:
v0: float
g: float
y: float
width: float = 44
def __init__(self) -> None:
self.in_jump = False
self.vel = 0
self.acc = 0
self.ground_level = 200
self.jump_duration = 0.5
self.y = 0
self.jump_height = 100
self.g = self.jump_height / (2 * pow(self.jump_duration / 4, 2))
self.v0 = pow(2 * self.jump_height * self.g, 1 / 2)
def activate(self, batch: Batch):
self.dino_image = pyglet.image.ImageGrid(
get_dino_image().get_region(848, 100 - 2 - 47, 44 * 4, 47), 1, 4
).get_texture_sequence()
self.sprite = NearestSprite(
pyglet.image.animation.Animation.from_image_sequence(
self.dino_image[2:4],
duration=0.5,
),
0,
y=self.ground_level,
)
def draw(self):
self.sprite.draw()
def update(self, dt: float, speed: float):
for frame in cast(
list[pyglet.image.AnimationFrame],
cast(pyglet.image.Animation, self.sprite._animation).frames,
):
frame.duration = pow((speed / 400) + 1, -2)
self.vel -= self.g * dt
self.y += self.vel * dt
if self.y < 0:
self.y = 0
self.vel = 0
self.sprite.y = self.y + self.ground_level
def jump(self):
if self.y == 0:
self.vel = self.v0
class DinoRunner(Scene):
background: Background
dino: Dino
obstacles: list[Obstacle]
def __init__(self, window: Window) -> None:
super().__init__(window)
self.frame = Frame(window, order=4)
self.batch = None
self.window = window
self.background = Background()
self.dino = Dino()
self.game_width = 1200
self.time = 0
self.should_jump = False
self.uuid = ""
self._reset()
def activate(self) -> None:
self._reset()
self.batch = Batch()
self.background.activate(self.batch)
for obstacle in self.obstacles:
obstacle.activate(self.batch)
self.dino.activate(self.batch)
self.score = Label(
f"Score: 0",
x=int(self.window.width // 2),
y=self.window.height - 20,
color=(0, 0, 0, 255),
anchor_x="center",
anchor_y="top",
font_name="Times New Roman",
font_size=12,
)
self.actions: dict[float, list[RunnerAction]] = defaultdict(lambda: [])
def _reset(self) -> None:
self.state = 0
self.speed = 400
self.acc = 20
self.offset = 0
self.obstacles = [
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
BigObstacle(),
BigObstacle(),
LongObstacle(),
]
for obs in self.obstacles:
obs.x = -obs.width
self.dts: list[float] = []
def draw(self) -> None:
pyglet.gl.glClearColor(1, 1, 1, 1)
if self.batch:
self.batch.draw()
for obstacle in self.obstacles:
obstacle.draw()
self.dino.draw()
self.score.draw()
def deactivate(self) -> None:
return super().deactivate()
def _on_interact_handler(self, interact: Interact) -> None:
if interact.status == InteractStatus.INTERACT_STATUS_UPDATE:
self.rng = random.Random(interact.progress)
self.time = 0
self.offset = 0
self.state = 1
def on_key_press(self, symbol: int, modifiers: int) -> int | None:
if symbol == SPACE:
if self.state == 0:
client.global_connection.interact(
uuid=self.uuid,
status=InteractStatus.INTERACT_STATUS_UPDATE,
handler=self._on_interact_handler,
)
if self.state == 1:
self.should_jump = True
def on_key_release(self, symbol: int, modifiers: int) -> int | None:
if symbol == SPACE:
self.should_jump = False
def update(self, dt: float) -> None:
if self.state == 1:
self.dts.append(dt)
self.offset -= self.speed * dt
self.speed += self.acc * dt
self.time += dt
self.background.update(dt, self.offset)
self.dino.update(dt, self.speed)
for obstacle in self.obstacles:
obstacle.update(dt, self.speed)
if obstacle.x < self.dino.width and obstacle.x + obstacle.width > 0:
if self.dino.y < obstacle.height:
self.actions[self.time].append(RunnerAction.RUNNER_ACTION_DIE)
self.state = 2
obstacles = sorted(self.obstacles, key=lambda x: cast(int, x.x))
last = obstacles[-1]
if last.x + last.width < self.game_width:
if self.rng.random() < 0.04:
free = [x for x in obstacles if x.x + x.width <= 0]
if len(free) > 0:
obs = self.rng.choice(free)
obs.x = self.game_width
if self.should_jump:
self.actions[self.time].append(RunnerAction.RUNNER_ACTION_JUMP)
self.dino.jump()
self.score.text = f"Score: {int(-self.offset//100):d}"
if self.state == 2:
pyglet.gl.glClearColor(0, 0, 0, 1)
client.global_connection.interact(
uuid=self.uuid,
status=InteractStatus.INTERACT_STATUS_STOP,
runner=Runner(
events=[
RunnerEvent(time=k, action=a)
for k, v in self.actions.items()
for a in v
],
dts=self.dts,
),
)
client.scene_manager.set_scene("game")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/input.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/input.py | from typing import TYPE_CHECKING, Callable, cast
from pyglet.graphics import Batch
from pyglet.window import Window
from pyglet.window.key import ENTER
import client
from client.game.ui.input import TextInput
from client.scenes.scenemanager import Scene
if TYPE_CHECKING:
from client.scenes.game import Game
InputCallback = Callable[[str], None] | None
class InputScene(Scene):
callback: InputCallback
def __init__(
self,
window: Window,
) -> None:
super().__init__(window=window)
self.batch = Batch()
self.input = TextInput(
"",
32,
32,
self.window.width - 32 * 2,
batch=self.batch,
text_color=(0, 0, 0, 255),
caret_color=(0, 0, 0, 255),
color=(0, 0, 0, 0),
)
def on_key_press(self, symbol: int, modifiers: int) -> int | None:
if symbol == ENTER:
if self.callback:
self.callback(self.input.value)
self.input.value = ""
game = cast("Game", client.scene_manager.current_scene)
game.remove_input()
return super().on_key_press(symbol, modifiers)
def draw(self) -> None:
self.input.draw()
self.batch.draw()
return super().draw()
def activate(self) -> None:
self.window.push_handlers(self.input)
def deactivate(self) -> None:
self.cb = None
self.window.remove_handlers(self.input)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/shop.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/shop.py | from typing import TYPE_CHECKING, Callable, cast
from pyglet.gl import GL_SCISSOR_TEST, glDisable, glEnable, glScissor
from pyglet.graphics import Batch, Group
from pyglet.gui import Frame
from pyglet.image import Animation, Texture
from pyglet.text import Label
from pyglet.window import Window
import client
from client.game.nearest_sprite import NearestSprite
from client.game.ui import get_ui_grid
from client.game.ui.button import ImageButton
from client.game.ui.slider import Slider
from client.game.ui.tilebox import TileBox
from client.game.ui.utils import Exit
from client.scenes.scenemanager import Scene
from shared.gen.messages.v1 import ShopInteract, ShopInteractType
if TYPE_CHECKING:
from client.scenes.game import Game
ShopCallback = Callable[[], None] | None
class Coin(Group):
coins: int
def __init__(
self,
x: int,
y: int,
coins: int,
order: int = 0,
batch: Batch | None = None,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self._x = x
self._y = y
self.coins = coins
self._coin = NearestSprite(
cast(Texture, get_ui_grid()[61 * 23 + 13]),
x=x + cast(int, get_ui_grid().item_width) * 2,
y=y - cast(int, get_ui_grid().item_height) // 2,
origin=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
group=self,
)
self._coin.scale = 3
self._price_label = Label(
str(coins),
x=x + 15,
y=y,
batch=batch,
group=self,
anchor_y="center",
anchor_x="right",
color=(0, 0, 0, 255),
font_size=20,
)
@property
def x(self) -> int:
return self._x
@x.setter
def x(self, x: int) -> None:
self._x = x
@property
def y(self) -> int:
return self._y
@y.setter
def y(self, y: int) -> None:
offset = self._y - y
if self._coin:
self._coin.y -= offset
if self._price_label:
self._price_label.y -= offset
self._y = y
def draw(self) -> None:
if self._coin:
self._coin.draw()
def __del__(self) -> None:
self._price_label.__del__()
self._coin.__del__()
class Item(Group):
icon: int
name: str
quantity: int
def __init__(
self,
x: int,
y: int,
icon: int,
name: str,
quantity: int,
order: int = 0,
batch: Batch | None = None,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self._x = x
self._y = y
self.icon = icon
self.name = name
self.quantity = quantity
self._image = NearestSprite(
cast(Texture, get_ui_grid()[self.icon]),
x=x + cast(int, get_ui_grid().item_width) * 3,
y=y - (cast(int, get_ui_grid().item_height) // 2),
origin=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
group=self,
)
self._image.scale = 3
self._name_label = Label(
text=f"{self.quantity}x {self.name}",
x=x + cast(int, get_ui_grid().item_width) * 3 + 50,
y=y,
batch=batch,
group=self,
anchor_y="center",
color=(0, 0, 0, 255),
font_size=20,
)
@property
def x(self) -> int:
return self._x
@x.setter
def x(self, x: int) -> None:
self._x = x
@property
def y(self) -> int:
return self._y
@y.setter
def y(self, y: int) -> None:
offset = self._y - y
self._image.y -= offset
if self._name_label:
self._name_label.y -= offset
self._y = y
def draw(self) -> None:
self._image.draw()
def __del__(self) -> None:
self._name_label.__del__()
class ShopItem:
item: ShopInteract
width: int
height: int
_x: int
_y: int
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
item: ShopInteract,
batch: Batch,
group: Group,
frame: Frame,
) -> None:
self.item = item
self._x = x
self._y = y
self.width = width
self.height = height
self.frame = frame
self._first_item = Item(
x=x,
y=y + height // 2,
icon=self.item.item.icon,
name=self.item.item.name,
quantity=self.item.item.quantity,
batch=batch,
parent=group,
)
if self.item.type == ShopInteractType.SHOP_INTERACT_TYPE_TRADE:
self._second_item = Item(
x=x + 300 + cast(int, get_ui_grid().item_width) * 3,
y=y + height // 2,
icon=self.item.trade_in.icon,
name=self.item.trade_in.name,
quantity=self.item.trade_in.quantity,
batch=batch,
parent=group,
)
else:
self._second_item = Coin(
x=x + 500 - 15,
y=y + height // 2,
coins=self.item.cost,
batch=batch,
parent=group,
)
self._outline = TileBox(
x,
y,
width,
height,
tile_offset_x=3,
tile_offset_y=15,
group=group,
)
self._buy_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 17 + 54 : 61 * 17 + 57],
duration=0.01,
),
x=x + 700,
y=y + height // 2 - cast(int, get_ui_grid().item_height) // 2,
group=group,
scale_x=3,
scale_y=3,
)
arrow_index = 61 * 19 + 28
if self.item.type == ShopInteractType.SHOP_INTERACT_TYPE_SELL:
arrow_index = 61 * 19 + 29
self._arrow_icon = NearestSprite(
cast(Texture, get_ui_grid()[arrow_index]),
x=x + 325,
y=y + height // 2 - cast(int, get_ui_grid().item_height) // 2,
origin=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
group=group,
)
self._arrow_icon.scale = 3
self.frame.add_widget(self._buy_button)
self._buy_button.set_handler("on_press", self.buy)
def __del__(self) -> None:
try:
self.frame.remove_widget(self._buy_button)
except KeyError:
pass
self._second_item.__del__()
self._first_item.__del__()
def buy(self) -> None:
cast("Game", client.scene_manager.current_scene).buy(self.item)
@property
def x(self) -> int:
return self._x
@x.setter
def x(self, x: int) -> None:
self._x = x
self._outline.x = x
@property
def y(self) -> int:
return self._y
@y.setter
def y(self, y: int) -> None:
offset = self._y - y
self._outline.y += offset
if self._second_item:
self._second_item.y += offset
if self._first_item:
self._first_item.y += offset
self._arrow_icon.y += offset
self.frame.remove_widget(widget=self._buy_button)
self._buy_button.y += offset
self.frame.add_widget(widget=self._buy_button)
self._y = y
def draw(self) -> None:
self._outline.draw()
self._buy_button.draw()
self._arrow_icon.draw()
self._second_item.draw()
self._first_item.draw()
class InnerShop(Group):
shop_items_ui: list[ShopItem]
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
batch: Batch,
frame: Frame,
) -> None:
self.x = x
self.y = y
self.width = width
self.height = height
self.batch = batch
self.frame = frame
self.shop_items_ui = []
self.item_height = 128
super().__init__()
def recreate(self, items: list[ShopInteract]) -> None:
for item in self.shop_items_ui:
item.__del__()
del item
item = None
self.shop_items_ui = []
for i, item in enumerate(items):
s = ShopItem(
x=self.x,
y=self.height + self.y - self.item_height * (i + 1),
width=self.width,
height=self.item_height,
item=item,
batch=self.batch,
group=self,
frame=self.frame,
)
self.shop_items_ui.append(s)
def draw(self) -> None:
for item in self.shop_items_ui:
item.draw()
def set_state(self) -> None:
glEnable(GL_SCISSOR_TEST)
glScissor(self.x, self.y, self.width, self.height)
def unset_state(self) -> None:
glDisable(GL_SCISSOR_TEST)
class Shop(Scene):
def __init__(
self,
window: Window,
cb: ShopCallback = None,
) -> None:
super().__init__(window=window)
x = 0
y = 0
width = window.width
height = window.height
self.items: list[ShopInteract] = []
self._outline = TileBox(x, y, width, height)
self.inner_width = (width // self._outline.tile_size) * self._outline.tile_size
self.inner_height = (
height // self._outline.tile_size
) * self._outline.tile_size
self.batch = Batch()
self.frame = Frame(window, order=4)
self.uuid = ""
self.slider = 0
self._up_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 13 + 54 : 61 * 13 + 57],
duration=0.01,
),
x=x + self.inner_width - cast(int, get_ui_grid().item_width) * 2 - 40,
y=y + self.inner_height - cast(int, get_ui_grid().item_height) * 2 - 40,
scale_x=3,
scale_y=3,
)
self._up_button.set_handler("on_press", self._slide_up)
self._down_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 13 + 51 : 61 * 13 + 54],
duration=0.01,
),
x=x + self.inner_width - cast(int, get_ui_grid().item_width) * 2 - 40,
y=y + 40 + cast(int, get_ui_grid().item_height),
scale_x=3,
scale_y=3,
)
self._down_button.set_handler("on_press", self._slide_down)
self._slider = Slider(
x=x + self.inner_width - cast(int, get_ui_grid().item_width) * 3 - 40,
y=y + 40 + cast(int, get_ui_grid().item_height) * 3,
batch=self.batch,
width=cast(int, get_ui_grid().item_width) * 3,
height=self.inner_height - cast(int, get_ui_grid().item_width) * 6 - 40 * 2,
)
self._slider.set_handler("on_change", self._slide)
self.cb = cb
self.inner_shop = InnerShop(
x=x + self._outline.tile_size,
y=y + self._outline.tile_size,
width=(
self.inner_width
- 2 * self._outline.tile_size
- cast(int, get_ui_grid().item_width) * 3
- 25
),
height=self.inner_height - 2 * self._outline.tile_size,
batch=self.batch,
frame=self.frame,
)
self._exit = Exit(
x=-10,
y=int(height - 32 * 2.75),
exit_func=self._close,
batch=self.batch,
frame=self.frame,
)
self.dirty = True
self.sider_step_size = self.inner_shop.item_height
self._update_slider()
def _close(self) -> None:
cast("Game", client.scene_manager.current_scene).remove_shop()
def _max_slider(self) -> int:
return (len(self.inner_shop.shop_items_ui) - 1) * self.inner_shop.item_height
def _slide(self, value: float) -> None:
y = int((100 - value) / 100 * self._max_slider())
step = self.slider - y
self.slider = y
self._update_item_y(step)
def _update_slider(self) -> None:
val = 100
if self._max_slider() != 0:
val = 100 - (self.slider / self._max_slider()) * 100
self._slider.value = val
def _slide_up(self) -> None:
step = self.sider_step_size
if self.slider - step < 0:
step = self.slider % self.sider_step_size
if step == self.sider_step_size:
return
self.slider -= step
self._update_slider()
self._update_item_y(step)
def _slide_down(self) -> None:
step = self.sider_step_size
if self.slider + step > self._max_slider():
step = self.sider_step_size - (self.slider % self.sider_step_size)
if step == self.sider_step_size:
return
self.slider += step
self._update_slider()
self._update_item_y(-step)
def _update_item_y(self, step: int) -> None:
for item in self.inner_shop.shop_items_ui:
item.y += step
def draw(self) -> None:
if self.dirty:
# TODO: Reuse old textures
self.slider = 0
self._update_slider()
self.inner_shop.recreate(self.items)
self.dirty = False
self._outline.draw()
self.inner_shop.draw()
self.batch.draw()
self._up_button.draw()
self._down_button.draw()
self._slider.draw()
self._exit.draw()
def set_shop_items(self, items: list[ShopInteract], uuid: str) -> None:
self.items = items
self.uuid = uuid
self.dirty = True
def start(
self, items: list[ShopInteract], uuid: str, cb: ShopCallback = None
) -> None:
self.items = items
self.cb = cb
self.uuid = uuid
self.dirty = True
def activate(self) -> None:
self.frame.add_widget(widget=self._up_button)
self.frame.add_widget(widget=self._down_button)
self.frame.add_widget(widget=self._slider)
self._exit.activate()
def deactivate(self) -> None:
self.reset()
self.cb = None
self.frame.remove_widget(widget=self._up_button)
self.frame.remove_widget(widget=self._down_button)
self.frame.remove_widget(widget=self._slider)
self._exit.__del__()
def reset(self) -> None:
self.text = []
self.uuid = ""
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/scenemanager.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/scenemanager.py | from __future__ import annotations
import time
from abc import ABC, abstractmethod
from pyglet.input import Controller, ControllerManager
from pyglet.window import Window, key
import client
from shared.constants import TARGET_FPS, TARGET_UPS
class Scene(ABC):
_sub_scenes: dict[str, Scene]
_current_sub_scenes: list[Scene]
_tmp_new_sub_scenes: list[Scene]
_tmp_old_sub_scenes: list[Scene]
def __init__(self, window: Window) -> None:
self.window = window
self._sub_scenes = {}
self._current_sub_scenes = []
self._tmp_new_sub_scenes = []
self._tmp_old_sub_scenes = []
def inner_draw(self) -> None:
if len(self._tmp_new_sub_scenes) > 0:
for scene in self._tmp_new_sub_scenes:
if scene not in self._current_sub_scenes:
self._current_sub_scenes.append(scene)
scene.activate()
self._tmp_new_sub_scenes.clear()
if len(self._tmp_old_sub_scenes) > 0:
for scene in self._tmp_old_sub_scenes:
if scene in self._current_sub_scenes:
self._current_sub_scenes.remove(scene)
scene.deactivate()
self._tmp_old_sub_scenes.clear()
self.draw()
for scene in self._current_sub_scenes:
scene.inner_draw()
@abstractmethod
def draw(self) -> None:
pass
def activate(self) -> None:
for scene in self._current_sub_scenes:
self.window.push_handlers(scene)
scene.activate()
def deactivate(self) -> None:
for scene in self._current_sub_scenes:
self.window.remove_handlers(scene)
scene.deactivate()
def update(self, dt: float) -> None:
for scene in self._current_sub_scenes:
scene.update(dt)
# Controller event handlers:
def on_dpad_motion(
self,
controller: Controller,
dpleft: bool,
dpright: bool,
dpup: bool,
dpdown: bool,
) -> None:
pass
def on_button_press(self, controller: Controller, button: str) -> int | None:
pass
def on_button_release(self, controller: Controller, button: str) -> int | None:
pass
def on_stick_motion(
self, controller: Controller, stick: str, xvalue: float, yvalue: float
) -> int | None:
pass
# Keyboard event handlers:
def on_key_press(self, symbol: int, modifiers: int) -> int | None:
pass
def on_key_release(self, symbol: int, modifiers: int) -> int | None:
pass
def add_scene(self, name: str, scene: Scene) -> None:
self._sub_scenes[name] = scene
def remove_scene(self, name: str) -> None:
del self._sub_scenes[name]
def is_overlay_scene(self, scene_name: str) -> bool:
scene = self._sub_scenes[scene_name]
return scene in self._current_sub_scenes or scene in self._tmp_new_sub_scenes
def add_overlay_scene(self, scene_name: str) -> None:
assert scene_name in self._sub_scenes, "Sub Scene not found! Did you add it?"
scene = self._sub_scenes[scene_name]
self.window.push_handlers(scene)
self._tmp_new_sub_scenes.append(scene)
def remove_overlay_scene(self, scene_name: str) -> None:
assert scene_name in self._sub_scenes, "Sub Scene not found! Did you add it?"
assert self.is_overlay_scene(scene_name), "Sub Scene not activated!"
scene = self._sub_scenes[scene_name]
if scene in self._current_sub_scenes:
self.window.remove_handlers(scene)
self._tmp_old_sub_scenes.append(scene)
if scene in self._tmp_new_sub_scenes:
self._tmp_new_sub_scenes.remove(scene)
class StubScene(Scene):
def draw(self) -> None:
pass
class SceneManager:
window: Window
current_scene: Scene | None
overlay_scene: Scene | None
_scenes: dict[str, Scene]
_tmp_scene: str | None
_tmp_overlay_scene: str | None
def __init__(self, window: Window) -> None:
self.window = window
self.window.on_draw = self._on_draw
self.stats = []
self._scenes = {}
self.current_scene = None
self.overlay_scene = None
self._tmp_scene = None
self._tmp_overlay_scene = None
self.last_draw = None
self.last_update = None
# Instantiation a ControllerManager to handle hot-plugging:
self.controller = None
self.controller_manager = ControllerManager()
self.controller_manager.on_connect = self.on_controller_connect
self.controller_manager.on_disconnect = self.on_controller_disconnect
# Initialize Controller if it's connected:
controllers: list[Controller] = self.controller_manager.get_controllers()
if controllers:
self.on_controller_connect(controllers[0])
# Initialize Keystate helper
self.keys = key.KeyStateHandler()
window.push_handlers(self.keys)
def _on_draw(self) -> None:
with client.game_state.draw_lock:
a = time.time()
# if self.last_draw:
# if 1 / (a - self.last_draw) < ((TARGET_FPS) * 0.7):
# tracer = get_tracer()
# if tracer:
# tracer.log_instant("LAAAAG", 1 / (a - self.last_draw), scope="g")
# print("LAAAAG", 1 / (a - self.last_draw))
# for stat in self.stats:
# print(stat)
if self._tmp_scene:
self._set_scene()
if self._tmp_overlay_scene:
self._set_overlay_scene()
self.window.clear()
if self.current_scene:
self.current_scene.inner_draw()
if self.overlay_scene:
self.overlay_scene.inner_draw()
self.last_draw = time.time()
dt = self.last_draw - a
# print(dt)
if dt > 1 / (TARGET_FPS * 0.9):
# if get_tracer():
# get_tracer().log_instant("Frame long draw", dt, scope="g")
print("frame took too long to draw :(", dt)
def on_controller_connect(self, controller: Controller) -> None:
if not self.controller:
controller.open()
self.controller = controller
self.controller.push_handlers(self.current_scene)
self.controller.push_handlers(self.overlay_scene)
else:
print(f"A Controller is already connected: {self.controller}")
def on_controller_disconnect(self, controller: Controller) -> None:
if self.controller and self.controller == controller:
self.controller.remove_handlers(self.current_scene)
self.controller.remove_handlers(self.overlay_scene)
self.controller = None
def add_scene(self, name: str, scene: Scene) -> None:
self._scenes[name] = scene
def _set_scene(self) -> None:
if self.current_scene:
self.current_scene.deactivate()
self.window.remove_handlers(self.current_scene)
if self.controller:
self.controller.remove_handlers(self.current_scene)
if not self._tmp_scene:
self.current_scene = None
return
assert self._tmp_scene in self._scenes, "Scene not found! Did you add it?"
self.current_scene = self._scenes[self._tmp_scene]
self.current_scene.activate()
self.window.push_handlers(self.current_scene)
if self.controller:
self.controller.push_handlers(self.current_scene)
self._tmp_scene = None
def set_scene(self, scene: str | None) -> None:
if scene:
self._tmp_scene = scene
else:
self._tmp_scene = ""
def _set_overlay_scene(self) -> None:
if self.overlay_scene:
self.overlay_scene.deactivate()
self.window.remove_handlers(self.overlay_scene)
if self.controller:
self.controller.remove_handlers(self.overlay_scene)
if self._tmp_overlay_scene is None:
self.overlay_scene = self._tmp_overlay_scene
return
assert (
self._tmp_overlay_scene in self._scenes
), "Scene not found! Did you add it?"
self.overlay_scene = self._scenes[self._tmp_overlay_scene]
self.overlay_scene.activate()
self.window.push_handlers(self.overlay_scene)
if self.controller:
self.controller.push_handlers(self.overlay_scene)
self._tmp_overlay_scene = None
def set_overlay_scene(self, scene: str | None) -> None:
if scene:
self._tmp_overlay_scene = scene
else:
self._tmp_overlay_scene = ""
def update(self, dt: float) -> None:
with client.game_state.update_lock:
a = time.time()
# if self.last_update:
# divider = a - self.last_update
# if divider > 1 / (TARGET_UPS * 0.5):
# print("UPS LAAAAG", divider)
# for stat in self.stats:
# print(stat)
if self.current_scene:
self.current_scene.update(dt)
if self.overlay_scene:
self.overlay_scene.update(dt)
self.last_update = time.time()
dt = self.last_update - a
# print(dt)
if dt > 1 / (TARGET_UPS * 0.9):
# if get_tracer():
# get_tracer().log_instant("Frame long draw", dt, scope="g")
print("update took too long to process :(", dt)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/hud.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/hud.py | from typing import TYPE_CHECKING, cast
from pyglet.graphics import Batch, Group
from pyglet.gui import Frame
from pyglet.image import Animation, Texture
from pyglet.text import Label
from pyglet.window import Window
import client
from client.game.nearest_sprite import NearestSprite
from client.game.ui import get_ui_grid
from client.game.ui.button import ImageButton
from client.game.ui.tilebox import TileBox
from client.scenes.scenemanager import Scene
from shared.gen.messages.v1 import User
if TYPE_CHECKING:
from client.scenes.game import Game
class Inventory(Group):
height: int = 32 * 3
def __init__(
self,
batch: Batch | None = None,
frame: Frame | None = None,
order: int = 0,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self.inventory_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 1 + 51 : 61 * 1 + 54],
duration=0.01,
),
x=-1,
y=0,
scale_x=2,
scale_y=2,
group=self,
)
self.inventory_button.set_handler("on_press", self._on_press)
self.bg = TileBox(
x=0,
y=0,
width=0,
height=self.height,
tile_size=32,
tile_offset_x=3,
tile_offset_y=10,
group=self,
)
self.frame = frame
def deactivate(self) -> None:
if self.frame:
self.frame.remove_widget(self.inventory_button)
def _on_press(self) -> None:
cast("Game", client.scene_manager.current_scene).display_inventory()
def on_resize(self, parent_height: int, window: Window) -> None:
if self.inventory_button and self.bg:
if self.frame and self.inventory_button._image.x != -1:
self.frame.remove_widget(self.inventory_button)
self.inventory_button.x = window.width - self.inventory_button.width * 2
self.inventory_button.y = (
parent_height / 2 - self.inventory_button.height / 2
)
if self.frame:
self.frame.add_widget(self.inventory_button)
self.bg.x = self.inventory_button.x - (32)
self.bg.y = 0
self.bg.width = 32 * 3
def draw(self) -> None:
if self.bg:
self.bg.draw()
if self.inventory_button:
self.inventory_button.draw()
def __del__(self) -> None:
if self.frame:
self.frame.remove_widget(self.inventory_button)
del self.inventory_button
self.inventory_button = None
class Logout(Group):
height: int = 32 * 3
def __init__(
self,
batch: Batch | None = None,
frame: Frame | None = None,
order: int = 0,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self.logout_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 3 + 48 : 61 * 3 + 51],
duration=0.01,
),
x=-1,
y=0,
scale_x=2,
scale_y=2,
group=self,
)
self.logout_button.set_handler("on_press", self._on_press)
self.bg = TileBox(
x=0,
y=0,
width=0,
height=self.height,
tile_size=32,
tile_offset_x=3,
tile_offset_y=10,
group=self,
)
self.frame = frame
def _on_press(self) -> None:
cast("Game", client.scene_manager.current_scene).logout()
def on_resize(self, parent_height: int, window: Window):
if self.logout_button and self.bg:
if self.frame and self.logout_button._image.x != -1:
self.frame.remove_widget(self.logout_button)
self.logout_button.x = window.width - self.logout_button.width * 2
self.logout_button.y = window.height - parent_height / 2
if self.frame:
self.frame.add_widget(self.logout_button)
self.bg.x = self.logout_button.x - (32)
self.bg.y = self.logout_button.y - (32)
self.bg.width = 32 * 3
def draw(self) -> None:
if self.bg:
self.bg.draw()
if self.logout_button:
self.logout_button.draw()
def __del__(self) -> None:
del self.logout_button
self.logout_button = None
def deactivate(self) -> None:
if self.frame:
self.frame.remove_widget(self.logout_button)
class Coins(Group):
coins: int = 1337
height: int = 32 * 3
def __init__(
self, batch: Batch | None = None, order: int = 0, parent: Group | None = None
) -> None:
super().__init__(order, parent)
self.label = Label(
"",
x=0,
y=0,
batch=batch,
group=self,
anchor_y="center",
anchor_x="right",
font_size=16,
color=(80, 0, 0, 255),
)
self.bg = TileBox(
x=0,
y=0,
width=0,
height=self.height,
tile_size=32,
tile_offset_x=3,
tile_offset_y=10,
group=self,
)
self.coin = NearestSprite(
cast(Texture, get_ui_grid()[61 * 23 + 13]),
x=0,
y=0,
origin=(
cast(int, get_ui_grid().item_width) / 2,
cast(int, get_ui_grid().item_height) / 2,
),
group=self,
)
self.coin.scale = 2
def update(self, dt: float) -> None:
match client.game_state.my_user:
case User() as u:
if self.label:
self.label.text = str(u.money)
case _:
pass
def on_resize(self, parent_height: int, window: Window):
if self.label:
self.label.text = f"{self.coins}"
width = (
self.label.content_width + (-self.label.content_width) % 32
) + 32 * 3
self.label.y = window.height - parent_height // 2
self.label.x = width - 32 - 4
if self.bg:
self.bg.y = window.height - self.height
self.bg.width = width
if self.coin:
self.coin.x = 32 + cast(int, get_ui_grid().item_width) / 2
self.coin.y = (
window.height
- self.height // 2
- cast(int, get_ui_grid().item_height) / 2
)
def draw(self):
if self.bg:
self.bg.draw()
if self.coin:
self.coin.draw()
def __del__(self):
del self.bg
self.bg = None
del self.coin
self.coin = None
del self.label
self.label = None
class Health(Group):
health: int = 1337
height: int = 32 * 3
def __init__(
self, batch: Batch | None = None, order: int = 0, parent: Group | None = None
) -> None:
super().__init__(order, parent)
self.label = Label(
"",
x=0,
y=0,
batch=batch,
group=self,
anchor_y="center",
anchor_x="right",
font_size=16,
color=(80, 0, 0, 255),
)
self.bg = TileBox(
x=0,
y=0,
width=0,
height=self.height,
tile_size=32,
tile_offset_x=3,
tile_offset_y=10,
group=self,
)
self.heart = NearestSprite(
img=cast(Texture, get_ui_grid()[61 * 10 + 11]),
x=0,
y=0,
origin=(
cast(int, get_ui_grid().item_width) / 2,
cast(int, get_ui_grid().item_height) / 2,
),
group=self,
)
self.heart.scale = 2
def update(self, dt: float) -> None:
match client.game_state.my_user:
case User() as u:
if self.label:
self.label.text = str(u.health)
case _:
pass
def on_resize(self, parent_height: int, window: Window):
if self.label:
self.label.text = f"{self.health}"
width = (
self.label.content_width + (-self.label.content_width) % 32
) + 32 * 3
self.label.y = window.height - parent_height // 2 - 64
self.label.x = width - 32 - 4
if self.bg:
self.bg.y = window.height - self.height - 64
self.bg.width = width
if self.heart:
self.heart.x = 32 + cast(int, get_ui_grid().item_width) / 2
self.heart.y = (
window.height
- self.height // 2
- cast(int, get_ui_grid().item_height) / 2
- 64
)
def draw(self):
if self.bg:
self.bg.draw()
if self.heart:
self.heart.draw()
def __del__(self):
del self.bg
self.bg = None
del self.heart
self.heart = None
del self.label
self.label = None
class UsernameLabel(Group):
height: int = 32 * 3
name: str = ""
def __init__(
self, batch: Batch | None = None, order: int = 0, parent: Group | None = None
) -> None:
match client.game_state.my_user:
case User() as u:
self.name = u.username
case _:
pass
super().__init__(order, parent)
self.label = Label(
"",
x=0,
y=0,
batch=batch,
group=self,
anchor_y="center",
anchor_x="center",
font_size=16,
color=(80, 0, 0, 255),
)
self.bg = TileBox(
x=0,
y=0,
width=0,
height=self.height,
tile_size=32,
tile_offset_x=3,
tile_offset_y=10,
group=self,
)
def on_resize(self, parent_height: int, window: Window):
if self.label and self.bg:
self.label.text = self.name
self.label.x = window.width // 2
self.label.y = window.height - parent_height // 2
width = (
self.label.content_width + (-self.label.content_width) % 32
) + 32 * 3
self.bg.x = window.width // 2 - width // 2
self.bg.y = window.height - self.height
self.bg.width = width
def draw(self):
if self.bg:
self.bg.draw()
def __del__(self):
del self.label
self.label = None
del self.bg
self.bg = None
class HudTop(Group):
height: int = 32 * 3
def __init__(
self,
batch: Batch | None = None,
frame: Frame | None = None,
order: int = 0,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self.username = UsernameLabel(batch)
self.coins = Coins(batch)
self.health = Health(batch=batch)
self.logout = Logout(batch, frame)
def on_resize(self, window: Window):
if self.username:
self.username.on_resize(self.height, window)
if self.coins:
self.coins.on_resize(self.height, window)
if self.health:
self.health.on_resize(self.height, window)
if self.logout:
self.logout.on_resize(self.height, window)
def update(self, dt: float) -> None:
if self.coins:
self.coins.update(dt)
if self.health:
self.health.update(dt)
def draw(self):
if self.username:
self.username.draw()
if self.coins:
self.coins.draw()
if self.health:
self.health.draw()
if self.logout:
self.logout.draw()
def __del__(self):
del self.username
self.username = None
del self.coins
self.coins = None
del self.logout
self.logout = None
del self.health
self.health = None
def deactivate(self) -> None:
if self.logout:
self.logout.deactivate()
class HudBottom(Group):
height: int = 32 * 3
def __init__(
self,
batch: Batch | None = None,
frame: Frame | None = None,
order: int = 0,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self.inventory = Inventory(batch=batch, frame=frame, parent=self)
def on_resize(self, window: Window):
if self.inventory:
self.inventory.on_resize(self.height, window)
def update(self, dt: float) -> None:
pass
def draw(self):
if self.inventory:
self.inventory.draw()
def __del__(self):
del self.inventory
self.inventory = None
def deactivate(self) -> None:
if self.inventory:
self.inventory.deactivate()
class Hud(Scene):
top: HudTop | None
bottom: HudBottom | None
def __init__(self, window: Window) -> None:
super().__init__(window)
self.frame = Frame(window, order=4)
self.top = None
self.bottom = None
self.batch = None
self.window = window
def activate(self) -> None:
self.batch = Batch()
self.top = HudTop(self.batch, self.frame)
self.top.on_resize(self.window)
self.bottom = HudBottom(self.batch, self.frame)
self.bottom.on_resize(self.window)
def draw(self) -> None:
if self.top:
self.top.draw()
if self.bottom:
self.bottom.draw()
if self.batch:
self.batch.draw()
def deactivate(self) -> None:
if self.top:
self.top.deactivate()
del self.top
self.top = None
if self.bottom:
self.bottom.deactivate()
del self.bottom
self.bottom = None
del self.batch
self.batch = None
return super().deactivate()
def update(self, dt: float) -> None:
if self.top:
self.top.update(dt)
if self.bottom:
self.bottom.update(dt)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/intro.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/intro.py | from pathlib import Path
from typing import cast
from pyglet import image
from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.image import ImageData
from pyglet.sprite import Sprite
from pyglet.text import Label
from pyglet.window import Window
import client
from client.scenes.scenemanager import Scene
class Intro(Scene):
status: str
def get_background_image(self) -> ImageData:
return cast(
ImageData,
image.load(Path(client.PATH, "assets/intro_background.png")),
)
def __init__(self, window: Window) -> None:
super().__init__(window)
self.frame = Frame(window, order=4)
self.batch = Batch()
self.status = ""
self.background_image = self.get_background_image()
self.background = Sprite(img=self.background_image, x=0, y=0, batch=self.batch)
self.press_key_label = Label(
text="Press any key to continue ...",
font_name="Consolas",
font_size=14,
x=600,
y=100,
anchor_x="center",
anchor_y="center",
multiline=True,
width=500,
batch=self.batch,
)
self.game_logo = Sprite(
img=image.load_animation(Path(client.PATH, "assets/game_logo.gif")),
x=100,
y=280,
batch=self.batch,
)
def activate(self) -> None:
super().activate()
def deactivate(self) -> None:
super().deactivate()
def draw(self) -> None:
self.batch.draw()
def on_key_press(self, symbol: int, modifiers: int) -> bool | None:
client.scene_manager.set_scene(scene="mainmenu")
def update(self, dt: float) -> None:
pass
# self.status_label.text = self.status
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/globals.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/globals.py | from pyglet.text import Label
from pyglet.window import FPSDisplay, Window
from client.scenes.scenemanager import Scene
from shared.gen.messages.v1 import Error, ErrorType
class Globals(Scene):
error_message: str
def __init__(self, window: Window) -> None:
super().__init__(window)
self.fps_display = FPSDisplay(window=window, color=(255, 0, 0, 255))
self.error_message = ""
self.error_label = Label(
self.error_message,
x=300,
y=10,
color=(255, 0, 0, 255),
font_size=15,
)
def on_error(self, error: Error) -> None:
self.error_message = f"{ErrorType(error.type).name}: {error.message}"
def draw(self) -> None:
self.fps_display.draw()
# self.error_label.draw()
def update(self, dt: float) -> None:
return
self.error_label.text = self.error_message
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/test.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/test.py | from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.window import Window
from client.game.ui.button import TextButton
from client.game.ui.dialog import Dialog
from client.game.ui.dropdown import Dropdown
from client.game.ui.input import PasswordInput
from client.scenes.scenemanager import Scene
class TestScene(Scene):
def __init__(self, window: Window):
self.frame = Frame(window, order=4)
self.batch = Batch()
self._text_button = TextButton("ASDFKKKk", x=100, y=100, batch=self.batch)
self._text_button.set_handler("on_press", lambda: None)
self._dropdown = Dropdown(
x=200, y=200, entries=["A", "B", "CCC"], batch=self.batch
)
self._dialog = Dialog(
400,
200,
400,
200,
text=[
"Hello World.",
"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.",
"123",
],
batch=self.batch,
)
def text_entry_handler(text: str) -> None:
print(text)
self._input = PasswordInput(
"value",
500,
100,
200,
batch=self.batch,
text_color=(255, 0, 0, 255),
caret_color=(0, 0, 0, 255),
color=(0, 0, 0, 0),
)
self._input.set_handler("on_commit", text_entry_handler)
def activate(self) -> None:
self.frame.add_widget(self._input)
self.frame.add_widget(widget=self._dialog)
self.frame.add_widget(self._dropdown)
self.frame.add_widget(self._text_button)
super().activate()
def deactivate(self) -> None:
self.frame.remove_widget(self._input)
self.frame.remove_widget(widget=self._dialog)
self.frame.remove_widget(self._dropdown)
self.frame.remove_widget(self._text_button)
super().deactivate()
def draw(self):
self._text_button.draw()
self._dialog.draw()
self._input.draw()
self.batch.draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/game.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/game.py | from datetime import datetime, timedelta
from itertools import chain
from typing import Callable, Dict, cast
from pyglet.event import EVENT_HANDLED
from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.window import Window
from pyglet.window.key import ESCAPE, SPACE
import client
from client.game.area import Area
from client.game.camera import CenteredCamera
from client.game.entities.enemy import Enemy
from client.game.entities.entity import ServerManagedEntity
from client.game.entities.npc import NPC
from client.game.entities.other_player import OtherPlayer
from client.game.entities.player import Player
from client.game.map import ClientMap
from client.game.pickupable import Pickupable
from client.game.sound_manager import SoundManager
from client.scenes.dialog import DialogScene
from client.scenes.dino_runner import DinoRunner
from client.scenes.hud import Hud
from client.scenes.input import InputScene
from client.scenes.inventory import Inventory
from client.scenes.scenemanager import Scene
from client.scenes.shop import Shop
from shared.collison import point_in_poly
from shared.constants import VIEW_DISTANCE_SQ
from shared.gen.messages.v1 import (
Activity,
Interact,
InteractStatus,
InteractType,
LoggedIn,
Logout,
ObjectAsset,
Objects,
ObjectType,
Ping,
SessionType,
ShopInteract,
User,
Users,
)
class Game(Scene):
def __init__(self, window: Window) -> None:
super().__init__(window)
self.batch = Batch()
self.game_batch = Batch()
self.frame = Frame(window, order=4)
self.sound_manager = SoundManager()
self.in_interaction_key = False
# self.sound_manager.set_background_music("client/assets/determination.wav")
# self.sound_manager.play_background_music()
self.map = ClientMap()
self.camera = CenteredCamera(window, None, None, scroll_speed=1)
self.player: Player = Player()
self.other_players: Dict[str, OtherPlayer] = {}
self.npcs: Dict[str, NPC] = {}
self.enemies: Dict[str, Enemy] = {}
self.areas: Dict[str, Area] = {}
self.pickupable: Dict[str, Pickupable] = {}
self.input = InputScene(window=window)
self.add_scene("input", self.input)
self.dialog = DialogScene(window=window)
self.add_scene("dialog", self.dialog)
self.shop = Shop(window=window)
self.add_scene("shop", self.shop)
self.inventory = Inventory(window=window)
self.add_scene("inventory", self.inventory)
self.hud = Hud(window=window)
self.add_scene("hud", self.hud)
self.add_overlay_scene("hud")
client.global_connection.ping_handler += self._on_ping
client.global_connection.users_handler += self._on_users
client.global_connection.logout_handler += self._on_player_logout
client.global_connection.objects_handler += self._on_object_handler
client.global_connection.login_handler += self._on_login_handler
client.global_connection.interact_handler += self._on_interact_handler
def remove_input(self) -> None:
self.player.can_move = True
if self.is_overlay_scene("input"):
self.remove_overlay_scene("input")
if not self.is_overlay_scene("hud"):
self.add_overlay_scene("hud")
def display_input(self, cb: Callable[[str], None] | None = None) -> None:
self.player.can_move = False
self.player.activity = Activity.ACTIVITY_IDLE
self.input.callback = cb
if self.is_overlay_scene("hud"):
self.remove_overlay_scene("hud")
if self.is_overlay_scene(scene_name="dialog"):
self.remove_overlay_scene("dialog")
self.add_overlay_scene("input")
input_scene = cast(InputScene, self._sub_scenes["input"])
input_scene.input._focus = True
def remove_dialog(self) -> None:
self.player.can_move = True
if self.is_overlay_scene("dialog"):
self.remove_overlay_scene("dialog")
if not self.is_overlay_scene("hud"):
self.add_overlay_scene("hud")
def display_dialog(
self, text: list[str], cb: Callable[[], None] | None = None
) -> None:
self.player.can_move = False
self.player.activity = Activity.ACTIVITY_IDLE
self.dialog.callback = cb
self.dialog.set_text(text)
self.dialog.next_text()
if self.is_overlay_scene("hud"):
self.remove_overlay_scene("hud")
if not self.is_overlay_scene("dialog"):
self.add_overlay_scene("dialog")
# self.dialog.start(text, cb=cb)
def remove_shop(self) -> None:
if self.shop.uuid in self.npcs:
self.npcs[self.shop.uuid].stop_interaction()
self.player.can_move = True
if self.is_overlay_scene("shop"):
self.remove_overlay_scene("shop")
if not self.is_overlay_scene("hud"):
self.add_overlay_scene("hud")
def display_shop(
self, items: list[ShopInteract], uuid: str, cb: Callable[[], None] | None = None
) -> None:
self.player.can_move = False
self.player.activity = Activity.ACTIVITY_IDLE
self.shop.start(items, uuid, cb=cb)
self.remove_overlay_scene("hud")
self.add_overlay_scene("shop")
def remove_inventory(self) -> None:
self.player.can_move = True
if self.is_overlay_scene("inventory"):
self.remove_overlay_scene("inventory")
if not self.is_overlay_scene("hud"):
self.add_overlay_scene("hud")
def display_inventory(self) -> None:
if client.game_state.my_user is None:
return
self.player.can_move = False
self.player.activity = Activity.ACTIVITY_IDLE
self.inventory.set_inventory_items(client.game_state.my_user.inventory)
self.remove_overlay_scene("hud")
self.add_overlay_scene("inventory")
def start_runner(self, uuid: str) -> None:
client.scene_manager.set_scene(scene="dino_runner")
runner = cast(DinoRunner, client.scene_manager._scenes["dino_runner"])
runner.uuid = uuid
def activate(self):
if client.game_state.my_user:
self.player.x = client.game_state.my_user.coords.x
self.player.y = client.game_state.my_user.coords.y
self.player._attacking = False
for n in self.npcs.values():
n.stop_interaction()
self.in_interaction_key = False
super().activate()
def deactivate(self) -> None:
super().deactivate()
def _entity_in_view_distance(self, entity: ServerManagedEntity) -> bool:
e = client.game_state.objects[entity.uuid][1]
return (abs(self.player.x - e.coords.x) ** 2) + (
abs(self.player.y - e.coords.y) ** 2
) <= VIEW_DISTANCE_SQ
def _other_players_in_view_distance(self, entity: ServerManagedEntity) -> bool:
e = client.game_state.users[entity.uuid]
return (abs(self.player.x - e.coords.x) ** 2) + (
abs(self.player.y - e.coords.y) ** 2
) <= VIEW_DISTANCE_SQ
def draw(self) -> None:
with self.camera:
self.map.draw(self.camera)
entities = chain(
filter(
self._entity_in_view_distance,
chain(
self.npcs.values(),
self.enemies.values(),
self.pickupable.values(),
),
),
filter(
self._other_players_in_view_distance, self.other_players.values()
),
[self.player],
)
for entity in sorted(entities, key=lambda entity: entity.y):
entity.draw()
self.game_batch.draw()
self.batch.draw()
def _on_interact_handler(self, interact: Interact) -> None:
match interact.type:
case InteractType.INTERACT_TYPE_TEXT:
match interact.status:
case InteractStatus.INTERACT_STATUS_START:
npc = self.npcs[interact.uuid]
self.display_dialog([interact.text], cb=npc.interact)
case InteractStatus.INTERACT_STATUS_UPDATE:
if self.is_overlay_scene("dialog"):
self.dialog.append_text(interact.text)
else:
npc = self.npcs[interact.uuid]
self.display_dialog([interact.text], cb=npc.interact)
case InteractStatus.INTERACT_STATUS_STOP:
self.npcs[interact.uuid].stop_interaction()
self.remove_dialog()
case InteractStatus.INTERACT_STATUS_UNSPECIFIED:
assert False
case InteractType.INTERACT_TYPE_RUNNER:
match interact.status:
case InteractStatus.INTERACT_STATUS_START:
self.start_runner(interact.uuid)
case InteractStatus.INTERACT_STATUS_UPDATE:
print("RUNNER UPDATE")
case InteractStatus.INTERACT_STATUS_STOP:
print("RUNNER STOP")
case InteractStatus.INTERACT_STATUS_UNSPECIFIED:
assert False
case InteractType.INTERACT_TYPE_SHOP:
match interact.status:
case InteractStatus.INTERACT_STATUS_START:
npc = self.npcs[interact.uuid]
self.display_shop(interact.shop, interact.uuid, cb=npc.interact)
case InteractStatus.INTERACT_STATUS_UPDATE:
self.shop.set_shop_items(interact.shop, interact.uuid)
case InteractStatus.INTERACT_STATUS_STOP:
self.remove_shop()
case InteractStatus.INTERACT_STATUS_UNSPECIFIED:
assert False
case InteractType.INTERACT_TYPE_CUT_OUT:
match interact.status:
case InteractStatus.INTERACT_STATUS_START:
self.camera.cut_out = True
case InteractStatus.INTERACT_STATUS_UPDATE:
self.camera.cut_out = True
case InteractStatus.INTERACT_STATUS_STOP:
self.camera.cut_out = False
case InteractStatus.INTERACT_STATUS_UNSPECIFIED:
assert False
case InteractType.INTERACT_TYPE_LICENSE:
npc = self.npcs[interact.uuid]
self.display_input(cb=npc.interact)
case _:
pass
def _on_login_handler(self, login: LoggedIn) -> None:
if login.success:
self.player.interact_distance = login.interact_distance
self.player.set_assets(login.assets)
if login.type == SessionType.SESSION_TYPE_FREE_CAM:
if self.is_overlay_scene("hud"):
self.remove_overlay_scene("hud")
def _on_object_asset_handler(self, object_asset: ObjectAsset) -> None:
if object_asset.object_uuid in self.npcs:
n = self.npcs[object_asset.object_uuid]
assert (
object_asset.type == ObjectType.OBJECT_TYPE_NPC
), "NOT IMPLEMENTED. Got: " + str(object_asset.type)
n.label = object_asset.name
n.interactable = object_asset.interactable
n.interact_distance = object_asset.interact_distance
n.set_assets(object_asset.assets)
if object_asset.object_uuid in self.other_players:
p = self.other_players[object_asset.object_uuid]
p.set_assets(object_asset.assets)
if object_asset.object_uuid in self.enemies:
e = self.enemies[object_asset.object_uuid]
assert (
object_asset.type == ObjectType.OBJECT_TYPE_ENEMY
), "NOT IMPLEMENTED. Got: " + str(object_asset.type)
e.set_assets(assets=object_asset.assets)
def _on_object_handler(self, objects: Objects) -> None:
for o in objects.objects:
client.game_state.objects[o.uuid] = (
client.game_state.objects[o.uuid][1]
if o.uuid in client.game_state.objects
else o,
o,
)
if o.type == ObjectType.OBJECT_TYPE_UNSPECIFIED:
pass # Do nothing for now
if o.type == ObjectType.OBJECT_TYPE_AREA:
if o.remove:
del self.areas[o.uuid]
else:
self.areas[o.uuid] = Area(o.uuid, o.area)
elif o.type == ObjectType.OBJECT_TYPE_NPC:
if o.remove and o.uuid not in self.npcs:
del self.npcs[o.uuid]
elif o.uuid not in self.npcs:
self.npcs[o.uuid] = NPC(
uuid=o.uuid,
batch=self.game_batch,
)
client.global_connection.get_object_asset(
o.uuid, self._on_object_asset_handler
)
elif o.type == ObjectType.OBJECT_TYPE_ENEMY:
if o.remove and o.uuid in self.enemies:
del self.enemies[o.uuid]
elif o.uuid not in self.enemies:
enemy_data = o.enemy_info
assert enemy_data is not None, "Enemy object without enemy data!"
self.enemies[o.uuid] = Enemy(
uuid=o.uuid,
health=enemy_data.health,
health_max=enemy_data.health_max,
batch=self.game_batch,
last_attack=enemy_data.last_attack,
)
client.global_connection.get_object_asset(
o.uuid, self._on_object_asset_handler
)
elif o.type == ObjectType.OBJECT_TYPE_PICKUPABLE:
if o.remove and o.uuid in self.pickupable:
del self.pickupable[o.uuid]
elif o.uuid not in self.pickupable:
self.pickupable[o.uuid] = Pickupable(
uuid=o.uuid,
item=o.pickupable,
x=o.coords.x,
y=o.coords.y,
)
def _on_player_logout(self, logout: Logout) -> None:
if client.game_state.is_authenticated():
if (
client.game_state.my_user
and logout.user.uuid == client.game_state.my_user.uuid
):
self.logout()
else:
if logout.user.uuid in self.other_players:
del self.other_players[logout.user.uuid]
def _on_ping(self, ping: Ping) -> None:
client.game_state.last_ping = ping.time
def _on_users(self, users: Users) -> None:
u: Dict[str, User] = {user.uuid: user for user in users.users}
if client.game_state.is_authenticated():
if client.game_state.my_user:
my_uuid = client.game_state.my_user.uuid
if my_uuid in u:
coords = u[my_uuid].coords
self.player.x = coords.x
self.player.y = coords.y
client.game_state.my_user = u[my_uuid]
del u[my_uuid]
new_players = u.keys() - self.other_players.keys()
for uuid, user in u.items():
if len(user.inventory) > 0:
print(user.inventory)
client.game_state.users[uuid] = user
for new_player in new_players:
self.other_players[new_player] = OtherPlayer(
uuid=u[new_player].uuid,
batch=self.game_batch,
)
client.global_connection.get_object_asset(
u[new_player].uuid, self._on_object_asset_handler
)
def update(self, dt: float) -> None:
online_time = datetime.now() - timedelta(minutes=1)
if client.game_state.last_ping.timestamp() < online_time.timestamp():
self.logout()
self.player.update(dt)
self.camera.position = (self.player.x, self.player.y)
if self.player.coords_dirty:
client.global_connection.move(
self.player.x,
self.player.y,
self.player.rotation,
)
self.player.coords_dirty = False
entities = chain(
filter(
self._entity_in_view_distance,
chain(
self.npcs.values(),
self.enemies.values(),
self.pickupable.values(),
),
),
filter(self._other_players_in_view_distance, self.other_players.values()),
)
for e in entities:
e.update(dt)
if (
not client.game_state.my_user is None
and client.game_state.my_user.health < 0
):
client.global_connection.logout()
client.game_state.logout()
client.scene_manager.set_scene(scene="game_over")
return super().update(dt)
def on_key_release(self, symbol: int, modifiers: int) -> int | None:
if symbol == SPACE:
self.in_interaction_key = False
def logout(self) -> None:
client.global_connection.logout()
client.game_state.logout()
exit()
def on_key_press(self, symbol: int, modifiers: int) -> bool | None:
if symbol == ESCAPE:
if self.shop in self._current_sub_scenes:
self.remove_shop()
elif self.inventory in self._current_sub_scenes:
self.remove_inventory()
else:
self.logout()
return EVENT_HANDLED
if symbol == SPACE:
if not self.in_interaction_key:
try:
if self.is_overlay_scene("dialog"):
self.dialog.next_text()
return
if self.is_overlay_scene("input"):
return
for npc in self.npcs.values():
if not npc.interactable:
continue
dx = (self.player.x + self.player.interact_offset[0]) - (
(npc.x + npc.interact_offset[0])
)
dy = (self.player.y + self.player.interact_offset[1]) - (
(npc.y + npc.interact_offset[1])
)
distance_sq = dx**2 + dy**2
if (
distance_sq
< (npc.interact_distance + self.player.interact_distance)
** 2
):
npc.interact()
return
# check for area collision
for area in self.areas.values():
if point_in_poly(self.player.x, self.player.y, area.area):
area.interact()
finally:
self.in_interaction_key = True
def buy(self, item: ShopInteract) -> None:
npc = self.npcs[self.shop.uuid]
npc.in_interaction = False
client.global_connection.interact(
uuid=self.shop.uuid,
status=InteractStatus.INTERACT_STATUS_UPDATE,
shop=[item],
)
self.remove_shop()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/mainmenu.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/scenes/mainmenu.py | from pathlib import Path
from typing import cast
from pyglet import image
from pyglet.graphics import Batch
from pyglet.gui import Frame
from pyglet.image import ImageData
from pyglet.sprite import Sprite
from pyglet.text import Label
from pyglet.window import Window
import client
from client.game.ui.button import TextButton
from client.game.ui.input import PasswordInput, TextInput
from client.scenes.scenemanager import Scene
from shared.gen.messages.v1 import ErrorType, LoggedIn
class MainMenu(Scene):
status: str
def get_background_image(self) -> ImageData:
return cast(
ImageData,
image.load(Path(client.PATH, "assets/main_menu_background.png")),
)
def __init__(self, window: Window, username: str, password: str) -> None:
super().__init__(window)
self.frame = Frame(window, order=4)
self.batch = Batch()
self.status = ""
self.background_image = self.get_background_image()
self.background = Sprite(img=self.background_image, x=0, y=-70)
self.game_logo = Sprite(
img=image.load(Path(client.PATH, "assets/game_logo.gif")),
x=50,
y=250,
batch=self.batch,
)
self.game_logo.width = 900
self.game_logo.height = 314
self.username_label = Label(
"Username", x=300, y=250, batch=self.batch, color=(75, 20, 78, 255)
)
self._input_username = TextInput(
text=username,
x=300,
y=225,
width=200,
batch=self.batch,
text_color=(0, 0, 0, 255),
caret_color=(0, 0, 0, 255),
color=(0, 0, 0, 0),
)
self.password_label = Label(
"Password", x=300, y=200, batch=self.batch, color=(0, 0, 0, 255)
)
self._input_password = PasswordInput(
text=password,
x=300,
y=175,
width=200,
batch=self.batch,
text_color=(0, 0, 0, 255),
caret_color=(0, 0, 0, 255),
color=(0, 0, 0, 0),
)
self.status_label = Label(
self.status, x=300, y=140, batch=self.batch, color=(255, 0, 0, 255)
)
def login():
def login_sucess(l: LoggedIn) -> None:
if l.success:
client.scene_manager.set_scene("game")
else:
match l.error:
case ErrorType.ERROR_TYPE_UNAUTHORIZED:
self.status = "Username or Password doesn't match"
case ErrorType.ERROR_TYPE_TIMEOUT:
self.status = f"You died and are still in the timeout phase"
case ErrorType.ERROR_TYPE_UNSPECIFIED:
self.status = "Unknown error"
case ErrorType.ERROR_TYPE_ALREADY_LOGGED_IN:
self.status = "User already logged in elsewhere or crashed not too long ago."
case _:
self.status = "Unknown error"
username = self._input_username.value
password = self._input_password.value
client.global_connection.login(
username=username, password=password, handler=login_sucess
)
self._text_button = TextButton("Login", x=300, y=70, batch=self.batch)
self._text_button.set_handler("on_press", login)
def activate(self) -> None:
self.window.push_handlers(self._input_password)
self.window.push_handlers(self._input_username)
self.frame.add_widget(self._text_button)
super().activate()
def deactivate(self) -> None:
self.window.remove_handlers(self._input_password)
self.window.remove_handlers(self._input_username)
self.frame.remove_widget(self._text_button)
super().deactivate()
def draw(self) -> None:
self.background.draw()
self._text_button.draw()
self._input_password.draw()
self._input_username.draw()
self.batch.draw()
def update(self, dt: float) -> None:
self.status_label.text = self.status
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/networking/runner.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/networking/runner.py | import logging
import struct
from asyncio import (
IncompleteReadError,
Lock,
StreamReader,
StreamWriter,
open_connection,
)
from multiprocessing.synchronize import Event as EventClass
from typing import Any, cast
import aioprocessing
from client.game.utils import sleep
from shared.gen.messages.v1 import ClientMessage, ServerMessage
class Runner:
host: str
port: int
ssl: bool
reader: StreamReader
writer: StreamWriter
start_connection_lock: Lock
connected: bool
runner_con: aioprocessing.AioQueue # type: ignore
thread_con: aioprocessing.AioQueue # type: ignore
def __init__(
self,
runner_con: aioprocessing.AioQueue, # type: ignore
thread_con: aioprocessing.AioQueue, # type: ignore
host: str,
port: int,
ssl: bool,
) -> None:
self.runner_con = runner_con
self.thread_con = thread_con
self.host = host
self.port = port
self.ssl = ssl
self.start_connection_lock = Lock()
self.connected = False
async def read_message_loop(self, running: EventClass) -> None:
await self._start_connection()
while running.is_set():
try:
size_buf = await self.reader.readexactly(4)
size = struct.unpack("!i", size_buf)[0]
data_buf = await self.reader.readexactly(size)
message = ServerMessage().parse(data_buf)
self.runner_con.put(message.to_pydict())
except (IncompleteReadError, BrokenPipeError):
await sleep(0.1)
async def send_message_loop(self, running: EventClass) -> None:
await self._start_connection()
while running.is_set():
message_dict = cast(dict[str, Any], await self.thread_con.coro_get())
message: ClientMessage = ClientMessage().from_dict(message_dict)
packet = message.SerializeToString()
await self._send_message(client_message=packet)
async def _start_connection(self) -> None:
async with self.start_connection_lock:
if not self.connected or self.writer.is_closing():
sucess = False
while not sucess:
try:
self.reader, self.writer = await open_connection(
host=self.host,
port=self.port,
ssl=self.ssl,
)
sucess = True
self.connected = True
logging.debug("New Connection")
except Exception:
logging.debug("Error establishing connection")
await sleep(delay=0.1)
async def _send_message(self, client_message: bytes) -> None:
await self._start_connection()
message = struct.pack("!i", len(client_message)) + client_message
self.writer.write(message)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/networking/network.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/networking/network.py | import threading
import uuid
from asyncio import Lock, Queue, Task, create_task, iscoroutinefunction
from asyncio.exceptions import IncompleteReadError
from datetime import datetime
from typing import Any, Awaitable, Callable, Dict, Tuple, TypeVar, cast
import aioprocessing
import betterproto
from client.game.state import GameState
from client.game.utils import check_wait, sleep
from shared.gen.messages.v1 import (
AcknowledgeDamage,
AttackEnemy,
ClientMessage,
Coords,
Error,
Interact,
InteractStatus,
LoggedIn,
Login,
Logout,
MapChunkRequest,
MapChunkResponse,
ObjectAsset,
ObjectAssetRequest,
Objects,
Ping,
Runner,
ServerMessage,
ShopInteract,
Users,
)
from shared.lazy import LazyDict
from shared.utils import AsyncLockEventHandler, EventHandler
ServerMessageType = TypeVar(
"ServerMessageType",
bound=ServerMessage.ping.__class__
| ServerMessage.logged_in.__class__
| ServerMessage.users.__class__
| ServerMessage.chunk.__class__
| ServerMessage.error.__class__
| ServerMessage.logout.__class__
| ServerMessage.objects.__class__
| ServerMessage.object_asset.__class__
| ServerMessage.interact.__class__
| ServerMessage.give_damage.__class__,
)
AyncMessageHandlerType = Callable[[ServerMessageType, Lock], Awaitable[None]]
MessageHandlerType = Callable[[ServerMessageType], None]
ErrorHandlerType = Callable[[Error], None]
class Connection:
runner_con: aioprocessing.AioQueue # type: ignore
thread_con: aioprocessing.AioQueue # type: ignore
connected: bool = False
error_handler: ErrorHandlerType
# (ClientMessage, (Handler, ErrorHandler)) If ErrorHandler None, the default error Handler is used
network_queue: Queue[
Tuple[
ClientMessage,
Tuple[
MessageHandlerType[...] | AyncMessageHandlerType[...] | None,
ErrorHandlerType | None,
],
]
]
handlers: Dict[
str,
Tuple[
MessageHandlerType[...] | AyncMessageHandlerType[...] | None,
ErrorHandlerType | None,
],
]
game_state: GameState
start_connection_lock: Lock
task_list: set[Task[None]]
def __init__(
self,
runner_con: aioprocessing.AioQueue, # type: ignore
thread_con: aioprocessing.AioQueue, # type: ignore
error_handler: ErrorHandlerType,
game_state: GameState,
) -> None:
self.runner_con = runner_con
self.thread_con = thread_con
self.error_handler = error_handler
self.network_queue = Queue()
self.handlers = {}
self.game_state = game_state
self.start_connection_lock = Lock()
self.task_list = set()
self.ping_handler = EventHandler()
self.users_handler = EventHandler()
self.logout_handler = EventHandler()
self.objects_handler = EventHandler()
self.login_handler = EventHandler()
self.interact_handler = EventHandler()
self.map_chunk_handler = AsyncLockEventHandler()
async def ping_loop(self, running: threading.Event) -> None:
while running.is_set():
if self.game_state.is_authenticated():
await self.ping()
# await sleep(1)
for _ in range(100):
await sleep(1 / 100)
async def read_message_loop(self, running: threading.Event) -> None:
while running.is_set():
await check_wait()
try:
d: dict[str, Any] = cast(
dict[str, Any], await self.runner_con.coro_get()
)
message: LazyDict = LazyDict(d, ServerMessage)
message_id = message.uuid
match message:
case {"ping": inner_message}:
self.ping_handler(LazyDict(inner_message, Ping))
case {"loggedIn": inner_message}:
self.login_handler(LazyDict(inner_message, LoggedIn))
case {"error": inner_message}:
error = LazyDict(inner_message, Error)
# logging.error(f"{ErrorType(error.type).name} {error.message}")
case {"users": inner_message}:
self.users_handler(LazyDict(inner_message, Users))
case {"logout": inner_message}:
self.logout_handler(LazyDict(inner_message, Logout))
case {"objects": inner_message}:
self.objects_handler(LazyDict(inner_message, Objects))
case {"interact": inner_message}:
self.interact_handler(LazyDict(inner_message, Interact))
case {"chunk": inner_message}:
task = create_task(
self.map_chunk_handler(
LazyDict(inner_message, MapChunkResponse)
),
name="chunk",
)
self.task_list.add(task)
task.add_done_callback(self.task_list.discard)
case {"giveDamage": inner_message}:
self.acknowledge_damage(damage=inner_message["damage"])
case _:
pass
handler = None
error_handler = None
if message_id in self.handlers:
handler, error_handler = self.handlers[message_id]
del self.handlers[message_id]
match message:
case {"error": inner_message}:
error = LazyDict(inner_message, Error)
if error_handler is None:
self.error_handler(cast(Error, error))
else:
error_handler(cast(Error, error))
case {"uuid": _, **inner_message}:
if handler is not None:
key, value = next(inner_message.items().__iter__())
key = betterproto.casing.safe_snake_case(key)
sub_cls = ServerMessage._cls_for(ServerMessage.__dataclass_fields__[key]) # type: ignore
x = LazyDict(value, sub_cls)
if iscoroutinefunction(handler):
task = create_task(handler(x), name=key)
self.task_list.add(task)
task.add_done_callback(self.task_list.discard)
else:
handler(x) # type: ignore
case _:
print("MEH")
except (IncompleteReadError, BrokenPipeError):
await sleep(0.1)
async def send_message_loop(self, running: threading.Event) -> None:
while running.is_set():
message, handler = await self.network_queue.get()
message_id = str(uuid.uuid4())
message.uuid = message_id
self.handlers[message_id] = handler
self.thread_con.put(message.to_dict())
async def ping(
self,
handler: MessageHandlerType[Ping] | None = None,
error_handler: ErrorHandlerType | None = None,
) -> None:
ping = ClientMessage(ping=Ping(time=datetime.now()))
await self.network_queue.put((ping, (handler, error_handler)))
def login(
self,
username: str,
password: str,
handler: MessageHandlerType[LoggedIn] | None = None,
error_handler: ErrorHandlerType | None = None,
) -> None:
login = ClientMessage(login=Login(username=username, password=password))
self.network_queue.put_nowait((login, (handler, error_handler)))
def move(
self,
x: float,
y: float,
rotation: float,
error_handler: ErrorHandlerType | None = None,
) -> None:
coords = ClientMessage(coords=Coords(x=x, y=y, rotation=rotation))
self.network_queue.put_nowait((coords, (None, error_handler)))
def get_chunks(
self,
x: int,
y: int,
handler: AyncMessageHandlerType[MapChunkResponse] | None = None,
error_handler: ErrorHandlerType | None = None,
) -> None:
get_chunk_msg = ClientMessage(chunk_request=MapChunkRequest(x=int(x), y=int(y)))
self.network_queue.put_nowait((get_chunk_msg, (handler, error_handler)))
def get_object_asset(
self,
uuid: str,
handler: MessageHandlerType[ObjectAsset] | None = None,
error_handler: ErrorHandlerType | None = None,
) -> None:
get_object_asset = ClientMessage(
object_asset_request=ObjectAssetRequest(uuid=uuid)
)
self.network_queue.put_nowait((get_object_asset, (handler, error_handler)))
def interact(
self,
uuid: str,
status: InteractStatus,
text: str = "",
shop: list[ShopInteract] = [],
runner: Runner | None = None,
handler: MessageHandlerType[Interact] | None = None,
error_handler: ErrorHandlerType | None = None,
) -> None:
interact = ClientMessage(
interact=Interact(
uuid=uuid,
text=text,
status=status,
shop=shop,
runner=runner if runner is not None else Runner(),
)
)
self.network_queue.put_nowait((interact, (handler, error_handler)))
def acknowledge_damage(
self,
damage: int,
handler: MessageHandlerType[Interact] | None = None,
error_handler: ErrorHandlerType | None = None,
):
acknowledge_damage = ClientMessage(acknowledge_damage=AcknowledgeDamage(damage))
self.network_queue.put_nowait((acknowledge_damage, (handler, error_handler)))
def attack_enemy(
self,
time: datetime,
uuid: str,
damage: int,
handler: MessageHandlerType[Interact] | None = None,
error_handler: ErrorHandlerType | None = None,
):
attack_enemy_msg = ClientMessage(
attack_enemy=AttackEnemy(time=time, uuid=uuid, damage=damage)
)
self.network_queue.put_nowait((attack_enemy_msg, (handler, error_handler)))
def logout(
self,
handler: MessageHandlerType[Interact] | None = None,
error_handler: ErrorHandlerType | None = None,
) -> None:
logout = ClientMessage(logout=Logout())
self.network_queue.put_nowait((logout, (handler, error_handler)))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/networking/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/networking/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/nearest_sprite.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/nearest_sprite.py | from typing import Tuple, TypedDict
import pyglet
from pyglet import graphics
from pyglet.gl import (
GL_CLAMP_TO_EDGE,
GL_NEAREST,
GL_ONE_MINUS_SRC_ALPHA,
GL_SRC_ALPHA,
GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER,
GL_TEXTURE_MIN_FILTER,
GL_TEXTURE_WRAP_S,
GL_TEXTURE_WRAP_T,
GL_TRIANGLES,
glTexParameteri,
)
from pyglet.graphics import Group
from pyglet.graphics.shader import ShaderProgram
from pyglet.image import Animation, Texture
from pyglet.sprite import AdvancedSprite
vertex_source = """#version 150 core
in vec3 translate;
in vec4 colors;
in vec3 tex_coords;
in vec2 scale;
in vec3 position;
in float rotation;
out vec4 vertex_colors;
out vec3 texture_coords;
uniform vec2 origin_scale;
uniform vec2 origin_rotation;
uniform WindowBlock
{
mat4 projection;
mat4 view;
} window;
mat4 m_scale = mat4(1.0);
mat4 m_rotation = mat4(1.0);
mat4 m_translate = mat4(1.0);
mat4 m_origin_scale = mat4(1.0);
mat4 m_neg_origin_scale = mat4(1.0);
mat4 m_origin_rotation = mat4(1.0);
mat4 m_neg_origin_rotation = mat4(1.0);
void main()
{
m_scale[0][0] = scale.x;
m_scale[1][1] = scale.y;
m_translate[3][0] = translate.x;
m_translate[3][1] = translate.y;
m_translate[3][2] = translate.z;
m_origin_scale[3][0] = origin_scale.x;
m_origin_scale[3][1] = origin_scale.y;
m_neg_origin_scale[3][0] = -origin_scale.x;
m_neg_origin_scale[3][1] = -origin_scale.y;
m_origin_rotation[3][0] = origin_rotation.x;
m_origin_rotation[3][1] = origin_rotation.y;
m_neg_origin_rotation[3][0] = -origin_rotation.x;
m_neg_origin_rotation[3][1] = -origin_rotation.y;
m_rotation[0][0] = cos(-radians(rotation));
m_rotation[0][1] = sin(-radians(rotation));
m_rotation[1][0] = -sin(-radians(rotation));
m_rotation[1][1] = cos(-radians(rotation));
gl_Position = window.projection * window.view * m_translate * m_origin_rotation * m_rotation * m_neg_origin_rotation * m_origin_scale * m_scale * m_neg_origin_scale * vec4(position, 1.0);
vertex_colors = colors;
texture_coords = tex_coords;
}
"""
fragment_source = """#version 150 core
in vec4 vertex_colors;
in vec3 texture_coords;
out vec4 final_colors;
uniform sampler2D sprite_texture;
void main()
{
final_colors = texture(sprite_texture, texture_coords.xy) * vertex_colors;
}
"""
def get_default_shader() -> ShaderProgram:
try:
return pyglet.gl.current_context._game_sprite_default_shader # type: ignore
except AttributeError:
_default_vert_shader = graphics.shader.Shader(vertex_source, "vertex")
_default_frag_shader = graphics.shader.Shader(fragment_source, "fragment")
default_shader_program = graphics.shader.ShaderProgram(
_default_vert_shader, _default_frag_shader
)
pyglet.gl.current_context.game_sprite_default_shader = ( # type: ignore
default_shader_program
)
return pyglet.gl.current_context.game_sprite_default_shader # type: ignore
class RequestParams(TypedDict, total=False):
pass
class NearestSprite(AdvancedSprite):
origin: Tuple[float, float]
def __init__(
self,
img: Texture | Animation,
x: int = 0,
y: int = 0,
z: int = 0,
origin: Tuple[float, float] = (0, 0),
origin_scale: Tuple[float, float] = (0, 0),
origin_rotation: Tuple[float, float] = (0, 0),
blend_src: int = GL_SRC_ALPHA,
blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
# never ever give this a batch, this would use the default shader and break things! you have to call .draw yourself
group: Group | None = None,
subpixel: bool = False,
):
if origin != (0, 0):
self.origin_scale = origin
self.origin_rotation = origin
assert origin_scale == (0, 0)
assert origin_rotation == (0, 0)
else:
self.origin_scale = origin_scale
self.origin_rotation = origin_rotation
super().__init__(
img,
x,
y,
z,
blend_src,
blend_dest,
None,
group,
subpixel,
get_default_shader(),
)
def draw(self):
"""Draw the sprite at its current position.
See the module documentation for hints on drawing multiple sprites
efficiently.
"""
if not self._group:
return
self._group.set_state_recursive()
if self.program:
self.program["origin_scale"] = (self.origin_scale[0], self.origin_scale[1])
self.program["origin_rotation"] = (
self.origin_rotation[0],
self.origin_rotation[1],
)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
if self._vertex_list:
self._vertex_list.draw(GL_TRIANGLES)
self._group.unset_state_recursive()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/state.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/state.py | import threading
import time
from datetime import datetime
from types import TracebackType
from typing import Dict, Tuple, cast
import client
from client.game.entities.enemy import Enemy
from client.scenes.game import Game
from shared.constants import TARGET_FPS, TARGET_UPS
from shared.gen.messages.v1 import LoggedIn, Object, SessionType, User
class TimedLock:
lock: threading.Lock
t0: float
t1: float
frequency: float
def __init__(self, frequency: float) -> None:
self.lock = threading.Lock()
self.frequency = frequency
self.t0 = 0
self.t1 = 0
def __enter__(self) -> bool:
self.lock.acquire(True)
self.t0 = time.time()
return True
def locked(self) -> bool:
return self.lock.locked()
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> None:
self.lock.release()
self.t1 = time.time()
class GameState:
users: Dict[str, User]
objects: Dict[str, Tuple[Object, Object]]
my_user: User | None
last_ping: datetime
session_type: SessionType
draw_lock: TimedLock
update_lock: TimedLock
def __init__(self) -> None:
self.draw_lock = TimedLock(1 / TARGET_FPS)
self.update_lock = TimedLock(1 / TARGET_UPS)
self.users = {}
self.objects = {}
self.my_user = None
self.last_ping = datetime.now()
self.session_type = SessionType.SESSION_TYPE_UNSPECIFIED
def is_authenticated(self) -> bool:
return self.my_user is not None
def login(self, message: LoggedIn) -> None:
if message.success:
self.my_user = message.self
self.session_type = message.type
def logout(self) -> None:
self.my_user = None
def get_objects_in_range(self, distance_squared: float) -> list[Enemy]:
if self.my_user is None:
return []
game_scene = cast(Game, client.scene_manager.current_scene)
all_enemies = game_scene.enemies.values()
coords = self.my_user.coords
return list(
filter(
lambda e: ((coords.x - e.x) ** 2) + ((coords.y - e.y) ** 2)
<= distance_squared, # TODO: Last or next here?
all_enemies,
)
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/configuration.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/configuration.py | import os
from dataclasses import dataclass, field
@dataclass
class Configuration:
host: str = field(
default_factory=lambda: os.environ.get("SERVER_HOST", "localhost")
)
port: str = field(default_factory=lambda: os.environ.get("SERVER_PORT", "31337"))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/area.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/area.py | from dataclasses import dataclass
from typing import TYPE_CHECKING, cast
import client
from client.game.entities.entity import Direction
from shared.gen.messages.v1 import Interact, InteractStatus, InteractType, Polygon
if TYPE_CHECKING:
from client.scenes.game import Game
@dataclass
class Area:
uuid: str
def __init__(self, uuid: str, area: Polygon, *args: int, **kwargs: str) -> None:
super().__init__(*args, **kwargs)
self.area = area
self.uuid = uuid
self.in_interaction = False
def on_interaction(self, interact: Interact):
game = cast("Game", client.scene_manager.current_scene)
player = game.player
match interact.type:
case InteractType.INTERACT_TYPE_DIG:
match interact.status:
case InteractStatus.INTERACT_STATUS_START:
self.in_interaction = True
player.can_move = False
player.direction = Direction.UP
player.progress = interact.progress
case InteractStatus.INTERACT_STATUS_UPDATE:
player.progress = interact.progress
pass
case InteractStatus.INTERACT_STATUS_STOP:
self.in_interaction = False
player.can_move = True
player.progress = -1
case InteractStatus.INTERACT_STATUS_UNSPECIFIED:
assert False
case _:
pass
def interact(self):
if self.in_interaction:
client.global_connection.interact(
self.uuid,
text="",
status=InteractStatus.INTERACT_STATUS_UPDATE,
handler=self.on_interaction,
)
else:
client.global_connection.interact(
self.uuid,
text="",
status=InteractStatus.INTERACT_STATUS_START,
handler=self.on_interaction,
)
def stop_interaction(self) -> None:
if self.in_interaction:
client.global_connection.interact(
self.uuid,
text="",
status=InteractStatus.INTERACT_STATUS_STOP,
handler=self.on_interaction,
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/camera.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/camera.py | from types import TracebackType
from typing import Optional, Tuple, Type
import pyglet
from pyglet.gl import (
GL_DEPTH_BUFFER_BIT,
GL_EQUAL,
GL_FALSE,
GL_KEEP,
GL_NEVER,
GL_REPLACE,
GL_STENCIL_BUFFER_BIT,
GL_STENCIL_TEST,
GL_TRUE,
glClear,
glColorMask,
glDepthMask,
glDisable,
glEnable,
glStencilFunc,
glStencilMask,
glStencilOp,
)
from pyglet.shapes import Circle
from pyglet.window import Window
"""Camera class for easy scrolling and zooming.
A simple example of a Camera class that can be used to easily scroll and
zoom when rendering. For example, you might have a playfield that needs
to scroll and/or zoom, and a GUI layer that will remain static. For that
scenario, you can create two Camera instances. You can optionally set
the minimum allowed zoom, maximum allowed zoom, and scrolling speed::
world_camera = Camera(scroll_speed=5, min_zoom=1, max_zoom=4)
gui_camera = Camera()
After creating Camera instances, the zoom can be easily updated. It will
clamp to the `max_zoom` parameter (default of 4)::
world_camera.zoom += 1
The scrolling can be set in two different ways. Directly with the
`Camera.position attribute, which can be set with a tuple of absolute
x, y values::
world_camera.position = 50, 0
Or, it can be updated incrementally with the `Camera.move(x, y)` method.
This will update the camera position by multiplying the passed vector by
the `Camera.scroll_speed` parameter, which can be set on instantiation.
world_camera.move(1, 0)
# If the world_camera.scroll_speed is "5", this will move the camera
# by 5 pixels right on the x axis.
During your `Window.on_draw` event, you can set the Camera, and draw the
appropriate objects. For convenience, the Camera class can act as a context
manager, allowing easy use of "with"::
@window.event
def on_draw():
window.clear()
# Draw your world scene using the world camera
with world_camera:
batch.draw()
# Can also be written as:
# camera.begin()
# batch.draw()
# camera.end()
# Draw your GUI elements with the GUI camera.
with gui_camera:
label.draw()
"""
class Camera:
offset_x: float
offset_y: float
"""A simple 2D camera that contains the speed and offset."""
def __init__(
self,
window: pyglet.window.Window,
max_scroll_x: float | None,
max_scroll_y: float | None,
scroll_speed: float = 1,
min_zoom: float = 1,
max_zoom: float = 4,
) -> None:
assert (
min_zoom <= max_zoom
), "Minimum zoom must not be greater than maximum zoom"
self.scroll_speed = scroll_speed
self.max_zoom = max_zoom
self.min_zoom = min_zoom
self.offset_x = 0
self.offset_y = 0
self._zoom = max(min(1, self.max_zoom), self.min_zoom)
self.window = window
self.max_scroll_x = max_scroll_x
self.max_scroll_y = max_scroll_y
@property
def zoom(self) -> float:
return self._zoom
@zoom.setter
def zoom(self, value: float) -> None:
"""Here we set zoom, clamp value to minimum of min_zoom and max of max_zoom."""
self._zoom = max(min(value, self.max_zoom), self.min_zoom)
@property
def position(self) -> Tuple[float, float]:
"""Query the current offset."""
return self.offset_x, self.offset_y
@position.setter
def position(self, value: Tuple[float, float]) -> None:
"""Set the scroll offset directly."""
# Check for borders
self.offset_x, self.offset_y = value
def move(self, axis_x: float, axis_y: float) -> None:
"""Move axis direction with scroll_speed.
Example: Move left -> move(-1, 0)
"""
self.offset_x += self.scroll_speed * axis_x
self.offset_y += self.scroll_speed * axis_y
def begin(self) -> None:
# Set the current camera offset so you can draw your scene.
# Translate using the zoom and the offset.
# pyglet.gl.glTranslatef(-self.offset_x * self._zoom, -self.offset_y * self._zoom, 0)
# Scale by zoom level.
# pyglet.gl.glScalef(self._zoom, self._zoom, 1)
self.window.view = self.window.view.translate(
pyglet.math.Vec3(
-self.offset_x * self._zoom, -self.offset_y * self._zoom, 0
)
)
self.window.view = self.window.view.scale(
pyglet.math.Vec3(self._zoom, self._zoom, 1)
)
def end(self) -> None:
# Since this is a matrix, you will need to reverse the translate after rendering otherwise
# it will multiply the current offset every draw update pushing it further and further away.
# Reverse scale, since that was the last transform.
# pyglet.gl.glScalef(1 / self._zoom, 1 / self._zoom, 1)
self.window.view = self.window.view.scale(
pyglet.math.Vec3(1 / self._zoom, 1 / self._zoom, 1)
)
# Reverse translate.
# pyglet.gl.glTranslatef(self.offset_x * self._zoom, self.offset_y * self._zoom, 0)
self.window.view = self.window.view.translate(
pyglet.math.Vec3(self.offset_x * self._zoom, self.offset_y * self._zoom, 0)
)
def __enter__(self) -> None:
self.begin()
def __exit__(
self,
exc_type: Optional[Type[BaseException]],
exc: Optional[BaseException],
traceback: Optional[TracebackType],
) -> None:
self.end()
class CenteredCamera(Camera):
"""A simple 2D camera class. 0, 0 will be the centre of the screen, as opposed to the bottom left."""
def __init__(
self,
window: Window,
max_scroll_x: float | None,
max_scroll_y: float | None,
scroll_speed: float = 1,
min_zoom: float = 1,
max_zoom: float = 4,
) -> None:
super().__init__(
window, max_scroll_x, max_scroll_y, scroll_speed, min_zoom, max_zoom
)
self.cut_out = False
self._circle_cut = Circle(
x=window.width // 2 + 16,
y=window.height // 2 + 25,
radius=30,
color=(255, 255, 255, 255),
)
self.zoom = 2
def begin(self) -> None:
if self.cut_out:
glClear(GL_DEPTH_BUFFER_BIT)
glEnable(GL_STENCIL_TEST)
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE)
glDepthMask(GL_FALSE)
glStencilFunc(GL_NEVER, 1, 0xFF)
glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP) # draw 1s on test fail (always)
glStencilMask(0xFF)
glClear(GL_STENCIL_BUFFER_BIT) # needs mask=0xFF
self._circle_cut.draw()
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE)
glDepthMask(GL_TRUE)
glStencilMask(0x00)
glStencilFunc(GL_EQUAL, 1, 0xFF)
x = -self.window.width // 2 / self._zoom + self.offset_x
y = self.window.height // 2 / self._zoom + self.offset_y
# pyglet.gl.glTranslatef(-x * self._zoom, -y * self._zoom, 0)
# pyglet.gl.glScalef(self._zoom, self._zoom, 1)
self.window.view = self.window.view.translate(
pyglet.math.Vec3(-x * self._zoom, y * self._zoom, 0)
)
self.window.view = self.window.view.scale(
pyglet.math.Vec3(self._zoom, self._zoom, 1)
)
def end(self):
x = -self.window.width // 2 / self._zoom + self.offset_x
y = self.window.height // 2 / self._zoom + self.offset_y
# pyglet.gl.glScalef(1 / self._zoom, 1 / self._zoom, 1)
# pyglet.gl.glTranslatef(x * self._zoom, y * self._zoom, 0)
self.window.view = self.window.view.scale(
pyglet.math.Vec3(1 / self._zoom, 1 / self._zoom, 1)
)
self.window.view = self.window.view.translate(
pyglet.math.Vec3(x * self._zoom, -y * self._zoom, 0)
)
glDisable(GL_STENCIL_TEST)
@property
def position(self):
"""Query the current offset."""
return self.offset_x, self.offset_y
@position.setter
def position(self, value: Tuple[float, float]):
"""Set the scroll offset directly."""
# Check for borders
# Check right border
x, y = value
x_screen = x - self.window.width // 2
y_screen = y - self.window.height // 2
if self.max_scroll_x:
x_screen = min(max(0, x_screen), self.max_scroll_x - self.window.width)
if self.max_scroll_y:
y_screen = min(
max(-self.window.height // 2 + 32 * 2, y_screen), self.window.height
) # No idea why we need to 32*2. Was estimated by printing values
self.offset_x = x_screen + self.window.width // 2
self.offset_y = y_screen + self.window.height // 2
# self.offset_x = min(self.max_scroll_x + self.window.width//2, x)
# self.offset_x = min(self.max_scroll_x, x + self.window.width//2)
# self.offset_x, self.offset_y = value
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/utils.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/utils.py | import asyncio
import time
from asyncio import get_running_loop
from time import sleep as time_sleep
import pyglet
import client
from shared.constants import TARGET_FPS, TARGET_UPS
if pyglet.compat_platform in ["win32", "cygwin"]:
async def sleep(delay: float):
await get_running_loop().run_in_executor(None, time_sleep, delay)
else:
sleep = asyncio.sleep # type: ignore
async def check_wait() -> None:
start_lock = time.time()
tmp_time = time.time()
while (
client.game_state.update_lock.locked()
or (tmp_time - client.game_state.update_lock.t1)
> client.game_state.update_lock.frequency
) and tmp_time - start_lock < (1 / TARGET_UPS) * 2:
await sleep(((1 / TARGET_UPS) * 0.2))
tmp_time = time.time()
start_lock = time.time()
tmp_time = time.time()
while (
(
client.game_state.draw_lock.locked()
or tmp_time - client.game_state.draw_lock.t1
)
> client.game_state.draw_lock.frequency
) and tmp_time - start_lock < (1 / TARGET_FPS) * 2:
await sleep((1 / TARGET_FPS) * 0.2)
tmp_time = time.time()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/sound_manager.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/sound_manager.py | import pyglet
class SoundManager:
def __init__(self) -> None:
self.player = pyglet.media.Player()
self.bg_music = None
pass
def set_background_music(self, path: str) -> None:
self.bg_music = pyglet.resource.media(path)
self.player.queue(self.bg_music)
pass
def play_background_music(self) -> None:
if self.bg_music is None:
return
self.player.play()
def stop_background_music(self) -> None:
self.player.pause()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/map.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/map.py | from __future__ import annotations
import logging
import time
from asyncio import Lock, PriorityQueue
from copy import copy
from dataclasses import dataclass
from datetime import datetime, timedelta
from functools import cache
from typing import TYPE_CHECKING, List, cast
from shared.constants import CHUNK_SIZE_X, CHUNK_SIZE_Y, TILE_SIZE_X, TILE_SIZE_Y
from shared.gen.messages.v1 import MapChunkResponse, TileCollision, Tileset
if TYPE_CHECKING:
from client.scenes.game import Game
from pyglet.gl import (
GL_BLEND,
GL_CLAMP_TO_EDGE,
GL_NEAREST,
GL_ONE_MINUS_SRC_ALPHA,
GL_SRC_ALPHA,
GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER,
GL_TEXTURE_MIN_FILTER,
GL_TEXTURE_WRAP_S,
GL_TEXTURE_WRAP_T,
GL_TRIANGLES,
glBlendFunc,
glDisable,
glEnable,
glTexParameteri,
)
from pyglet.graphics.shader import Shader, ShaderProgram
from pyglet.graphics.vertexdomain import IndexedVertexList
from pyglet.image import ImageData, Texture
import client
from client.game.camera import Camera
from client.game.utils import check_wait
from shared.map import Map, Tile
TEXTURE_SIZE = 16
TILES_PER_ROW = 16
TILE_IDS = [[0 for _ in range(CHUNK_SIZE_X)] for _ in range(CHUNK_SIZE_Y)]
TEX_COORDS: list[float] = [0.0] * (CHUNK_SIZE_X * CHUNK_SIZE_Y * 8)
VERTEX_SOURCE = """#version 330 core
in vec2 tex_coords;
in vec2 position;
out vec2 vertex_colors;
uniform vec2 translation;
uniform bool center;
uniform WindowBlock
{ // This UBO is defined on Window creation, and available
mat4 projection; // in all Shaders. You can modify these matrixes with the
mat4 view; // Window.view and Window.projection properties.
} window;
mat4 m_translate = mat4(1.0);
void main()
{
m_translate[3][0] = translation.x;
m_translate[3][1] = -translation.y;
gl_Position = window.projection * window.view * m_translate * vec4(position, 0, 1);
vertex_colors = tex_coords;
}
"""
FRAGMENT_SOURCE = """#version 330 core
in vec2 vertex_colors;
out vec4 final_color;
uniform sampler2D texture_atlas;
void main()
{
final_color = texture(texture_atlas, vertex_colors);
}
"""
@cache
def get_map_shader() -> ShaderProgram:
logging.debug("Map Shader Recalc")
vert_shader = Shader(VERTEX_SOURCE, "vertex")
frag_shader = Shader(FRAGMENT_SOURCE, "fragment")
return ShaderProgram(vert_shader, frag_shader)
def get_vlist(program: ShaderProgram) -> IndexedVertexList:
position: list[float] = []
indices: list[int] = []
tex_coords: list[float] = []
for x in range(CHUNK_SIZE_X):
for y in range(CHUNK_SIZE_Y):
position += create_quad(x, y - CHUNK_SIZE_Y)
indices += gen_quad_indices(CHUNK_SIZE_Y * y + x)
tex_coords += [0] * 8
return program.vertex_list_indexed(
4 * CHUNK_SIZE_X * CHUNK_SIZE_Y,
GL_TRIANGLES,
indices,
position=("f", position),
tex_coords=("f", tex_coords),
) # type: ignore
def create_quad(
x: float, y: float
) -> tuple[float, float, float, float, float, float, float, float]:
x = x * TILE_SIZE_X
y = y * TILE_SIZE_Y
x2 = x + TILE_SIZE_X
y2 = y + TILE_SIZE_Y
return (x, y, x2, y, x2, y2, x, y2)
def create_quad_tex(
offset: float, width: float, height: float
) -> tuple[float, float, float, float, float, float, float, float]:
x = TEXTURE_SIZE * (offset % TILES_PER_ROW)
y = TEXTURE_SIZE * (offset // TILES_PER_ROW)
x2 = x + TEXTURE_SIZE
y2 = y + TEXTURE_SIZE
x /= width
x2 /= width
y /= height
y2 /= height
return (x, y2, x2, y2, x2, y, x, y)
def gen_quad_indices(n: int) -> tuple[int, int, int, int, int, int]:
offset = n * 4
return (0 + offset, 1 + offset, 2 + offset, 0 + offset, 2 + offset, 3 + offset)
@dataclass
class Chunk:
tileset: Tileset
width: int
height: int
tiles: List[List[int]]
tex_coords: List[float]
collisions: List[TileCollision]
texture: Texture | None = None
dirty: bool = True
def get_texture(self):
if self.texture:
return self.texture
self.texture = ImageData(
self.tileset.width,
self.tileset.height,
"RGBA",
self.tileset.tileset,
).get_texture()
return self.texture
class ChunkWrapper:
def __init__(self, cache: ChunkCache, item: MapChunkResponse) -> None:
self.cache = cache
self.value = item
self.game = cast("Game", client.scene_manager.current_scene)
def __f(self, val: MapChunkResponse):
x, y = self.game.player.x, self.game.player.y
return ((val.chunks[0].x + 0.5) * (CHUNK_SIZE_X * TILE_SIZE_X) - x) ** 2 + (
(val.chunks[0].y + 0.5) * (CHUNK_SIZE_Y * TILE_SIZE_Y) - y
) ** 2
def __lt__(self, obj: ChunkWrapper):
return self.__f(self.value) < self.__f(obj.value)
def __le__(self, obj: ChunkWrapper):
return self.__f(self.value) <= self.__f(obj.value)
def __eq__(self, obj: object):
match obj:
case ChunkWrapper():
return self.__f(self.value) == self.__f(obj.value)
case _:
return False
def __ne__(self, obj: object):
match obj:
case ChunkWrapper():
return self.__f(self.value) != self.__f(obj.value)
case _:
return True
def __gt__(self, obj: ChunkWrapper):
return self.__f(self.value) > self.__f(obj.value)
def __ge__(self, obj: ChunkWrapper):
return self.__f(self.value) >= self.__f(obj.value)
class ChunkCache(dict[tuple[int, int], List[Chunk]]):
request_time: dict[tuple[int, int], datetime]
def __init__(self) -> None:
self.request_time = dict()
client.global_connection.map_chunk_handler += self._add_chunk_prio
self.prio_queue: PriorityQueue[ChunkWrapper] = PriorityQueue()
@staticmethod
def _create_tex(tids: list[list[int]], tileset: Tileset) -> List[float]:
# this is now really performant
width = tileset.width
height = tileset.height
tex_coords: list[float] = copy(TEX_COORDS)
for x_ in range(CHUNK_SIZE_X):
for y_ in range(CHUNK_SIZE_Y):
offset = tids[x_][y_]
x = TEXTURE_SIZE * (offset % TILES_PER_ROW)
y = TEXTURE_SIZE * (offset // TILES_PER_ROW)
x2 = x + TEXTURE_SIZE
y2 = y + TEXTURE_SIZE
x /= width
x2 /= width
y /= height
y2 /= height
idx = (x_ * CHUNK_SIZE_Y + y_) * 8
tex_coords[idx + 0] = x
tex_coords[idx + 1] = y2
tex_coords[idx + 2] = x2
tex_coords[idx + 3] = y2
tex_coords[idx + 4] = x2
tex_coords[idx + 5] = y
tex_coords[idx + 6] = x
tex_coords[idx + 7] = y
return tex_coords
async def _add_chunk_prio(
self, lock: Lock, chunk_response: MapChunkResponse
) -> None:
cx = chunk_response.chunks[0].x
cy = chunk_response.chunks[0].y
print(
"Adding chunk to QUEUE",
cx,
cy,
len(chunk_response.chunks),
)
self.prio_queue.put_nowait(ChunkWrapper(self, chunk_response))
async with lock: # type: ignore
while not self.prio_queue.empty():
item = await self.prio_queue.get()
await self._add_chunk(item.value)
async def _add_chunk(self, chunk_response: MapChunkResponse) -> None:
cx = chunk_response.chunks[0].x
cy = chunk_response.chunks[0].y
print(
"Adding chunk",
cx,
cy,
len(chunk_response.chunks),
)
chunks: List[Chunk] = []
t0 = time.time()
for c in chunk_response.chunks:
tids = copy(TILE_IDS)
for x in range(len(TILE_IDS)):
tids[x] = copy(TILE_IDS[x])
await check_wait()
x = 0
y = 0
for tile in c.tiles:
await check_wait()
tids[x][CHUNK_SIZE_Y - 1 - y] = tile
x += 1
if x == c.width:
x = 0
y += 1
tex_coords = self._create_tex(tids, c.tileset)
cchunk = Chunk(
c.tileset,
c.width,
c.height,
tids,
tex_coords,
c.collisions,
)
chunks.append(cchunk)
print("adding chunk took:", time.time() - t0)
self.__setitem__((cx, cy), chunks)
def __missing__(self, keys: tuple[int, int]) -> None:
assert isinstance(keys, tuple) and len(keys) == 2
if (
keys not in self.request_time
or self.request_time[keys] + timedelta(seconds=60) < datetime.now()
):
print("Requesting chunk", keys[0], keys[1])
self.request_time[keys] = datetime.now()
client.global_connection.get_chunks(x=keys[0], y=keys[1])
return None
class RenderChunk:
chunk: None | tuple[int, int]
def __init__(self) -> None:
self.layers: List[IndexedVertexList] = []
self.chunk = None
def get_layer(self, idx: int, program: ShaderProgram) -> IndexedVertexList:
if len(self.layers) <= idx:
self.layers.append(get_vlist(program))
return self.layers[idx]
class ClientMap(Map):
program: ShaderProgram | None
chunk_cache: ChunkCache
def __init__(self):
self.chunk_cache = ChunkCache()
self.program = None
self.vlists = None
def get_tiles(
self, x: float, y: float, user_id: str = ""
) -> tuple[List[Tile], float, float] | None:
tiles: List[Tile] = []
chunk_x = int(x // (CHUNK_SIZE_X * TILE_SIZE_X))
chunk_y = int(y // (CHUNK_SIZE_Y * TILE_SIZE_Y))
tile_x = int((x // TILE_SIZE_X) % CHUNK_SIZE_X)
tile_y = int((-y // TILE_SIZE_Y) % CHUNK_SIZE_Y)
chunks = self.chunk_cache[(chunk_x, chunk_y)]
if not chunks:
return ([], chunk_x + tile_x, chunk_y + tile_y)
for chunk in chunks:
tid = chunk.tiles[tile_x][tile_y]
collision = chunk.collisions[tid]
tiles.append(Tile(tid, collision.polygons))
return (
tiles,
chunk_x * CHUNK_SIZE_X * TILE_SIZE_X + tile_x * TILE_SIZE_X,
chunk_y * CHUNK_SIZE_Y * TILE_SIZE_Y
+ (-tile_y + CHUNK_SIZE_Y) * TILE_SIZE_Y,
)
def set_state(self) -> None:
assert self.program
# glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
self.program.use()
# self.texture.bind(self.texture_unit)
# TODO restore state
# glActiveTexture(GL_TEXTURE0 + self.texture_unit)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def unset_state(self) -> None:
assert self.program
self.program.stop()
# glActiveTexture(GL_TEXTURE0 + self.texture_unit)
# glBindTexture(GL_TEXTURE_2D, 0)
# glActiveTexture(GL_TEXTURE0)
# glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glDisable(GL_BLEND)
def draw(self, camera: Camera) -> None:
# render this chunk and all existing neighbour chunks
chunk_x = int(camera.offset_x // (CHUNK_SIZE_X * TILE_SIZE_X))
chunk_y = int(camera.offset_y // (CHUNK_SIZE_Y * TILE_SIZE_Y))
if self.program is None:
self.program = get_map_shader()
if self.vlists is None:
self.vlists = (*(RenderChunk() for _ in range(3 * 3)),)
self.set_state()
for x, y in [
(0, 0),
(0, 1),
(0, -1),
(-1, 0),
(1, 0),
(-1, -1),
(-1, 1),
(1, -1),
(1, 1),
]:
chunks = self.chunk_cache[(chunk_x + x, chunk_y + y)]
if not chunks:
continue
idx = ((chunk_x + x + 1) % 3) * 3 + ((chunk_y + y + 1) % 3)
render_chunk = self.vlists[idx]
dirty = render_chunk.chunk != (chunk_x + x, chunk_y + y)
for i, chunk in enumerate(chunks):
vlist = render_chunk.get_layer(i, self.program)
# TODO translate chunk
self.program["translation"] = (
(chunk_x + x) * (CHUNK_SIZE_X * TILE_SIZE_X),
(chunk_y + y) * (CHUNK_SIZE_Y * TILE_SIZE_Y),
)
if dirty or chunk.dirty:
vlist.set_attribute_data("tex_coords", chunk.tex_coords)
chunk.dirty = False
chunk.get_texture().bind(0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
vlist.draw(GL_TRIANGLES)
render_chunk.chunk = (chunk_x + x, chunk_y + y)
self.unset_state()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/pickupable.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/pickupable.py | from dataclasses import dataclass
from typing import Any, cast
from pyglet.image import Texture
from client.game.entities.entity import ServerManagedEntity
from client.game.nearest_sprite import NearestSprite
from client.game.ui import get_ui_grid
from shared.gen.messages.v1 import Item
@dataclass
class Pickupable(ServerManagedEntity):
uuid: str
def __init__(
self, item: Item, x: float, y: float, *args: Any, **kwargs: Any
) -> None:
super().__init__(*args, **kwargs)
self.item = item
self.x = x
self.y = -y
self.is_ready = True
self.shrinking_rotate = False
def on_load(self) -> None:
origin_rotation = (
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
)
if self.item.icon >= 2562 and self.item.icon <= 2571:
origin_rotation = (
cast(int, get_ui_grid().item_width) // 2,
0,
)
self.sprite = NearestSprite(
cast(Texture, get_ui_grid()[self.item.icon]),
x=int(self.x + cast(int, get_ui_grid().item_width) // 2),
y=int(self.y - cast(int, get_ui_grid().item_height) // 2),
origin_scale=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
origin_rotation=origin_rotation,
)
self.sprite.scale = 1.25
self.sprite.rotation = 0
return super().on_load()
def update(self, dt: float) -> None:
if self.is_loaded:
update = 10 * dt
if self.shrinking_rotate:
update *= -1
self.sprite.rotation += update
if self.sprite.rotation < -5:
self.shrinking_rotate = False
if self.sprite.rotation > 5:
self.shrinking_rotate = True
return super().update(dt)
def draw(self) -> None:
if self.is_loaded:
self.sprite.draw()
return super().draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/npc.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/npc.py | from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, cast
from pyglet import shapes
import client
from client.game.entities.entity import (
Direction,
InteractEntity,
NamedEntity,
ServerManagedEntity,
TilesetEntity,
)
from shared.constants import SERVER_TICK_RATE
from shared.gen.messages.v1 import Activity, InteractStatus
if TYPE_CHECKING:
from client.scenes.game import Game
def is_c_between_ab(
a: tuple[float, float],
b: tuple[float, float],
c: tuple[float, float],
epsilon: float = 4, # this is in pixels, so this can be quite large
) -> tuple[bool, float]:
# check aabb
minX, maxX = (a[0], b[0]) if a[0] < b[0] else (b[0], a[0])
minY, maxY = (a[1], b[1]) if a[1] < b[1] else (b[1], a[1])
if (
c[0] < (minX - epsilon)
or c[0] > (maxX + epsilon)
or c[1] < (minY - epsilon)
or c[1] > (maxY + epsilon)
):
return False, -1
if b[1] != a[1] and c[1] != a[1]:
s1 = (b[0] - a[0]) / (b[1] - a[1])
s2 = (c[0] - a[0]) / (c[1] - a[1])
return abs(s1 - s2) < epsilon, abs(s1 - s2)
if b[0] != a[0] and c[0] != a[0]:
s1 = (b[1] - a[1]) / (b[0] - a[0])
s2 = (c[1] - a[1]) / (c[0] - a[0])
return abs(s1 - s2) < epsilon, abs(s1 - s2)
return True, -1
@dataclass
class NPC(TilesetEntity, NamedEntity, InteractEntity, ServerManagedEntity):
def __init__(self, *args: int, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
self.rotation = 270.0
self.activity = Activity.ACTIVITY_IDLE
self.label = "UNKNOWN"
self.bb = None
self.bb_offset_x = 4
self.bb_offset_y = -3
self.last_x = 0
self.next_x = 0
self.last_y = 0
self.next_y = 0
self.in_interaction = False
self.interact_distance = 0
def on_load(self) -> None:
self.bb = shapes.Rectangle(
self.x + self.bb_offset_x,
-(self.y + self.bb_offset_y),
self.width,
self.height,
color=(0, 0, 255),
)
super().on_load()
def stop_interaction(self) -> None:
if self.in_interaction:
if self.sprite:
self.sprite.scale_x = 1
client.global_connection.interact(
self.uuid, text="", status=InteractStatus.INTERACT_STATUS_STOP
)
super().stop_interaction()
def interact(self, input: str = "") -> None:
game = cast("Game", client.scene_manager.current_scene)
player = game.player
px = player.x + player.interact_offset[0]
py = player.y + player.interact_offset[1]
sx = self.x + self.interact_offset[0]
sy = self.y + self.interact_offset[1]
# make dino look at player
if px < sx:
if self.sprite:
self.sprite.scale_x = -1
# make player look at dino
dx = px - sx
dy = py - sy
if abs(dx) > abs(dy):
if dx < 0:
player.direction = Direction.RIGHT
else:
player.direction = Direction.LEFT
else:
if dy < 0:
player.direction = Direction.DOWN
else:
player.direction = Direction.UP
pass
if self.in_interaction:
client.global_connection.interact(
self.uuid, text=input, status=InteractStatus.INTERACT_STATUS_UPDATE
)
else:
client.global_connection.interact(
self.uuid, text=input, status=InteractStatus.INTERACT_STATUS_START
)
super().interact()
def update(self, dt: float) -> None:
next_x = client.game_state.objects[self.uuid][1].coords.x
next_y = client.game_state.objects[self.uuid][1].coords.y
last_x = client.game_state.objects[self.uuid][0].coords.x
last_y = client.game_state.objects[self.uuid][0].coords.y
if next_x != last_x or next_y != last_y:
self.activity = Activity.ACTIVITY_WALKING
pred_x = self.x + (next_x - last_x) * (SERVER_TICK_RATE * dt)
pred_y = self.y + (next_y - last_y) * (SERVER_TICK_RATE * dt)
val, _err = is_c_between_ab(
(last_x, last_y), (next_x, next_y), (pred_x, pred_y)
)
if val:
# pred okay
new_x = pred_x
new_y = pred_y
else:
# miss
new_x = last_x
new_y = last_y
if self.x > new_x:
self.rotation = 270
else:
self.rotation = 90
self.x = new_x
self.y = new_y
super().update(dt)
def draw(self) -> None:
if self.bb is not None:
self.bb.x = self.x + self.bb_offset_x
self.bb.y = -(self.y + self.bb_offset_y)
self.bb.draw()
return super().draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/renderable.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/renderable.py | from dataclasses import dataclass
@dataclass
class Renderable:
is_loaded: bool
is_ready: bool
def __init__(self) -> None:
self.is_ready = False
self.is_loaded = False
def on_load(self) -> None:
pass
def update(self, dt: float) -> None:
pass
def draw(self) -> None:
if not self.is_loaded and self.is_ready:
self.on_load()
self.is_loaded = True
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/other_player.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/other_player.py | from dataclasses import dataclass
from typing import Any
import client
from client.game.entities.entity import (
Direction,
NamedEntity,
ServerManagedEntity,
TilesetEntity,
)
from shared.gen.messages.v1 import Activity
@dataclass
class OtherPlayer(TilesetEntity, NamedEntity, ServerManagedEntity):
direction: Direction
def __init__(self, *args: int, **kwargs: Any) -> None:
super().__init__(*args, **kwargs)
self.direction = Direction.DOWN
def update(self, dt: float) -> None:
if not self.is_loaded:
return
new_x = client.game_state.users[self.uuid].coords.x
new_y = client.game_state.users[self.uuid].coords.y
rot = client.game_state.users[self.uuid].coords.rotation % 360
if rot <= 45 or rot >= 315:
self.direction = Direction.UP
elif rot >= 135 and rot <= 225:
self.direction = Direction.DOWN
elif rot > 45 and rot < 135:
self.direction = Direction.RIGHT
elif rot > 135 and rot < 315:
self.direction = Direction.LEFT
self.rotation = rot
if new_x == self.x and new_y == self.y:
self.activity = Activity.ACTIVITY_IDLE
else:
self.activity = Activity.ACTIVITY_WALKING
self.x = new_x
self.y = new_y
super().update(dt)
def on_load(self) -> None:
self.label = client.game_state.users[self.uuid].username
super().on_load()
def draw(self) -> None:
return super().draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/entity.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/entity.py | from collections import defaultdict
from dataclasses import dataclass
from enum import IntEnum
from typing import TYPE_CHECKING, Dict, Tuple, cast
from pyglet import shapes
from pyglet.graphics import Batch
from pyglet.image import Animation, AnimationFrame, ImageData, ImageGrid, TextureGrid
from pyglet.math import Mat4, Vec3
from pyglet.sprite import Sprite
from pyglet.text import Label
import client
from client.game.entities.renderable import Renderable
from client.game.nearest_sprite import NearestSprite
from shared.constants import NUM_TILES_PER_COLUM
from shared.gen.messages.v1 import Activity
from shared.gen.messages.v1 import Direction as DirectionProto
from shared.gen.messages.v1 import EntityAssets
if TYPE_CHECKING:
from client.scenes.game import Game
DEBUG_INTERACTION = False
class Direction(IntEnum):
UP = 0
RIGHT = 90
LEFT = 270
DOWN = 180
@dataclass
class Entity(Renderable):
x: float
y: float
width: float
height: float
rotation: float
def __init__(self, *args: int, **kwargs: str) -> None:
super().__init__(*args, **kwargs)
self.x = 0.0
self.y = 0.0
self.width = 0.0
self.height = 0.0
def on_load(self) -> None:
super().on_load()
@dataclass
class SpriteEntity(Entity):
sprite: Sprite | None
def __init__(self, *args: int, **kwargs: str) -> None:
super().__init__(*args, **kwargs)
self.sprite = None
def on_load(self) -> None:
super().on_load()
def draw(self) -> None:
super().draw()
if self.sprite is not None:
self.sprite.x = self.x
self.sprite.y = -self.y # convert between tiled and pyglet coords
self.sprite.draw()
@dataclass
class TilesetEntity(SpriteEntity):
assets: EntityAssets
sprites: Dict[Activity, Dict[DirectionProto, Sprite]]
activity: Activity
def __init__(self, *args: int, **kwargs: str) -> None:
super().__init__(*args, **kwargs)
self.activity = Activity.ACTIVITY_IDLE
self.sprites = defaultdict(lambda: {})
def set_assets(self, assets: EntityAssets) -> None:
self.assets = assets
self.is_ready = True
def on_load(self) -> None:
self.width = self.assets.width
self.height = self.assets.height
tileset = self.assets.tileset
sprite_image = ImageData(
tileset.width, tileset.height, "RGBA", tileset.tileset, tileset.width * -4
)
rows = tileset.height // self.height
image_grid = ImageGrid(
sprite_image,
rows=rows,
columns=NUM_TILES_PER_COLUM,
)
texture_grid: TextureGrid = image_grid.get_texture_sequence()
for asset in self.assets.entity_assets:
animation = next((a for a in tileset.animations if a.id == asset.id), None)
if animation is None:
sprite = NearestSprite(
Animation.from_image_sequence( # type: ignore
texture_grid[
(
rows - 1 - (asset.id // NUM_TILES_PER_COLUM),
asset.id % NUM_TILES_PER_COLUM,
) : (
rows - 1 - (asset.id // NUM_TILES_PER_COLUM) + 1,
(asset.id % NUM_TILES_PER_COLUM) + 1,
)
],
duration=0.1,
),
origin=(self.width / 2, self.height / 2),
)
else:
frames = [
AnimationFrame(
image=texture_grid[ # type: ignore
(
rows - 1 - (step.id // NUM_TILES_PER_COLUM),
step.id % NUM_TILES_PER_COLUM,
) : (
rows - 1 - (step.id // NUM_TILES_PER_COLUM) + 1,
(step.id % NUM_TILES_PER_COLUM) + 1,
)
][0],
duration=step.duration / 1000,
)
for step in animation.animation_setps
]
sprite = NearestSprite(
Animation(frames=frames), origin=(self.width / 2, self.height / 2)
)
self.sprites[asset.activity][asset.direction] = sprite
self.activity, direction_sprite = list(self.sprites.items())[0]
self.direction = list(direction_sprite.keys())[0]
super().on_load()
def rotation_to_directionproto(self):
match (int(self.rotation // 90) % 4) * 90:
case Direction.UP.value:
d = DirectionProto.DIRECTION_NORTH
case Direction.RIGHT.value:
d = DirectionProto.DIRECTION_EAST
case Direction.DOWN.value:
d = DirectionProto.DIRECTION_SOUTH
case Direction.LEFT.value:
d = DirectionProto.DIRECTION_WEST
case _:
assert False, "This should never be reached"
return d
def update(self, dt: float) -> None:
if self.is_loaded:
d = self.rotation_to_directionproto()
self.sprite = self.sprites[self.activity][d]
super().update(dt)
@dataclass
class InteractEntity(Entity):
interact_distance: float
interact_offset: Tuple[float, float]
interactable: bool
if DEBUG_INTERACTION:
interaction_bb: shapes.Circle | None
def __init__(
self,
interact_offset: Tuple[float, float] = (0, 0),
interact_distance: float = 0,
*args: int,
**kwargs: str,
) -> None:
super().__init__(*args, **kwargs)
self.interact_offset = interact_offset
self.interact_distance = interact_distance
if DEBUG_INTERACTION:
self.interaction_bb = None
self.interactable = True
def on_load(self) -> None:
super().on_load()
self.interact_offset = (self.width / 2, -self.height / 2)
if DEBUG_INTERACTION:
self.interaction_bb = shapes.Circle(
self.x + self.interact_offset[0],
-(self.y + self.interact_offset[1]),
self.interact_distance,
color=(80, 80, 0, 230),
)
def draw(self) -> None:
super().draw()
if DEBUG_INTERACTION:
if self.interaction_bb:
self.interaction_bb.x = self.x + self.interact_offset[0]
self.interaction_bb.y = -(self.y + self.interact_offset[1])
self.interaction_bb.draw()
def stop_interaction(self) -> None:
self.in_interaction = False
def interact(self) -> None:
self.in_interaction = True
@dataclass
class NamedEntity(Entity):
label: str
username_label: Label | None
batch: Batch | None
def __init__(self, batch: Batch | None = None, *args: int, **kwargs: str) -> None:
super().__init__(*args, **kwargs)
self.label = ""
self.username_label = None
self.batch = batch
def on_load(self) -> None:
self.username_label = Label(
self.label,
x=0,
y=0,
color=(0, 0, 0, 255),
anchor_x="center",
font_name="Times New Roman",
font_size=12,
batch=self.batch,
)
super().on_load()
def update(self, dt: float) -> None:
if self.username_label:
if self.label != self.username_label.text:
self.username_label.text = self.label
self.username_label.x = self.x + self.width / 2
self.username_label.y = -self.y + 40
super().update(dt)
def draw(self) -> None:
if self.username_label is not None:
# This is hack AF, pyglet should fix their label shaders
window = client.scene_manager.window
game = cast("Game", client.scene_manager.current_scene)
zoom: float = game.camera.zoom
old_window_view = window.view
window.view = (
window.view
@ Mat4.from_translation(
Vec3(
cast(int, self.username_label.x),
cast(int, self.username_label.y),
0,
)
)
@ Mat4.from_scale(Vec3(1 / zoom, 1 / zoom, 1))
@ Mat4.from_translation(
Vec3(
-cast(int, self.username_label.x),
-cast(int, self.username_label.y),
0,
)
)
)
# self.username_label.font_size = 12 * zoom
if self.batch is None:
self.username_label.draw()
window.view = old_window_view
return super().draw()
@dataclass
class ServerManagedEntity(Entity):
uuid: str
def __init__(self, uuid: str, *args: int, **kwargs: str) -> None:
super().__init__(*args, **kwargs)
self.uuid = uuid
def on_load(self) -> None:
super().on_load()
def update(self, dt: float) -> None:
super().update(dt)
def draw(self) -> None:
return super().draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/player.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/player.py | import time
from dataclasses import dataclass
from datetime import datetime
from typing import TYPE_CHECKING, Dict, List, cast
from pyglet import shapes
from pyglet.window import key
import client
from client.game.entities.enemy import Enemy
from client.game.entities.entity import Direction, InteractEntity, TilesetEntity
from shared.collison import CollisionManager
from shared.constants import PLAYER_HEIGHT, PLAYER_SPEED, PLAYER_WIDTH
from shared.gen.messages.v1 import Activity, SessionType
if TYPE_CHECKING:
from client.scenes.game import Game
PROGRESSBAR_WIDTH = 40
@dataclass
class Player(TilesetEntity, InteractEntity):
velocity_x: float
velocity_y: float
_direction: Direction
_x: float = 0.0
_y: float = 0.0
_rotation: float = 0.0
_attacking: bool = False
_last_attack: float = 0
def __init__(self, *args: int, **kwargs: str):
super().__init__(*args, **kwargs)
self.keys = key.KeyStateHandler()
self.event_handlers = [self, self.keys]
self.coords_dirty = False
self.velocity_x = 0
self.velocity_y = 0
self._direction = Direction.DOWN
self.can_move = True
self._x = 0
self._y = 0
self._rotation = 0
self._rotation = float(self._direction.value)
self.speed = PLAYER_SPEED
self.width = PLAYER_WIDTH
self.height = PLAYER_HEIGHT
self.bb = shapes.Rectangle(
self.x, self.y, self.width, self.height, color=(255, 0, 30)
)
self.collision_manager = CollisionManager(self.width, self.height)
self.interact_distance = 0
self._attacking = False
self._last_attack = 0
self.progressbar = shapes.BorderedRectangle(
x=0,
y=0,
width=PROGRESSBAR_WIDTH,
height=7,
border=3,
color=(0, 255, 0),
border_color=(0, 0, 0),
)
self.outer_progressbar = shapes.Rectangle(
x=0, y=0, width=PROGRESSBAR_WIDTH, height=7, color=(179, 174, 173, 127)
)
self.progress = -1.0
self.progressbar_offset_x = 10
self.progressbar_offset_y = -25
@property
def direction(self) -> Direction:
return self._direction
@property
def x(self) -> float:
return self._x
@property
def y(self) -> float:
return self._y
@property
def rotation(self) -> float:
return self._rotation
@direction.setter
def direction(self, value: Direction) -> None:
if value != self._direction:
self.coords_dirty = True
self._direction = value
self._rotation = float(value.value)
@x.setter
def x(self, value: float) -> None:
if value != self._x:
self.coords_dirty = True
self._x = value
@y.setter
def y(self, value: float) -> None:
if value != self._y:
self.coords_dirty = True
self._y = value
@rotation.setter # pyright: ignore[reportIncompatibleVariableOverride]
def rotation(self, value: float) -> None:
value %= 360
if value != self._rotation:
self.coords_dirty = True
self._rotation = value
def _find_attack_enemy(self):
direction = self.rotation_to_directionproto()
self.sprites[Activity.ACTIVITY_ATTACKING][
direction
].frame_index = 0 # Reset attack animation to start
self.sprite = self.sprites[Activity.ACTIVITY_ATTACKING][direction]
objects_in_range: List[Enemy] = client.game_state.get_objects_in_range(
distance_squared=400
)
enemy_obj = None
# print("Obj in range: " + str(len(objects_in_range)))
if len(objects_in_range) == 0:
return
enemy_obj = objects_in_range[0] # TODO: Differentiate between enemies
client.global_connection.attack_enemy(
time=datetime.now(), uuid=enemy_obj.uuid, damage=10
)
def _update_move(self, dt: float) -> None:
game: Game = cast("Game", client.scene_manager.current_scene)
self.velocity_x = 0
self.velocity_y = 0
keys = cast(Dict[int, bool], client.scene_manager.keys.data)
controller = client.scene_manager.controller
if controller:
if abs(controller.leftx) >= 0.25:
self.velocity_x = controller.leftx
if abs(controller.lefty) >= 0.25:
self.velocity_y = controller.lefty
match keys:
case {key.LEFT: True, key.RIGHT: True} | {key.A: True, key.D: True}:
pass
case {key.LEFT: True} | {key.A: True}:
self.velocity_x = -1
case {key.RIGHT: True} | {key.D: True}:
self.velocity_x = 1
case _:
pass
match keys:
case {key.UP: True, key.DOWN: True} | {key.W: True, key.S: True}:
pass
case {key.UP: True} | {key.W: True}:
self.velocity_y = -1
case {key.DOWN: True} | {key.S: True}:
self.velocity_y = 1
case _:
pass
if client.game_state.session_type == SessionType.SESSION_TYPE_NORMAL:
match keys:
case {key.SPACE: True}:
if self.can_attack():
self._attacking = True
self._last_attack = time.time()
self._find_attack_enemy()
case _:
pass
if self.velocity_x != 0 and self.velocity_y != 0:
self.velocity_x *= 0.7071 # 1/sqrt(2)
self.velocity_y *= 0.7071
self.velocity_x *= self.speed
self.velocity_y *= self.speed
new_x = self.x + self.velocity_x * dt
new_y = self.y + self.velocity_y * dt
if client.game_state.session_type != SessionType.SESSION_TYPE_FREE_CAM:
match self.collision_manager.check_collisons(
game.map,
self.x,
self.y,
new_x,
new_y,
):
case None:
return
case (next_x, next_y):
pass
if next_x != self.x or next_y != self.y:
self.activity = Activity.ACTIVITY_WALKING
else:
self.activity = Activity.ACTIVITY_IDLE
# Handle attacking
# If we attack, we cancel all movements
if self._attacking:
self.activity = Activity.ACTIVITY_ATTACKING
if self.can_attack(): # Attack finished, we might attack again
self._attacking = False
if not self._attacking:
if next_y > self.y:
self.direction = Direction.DOWN
elif next_y < self.y:
self.direction = Direction.UP
elif next_x > self.x:
self.direction = Direction.RIGHT
elif next_x < self.x:
self.direction = Direction.LEFT
else:
if self.velocity_x != 0 and self.velocity_y != 0:
pass
elif self.velocity_x > 0:
self.direction = Direction.RIGHT
elif self.velocity_x < 0:
self.direction = Direction.LEFT
elif self.velocity_y < 0:
self.direction = Direction.UP
elif self.velocity_y > 0:
self.direction = Direction.DOWN
self.x = next_x # pyright: ignore[reportIncompatibleVariableOverride]
self.y = next_y # pyright: ignore[reportIncompatibleVariableOverride]
else:
self.x = new_x # pyright: ignore[reportIncompatibleVariableOverride]
self.y = new_y # pyright: ignore[reportIncompatibleVariableOverride]
def update(self, dt: float) -> None:
if self.can_move:
self._update_move(dt)
super().update(dt)
def can_attack(self):
return time.time() > self._last_attack + 0.600 # One attack is 600ms
def draw(self) -> None:
if client.game_state.session_type == SessionType.SESSION_TYPE_FREE_CAM:
return
self.bb.x = self.x
self.bb.y = -self.y
# Draw health bar below the enemy
if self.progress >= 0:
self.outer_progressbar.x = (
self.x + self.progressbar_offset_x - PROGRESSBAR_WIDTH / 2
)
self.outer_progressbar.y = -(self.y + self.progressbar_offset_y)
self.outer_progressbar.draw()
self.progressbar.x = (
self.x + self.progressbar_offset_x - Enemy.HEALTHBAR_WIDTH / 2
)
if self.progress > 0 and self.progress <= 1:
self.progressbar.y = -(self.y + self.progressbar_offset_y)
self.progressbar.width = int(PROGRESSBAR_WIDTH * (self.progress))
self.progressbar.draw()
return super().draw()
def on_load(self) -> None:
super().on_load()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/enemy.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/entities/enemy.py | import time
from dataclasses import dataclass
from typing import Any
from pyglet import shapes
import client
from client.game.entities.entity import (
InteractEntity,
NamedEntity,
ServerManagedEntity,
TilesetEntity,
)
from shared.constants import SERVER_TICK_RATE
from shared.gen.messages.v1 import Activity, InteractStatus
def is_c_between_ab(
a: tuple[float, float],
b: tuple[float, float],
c: tuple[float, float],
epsilon: float = 4, # this is in pixels, so this can be quite large
) -> tuple[bool, float]:
# check aabb
minX, maxX = (a[0], b[0]) if a[0] < b[0] else (b[0], a[0])
minY, maxY = (a[1], b[1]) if a[1] < b[1] else (b[1], a[1])
if (
c[0] < (minX - epsilon)
or c[0] > (maxX + epsilon)
or c[1] < (minY - epsilon)
or c[1] > (maxY + epsilon)
):
return False, -1
if b[1] != a[1] and c[1] != a[1]:
s1 = (b[0] - a[0]) / (b[1] - a[1])
s2 = (c[0] - a[0]) / (c[1] - a[1])
return abs(s1 - s2) < epsilon, abs(s1 - s2)
if b[0] != a[0] and c[0] != a[0]:
s1 = (b[1] - a[1]) / (b[0] - a[0])
s2 = (c[1] - a[1]) / (c[0] - a[0])
return abs(s1 - s2) < epsilon, abs(s1 - s2)
return True, -1
@dataclass
class Enemy(TilesetEntity, NamedEntity, InteractEntity, ServerManagedEntity):
HEALTHBAR_WIDTH = 40
health: int
health_max: int
last_attack: float
is_dead: bool
dead_time: float
def __init__(
self,
health: int,
health_max: int,
last_attack: float,
*args: int,
**kwargs: Any,
) -> None:
super().__init__(*args, **kwargs)
self.rotation = 90.0
self.activity = Activity.ACTIVITY_IDLE
self.label = "T-RRRRRRREX"
self.bb = None
self.bb_offset_x = 4
self.bb_offset_y = -3
self.last_x = 0
self.next_x = 0
self.last_y = 0
self.next_y = 0
self.in_interaction = False
self.interact_distance = 0
self.health = health
self.health_max = health_max
self.health_bar = None
self.health_bar_outer = None
self.health_bar_offset_x = 10
self.health_bar_offset_y = -25
self.is_dead = False
self.dead_time = 0
self.last_attack = last_attack
def on_load(self) -> None:
self.bb = shapes.Rectangle(
self.x + self.bb_offset_x,
-(self.y + self.bb_offset_y),
self.width,
self.height,
color=(0, 0, 255),
)
# TEMP: Draw circle for aggro notice
self.bb = shapes.Circle(
x=self.x,
y=-(self.y),
radius=80,
color=(0, 0, 255, 40),
)
self.health_bar = shapes.BorderedRectangle(
x=0,
y=0,
width=Enemy.HEALTHBAR_WIDTH,
height=7,
border=3,
color=(255, 0, 0),
border_color=(0, 0, 0),
)
self.health_bar_outer = shapes.Rectangle(
x=0, y=0, width=Enemy.HEALTHBAR_WIDTH, height=7, color=(179, 174, 173, 127)
)
super().on_load()
def stop_interaction(self) -> None:
if self.in_interaction:
if self.sprite:
self.sprite.scale_x = 1
client.global_connection.interact(
self.uuid, text="", status=InteractStatus.INTERACT_STATUS_STOP
)
super().stop_interaction()
def update(self, dt: float) -> None:
next_x = client.game_state.objects[self.uuid][1].coords.x
next_y = client.game_state.objects[self.uuid][1].coords.y
last_x = client.game_state.objects[self.uuid][0].coords.x
last_y = client.game_state.objects[self.uuid][0].coords.y
if next_x != last_x or next_y != last_y:
self.activity = Activity.ACTIVITY_WALKING
pred_x = self.x + (next_x - last_x) * (SERVER_TICK_RATE * dt)
pred_y = self.y + (next_y - last_y) * (SERVER_TICK_RATE * dt)
val, _err = is_c_between_ab(
(last_x, last_y), (next_x, next_y), (pred_x, pred_y)
)
if val:
# pred okay
new_x = pred_x
new_y = pred_y
else:
# miss
new_x = last_x
new_y = last_y
# Update other properties like health, name, ...
self.health = client.game_state.objects[self.uuid][1].enemy_info.health
self.health_max = client.game_state.objects[self.uuid][1].enemy_info.health_max
self.name = client.game_state.objects[self.uuid][1].enemy_info.name
self.last_attack = client.game_state.objects[self.uuid][
1
].enemy_info.last_attack
self.label = (
f"{self.name} ({self.health} HP)" # TODO: make name label update better
)
if time.time() - self.last_attack < 1: # Attack was in last second
self.activity = Activity.ACTIVITY_ATTACKING
if self.health <= 0 and self.is_dead == False:
self.is_dead = True
self.dead_time = time.time()
elif self.health > 0:
self.is_dead = False
if self.is_dead:
self.activity = Activity.ACTIVITY_DEATH
self.label = ""
if self.x > new_x:
self.rotation = 270
else:
self.rotation = 90
self.x = new_x
self.y = new_y
super().update(dt)
def draw(self) -> None:
if self.is_dead and (time.time() - self.dead_time) > 0.5:
return # Dont draw enemey after death animation
if self.bb is not None:
self.bb.x = self.x + self.bb_offset_x
self.bb.y = -(self.y + self.bb_offset_y)
self.bb.draw()
if self.health > 0:
# Draw health bar below the enemy
if self.health_bar_outer is not None:
self.health_bar_outer.x = (
self.x + self.health_bar_offset_x - Enemy.HEALTHBAR_WIDTH / 2
)
self.health_bar_outer.y = -(self.y + self.health_bar_offset_y)
self.health_bar_outer.draw()
if self.health_bar is not None and self.health_max != 0:
self.health_bar.x = (
self.x + self.health_bar_offset_x - Enemy.HEALTHBAR_WIDTH / 2
)
self.health_bar.y = -(self.y + self.health_bar_offset_y)
self.health_bar.width = int(
Enemy.HEALTHBAR_WIDTH * (self.health / self.health_max)
)
self.health_bar.draw()
return super().draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/dialog.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/dialog.py | from typing import Callable, cast
from pyglet import clock
from pyglet.graphics import Batch
from pyglet.gui.widgets import WidgetBase
from pyglet.image import Texture
from pyglet.text.document import FormattedDocument
from pyglet.text.layout import TextLayout, _Line # pyright: ignore[reportPrivateUsage]
from client.game.nearest_sprite import NearestSprite
from client.game.ui import get_ui_grid
from client.game.ui.tilebox import TileBox
DialogCallback = Callable[[], None] | None
class Dialog(WidgetBase):
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
text: list[str],
batch: Batch,
cb: DialogCallback = None,
) -> None:
self.text = text
self._outline = TileBox(x, y, width, height)
offset = self._outline.tile_size
self.inner_width = (width // self._outline.tile_size) * self._outline.tile_size
self.inner_height = (
height // self._outline.tile_size
) * self._outline.tile_size
self.text_idx = 0
self.document = FormattedDocument("")
self.flow_document = FormattedDocument("")
self.flow_document_layout = TextLayout(
height=self.inner_height - offset * 2,
width=self.inner_width - offset * 2,
document=self.flow_document,
multiline=True,
)
self.flow_document_layout.visible = False
self.flow_document_layout.x = x + offset
self.flow_document_layout.y = y + offset
self._layout = TextLayout(
height=self.inner_height - offset * 2,
width=self.inner_width - offset * 2,
batch=batch,
document=self.document,
multiline=True,
)
self._layout.x = x + offset
self._layout.y = y + offset
self._blink = NearestSprite(
cast(Texture, get_ui_grid()[23]),
x=x + self.inner_width - offset - cast(int, get_ui_grid().item_width) - 4,
y=y + offset,
origin=(
cast(int, get_ui_grid().item_width) // 2,
cast(int, get_ui_grid().item_height) // 2,
),
)
self._blink.scale = 2.2
self._blink.visible = False
self._pressed = False
self._wait_for_next_page = True
self._char_idx = 0
self.PERIOD = 0.01 # in s
self.BLINK_PERIOD = 0.5
self.cb = cb
clock.schedule_interval(self._do_blink, self.BLINK_PERIOD)
super().__init__(x, y, width, height)
self.enabled = len(self.text) != 0
self.dirty = True
def _do_blink(self, dt: float) -> None:
if not self.enabled:
return
self._blink.visible = not self._blink.visible
def draw(self) -> None:
if not self.enabled:
return
if self.dirty:
self.next_text()
self.dirty = False
self._outline.draw()
self._blink.draw()
def _next_char(self, dt: float) -> None:
if not self.enabled:
return
if len(self.text) == 0:
return
# Breaks if text start with a space
if self.text[self.text_idx][self._char_idx] == " ":
# check if next word would wrap
# get next word
next_word = self.text[self.text_idx][self._char_idx + 1 :].split(" ")[0]
self.flow_document.text = self.document.text + " " + next_word
flow_lines = cast(
list[_Line],
self.flow_document_layout._get_lines(), # pyright: ignore[reportPrivateUsage]
)
layout_lines = cast(
list[_Line],
self._layout._get_lines(), # pyright: ignore[reportPrivateUsage]
)
if len(flow_lines) > len(layout_lines):
# would wrap insert newline
self.document.insert_text(
len(self.document.text), "\n", {"color": (255, 255, 255, 255)}
)
# skip whitespace
self._char_idx += 1
if cast(int, self.flow_document_layout.content_height) > cast(
int, self.flow_document_layout.height
):
self._wait_for_next_page = True
clock.unschedule(self._next_char)
clock.schedule_interval(self._do_blink, self.BLINK_PERIOD)
self._blink.visible = True
if not self._wait_for_next_page:
self.document.insert_text(
len(self.document.text),
self.text[self.text_idx][self._char_idx],
{"color": (0, 0, 0, 255)},
)
self._char_idx += 1
if self._char_idx >= len(self.text[self.text_idx]):
clock.unschedule(self._next_char)
clock.schedule_interval(self._do_blink, self.BLINK_PERIOD)
self.text_idx += 1
self._char_idx = 0
self._blink.visible = True
def next_text(self) -> None:
if not self.enabled:
return
self._blink.visible = False
clock.unschedule(self._do_blink)
if self._wait_for_next_page:
self._wait_for_next_page = False
self.document.text = ""
self.flow_document.text = ""
clock.schedule_interval(self._next_char, self.PERIOD)
return
clock.unschedule(self._next_char)
if self.text_idx >= len(self.text):
if self.cb:
self.cb()
return
if self.text_idx != 0:
self.document.insert_text(
len(self.document.text), " ", {"color": (255, 255, 255, 255)}
)
clock.schedule_interval(self._next_char, self.PERIOD)
def on_mouse_press(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled or not self._check_hit(x, y):
return
if not self._pressed:
self.next_text()
self._pressed = True
def on_mouse_release(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled or not self._pressed:
return
self._pressed = False
def append_text(self, text: str) -> None:
self.reset()
self.text.append(text)
self.dirty = True
def start(self, text: list[str], cb: DialogCallback = None) -> None:
self.text = text
self.enabled = True
self.cb = cb
self.next_text()
def stop(self) -> None:
self.reset()
self.enabled = False
self.cb = None
def reset(self) -> None:
self.text = []
self.document.text = ""
self.flow_document.text = ""
self._blink.visible = False
self._pressed = False
self._wait_for_next_page = True
self._char_idx = 0
self.text_idx = 0
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/input.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/input.py | import inspect
from typing import Any, cast
import pyperclip
from pyglet.graphics import Batch, Group
from pyglet.gui import TextEntry
from pyglet.text.document import AbstractDocument
from pyglet.window.key import MOTION_COPY, MOTION_PASTE
from client import MOTION_DELETE_REST, MOTION_SELECT_ALL
from client.game.ui.tilebox import TileStrip
class AdvancedTextEntry(TextEntry):
def on_text_motion(self, motion: int):
handled = False
if self._focus:
handled = True
doc = cast(AbstractDocument, self._layout.document)
caret_doc = cast(
AbstractDocument,
self._caret._layout.document, # pyright: ignore[reportPrivateUsage]
)
match motion:
case MOTION_COPY.real:
selected_text = (
doc.text[
self._layout._selection_start : self._layout._selection_end # pyright: ignore[reportPrivateUsage]
],
)
pyperclip.copy(selected_text)
case MOTION_PASTE.real:
self.on_text(pyperclip.paste())
case MOTION_SELECT_ALL.real:
self._caret.position = 0
self._caret.mark = len(doc.text)
self._layout.set_selection(0, len(doc.text))
case MOTION_DELETE_REST.real:
w = self._caret._next_word_re.search( # pyright: ignore[reportPrivateUsage]
caret_doc.text,
cast(
int,
self._caret._position, # pyright: ignore[reportPrivateUsage]
),
)
caret_doc.delete_text(
cast(
int,
self._caret._position, # pyright: ignore[reportPrivateUsage]
),
w.endpos if w else len(doc.text),
)
case _:
handled = False
if not handled:
super().on_text_motion(motion)
class TextInput(AdvancedTextEntry):
def __init__(
self,
text: str,
x: int,
y: int,
width: int,
color: tuple[int, int, int, int] = ...,
text_color: tuple[int, int, int, int] = ...,
caret_color: tuple[int, int, int, int] = ...,
batch: Batch | None = None,
group: Group | None = None,
):
self.bg = TileStrip(
x - 13 * 2,
y - 8,
width + 13 * 2,
32,
32,
3,
23,
group=group,
)
super().__init__(
text,
x + 13,
y,
width - 32,
color,
text_color,
caret_color,
batch,
group,
)
def draw(self):
self.bg.draw()
class Proxy:
wrap: AbstractDocument
def __init__(self, wrap: AbstractDocument):
self.__dict__["wrap"] = wrap
def __getattr__(self, name: str):
if name == "text":
stack = inspect.stack()
if stack[1][0].f_code.co_name == "on_text":
return getattr(self.wrap, name)
return "*" * len(getattr(self.wrap, name))
return getattr(self.wrap, name)
def __setattr__(self, name: str, value: Any):
setattr(self.wrap, name, value)
class PasswordInput(TextInput):
def __init__(
self,
text: str,
x: int,
y: int,
width: int,
color: tuple[int, int, int, int] = ...,
text_color: tuple[int, int, int, int] = ...,
caret_color: tuple[int, int, int, int] = ...,
batch: Batch | None = None,
group: Group | None = None,
):
super().__init__(
text, x, y, width, color, text_color, caret_color, batch, group
)
self._layout.document = Proxy(cast(AbstractDocument, self._layout.document))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/slider.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/slider.py | from typing import cast
from pyglet.graphics import Batch, Group
from pyglet.gui.widgets import WidgetBase
from pyglet.image import Texture
from client.game.nearest_sprite import NearestSprite
from client.game.ui import get_ui_grid
from client.game.ui.tilebox import TileStrip
class Slider(WidgetBase):
def __init__(
self,
x: float,
y: float,
width: float,
height: float,
batch: Batch | None = None,
group: Group | None = None,
) -> None:
edge = 0
knob_height = 64
knob_width = width + 32
super().__init__(x, y, max(width, knob_width), height)
self._edge = edge
self._half_knob_width = knob_width / 2
self._half_knob_height = knob_height / 2
self._min_knob_y = y + edge
self._max_knob_y = y + height - knob_height - edge
self._user_group = group
bg_group = Group(order=0, parent=group)
fg_group = Group(order=1, parent=group)
new_height = ((height / 2) // 32) * 32
self._base_spr = TileStrip(
x - width % 32 - 4,
y + height / 2 - new_height / 2,
group=bg_group,
width=int(width),
height=int(new_height),
horizontal=False,
tile_offset_x=19,
tile_offset_y=6,
scale_x=3.65,
scale_y=3.65,
)
self._knob_spr = NearestSprite(
cast(Texture, get_ui_grid()[61 * 5 + 22]),
int(x + width / 2 - self._half_knob_width) - 2,
int(y + edge),
group=fg_group,
)
self._knob_spr.scale_x = knob_width / 16
self._knob_spr.scale_y = knob_height / 16
self._value = 0
self._in_update = False
def draw(self) -> None:
self._base_spr.draw()
self._knob_spr.draw()
@property
def value(self) -> float:
return self._value
@value.setter
def value(self, value: float) -> None:
self._value = value
y = (
(self._max_knob_y - self._min_knob_y) * value / 100
+ self._min_knob_y
+ self._half_knob_height
)
self._knob_spr.y = max(
self._min_knob_y, min(y - self._half_knob_height, self._max_knob_y)
)
@property
def _min_x(self) -> float:
return cast(float, self._x - self._half_knob_width)
@property
def _max_x(self) -> float:
return cast(float, self._x + self._half_knob_width + self.width / 2)
@property
def _min_y(self) -> float:
return cast(float, self._y + self._edge)
@property
def _max_y(self) -> float:
return cast(float, self._y + self._height - self._edge)
def _check_hit(self, x: int, y: int) -> bool:
return self._min_x < x < self._max_x and self._min_y < y < self._max_y
def _update_knob(self, y: float) -> None:
self._knob_spr.y = max(
self._min_knob_y, min(y - self._half_knob_height, self._max_knob_y)
)
self._value = abs(
((self._knob_spr.y - self._min_knob_y) * 100)
/ (self._min_knob_y - self._max_knob_y)
)
self.dispatch_event("on_change", self._value)
def on_mouse_press(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled:
return
if self._check_hit(x, y):
self._in_update = True
self._update_knob(y)
def on_mouse_drag(
self, x: int, y: int, dx: int, dy: int, buttons: int, modifiers: int
) -> None:
if not self.enabled:
return
if self._in_update:
self._update_knob(y)
def on_mouse_scroll(self, x: int, y: int, mouse: int, direction: int) -> None:
if not self.enabled:
return
if self._check_hit(x, y):
self._update_knob(self._knob_spr.y + self._half_knob_height + direction)
def on_mouse_release(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled:
return
self._in_update = False
Slider.register_event_type("on_change")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/utils.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/utils.py | from typing import Callable, cast
from pyglet.graphics import Batch, Group
from pyglet.gui import Frame
from pyglet.image import Animation
from client.game.ui import get_ui_grid
from client.game.ui.button import ImageButton
from client.game.ui.tilebox import TileBox
class Exit(Group):
height: int = 32 * 3
def __init__(
self,
x: int,
y: int,
exit_func: Callable[[], None],
frame: Frame,
batch: Batch | None = None,
order: int = 0,
parent: Group | None = None,
) -> None:
super().__init__(order, parent)
self.frame = frame
self.exit_func = exit_func
self.exit_button = ImageButton(
img=Animation.from_image_sequence(
get_ui_grid()[61 * 3 + 48 : 61 * 3 + 51],
duration=0.01,
),
x=x + self.height // 2 - cast(int, get_ui_grid().item_width) // 2,
y=y + self.height // 2 - cast(int, get_ui_grid().item_height) // 2,
scale_x=2,
scale_y=2,
group=self,
)
self.exit_button.set_handler("on_press", self.exit)
self.bg = TileBox(
x=x,
y=y,
width=self.height,
height=self.height,
tile_size=32,
tile_offset_x=3,
tile_offset_y=10,
group=self,
)
def activate(self) -> None:
self.frame.add_widget(self.exit_button)
def exit(self) -> None:
self.exit_func()
def draw(self) -> None:
if self.bg:
self.bg.draw()
if self.exit_button:
self.exit_button.draw()
def __del__(self) -> None:
self.frame.remove_widget(self.exit_button)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/tilebox.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/tilebox.py | import logging
from functools import cache
from pyglet.gl import (
GL_BLEND,
GL_CLAMP_TO_EDGE,
GL_NEAREST,
GL_ONE_MINUS_SRC_ALPHA,
GL_SRC_ALPHA,
GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER,
GL_TEXTURE_MIN_FILTER,
GL_TEXTURE_WRAP_S,
GL_TEXTURE_WRAP_T,
GL_TRIANGLES,
glBlendFunc,
glDisable,
glEnable,
glTexParameteri,
)
from pyglet.graphics import Group
from pyglet.graphics.shader import Shader, ShaderProgram
from client.game.ui import get_ui_image
TILE_SIZE_X = 16
TILE_SIZE_Y = 16
VERTEX_SOURCE = """#version 330 core
in vec2 tex_coords;
in vec2 position;
out vec2 texture_pos;
out vec3 vertex_colors;
uniform vec2 translation;
uniform vec2 scale;
uniform vec3 color_add;
uniform bool center;
uniform WindowBlock
{ // This UBO is defined on Window creation, and available
mat4 projection; // in all Shaders. You can modify these matrixes with the
mat4 view; // Window.view and Window.projection properties.
} window;
mat4 m_translate = mat4(1.0);
mat4 m_scale = mat4(1.0);
void main()
{
m_translate[3][0] = translation.x;
m_translate[3][1] = translation.y;
m_scale[0][0] = scale.x;
m_scale[1][1] = scale.y;
gl_Position = window.projection * window.view * m_translate * m_scale * vec4(position, 0, 1);
texture_pos = tex_coords;
vertex_colors = color_add;
}
"""
FRAGMENT_SOURCE = """#version 330 core
in vec2 texture_pos;
in vec3 vertex_colors;
out vec4 final_color;
uniform sampler2D texture_atlas;
void main()
{
vec4 tex_color = texture(texture_atlas, texture_pos);
final_color = tex_color + vec4(vertex_colors, 0) *tex_color.w;
}
"""
@cache
def get_tile_box_shader() -> ShaderProgram:
logging.debug("Map Shader Recalc")
vert_shader = Shader(VERTEX_SOURCE, "vertex")
frag_shader = Shader(FRAGMENT_SOURCE, "fragment")
return ShaderProgram(vert_shader, frag_shader)
def create_quad(
x: float, y: float, ts: int
) -> tuple[float, float, float, float, float, float, float, float]:
x = x * ts
y = y * ts
x2 = x + ts
y2 = y + ts
return (x, y, x2, y, x2, y2, x, y2)
def create_quad_tex(
x: float, y: float, w: float, h: float
) -> tuple[float, float, float, float, float, float, float, float]:
x = x * TILE_SIZE_X
y = y * TILE_SIZE_Y
x2 = x + TILE_SIZE_X
y2 = y + TILE_SIZE_Y
x /= w
x2 /= w
y /= h
y2 /= h
y = 1 - y
y2 = 1 - y2
return (x, y2, x2, y2, x2, y, x, y)
def gen_quad_indices(n: int) -> tuple[int, int, int, int, int, int]:
offset = n * 4
return (0 + offset, 1 + offset, 2 + offset, 0 + offset, 2 + offset, 3 + offset)
class TileStrip(Group):
def __init__(
self,
x: float,
y: float,
width: int,
height: int,
tile_size: int = 32,
tile_offset_x: int = 0,
tile_offset_y: int = 0,
scale_x: float = 1,
scale_y: float = 1,
group: Group | None = None,
horizontal: bool = True,
):
self.color_add: tuple[float, float, float] = (0, 0, 0)
self.scale_x = scale_x
self.scale_y = scale_y
self.tile_offset_x = tile_offset_x
self.tile_offset_y = tile_offset_y
self.tile_size = tile_size
self.width = width - width % -tile_size
self.width = max(tile_size * 3, self.width)
self.height = height - height % -tile_size
self.x = x
self.y = y
self.horizontal = horizontal
self.vlist = None
self.program = get_tile_box_shader()
super().__init__(parent=group)
def set_state(self):
# glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
self.program.use()
self.texture.bind(0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def unset_state(self):
glDisable(GL_BLEND)
self.program.stop()
# glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
def draw(self):
if self.vlist is None:
image = get_ui_image()
self.texture = image.get_texture()
position: list[float] = []
indices: list[int] = []
tex_coords: list[float] = []
match self.horizontal:
case True:
for x in range(int(self.width // self.tile_size)):
position += create_quad(
x=x - (self.width // self.tile_size) / 2,
y=-0.5,
ts=self.tile_size,
)
indices += gen_quad_indices(x)
tile_offset_x = 0
if x > 0:
tile_offset_x += 1
if x == self.width // self.tile_size - 1:
tile_offset_x += 1
tex_coords += create_quad_tex(
self.tile_offset_x + tile_offset_x,
self.tile_offset_y,
image.width,
image.height,
)
case False:
for y in range(int(self.height // self.tile_size)):
position += create_quad(
x=-0.5,
y=y - (self.height // self.tile_size) / 2,
ts=self.tile_size,
)
indices += gen_quad_indices(y)
tile_offset_y = 0
if y > 0:
tile_offset_y -= 1
if y == self.height // self.tile_size - 1:
tile_offset_y -= 1
tex_coords += create_quad_tex(
self.tile_offset_x,
self.tile_offset_y + tile_offset_y,
image.width,
image.height,
)
self.vlist = self.program.vertex_list_indexed(
4 * (self.width // self.tile_size) * (self.height // self.tile_size),
GL_TRIANGLES,
indices,
position=("f", position),
tex_coords=("f", tex_coords),
)
self.program["translation"] = (
self.x + self.width / 2,
self.y + self.height / 2,
)
self.program["scale"] = (self.scale_x, self.scale_y)
self.program["color_add"] = self.color_add
# self.program["center"] = center
self.set_state_recursive()
self.vlist.draw(GL_TRIANGLES)
self.unset_state_recursive()
class TileBox(Group):
def __init__(
self,
x: float,
y: float,
width: float,
height: float,
color: tuple[int, int, int, int] = (80, 0, 80, 255),
tile_size: int = 32,
tile_offset_x: int = 0,
tile_offset_y: int = 0,
scale_x: float = 1,
scale_y: float = 1,
group: Group | None = None,
):
self.scale_x = scale_y
self.scale_y = scale_x
self.tile_size = tile_size
self.width = (width // tile_size) * tile_size
self.height = (height // tile_size) * tile_size
self.x = x
self.y = y
self.vlist = None
self.tile_offset_x = tile_offset_x
self.tile_offset_y = tile_offset_y
self.program = get_tile_box_shader()
super().__init__(parent=group)
def set_state(self):
# glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
self.program.use()
self.texture.bind(0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def unset_state(self):
glDisable(GL_BLEND)
self.program.stop()
# glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
def draw(self):
if self.vlist is None:
image = get_ui_image()
self.texture = image.get_texture()
position: list[float] = []
indices: list[int] = []
tex_coords: list[float] = []
for x in range(int(self.width // self.tile_size)):
for y in range(int(self.height // self.tile_size)):
position += create_quad(x, y, self.tile_size)
indices += gen_quad_indices(
int(self.width // self.tile_size) * y + x
)
tile_offset_x = 0
tile_offset_y = 2
if x > 0:
tile_offset_x += 1
if x == self.width // self.tile_size - 1:
tile_offset_x += 1
if y > 0:
tile_offset_y -= 1
if y == self.height // self.tile_size - 1:
tile_offset_y -= 1
tex_coords += create_quad_tex(
self.tile_offset_x + tile_offset_x,
self.tile_offset_y + tile_offset_y,
image.width,
image.height,
)
self.vlist = self.program.vertex_list_indexed(
int(
4 * (self.width // self.tile_size) * (self.height // self.tile_size)
),
GL_TRIANGLES,
indices,
position=("f", position),
tex_coords=("f", tex_coords),
)
self.program["translation"] = (self.x, self.y)
self.program["scale"] = (self.scale_x, self.scale_y)
self.program["color_add"] = (0, 0, 0)
# self.program["center"] = center
self.set_state_recursive()
self.vlist.draw(GL_TRIANGLES)
self.unset_state_recursive()
def delete(self):
if self.vlist:
self.vlist.delete()
self.vlist = None
def __del__(self):
if self.vlist:
self.vlist.delete()
self.vlist = None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/__init__.py | from functools import cache
from pathlib import Path
from typing import cast
import pyglet
from pyglet.image import ImageData, TextureGrid
import client
@cache
def get_ui_image() -> ImageData:
return cast(
ImageData,
pyglet.image.load(Path(client.PATH, "assets/ui/16x16/Modern_UI_Style_1.png")),
)
@cache
def get_ui_grid() -> TextureGrid:
rows = 43
columns = 61
image_grid = pyglet.image.ImageGrid(get_ui_image(), rows=rows, columns=columns)
texture_grid = image_grid.get_texture_sequence()
# for some reason the grid is upside down, ouch
texture_grid.items = [
x
for i in range(rows)
for x in cast(list[int], texture_grid.items[i * columns :][:columns][::-1])
][::-1]
return texture_grid
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/dropdown.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/dropdown.py | from typing import cast
from pyglet.graphics import Batch, Group
from pyglet.gui.widgets import WidgetBase
from pyglet.shapes import Rectangle
from pyglet.text import Label
class DropdownEntry(WidgetBase):
def __init__(self, x: int, y: int, text: str, batch: Batch, group: Group):
padding = 0
self._label = Label(
text,
x=x + padding,
y=y + padding,
batch=batch,
anchor_y="bottom",
color=(255, 255, 255, 255),
group=group,
)
label_width = self._label.content_width
label_height = cast(int, self._label.content_height)
width = label_width + padding * 2
height = label_height + padding * 2
super().__init__(x, y, width, height)
class Dropdown(WidgetBase):
def __init__(
self,
x: int,
y: int,
entries: list[str],
batch: Batch,
) -> None:
self.group = Group()
self.entries: list[DropdownEntry] = []
height = 0
width = 0
for entry in entries[::-1]:
dentry = DropdownEntry(
x=x, y=y + height, text=entry, batch=batch, group=self.group
)
height += dentry.height
width = max(width, dentry.width)
self.entries.append(dentry)
self._outline = Rectangle(
x, y, width, height, color=(80, 0, 80, 255), batch=batch
)
self._selector = Rectangle(
x, y, width, 0, color=(255, 255, 255, 255), batch=batch
)
self._selector.opacity = 0
self.selected_entry = None
super().__init__(x, y, width, height)
def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
if self._check_hit(x, y):
for entry in self.entries:
if entry.y < y < entry.y + entry.height:
break
else:
self._selector.opacity = 0
if self.selected_entry:
self.selected_entry._label.color = ( # pyright: ignore[reportPrivateUsage]
255,
255,
255,
255,
)
self.selected_entry = None
return
self._selector.x = entry.x
self._selector.y = entry.y
self._selector.height = entry.height
self._selector.opacity = 255
if self.selected_entry:
self.selected_entry._label.color = ( # pyright: ignore[reportPrivateUsage]
255,
255,
255,
255,
)
entry._label.color = (0, 0, 0, 255) # pyright: ignore[reportPrivateUsage]
self.selected_entry = entry
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/button.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/client/client/game/ui/button.py | from typing import cast
from pyglet.graphics import Batch, Group
from pyglet.gui.widgets import WidgetBase
from pyglet.image import Animation, AnimationFrame, Texture
from pyglet.text import Label
from client.game.nearest_sprite import NearestSprite
from client.game.ui.tilebox import TileStrip
class ButtonBase(WidgetBase):
def __init__(self, x: float, y: float, width: float, height: float) -> None:
self._pressed = False
self.enabled = True
self._hover = False
super().__init__(x, y, width, height)
def pressed(self) -> None:
pass
def released(self) -> None:
pass
def on_mouse_press(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled or not self._check_hit(x, y):
return
self._pressed = True
self.pressed()
self.dispatch_event("on_press")
def on_mouse_release(self, x: int, y: int, buttons: int, modifiers: int) -> None:
if not self.enabled or not self._pressed:
return
self._pressed = False
self.released()
self.dispatch_event("on_release")
def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
if not self.enabled or not self._check_hit(x, y):
self._hover = False
return
self._hover = True
def _update_position(self) -> None:
pass
ButtonBase.register_event_type("on_press")
ButtonBase.register_event_type("on_release")
class Button(ButtonBase):
def __init__(
self,
x: int,
y: int,
width: int,
height: int,
batch: Batch,
group: Group | None = None,
color: tuple[int, int, int, int] = (80, 0, 80, 255),
) -> None:
self._outline = TileStrip(
x + 24,
y,
width + 16 * 3,
height=height,
tile_offset_x=3,
tile_offset_y=23,
scale_y=1.2,
scale_x=1.2,
group=group,
)
self._outline.x -= 32
super().__init__(
x + 8 * self._outline.scale_x,
y - 8,
(self._outline.width - 16 * 3) * self._outline.scale_x,
(self._outline.height) * self._outline.scale_y,
)
def _update_position(self) -> None:
self._outline.x = self._x
self._outline.y = self._y
def draw(self) -> None:
if self._hover:
self._outline.color_add = (0.1, 0.1, 0.1)
else:
self._outline.color_add = (0, 0, 0)
self._outline.draw()
class TextButton(Button):
def __init__(
self, text: str, x: int, y: int, batch: Batch, group: Group | None = None
) -> None:
self._label = Label(
text,
x=x,
y=y + 4,
batch=batch,
group=group,
anchor_y="bottom",
color=(0, 0, 0, 255),
)
label_width = self._label.content_width
label_height = cast(int, self._label.content_height)
width = label_width
height = label_height
super().__init__(x, y, width, height, batch, group=group)
self._label.x += label_width / 2 - 4
def draw(self) -> None:
super().draw()
def _update_position(self) -> None:
self._label.x = self._x
self._label.y = self._y
super()._update_position()
class ImageButton(ButtonBase):
def __init__(
self,
img: Texture | Animation,
x: int,
y: int,
group: Group | None = None,
scale_x: float = 1.0,
scale_y: float = 1.0,
) -> None:
match img:
case Texture() as t:
width = t.width
height = t.height
self._animate = False
case Animation():
width = cast(int, img.get_max_width())
height = cast(int, img.get_max_height())
self._animate = True
cast(AnimationFrame, img.frames[-1]).duration = None
self._image = NearestSprite(
img=img,
x=x,
y=y,
group=group,
origin=(width // 2, height // 2),
)
if self._animate:
self._image.paused = True
self._image.scale_x = scale_x
self._image.scale_y = scale_y
self._w = width
self._h = height
super().__init__(
x - (self._w * (self._image.scale_x - 1)) / 2,
y - (self._h * (self._image.scale_y - 1)) / 2,
width * scale_x,
height * scale_y,
)
@property
def x(self) -> float:
return self._x
@x.setter
def x(self, value: float) -> None:
self._image.x = value + (self._w * (self._image.scale_x - 1)) / 2
self._x = value
@property
def y(self) -> float:
return self._y
@y.setter
def y(self, value: float) -> None:
self._image.y = value + (self._h * (self._image.scale_y - 1)) / 2
self._y = value
def pressed(self) -> None:
if self._animate:
self._image.paused = False
def released(self) -> None:
if self._animate:
self._image._next_dt = 0 # pyright: ignore[reportPrivateUsage]
self._image._animate(0) # pyright: ignore[reportPrivateUsage]
self._image.paused = True
def draw(self) -> None:
self._image.draw()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/constants.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/constants.py | CHUNK_SIZE_X: int = 32
CHUNK_SIZE_Y: int = 32
TILE_SIZE_X: int = 16
TILE_SIZE_Y: int = 16
NUM_TILES_PER_COLUM: int = 16
PLAYER_SPEED: int = 100
PLAYER_WIDTH: int = 16
PLAYER_HEIGHT: int = 16
PLAYER_DEATH_TIMEOUT = 60 * 5 # 5 minutes
VIEW_DISTANCE: int = 500
VIEW_DISTANCE_SQ: int = pow(VIEW_DISTANCE, 2)
SERVER_TICK_RATE: int = 30
TARGET_FPS: int = 30
TARGET_UPS: int = 60
START_X = 80
START_Y = 80
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/collison.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/collison.py | import functools
import operator
from typing import Iterator, Tuple
import collision
from shared.gen.messages.v1 import Polygon
from shared.map import Map
def bb(x: float, y: float, w: float, h: float) -> Iterator[Tuple[float, float]]:
yield x, y
yield x + w, y
yield x + w, y + h
yield x, y + h
cached_polys: dict[int, collision.Concave_Poly] = {}
def to_poly(poly: Polygon) -> collision.Concave_Poly:
id_ = id(poly)
if id_ in cached_polys:
return cached_polys[id_]
p = collision.Concave_Poly(
collision.Vector(0, 0),
[collision.Vector(p.x, p.y) for p in poly.points],
)
cached_polys[id_] = p
return p
def point_in_poly(x: float, y: float, poly: Polygon) -> bool:
to_test = to_poly(poly=poly)
return collision.point_in_poly(collision.Vector(x, y), to_test)
class CollisionManager:
def __init__(self, width: int, height: int) -> None:
self.width = width
self.height = height
# handle different collision types so that we only cancel direction of collision
def _do_edge_detection(
self,
map: Map,
old_x: float,
old_y: float,
new_x: float,
new_y: float,
offset_x: int,
offset_y: int,
user_id: str,
) -> Tuple[float, float] | None:
player = collision.Poly(
collision.Vector(new_x, old_y),
[
collision.Vector(x, y)
for x, y in [
(0, 0),
(0, self.height),
(self.width, self.height),
(self.width, 0),
]
],
)
player2 = collision.Poly(
collision.Vector(old_x, new_y),
[
collision.Vector(x, y)
for x, y in [
(0, 0),
(0, self.height),
(self.width, self.height),
(self.width, 0),
]
],
)
match map.get_tiles(new_x + offset_x, old_y + offset_y, user_id):
case None:
return
case tiles, tx, ty:
pass
for col in functools.reduce(
operator.iconcat, [tile.collision for tile in tiles], []
):
poly = collision.Concave_Poly(
collision.Vector(tx, ty),
[collision.Vector(p.x, p.y) for p in col.points],
)
c = collision.collide(poly, player)
if c:
break
else:
return (new_x, old_y)
match map.get_tiles(old_x + offset_x, new_y + offset_y, user_id):
case None:
return
case tiles2, tx2, ty2:
pass
for col in functools.reduce(
operator.iconcat, [tile.collision for tile in tiles2], []
):
poly = collision.Concave_Poly(
collision.Vector(tx2, ty2),
[collision.Vector(p.x, p.y) for p in col.points],
)
c = collision.collide(poly, player2)
if c:
break
else:
return (old_x, new_y)
return (old_x, old_y)
def check_collisons(
self,
map: Map,
old_x: float,
old_y: float,
new_x: float,
new_y: float,
user_id: str = "",
) -> Tuple[float, float] | None:
entity = collision.Poly(
collision.Vector(new_x, new_y),
[
collision.Vector(x, y)
for x, y in [
(0, 0),
(0, self.height),
(self.width, self.height),
(self.width, 0),
]
],
)
colls: set[int] = set()
for idx, (x, y) in enumerate(bb(new_x, new_y, self.width, -self.height)):
match map.get_tiles(x=x, y=y, user_id=user_id):
case None:
return None
case tiles, tx, ty:
pass
for tile in tiles:
for col in tile.collision:
poly = collision.Concave_Poly(
collision.Vector(tx, ty),
[collision.Vector(p.x, p.y) for p in col.points],
)
resp = collision.Response()
c = collision.collide(poly, entity, resp)
if c:
colls.add(idx)
match list(colls):
case []:
return (new_x, new_y)
case [0, 1]:
return (new_x, old_y)
case [0, 3]:
return (old_x, new_y)
case [2, 3]:
return (new_x, old_y)
case [1, 2]:
return (old_x, new_y)
case [0]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, 0, 0, user_id
)
case [1]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, self.width, 0, user_id
)
case [2]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, self.width, -self.height, user_id
)
case [3]:
return self._do_edge_detection(
map, old_x, old_y, new_x, new_y, 0, -self.height, user_id
)
case _:
pass
return (old_x, old_y)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/lazy.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/lazy.py | import builtins
from collections.abc import Iterator
from enum import EnumMeta
from typing import Any
import betterproto
class Lazy:
cls: type
def __init__(self, cls: type) -> None:
self.cls = cls
def get_default(self, sub_cls: type) -> Any:
match sub_cls:
case builtins.str:
return ""
case builtins.int:
return 0
case builtins.float:
return 0.0
case builtins.bool:
return False
case builtins.bytes:
return b""
case builtins.list:
return LazyList([], cls=sub_cls)
case EnumMeta():
return list(sub_cls)[0]
case _:
return LazyDict({}, cls=sub_cls)
class LazyList(list[Any], Lazy):
def __init__(self, a: list[Any], cls: type) -> None:
Lazy.__init__(self=self, cls=cls)
super().__init__(a)
def __getitem__(self, items: Any) -> Any:
ret = super().__getitem__(items)
match ret:
case dict():
new_value = LazyDict(ret, cls=self.cls)
case list():
new_value = LazyList(ret, cls=self.cls)
case _:
new_value = ret
super().__setitem__(items, new_value)
return new_value
def __iter__(self) -> Iterator[Any]:
for ret in super().__iter__():
match ret:
case dict():
yield LazyDict(ret, cls=self.cls)
case list():
yield LazyList(ret, cls=self.cls)
case _:
yield ret
class LazyDict(dict[str, Any], Lazy):
def __init__(self, a: dict[str, Any], cls: type) -> None:
Lazy.__init__(self=self, cls=cls)
super().__init__(a)
self.object = None
def __getattr__(self, __name: str) -> Any:
if self.object:
return self.object.__getattribute__(__name)
key = betterproto.casing.camel_case(__name)
sub_cls: Any = self.cls._cls_for(self.cls.__dataclass_fields__[__name]) # type: ignore
if key in self:
ret = self[key]
match sub_cls:
case EnumMeta():
new_value = sub_cls(ret)
case _:
match ret:
case dict():
new_value = LazyDict(ret, cls=sub_cls)
case list():
new_value = LazyList(ret, cls=sub_cls)
case _:
new_value = ret
else:
new_value = self.get_default(sub_cls)
self[key] = new_value
return new_value
@property # type: ignore
def __class__(self) -> type:
return self.cls
def to_dict(
self,
casing: betterproto.Casing = betterproto.Casing.CAMEL,
include_default_values: bool = False,
) -> dict[str, Any]:
if not self.object:
value = self.cls().from_dict(self)
self.object = value
return self.object.to_dict(casing, include_default_values)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/bidict.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/bidict.py | from __future__ import annotations
from typing import Generic, TypeVar
_KT = TypeVar("_KT")
_VT = TypeVar("_VT")
class BijectionError(Exception, Generic[_VT]):
"""Must set a unique value in a BijectiveMap."""
def __init__(self, value: _VT) -> None:
self.value = value
msg = 'The value "{}" is already in the mapping.'
super().__init__(msg.format(value))
class BijectiveMap(dict[_KT, _VT]):
"""Invertible map."""
inverse: BijectiveMap[_VT, _KT]
def __init__(self, inverse: BijectiveMap[_VT, _KT] | None = None) -> None:
if inverse is None:
inverse = self.__class__(inverse=self)
self.inverse = inverse
def __setitem__(self, key: _KT, value: _VT) -> None:
if value in self.inverse:
raise BijectionError(value)
self.inverse._set_item(value, key)
self._set_item(key, value)
def __delitem__(self, key: _KT) -> None:
self.inverse._del_item(self[key])
self._del_item(key)
def _del_item(self, key: _KT) -> None:
super().__delitem__(key)
def _set_item(self, key: _KT, value: _VT) -> None:
super().__setitem__(key, value)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/utils.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/utils.py | from __future__ import annotations
from asyncio import Lock
from threading import Timer
from typing import Any, Awaitable, Callable, List
class AsyncLockEventHandler(object):
lock: Lock
def __init__(
self, handlers: List[Callable[[Lock, *Any], Awaitable[None]]] | None = None
) -> None:
self.lock = Lock()
if handlers is None:
self.__eventhandlers = []
else:
self.__eventhandlers = handlers
def __iadd__(
self, handler: Callable[[Lock, *Any], Awaitable[None]]
) -> AsyncLockEventHandler:
self.__eventhandlers.append(handler)
return self
def __isub__(
self, handler: Callable[[Lock, *Any], Awaitable[None]]
) -> AsyncLockEventHandler:
self.__eventhandlers.remove(handler)
return self
async def __call__(self, *args: Any, **keywargs: Any) -> None:
for eventhandler in self.__eventhandlers:
await eventhandler(self.lock, *args, **keywargs)
class AsyncEventHandler(object):
def __init__(
self, handlers: List[Callable[..., Awaitable[None]]] | None = None
) -> None:
if handlers is None:
self.__eventhandlers = []
else:
self.__eventhandlers = handlers
def __iadd__(self, handler: Callable[..., Awaitable[None]]) -> AsyncEventHandler:
self.__eventhandlers.append(handler)
return self
def __isub__(self, handler: Callable[..., Awaitable[None]]) -> AsyncEventHandler:
self.__eventhandlers.remove(handler)
return self
async def __call__(self, *args: Any, **keywargs: Any) -> None:
for eventhandler in self.__eventhandlers:
await eventhandler(*args, **keywargs)
class EventHandler(object):
def __init__(self, handlers: List[Callable[..., None]] | None = None) -> None:
if handlers is None:
self.__eventhandlers = []
else:
self.__eventhandlers = handlers
def __iadd__(self, handler: Callable[..., None]) -> EventHandler:
self.__eventhandlers.append(handler)
return self
def __isub__(self, handler: Callable[..., None]) -> EventHandler:
self.__eventhandlers.remove(handler)
return self
def __call__(self, *args: Any, **keywargs: Any) -> None:
for eventhandler in self.__eventhandlers:
eventhandler(*args, **keywargs)
class RepeatedTimer(object):
def __init__(
self, interval: int, function: Callable[..., None], *args: Any, **kwargs: Any
) -> None:
self._timer = None
self.interval = interval
self.function = function
self.args = args
self.kwargs = kwargs
self.is_running = False
self.start()
def _run(self) -> None:
self.is_running = False
self.start()
self.function(*self.args, **self.kwargs)
def start(self) -> None:
if not self.is_running:
self._timer = Timer(self.interval, self._run)
self._timer.start()
self.is_running = True
def stop(self) -> None:
if self._timer:
self._timer.cancel()
self._timer.join()
self.is_running = False
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/map.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/map.py | from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import List, Tuple
from shared.gen.messages.v1 import Polygon
@dataclass
class Tile:
chunk_atlas_offset: int
collision: List[Polygon]
class Map(ABC):
@abstractmethod
def get_tiles(
self, x: float, y: float, user_id: str
) -> Tuple[List[Tile], float, float] | None:
pass
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/gen/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/gen/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/gen/messages/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/gen/messages/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/gen/messages/v1/__init__.py | ctfs/CCCamp/2023/game/Dig_It_Up/src/shared/shared/gen/messages/v1/__init__.py | # Generated by the protocol buffer compiler. DO NOT EDIT!
# sources: messages/v1/entity.proto, messages/v1/messages.proto, messages/v1/tile.proto
# plugin: python-betterproto
# This file has been @generated
from dataclasses import dataclass
from datetime import datetime
from typing import List
import betterproto
class Direction(betterproto.Enum):
DIRECTION_UNSPECIFIED = 0
DIRECTION_NORTH = 1
DIRECTION_EAST = 2
DIRECTION_SOUTH = 3
DIRECTION_WEST = 4
class Activity(betterproto.Enum):
ACTIVITY_UNSPECIFIED = 0
ACTIVITY_IDLE = 1
ACTIVITY_WALKING = 2
ACTIVITY_ATTACKING = 3
ACTIVITY_DEATH = 4
class ObjectType(betterproto.Enum):
OBJECT_TYPE_UNSPECIFIED = 0
OBJECT_TYPE_NPC = 1
OBJECT_TYPE_ENEMY = 2
OBJECT_TYPE_AREA = 3
OBJECT_TYPE_PICKUPABLE = 4
class InteractStatus(betterproto.Enum):
INTERACT_STATUS_UNSPECIFIED = 0
INTERACT_STATUS_START = 1
INTERACT_STATUS_UPDATE = 2
INTERACT_STATUS_STOP = 3
class InteractType(betterproto.Enum):
INTERACT_TYPE_UNSPECIFIED = 0
INTERACT_TYPE_TEXT = 1
INTERACT_TYPE_SHOP = 2
INTERACT_TYPE_DIG = 3
INTERACT_TYPE_RUNNER = 4
INTERACT_TYPE_CUT_OUT = 5
INTERACT_TYPE_LICENSE = 6
class ShopInteractType(betterproto.Enum):
SHOP_INTERACT_TYPE_UNSPECIFIED = 0
SHOP_INTERACT_TYPE_BUY = 1
SHOP_INTERACT_TYPE_SELL = 2
SHOP_INTERACT_TYPE_TRADE = 3
class RunnerAction(betterproto.Enum):
RUNNER_ACTION_UNSPECIFIED = 0
RUNNER_ACTION_JUMP = 1
RUNNER_ACTION_MAYBE_ADD_OBSTACLE = 2
RUNNER_ACTION_DIE = 3
class SessionType(betterproto.Enum):
SESSION_TYPE_UNSPECIFIED = 0
SESSION_TYPE_NORMAL = 1
SESSION_TYPE_FREE_CAM = 2
class ErrorType(betterproto.Enum):
ERROR_TYPE_UNSPECIFIED = 0
ERROR_TYPE_UNAUTHORIZED = 1
ERROR_TYPE_INVALID_CHUNK = 2
ERROR_TYPE_INVALID_OBJECT = 3
ERROR_TYPE_TIMEOUT = 4
ERROR_TYPE_ALREADY_LOGGED_IN = 5
@dataclass(eq=False, repr=False)
class Point(betterproto.Message):
x: float = betterproto.double_field(1)
y: float = betterproto.double_field(2)
@dataclass(eq=False, repr=False)
class Polygon(betterproto.Message):
points: List["Point"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class TileCollision(betterproto.Message):
polygons: List["Polygon"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class AnimationStep(betterproto.Message):
id: int = betterproto.int32_field(1)
duration: int = betterproto.int32_field(2)
@dataclass(eq=False, repr=False)
class Animation(betterproto.Message):
id: int = betterproto.int32_field(1)
animation_setps: List["AnimationStep"] = betterproto.message_field(2)
@dataclass(eq=False, repr=False)
class Tileset(betterproto.Message):
tileset: bytes = betterproto.bytes_field(1)
width: int = betterproto.int32_field(2)
height: int = betterproto.int32_field(3)
animations: List["Animation"] = betterproto.message_field(4)
@dataclass(eq=False, repr=False)
class Object(betterproto.Message):
uuid: str = betterproto.string_field(1)
coords: "Coords" = betterproto.message_field(2)
type: "ObjectType" = betterproto.enum_field(3)
remove: bool = betterproto.bool_field(4)
enemy_info: "EnemyInfo" = betterproto.message_field(5)
area: "Polygon" = betterproto.message_field(6)
pickupable: "Item" = betterproto.message_field(7)
@dataclass(eq=False, repr=False)
class EnemyInfo(betterproto.Message):
health: int = betterproto.int32_field(1)
health_max: int = betterproto.int32_field(2)
name: str = betterproto.string_field(3)
last_attack: float = betterproto.double_field(4)
@dataclass(eq=False, repr=False)
class Objects(betterproto.Message):
objects: List["Object"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class ObjectAssetRequest(betterproto.Message):
uuid: str = betterproto.string_field(1)
@dataclass(eq=False, repr=False)
class EntityAsset(betterproto.Message):
id: int = betterproto.int32_field(1)
direction: "Direction" = betterproto.enum_field(2)
activity: "Activity" = betterproto.enum_field(3)
@dataclass(eq=False, repr=False)
class EntityAssets(betterproto.Message):
height: int = betterproto.int32_field(1)
width: int = betterproto.int32_field(2)
tileset: "Tileset" = betterproto.message_field(3)
entity_assets: List["EntityAsset"] = betterproto.message_field(4)
collisions: List["TileCollision"] = betterproto.message_field(5)
@dataclass(eq=False, repr=False)
class ObjectAsset(betterproto.Message):
object_uuid: str = betterproto.string_field(1)
assets: "EntityAssets" = betterproto.message_field(2)
name: str = betterproto.string_field(3)
type: "ObjectType" = betterproto.enum_field(4)
interactable: bool = betterproto.bool_field(5)
interact_distance: float = betterproto.double_field(6)
@dataclass(eq=False, repr=False)
class Interact(betterproto.Message):
uuid: str = betterproto.string_field(1)
text: str = betterproto.string_field(2)
status: "InteractStatus" = betterproto.enum_field(3)
type: "InteractType" = betterproto.enum_field(4)
shop: List["ShopInteract"] = betterproto.message_field(5)
progress: float = betterproto.double_field(6)
runner: "Runner" = betterproto.message_field(7)
@dataclass(eq=False, repr=False)
class ShopInteract(betterproto.Message):
item: "Item" = betterproto.message_field(1)
cost: int = betterproto.int32_field(2)
type: "ShopInteractType" = betterproto.enum_field(3)
trade_in: "Item" = betterproto.message_field(4)
@dataclass(eq=False, repr=False)
class Item(betterproto.Message):
name: str = betterproto.string_field(1)
description: str = betterproto.string_field(2)
icon: int = betterproto.int32_field(3)
quantity: int = betterproto.int32_field(4)
@dataclass(eq=False, repr=False)
class RunnerEvent(betterproto.Message):
time: float = betterproto.double_field(1)
action: "RunnerAction" = betterproto.enum_field(2)
@dataclass(eq=False, repr=False)
class Runner(betterproto.Message):
events: List["RunnerEvent"] = betterproto.message_field(1)
dts: List[float] = betterproto.double_field(2)
@dataclass(eq=False, repr=False)
class Coords(betterproto.Message):
x: float = betterproto.double_field(1)
y: float = betterproto.double_field(2)
rotation: float = betterproto.double_field(3)
@dataclass(eq=False, repr=False)
class User(betterproto.Message):
uuid: str = betterproto.string_field(1)
username: str = betterproto.string_field(2)
coords: "Coords" = betterproto.message_field(3)
money: int = betterproto.int32_field(4)
inventory: List["Item"] = betterproto.message_field(5)
health: int = betterproto.int32_field(6)
last_death: float = betterproto.float_field(7)
@dataclass(eq=False, repr=False)
class Users(betterproto.Message):
users: List["User"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class Login(betterproto.Message):
username: str = betterproto.string_field(1)
password: str = betterproto.string_field(2)
@dataclass(eq=False, repr=False)
class LoggedIn(betterproto.Message):
success: bool = betterproto.bool_field(1)
self: "User" = betterproto.message_field(2)
assets: "EntityAssets" = betterproto.message_field(3)
interact_distance: float = betterproto.double_field(4)
type: "SessionType" = betterproto.enum_field(5)
error: "ErrorType" = betterproto.enum_field(6)
@dataclass(eq=False, repr=False)
class Ping(betterproto.Message):
time: datetime = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class MapChunk(betterproto.Message):
x: int = betterproto.int32_field(1)
y: int = betterproto.int32_field(2)
height: int = betterproto.int32_field(3)
width: int = betterproto.int32_field(4)
tiles: List[int] = betterproto.int32_field(5)
tileset: "Tileset" = betterproto.message_field(6)
collisions: List["TileCollision"] = betterproto.message_field(7)
@dataclass(eq=False, repr=False)
class MapChunkRequest(betterproto.Message):
x: int = betterproto.int32_field(1)
y: int = betterproto.int32_field(2)
@dataclass(eq=False, repr=False)
class Error(betterproto.Message):
type: "ErrorType" = betterproto.enum_field(1)
message: str = betterproto.string_field(2)
@dataclass(eq=False, repr=False)
class Logout(betterproto.Message):
user: "User" = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class GiveDamage(betterproto.Message):
"""Message related to fighting"""
damage: int = betterproto.int32_field(1)
@dataclass(eq=False, repr=False)
class AcknowledgeDamage(betterproto.Message):
damage: int = betterproto.int32_field(1)
@dataclass(eq=False, repr=False)
class AttackEnemy(betterproto.Message):
time: datetime = betterproto.message_field(1)
uuid: str = betterproto.string_field(2)
damage: int = betterproto.int32_field(3)
@dataclass(eq=False, repr=False)
class ClientMessage(betterproto.Message):
ping: "Ping" = betterproto.message_field(1, group="message")
login: "Login" = betterproto.message_field(2, group="message")
coords: "Coords" = betterproto.message_field(3, group="message")
chunk_request: "MapChunkRequest" = betterproto.message_field(4, group="message")
object_asset_request: "ObjectAssetRequest" = betterproto.message_field(
5, group="message"
)
interact: "Interact" = betterproto.message_field(6, group="message")
acknowledge_damage: "AcknowledgeDamage" = betterproto.message_field(
7, group="message"
)
attack_enemy: "AttackEnemy" = betterproto.message_field(8, group="message")
logout: "Logout" = betterproto.message_field(9, group="message")
uuid: str = betterproto.string_field(100)
@dataclass(eq=False, repr=False)
class MapChunkResponse(betterproto.Message):
chunks: List["MapChunk"] = betterproto.message_field(1)
@dataclass(eq=False, repr=False)
class ServerMessage(betterproto.Message):
ping: "Ping" = betterproto.message_field(1, group="message")
logged_in: "LoggedIn" = betterproto.message_field(2, group="message")
users: "Users" = betterproto.message_field(3, group="message")
chunk: "MapChunkResponse" = betterproto.message_field(4, group="message")
error: "Error" = betterproto.message_field(5, group="message")
logout: "Logout" = betterproto.message_field(6, group="message")
objects: "Objects" = betterproto.message_field(7, group="message")
object_asset: "ObjectAsset" = betterproto.message_field(8, group="message")
interact: "Interact" = betterproto.message_field(9, group="message")
give_damage: "GiveDamage" = betterproto.message_field(10, group="message")
uuid: str = betterproto.string_field(100)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/server_runner.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/server_runner.py | from __future__ import annotations
import struct
import time
import traceback
from asyncio import (
Queue,
StreamReader,
StreamWriter,
as_completed,
create_task,
sleep,
start_server,
)
from copy import deepcopy
from datetime import datetime, timedelta
from threading import Event
from typing import Awaitable, Callable, Dict, Tuple, TypeVar, cast
from uuid import uuid4
from betterproto import which_one_of
import server
from server.game.auth import auth
from server.game.entity.area import AreaObject
from server.game.entity.enemy import Enemy
from server.game.entity.npc import NPC
from server.game.map.properties import CustomInteraction, InteractionOn
from shared.collison import point_in_poly
from shared.constants import PLAYER_DEATH_TIMEOUT, SERVER_TICK_RATE, START_X, START_Y
from shared.gen.messages.v1 import (
AcknowledgeDamage,
AttackEnemy,
ClientMessage,
Coords,
EnemyInfo,
Error,
ErrorType,
GiveDamage,
Interact,
InteractStatus,
InteractType,
LoggedIn,
Login,
Logout,
MapChunkRequest,
MapChunkResponse,
Object,
ObjectAsset,
ObjectAssetRequest,
Objects,
ObjectType,
Ping,
ServerMessage,
SessionType,
User,
Users,
)
from shared.utils import AsyncEventHandler
ServerMessageOneOfType = (
Ping
| Login
| Coords
| MapChunkRequest
| ObjectAssetRequest
| Interact
| AcknowledgeDamage
| AttackEnemy
| Logout
)
ServerMessageOneOfTypeVar = TypeVar(
"ServerMessageOneOfTypeVar",
Ping,
Login,
Coords,
MapChunkRequest,
ObjectAssetRequest,
Interact,
AcknowledgeDamage,
AttackEnemy,
Logout,
)
class Connection:
reader: StreamReader
writer: StreamWriter
# (ServerMessage, Handler)
network_queue: Queue[
Tuple[ServerMessage, Callable[[ServerMessageOneOfType], None] | None]
]
handlers: Dict[str, Callable[[ServerMessageOneOfType], None]]
peer: str
def __init__(self, reader: StreamReader, writer: StreamWriter) -> None:
self.reader = reader
self.writer = writer
self.network_queue = Queue()
self.handlers = {}
self.peer = reader._transport.get_extra_info("peername") # type: ignore
self.ping_handler = AsyncEventHandler([self._ping])
self.login_handler = AsyncEventHandler([self._login])
self.move_handler = AsyncEventHandler([self._move])
self.map_chunk_handler = AsyncEventHandler([self._chunk_request])
self.object_asset_handler = AsyncEventHandler([self._object_asset_request])
self.interact_handler = AsyncEventHandler([self._interact])
self.acknowledge_damage_handler = AsyncEventHandler([self._acknowledge_damage])
self.attack_enemy_handler = AsyncEventHandler([self._attack_enemy])
self.logout_handler = AsyncEventHandler([self._logout])
async def read_message_loop(self) -> None:
try:
while not self.reader.at_eof():
size_buf = await self.reader.readexactly(4)
size = struct.unpack("!i", size_buf)[0]
data_buf = await self.reader.readexactly(size)
message = ClientMessage().parse(data_buf)
message_id = message.uuid
_, inner_message = which_one_of(message=message, group_name="message")
match inner_message:
case Ping():
await self.ping_handler(message_id, inner_message)
case Login():
await self.login_handler(message_id, inner_message)
case Coords():
await self.move_handler(message_id, inner_message)
case MapChunkRequest():
await self.map_chunk_handler(message_id, inner_message)
case ObjectAssetRequest():
await self.object_asset_handler(message_id, inner_message)
case Interact():
await self.interact_handler(message_id, inner_message)
case AcknowledgeDamage():
await self.acknowledge_damage_handler(message_id, inner_message)
case AttackEnemy():
await self.attack_enemy_handler(message_id, inner_message)
case Logout():
await self.logout_handler(message_id, inner_message)
case default:
raise Exception(f"Unkown message_type: {default}")
except Exception:
traceback.print_exc()
if server.game_state.is_authenticated(self.peer):
await self.logout()
async def send_message_loop(self) -> None:
try:
while True:
message, handler = await self.network_queue.get()
if message.uuid == "":
message_id = str(uuid4())
message.uuid = message_id
if handler is not None:
self.handlers[message.uuid] = handler
self._send_message(message)
except Exception:
traceback.print_exc()
if server.game_state.is_authenticated(self.peer):
await self.logout()
def _send_message(self, client_message: ServerMessage) -> None:
message_bytes = client_message.SerializeToString()
message = struct.pack("!i", len(message_bytes)) + message_bytes
self.writer.write(message)
@staticmethod
def authenticated(
func: Callable[[Connection, str, ServerMessageOneOfTypeVar], Awaitable[None]]
) -> Callable[[Connection, str, ServerMessageOneOfTypeVar], Awaitable[None]]:
async def inner(
self: Connection, uuid: str, message: ServerMessageOneOfTypeVar
) -> None:
if server.game_state.is_authenticated(self.peer):
await func(self, uuid, message)
else:
response = ServerMessage(
error=Error(
type=ErrorType.ERROR_TYPE_UNAUTHORIZED,
message="Not logged in yet.",
),
uuid=uuid,
)
await self.network_queue.put((response, None))
return inner
@authenticated
async def _logout(self, uuid: str, message: Logout) -> None:
await self.logout()
async def logout(self) -> None:
session = server.game_state.peer_sessions[self.peer]
user = server.game_state.get_user(session.user_id)
if user is None:
return
if session.type != SessionType.SESSION_TYPE_FREE_CAM:
response = ServerMessage(logout=Logout(user=user))
await server.global_server.broadcast(response)
await server.game_state.logout(self.peer)
@authenticated
async def _ping(self, uuid: str, message: Ping) -> None:
await server.game_state.ping(self.peer, message)
response = ServerMessage(ping=Ping(time=datetime.now()), uuid=uuid)
await self.network_queue.put((response, None))
async def _login(self, uuid: str, message: Login) -> None:
res = auth(message.username, message.password)
error_msg = ErrorType.ERROR_TYPE_UNSPECIFIED
if res == None: # Invalid auth
error_msg = ErrorType.ERROR_TYPE_UNAUTHORIZED
user_uuid = server.game_state.get_user_uuid(message.username)
user = server.game_state.get_user(user_uuid)
if user is None:
user = await server.game_state.get_remote_fulluser(message.username)
if user:
user.coords.timestamp = datetime.now()
if user is None:
user_id = str(uuid4())
start_coords = Coords(x=START_X, y=START_Y)
start_coords.timestamp = datetime.now()
user = User(
username=message.username,
uuid=user_id,
coords=start_coords,
money=1000,
health=100,
last_death=0,
)
elif (
user.last_death != 0
and (time.time() - user.last_death)
< PLAYER_DEATH_TIMEOUT # Check if user is still in timeout
):
res = None
error_msg = ErrorType.ERROR_TYPE_TIMEOUT
else:
if server.game_state.is_logged_in(message.username):
res = None
error_msg = ErrorType.ERROR_TYPE_ALREADY_LOGGED_IN
if await server.game_state.is_logged_in_remote(message.username):
res = None
error_msg = ErrorType.ERROR_TYPE_ALREADY_LOGGED_IN
response = ServerMessage(
logged_in=LoggedIn(
success=res is not None,
type=res if res is not None else SessionType.SESSION_TYPE_UNSPECIFIED,
error=error_msg,
),
uuid=uuid,
)
if res:
response.logged_in.self = user
response.logged_in.assets = server.game_state.map.player_asset
response.logged_in.interact_distance = 14
await self.network_queue.put((response, None))
if res:
await server.game_state.login(self.peer, user.uuid, user, res)
if res != SessionType.SESSION_TYPE_FREE_CAM:
response = ServerMessage(users=Users(users=[user]))
await server.global_server.broadcast(response, exclude=[self.peer])
users = server.game_state.get_online_users(self.peer)
response = ServerMessage(
users=Users(users=users),
)
await self.network_queue.put((response, None))
await self._send_new_objects_view_distance(user)
@authenticated
async def _move(self, uuid: str, message: Coords) -> None:
message.timestamp = datetime.now()
valid = await server.game_state.move(self.peer, message)
session = server.game_state.peer_sessions[self.peer]
user_uuid = session.user_id
user = server.game_state.get_user(user_uuid)
if user is None:
return
await self._send_new_objects_view_distance(user)
if session.type != SessionType.SESSION_TYPE_FREE_CAM:
if not valid:
response = ServerMessage(users=Users(users=[user]))
await server.global_server.broadcast(response, include=[self.peer])
objects = server.game_state.get_objects_view_distance(
user_uuid, user.coords.x, user.coords.y
)
for o in objects:
match o:
case AreaObject():
if o.interaction_on != InteractionOn.COLLIDE:
continue
if point_in_poly(user.coords.x, user.coords.y, o.area):
if not o.actice:
interact = o.in_range(user_uuid)
if interact:
resp = ServerMessage()
resp.interact = interact
await server.global_server.broadcast(
resp, include=[self.peer]
)
elif o.actice:
interact = o.out_of_range(user_uuid)
if interact:
resp = ServerMessage()
resp.interact = interact
await server.global_server.broadcast(
resp, include=[self.peer]
)
case _:
pass
@authenticated
async def _chunk_request(self, uuid: str, message: MapChunkRequest) -> None:
session = server.game_state.peer_sessions[self.peer]
chunks = server.game_state.map.get_chunks(message.x, message.y, session.user_id)
response = ServerMessage(uuid=uuid)
if len(chunks) == 0:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_CHUNK,
message="Invalid Chunk requested",
)
else:
print("Sending Chunk", chunks[0].x, chunks[0].y)
response.chunk = MapChunkResponse(chunks=chunks)
await self.network_queue.put((response, None))
@authenticated
async def _acknowledge_damage(self, uuid: str, message: AcknowledgeDamage) -> None:
user_uuid = server.game_state.peer_sessions[self.peer].user_id
user = server.game_state.get_user(uuid=user_uuid)
if user is None:
return
response = ServerMessage(uuid=uuid)
if (
server.game_state.fight_manager.can_take_damage_user(
username=user.username, cooldown_ticks=30
)
and message.damage > 0
):
user.health -= message.damage
await self.network_queue.put((response, None))
await server.global_server.update_self(user.uuid)
@authenticated
async def _attack_enemy(self, uuid: str, message: AttackEnemy) -> None:
session = server.game_state.peer_sessions[self.peer]
if session.type != SessionType.SESSION_TYPE_NORMAL:
return
user = server.game_state.get_user(uuid=session.user_id)
if user is None:
print("User not found")
return
enemy = server.game_state.enemy_manager.get_enemy_for_user_by_uuid(
user_uuid=session.user_id, enemy_uuid=message.uuid
)
if enemy is None:
return # TODO: Enemy not found message to client?
if not server.game_state.fight_manager.is_plausible_attack(
user=user, enemy=enemy, attack_msg=message
):
print("not plausible attack")
return # TODO: Not plausible message to client?
if not server.game_state.fight_manager.can_take_damage_enemy(
enemy_uuid=enemy.uuid, cooldown_ticks=30
): # TODO: Dynamic cooldown for attacks
print("Enemy can't get damage again, cooldown not reached")
return # TODO: Not plausible message to client?
await enemy.take_damage(message.damage)
# We use `move_enemy_object` here to send the enemy update to the client. Lazy, but good enough
await server.global_server.move_enemy_object(
uuid=enemy.uuid,
x=enemy.x,
y=enemy.y,
health=enemy.health,
health_max=enemy.health_max,
last_attack=enemy.last_attack,
name=enemy.name,
include_user_ids=[user.uuid],
)
@authenticated
async def _object_asset_request(
self, uuid: str, message: ObjectAssetRequest
) -> None:
response = ServerMessage(uuid=uuid)
o = server.game_state.object_manager.get_object_by_uuid(message.uuid)
match o:
case NPC():
response.object_asset = ObjectAsset(
object_uuid=o.uuid,
assets=o.entity_assets,
name=o.name,
type=ObjectType.OBJECT_TYPE_NPC,
interactable=o.interactable,
interact_distance=o.interact_distance,
)
case Enemy():
response.object_asset = ObjectAsset(
object_uuid=o.uuid,
assets=o.entity_assets,
name=o.name,
type=ObjectType.OBJECT_TYPE_ENEMY,
interactable=False,
interact_distance=0,
)
case _:
if message.uuid in server.game_state.users:
response.object_asset = ObjectAsset(
object_uuid=message.uuid,
assets=server.game_state.map.player_asset,
)
elif (
await server.game_state.get_remote_userid(message.uuid) is not None
):
response.object_asset = ObjectAsset(
object_uuid=message.uuid,
assets=server.game_state.map.player_asset,
)
else:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
await self.network_queue.put((response, None))
@authenticated
async def _interact(self, uuid: str, message: Interact) -> None:
response = ServerMessage(uuid=uuid)
obj = server.game_state.object_manager.get_object_by_uuid(message.uuid)
if obj is None:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
else:
session = server.game_state.peer_sessions[self.peer]
user_id = session.user_id
if session.type != SessionType.SESSION_TYPE_NORMAL:
return
user = server.game_state.get_user(user_id)
match obj:
case AreaObject():
o = server.game_state.area_manager.get_areas_for_user_by_uuid(
user_uuid=user_id, area_uuid=message.uuid
)
if user is None or o is None:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
else:
if o.interaction_on != InteractionOn.INTERACT:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid interaction requested",
)
else:
if point_in_poly(user.coords.x, user.coords.y, o.area):
interact = await o.interact(user_id, message)
if not interact:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid interaction requested",
)
else:
response.interact = interact
case NPC():
o = server.game_state.npc_manager.get_npc_for_user_by_uuid(
user_uuid=user_id, npc_uuid=message.uuid
)
player_asset = server.game_state.map.player_asset
if user is None or o is None:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
else:
if not o.interactable:
return
dx = (user.coords.x + player_asset.width / 2) - (
(o.x + o.entity_assets.width / 2)
)
dy = (user.coords.y - player_asset.height / 2) - (
(o.y - o.entity_assets.height / 2)
)
distance_sq = dx**2 + dy**2
if distance_sq < (o.interact_distance + 14) ** 2:
status = message.status
text = ""
interaction_type = InteractType.INTERACT_TYPE_UNSPECIFIED
shop = []
progress = 0.0
if (
o.interactions[o.interaction_step].custom_interaction
== CustomInteraction.RUNNER
):
interaction = await o.interact(
user_id=user_id, interact=message
)
if o.runner_seed is not None:
progress = o.runner_seed
interaction_type = interaction.interaction_type
elif message.status != InteractStatus.INTERACT_STATUS_STOP:
interaction = await o.interact(
user_id=user_id, interact=message
)
text = await interaction.text
shop = interaction.shop
if (
text == ""
and len(shop) == 0
and interaction.interaction_type
!= InteractType.INTERACT_TYPE_RUNNER
):
status = InteractStatus.INTERACT_STATUS_STOP
interaction_type = interaction.interaction_type
for s in shop:
if s.item:
s.item.description = ""
if s.trade_in:
s.trade_in.description = ""
response.interact = Interact(
status=status,
uuid=message.uuid,
text=text,
type=interaction_type,
shop=shop,
progress=progress,
)
case _:
response.error = Error(
type=ErrorType.ERROR_TYPE_INVALID_OBJECT,
message="Invalid Object requested",
)
await self.network_queue.put((response, None))
async def _send_new_objects_view_distance(self, user: User) -> None:
objects: list[Object] = []
session = server.game_state.user_sessions[user.uuid]
for e in server.game_state.get_objects_view_distance(
uuid=user.uuid, x=user.coords.x, y=user.coords.y
):
if e.uuid in session.known_objects:
continue
obj_to_add = e.to_proto()
if e.type == ObjectType.OBJECT_TYPE_PICKUPABLE:
obj_to_add = deepcopy(obj_to_add)
obj_to_add.pickupable.description = ""
assert obj_to_add.type != ObjectType.OBJECT_TYPE_UNSPECIFIED, obj_to_add
objects.append(obj_to_add)
if len(objects) > 0:
session.known_objects |= set([o.uuid for o in objects])
response = ServerMessage(
objects=Objects(objects=objects),
)
await self.network_queue.put((response, None))
class Server:
connections: Dict[str, Connection]
def __init__(self, clickhouse_url: str) -> None:
self.connections = {}
self.clickhouse_url = clickhouse_url
async def start(self, host: str, port: int, running: Event) -> None:
self.running = running
await server.game_state.init(self.clickhouse_url)
s = await start_server(self.hande_cb, host=host, port=port)
update_loop_task = create_task(self.update_loop())
for coro in as_completed([update_loop_task]):
await coro
running.clear()
break
s.close()
# This is needed to give execution back to the control loop during the connection awaits
async def update_loop(self) -> None:
last_time = datetime.now()
while self.running.is_set():
current_time = datetime.now()
dt = (current_time - last_time).total_seconds()
if dt > (1 / (SERVER_TICK_RATE)) * 1.2:
print("REEE Server Lag")
await server.game_state.npc_manager.update(dt=dt)
await server.game_state.enemy_manager.update(dt=dt)
await server.game_state.pickupable_manager.update(dt=dt)
await server.game_state.object_manager.update(dt=dt)
# Check for user death and set timeout
for user in server.game_state.users.values():
if user.health < 0:
await server.game_state.die(user)
if user.uuid in server.game_state.user_sessions:
peer = server.game_state.user_sessions[user.uuid].peer
if (
peer in server.global_server.connections
and server.game_state.is_authenticated(peer)
):
await server.global_server.connections[peer].logout()
online_time = current_time - timedelta(minutes=1)
for s in list(server.game_state.peer_sessions.values()):
if s.last_ping.timestamp() < online_time.timestamp():
await server.global_server.connections[s.peer].logout()
await self.update_other_player_position()
last_time = datetime.now()
await sleep(1 / SERVER_TICK_RATE)
async def hande_cb(self, reader: StreamReader, writer: StreamWriter) -> None:
connection = Connection(reader, writer)
peer = cast(str, reader._transport.get_extra_info("peername")) # type: ignore
self.connections[peer] = connection
read_task = create_task(connection.read_message_loop())
send_task = create_task(connection.send_message_loop())
for coro in as_completed([read_task, send_task]):
await coro
break
del self.connections[peer]
def broadcast_sync(
self,
message: ServerMessage,
handler: Callable[[ServerMessageOneOfType], None] | None = None,
exclude: list[str] = [],
include: list[str] | None = None,
) -> None:
for peer, c in self.connections.items():
if not server.game_state.is_authenticated(peer):
continue
if peer in exclude:
continue
if include is not None and peer not in include:
continue
c.network_queue.put_nowait((message, handler))
async def broadcast(
self,
message: ServerMessage,
handler: Callable[[ServerMessageOneOfType], None] | None = None,
exclude: list[str] = [],
include: list[str] | None = None,
) -> None:
for peer, c in self.connections.items():
if not server.game_state.is_authenticated(peer):
continue
if peer in exclude:
continue
if include is not None and peer not in include:
continue
await c.network_queue.put((message, handler))
async def move_object(
self,
uuid: str,
x: float,
y: float,
include_user_ids: list[str] | None = None,
) -> None:
# No type specified, as this should be an object already known to the client
r = ServerMessage(objects=Objects([Object(uuid=uuid, coords=Coords(x=x, y=y))]))
users = server.game_state.get_local_users_distance(x, y)
users = [u.uuid for u in users]
if include_user_ids is not None:
users = [u for u in users if u in include_user_ids]
users_sessions = [
server.game_state.user_sessions[u].peer
for u in users
if u in server.game_state.user_sessions
]
if len(users_sessions) == 0:
return
await self.broadcast(r, include=users_sessions)
# This also includes enemy specific information
async def move_enemy_object(
self,
uuid: str,
x: float,
y: float,
health: int,
health_max: int,
last_attack: float,
name: str,
include_user_ids: list[str] | None = None,
) -> None:
# No type specified, as this should be an object already known to the client
r = ServerMessage(
objects=Objects(
[
Object(
uuid=uuid,
coords=Coords(x=x, y=y),
enemy_info=EnemyInfo(
health=health,
health_max=health_max,
name=name,
last_attack=last_attack,
),
)
]
)
)
users = server.game_state.get_local_users_distance(x, y)
users = [u.uuid for u in users]
if include_user_ids is not None:
users = [u for u in users if u in include_user_ids]
users_sessions = [
server.game_state.user_sessions[u].peer
for u in users
if u in server.game_state.user_sessions
]
if len(users_sessions) == 0:
return
await self.broadcast(r, include=users_sessions)
async def give_damage(
self, uuid: str, damage: int, include_user_ids: list[str] | None = None
) -> None:
r = ServerMessage(give_damage=GiveDamage(damage=damage))
users = server.game_state.users
if include_user_ids is not None:
users = [u for u in users if u in include_user_ids]
users_sessions = [
server.game_state.user_sessions[u].peer
for u in users
if u in server.game_state.user_sessions
]
if len(users_sessions) == 0:
return
await self.broadcast(r, include=users_sessions)
async def update_self(
self,
uuid: str,
) -> None:
user = server.game_state.users[uuid]
session = server.game_state.get_session(uuid)
r = ServerMessage(users=Users(users=[user]))
await server.game_state.update_remote_user(user)
if session:
await self.broadcast(r, include=[session])
async def update_other_player_position(self) -> None:
sessions = list(server.game_state.peer_sessions.values())
for s in sessions:
self_user = server.game_state.users.get(s.user_id, None)
if self_user is None:
continue
users = await server.game_state.get_online_users_distance(
self_user.coords.x, self_user.coords.y, s
)
new_known_users = set([u.uuid for u in users])
old_known_users = s.known_users - new_known_users
s.known_users = new_known_users
for u in old_known_users:
response = ServerMessage(logout=Logout(user=User(uuid=u)))
await server.global_server.broadcast(response, include=[s.peer])
message = ServerMessage(users=Users(users=users))
await self.broadcast(message, include=[s.peer])
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/models.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/models.py | from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Any
from shared.gen.messages.v1 import Coords, MapChunk, SessionType
@dataclass
class Position:
coords: Coords
time: datetime
@dataclass
class Session:
type: SessionType = field(default=SessionType.SESSION_TYPE_NORMAL)
peer: str = field(default_factory=str)
user_id: str = field(default_factory=str)
known_objects: set[str] = field(default_factory=set)
last_positions: list[Position] = field(default_factory=list[Position])
maze: list[list[MapChunk]] = field(default_factory=list)
waiting_maze_chunks: list[tuple[int, int]] = field(default_factory=list)
last_ping: datetime = field(default=datetime.now())
known_users: set[str] = field(default_factory=set)
logout: bool = field(default_factory=bool)
def __getstate__(self) -> None:
return None
def __setstate__(self, state: Any) -> None:
self.__dict__ = Session().__dict__
@dataclass
class ScoreboardEntry:
user_id: str
username: str | None = None
start: datetime | None = None
end: datetime | None = None
@property
def time(self) -> timedelta:
if self.start and self.end:
return self.end - self.start
return timedelta.max
def reset(self) -> None:
self.start = None
self.end = None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/main.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/main.py | import argparse
import logging
import os
import sys
import tempfile
from asyncio import get_event_loop
from concurrent.futures import ProcessPoolExecutor
from datetime import datetime
from threading import Event
from typing import cast
import dill
from rpyc.core import SlaveService
from rpyc.utils.server import ThreadedServer
import server
from server.game import auth
from server.game.state import Game
from server.server_runner import Server
def save_thread(file: str | None) -> None:
if file is None:
file = "backups/state.pickle"
state = server.game_state
with tempfile.NamedTemporaryFile(delete=False) as f:
dill.dump(state, f)
os.rename(f.name, file)
logging.info(msg=f"Backup saved in {file}")
def debug_server(path: str):
server = ThreadedServer(service=SlaveService, auto_register=False, socket_path=path)
import threading
thread = threading.Thread(target=server.start)
thread.daemon = True
thread.start()
def run() -> None:
# tracer = VizTracer(
# log_async=True, tracer_entries=10000000, output_file="result.json"
# )
# tracer.enable_thread_tracing()
# tracer.start()
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="Verbose", action="store_true")
parser.add_argument("-p", "--port", help="Port Default 1337", default=1337)
parser.add_argument("--host", help="Host Default 0.0.0.0", default="0.0.0.0")
parser.add_argument(
"--backup_file", help="Server backup file and auto restore", default=None
)
parser.add_argument("--debug_socket", help="Debug socket for server", default=None)
parser.add_argument("--auth_path", help="Path for credentials file", default=None)
parser.add_argument(
"--clickhouse_url", help="Clickhouse URL", default="http://localhost:8123/"
)
args = parser.parse_args()
log = logging.getLogger()
log.handlers.clear()
log.setLevel(level=logging.INFO)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
log.addHandler(handler)
assert args.auth_path, "Auth Path Needed"
auth.auth_path = args.auth_path
if args.debug_socket:
debug_server(args.debug_socket)
if args.verbose:
log.setLevel(level=logging.DEBUG)
server.executor = ProcessPoolExecutor(max_workers=4)
if args.backup_file and os.path.isfile(args.backup_file):
with open(args.backup_file, "rb") as f:
state = cast(Game, dill.load(f))
state.user_sessions = {}
state.peer_sessions = {}
for u in state.users.values():
u.coords.timestamp = datetime.now()
server.game_state = state
else:
server.game_state = Game()
server.global_server = Server(args.clickhouse_url)
log.info(f"Listening on {args.host}:{args.port}")
running = Event()
running.set()
loop = get_event_loop()
server_coro = server.global_server.start(
host=args.host, port=args.port, running=running
)
# Backups are now done via db
# save_timer = RepeatedTimer(
# interval=60,
# function=save_thread,
# file=args.backup_file,
# )
# save_timer.start()
try:
server_task = loop.run_until_complete(server_coro)
loop.run_forever()
except KeyboardInterrupt:
pass
print("BYE")
# tracer.stop()
# tracer.save()
# Close the server
server_task.close() # type: ignore
loop.run_until_complete(server_task.wait_closed()) # type: ignore
loop.close()
running.clear()
# save_timer.stop()
def debug():
parser = argparse.ArgumentParser()
parser.add_argument("--debug_socket", help="Debug socket for server", default=None)
args = parser.parse_args()
assert args.debug_socket
from rpyc.utils.classic import unix_connect # type: ignore
conn = unix_connect(args.debug_socket) # type: ignore
modules = conn.modules # type: ignore
from IPython.terminal.embed import embed # type: ignore
server = modules["server"] # type: ignore
embed(local_ns=locals(), colors="neutral")
if __name__ == "__main__":
run()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/__init__.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/__init__.py | from concurrent.futures import ProcessPoolExecutor
from pathlib import Path
from server.game.state import Game
from server.server_runner import Server
game_state: Game
global_server: Server
executor: ProcessPoolExecutor
PATH = Path(__file__).parent
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/fight.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/fight.py | import time
from typing import Dict
from server.game.entity.enemy import Enemy
from shared.constants import SERVER_TICK_RATE
from shared.gen.messages.v1 import AttackEnemy, User
class FightManager:
user_damage_cooldowns: Dict[str, float]
enemy_damage_cooldowns: Dict[str, float]
def __init__(self) -> None:
self.user_damage_cooldowns = {}
self.enemy_damage_cooldowns = {}
def can_take_damage_user(self, username: str, cooldown_ticks: int = 30) -> bool:
# User not in list => Store and allow to take damage
if not username in self.user_damage_cooldowns:
self.user_damage_cooldowns[username] = time.time()
return True
last_damage_timestamp = self.user_damage_cooldowns[username]
ticks_passed = (time.time() - last_damage_timestamp) * SERVER_TICK_RATE
# Cooldown did not pass yet
if ticks_passed < cooldown_ticks:
return False
self.user_damage_cooldowns[username] = time.time()
return True
def can_take_damage_enemy(self, enemy_uuid: str, cooldown_ticks: int = 30) -> bool:
# User not in list => Store and allow to take damage
if not enemy_uuid in self.user_damage_cooldowns:
self.enemy_damage_cooldowns[enemy_uuid] = time.time()
return True
last_damage_timestamp = self.enemy_damage_cooldowns[enemy_uuid]
ticks_passed = (time.time() - last_damage_timestamp) * SERVER_TICK_RATE
# Cooldown did not pass yet
if ticks_passed < cooldown_ticks:
return False
self.enemy_damage_cooldowns[enemy_uuid] = time.time()
return True
def is_plausible_attack(self, user: User, enemy: Enemy, attack_msg: AttackEnemy):
# Check if attack direction is plausible:
# TODO
# Check if damage is plausible
if attack_msg.damage > 11:
return False
if attack_msg.damage < 0:
return False
# Check if enemy is in range of weapon
dist_x = (user.coords.x - enemy.x) ** 2
dist_y = (user.coords.y - enemy.y) ** 2
max_attack_distance = 400 # TODO: Find good value, maybe dynamic from weapon
if dist_x + dist_y > max_attack_distance:
return False
attack_timestamp = time.mktime(attack_msg.time.timetuple())
if not enemy.uuid in self.enemy_damage_cooldowns:
self.enemy_damage_cooldowns[enemy.uuid] = attack_timestamp
return True
# TODO: Get dynamic from current user weapon
weapon_cooldown_ticks = 30
last_damage_timestamp = self.enemy_damage_cooldowns[enemy.uuid]
ticks_passed = (attack_timestamp - last_damage_timestamp) * SERVER_TICK_RATE
if ticks_passed > weapon_cooldown_ticks:
self.enemy_damage_cooldowns[enemy.uuid] = time.mktime(
attack_msg.time.timetuple()
)
return True
return False
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/state.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/state.py | import json
import math
import time
from collections import defaultdict
from copy import deepcopy
from datetime import datetime, timedelta
from pathlib import Path
from typing import Any, Dict, List, Literal, cast
from aiochclient import ChClient
from aiohttp import ClientSession
from aiohttp_retry import ExponentialRetry, RetryClient
import server
from server.game.entity.area import AreaObject
from server.game.entity.enemy import Enemy
from server.game.entity.npc import NPC
from server.game.entity.object import Object
from server.game.entity.pickupable import Pickupable
from server.game.fight import FightManager
from server.game.map.map import Map
from server.game.secret import ITEMS
from server.models import Position, ScoreboardEntry, Session
from shared.collison import CollisionManager, point_in_poly
from shared.constants import (
CHUNK_SIZE_X,
CHUNK_SIZE_Y,
PLAYER_HEIGHT,
PLAYER_SPEED,
PLAYER_WIDTH,
START_X,
START_Y,
TILE_SIZE_X,
TILE_SIZE_Y,
VIEW_DISTANCE_SQ,
)
from shared.gen.messages.v1 import (
Coords,
Item,
Ping,
SessionType,
ShopInteract,
ShopInteractType,
User,
)
def sign(x: float) -> Literal[-1, 1, 0]:
if x < 0:
return -1
elif x > 0:
return 1
else:
return 0
class PrefixMatch:
index: int
expected: List[Any]
def __init__(self, expected: List[Any]):
self.index = 0
self.expected = expected
def check_next(self, obj: Any) -> bool:
if self.expected[self.index] == obj:
self.index += 1
if self.index == len(self.expected):
self.index = 0
return True
elif self.index > 0 and self.expected[self.index - 1] != obj:
self.index = 0
return False
class ObjectManager:
static_objects: Dict[str, Object]
def __init__(self):
self.static_objects = {}
def get_objects_dict(self) -> Dict[str, Object]:
return self.static_objects
def get_objects_list(self) -> List[Object]:
return list(self.static_objects.values())
def get_object_by_uuid(self, uuid: str) -> Object | None:
if not uuid in self.static_objects:
return None
return self.static_objects[uuid]
async def update(self, dt: float):
for object in self.static_objects.values():
await object.update(dt=dt)
class EnemyManager:
enemies: Dict[str, Dict[str, Enemy]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.enemies = defaultdict(lambda: {})
self.object_manager = object_manager
# Helper classes
def get_enemies_for_user_dict(self, user_uuid: str) -> Dict[str, Enemy]:
return self.enemies[user_uuid]
def get_enemies_for_user_list(self, user_uuid: str) -> List[Enemy]:
return list(self.enemies[user_uuid].values())
def get_enemy_for_user_by_uuid(
self, user_uuid: str, enemy_uuid: str
) -> Enemy | None:
if not user_uuid in self.enemies:
return None
if not enemy_uuid in self.enemies[user_uuid]:
return None
return self.enemies[user_uuid][enemy_uuid]
def new_login(self, user_uuid: str):
if user_uuid not in self.enemies:
self.enemies[user_uuid] = {}
def deepcopy_add(self, user_uuid: str, enemy: Enemy):
tmp = deepcopy(enemy)
tmp.user_uuid = user_uuid
self.enemies[user_uuid][enemy.uuid] = tmp
async def update(self, dt: float):
for _, user_enemies in self.enemies.items():
for enemy in user_enemies.values():
await enemy.update(dt)
class AreaManager:
area_objects: Dict[str, Dict[str, AreaObject]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.area_objects = defaultdict(lambda: {})
self.object_manager = object_manager
def get_areas_for_user_dict(self, user_uuid: str) -> Dict[str, AreaObject]:
return self.area_objects[user_uuid]
def get_areas_for_user_list(self, user_uuid: str) -> List[AreaObject]:
return list(self.area_objects[user_uuid].values())
async def update(self, dt: float):
for user_areas in self.area_objects.values():
for npc in user_areas.values():
await npc.update(dt=dt)
def get_areas_for_user_by_uuid(
self, user_uuid: str, area_uuid: str
) -> AreaObject | None:
if not user_uuid in self.area_objects:
return None
if not area_uuid in self.area_objects[user_uuid]:
return None
return self.area_objects[user_uuid][area_uuid]
def deepcopy_add(self, user_uuid: str, area: AreaObject):
tmp = deepcopy(area)
tmp.user_uuid = user_uuid
self.area_objects[user_uuid][area.uuid] = tmp
class NPCManager:
npc_objects: Dict[str, Dict[str, NPC]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.npc_objects = defaultdict(lambda: {})
self.object_manager = object_manager
def get_npcs_for_user_dict(self, user_uuid: str) -> Dict[str, NPC]:
return self.npc_objects[user_uuid]
def get_npcs_for_user_list(self, user_uuid: str) -> List[NPC]:
return list(self.npc_objects[user_uuid].values())
async def update(self, dt: float):
for user_npcs in self.npc_objects.values():
for npc in user_npcs.values():
await npc.update(dt=dt)
def get_npc_for_user_by_uuid(self, user_uuid: str, npc_uuid: str) -> NPC | None:
if not user_uuid in self.npc_objects:
return None
if not npc_uuid in self.npc_objects[user_uuid]:
return None
return self.npc_objects[user_uuid][npc_uuid]
def deepcopy_add(self, user_uuid: str, npc: NPC):
tmp = deepcopy(npc)
tmp.user_uuid = user_uuid
self.npc_objects[user_uuid][npc.uuid] = tmp
class PickupableManager:
pickupable_objects: Dict[str, Dict[str, Pickupable]]
object_manager: ObjectManager
def __init__(self, object_manager: ObjectManager):
self.pickupable_objects = defaultdict(lambda: {})
self.object_manager = object_manager
def get_pickupable_for_user_dict(self, user_uuid: str) -> Dict[str, Pickupable]:
return self.pickupable_objects[user_uuid]
def get_pickupable_for_user_list(self, user_uuid: str) -> List[Pickupable]:
return list(self.pickupable_objects[user_uuid].values())
def get_pickupable_for_user_by_uuid(
self, user_uuid: str, pickupable_uuid: str
) -> Pickupable | None:
if not user_uuid in self.pickupable_objects:
return None
if not pickupable_uuid in self.pickupable_objects[user_uuid]:
return None
return self.pickupable_objects[user_uuid][pickupable_uuid]
def deepcopy_add(self, user_uuid: str, pickupable: Pickupable) -> None:
tmp = deepcopy(pickupable)
tmp.user_uuid = user_uuid
self.pickupable_objects[user_uuid][pickupable.uuid] = tmp
async def update(self, dt: float) -> None:
for _, pickupables in self.pickupable_objects.items():
for pickupable in list(pickupables.values()):
if pickupable.pickedup and pickupable.garbage_collect_on_pickup:
del pickupables[pickupable.uuid]
continue
await pickupable.update(dt)
class Game:
peer_sessions: Dict[str, Session]
user_sessions: Dict[str, Session]
users: Dict[str, User]
recent_moves: Dict[str, PrefixMatch]
user_collision_manager: CollisionManager
objects: Dict[str, Dict[str, Object]]
fight_manager: FightManager
scoreboard: dict[str, ScoreboardEntry]
running_scoreboard: dict[str, ScoreboardEntry]
enemy_manager: EnemyManager
object_manager: ObjectManager
npc_manager: NPCManager
area_manager: AreaManager
pickupable_manager: PickupableManager
def __init__(self) -> None:
self.peer_sessions = {}
self.user_sessions = {}
self.users = {}
self.recent_moves = {}
self.user_collision_manager = CollisionManager(PLAYER_WIDTH, PLAYER_HEIGHT)
# Manager
self.fight_manager = FightManager()
self.object_manager = ObjectManager()
self.enemy_manager = EnemyManager(self.object_manager)
self.npc_manager = NPCManager(self.object_manager)
self.area_manager = AreaManager(self.object_manager)
self.pickupable_manager = PickupableManager(self.object_manager)
self.map = Map(Path(server.PATH, "./map/testmap.json"))
self.object_manager.static_objects = self.map.initialize()
self.scoreboard = {}
self.running_scoreboard = {}
async def init(self, clickhouse_url: str) -> None:
self.session = ClientSession()
retry_options = ExponentialRetry(attempts=2)
self.retry_client = RetryClient(
client_session=self.session, retry_options=retry_options
)
self.ch_client = ChClient(session=self.session, url=clickhouse_url)
async def update_remote_user(self, user: User) -> None:
session = self.user_sessions[user.uuid]
await self.ch_client.execute(
"INSERT INTO game.users VALUES",
(
user.uuid,
user.username,
user.coords.x,
user.coords.y,
user.coords.rotation,
user.money,
json.dumps([i.to_json() for i in user.inventory]),
user.health,
user.last_death,
session.last_ping.timestamp(),
),
)
async def update_scoreboard(self, entry: ScoreboardEntry) -> None:
user = self.users[entry.user_id]
if entry.start is None:
return
if entry.end is None:
return
await self.ch_client.execute(
"INSERT INTO game.scoreboard VALUES",
(
user.username,
entry.start.timestamp(),
entry.end.timestamp(),
),
)
async def get_remote_scoreboard(self) -> list[ScoreboardEntry]:
res = await self.ch_client.fetch(
"SELECT uuid, username, start, end FROM game.scoreboard FINAL INNER JOIN (SELECT * FROM game.users FINAL) users USING username"
)
return [
ScoreboardEntry(
user_id=r["uuid"],
username=r["username"],
start=datetime.fromtimestamp(r["start"]),
end=datetime.fromtimestamp(r["end"]),
)
for r in res
]
def is_authenticated(self, client: str) -> bool:
return client in self.peer_sessions
def is_logged_in(self, username: str) -> bool:
return next(
(
True
for u in self.user_sessions.keys()
if self.users[u].username == username
),
False,
)
async def is_logged_in_remote(self, username: str) -> bool:
online_time = datetime.now() - timedelta(minutes=1)
user = await self.ch_client.fetchrow(
"SELECT * FROM game.users FINAL WHERE username = {username} AND last_ping >= {last_ping}",
params={"username": username, "last_ping": online_time.timestamp()},
)
return user is not None
def get_user_uuid(self, username: str) -> str | None:
return next(
(u.uuid for u in self.users.values() if u.username == username), None
)
def get_user(self, uuid: str | None) -> User | None:
if uuid is None:
return None
return self.users[uuid]
def get_session(self, user_id: str) -> str | None:
return self.user_sessions[user_id].peer
async def login(
self, client: str, user_id: str, user: User, type: SessionType
) -> Session:
await self.ch_client.is_alive()
chunk_x = user.coords.x // (CHUNK_SIZE_X * TILE_SIZE_X)
chunk_y = user.coords.y // (CHUNK_SIZE_Y * TILE_SIZE_Y)
if self.map.is_dynamic_chunk(chunk_x, chunk_y):
user.coords = Coords(x=START_X, y=START_Y)
user.coords.timestamp = datetime.now()
session = Session(peer=client, user_id=user_id, type=type)
session.last_ping = datetime.now()
self.peer_sessions[client] = session
self.user_sessions[user_id] = session
if user_id not in self.users:
self.users[user_id] = user
self.recent_moves[user_id] = PrefixMatch(
[
(-1, 0),
(1, 0),
(1, -1),
(0, -1),
(-1, 1),
(0, -1),
(1, -1),
(-1, 0),
(1, 1),
(1, -1),
(0, -1),
(1, 0),
]
)
await self.update_remote_user(user)
return session
async def logout(self, client: str) -> None:
if client in self.peer_sessions:
session = self.peer_sessions[client]
session.logout = True
user = self.users[session.user_id]
session.last_ping = datetime.fromtimestamp(0)
await self.update_remote_user(user)
self.peer_sessions.pop(client)
self.user_sessions.pop(session.user_id)
self.users.pop(session.user_id)
async def move(self, client: str, coords: Coords) -> bool:
if client in self.peer_sessions:
session = self.peer_sessions[client]
user_id = session.user_id
user = self.users[user_id]
if session.type == SessionType.SESSION_TYPE_FREE_CAM:
user.coords = coords
return True
user_coords_timestamp = cast(datetime, user.coords.timestamp) # type: ignore
coords_timestamp = cast(datetime, coords.timestamp) # type: ignore
distance_time = coords_timestamp - user_coords_timestamp
distance_x = user.coords.x - coords.x
distance_y = user.coords.y - coords.y
distance_sq = distance_x**2 + distance_y**2
max_distance_sq = (
min(distance_time.total_seconds(), 0.2) * PLAYER_SPEED
) ** 2
if max_distance_sq < distance_sq:
# maybe we found a hacker, check average over last positions
check_time = 0.2 # check for the last 200 ms
new_pos: list[Position] = []
k = -1
while len(session.last_positions) > 0:
pos = session.last_positions.pop()
new_pos.append(pos)
k = (coords_timestamp - pos.time).total_seconds()
if k >= check_time:
break
toff = (
coords_timestamp - new_pos[-1].time
).total_seconds() - check_time
session.last_positions = new_pos[::-1]
if len(new_pos) < 2:
user.coords.timestamp = coords_timestamp
return False
# does this interpolation to exactly 0.2s anything? or would comparison to 0.2+toff also be fine?
dt = (new_pos[-2].time - new_pos[-1].time).total_seconds()
dx = (new_pos[-2].coords.x - new_pos[-1].coords.x) * (toff / dt)
dy = (new_pos[-2].coords.y - new_pos[-1].coords.y) * (toff / dt)
pos_at_50 = new_pos[-1].coords.x + dx, new_pos[-1].coords.y + dy
distance_x_at_50 = coords.x - pos_at_50[0]
distance_y_at_50 = coords.y - pos_at_50[1]
distance_sq_50 = distance_x_at_50**2 + distance_y_at_50**2
# with this change PLAYER_SPEED (not *1.2) should be fine, but it isn't, why?
#
if math.sqrt(distance_sq_50) > check_time * PLAYER_SPEED * 1.2:
print(distance_time.total_seconds())
# print(math.sqrt(distance_sq_50), check_time * PLAYER_SPEED, k)
if math.sqrt(distance_sq_50) > check_time * PLAYER_SPEED * 1.2:
user.coords.timestamp = coords_timestamp
return False
match self.user_collision_manager.check_collisons(
self.map, user.coords.x, user.coords.y, coords.x, coords.y, user_id
):
case None:
return False
case x, y:
pass
valid = True
if x != coords.x or y != coords.y:
valid = False
coords.x = x
coords.y = y
user.coords = coords
if valid:
await self.update_remote_user(user)
session.last_positions.append(Position(coords, coords_timestamp))
if self.recent_moves[user_id].check_next(
(sign(distance_x), sign(distance_y))
):
await self.give_item(
user_id,
ITEMS["flag_cheat"],
True,
)
return valid
return False
async def give_item(self, user_id: str, item: Item, once: bool = False) -> bool:
user = self.users[user_id]
res = True
for i in user.inventory:
if i.name == item.name:
if once:
res = False
break
else:
i.quantity += item.quantity
res = True
break
else:
user.inventory.append(item)
if res:
await server.global_server.update_self(user_id)
return res
def shop(self, user_id: str, shop_interact: ShopInteract) -> bool:
user = self.users[user_id]
match shop_interact.type:
case ShopInteractType.SHOP_INTERACT_TYPE_BUY:
item = None
for i in user.inventory:
if i.name == shop_interact.item.name:
item = i
break
else:
return False
if item.quantity >= shop_interact.item.quantity:
item.quantity -= shop_interact.item.quantity
if item.quantity == 0:
user.inventory.remove(item)
user.money += shop_interact.cost
return True
case ShopInteractType.SHOP_INTERACT_TYPE_SELL:
if user.money >= shop_interact.cost:
user.money -= shop_interact.cost
for i in user.inventory:
if i.name == shop_interact.item.name:
i.quantity += shop_interact.item.quantity
break
else:
user.inventory.append(shop_interact.item)
return True
case ShopInteractType.SHOP_INTERACT_TYPE_TRADE:
item = None
for i in user.inventory:
if i.name == shop_interact.item.name:
item = i
break
else:
return False
if item.quantity >= shop_interact.item.quantity:
item.quantity -= shop_interact.item.quantity
if item.quantity == 0:
user.inventory.remove(item)
for i in user.inventory:
if i.name == shop_interact.trade_in.name:
i.quantity += shop_interact.trade_in.quantity
break
else:
user.inventory.append(shop_interact.trade_in)
return True
case _:
pass
return False
def get_users(self, client: str | None = None) -> List[User]:
if client in self.peer_sessions:
return [u for c, u in self.users.items() if c != self.peer_sessions[client]]
return list(self.users.values())
def get_online_users(self, client: str | None = None) -> List[User]:
if client in self.peer_sessions:
return [
self.users[user_id]
for user_id, session in self.user_sessions.items()
if session.peer != client
and session.type != SessionType.SESSION_TYPE_FREE_CAM
]
return list(self.users.values())
async def get_remote_username(self, username: str) -> User | None:
user = await self.ch_client.fetchrow(
"SELECT uuid, username, x, y, rotation FROM game.users FINAL WHERE username = {username}",
params={"username": username},
)
if user:
return User(
uuid=str(user["uuid"]),
username=user["username"],
last_death=user["last_death"],
coords=Coords(x=user["x"], y=user["y"], rotation=user["rotation"]),
)
else:
return None
async def get_remote_userid(self, user_id: str) -> User | None:
user = await self.ch_client.fetchrow(
"SELECT uuid, username, x, y, rotation, last_death FROM game.users FINAL WHERE uuid = {uuid}",
params={"uuid": user_id},
)
if user:
return User(
uuid=str(user["uuid"]),
username=user["username"],
last_death=user["last_death"],
coords=Coords(x=user["x"], y=user["y"], rotation=user["rotation"]),
)
else:
return None
async def get_remote_fulluser(self, username: str) -> User | None:
user = await self.ch_client.fetchrow(
"SELECT * FROM game.users FINAL WHERE username = {username}",
params={"username": username},
)
if user:
return User(
uuid=str(user["uuid"]),
username=user["username"],
coords=Coords(x=user["x"], y=user["y"], rotation=user["rotation"]),
money=user["money"],
inventory=[Item().from_json(i) for i in json.loads(user["inventory"])],
health=user["health"],
last_death=user["last_death"],
)
else:
return None
async def get_remote_online_users(
self, exclude_user_id: str | None = None
) -> List[User]:
online_time = datetime.now() - timedelta(minutes=1)
res = []
if exclude_user_id is None:
res = await self.ch_client.fetch(
"SELECT uuid, username, x, y, rotation, last_death FROM game.users FINAL WHERE last_ping >= {last_ping}",
params={"last_ping": online_time.timestamp()},
)
else:
res = await self.ch_client.fetch(
"SELECT uuid, username, x, y, rotation, last_death FROM game.users FINAL WHERE uuid != {uuid} AND last_ping >= {last_ping}",
params={"uuid": exclude_user_id, "last_ping": online_time.timestamp()},
)
users = [
User(
uuid=str(r["uuid"]),
username=r["username"],
last_death=r["last_death"],
coords=Coords(x=r["x"], y=r["y"], rotation=r["rotation"]),
)
for r in res
]
return users
def get_local_users_distance(
self, x: float, y: float, user_session: Session | None = None
) -> List[User]:
peer = None
if user_session:
peer = user_session.peer
users = self.get_online_users(peer)
objects = filter(
lambda e: (abs(x - e.coords.x) ** 2) + (abs(y - e.coords.y) ** 2)
<= VIEW_DISTANCE_SQ,
users,
)
return list(objects)
async def get_online_users_distance(
self, x: float, y: float, user_session: Session | None = None
) -> List[User]:
peer = None
user_id = None
if user_session:
peer = user_session.peer
user_id = user_session.user_id
users = self.get_online_users(peer) + await self.get_remote_online_users(
user_id
)
objects = filter(
lambda e: (abs(x - e.coords.x) ** 2) + (abs(y - e.coords.y) ** 2)
<= VIEW_DISTANCE_SQ,
users,
)
return list(objects)
@staticmethod
def is_in_view(x: float, y: float, object: Object) -> bool:
match object:
case AreaObject():
return point_in_poly(x, y, object.area)
case _:
return ((x - object.x) ** 2) + ((y - object.y) ** 2) <= VIEW_DISTANCE_SQ
def get_objects_view_distance(self, uuid: str, x: float, y: float) -> List[Object]:
original_objects = filter(
lambda obj: self.is_in_view(x, y, obj),
self.object_manager.get_objects_list(),
)
# A list to store all the different object types as Object
objects: Dict[str, Object] = {}
# Get map values. Those are Enemies, NPCs, Items etc. Depending on the type, we have to handle them per user
# TODO: Maybe better perf to add the deepcopied object directly
for o in original_objects:
match o:
case AreaObject():
if o.uuid not in self.area_manager.get_areas_for_user_dict(
user_uuid=uuid
):
self.area_manager.deepcopy_add(user_uuid=uuid, area=o)
objects[o.uuid] = self.area_manager.get_areas_for_user_dict(
user_uuid=uuid
)[o.uuid]
case NPC():
if o.interactable:
if o.uuid not in self.npc_manager.get_npcs_for_user_dict(
user_uuid=uuid
):
self.npc_manager.deepcopy_add(user_uuid=uuid, npc=o)
objects[o.uuid] = self.npc_manager.get_npcs_for_user_dict(
user_uuid=uuid
)[o.uuid]
else:
objects[o.uuid] = o
case Enemy():
if o.uuid not in self.enemy_manager.get_enemies_for_user_dict(
user_uuid=uuid
):
self.enemy_manager.deepcopy_add(user_uuid=uuid, enemy=o)
objects[o.uuid] = self.enemy_manager.get_enemies_for_user_dict(
user_uuid=uuid
)[o.uuid]
case Pickupable():
if o.pickedup:
continue
if (
o.uuid
not in self.pickupable_manager.get_pickupable_for_user_dict(
user_uuid=uuid
)
):
self.pickupable_manager.deepcopy_add(
user_uuid=uuid, pickupable=o
)
object = self.pickupable_manager.get_pickupable_for_user_dict(
user_uuid=uuid
)[o.uuid]
if not object.pickedup:
objects[o.uuid] = object
# Fallback for unknown objects
case _:
objects[o.uuid] = o
objects.update(
{
p.uuid: p
for p in self.area_manager.get_areas_for_user_list(user_uuid=uuid)
if p.uuid not in objects
}
)
objects.update(
{
p.uuid: p
for p in self.npc_manager.get_npcs_for_user_list(user_uuid=uuid)
if p.uuid not in objects
}
)
objects.update(
{
p.uuid: p
for p in self.enemy_manager.get_enemies_for_user_list(user_uuid=uuid)
if p.uuid not in objects
}
)
objects.update(
{
p.uuid: p
for p in self.pickupable_manager.get_pickupable_for_user_list(
user_uuid=uuid
)
if p.uuid not in objects and not p.pickedup
}
)
# objects += self.object_manager.get_static_objects()
return list(objects.values())
def start_timer(self, user_id: str) -> None:
scoreboard_entry = self.running_scoreboard.get(user_id)
if scoreboard_entry is None:
scoreboard_entry = ScoreboardEntry(user_id=user_id)
self.running_scoreboard[user_id] = scoreboard_entry
scoreboard_entry.reset()
scoreboard_entry.start = datetime.now()
async def stop_timer(self, user_id: str) -> ScoreboardEntry | None:
scoreboard_entry = self.running_scoreboard.get(user_id)
if scoreboard_entry is None:
return
if scoreboard_entry.end:
return
scoreboard_entry.end = datetime.now()
del self.running_scoreboard[user_id]
last_best_entry = self.scoreboard.get(user_id)
if last_best_entry is None or last_best_entry.time > scoreboard_entry.time:
self.scoreboard[user_id] = scoreboard_entry
await self.update_scoreboard(scoreboard_entry)
return scoreboard_entry
async def die(self, user: User) -> None:
print(f"Player {user.username} died :( Resetting")
user.last_death = time.time()
start_coords = Coords(x=START_X, y=START_Y)
start_coords.timestamp = datetime.now()
user.health = 100
user.coords = start_coords
await self.update_remote_user(user)
async def ping(self, peer: str, ping: Ping) -> None:
session = self.peer_sessions[peer]
if session.logout:
return
user = self.users[session.user_id]
session.last_ping = datetime.now()
await self.update_remote_user(user)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/__init__.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/secret.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/secret.py | from shared.gen.messages.v1 import Item
ITEMS = {
"shovel": Item(name="Shovel", description="DIGGY DIGGY", quantity=1, icon=2501),
"flag_dig": Item(
name="Dig Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2562,
),
"flag_runner": Item(
name="Runner Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2563,
),
"flag_license": Item(
name="License check Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2564,
),
"localo": Item(
name="localo",
description="This could have been a flag, but instead you found localo. And you won't get rid of him, since nobody bothered to implement a the functionality to delete items from your inventory.",
quantity=1,
icon=2379,
),
"flag_sanity": Item(
name="Sanity Flag",
description="Everyone has to start somewhere. ALLES!{REDACTED}",
quantity=1,
icon=2565,
),
"flag_race_to_top": Item(
name="Race to Top Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2566,
),
"flag_merchant": Item(
name="Merchant Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2567,
),
# 2568 Maze flag
"flag_boss": Item(
name="Boss Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2569,
),
"flag_cheat": Item(
name="Cheat Flag",
description=" ALLES!{REDACTED}",
quantity=1,
icon=2570,
),
# 2571 unreachable flag
}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/auth.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/auth.py | import json
from pathlib import Path
from shared.gen.messages.v1 import SessionType
auth_path: str
def auth(username: str, password: str) -> SessionType | None:
with open(Path(auth_path), "r") as f:
users = json.load(f)
for u, p in users["users"].items():
if username[:-1] == u and username[-1].isnumeric():
if p == password:
return SessionType.SESSION_TYPE_NORMAL
for u, p in users["freecam"].items():
if username[:-1] == u and username[-1].isnumeric():
if p == password:
return SessionType.SESSION_TYPE_FREE_CAM
return None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/entity/statemachine.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/entity/statemachine.py | from dataclasses import dataclass
from typing import Dict
STATE_CONTINUE = "STATE_CONTINUE"
@dataclass
class BaseState:
DEBUG = False
name: str
parameter: object
def __init__(self, name: str = "none", param: object = None):
self.name = name
self.parameter = param
def enter(self):
if BaseState.DEBUG:
print("Entering state: " + self.name)
pass
def leave(self):
if BaseState.DEBUG:
print("Entering state: " + self.name)
pass
async def update(self, dt: float) -> str:
return STATE_CONTINUE
@dataclass
class StateMachine:
current_state: BaseState
previous_state: BaseState
_states: Dict[str, BaseState]
def __init__(self):
self.current_state = BaseState()
self.previous_state = BaseState()
self._states = {}
pass
async def update(self, dt: float):
next_state: str = await self.current_state.update(dt=dt)
if next_state == STATE_CONTINUE:
return
# State transition
self.change_state(next_state)
def change_state(self, name: str):
assert name in self._states.keys(), "State not found: " + name
self.current_state.leave()
self.previous_state = self.current_state
self.current_state = self._states[name]
self.current_state.enter()
def add_state(self, state: BaseState):
assert state.name not in self._states.keys(), (
"State already in state list" + state.name
)
self._states[state.name] = state
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/entity/npc.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/entity/npc.py | import json
import logging
import math
import random
from copy import copy
from dataclasses import dataclass
from datetime import timedelta
from pathlib import Path
from typing import Any, List, Tuple, cast
import server
from server.game.entity.dino_runner import Engine
from server.game.entity.object import Object
from server.game.map.properties import CustomInteraction
from server.game.secret import ITEMS
from server.models import ScoreboardEntry
from shared.gen.messages.v1 import (EntityAsset, EntityAssets, Interact,
InteractStatus, InteractType, Item)
from shared.gen.messages.v1 import Object as ObjectProto
from shared.gen.messages.v1 import (ObjectType, Polygon, ShopInteract,
ShopInteractType)
# This comes from the native python module, redacted here
# from license_checker import check_license # type: ignore
shop_items: Any = None
def get_random_shop_item(exclude: Item | None = None) -> Item:
global shop_items
if shop_items is None:
with open(Path(server.PATH, "./map/items.json")) as f:
shop_items = json.load(f)["items"]
possibilities = shop_items.copy()
if exclude:
possibilities = [p for p in possibilities if p["name"] != exclude.name]
item = random.choice(possibilities)
item_proto = Item().from_dict(item)
item_proto.quantity = random.randint(1, 3)
return item_proto
@dataclass
class NPCPath:
path: Polygon
current_path_step: int
speed: float
loop: bool
def __init__(self, path: Polygon | None, speed: float, loop: bool = False):
match path:
case None:
self.path = Polygon()
case p:
self.path = p
self.current_path_step = 0
self.speed = speed
self.loop = loop
def reset(self):
self.current_path_step = 0
def get_next_position(self, dt: float, x: float, y: float) -> Tuple[float, float]:
if self.current_path_step > len(self.path.points) or len(self.path.points) == 0:
return (x, y)
next_point = self.path.points[self.current_path_step % len(self.path.points)]
if x == next_point.x and y == next_point.y:
self.current_path_step += 1
if self.loop:
self.current_path_step %= len(self.path.points)
next_point = self.path.points[
self.current_path_step % len(self.path.points)
]
dx = next_point.x - x
dy = next_point.y - y
l = math.sqrt(dx**2 + dy**2)
dx *= 1 / l
dy *= 1 / l
distance_x = dx * self.speed * dt
distance_y = dy * self.speed * dt
max_l = math.sqrt(distance_x**2 + distance_y**2)
if max_l > l:
distance_x = dx * l
distance_y = dy * l
next_x = x + distance_x
next_y = y + distance_y
x = next_x
y = next_y
return (x, y)
@dataclass
class Interaction:
id: int
_text: str
path: NPCPath
speed: float
loop: bool
current_path_step: int
next_interaction: int
custom_interaction: CustomInteraction
custom_attribute: str
def __init__(
self,
id: int,
text: str,
path: Polygon | None,
speed: float,
loop: bool,
custom_interaction: CustomInteraction,
custom_attribute: str,
current_path_step: int = 0,
next_interaction: int = -1,
) -> None:
match path:
case None:
self.path = NPCPath(path=None, speed=speed, loop=loop)
case p:
self.path = NPCPath(path=p, speed=speed, loop=loop)
self.id = id
self._text = text
self.speed = speed
self.loop = loop
self.custom_interaction = custom_interaction
self.custom_attribute = custom_attribute
self.current_path_step = current_path_step
self.next_interaction = next_interaction
if self.custom_interaction == CustomInteraction.TALKY:
with open(Path(server.PATH, custom_attribute), "r") as f:
self._text = f.read()
@property
async def text(self) -> str:
match self.custom_interaction:
case CustomInteraction.REQUIRE_ITEMS:
# this is fine :mildpanic:
req = eval(self.custom_attribute)
return self._text.replace(
r"%items",
",".join([f"{y}x {x}" for (x, y) in req.items()]),
)
case CustomInteraction.TALKY:
if len(self._text) == 0:
with open(Path(server.PATH, self.custom_attribute), "r") as f:
self._text = f.read()
return ""
split = self._text.split("\n", 1)
passage = split[0]
if len(passage) <= 200:
if len(split) > 1:
self._text = split[1]
else:
self._text = ""
else:
passage = passage[:200].rsplit(" ", 1)[0]
self._text = self._text[len(passage) :]
passage = passage.lstrip()
return passage
case CustomInteraction.SCOREBOARD:
# scoreboard: list[ScoreboardEntry] = [
# e for e in server.game_state.scoreboard.values() if e.time
# ]
scoreboard: list[ScoreboardEntry] = [
e for e in await server.game_state.get_remote_scoreboard() if e.time
]
scoreboard.sort(key=lambda e: e.time if e.time else timedelta.max)
return "\n".join(
[
f"#{i} {user} {time} "
for i, (time, user) in enumerate(
(
e.time,
e.username,
)
for e in scoreboard
)
if user
]
)
case _:
return self._text
@text.setter
def text(self, text: str) -> None:
self._text = text
@property
def interaction_type(self) -> InteractType:
match self.custom_interaction:
case CustomInteraction.SHOP:
return InteractType.INTERACT_TYPE_SHOP
case CustomInteraction.RUNNER:
return InteractType.INTERACT_TYPE_RUNNER
case CustomInteraction.LICENSE:
return InteractType.INTERACT_TYPE_LICENSE
case _:
return InteractType.INTERACT_TYPE_TEXT
@property
def shop(self) -> list[ShopInteract]:
shop: list[ShopInteract] = []
match self.custom_interaction:
case CustomInteraction.SHOP:
pass
case _:
return shop
shop.append(
ShopInteract(
item=copy(ITEMS["flag_merchant"]),
cost=1000000,
type=ShopInteractType.SHOP_INTERACT_TYPE_SELL,
)
)
for _ in range(random.randrange(1, 11)):
match random.randrange(3):
case 0:
shop.append(
ShopInteract(
item=get_random_shop_item(),
type=ShopInteractType.SHOP_INTERACT_TYPE_BUY,
cost=random.randrange(750, 1000),
)
)
case 1:
shop.append(
ShopInteract(
item=get_random_shop_item(),
type=ShopInteractType.SHOP_INTERACT_TYPE_SELL,
cost=random.randrange(750, 1000),
)
)
case 2:
item = get_random_shop_item()
shop.append(
ShopInteract(
item=item,
type=ShopInteractType.SHOP_INTERACT_TYPE_TRADE,
trade_in=get_random_shop_item(item),
)
)
case _:
pass
return shop
def reset(self) -> None:
self.current_path_step = 0
def move(self, dt: float, x: float, y: float) -> Tuple[float, float]:
if self.path:
x, y = self.path.get_next_position(dt, x, y)
return (x, y)
@dataclass(kw_only=True)
class NPC(Object):
interactable: bool
interact_distance: float
interaction_step: int
interactions: List[Interaction]
entity_asset: EntityAsset
user_uuid: str | None
def __init__(
self,
interactable: bool,
interact_distance: float,
interactions: List[Interaction],
entity_assets: EntityAssets,
user_uuid: str | None = None,
interaction_step: int = 0,
*args: Any,
**kwargs: Any,
) -> None:
self.interactable = interactable
self.interact_distance = interact_distance
self.interactions = interactions
self.user_uuid = user_uuid
self.interaction_step = interaction_step
self.entity_assets = entity_assets
self.runner_seed = None
super().__init__(*args, **kwargs)
self.type = ObjectType.OBJECT_TYPE_NPC
async def update(self, dt: float) -> None:
await super().update(dt=dt)
current_interaction = (
self.interactions[self.interaction_step]
if self.interaction_step < len(self.interactions)
else None
)
if current_interaction is not None:
next_x, next_y = current_interaction.move(dt, self.x, self.y)
moved = True if self.x != next_x or self.y != next_y else False
self.x = next_x
self.y = next_y
if self.user_uuid is not None:
await server.global_server.move_object(
self.uuid, self.x, self.y, include_user_ids=[self.user_uuid]
)
elif moved:
await server.global_server.move_object(self.uuid, self.x, self.y)
def _step_interact(self) -> None:
current_interaction = self.interactions[self.interaction_step]
if current_interaction.next_interaction == -1:
next_interaction_id = (self.interaction_step + 1) % len(self.interactions)
else:
next_interaction_id = current_interaction.next_interaction
self.interaction_step = next_interaction_id
interaction = self.interactions[next_interaction_id]
interaction.reset()
# This is actually in the native build module. Just a placeholder here
def check_license(
self, _num
):
return 1
async def interact(self, user_id: str, interact: Interact) -> Interaction:
current_interaction = self.interactions[self.interaction_step]
should_skip = False
match current_interaction.interaction_type:
case InteractType.INTERACT_TYPE_LICENSE:
try:
val = int(interact.text, 16) & 0xFFFFFFFFFFFFFFFF
ret = cast(int, check_license(val))
match ret:
case 1:
should_skip = True
self.interaction_step += 2
self.interaction = self.interactions[self.interaction_step]
self.interaction.reset()
self.interaction.text = (
await self.interaction.text
).replace(r"%item", r"LOCALO")
success = await server.game_state.give_item(
user_id, ITEMS["localo"], True
)
if success:
await server.global_server.update_self(user_id)
case 2:
should_skip = True
self.interaction_step += 2
self.interaction = self.interactions[self.interaction_step]
self.interaction.reset()
self.interaction.text = (
await self.interaction.text
).replace(r"%item", r"FLAG")
success = await server.game_state.give_item(
user_id, ITEMS["flag_license"], True
)
if success:
await server.global_server.update_self(user_id)
case _:
pass
except:
pass
pass
case InteractType.INTERACT_TYPE_SHOP:
if len(interact.shop) > 0:
flag = ITEMS["flag_merchant"]
i = interact.shop[0]
for item in shop_items:
if item["name"] == i.item.name:
i.item.description = item["description"]
break
if i.item.name == flag.name:
i.item.description = flag.description
if i.trade_in:
for item in shop_items:
if item["name"] == i.trade_in.name:
i.trade_in.description = item["description"]
break
if i.trade_in.name == flag.name:
i.trade_in.description = flag.description
success = server.game_state.shop(user_id, i)
if success:
await server.global_server.update_self(user_id)
case _:
pass
if not should_skip:
self._step_interact()
interaction = self.interactions[self.interaction_step]
match interaction.custom_interaction:
case CustomInteraction.REQUIRE_ITEMS:
reqs = eval(interaction.custom_attribute)
user = server.game_state.get_user(user_id)
assert user
for i, q in reqs.items():
item = next((x for x in user.inventory if x.name == i), None)
if item is None:
break
if item.quantity < q:
break
else:
for i, q in reqs.items():
item = next((x for x in user.inventory if x.name == i))
item.quantity -= q
if item.quantity == 0:
user.inventory.remove(item)
await server.global_server.update_self(user_id)
self.interaction_step += 2
self.interaction = self.interactions[self.interaction_step]
self.interaction.reset()
case CustomInteraction.RUNNER:
if (
interact.status == InteractStatus.INTERACT_STATUS_STOP
and self.runner_seed is not None
):
runner = interact.runner
sim = Engine()
sim.seed = self.runner_seed
result, _time, score = sim.run(runner)
if result and score > 1337:
success = await server.game_state.give_item(
user_id, ITEMS["flag_runner"], True
)
if success:
await server.global_server.update_self(user_id)
self.runner_seed = None
if interact.status == InteractStatus.INTERACT_STATUS_UPDATE:
if self.runner_seed == None:
self.runner_seed = random.random() * 31337
case CustomInteraction.RACE_START:
server.game_state.start_timer(user_id=user_id)
self._step_interact()
case CustomInteraction.RACE_STOP:
entry = await server.game_state.stop_timer(user_id=user_id)
race_to_reach = timedelta(minutes=1, seconds=20, milliseconds=750)
if entry is None:
self._step_interact()
elif entry.time < race_to_reach:
interaction._text = f"Your found me, in {entry.time}. Good job, I gave you a flag to keep."
success = await server.game_state.give_item(
user_id, ITEMS["flag_race_to_top"], True
)
if success:
await server.global_server.update_self(user_id)
else:
interaction._text = f"You found me, but it took {entry.time}, try again and get faster than {race_to_reach}."
case CustomInteraction.GIVE_ITEM:
if interaction.custom_attribute not in ITEMS:
logging.warn(f"Unknown ITEM {interaction.custom_attribute}")
else:
success = await server.game_state.give_item(
user_id, ITEMS[interaction.custom_attribute], True
)
if success:
await server.global_server.update_self(user_id)
case _:
pass
interaction = self.interactions[self.interaction_step]
return interaction
def to_proto(self) -> ObjectProto:
return super().to_proto()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/entity/dino_runner.py | ctfs/CCCamp/2023/game/Unreachable/src/server/server/game/entity/dino_runner.py | import random
from collections import defaultdict
from shared.constants import TARGET_UPS
from shared.gen.messages.v1 import Runner, RunnerAction
class Obstacle:
x: float = 0
width: float
height: float
class SmallObstacle(Obstacle):
width = 17
height = 35
class BigObstacle(Obstacle):
width = 25
height = 50 - 2
class LongObstacle(Obstacle):
width = 75
height = 50 - 2
class Engine:
time: float
acc: float
speed: float
game_width: float
obstacles: list[Obstacle]
dino_y: float = 0
dino_width: float = 44
dino_v: float = 0
stop: bool
seed: float = 0
rng: random.Random
def update(self, dt: float):
self.offset -= self.speed * dt
self.speed += self.acc * dt
self.dino_v -= self.g * dt
self.dino_y += self.dino_v * dt
if self.dino_y < 0:
self.dino_y = 0
self.dino_v = 0
for obstacle in self.obstacles:
obstacle.x -= dt * self.speed
if (
obstacle.x + obstacle.width >= 0
and obstacle.x + obstacle.width < self.dino_width
):
if self.dino_y < obstacle.height:
self.stop = True
obstacles = sorted(self.obstacles, key=lambda x: x.x)
last = obstacles[-1]
if last.x + last.width < self.game_width:
if self.rng.random() < 0.04:
free = [x for x in obstacles if x.x + x.width <= 0]
if len(free) > 0:
obs = self.rng.choice(free)
obs.x = self.game_width
def run(self, runner: Runner):
self.rng = random.Random(self.seed)
self.time = 0
self.acc = 20
self.speed = 400
self.game_width = 1200
self.jump_duration = 0.5
self.jump_height = 100
self.offset = 0
self.g = self.jump_height / (2 * pow(self.jump_duration / 4, 2))
self.v0 = pow(2 * self.jump_height * self.g, 1 / 2)
self.obstacles = [
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
SmallObstacle(),
BigObstacle(),
BigObstacle(),
LongObstacle(),
]
for obs in self.obstacles:
obs.x = -obs.width
self.stop = False
events: dict[float, list[RunnerAction]] = defaultdict(lambda: [])
for event in runner.events:
events[event.time].append(event.action)
for dt in runner.dts:
# TODO check that client doesn't cheat by sending weird dts
if dt > 1 / (10) or dt < 1 / (TARGET_UPS * 1.2):
return False, self.time, int(-self.offset // 100)
self.time += dt
self.update(dt)
if self.stop:
if RunnerAction.RUNNER_ACTION_DIE in events[self.time]:
break
return False, self.time, int(-self.offset // 100)
for action in events[self.time]:
if action == RunnerAction.RUNNER_ACTION_JUMP:
if self.dino_y == 0:
self.dino_v = self.v0
return True, self.time, int(-self.offset // 100)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.