WIP again

4 files changed, 159 insertions, 124 deletions

diff --git a/src/macroknight/entities.hy b/src/macroknight/entities.hy
index 1ac59ce..50d774c 100644
--- a/src/macroknight/entities.hy
+++ b/src/macroknight/entities.hy
@@ -7,14 +7,14 @@
    ;;; Game entity
   (setv _fixed False)
 
-  (defn __init__ [self id tile tile-size initial-pos]
+  (defn __init__ [self id tile tile-size x y]
     (.__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))))
+                                :left (* x tile-size)
+                                :top (* y tile-size))))
 
   (defn [property] fixed [self]
     self._fixed)
@@ -28,21 +28,24 @@
 (defclass LevelTile [Entity]
   (setv _fixed True)
 
-  (defn __init__ [self id tile-size scaling x y tile]
+  (defn __init__ [self id tile tile-size x y scaling]
     (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)))))
+      (.__init__ (super) id tile_ tile-size x y))))
+
+(defclass Goal [Entity]
+  (setv _fixed True))
 
 (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))
+  (defn __init__ [self id tile tile-size x y]
+    (.__init__ (super) id tile tile-size x y)
     (setv self.jumping False)
     (setv self.jump-move 0))
 
diff --git a/src/macroknight/game.hy b/src/macroknight/game.hy
index 1c10c95..a8f6c62 100644
--- a/src/macroknight/game.hy
+++ b/src/macroknight/game.hy
@@ -1,8 +1,9 @@
 (require hy)
 (require hyrule *)
 (import pygame
+        pprint [pprint]
         pytmx.util_pygame [load_pygame]
-        entities [Player LevelTile]
+        entities [Player LevelTile Goal]
         tiles [TileSet draw-tile]
         utils [neg]
         text [render-text]
@@ -20,120 +21,150 @@
 (setv clock (pygame.time.Clock))
 (setv running True)
 (setv tileset (TileSet "assets/monochrome-transparent.png" TILE_SCALING TILE_SIZE TILE_SIZE 1))
-(setv sprites-group [])
-(setv level (load_pygame "assets/level-0.tmx"))
+(setv levels [(load_pygame "assets/level-0.tmx")
+              (load_pygame "assets/level-1.tmx")])
+(setv level-id 0)
 (defn abs-to-tile-index [abs-id]
   (int (floor (/ abs-id TILE_SIZE))))
-(setv player-pos
-      (let [player-objects (lfor ent (get level.layers 1) :if (= ent.type "Player") ent)]
-        (if (any player-objects)
-            (let [player-object (get player-objects 0)]
-               #((abs-to-tile-index player-object.x)
-                 (abs-to-tile-index player-object.y)))
-            #(5 5))))
-(setv player (Player 1 (get tileset.tiles 28) TILE_SIZE #* player-pos))
-(.append sprites-group player)
-(setv macro-input-mode False)
-(setv macro-wait-time 0)
-(setv macro-commands [None None None])
-
-(for [tiledef (enumerate (.tiles (get level.layers 0)))]
-  (.append sprites-group (LevelTile (get tiledef 0) TILE_SIZE TILE_SCALING #* (get tiledef 1))))
-
-(setv ongoing_inputs [])
-
-(while running
-  (for [event (pygame.event.get)]
-    (case event.type
-          pygame.QUIT (setv running False)
-          pygame.KEYDOWN (if (= event.key pygame.K_ESCAPE)
-                             (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])
-                                   (setv (get macro-commands (.index macro-commands None)) event.key))
-                                 (if (and (= event.key pygame.K_SPACE) (= macro-wait-time 0))
-                                     (setv macro-input-mode True)
-                                     (.append ongoing_inputs event.key))))
-          pygame.KEYUP (when (in event.key ongoing_inputs)
-                         (.remove ongoing_inputs event.key))))
-
-  (.fill screen "#000000")
-
-  ;; Render text objects
+
+(setv game-running True)
+
+
+(while game-running
+
+  ;; Load the level
+  (setv level (get levels level-id))
+  (setv entities [])
+  (setv player-pos #(5 5))
   (for [item (get level.layers 1)]
-    (when (= item.type "Text")
-      (render-text screen
-                   tileset
-                   (.upper item.text)
-                   (abs-to-tile-index item.x)
-                   (abs-to-tile-index item.y))))
-
-
-  (if macro-input-mode
-      ;; If the commands list is full
-      (if (get macro-commands -1)
-          ;; Process commands
-          (do
-            (let [#(command-id command) (get (lfor command (enumerate macro-commands) :if (get command 1) command) 0)]
-              (case command
-                    pygame.K_a (.move player #((neg (* 2 TILE_SIZE)) 0))
-                    pygame.K_s (.move player #(0 TILE_SIZE))
-                    pygame.K_w (.move player #(0 (neg (/ player.MAX_JUMPING 2))))
-                    pygame.K_d (.move player #((* 2 TILE_SIZE) 0)))
-              (if (= command-id (- (len macro-commands) 1))
-                  (do  (setv macro-commands [None None None])
-                       (setv macro-input-mode False)
-                       (setv macro-wait-time (+ (pygame.time.get_ticks) MACRO_COOLDOWN)))
-                  (setv (get macro-commands command-id) None)))
-            (pygame.time.wait MACRO_STEP_WAIT))
-
-          ;; 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)))))
-
-      ;; Not in macro mode
-      (do
-        (when (> macro-wait-time 0)
-          (let [progress (round (* 3 (/ (- (pygame.time.get_ticks) macro-wait-time) MACRO_COOLDOWN)))]
-            (for [indicator (range 3)]
-              (draw-tile
-                screen tileset 725 ))))
-        (for [inp ongoing_inputs]
-          (case inp
-                pygame.K_a (.move player #((neg player.SPEED) 0))
-                pygame.K_s (.move player #(0 1))
-                pygame.K_w (.jump player)
-                pygame.K_d (.move player #(player.SPEED 0))))
+    (let [tile-x (abs-to-tile-index item.x)
+          tile-y (abs-to-tile-index item.y)]
+      (case item.type
+            "Player" (setv player-pos #(tile-x tile-y))
+            "Goal" (.append entities
+                            (Goal (len entities)
+                                  (get tileset.tiles 0)
+                                  TILE_SIZE
+                                  (abs-to-tile-index item.x)
+                                  (abs-to-tile-index item.y))))))
+  
+  (setv player-pos
+        (let [player-objects (lfor ent (get level.layers 1) :if (= ent.type "Player") ent)]
+          (if (any player-objects)
+              (let [player-object (get player-objects 0)]
+                #((abs-to-tile-index player-object.x)
+                   (abs-to-tile-index player-object.y)))
+              #(5 5))))
+  (setv player (Player 1 (get tileset.tiles 28) TILE_SIZE #* player-pos))
+  (.append entities player)
+  (setv macro-input-mode False)
+  (setv macro-wait-time 0)
+  (setv macro-commands [None None None])
+  (for [#(id tiledef) (enumerate (.tiles (get level.layers 0)))]
+    (let [x (get tiledef 0)
+          y (get tiledef 1)
+          tile (get tiledef 2)]
+      (.append entities (LevelTile id tile TILE_SIZE x y TILE_SCALING))))
+
+  (setv ongoing_inputs [])
+
+  (pprint (get entities 0))
+
+  (while running
+    (for [event (pygame.event.get)]
+      (case event.type
+            pygame.QUIT (do
+                          (setv running False)
+                          (setv game-running False))
+            pygame.KEYDOWN (if (= event.key pygame.K_ESCAPE)
+                               (do
+                                 (setv running False)
+                                 (setv game-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])
+                                     (setv (get macro-commands (.index macro-commands None)) event.key))
+                                   (if (and (= event.key pygame.K_SPACE) (= macro-wait-time 0))
+                                       (setv macro-input-mode True)
+                                       (.append ongoing_inputs event.key))))
+            pygame.KEYUP (when (in event.key ongoing_inputs)
+                           (.remove ongoing_inputs event.key))))
+
+    (.fill screen "#000000")
+
+    ;; Render special objects
+    (for [item (get level.layers 1)]
+      (case item.type 
+            "Text" (render-text screen
+                                tileset
+                                (.upper item.text)
+                                (abs-to-tile-index item.x)
+                                (abs-to-tile-index item.y))))
+
+    (if macro-input-mode
+        ;; If the commands list is full
+        (if (get macro-commands -1)
+            ;; Process commands
+            (do
+              (let [#(command-id command) (get (lfor command (enumerate macro-commands) :if (get command 1) command) 0)]
+                (case command
+                      pygame.K_a (.move player #((neg (* 2 TILE_SIZE)) 0))
+                      pygame.K_s (.move player #(0 TILE_SIZE))
+                      pygame.K_w (.move player #(0 (neg (/ player.MAX_JUMPING 2))))
+                      pygame.K_d (.move player #((* 2 TILE_SIZE) 0)))
+                (if (= command-id (- (len macro-commands) 1))
+                    (do  (setv macro-commands [None None None])
+                         (setv macro-input-mode False)
+                         (setv macro-wait-time (+ (pygame.time.get_ticks) MACRO_COOLDOWN)))
+                    (setv (get macro-commands command-id) None)))
+              (pygame.time.wait MACRO_STEP_WAIT))
+
+            ;; 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)))))
+
+        ;; Not in macro mode
+        (do
+          (when (> macro-wait-time 0)
+            (let [progress (round (* 3 (/ (- (pygame.time.get_ticks) macro-wait-time) MACRO_COOLDOWN)))]
+              (for [indicator (range 3)]
+                (draw-tile
+                  screen tileset 725 ))))
+          (for [inp ongoing_inputs]
+            (case inp
+                  pygame.K_a (.move player #((neg player.SPEED) 0))
+                  pygame.K_s (.move player #(0 1))
+                  pygame.K_w (.jump player)
+                  pygame.K_d (.move player #(player.SPEED 0))))
 
           (when (any ongoing_inputs)
-            (for [sprite sprites-group]
-              (apply-collisions sprite sprites-group)))
+            (for [entity entities]
+              (apply-collisions entity entities)))
 
           (.flush player)
 
           ;; Apply systems
-          (for [sprite sprites-group]
-            (apply-gravity sprite sprites-group)
-            (apply-collisions sprite sprites-group))
+          (for [entity entities]
+            (apply-gravity entity entities)
+            (apply-collisions entity entities))
 
           (.flush player)))
 
 
-  (for [sprite sprites-group]
-    (.blit screen sprite.surf sprite.rect))
+    (for [entity entities]
+      (.blit screen entity.surf entity.rect))
 
-  (pygame.display.flip)
+    (pygame.display.flip)
 
-  (when (or (= 0 macro-wait-time)
-            (< (- (pygame.time.get_ticks) macro-wait-time) 0))
-    (setv macro-wait-time 0))
+    (when (or (= 0 macro-wait-time)
+              (< (- (pygame.time.get_ticks) macro-wait-time) 0))
+      (setv macro-wait-time 0))
 
-  (.tick clock 60))
+    (.tick clock 60)))
 
 (pygame.quit)
diff --git a/src/macroknight/systems.hy b/src/macroknight/systems.hy
index 2762247..b02bc50 100644
--- a/src/macroknight/systems.hy
+++ b/src/macroknight/systems.hy
@@ -6,15 +6,14 @@
     (.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))))
+  (when (not entity.fixed)
+    (for [ent (gfor enti entities :if (!= enti.id entity.id) enti)]
+      (when (.colliderect entity.rect ent.rect)
+        (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/tiles.hy b/src/macroknight/tiles.hy
index f9e112d..2345e17 100644
--- a/src/macroknight/tiles.hy
+++ b/src/macroknight/tiles.hy
@@ -22,15 +22,17 @@
                   tile)))))
 
 (defclass MiniSprite [pygame.sprite.Sprite]
-  (defn __init__ [self tile tile-size x y]
+  (defn __init__ [self tile tile-size x y [goal False]]
     (.__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)))))
+                               :top (* y tile-size)))
+    (setv self.goal goal)))
 
-(defn draw-tile [target tileset tile-id x y]
+(defn draw-tile [target tileset tile-id #* args #** kwargs]
   (let [tile (get tileset.tiles tile-id)
-        sprite (MiniSprite tile tileset.tile-w x y)]
-    (.blit target sprite.surf sprite.rect)))
+        sprite (MiniSprite tile tileset.tile-w #* args #** kwargs)]
+    (.blit target sprite.surf sprite.rect)
+    sprite))