SNKRX/shared.lua

-- Shared functions and classes for projects using JUGGLRX's visual style.
function shared_init()
  local colors = {
    white = ColorRamp(Color(1, 1, 1, 1), 0.025),
    black = ColorRamp(Color(0, 0, 0, 1), 0.025),
    bg = ColorRamp(Color'#303030', 0.025),
    fg = ColorRamp(Color'#dadada', 0.025),
    fg_alt = ColorRamp(Color'#b0a89f', 0.025),
    yellow = ColorRamp(Color'#facf00', 0.025),
    orange = ColorRamp(Color'#f07021', 0.025),
    blue = ColorRamp(Color'#019bd6', 0.025),
    green = ColorRamp(Color'#8bbf40', 0.025),
    red = ColorRamp(Color'#e91d39', 0.025),
    purple = ColorRamp(Color'#8e559e', 0.025),
  }
  for name, color in pairs(colors) do _G[name] = color end
  modal_transparent = Color(0.1, 0.1, 0.1, 0.5)
  fg_transparent = Color(fg[0].r, fg[0].g, fg[0].b, 0.5)

  graphics.set_background_color(bg[0])
  graphics.set_color(fg[0])
  slow_amount = 1

  sfx = SoundTag()
  sfx.volume = 0.5
  music = SoundTag()
  music.volume = 0.5

  fat_font = Font('FatPixelFont', 8)
  pixul_font = Font('PixulBrush', 8)
  main_canvas = Canvas(gw, gh, {stencil = true})
  shadow_canvas = Canvas(gw, gh)
  shadow_shader = Shader(nil, 'shadow.frag')
end


function shared_draw(draw_action)
  main_canvas:draw_to(function()
    draw_action()
    if flashing then graphics.rectangle(gw/2, gh/2, gw, gh, nil, nil, flash_color) end
  end)

  shadow_canvas:draw_to(function()
    graphics.set_color(white[0])
    shadow_shader:set()
    main_canvas:draw2(0, 0, 0, 1, 1)
    shadow_shader:unset()
  end)

  shadow_canvas:draw(6, 6, 0, sx, sy)
  main_canvas:draw(0, 0, 0, sx, sy)
end




SpawnEffect = Object:extend()
SpawnEffect:implement(GameObject)
function SpawnEffect:init(args)
  self:init_game_object(args)
  self.target_color = self.color or red[0]
  self.color = fg[0]
  self.rs = 0
  self.t:tween(0.1, self, {rs = 6}, math.cubic_in_out, function()
    if self.action then self.action(self.x, self.y) end
    self.spring:pull(1)
    for i = 1, random:int(6, 8) do HitParticle{group = main.current.effects, self.x, self.y, color = self.target_color, duration = random:float(0.3, 0.5), w = random:float(5, 8), v = random:float(150, 200)} end
    self.t:tween(0.25, self, {rs = 0}, math.linear, function() self.dead = true end)
    self.t:after(0.15, function() self.color = self.target_color end)
  end)
end


function SpawnEffect:update(dt)
  self:update_game_object(dt)
end


function SpawnEffect:draw()
  graphics.circle(self.x, self.y, random:float(0.9, 1.1)*self.rs*self.spring.x, self.color)
end



