olympus-engine 0.1.0__py3-none-any.whl

olympus/__init__.py

@@ -0,0 +1,22 @@
+from .screen import Screen, LEFT, RIGHT, UP, DOWN, O, X
+from .palette import (
+      PALETTE, BLACK, DARKBLUE, DARKPURPLE, DARKGREEN, BROWN, DARKGREY,
+      LIGHTGREY, WHITE, RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, PINK, PEACH,
+  )
+from .sprites import make_sprite, load_sprite
+from .sound import Sound, load_wav
+from .anim import Anim
+from .tilemap import Tilemap, TILE
+from .collide import overlap, hits_any
+from .font import FONT
+
+__version__ = "0.1.0"
+
+__all__ = [
+      "Screen", "LEFT", "RIGHT", "UP", "DOWN", "O", "X",
+      "PALETTE", "BLACK", "DARKBLUE", "DARKPURPLE", "DARKGREEN", "BROWN",
+      "DARKGREY", "LIGHTGREY", "WHITE", "RED", "ORANGE", "YELLOW", "GREEN",
+      "BLUE", "INDIGO", "PINK", "PEACH",
+      "make_sprite", "load_sprite", "Sound", "load_wav", "Anim",
+      "Tilemap", "TILE", "overlap", "hits_any", "FONT",
+  ]

olympus/anim.py

@@ -0,0 +1,20 @@
+class Anim:
+    def __init__(self, frames, speed=6):
+        self.frames = frames
+        self.speed = speed
+        self.t = 0
+        self.i = 0
+
+    def reset(self):
+        self.t = 0
+        self.i = 0
+
+    def update(self):
+        self.t += 1
+        if self.t >= self.speed:
+            self.t = 0
+            self.i = (self.i + 1) % len(self.frames)
+
+    def frame(self):
+        return self.frames[self.i]
+

olympus/collide.py

@@ -0,0 +1,10 @@
+def overlap(a, b):
+    ax, ay, aw, ah, = a
+    bx, by, bw, bh = b
+    return (ax < bx + bw and ax + aw > bx and ay < by + bh and ay + ah > by)
+
+def hits_any(box, boxes):
+    for b in boxes:
+        if overlap(box, b):
+            return True
+    return False

olympus/editor.py

