Refactor!!

6 files changed, 168 insertions, 137 deletions

diff --git a/src/macroknight/entities.hy b/src/macroknight/entities.hy
new file mode 100644
index 0000000..1ac59ce
--- /dev/null
+++ b/src/macroknight/entities.hy
@@ -0,0 +1,66 @@
+(import pygame.sprite [Sprite]
+        pygame [Surface]
+        pygame
+        utils [neg merge-moves])
+
+(defclass Entity [Sprite]
+   ;;; Game entity
+  (setv _fixed False)
+
+  (defn __init__ [self id tile tile-size initial-pos]
+    (.__init__ (super))
+    (setv self.id id)
+    (setv self._surf (Surface #(tile-size tile-size)))
+    (.blit self._surf tile #(0 0))
+    (setv self._rect (.get_rect self._surf
+                                :left (* (get initial-pos 0) tile-size)
+                                :top (* (get initial-pos 1) tile-size))))
+
+  (defn [property] fixed [self]
+    self._fixed)
+
+  (defn [property] rect [self]
+    self._rect)
+
+  (defn [property] surf [self]
+    self._surf))
+
+(defclass LevelTile [Entity]
+  (setv _fixed True)
+
+  (defn __init__ [self id tile-size scaling x y tile]
+    (let [tile-width (* (.get_width tile) scaling)
+          tile-height (* (.get_height tile) scaling)
+          tile_ (if (!= scaling 1)
+                    (pygame.transform.scale tile #(tile-width tile-height))
+                    tile)]
+      (.__init__ (super) id tile_ tile-size #(x y)))))
+
+(defclass Player [Entity]
+  (setv SPEED 3)
+  (setv JUMP_IMPULSE 10)
+  (setv MAX_JUMPING 100)
+
+  (defn __init__ [self id tile tile-size initial-x initial-y]
+    (.__init__ (super) id tile tile-size #(initial-x initial-y))
+    (setv self.jumping False)
+    (setv self.jump-move 0))
+
+  (defn move [self move]
+    (.append self.moves move)
+    (.move_ip self._rect (get move 0) (get move 1)))
+
+  (defn [property] total-move [self]
+    (merge-moves self.moves))
+
+  (defn jump [self]
+    (setv self.jumping True)
+    (when (< self.jump-move self.MAX_JUMPING)
+      (setv self.jump-move (+ self.jump-move self.JUMP_IMPULSE))
+      (.move self #(0 (neg self.JUMP_IMPULSE)))))
+
+  (defn ground [self]
+    (setv self.jump-move 0))
+
+  (defn flush [self]
+    (setv self.moves [])))
diff --git a/src/macroknight/game.hy b/src/macroknight/game.hy
index 7227f76..53e6fac 100644
--- a/src/macroknight/game.hy
+++ b/src/macroknight/game.hy
@@ -2,148 +2,33 @@
 (require hyrule *)
 (import pygame
         pytmx.util_pygame [load_pygame]
-        pprint [pprint])
+        entities [Player LevelTile]
+        tiles [TileSet draw-tile]
+        utils [neg]
+        text [render-text]
+        systems [apply-gravity apply-collisions])
 
 (pygame.init)
 
-
 (setv TILE_SCALING 1)
 (setv TILE_SIZE (* TILE_SCALING 16))
-(setv GRAVITY 5)
-
-(defn neg [value]
-  (* -1 value))
-
-(defn invert [move]
-  #((neg (get move 0))
-     (neg (get move 1))))
-
-(defn merge-moves [moves]
-  (let [end-move #(0 0)]
-    (for [move moves]
-      (setv end-move
-            #((+ (get end-move 0) (get move 0))
-               (+ (get end-move 1) (get move 1)))))
-    end-move))
-
-(defclass TileSet []
-  (defn __init__ [self image tile-w tile-h [padding 0]]
-
-    (setv self.sheet
-          (let [surf (pygame.image.load "assets/monochrome-transparent.png")]
-            (if (!= TILE_SCALING 1)
-                (pygame.transform.scale
-                  surf
-                  #((* (.get_width surf) TILE_SCALING)
-                     (* (.get_height surf) TILE_SCALING)))
-                surf)))
-
-    (setv self.tiles
-          (lfor y (range 0 (.get_height self.sheet) (+ tile-h (* padding TILE_SCALING)))
-                x (range 0 (.get_width self.sheet) (+ tile-w (* padding TILE_SCALING)))
-                (let [tile (pygame.Surface #(tile-w tile-h))]
-                  (.blit tile self.sheet #(0 0) #(x y tile-w tile-h))
-                  tile)))))
-
-
-;; Define systems here
-(defn apply-gravity [entity entities]
-  (when (not entity.fixed)
-    (.move entity #(0 GRAVITY))))
-
-(defn apply-collisions [entity entities]
-  (for [ent entities]
-    (when (and (!= ent.id entity.id)
-               (.colliderect entity.rect ent.rect)
-               (not entity.fixed))
-      (let [collision-rect (.clip entity.rect ent.rect)
-            move-x (get entity.total-move 0)
-            move-y (get entity.total-move 1)]
-        (when (!= move-x 0)
-          (.move entity #((* (if (> move-x 0) -1 1) collision-rect.width) 0)))
-        (when (!= move-y 0)
-          (.move entity #(0 (* (if (> move-y 0) -1 1) collision-rect.height)))))
-      (.ground entity))))
-
-;; Define entities here
-(defclass LevelTile []
-  (setv fixed True)
-
-  (defn __init__ [self id x y surf]
-    (setv self.id id)
-    (setv self.surf
-          (if (!= TILE_SCALING 1)
-              (pygame.transform.scale
-                surf
-                #((* (.get_width surf) TILE_SCALING)
-                   (* (.get_height surf) TILE_SCALING)))
-              surf))
-
-    (setv self.rect (.get_rect surf :left (* x TILE_SIZE) :top (* y TILE_SIZE)))))
-
-(defclass MiniSprite [pygame.sprite.Sprite]
-  (defn __init__ [self tile x y]
-    (.__init__ (super))
-    (setv self.surf (pygame.Surface #(TILE_SIZE TILE_SIZE)))
-    (.blit self.surf tile #(0 0))
-    (setv self.rect (.get_rect self.surf :left (* x TILE_SIZE) :top (* y TILE_SIZE)))))
-
-(defclass Player [pygame.sprite.Sprite]
-  (setv fixed False)
-  (setv SPEED 3)
-  (setv JUMP_IMPULSE 10)
-  (setv MAX_JUMPING 100)
-
-  (defn __init__ [self tile initial-x initial-y]
-    (.__init__ (super))
-    (setv self.id 1)
-    (setv self.surf (pygame.Surface #(TILE_SIZE TILE_SIZE)))
-    (setv self.jumping False)
-    (setv self.jump_move 0)
-    (.blit self.surf tile #(0 0))
-    (setv self.rect (.get_rect self.surf :left (* 5 TILE_SIZE))))
-
-  (defn move [self move]
-    (.append self.moves move)
-    (.move_ip self.rect (get move 0) (get move 1)))
-
-  (defn [property] total-move [self]
-    (merge-moves self.moves))
-
-  (defn jump [self]
-    (setv self.jumping True)
-    (when (< self.jump_move self.MAX_JUMPING)
-      (setv self.jump_move (+ self.jump_move self.JUMP_IMPULSE))
-      (.move self #(0 (neg self.JUMP_IMPULSE)))))
-
-  (defn ground [self]
-    (setv self.jump_move 0))
-
-  (defn flush [self]
-    (setv self.moves [])))
 
 (setv screen (pygame.display.set_mode #((* TILE_SCALING 640) (* TILE_SCALING 480))))
 (setv clock (pygame.time.Clock))
 (setv running True)
-
-(setv tiles (TileSet "assets/monochrome-transparent.png" TILE_SIZE TILE_SIZE 1))
-
-(setv player (Player (get tiles.tiles 28) 0 0))
+(setv tileset (TileSet "assets/monochrome-transparent.png" TILE_SCALING TILE_SIZE TILE_SIZE 1))
+(setv player (Player 1 (get tileset.tiles 28) TILE_SIZE 5 5))
 (setv sprites-group [])
 (.append sprites-group player)
-(setv level (load_pygame "assets/level-1.tmx"))
+(setv level (load_pygame "assets/level-0.tmx"))
 (setv macro-input-mode False)
 (setv macro-commands [None None None])
 
 (for [tiledef (enumerate (.tiles (get level.layers 0)))]
-  (.append sprites-group (LevelTile (get tiledef 0) #* (get tiledef 1))))
+  (.append sprites-group (LevelTile (get tiledef 0) TILE_SIZE TILE_SCALING #* (get tiledef 1))))
 
 (setv ongoing_inputs [])
 
-(defn draw-tile [target tile-id x y]
-  (let [tile (MiniSprite (get tiles.tiles tile-id) x y)]
-    (.blit target tile.surf tile.rect)))
-
 (while running
   (for [event (pygame.event.get)]
     (case event.type
@@ -152,7 +37,6 @@
                              (setv running False)
                              (if macro-input-mode
                                  (when (in event.key [pygame.K_a pygame.K_w pygame.K_a pygame.K_s pygame.K_d])
-                                   (print event.key)
                                    (setv (get macro-commands (.index macro-commands None)) event.key))
                                  (case event.key
                                        pygame.K_SPACE (setv macro-input-mode True)
@@ -162,32 +46,36 @@
 
   (.fill screen "#000000")
 
+  (render-text screen tileset "USE A MACRO MOVE TO JUMP HIGHER" 1 10)
+  (render-text screen tileset "HIT SPACE AND ENTER A COMBO" 1 11)
+
   (if macro-input-mode
       ;; If the commands list is full
       (if (get macro-commands -1)
           ;; Process commands
           (do
-            (pprint (lfor command macro-commands :if command command))
             (let [#(command-id command) (get (lfor command (enumerate macro-commands) :if (get command 1) command) 0)]
               (case command
                     pygame.K_a (.move player #((neg TILE_SIZE) 0))
                     pygame.K_s (.move player #(0 1))
-                    pygame.K_w (.move player #(0 (neg player.MAX_JUMPING)))
+                    pygame.K_w (.move player #(0 (neg (/ player.MAX_JUMPING 2))))
                     pygame.K_d (.move player #(TILE_SIZE 0)))
               (if (= command-id (- (len macro-commands) 1))
                   (do  (setv macro-commands [None None None])
                        (setv macro-input-mode False))
                   (setv (get macro-commands command-id) None))))
 
-          (do (draw-tile screen 774 3 1)
-              (for [#(num command) (enumerate macro-commands)]
-                (let [x-pos (+ 4 num)]
-                  (case command
-                        pygame.K_w (draw-tile screen 1057 x-pos 1)
-                        pygame.K_d (draw-tile screen 1058 x-pos 1)
-                        pygame.K_s (draw-tile screen 1059 x-pos 1)
-                        pygame.K_a (draw-tile screen 1060 x-pos 1))))))
+          ;; If there's still space in the commands list
+          (for [#(num command) (enumerate macro-commands)]
+            (let [x-pos (+ 4 num)]
+              (case command
+                    pygame.K_w (draw-tile screen tileset 1057 x-pos 5)
+                    pygame.K_d (draw-tile screen tileset 1058 x-pos 5)
+                    pygame.K_s (draw-tile screen tileset 1059 x-pos 5)
+                    pygame.K_a (draw-tile screen tileset 1060 x-pos 5)
+                    None (draw-tile screen tileset 725 x-pos 5)))))
 
+      ;; Else
       (do (for [inp ongoing_inputs]
             (case inp
                   pygame.K_a (.move player #((neg player.SPEED) 0))
@@ -213,7 +101,6 @@
     (.blit screen sprite.surf sprite.rect))
 
   (pygame.display.flip)
-  (.tick clock 60)
-  )
+  (.tick clock 60))
 
 (pygame.quit)
diff --git a/src/macroknight/systems.hy b/src/macroknight/systems.hy
new file mode 100644
index 0000000..2762247
--- /dev/null
+++ b/src/macroknight/systems.hy
@@ -0,0 +1,20 @@
+;; Define systems here
+(setv GRAVITY 5)
+
+(defn apply-gravity [entity entities]
+  (when (not entity.fixed)
+    (.move entity #(0 GRAVITY))))
+
+(defn apply-collisions [entity entities]
+  (for [ent entities]
+    (when (and (!= ent.id entity.id)
+               (.colliderect entity.rect ent.rect)
+               (not entity.fixed))
+      (let [collision-rect (.clip entity.rect ent.rect)
+            move-x (get entity.total-move 0)
+            move-y (get entity.total-move 1)]
+        (when (!= move-x 0)
+          (.move entity #((* (if (> move-x 0) -1 1) collision-rect.width) 0)))
+        (when (!= move-y 0)
+          (.move entity #(0 (* (if (> move-y 0) -1 1) collision-rect.height)))))
+      (.ground entity))))
diff --git a/src/macroknight/text.hy b/src/macroknight/text.hy
new file mode 100644
index 0000000..1b631c1
--- /dev/null
+++ b/src/macroknight/text.hy
@@ -0,0 +1,8 @@
+(import tiles [draw-tile])
+
+(defn render-text [surf tileset text x y]
+  (for [#(char-num char) (enumerate text)]
+    (when (> (ord char) 32)
+      (let [sprite-num (+ (ord char)
+                          (if (> (ord char) 77) 888 852))]
+        (draw-tile surf tileset sprite-num (+ x char-num) y)))))
diff --git a/src/macroknight/tiles.hy b/src/macroknight/tiles.hy
new file mode 100644
index 0000000..40692e7
--- /dev/null
+++ b/src/macroknight/tiles.hy
@@ -0,0 +1,36 @@
+(import pygame)
+
+(defclass TileSet []
+  (defn __init__ [self image scaling tile-w tile-h [padding 0]]
+    (setv self.tile-w tile-w)
+    (setv self.tile-h tile-h)
+    (setv self.scaling scaling)
+
+    (setv self.sheet
+          (let [surf (pygame.image.load "assets/monochrome-transparent.png")
+                map-width (* (.get_width surf) self.scaling)
+                map-height (* (.get_height surf) self.scaling)]
+            (if (!= self.scaling 1)
+                (pygame.transform.scale surf #(map-width map-height))
+                surf)))
+
+    (setv self.tiles
+          (lfor y (range 0 (.get_height self.sheet) (+ tile-h (* padding self.scaling)))
+                x (range 0 (.get_width self.sheet) (+ tile-w (* padding self.scaling)))
+                (let [tile (pygame.Surface #(tile-w tile-h))]
+                  (.blit tile self.sheet #(0 0) #(x y tile-w tile-h))
+                  tile)))))
+
+(defclass MiniSprite [pygame.sprite.Sprite]
+  (defn __init__ [self tile tile-size x y]
+    (.__init__ (super))
+    (setv self.surf (pygame.Surface #(tile-size tile-size)))
+    (.blit self.surf tile #(0 0))
+    (setv self.rect (.get_rect self.surf
+                               :left (* x tile-size)
+                               :top (* y tile-size)))))
+
+(defn draw-tile [target tileset tile-id x y]
+  (let [tile (get tileset.tiles tile-id)
+        sprite (MiniSprite tile tileset.tile-w x y)]
+    (.blit target sprite.surf sprite.rect)))
diff --git a/src/macroknight/utils.hy b/src/macroknight/utils.hy
new file mode 100644
index 0000000..a857d02
--- /dev/null
+++ b/src/macroknight/utils.hy
@@ -0,0 +1,14 @@
+(defn neg [value]
+  (* -1 value))
+
+(defn invert [move]
+  #((neg (get move 0))
+     (neg (get move 1))))
+
+(defn merge-moves [moves]
+  (let [end-move #(0 0)]
+    (for [move moves]
+      (setv end-move
+            #((+ (get end-move 0) (get move 0))
+               (+ (get end-move 1) (get move 1)))))
+    end-move))