-- Mixin to be added to a state so it can have nodemap creation, saving and manipulating capabilities.
Nodemap = Object:extend()
-- nodemap is a table that contains the definition of the skill tree or overmap.
-- Each node in it should have the following attributes defined:
-- .x, .y, .neighbors or .links. Optionally: .rs, .color, .visited, .can_be_visited, .on_visit, .on_draw, .data
-- An example would look like this:
-- nodemap = {
--  [1] = {x = x, y = y, visited = true, links = {2, 3, 4, 5}}
--  [2] = {x = x, y = y - 64, links = {1}}
--  [3] = {x = x + 64, y = y, links = {1}}
--  [4] = {x = x, y = y + 64, links = {1}}
--  [5] = {x = x - 64, y = y, links = {1}}
-- }
-- .data can be a table that contains other attributes. These will be automatically added to the Node object when it's created.
-- .on_visit should be defined if you want the button to do something when it's clicked. Example:
--  [2] = {x = x, y = y - 64, links = {1}, on_visit = function(visited_node) state.goto'level_2' end}
-- .on_draw should be used when you want to draw the node in some specific way rather than the default one.
-- color_mode can be nil or 'skill_tree', if it's the latter then nodes and edges will change colors according to if they were a part of a skill tree:
-- Unvisitable nodes are gray, visitable nodes are white, visited nodes are their default color
-- This is opposed to the default color mode, where all nodes and edges have their their default colors, and when they're visited they turn gray instead.
function Nodemap:generate_nodemap(group, nodemap, color_mode)
  for id, node in pairs(nodemap) do
    Node{group = group, x = node.x, y = node.y, node_id = id, neighbors = node.links, rs = node.rs, visited = node.visited, can_be_visited = node.can_be_visited, color = node.color, label = node.label, data = node.data,
    on_visit = node.on_visit, on_draw = node.on_draw, color_mode = color_mode}
  end

  for id, node in pairs(nodemap) do
    for _, node_id in ipairs(node.links) do
      if nodemap[node_id] then
        Edge{group = group, x = 0, y = 0, node1_id = id, node2_id = node_id, color_mode = color_mode}
      end
    end
  end
end


Node = Object:extend()
Node:implement(GameObject)
function Node:init(args)
  self:init_game_object(args)
  for k, v in pairs(self.data) do self[k] = v end
  self.data = nil
  self.rs = self.rs or 6
  self.shape = Circle(self.x, self.y, 1.5*self.rs)
  self.interact_with_mouse = true

  self.src_color = self.color
  if self.color_mode == 'skill_tree' then
    self.color = bg[5]
    if self.visited then self.color = fg[0] end
  end

  self.t:every_immediate(1.4, function()
    if self.can_be_visited then
      self.t:tween(0.7, self, {sx = 0.9, sy = 0.9}, math.linear, function()
        self.t:tween(0.7, self, {sx = 1.1, sy = 1.1}, math.linear, nil, 'visit_pulse_1')
      end, 'visit_pulse_2')
    end
  end, nil, nil, 'visit_pulse')

  if self.label then self.label_r = 0 end
  self.t:after(0.01, function()
    if self.label then
      local xs, ys = 0, 0
      for _, neighbor_id in ipairs(self.neighbors) do
        local neighbor = self.group:get_object_by_property('node_id', neighbor_id)
        local r = math.angle(self.x, self.y, neighbor.x, neighbor.y)
        x, y = math.cos(r), math.sin(r)
        xs = xs + x
        ys = ys + y
      end
      self.label_r = Vector(-xs, -ys):angle()
      self.label_color = self.color
    end

    self.edges = {}
    for _, neighbor_id in ipairs(self.neighbors) do
      local edge = nil
      edge = self.group:get_object_by_properties({'node1_id', 'node2_id'}, {self.node_id, neighbor_id})
      if not edge then edge = self.group:get_object_by_properties({'node1_id', 'node2_id'}, {neighbor_id, self.node_id}) end
      if edge then table.insert(self.edges, edge) end
    end
  end)
end