@@ -0,0 +1,191 @@
+import ctypes 
+import sdl2
+import numpy as np
+from .screen import Screen
+
+VW = VH = 128
+SCALE = 5
+GRID = 16
+CANVAS = 96
+CELL = CANVAS // GRID
+CANVAS_X = CANVAS_Y = 4
+PAL_X, PAL_Y, SW = 4, 104, 7
+PV_X, PV_Y = 104, 4
+TRANSPARENT = 255
+SAVE_FILE = "sprite.sav"
+
+grid = np.full((GRID, GRID), TRANSPARENT, dtype=np.uint8)
+selected = 8
+undo_stack = []
+onion = None
+show_onion = True
+
+def in_canvas(mx, my):
+    return (CANVAS_X <= mx < CANVAS_X + GRID * CELL and CANVAS_Y <= my < CANVAS_Y + GRID * CELL)
+
+def canvas_cell(mx, my):
+    return (my - CANVAS_Y) // CELL, (mx - CANVAS_X) // CELL
+
+def palette_index(mx, my):
+    if PAL_Y <= my < PAL_Y + SW and mx >= PAL_X:
+        i = (mx - PAL_X) // SW
+        if 0 <= i < 16:
+            return i
+    return None
+
+def grid_rows():
+    out = []
+    for r in range(GRID):
+        line = "".join("." if grid[r, c] == TRANSPARENT else format(grid[r, c], "x") for c in range(GRID))
+        out.append(line)
+    return out
+
+def to_code():
+    body = "\n".join('    "%s",' % row for row in grid_rows())
+    return "make_sprite([\n" + body + "\n])"
+
+def push_undo():
+      undo_stack.append(grid.copy())
+      if len(undo_stack) > 50:
+          undo_stack.pop(0)
+
+
+def save_grid():
+      with open(SAVE_FILE, "w") as f:
+          f.write("\n".join(grid_rows()) + "\n")
+
+
+def load_grid():
+      try:
+          with open(SAVE_FILE) as f:
+              lines = [ln.rstrip("\n") for ln in f if ln.strip()]
+      except FileNotFoundError:
+          return
+      push_undo()
+      grid[:, :] = TRANSPARENT
+      for r in range(min(GRID, len(lines))):
+          for c in range(min(GRID, len(lines[r]))):
+              ch = lines[r][c]
+              grid[r, c] = TRANSPARENT if ch == "." else int(ch, 16)
+
+
+def draw(screen):
+      screen.cls(1)   # dark-blue background = grid lines
+      # canvas
+      for r in range(GRID):
+          for c in range(GRID):
+              x = CANVAS_X + c * CELL
+              y = CANVAS_Y + r * CELL
+              v = grid[r, c]
+              if v != TRANSPARENT:
+                  col = v
+              elif show_onion and onion is not None and onion[r, c] != TRANSPARENT:
+                  col = 2          # ghost of the onion frame (dark purple)
+              else:
+                  col = 6 if (r + c) % 2 == 0 else 5   # empty = checkerboard
+              screen.rectfill(x, y, x + CELL - 2, y + CELL - 2, col)
+      # palette strip
+      for i in range(16):
+          x = PAL_X + i * SW
+          screen.rectfill(x, PAL_Y, x + SW - 2, PAL_Y + SW - 2, i)
+      sx = PAL_X + selected * SW
+      screen.rect(sx - 1, PAL_Y - 1, sx + SW - 1, PAL_Y + SW - 1, 7)
+      # 1x live preview (actual size)
+      for r in range(GRID):
+          for c in range(GRID):
+              if grid[r, c] != TRANSPARENT:
+                  screen.pset(PV_X + c, PV_Y + r, grid[r, c])
+      screen.rect(PV_X - 1, PV_Y - 1, PV_X + GRID, PV_Y + GRID, 6)
+      screen.text("C:" + str(selected), 104, 26, 7)
+      screen.text("ON" if show_onion else "OFF", 104, 34, 7)
+      # help
+      screen.text("E:CODE S:SAVE L:LOAD", 4, 114, 7)
+      screen.text("Z:UNDO C:CLR O/H:ONION", 4, 120, 7)
+
+
+def main():
+      global selected, onion, show_onion
+      sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
+      window = sdl2.SDL_CreateWindow(
+          b"Olympus Sprite Editor",
+          sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED,
+          VW * SCALE, VH * SCALE, sdl2.SDL_WINDOW_SHOWN)
+      renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED)
+      sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"0")
+      texture = sdl2.SDL_CreateTexture(
+          renderer, sdl2.SDL_PIXELFORMAT_RGB24,
+          sdl2.SDL_TEXTUREACCESS_STREAMING, VW, VH)
+
+      screen = Screen(VW, VH)
+      event = sdl2.SDL_Event()
+      mxp, myp = ctypes.c_int(0), ctypes.c_int(0)
+      prev_held = False
+      running = True
+
+      while running:
+          while sdl2.SDL_PollEvent(ctypes.byref(event)):
+              if event.type == sdl2.SDL_QUIT:
+                  running = False
+              elif event.type == sdl2.SDL_KEYDOWN:
+                  k = event.key.keysym.sym
+                  if k == sdl2.SDLK_ESCAPE:
+                      running = False
+                  elif k == sdl2.SDLK_c:
+                      push_undo(); grid[:, :] = TRANSPARENT
+                  elif k == sdl2.SDLK_e:
+                      code = to_code()
+                      print("\n" + code + "\n")
+                      with open("sprite_out.txt", "w") as f:
+                          f.write(code + "\n")
+                  elif k == sdl2.SDLK_s:
+                      save_grid()
+                  elif k == sdl2.SDLK_l:
+                      load_grid()
+                  elif k == sdl2.SDLK_z:
+                      if undo_stack:
+                          grid[:, :] = undo_stack.pop()
+                  elif k == sdl2.SDLK_o:
+                      onion = grid.copy(); show_onion = True
+                  elif k == sdl2.SDLK_h:
+                      show_onion = not show_onion
+
+          buttons = sdl2.SDL_GetMouseState(ctypes.byref(mxp), ctypes.byref(myp))
+          mx, my = mxp.value // SCALE, myp.value // SCALE
+          left = buttons & sdl2.SDL_BUTTON_LMASK
+          right = buttons & sdl2.SDL_BUTTON_RMASK
+          held = bool(left or right)
+
+          # snapshot once at the start of each stroke that begins on the canvas
+          if held and not prev_held and in_canvas(mx, my):
+              push_undo()
+          prev_held = held
+
+          if left:
+              if in_canvas(mx, my):
+                  r, c = canvas_cell(mx, my)
+                  grid[r, c] = selected
+              else:
+                  pi = palette_index(mx, my)
+                  if pi is not None:
+                      selected = pi
+          if right and in_canvas(mx, my):
+              r, c = canvas_cell(mx, my)
+              grid[r, c] = TRANSPARENT
+
+          draw(screen)
+          rgb = screen.to_rgb()
+          sdl2.SDL_UpdateTexture(texture, None, ctypes.c_void_p(rgb.ctypes.data), VW *
+  3)
+          sdl2.SDL_RenderClear(renderer)
+          sdl2.SDL_RenderCopy(renderer, texture, None, None)
+          sdl2.SDL_RenderPresent(renderer)
+          sdl2.SDL_Delay(16)
+
+      sdl2.SDL_DestroyTexture(texture)
+      sdl2.SDL_DestroyRenderer(renderer)
+      sdl2.SDL_DestroyWindow(window)
+      sdl2.SDL_Quit()
+
+
+if __name__ == "__main__":
+    main()

