Stuff

1 files changed, 45 insertions, 46 deletions

diff --git a/entity.lua b/entity.lua
index dfad84f..945b787 100644
--- a/entity.lua
+++ b/entity.lua
@@ -1,21 +1,18 @@
 Entities = {
     Player = 0,
     Sword = 1,
-    Enemy = 2
+    Enemy = 2,
+    Bow = 3
 }
 States = {
     Walk = "walk",
-    Idle = "idle"
+    Idle = "idle",
+    Equipped = "equipped",
+    Slashing = "slashing",
+    Drawing = "drawing",
+    Drawn = "drawn"
 }
 
-
-_id = 0
-function _next_id()
-    i = _id
-    _id += 1
-    return i
-end
-
 Entity = {}
 Entity.__index = Entity
 function Entity:b_add_state(name, state)
@@ -27,6 +24,7 @@ end
 function Entity:b_state(name)
     assert(self.states[name] != nil)
     self.state = name
+    self.state_stopwatch = 0
     return self
 end
 function Entity:b_render_order(ord)
@@ -53,49 +51,47 @@ function Entity:b_collidable()
     self.collision = true
     return self
 end
+function Entity:b_line_of_sight(vec)
+    self.line_of_sight = vec2(vec)
+    return self
+end
+function Entity:build()
+    assert(self.transition_state)
+
+    assert(self.position)
+    assert(self.state)
+    assert(self.state_stopwatch)
+end
 
 function Entity:transition_to(state_name)
-    if self:transition(self.state, state_name) then
+    assert(self.states[state_name])
+    if self.state ~= state_name then
         self.state = state_name
         self.state_stopwatch = 0
     end
+    print(self.state)
     return self
 end
 
-function Entity:transition(from, to)
-    if from == States.Walk and to == States.Idle or to == States.Idle and from == States.Walk then
-        return true
-    end
-    return false
-end
-
 function Entity:update(dt)
-    if self.state_stopwatch == nil then
-        self.state_stopwatch = 0
-    end
-    self.state_stopwatch += dt
     self:integrate(dt)
 
-    self:update_sprite_position()
     self:update_line_of_sight()
 
-    if (self.velocity.x == 0 and self.velocity.x == self.velocity.y) then
-        self:transition_to(States.Idle)
-    else
-        self:transition_to(States.Walk)
-    end
-
+    self:update_sprite_position()
     if (self.equipped != nil) then
         parent = self
         foreach(self.equipped, function (e) e:equipped_from(parent) end)
     end
+
+    assert(self.transition_state)
+    self:transition_state()
 end
 
 function Entity:update_line_of_sight()
     nv = self.velocity:apply(normalize_scalar)
     if nv.y != 0 then self.line_of_sight = vec2(0, nv.y)
-    elseif nv.x != 0 then self.line_of_sight = vec2(nv.x, 0) 
-    else self.line_of_sight = vec2(0, 0) end
+    elseif nv.x != 0 then self.line_of_sight = vec2(nv.x, 0) end
 end
 
 -- prevent cobblestoning during non-manhattan movement by "lagging" the sprite
@@ -144,29 +140,24 @@ function Entity:update_sprite_position()
 end
 
 function Entity:integrate(dt)
+    self.state_stopwatch += dt
     if (self.velocity != nil) then
         self.position = self.position + (self.velocity * dt)
     end
 end
 
-_equip_distance = 6
+_equipped_item_distance = 6
 function Entity:equipped_from(parent)
     self.line_of_sight = vec2(parent.line_of_sight)
 
-    offset = (parent.line_of_sight * _equip_distance)
+    offset = (parent.line_of_sight * _equipped_item_distance)
 
     self.position = parent.position + offset
     self.sprite_position = parent.sprite_position + offset
 end
 
-function _get_frame(anim, t)
-    len = #anim.seq
-    frames_passed = (t / anim.dt)
-    idx = flr(1 + (frames_passed % len))
-    return anim.seq[idx]
-end
-
-_animation_keys = {"neg", "", "pos"}
+--                  -1      0      1
+_animation_keys = {"neg", "pos", "pos"}
 function _get_animation_key(line_of_sight)
     n_line_of_sight = line_of_sight:apply(normalize_scalar)
     if n_line_of_sight.y ~= 0 then
@@ -182,24 +173,32 @@ function Entity:render()
     if (animation == nil) then return end
     key = _get_animation_key(self.line_of_sight)
     animation = animation[key] or animation
-    assert(animation[key])
+    assert(animation)
+
+    frames_passed = flr(self.state_stopwatch / animation.dt)
+    frame = animation.sequence[1 + (frames_passed % (#animation.sequence))]
+    assert(frame)
 
-    frame = _get_frame(animation.sequence, self.state_t)
-    reflection = animation.reflection or vec2(false, false)
+    reflection = animation.reflect or vec2(false, false)
     spr(
         frame,
-        entity.sprite_position.x, entity.sprite_position.y,
+        self.sprite_position.x, self.sprite_position.y,
         1, 1,
         reflection.x, reflection.y
     )
 end
 
+_id = 1
+function _next_id()
+    i = _id
+    _id += 1
+    return i
+end
 function entity()
     id = _next_id()
     World.add(setmetatable(
         {
             id = id,
-            position = vec2(0,0),
             velocity = vec2(0,0),
             collision = false
         }, Entity