function Node:update(dt)
  self:update_game_object(dt)

  if not self.visited then
    for _, neighbor_id in ipairs(self.neighbors) do
      local neighbor = self.group:get_object_by_property('node_id', neighbor_id)
      if neighbor and neighbor.visited then
        self.can_be_visited = true
      end
    end
  end

  if self.color_mode == 'skill_tree' then
    if self.can_be_visited then
      self.color = bg[10]
      if self.label then self.label_color = bg[10] end
      if self.hot then
        self.color = fg[0]
        if self.label then self.label_color = fg[0] end
      end
    end
  end

  if self.hot and self.can_be_visited and not self.visited and input.m1.pressed then
    self.t:cancel'visit_pulse'
    self.t:cancel'visit_pulse_1'
    self.t:cancel'visit_pulse_2'
    self.sx, self.sy = 1, 1
    self.spring:pull(0.25)
    self.can_be_visited = false
    self.visited = true
    self.hot = false
    if self.color_mode == 'skill_tree' then
      self.color = self.src_color
      if self.label then self.label_color = self.src_color end
    else
      self.color = bg[5]
      if self.label then self.label_color = bg[5] end
    end
    if self.label then self.label_color = self.color end
    if self.on_visit then self:on_visit() end
  end
end


function Node:draw()
  if self.on_draw then
    self:on_draw()
  else
    graphics.push(self.x, self.y, 0, self.spring.x*self.sx, self.spring.x*self.sy)
    if self.hot and self.can_be_visited then graphics.circle(self.x, self.y, 1.15*self.shape.rs, self.color)
    else graphics.circle(self.x, self.y, self.shape.rs, self.color, 3) end
    graphics.pop()
  end

  if self.label then
    local w = pixul_font:get_text_width(self.label)
    local s = math.remap(self.rs, 6, 12, 3.5, 2.5)
    graphics.print_centered(self.label, pixul_font, self.x + (w/6)*math.cos(self.label_r) + s*self.rs*math.cos(self.label_r), self.y + s*self.rs*math.sin(self.label_r), 0, self.spring.x*self.sx, self.spring.x*self.sy, nil, nil, self.label_color)
  end
end


function Node:on_mouse_enter()
  self.hot = true
  self.spring:pull(0.2, 200, 10)
  for _, edge in ipairs(self.edges) do edge.spring:pull(0.15, 200, 10) end
end


function Node:on_mouse_exit()
  self.hot = false
  self.spring:pull(0.05, 200, 10)
  for _, edge in ipairs(self.edges) do edge.spring:pull(0.05, 200, 10) end
end




Edge = Object:extend()
Edge:implement(GameObject)
function Edge:init(args)
  self:init_game_object(args)
  self.node1 = self.group:get_object_by_property('node_id', self.node1_id)
  self.node2 = self.group:get_object_by_property('node_id', self.node2_id)
  local r = math.angle(self.node1.x, self.node1.y, self.node2.x, self.node2.y)
  self.x1, self.y1 = self.node1.x + 2.75*self.node1.rs*math.cos(r), self.node1.y + 2.75*self.node1.rs*math.sin(r)
  self.x2, self.y2 = self.node2.x + 2.75*self.node2.rs*math.cos(r - math.pi), self.node2.y + 2.75*self.node2.rs*math.sin(r - math.pi)

  if self.color_mode == 'skill_tree' then self.color = bg[5]
  else self.color = fg[0] end
end


function Edge:update(dt)
  self:update_game_object(dt)

  if self.color_mode == 'skill' then
    self.color = bg[5]
    if (self.node1.visited and self.node2.can_be_visited) or (self.node2.visited and self.node1.can_be_visited) then self.color = bg[10] end
    if (self.node1.visited and self.node2.visited) or (self.node1.visited and self.node2.hot) or (self.node2.visited and self.node1.hot) then self.color = fg[0] end
  else
    if self.node1.visited and self.node2.visited then self.color = bg[5] end
  end

  --[[
  self.color = bg[5]
  if (self.node1.visited and self.node2.can_be_visited) or (self.node2.visited and self.node1.can_be_visited) then self.color = bg[10] end
  if (self.node1.visited and self.node2.visited) or (self.node1.visited and self.node2.hot) or (self.node2.visited and self.node1.hot) then self.color = fg[0] end
  ]]--
end