olympus/font.py

@@ -0,0 +1,43 @@
+FONT = {
+      'A': ["XXX", "X.X", "XXX", "X.X", "X.X"],
+      'B': ["XX.", "X.X", "XX.", "X.X", "XX."],
+      'C': ["XXX", "X..", "X..", "X..", "XXX"],
+      'D': ["XX.", "X.X", "X.X", "X.X", "XX."],
+      'E': ["XXX", "X..", "XX.", "X..", "XXX"],
+      'F': ["XXX", "X..", "XX.", "X..", "X.."],
+      'G': ["XXX", "X..", "X.X", "X.X", "XXX"],
+      'H': ["X.X", "X.X", "XXX", "X.X", "X.X"],
+      'I': ["XXX", ".X.", ".X.", ".X.", "XXX"],
+      'J': ["..X", "..X", "..X", "X.X", "XXX"],
+      'K': ["X.X", "X.X", "XX.", "X.X", "X.X"],
+      'L': ["X..", "X..", "X..", "X..", "XXX"],
+      'M': ["X.X", "XXX", "XXX", "X.X", "X.X"],
+      'N': ["X.X", "XXX", "XXX", "XXX", "X.X"],
+      'O': ["XXX", "X.X", "X.X", "X.X", "XXX"],
+      'P': ["XXX", "X.X", "XXX", "X..", "X.."],
+      'Q': ["XXX", "X.X", "X.X", "XXX", "..X"],
+      'R': ["XX.", "X.X", "XX.", "X.X", "X.X"],
+      'S': ["XXX", "X..", "XXX", "..X", "XXX"],
+      'T': ["XXX", ".X.", ".X.", ".X.", ".X."],
+      'U': ["X.X", "X.X", "X.X", "X.X", "XXX"],
+      'V': ["X.X", "X.X", "X.X", "X.X", ".X."],
+      'W': ["X.X", "X.X", "XXX", "XXX", "X.X"],
+      'X': ["X.X", "X.X", ".X.", "X.X", "X.X"],
+      'Y': ["X.X", "X.X", ".X.", ".X.", ".X."],
+      'Z': ["XXX", "..X", ".X.", "X..", "XXX"],
+      '0': ["XXX", "X.X", "X.X", "X.X", "XXX"],
+      '1': [".X.", "XX.", ".X.", ".X.", "XXX"],
+      '2': ["XXX", "..X", "XXX", "X..", "XXX"],
+      '3': ["XXX", "..X", "XXX", "..X", "XXX"],
+      '4': ["X.X", "X.X", "XXX", "..X", "..X"],
+      '5': ["XXX", "X..", "XXX", "..X", "XXX"],
+      '6': ["XXX", "X..", "XXX", "X.X", "XXX"],
+      '7': ["XXX", "..X", "..X", "..X", "..X"],
+      '8': ["XXX", "X.X", "XXX", "X.X", "XXX"],
+      '9': ["XXX", "X.X", "XXX", "..X", "XXX"],
+      '.': ["...", "...", "...", "...", ".X."],
+      ':': ["...", ".X.", "...", ".X.", "..."],
+      '!': [".X.", ".X.", ".X.", "...", ".X."],
+      '-': ["...", "...", "XXX", "...", "..."],
+      ' ': ["...", "...", "...", "...", "..."],
+  }

