Finish level loading, change a lot of small things, make the camera move

assets/levels/level1.json

@@ -10,7 +10,7 @@
         {
             "type": "swarm",
             "pos": [ 40.0, 40.0 ],
-            "num": 30
+            "population": 30
         },
 
         {

source/alone.ooc

@@ -28,6 +28,7 @@ main: func {
 
     level: Level
     level = loader load("assets/levels/level1.json")
+    ui level = level
 
     level start()
 }

source/game/Baddie.ooc

@@ -15,9 +15,6 @@ Baddie: class extends Actor {
 
     ui: MainUI
 
-    touchesGround := false
-    groundHeight := 0.0
-
     hero: Hero
 
     mainSprite: EllipseSprite
@@ -39,7 +36,8 @@ Baddie: class extends Actor {
 
     state := BaddieState CMON
 
-    init: func (=level, =groundHeight, =hero) {
+    init: func (=level) {
+        hero = level hero
         ui = level engine ui
 
         body = Body new(level)
@@ -49,14 +47,14 @@ Baddie: class extends Actor {
         bb filled = false
         bb size = vec2(10, 10)
         bb color = vec3(0.3, 0.3, Random randInt(0, 255) / 255.0)
-        ui sprites add(bb)
+        level sprites add(bb)
 
         mainSprite = EllipseSprite new(body pos)
         mainSprite size = vec2(15, 15)
         mainSprite color = vec3(0.4, 0.4, Random randInt(0, 255) / 255.0)
         mainSprite alpha = 0.4
-        ui sprites add(bb)
-        ui sprites add(mainSprite)
+        level sprites add(bb)
+        level sprites add(mainSprite)
 
         box = Box new(bb)
         level collideables add(box)
@@ -85,7 +83,7 @@ Baddie: class extends Actor {
             state = BaddieState WTF
         }
 
-        body speed interpolate(motion normalized() mul(speed), alpha)
+        body speed interpolate!(motion normalized() mul(speed), alpha)
         body update(delta)
     }
 

source/game/Hero.ooc

@@ -11,11 +11,12 @@ import deadlogger/Log
 
 Hero: class extends Actor {
 
-    ui: MainUI
     logger := static Log getLogger(This name)
     mainSprite : Sprite
     reflectionSprite : Sprite
 
+    ui: MainUI
+
     groundHeight := 0.0
     touchesGround := false
     jumpSpeed := 30.0
@@ -32,39 +33,38 @@ Hero: class extends Actor {
 
     init: func (=level, =groundHeight) {
         ui = level engine ui
-
         body = Body new(level)
-        body pos = vec2(100, ui height - 300)
-
 
         bb = RectSprite new(body pos)
         bb filled = false
         bb size = vec2(60, 100)
-        ui debugSprites add(bb)
+        level debugSprites add(bb)
 
         hb = RectSprite new(body pos)
         hb filled = false
         hb size = vec2(40, 60)
         hb color = vec3(0.0, 1.0, 0.0)
-        ui debugSprites add(hb)
+        level debugSprites add(hb)
 
         mainSprite = SvgSprite new(body pos, "assets/svg/movingObj_Full.svg")
         mainSprite scale = vec2(scale, scale)
         mainSprite offset x = - bb size x / 2
         mainSprite offset y = - bb size y / 2 - 20
-        ui sprites add(mainSprite)
+        level sprites add(mainSprite)
     }
 
     update: func (delta: Float) {
+        // logger info("Position = %s" format(body pos _)) 
+
         if (ui isPressed(Keys LEFT)) {
-            body speed interpolateX(-speed, speedAlpha)
+            body speed interpolateX!(-speed, speedAlpha)
             direction = -1.0
         } else if (ui isPressed(Keys RIGHT)) {
-            body speed interpolateX(speed, speedAlpha)
+            body speed interpolateX!(speed, speedAlpha)
             mainSprite scale = vec2(-scale, scale)
             direction = 1.0
         } else {
-            body speed interpolateX(0, speedAlpha)
+            body speed interpolateX!(0, speedAlpha)
         }
 
         if (touchesGround && ui isPressed(Keys SPACE)) {
@@ -73,9 +73,10 @@ Hero: class extends Actor {
 
         body update(delta)
 
+        minAlpha := 0.2
         alphaAlpha := 0.1
         mainSprite alpha = mainSprite alpha * (1 - alphaAlpha) +
-                        (body speed norm() / 18.0 + 0.1) * alphaAlpha
+                        (body speed norm() / 18.0 + minAlpha) * alphaAlpha
         if (mainSprite alpha > 1.0) {
             mainSprite alpha = 1.0
         }
@@ -92,6 +93,7 @@ Hero: class extends Actor {
             touchesGround = false
         }
 
+        mainSprite pos = body pos
         mainSprite       offset x = direction * bb size x / 2
         mainSprite       scale x = - direction * scale
     }

source/game/Level.ooc

@@ -25,26 +25,17 @@ Level: class {
     name := "<untitled>"
     author := "<unknown>"
 
-    init: func (=engine) {
-        logger debug("Loading level...")
-
-        // add a bunch of stuff
-        bg := PngSprite new(vec2(0, 0), "assets/png/egypt.png")
-        // bg offset x = - bg width  / 2.0
-        // bg offset y = - bg height / 2.0
-        engine ui bgSprites add(bg)
+    // different passes
+    bgSprites := ArrayList<Sprite> new()
+    sprites := ArrayList<Sprite> new()
+    fgSprites := ArrayList<Sprite> new()
+    debugSprites := ArrayList<Sprite> new()
 
-        ground := Ground new(this)
-        actors add(ground)
+    hero: Hero
 
-        hero := Hero new(this, ground y)
+    init: func (=engine) {
+        hero = Hero new(this, engine ui height - 40)
         actors add(hero)
-
-        25 times(||
-            baddie := Baddie new(this, ground y, hero)
-            baddie body pos x = Random randInt(0, engine ui width)
-            actors add(baddie)
-        )
     }
 
     update: func (delta: Float) {
@@ -92,24 +83,6 @@ Actor: class {
 
 }
 
-Ground: class extends Actor {
-
-    y: Float
-
-    init: func (=level) {
-        engine := level engine
-
-        ground := RectSprite new(vec2(engine ui width * 0.5, engine ui height * 0.75))
-        ground size = vec2(engine ui width, engine ui height * 0.5)
-        ground color = vec3(0.0, 0.0, 0.0)
-        ground alpha = 0.9
-        engine ui fgSprites add(ground)
-
-        y = engine ui height / 2
-    }
-
-}
-
 Bang: class {
 
     pos := vec2(0, 0)

source/game/LevelLoader.ooc

@@ -11,34 +11,55 @@ import math/[Vec2, Vec3, Random]
 // libs deps
 import structs/[ArrayList, HashBag, Bag]
 import deadlogger/Log
-import text/json
+import text/json, text/json/Parser
 import io/FileReader
 
 LevelLoader: class {
 
-    logger := static Log getLogger("LevelLoader")
+    logger := static Log getLogger(This name)
     engine: Engine
 
     init: func (=engine)
 
     load: func (path: String) -> Level {
         logger debug("Loading json %s!" format(path))
         json := JSON parse(FileReader new(path), HashBag)
+
         level := Level new(engine)
         level name   = json get("name",   String)
         level author = json get("author", String)
 
         logger debug("Level '%s', by '%s'" format(level name, level author))
 
-
         objects := json get("objects", Bag)
         for(i in 0..objects size) {
             object := objects get(i, HashBag)
             type := object get("type", String)
             logger debug("Got an object of type '%s'" format(type))
+
+            match type {
+                case "background" =>
+                    bg := PngSprite new(vec2(0, 0), object get("path", String))
+                    level bgSprites add(bg)
+                case "hero" =>
+                    level hero body pos = readVec2(object, "pos")
+                    logger info("Hero starting at position %s" format(level hero body pos _))
+                case "swarm" =>
+                    object get("population", Int) times(||
+                        baddie := Baddie new(level)
+                        level actors add(baddie)
+                    )
+            }
         }
 
         level
     }
 
+    readVec2: func (hb: HashBag, key: String) -> Vec2 {
+        bag := hb get(key, Bag)
+        x := bag get(0, Number) value toFloat()
+        y := bag get(1, Number) value toFloat()
+        vec2(x, y)
+    }
+
 }

source/math/Vec2.ooc

@@ -34,16 +34,20 @@ Vec2: class {
         new(x - v x, y - v y)
     }
 
-    interpolate: func (target: This, alpha: Float) {
+    add: func (v: Vec2) -> This {
+        new(x + v x, y + v y)
+    }
+
+    interpolate!: func (target: This, alpha: Float) {
         (x, y) = (x * (1 - alpha) + target x * alpha,
                   y * (1 - alpha) + target y * alpha)
     }
 
-    interpolateX: func (target: Float, alpha: Float) {
+    interpolateX!: func (target: Float, alpha: Float) {
         x = x * (1 - alpha) + target * alpha
     }
 
-    interpolateY: func (target: Float, alpha: Float) {
+    isubnterpolateY!: func (target: Float, alpha: Float) {
         y = y * (1 - alpha) + target * alpha
     }
     toString: func -> String {

source/ui/MainUI.ooc

@@ -1,9 +1,12 @@
-use cairo, gtk
+use cairo, gtk, deadlogger
 
 // game deps
 import Sprite
+import game/[Level, Hero]
+import math/[Vec2, Vec3]
 
 // libs deps
+import deadlogger/Log
 import cairo/[Cairo, GdkCairo] 
 import gtk/[Gtk, Widget, Window]
 import gdk/[Event]
@@ -22,15 +25,16 @@ MainUI: class {
 
     width, height: Int
 
-    // different passes
-    bgSprites := ArrayList<Sprite> new()
-    sprites := ArrayList<Sprite> new()
-    fgSprites := ArrayList<Sprite> new()
-    debugSprites := ArrayList<Sprite> new()
-
     MAX_KEY := static 65536
     keyState: Bool*
 
+    logger := static Log getLogger(This name)
+
+    level: Level // current level being drawn
+
+    scale := 1.0
+    campos := vec2(0.0, 0.0)
+
     init: func (config: ZombieConfig) {
         keyState = gc_malloc(Bool size * MAX_KEY)
         win = Window new(config["title"])
@@ -92,14 +96,36 @@ MainUI: class {
     }
 
     paint: func (cr: Context) {
-        background(cr)
+        camposTarget := level hero body pos sub(vec2(width / 2, height / 2))
+        campos interpolate!(camposTarget, 0.2)
+        cr translate (-campos x, -campos y)
+
+        cr translate (  width / 2,   height / 2)
+        cr scale(scale, scale)
+        alphaScale := 0.05
+        if(level hero body speed norm() < 3.0) {
+            if (scale < 1.5) {
+                scale = scale * (1 - alphaScale) + (scale + 0.1) * alphaScale
+            }
+        } else {
+            if (scale > 0.9) {
+                scale = scale * (1 - alphaScale) + (scale - 0.1) * alphaScale
+            }
+        }
+        cr translate (- width / 2, - height / 2)
 
-        bgSprites each(|sprite| sprite draw(cr))
-        sprites each(|sprite| sprite draw(cr))
-        fgSprites each(|sprite| sprite draw(cr))
+        background(cr)
 
-        if(debug) {
-            debugSprites each(|sprite| sprite draw(cr))
+        // draw level
+        if (level) {
+            level bgSprites each(|sprite| sprite draw(cr))
+            level sprites each(|sprite| sprite draw(cr))
+            level fgSprites each(|sprite| sprite draw(cr))
+            if(debug) {
+                level debugSprites each(|sprite| sprite draw(cr))
+            }
+        } else {
+            logger error("No level set!")
         }
 
     }

source/ui/Sprite.ooc

@@ -18,9 +18,7 @@ Sprite: class {
     color := vec3(1.0, 0.0, 0.0)
     alpha := 1.0
 
-    init: func (=pos) {
-        logger debug("Created %s at %s" format(class name, pos _))
-    }
+    init: func (=pos)
 
     /*
      * This is where you have to draw the line between