function Edge:draw()
  graphics.push((self.x1+self.x2)/2, (self.y1+self.y2)/2, 0, self.spring.x, self.spring.x)
  graphics.line(self.x1, self.y1, self.x2, self.y2, self.color, 4)
  graphics.circle(self.x1, self.y1, 2, self.color)
  graphics.circle(self.x2, self.y2, 2, self.color)
  graphics.pop()
end




SpawnEffect = Object:extend()
SpawnEffect:implement(GameObject)
function SpawnEffect:init(args)
  self:init_game_object(args)
  self.target_color = self.color or red[0]
  self.color = fg[0]
  self.rs = 0
  self.t:tween(0.1, self, {rs = 6}, math.cubic_in_out, function()
    if self.action then self.action(self.x, self.y) end
    self.spring:pull(1)
    for i = 1, random:int(6, 8) do HitParticle{group = main.current.effects, x = self.x, y = self.y, color = self.target_color, duration = random:float(0.3, 0.5), w = random:float(5, 8), v = random:float(150, 200)} end
    self.t:tween(0.25, self, {rs = 0}, math.linear, function() self.dead = true end)
    self.t:after(0.15, function() self.color = self.target_color end)
  end)
end


function SpawnEffect:update(dt)
  self:update_game_object(dt)
end


function SpawnEffect:draw()
  graphics.circle(self.x, self.y, random:float(0.9, 1.1)*self.rs*self.spring.x, self.color)
end




HoverCrosshair = Object:extend()
HoverCrosshair:implement(GameObject)
function HoverCrosshair:init(args)
  self:init_game_object(args)
  self.ox, self.oy = 0, 0
  self.sx, self.sy = 0, 0
  self.line_width = 2
  self.w, self.h = 10, 10
end


function HoverCrosshair:update(dt)
  self:update_game_object(dt)
  if self.animation then self.animation:update(dt) end
end


function HoverCrosshair:draw()
  graphics.push(self.x, self.y, 0, self.sx*self.spring.x, self.sy*self.spring.x)
  graphics.polyline(fg[0], self.line_width, self.x - self.ox, self.y - self.oy + 0.4*self.h, self.x - self.ox, self.y - self.oy, self.x - self.ox + 0.4*self.w, self.y - self.oy)
  graphics.polyline(fg[0], self.line_width, self.x - self.ox, self.y + self.oy - 0.4*self.h, self.x - self.ox, self.y + self.oy, self.x - self.ox + 0.4*self.w, self.y + self.oy)
  graphics.polyline(fg[0], self.line_width, self.x + self.ox - 0.4*self.w, self.y - self.oy, self.x + self.ox, self.y - self.oy, self.x + self.ox, self.y - self.oy + 0.4*self.h)
  graphics.polyline(fg[0], self.line_width, self.x + self.ox - 0.4*self.w, self.y + self.oy, self.x + self.ox, self.y + self.oy, self.x + self.ox, self.y + self.oy - 0.4*self.h)
  graphics.pop()
end


function HoverCrosshair:activate(x, y, w, h, line_width)
  w, h = 10, 10
  line_width = 2
  self.x, self.y = camera:get_local_coords(x, y)
  self.t:cancel'deactivate'
  self.t:tween(0.1, self, {sx = 1, sy = 1}, math.cubic_in_out, function() self.sx, self.sy = 1, 1 end, 'activate')
  if self.w <= 10 and self.h <= 10 then
    self.animation = AnimationLogic(0.075, 3, 'bounce', {
      function() self.ox, self.oy = 0.6*self.w, 0.6*self.h end,
      function() self.ox, self.oy = 0.8*self.w, 0.8*self.h end,
      function() self.ox, self.oy = self.w, self.h end,
    })
  else
    self.animation = AnimationLogic(0.075, 3, 'bounce', {
      function() self.ox, self.oy = 0.8*self.w, 0.8*self.h end,
      function() self.ox, self.oy = 0.9*self.w, 0.9*self.h end,
      function() self.ox, self.oy = self.w, self.h end,
    })
  end
end