olympus/palette.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+PALETTE = np.array([
+    (0, 0, 0),        # 0  black
+    (29, 43, 83),     # 1  dark-blue
+    (126, 37, 83),    # 2  dark-purple
+    (0, 135, 81),     # 3  dark-green
+    (171, 82, 54),    # 4  brown
+    (95, 87, 79),     # 5  dark-grey
+    (194, 195, 199),  # 6  light-grey
+    (255, 241, 232),  # 7  white
+    (255, 0, 77),     # 8  red
+    (255, 163, 0),    # 9  orange
+    (255, 236, 39),   # 10 yellow
+    (0, 228, 54),     # 11 green
+    (41, 173, 255),   # 12 blue
+    (131, 118, 156),  # 13 indigo
+    (255, 119, 168),  # 14 pink
+    (255, 204, 170),  # 15 peach
+  ], dtype=np.uint8)
+
+  # friendly names, so you can write screen.pset(x, y, RED)
+BLACK, DARKBLUE, DARKPURPLE, DARKGREEN = 0, 1, 2, 3
+BROWN, DARKGREY, LIGHTGREY, WHITE = 4, 5, 6, 7
+RED, ORANGE, YELLOW, GREEN = 8, 9, 10, 11
+BLUE, INDIGO, PINK, PEACH = 12, 13, 14, 15

olympus/screen.py