function HoverCrosshair:deactivate()
  self.t:cancel'activate'
  self.t:tween(0.05, self, {sx = 0, sy = 0}, math.linear, function() self.sx, self.sy = 0, 0 end, 'deactivate')
end




TransitionEffect = Object:extend()
TransitionEffect:implement(GameObject)
function TransitionEffect:init(args)
  self:init_game_object(args)
  self.rs = 0
  self.text_sx, self.text_sy = 0, 0
  self.t:after(0.25, function()
    self.t:after(0.1, function()
      self.t:tween(0.1, self, {text_sx = 1, text_sy = 1}, math.cubic_in_out)
    end)
    self.t:tween(0.6, self, {rs = 1.2*gw}, math.linear, function()
      if self.transition_action then self:transition_action(unpack(self.transition_action_args or {})) end
      self.t:after(0.3, function()
        self.x, self.y = gw/2, gh/2
        self.t:after(0.6, function() self.t:tween(0.05, self, {text_sx = 0, text_sy = 0}, math.cubic_in_out) end)
        if not args.dont_tween_out then
          self.t:tween(0.6, self, {rs = 0}, math.linear, function() self.text = nil; self.dead = true end)
        else
          self.t:after(0.6, function() self.text = nil; self.dead = true end)
        end
      end)
    end)
  end)
end


function TransitionEffect:update(dt)
  self:update_game_object(dt)
  if self.text then self.text:update(dt) end
end


function TransitionEffect:draw()
  graphics.push(self.x, self.y, 0, self.sx, self.sy)
  graphics.circle(self.x, self.y, self.rs, self.color)
  graphics.pop()
  if self.text then self.text:draw(gw/2, gh/2, 0, self.text_sx, self.text_sy) end
end




local invisible = Color(1, 1, 1, 0)
global_text_tags = {
  red = TextTag{draw = function(c, i, text) graphics.set_color(red[0]) end},
  orange = TextTag{draw = function(c, i, text) graphics.set_color(orange[0]) end},
  yellow = TextTag{draw = function(c, i, text) graphics.set_color(yellow[0]) end},
  green = TextTag{draw = function(c, i, text) graphics.set_color(green[0]) end},
  purple = TextTag{draw = function(c, i, text) graphics.set_color(purple[0]) end},
  blue = TextTag{draw = function(c, i, text) graphics.set_color(blue[0]) end},
  bg = TextTag{draw = function(c, i, text) graphics.set_color(bg[0]) end},
  bg10 = TextTag{draw = function(c, i, text) graphics.set_color(bg[10]) end},
  light_bg = TextTag{draw = function(c, i, text) graphics.set_color(bg[5]) end},
  fg = TextTag{draw = function(c, i, text) graphics.set_color(fg[0]) end},
  fgm5 = TextTag{draw = function(c, i, text) graphics.set_color(fg[-5]) end},
  wavy = TextTag{update = function(c, dt, i, text) c.oy = 2*math.sin(4*time + i) end},
  wavy_mid = TextTag{update = function(c, dt, i, text) c.oy = 0.75*math.sin(3*time + i) end},
  wavy_mid2 = TextTag{update = function(c, dt, i, text) c.oy = 0.5*math.sin(3*time + i) end},
  wavy_lower = TextTag{update = function(c, dt, i, text) c.oy = 0.25*math.sin(2*time + i) end},

  cbyc = TextTag{init = function(c, i, text)
    c.color = invisible
    text.t:after((i-1)*0.15, function()
      c.color = red[0]
      camera:shake(3, 0.075)
      pop1:play{pitch = random:float(0.95, 1.05), volume = 0.35}
    end)
  end, draw = function(c, i, text)
    graphics.set_color(c.color)
  end},

  cbyc2 = TextTag{init = function(c, i, text)
    c.color = invisible
    text.t:after((i-1)*0.15, function()
      c.color = yellow[0]
      camera:shake(3, 0.075)
      pop1:play{pitch = random:float(0.95, 1.05), volume = 0.35}
    end)
  end, draw = function(c, i, text)
    graphics.set_color(c.color)
  end},

  nudge_down = TextTag{init = function(c, i, text)
    c.oy = -4
    text.t:tween(0.1, c, {oy = 0}, math.linear)
  end},
}