@@ -0,0 +1,199 @@
+import numpy as np
+from .palette import PALETTE
+import ctypes, sdl2
+from .font import FONT
+
+LEFT, RIGHT, UP, DOWN, O, X = 0, 1, 2, 3, 4, 5
+
+_SCANCODES = [
+    sdl2.SDL_SCANCODE_LEFT,
+    sdl2.SDL_SCANCODE_RIGHT,
+    sdl2.SDL_SCANCODE_UP,
+    sdl2.SDL_SCANCODE_DOWN,
+    sdl2.SDL_SCANCODE_Z,
+    sdl2.SDL_SCANCODE_X,
+]
+
+class Screen:
+
+    def __init__(self, w, h):
+        self.w = w
+        self.h = h
+        self.fb = np.zeros((h, w), dtype=np.uint8)
+        self._btn = [False] * 6
+        self._prev = [False] * 6
+
+    def cls(self, color):
+        self.fb[:, :] = color
+
+    def pset(self, x, y, color):
+        if 0 <= x < self.w and 0 <= y < self.h:
+            self.fb[y, x] = color
+
+    def line(self, x0, y0, x1, y1, color):
+        x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1)
+        dx = abs(x1 - x0)
+        dy = -abs(y1 - y0)
+        sx = 1 if x0 < x1 else -1
+        sy = 1 if y0 < y1 else -1
+        err = dx + dy
+        while True:
+            self.pset(x0, y0, color)
+            if x0 == x1 and y0 == y1:
+                break
+            e2 = 2 * err
+            if e2 >= dy:
+                err += dy
+                x0 += sx
+            if e2 <= dx:
+                err += dx
+                y0 += sy
+    
+    def rectfill(self, x0, y0, x1, y1, color):
+        x0, x1 = sorted((int(x0), int(x1)))
+        y0, y1 = sorted((int(y0), int(y1)))
+        x0 = max(0, x0)
+        y0 = max(0, y0)
+        x1 = min(self.w - 1, x1)
+        y1 = min(self.h - 1, y1)
+        if x0 <= x1 and y0 <= y1:
+            self.fb[y0:y1 + 1, x0:x1 + 1] = color
+    
+    def rect(self, x0, y0, x1, y1, color):
+        self.line(x0, y0, x1, y0, color)
+        self.line(x0, y1, x1, y1, color)
+        self.line(x0, y0, x0, y1, color)
+        self.line(x1, y0, x1, y1, color)
+
+    def circ(self, cx, cy, r, color):
+        cx, cy, r = int(cx), int(cy), int(r)
+        if r < 0:
+            return
+        x = r
+        y = 0
+        err = 1 - r
+        while x >= y:
+            self.pset(cx + x, cy + y, color)
+            self.pset(cx + y, cy + x, color)
+            self.pset(cx - y, cy + x, color)
+            self.pset(cx - x, cy + y, color)
+            self.pset(cx - x, cy - y, color)
+            self.pset(cx - y, cy - x, color)
+            self.pset(cx + y, cy - x, color)
+            self.pset(cx + x, cy - y, color)
+            y += 1
+            if err < 0:
+                err += 2 * y + 1
+            else:
+                x -= 1
+                err += 2 * (y - x) + 1
+    
+    def circfill(self, cx, cy, r, color):
+        cx, cy, r = int(cx), int(cy), int(r)
+        if r < 0:
+            return
+        x = r
+        y = 0
+        err = 1 - r
+        while x >= y:
+              # instead of plotting 8 edge points, draw horizontal spans between them
+            self.rectfill(cx - x, cy + y, cx + x, cy + y, color)
+            self.rectfill(cx - x, cy - y, cx + x, cy - y, color)
+            self.rectfill(cx - y, cy + x, cx + y, cy + x, color)
+            self.rectfill(cx - y, cy - x, cx + y, cy - x, color)
+            y += 1
+            if err < 0:
+                err += 2 * y + 1
+            else:
+                x -= 1
+                err += 2 * (y - x) + 1
+
+    def to_rgb(self):
+        return np.ascontiguousarray(PALETTE[self.fb])
+    
+    def btn(self, i):
+        return self._btn[i]
+    
+    def btnp(self, i):
+        return self._btn[i] and not self._prev[i]
+    
+    def spr(self, sprite, x, y, flip_x=False, flip_y=False):
+        s = sprite
+        if flip_x:
+            s = s[:, ::-1]
+        if flip_y:
+            s = s[::-1, :]
+        sh, sw = s.shape
+        x, y = int(x), int(y)
+
+        sx0 = max(0, -x)
+        sy0 = max(0, -y)
+        sx1 = min(sw, self.w - x)
+        sy1 = min(sh, self.h - y)
+        if sx0 >= sx1 or sy0 >= sy1:
+            return
+        
+        sub = s[sy0:sy1, sx0:sx1]
+        dst = self.fb[y + sy0:y + sy1, x + sx0:x + sx1]
+        mask = sub != 255
+        dst[mask] = sub[mask]
+
+    def text(self, s, x, y, color):
+        cx = x
+        for ch in str(s).upper():
+            glyph = FONT.get(ch)
+            if glyph is not None:
+                for j in range(5):
+                    row = glyph[j]
+                    for i in range(3):
+                        if row[i] != '.':
+                            self.pset(cx + i, y + j, color)
+            cx += 4
+        return cx
+    
+    def run(self, update, draw, scale=5, title=b"Olympus"):
+        sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
+        win_w, win_h = self.w * scale, self.h * scale
+
+        window = sdl2.SDL_CreateWindow(
+            title,
+            sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED,
+            win_w, win_h,
+            sdl2.SDL_WINDOW_SHOWN)
+
+        renderer = sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED)
+        sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"0")
+        texture = sdl2.SDL_CreateTexture(
+            renderer,
+            sdl2.SDL_PIXELFORMAT_RGB24,
+            sdl2.SDL_TEXTUREACCESS_STREAMING,
+            self.w, self.h)
+        
+        event = sdl2.SDL_Event()
+        running = True
+        while running:
+            while sdl2.SDL_PollEvent(ctypes.byref(event)):
+                if event.type == sdl2.SDL_QUIT:
+                    running = False
+                elif event.type == sdl2.SDL_KEYDOWN and \
+                        event.key.keysym.sym == sdl2.SDLK_ESCAPE:
+                    running = False
+            
+            keystate = sdl2.SDL_GetKeyboardState(None)
+            self._prev = self._btn
+            self._btn = [bool(keystate[sc]) for sc in _SCANCODES]
+
+            update()
+            draw()
+
+            rgb = self.to_rgb()
+            sdl2.SDL_UpdateTexture(texture, None, ctypes.c_void_p(rgb.ctypes.data), self.w * 3)
+            sdl2.SDL_RenderClear(renderer)
+            sdl2.SDL_RenderCopy(renderer, texture, None, None)
+            sdl2.SDL_RenderPresent(renderer)
+            sdl2.SDL_Delay(16)
+
+        sdl2.SDL_DestroyTexture(texture)
+        sdl2.SDL_DestroyRenderer(renderer)
+        sdl2.SDL_DestroyWindow(window)
+        sdl2.SDL_Quit()

olympus/sound.py