Text2 = Object:extend()
Text2:implement(GameObject)
function Text2:init(args)
  self:init_game_object(args)
  self.text = Text(args.lines, global_text_tags)
end


function Text2:update(dt)
  self:update_game_object(dt)
  self.text:update(dt)
end


function Text2:draw()
  self.text:draw(self.x, self.y, self.r, self.sx, self.sy)
end




InfoText = Object:extend()
InfoText:implement(GameObject)
function InfoText:init(args)
  self:init_game_object(args)
  self.sx, self.sy = 0, 0
  self.ox, self.oy = 0, 0
  self.ow, self.oh = 0, 0
  self.tox, self.toy = 0, 0
  self.text = Text({}, global_text_tags)
  return self
end


function InfoText:update(dt)
  self:update_game_object(dt)
end


function InfoText:draw()
  graphics.push(self.x + self.ox, self.y + self.oy, 0, self.sx*self.spring.x, self.sy*self.spring.x)
  graphics.rectangle(self.x + self.ox, self.y + self.oy, self.text.w + self.ow, self.text.h + self.oh, self.text.h/12, self.text.h/12, bg[-2])
  self.text:draw(self.x + self.ox + self.tox, self.y + self.oy + self.toy)
  graphics.pop()
end


function InfoText:activate(text, ox, oy, sx, sy, ow, oh, tox, toy)
  self.ox, self.oy = ox or 0, oy or 0
  self.sx, self.sy = sx or 1, sy or 1
  self.ow, self.oh = ow or 0, oh or 0
  self.tox, self.toy = tox or 0, toy or 0
  self.text:set_text(text)
  self.t:cancel'deactivate'
  self.t:tween(0.1, self, {sx = sx or 1, sy = sy or 1}, math.cubic_in_out, function() self.sx, self.sy = sx or 1, sy or 1 end, 'activate')
  self.spring:pull(0.075)
end


function InfoText:deactivate()
  self.t:cancel'activate'
  self.t:tween(0.05, self, {sy = 0}, math.linear, function() self.sy = 0; self.dead = true end, 'deactivate')
end




ColorRamp = Object:extend()
function ColorRamp:init(color, step)
  self.color = color
  self.step = step
  for i = -10, 10 do
    if i < 0 then
      self[i] = self.color:clone():lighten(i*self.step)
    elseif i > 0 then
      self[i] = self.color:clone():lighten(i*self.step)
    else
      self[i] = self.color:clone()
    end
  end
end




RefreshEffect = Object:extend()
RefreshEffect:implement(GameObject)
RefreshEffect:implement(Parent)
function RefreshEffect:init(args)
  self:init_game_object(args)
  self.oy = self.h/3
  self.t:tween(0.15, self, {h = 0}, math.linear, function() self.dead = true end)
end


function RefreshEffect:update(dt)
  self:update_game_object(dt)
  self:follow_parent_exclusively()
end


function RefreshEffect:draw()
  graphics.push(self.x, self.y, self.r)
  graphics.rectangle2(self.x - self.w/2, self.y - self.oy, self.w, self.h, nil, nil, fg[0])
  graphics.pop()
end




function flash(duration, color)
  flashing = true
  flash_color = color or fg[0]
  trigger:after(duration, function() flashing = false end, 'flash')
end


function slow(amount, duration, tween_method)
  amount = amount or 0.5
  duration = duration or 0.5
  tween_method = tween_method or math.cubic_in_out
  slow_amount = amount
  trigger:tween(duration, _G, {slow_amount = 1}, tween_method, function() slow_amount = 1 end, 'slow')
end