@@ -0,0 +1,69 @@
+import ctypes
+import wave
+import numpy as np
+import sdl2
+
+SAMPLE_RATE = 22050   # audio samples per second
+
+
+def load_wav(path, rate=SAMPLE_RATE):
+      """Load a .wav file and convert it to the engine's format
+      (mono, 16-bit, SAMPLE_RATE). Returns an int16 numpy array."""
+      wv = wave.open(path, "rb")
+      nch = wv.getnchannels()
+      width = wv.getsampwidth()
+      fr = wv.getframerate()
+      raw = wv.readframes(wv.getnframes())
+      wv.close()
+
+      # raw bytes -> float samples in -1..1, whatever the bit depth was
+      if width == 1:
+          a = (np.frombuffer(raw, np.uint8).astype(np.float32) - 128) / 128.0
+      elif width == 2:
+          a = np.frombuffer(raw, np.int16).astype(np.float32) / 32768.0
+      elif width == 4:
+          a = np.frombuffer(raw, np.int32).astype(np.float32) / 2147483648.0
+      else:
+          raise ValueError("unsupported WAV sample width: %d bytes" % width)
+
+      if nch > 1:                       # stereo -> mono: average the channels
+          a = a.reshape(-1, nch).mean(axis=1)
+
+      if fr != rate:                    # resample to our rate
+          m = len(a)
+          new = max(1, int(m * rate / fr))
+          a = np.interp(np.linspace(0, 1, new), np.linspace(0, 1, m), a)
+
+      return (a * 32767).astype(np.int16)
+
+
+class Sound:
+      def __init__(self):
+          sdl2.SDL_InitSubSystem(sdl2.SDL_INIT_AUDIO)
+          spec = sdl2.SDL_AudioSpec(SAMPLE_RATE, sdl2.AUDIO_S16SYS, 1, 1024)
+          self.dev = sdl2.SDL_OpenAudioDevice(None, 0, spec, None, 0)
+          if self.dev:
+              sdl2.SDL_PauseAudioDevice(self.dev, 0)
+
+      def play(self, freq, ms, volume=0.3):
+          """Synthesize and play a square-wave beep."""
+          if not self.dev:
+              return
+          n = int(SAMPLE_RATE * ms / 1000)
+          t = np.arange(n)
+          phase = (freq * t / SAMPLE_RATE) % 1.0
+          square = np.where(phase < 0.5, 1.0, -1.0)
+          fade = max(1, int(SAMPLE_RATE * 0.005))
+          if n > 2 * fade:
+              square[:fade] *= np.linspace(0, 1, fade)
+              square[-fade:] *= np.linspace(1, 0, fade)
+          data = (square * volume * 32767).astype(np.int16)
+          sdl2.SDL_QueueAudio(self.dev, data.ctypes.data_as(ctypes.c_void_p), data.nbytes)
+
+      def play_clip(self, clip, volume=1.0):
+          """Play a clip loaded with load_wav()."""
+          if not self.dev or clip is None:
+              return
+          if volume != 1.0:
+              clip = (clip.astype(np.float32) * volume).astype(np.int16)
+          sdl2.SDL_QueueAudio(self.dev, clip.ctypes.data_as(ctypes.c_void_p), clip.nbytes)

olympus/sprites.py

@@ -0,0 +1,31 @@
+import numpy as np
+import os
+from PIL import Image
+from .palette import PALETTE
+
+TRANSPARENT = 255
+
+def make_sprite(rows):
+    h = len(rows)
+    w = len(rows[0])
+    s = np.full((h, w), TRANSPARENT, dtype=np.uint8)
+    for j, row in enumerate(rows):
+        for i, ch in enumerate(row):
+            if ch != '.':
+                s[j, i] = int(ch, 16)
+    return s
+
+def load_sprite(path):
+    img = Image.open(path).convert("RGBA")
+    arr = np.array(img)
+    rgb = arr[:, :, :3].astype(np.int32)
+    alpha = arr[:, :, 3]
+
+    pal = PALETTE.astype(np.int32)
+
+    diff = rgb[:, :, None, :] - pal[None, None, :, :]
+    dist = (diff * diff).sum(axis=3)
+    idx = dist.argmin(axis=2).astype(np.uint8)
+
+    idx[alpha < 128] = TRANSPARENT
+    return idx

olympus/tilemap.py

@@ -0,0 +1,65 @@
+from .sprites import make_sprite
+
+TILE = 8
+
+WALL = make_sprite([
+    "55555555",
+    "56666665",
+    "56666665",
+    "56666665",
+    "56666665",
+    "56666665",
+    "56666665",
+    "55555555",
+])
+
+COIN = make_sprite([
+    "........",
+    "..aaaa..",
+    ".aaaaaa.",
+    ".aaaaaa.",
+    ".aaaaaa.",
+    ".aaaaaa.",
+    "..aaaa..",
+    "........",
+])
+
+TILES = {
+    'W': WALL,
+    'C': COIN,
+}
+
+SOLID = {'W'}
+
+class Tilemap:
+    def __init__(self, rows, tiles, solid):
+        self.rows = rows
+        self.tiles = tiles
+        self.solid = solid
+        self.h = len(rows)
+        self.w = len(rows[0])
+
+    def get(self, col, row):
+        if 0 <= row < self.h and 0 <= col < self.w:
+            return self.rows[row][col]
+        
+    def set(self, col, row, ch):
+        line = self.rows[row]
+        self.rows[row] = line[:col] + ch + line[col + 1:]
+
+    def draw(self, screen):
+        for row in range(self.h):
+            for col in range(self.w):
+                sprite = self.tiles.get(self.rows[row][col])
+                if sprite is not None:
+                    screen.spr(sprite, col * TILE, row * TILE)
+
+    def solid_at(self, x, y):
+        return self.get(x // TILE, y // TILE) in self.solid
+    
+    def box_hits_solid(self, x, y, w, h):
+        return (self.solid_at(x, y) or
+                self.solid_at(x + w - 1, y) or
+                self.solid_at(x, y + h - 1) or
+                self.solid_at(x + w - 1, y + h - 1))
+    

olympus_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: olympus-engine
+Version: 0.1.0
+Summary: A from-scratch 2D  game engine for Python
+Author: Nithil Gadde
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nithilgadde/Olympus
+Project-URL: Repository, https://github.com/nithilgadde/Olympus
+Project-URL: Issues, https://github.com/nithilgadde/Olympus/issues
+Keywords: game-engine,fantasy-console,pico-8,pixel-art,gamedev,retro,2d,sdl2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pysdl2
+Requires-Dist: pysdl2-dll
+Requires-Dist: pillow
+Dynamic: license-file
+
+# Olympus
+
+A from-scratch 2D fantasy-console game engine for Python. Build tiny pixel games on a 128×128 screen with a fixed 16-color palette and a few lines of code.
+
+![Olympus demo](https://raw.githubusercontent.com/nithilgadde/Olympus/main/docs/demo.gif)
+
+## Try it
+
+```bash
+pip install olympus-engine
+olympus-editor              # draw sprites with the mouse, export to code
+```
+
+Then make a tiny game in about 15 lines — see **Quick start** below.
+
+## Quick start
+
+Make a game in about 15 lines:
+
+```python
+import olympus as ol
+
+screen = ol.Screen(128, 128)
+x, y = 60, 60
+
+def update():
+    global x, y
+    if screen.btn(ol.LEFT):  x -= 1
+    if screen.btn(ol.RIGHT): x += 1
+    if screen.btn(ol.UP):    y -= 1
+    if screen.btn(ol.DOWN):  y += 1
+
+def draw():
+    screen.cls(ol.BLACK)
+    screen.rectfill(x, y, x + 7, y + 7, ol.RED)
+    screen.text("HELLO OLYMPUS", 18, 40, ol.WHITE)
+
+screen.run(update, draw)
+```
+
+You write `update` (game logic) and `draw` (pixels); the engine runs them 60 times a second and handles the window, input, and rendering.
+
+## Features
+
+- **128×128 indexed framebuffer** with a fixed 16-color palette — the classic fantasy-console look.
+- **Hand-written rasterizers**: pixels, lines (Bresenham), rectangles, and circles (midpoint), outlined or filled.
+- **Sprites** you can hand-draw as text or load from a PNG — loaded images are automatically quantized down to the 16-color palette.
+- **Animation, tilemaps, and AABB collision** — cycle frames for walk cycles, build levels as grids of characters, and check what's solid.
+- **A built-in pixel font** for scores, labels, and menus.
+- **Sound**: square-wave synthesis for retro blips, plus loading and playing your own `.wav` files.
+- **A built-in sprite editor** (`olympus-editor`) — draw with the mouse and export straight to engine code, with undo, save/load, and onion-skinning.
+
+## Running locally
+
+Requirements:
+
+- **Python 3.9+**
+- No system libraries to install by hand — `pysdl2-dll` ships the SDL2 binaries, and `pip` installs everything else (numpy, PySDL2, Pillow) automatically.
+
+From the project root (the folder with `pyproject.toml`):
+
+```bash
+python -m venv venv
+source venv/bin/activate        # Windows: venv\Scripts\activate
+pip install -e .
+
+python examples/demo.py         # run the demo game
+olympus-editor                  # open the sprite editor
+```
+
+## How it works
+
+Olympus is "from scratch" in a specific, deliberate way: **no graphics or game library does the drawing.** The screen is a NumPy array of palette *indices* (not RGB), and every shape is rasterized by hand — Bresenham lines, midpoint circles, a sprite blitter, a pixel font, and square-wave audio synthesized sample by sample. SDL2 is only used to open a window, present the finished pixel buffer, and read input. It is **not** a wrapper around pygame.
+
+A couple of decisions worth calling out:
+
+- **The framebuffer stores color indices, not RGB.** Drawing just writes small integers (0–15) into a 2D array, which is fast and keeps the palette constraint baked into the design. The conversion to real RGB happens once per frame, with a single NumPy lookup, right before handing the buffer to SDL.
+- **Loading a PNG means quantizing it.** Because the framebuffer is indexed, imported images can't be copied pixel-for-pixel — every pixel is snapped to its nearest palette color in a vectorized NumPy pass. That preserves the console's look no matter what art you throw at it.
+
+## Credits
+
+Built with [PySDL2](https://github.com/py-sdl/py-sdl2) (windowing, input, audio output), [NumPy](https://numpy.org/) (the framebuffer and rasterization), and [Pillow](https://python-pillow.org/) (PNG decoding). Inspired by [PICO-8](https://www.lexaloffle.com/pico-8.php) and the fantasy-console idea.
+
+Created by Nithil Gadde · MIT License

olympus_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+olympus/__init__.py,sha256=eozMHDlDWspmZdlDud9OJOOSMB3_T3Oq44O80k_ZgyU,843
+olympus/anim.py,sha256=4xKqzwiRjXs5AyqpFV_SqeHitxMYTwOwzbYbSjtQQzc,417
+olympus/collide.py,sha256=xI3lQ82jsF08H6qKcXs36n4Tyv43-79AY6jZXpohIQo,258
+olympus/editor.py,sha256=h7HI4bzl2G4pFf39E7DKCQYFfNvFhZDX0KGyEjRoquw,6387
+olympus/font.py,sha256=D5OOXiEumNPclHow6YLl0_rMhuXIStfNuMTgScTmUfw,1980
+olympus/palette.py,sha256=avdRvIa5cPZUX5mIaK2Tu1bs9CkoefcaV1Ww1e6fOZg,857
+olympus/screen.py,sha256=aJLYjFnJO3gO-p4Sj2yU87V6yqd5hG4BdO1Us7fiz9s,6109
+olympus/sound.py,sha256=HpZawQOXul9gWxYtF04Vk85HtQHCHZshnUT6dRMBPWE,2619
+olympus/sprites.py,sha256=8rxr269xqwEob4HOargLLD1TMJA48VNp7x40IqB2iSw,747
+olympus/tilemap.py,sha256=BKzWFBQNBCUFcmSKYsXM9vfCqxu408TceDXyYyxOP5M,1446
+olympus_engine-0.1.0.dist-info/licenses/LICENSE,sha256=af-qcTTYnbK2yszBGf_6FQxObp3Q8J0WdYxiAxoMS78,1069
+olympus_engine-0.1.0.dist-info/METADATA,sha256=XcBU31veRS5iYuSo4H8V3h65gE0dNJR2G2KS7EOWfdY,5095
+olympus_engine-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+olympus_engine-0.1.0.dist-info/entry_points.txt,sha256=Q9--T-GPzHlFI6xaVbycF3zSSci2EH2oFVuEMjh9iYQ,55
+olympus_engine-0.1.0.dist-info/top_level.txt,sha256=vO7aGDG7Or1P6gE-RGLFbywAeAl1kP4mgVXYkmD2lG0,8
+olympus_engine-0.1.0.dist-info/RECORD,,

olympus_engine-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

olympus_engine-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+olympus-editor = olympus.editor:main

olympus_engine-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nithil Gadde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

olympus_engine-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+olympus