HitCircle = Object:extend()
HitCircle:implement(GameObject)
function HitCircle:init(args)
  self:init_game_object(args)
  self.rs = self.rs or 8
  self.duration = self.duration or 0.05
  self.color = self.color or fg[0]
  self.t:after(self.duration, function() self.dead = true end, 'die')
  return self
end


function HitCircle:update(dt)
  self:update_game_object(dt)
end


function HitCircle:draw()
  graphics.circle(self.x, self.y, self.rs, self.color)
end


function HitCircle:scale_down(duration)
  duration = duration or 0.2
  self.t:cancel'die'
  self.t:tween(self.duration, self, {rs = 0}, math.cubic_in_out, function() self.dead = true end)
  return self
end


function HitCircle:change_color(delay_multiplier, target_color)
  delay_multiplier = delay_multiplier or 0.5
  self.t:after(delay_multiplier*self.duration, function() self.color = target_color end)
  return self
end




HitParticle = Object:extend()
HitParticle:implement(GameObject)
function HitParticle:init(args)
  self:init_game_object(args)
  self.v = self.v or random:float(50, 150)
  self.r = args.r or random:float(0, 2*math.pi)
  self.duration = self.duration or random:float(0.2, 0.6)
  self.w = self.w or random:float(3.5, 7)
  self.h = self.h or self.w/2
  self.color = self.color or fg[0]
  self.t:tween(self.duration, self, {w = 2, h = 2, v = 0}, math.cubic_in_out, function() self.dead = true end)
end


function HitParticle:update(dt)
  self:update_game_object(dt)
  self.x = self.x + self.v*math.cos(self.r)*dt
  self.y = self.y + self.v*math.sin(self.r)*dt
end


function HitParticle:draw()
  graphics.push(self.x, self.y, self.r)
  graphics.rectangle(self.x, self.y, self.w, self.h, 2, 2, self.color)
  graphics.pop()
end


function HitParticle:change_color(delay_multiplier, target_color)
  delay_multiplier = delay_multiplier or 0.5
  self.t:after(delay_multiplier*self.duration, function() self.color = target_color end)
  return self
end




AnimationEffect = Object:extend()
AnimationEffect:implement(GameObject)
function AnimationEffect:init(args)
  self:init_game_object(args)
  self.animation = Animation(self.delay, self.frames, 'once', {[0] = function() self.dead = true end})
  self.color = self.color or fg[0]
end


function AnimationEffect:update(dt)
  self:update_game_object(dt)
  self.animation:update(dt)
  if self.linear_movement then
    self.x = self.x + self.v*math.cos(self.r)*dt
    self.y = self.y + self.v*math.sin(self.r)*dt
  end
end


function AnimationEffect:draw()
  self.animation:draw(self.x + (self.ox or 0), self.y + (self.ox or 0), self.r + (self.oa or 0), (self.flip_sx or 1)*self.sx, (self.flip_sy or 1)*self.sy, nil, nil, self.color)
end


function AnimationEffect:set_linear_movement(v, r)
  self.v = v
  self.r = r
  self.linear_movement = true
  local duration = self.animation.size*self.delay
  self.t:after(2*duration/3, function() self.t:tween(duration/3, self, {v = 0}, math.cubic_in_out) end)
end




Wall = Object:extend()
Wall:implement(GameObject)
Wall:implement(Physics)
function Wall:init(args)
  self:init_game_object(args)
  self:set_as_chain(true, self.vertices, 'static', 'solid')
  self.color = self.color or fg[0]
end


function Wall:update(dt)
  self:update_game_object(dt)
end


function Wall:draw()
  self.shape:draw(self.color)
end




WallCover = Object:extend()
WallCover:implement(GameObject)
function WallCover:init(args)
  self:init_game_object(args)
  self.shape = Polygon(self.vertices)
  self.color = self.color or fg[0]
end


function WallCover:update(dt)
  self:update_game_object(dt)
end


function WallCover:draw()
  self.shape:draw(self.color)
end