Clean up net data with cargo;

app/context/server.lua

@@ -14,7 +14,7 @@ function Server:load()
   for i = 1, 0 do
     local p = self.players.players[i]
     setmetatable(p, {__index = app.playerRobot})
-    self.net:emit(app.net.core.events.class, {id = i, class = 1, team = i % 2})
+    self.net:emit(app.net.events.class, {id = i, class = 1, team = i % 2})
   end
 
   self.event:on('game.quit', function()

app/logic/map.lua

@@ -114,7 +114,7 @@ function Map:init(name)
     end
   end
 
-  ctx.event:on(app.net.core.events.prop, function(data)
+  ctx.event:on(app.net.events.prop, function(data)
     local prop = self.props[data.id]
     prop.x, prop.y = data.x / 10, data.y / 10
   end)

app/logic/spell.lua

@@ -109,7 +109,7 @@ function Spell:damage(enemies, amount)
   amount = f.val(amount)
 
   table.each(enemies, function(enemy)
-    ctx.net:emit(app.net.core.events.damage, {id = enemy.id, from = self.owner.id, amount = amount(enemy), tick = tick})
+    ctx.net:emit(app.net.events.damage, {id = enemy.id, from = self.owner.id, amount = amount(enemy), tick = tick})
   end)
 end
 

app/net/client.lua

@@ -1,27 +1,16 @@
 local NetClient = extend(app.net.core)
 
-NetClient.signatures = {}
-NetClient.signatures[app.net.core.messages.join] = {{'username', 'string'}, important = true}
-NetClient.signatures[app.net.core.messages.leave] = {important = true}
-NetClient.signatures[app.net.core.messages.class] = {{'class', '4bits'}, {'team', '1bit'}, important = true}
-NetClient.signatures[app.net.core.messages.input] = {
-  {'tick', '16bits'},
-  {'w', 'bool'}, {'a', 'bool'}, {'s', 'bool'}, {'d', 'bool'},
-  {'x', '12bits'}, {'y', '12bits'}, {'l', 'bool'}, {'r', 'bool'},
-  {'slot', '3bits'}, {'reload', 'bool'},
-  delta = {{'w', 'a', 's', 'd'}, {'x', 'y'}, 'l', 'r', 'slot', 'reload'}
-}
-NetClient.signatures[app.net.core.messages.chat] = {{'message', 'string'}, important = true}
+NetClient.signatures = app.net.signatures.client
 
 NetClient.receive = {}
 NetClient.receive['default'] = function(self, event) ctx.event:emit(event.msg, event.data) end
 
-NetClient.receive[app.net.core.messages.join] = function(self, event)
+NetClient.receive[app.net.messages.join] = function(self, event)
   ctx.id = event.data.id
   setmetatable(ctx.players:get(ctx.id), {__index = app.player.main})
 end
 
-NetClient.receive[app.net.core.messages.snapshot] = function(self, event)
+NetClient.receive[app.net.messages.snapshot] = function(self, event)
   ctx.tick = event.data.tick + math.floor(((event.peer:round_trip_time() / 2) / 1000) / tickRate)
   if env ~= 'release' then ctx.tick = event.data.tick end
   --ctx.map:load(event.data.map)
@@ -40,11 +29,11 @@ function NetClient:init()
   self:connectTo(serverIp, 6061)
   self.messageBuffer = {}
 
-  ctx.event:on(app.net.core.events.join, function(data)
+  ctx.event:on(app.net.events.join, function(data)
     ctx.players:get(data.id).username = data.username
   end)
 
-  ctx.event:on(app.net.core.events.sync, function(data)
+  ctx.event:on(app.net.events.sync, function(data)
     local p = ctx.players:get(data.id)
     if p and p.active then
       p:trace(data)
@@ -59,14 +48,14 @@ function NetClient:init()
 end
 
 function NetClient:quit()
-  self:send(app.net.core.messages.leave)
+  self:send(app.net.messages.leave)
   self.host:flush()
   self.server:disconnect()
 end
 
 function NetClient:connect(event)
   self.server = event.peer
-  self:send(app.net.core.messages.join, {username = username})
+  self:send(app.net.messages.join, {username = username})
   event.peer:ping_interval(100)
   event.peer:ping()
 end
@@ -81,8 +70,9 @@ function NetClient:send(msg, data)
   self.outStream:clear()
   self:pack(msg, data)
 
-  local channel = self.signatures[msg].important and 0 or 1
-  local reliability = self.signatures[msg].important and 'reliable' or 'unreliable'
+  local important = self.signatures[msg].important
+  local channel = important and 0 or 1
+  local reliability = important and 'reliable' or 'unreliable'
   self.server:send(tostring(self.outStream), channel, reliability)
 end
 

app/net/core.lua

@@ -1,27 +1,5 @@
 local Net = class()
 
-Net.events = {
-  join = 1,
-  leave = 2,
-  class = 3,
-  sync = 4,
-  fire = 5,
-  damage = 6,
-  dead = 7,
-  spawn = 8,
-  chat = 9,
-  prop = 10
-}
-
-Net.messages = {
-  join  = 11,
-  leave = 12,
-  snapshot = 13,
-  class = 14,
-  input = 15,
-  chat = 16
-}
-
 function Net:init()
   self.inStream = app.net.stream()
   self.outStream = app.net.stream()

app/net/events.lua

@@ -0,0 +1,12 @@
+return {
+  join = 1,
+  leave = 2,
+  class = 3,
+  sync = 4,
+  fire = 5,
+  damage = 6,
+  dead = 7,
+  spawn = 8,
+  chat = 9,
+  prop = 10
+}

app/net/messages.lua

@@ -0,0 +1,8 @@
+return {
+  join  = 11,
+  leave = 12,
+  snapshot = 13,
+  class = 14,
+  input = 15,
+  chat = 16
+}

app/net/server.lua

@@ -1,59 +1,30 @@
 local NetServer = extend(app.net.core)
 
-NetServer.signatures = {}
-NetServer.signatures[app.net.core.events.join] = {{'id', '4bits'}, {'username', 'string'}, important = true}
-NetServer.signatures[app.net.core.events.leave] = {{'id', '4bits'}, {'reason', 'string'}, important = true}
-NetServer.signatures[app.net.core.events.class] = {{'id', '4bits'}, {'class', '4bits'}, {'team', '1bit'}, important = true}
-NetServer.signatures[app.net.core.events.sync] = {
-  {'id', '4bits'},
-  {'tick', '16bits'},
-  {'ack', '16bits'},
-  {'x', '16bits'}, {'y', '16bits'}, {'z', '8bits'},
-  {'angle', '10bits'},
-  {'health', '10bits'}, {'shield', '10bits'},
-  {'weapon', '3bits'}, {'skill', '3bits'},
-  delta = {'x', 'y', 'z', 'angle', 'health', 'shield', 'weapon', 'skill'}
-}
-NetServer.signatures[app.net.core.events.fire] = {
-  {'id', '4bits'}, {'slot', '3bits'}, {'mx', '12bits'}, {'my', '12bits'},
-  delta = {{'mx', 'my'}}
-}
-NetServer.signatures[app.net.core.events.damage] = {{'id', '4bits'}, {'amount', 'string'}, {'from', '4bits'}}
-NetServer.signatures[app.net.core.events.dead] = {{'id', '4bits'}, {'kill', '4bits'}, {'assists', {{'id', '4bits'}}}, important = true}
-NetServer.signatures[app.net.core.events.spawn] = {{'id', '4bits'}, important = true}
-NetServer.signatures[app.net.core.events.chat] = {{'message', 'string'}, important = true}
-NetServer.signatures[app.net.core.events.prop] = {{'id', '16bits'}, {'x', '16bits'}, {'y', '16bits'}}
-NetServer.signatures[app.net.core.messages.join] = {{'id', '4bits'}, important = true}
-NetServer.signatures[app.net.core.messages.snapshot] = {
-  {'tick', '16bits'},
-  {'map', 'string'},
-  {'players', {{'id', '4bits'}, {'username', 'string'}, {'class', '4bits'}, {'team', '1bit'}}},
-  important = true
-}
+NetServer.signatures = app.net.signatures.server
 
 NetServer.receive = {}
 NetServer.receive['default'] = f.empty
 
-NetServer.receive[app.net.core.messages.join] = function(self, event)
+NetServer.receive[app.net.messages.join] = function(self, event)
   local pid = self.peerToPlayer[event.peer]
   ctx.players:get(pid).username = event.data.username
-  self:send(app.net.core.messages.join, event.peer, {id = pid})
-  self:emit(app.net.core.events.join, {id = pid, username = event.data.username})
-  self:emit(app.net.core.events.chat, {message = '{white}' .. event.data.username .. ' has joined!'})
+  self:send(app.net.messages.join, event.peer, {id = pid})
+  self:emit(app.net.events.join, {id = pid, username = event.data.username})
+  self:emit(app.net.events.chat, {message = '{white}' .. event.data.username .. ' has joined!'})
   self:snapshot(event.peer)
 end
 
-NetServer.receive[app.net.core.messages.leave] = function(self, event) self:disconnect(event) end
+NetServer.receive[app.net.messages.leave] = function(self, event) self:disconnect(event) end
 
-NetServer.receive[app.net.core.messages.class] = function(self, event)
-  self:emit(app.net.core.events.class, {id = self.peerToPlayer[event.peer], class = event.data.class, team = event.data.team})
+NetServer.receive[app.net.messages.class] = function(self, event)
+  self:emit(app.net.events.class, {id = self.peerToPlayer[event.peer], class = event.data.class, team = event.data.team})
 end
 
-NetServer.receive[app.net.core.messages.input] = function(self, event)
+NetServer.receive[app.net.messages.input] = function(self, event)
   ctx.players:get(self.peerToPlayer[event.peer]):trace(event.data, event.peer:round_trip_time())
 end
 
-NetServer.receive[app.net.core.messages.chat] = function(self, event)
+NetServer.receive[app.net.messages.chat] = function(self, event)
   local pid = self.peerToPlayer[event.peer]
   local username = ctx.players:get(pid).username
   local color = ctx.players:get(pid).team == 0 and 'purple' or 'orange'
@@ -63,7 +34,7 @@ NetServer.receive[app.net.core.messages.chat] = function(self, event)
     for word in string.gmatch(message, '([^ ]+)') do
       table.insert(data, word)
     end
-    local function reply(message) self:send(app.net.core.events.chat, event.peer, {message = '{red}' .. message}) end
+    local function reply(message) self:send(app.net.events.chat, event.peer, {message = '{red}' .. message}) end
     local handlers = {
       ['/restart'] = function(data)
         if username ~= ctx.owner then return reply('permission denied') end
@@ -79,25 +50,25 @@ NetServer.receive[app.net.core.messages.chat] = function(self, event)
         for i = 1, ctx.players.max do
           if ctx.players:get(i).username == data[2] then player = i break end
         end
-        if not player then return self:send(app.net.core.events.chat, event.peer, {message = '{red}couldn\'t find player "' .. data[2] .. '"'}) end
+        if not player then return self:send(app.net.events.chat, event.peer, {message = '{red}couldn\'t find player "' .. data[2] .. '"'}) end
         for i = 1, ctx.players.max do
           local p = self.host:get_peer(i)
           if self.peerToPlayer[p] == player then peer = p break end
         end
-        if not peer then return self:send(app.net.core.events.chat, event.peer, {message = '{red}"' .. data[2] .. '" doesn\'t seem to be connected'}) end
+        if not peer then return self:send(app.net.events.chat, event.peer, {message = '{red}"' .. data[2] .. '" doesn\'t seem to be connected'}) end
         self:disconnect({peer = peer, reason = 'kicked'})
       end,
 
       ['/roll'] = function(data)
-        self:emit(app.net.core.events.chat, {message = '{red}' .. username .. ' rolled {green}' .. love.math.random(1, 100)})
+        self:emit(app.net.events.chat, {message = '{red}' .. username .. ' rolled {green}' .. love.math.random(1, 100)})
       end,
 
       ['/bjorn'] = function(data)
-        self:emit(app.net.core.events.chat, {message = '{purple}-_-'})
+        self:emit(app.net.events.chat, {message = '{purple}-_-'})
       end,
 
       default = function(data)
-        self:send(app.net.core.events.chat, event.peer, {message = '{red}unknown command "' .. data[1]:sub(2) .. '"'})
+        self:send(app.net.events.chat, event.peer, {message = '{red}unknown command "' .. data[1]:sub(2) .. '"'})
       end
     }
     handlers['/reset'] = handlers['/restart']
@@ -106,7 +77,7 @@ NetServer.receive[app.net.core.messages.chat] = function(self, event)
 
     return (handlers[data[1]] or handlers.default)(data)
   end
-  self:emit(app.net.core.events.chat, {message = '{' .. color .. '}' .. username .. '{white}: ' .. message})
+  self:emit(app.net.events.chat, {message = '{' .. color .. '}' .. username .. '{white}: ' .. message})
 end
 
 function NetServer:init()
@@ -145,8 +116,8 @@ function NetServer:disconnect(event)
   local pid = self.peerToPlayer[event.peer]
   local username = ctx.players:get(pid).username
   local reason = event.reason or 'left'
-  self:emit(app.net.core.events.chat, {message = '{white}' .. username .. ' has left (' .. reason .. ')'})
-  self:emit(app.net.core.events.leave, {id = pid, reason = reason})
+  self:emit(app.net.events.chat, {message = '{white}' .. username .. ' has left (' .. reason .. ')'})
+  self:emit(app.net.events.leave, {id = pid, reason = reason})
   self.peerToPlayer[event.peer] = nil
   event.peer:disconnect_now()
   if username == ctx.owner then
@@ -204,7 +175,7 @@ function NetServer:snapshot(peer)
       })
     end
   end
-  self:send(app.net.core.messages.snapshot, peer, {tick = tick, map = 'testArena', ['players'] = players})
+  self:send(app.net.messages.snapshot, peer, {tick = tick, map = 'testArena', ['players'] = players})
 end
 
 function NetServer:nextPlayerId()

app/net/signatures.lua

@@ -0,0 +1,49 @@
+local signatures = {}
+
+signatures.client = {
+  [app.net.messages.join] = {{'username', 'string'}, important = true},
+  [app.net.messages.leave] = {important = true},
+  [app.net.messages.class] = {{'class', '4bits'}, {'team', '1bit'}, important = true},
+  [app.net.messages.input] = {
+    {'tick', '16bits'},
+    {'w', 'bool'}, {'a', 'bool'}, {'s', 'bool'}, {'d', 'bool'},
+    {'x', '12bits'}, {'y', '12bits'}, {'l', 'bool'}, {'r', 'bool'},
+    {'slot', '3bits'}, {'reload', 'bool'},
+    delta = {{'w', 'a', 's', 'd'}, {'x', 'y'}, 'l', 'r', 'slot', 'reload'}
+  },
+  [app.net.messages.chat] = {{'message', 'string'}, important = true}
+}
+
+signatures.server = {
+  [app.net.events.join] = {{'id', '4bits'}, {'username', 'string'}, important = true},
+  [app.net.events.leave] = {{'id', '4bits'}, {'reason', 'string'}, important = true},
+  [app.net.events.class] = {{'id', '4bits'}, {'class', '4bits'}, {'team', '1bit'}, important = true},
+  [app.net.events.sync] = {
+    {'id', '4bits'},
+    {'tick', '16bits'},
+    {'ack', '16bits'},
+    {'x', '16bits'}, {'y', '16bits'}, {'z', '8bits'},
+    {'angle', '10bits'},
+    {'health', '10bits'}, {'shield', '10bits'},
+    {'weapon', '3bits'}, {'skill', '3bits'},
+    delta = {'x', 'y', 'z', 'angle', 'health', 'shield', 'weapon', 'skill'}
+  },
+  [app.net.events.fire] = {
+    {'id', '4bits'}, {'slot', '3bits'}, {'mx', '12bits'}, {'my', '12bits'},
+    delta = {{'mx', 'my'}}
+  },
+  [app.net.events.damage] = {{'id', '4bits'}, {'amount', 'string'}, {'from', '4bits'}},
+  [app.net.events.dead] = {{'id', '4bits'}, {'kill', '4bits'}, {'assists', {{'id', '4bits'}}}, important = true},
+  [app.net.events.spawn] = {{'id', '4bits'}, important = true},
+  [app.net.events.chat] = {{'message', 'string'}, important = true},
+  [app.net.events.prop] = {{'id', '16bits'}, {'x', '16bits'}, {'y', '16bits'}},
+  [app.net.messages.join] = {{'id', '4bits'}, important = true},
+  [app.net.messages.snapshot] = {
+    {'tick', '16bits'},
+    {'map', 'string'},
+    {'players', {{'id', '4bits'}, {'username', 'string'}, {'class', '4bits'}, {'team', '1bit'}}},
+    important = true
+  }
+}
+
+return signatures

app/player/base.lua

@@ -218,7 +218,7 @@ function Player:slot(input, prev)
     local msg = {id = self.id, slot = slot, mx = obj.needsMouse and input.x, my = obj.needsMouse and input.y}
     obj:fire(self, input.x, input.y)
     if obj.targeted then obj.targeting = false end
-    ctx.net:emit(app.net.core.events.fire, msg)
+    ctx.net:emit(app.net.events.fire, msg)
   end
 
   for i = 1, 5 do

app/player/controller.lua

@@ -10,15 +10,15 @@ function Players:init()
     self.players[i].id = i
   end
 
-  ctx.event:on(app.net.core.events.leave, function(data)
+  ctx.event:on(app.net.events.leave, function(data)
     self:deactivate(data.id)
   end)
 
-  ctx.event:on(app.net.core.events.class, function(data)
+  ctx.event:on(app.net.events.class, function(data)
     self:setClass(data.id, data.class, data.team)
   end)
 
-  ctx.event:on(app.net.core.events.fire, function(data)
+  ctx.event:on(app.net.events.fire, function(data)
     if ctx.id and data.id ~= ctx.id then
       local p = self:get(data.id)
       local slot = p.slots[data.slot]
@@ -26,7 +26,7 @@ function Players:init()
     end
   end)
 
-  ctx.event:on(app.net.core.events.damage, function(data)
+  ctx.event:on(app.net.events.damage, function(data)
     local to, from = self:get(data.id), self:get(data.from)
     to.lastHurt = tick
     if data.id ~= data.from then
@@ -50,7 +50,7 @@ function Players:init()
     })
   end)
 
-  ctx.event:on(app.net.core.events.dead, function(data)
+  ctx.event:on(app.net.events.dead, function(data)
     local killer, victim = self:get(data.kill), self:get(data.id)
     if data.kill ~= data.id then
       killer.kills = killer.kills + 1
@@ -60,7 +60,7 @@ function Players:init()
     victim:die()
   end)
 
-  ctx.event:on(app.net.core.events.spawn, function(data)
+  ctx.event:on(app.net.events.spawn, function(data)
     local p = self:get(data.id)
     p.ded = false
     p:spawn()
@@ -68,7 +68,7 @@ function Players:init()
 
   ctx.event:on('game.restart', function(data)
     self:each(function(p)
-      ctx.net:emit(app.net.core.events.spawn, {id = p.id})
+      ctx.net:emit(app.net.events.spawn, {id = p.id})
     end)
   end)
 end

app/player/main.lua

@@ -52,7 +52,7 @@ function PlayerMain:update()
     end
   end
 
-  ctx.net:send(app.net.core.messages.input, input)
+  ctx.net:send(app.net.messages.input, input)
 
   app.player.base.update(self)
 

app/player/server.lua

@@ -60,7 +60,7 @@ function PlayerServer:update()
       if spawn.team == self.team then
         self.health = math.min(self.health + amount, self.maxHealth)
       else
-        ctx.event:emit(app.net.core.events.damage, {id = self.id, amount = amount, from = self.id, tick = tick})
+        ctx.event:emit(app.net.events.damage, {id = self.id, amount = amount, from = self.id, tick = tick})
       end
     else
       self.spawnMultiplier = 0
@@ -137,7 +137,7 @@ function PlayerServer:trace(data, ping)
     msg.id = self.id
     msg.tick = tick
     msg.ack = self.ack
-    ctx.net:emit(app.net.core.events.sync, msg)
+    ctx.net:emit(app.net.events.sync, msg)
 
     -- Undo lag compensation
     ctx.players:each(function(p)
@@ -151,7 +151,7 @@ function PlayerServer:trace(data, ping)
 end
 
 function PlayerServer:time()
-  self.ded = timer.rot(self.ded, function() ctx.net:emit(app.net.core.events.spawn, {id = self.id}) end)
+  self.ded = timer.rot(self.ded, function() ctx.net:emit(app.net.events.spawn, {id = self.id}) end)
   if self.ded == 0 then self.ded = false end
 end
 
@@ -194,7 +194,7 @@ function PlayerServer:hurt(data)
         if playerHurt[2][2] > 0 then table.insert(assists, {id = playerHurt[2][1]}) end
       end
 
-      ctx.net:emit(app.net.core.events.dead, {id = self.id, kill = data.from, assists = assists})
+      ctx.net:emit(app.net.events.dead, {id = self.id, kill = data.from, assists = assists})
     else
       f.exe(self.shields[1].callback, self)
       table.remove(self.shields, 1)

app/ui/hud/chat.lua

@@ -59,7 +59,7 @@ function Chat:keypressed(key)
     if key == 'backspace' then self.message = self.message:sub(1, -2)
     elseif key == 'return' or key == 'escape' then
       if #self.message > 0 and key ~= 'escape' then
-        ctx.net:send(app.net.core.messages.chat, {
+        ctx.net:send(app.net.messages.chat, {
           message = self.message
         })
       end

app/ui/hud/classSelect.lua

@@ -11,7 +11,7 @@ function ClassSelect:init()
   self.utility = 0
   self.teamCt = {0, 0}
 
-  ctx.event:on(app.net.core.events.class, function(data)
+  ctx.event:on(app.net.events.class, function(data)
     if data.id == ctx.id then self.active = false end
   end)
 end
@@ -112,7 +112,7 @@ function ClassSelect:keypressed(key)
     for i = 1, #data.class do
       local class = data.class[data.class.list[i]]
       if not class.locked and key == tostring(i) then
-        ctx.net:send(app.net.core.messages.class, {
+        ctx.net:send(app.net.messages.class, {
           class = i,
           team = ctx.id > 1 and 1 or 0
         })
@@ -133,7 +133,7 @@ function ClassSelect:mousereleased(x, y, button)
   if self.active and button == 'l' then
     for i = 1, #data.class.list do
       if not data.class[data.class.list[i]].locked and math.inside(x, y, u * .09 * i, v * .326, u * .08, u * .08) then
-        ctx.net:send(app.net.core.messages.class, {
+        ctx.net:send(app.net.messages.class, {
           class = i,
           team = self.team
         })

app/ui/hud/controller.lua

@@ -21,7 +21,7 @@ function Hud:init()
   self.classSelect = app.ui.hud.classSelect()
   self.debug = app.ui.hud.debug()
 
-  ctx.event:on(app.net.core.events.chat, function(data) self.chat:add(data) end)
+  ctx.event:on(app.net.events.chat, function(data) self.chat:add(data) end)
   ctx.view:register(self, 'gui')
 
   self.u = ctx.view.frame.width

app/ui/hud/feed.lua

@@ -6,7 +6,7 @@ function Feed:init()
   self.entries = {}
   self.alpha = 0
 
-  ctx.event:on(app.net.core.events.dead, function(data) self:insert(data) end)
+  ctx.event:on(app.net.events.dead, function(data) self:insert(data) end)
 end
 
 function Feed:update()

app/ui/hud/killPopup.lua

@@ -7,7 +7,7 @@ function KillPopup:init()
   self.multikill = {}
   self.multikillTick = {}
   self.feed = {}
-  ctx.event:on(app.net.core.events.dead, function(data)
+  ctx.event:on(app.net.events.dead, function(data)
     self.streak[data.id] = 0
     if data.id ~= data.kill then
       self.multikill[data.kill] = self.multikill[data.kill] or 0

app/ui/hud/scoreboard.lua

@@ -3,9 +3,9 @@ local Scoreboard = class()
 local g = love.graphics
 
 function Scoreboard:init()
-  ctx.event:on(app.net.core.events.class, function(data) self:refresh() end)
-  ctx.event:on(app.net.core.events.dead, function(data) self:refresh() end)
-  ctx.event:on(app.net.core.events.leave, function(data) self:refresh() end)
+  ctx.event:on(app.net.events.class, function(data) self:refresh() end)
+  ctx.event:on(app.net.events.dead, function(data) self:refresh() end)
+  ctx.event:on(app.net.events.leave, function(data) self:refresh() end)
 
   self.names = {[0] = '', [1] = ''}
   self.ks = {[0] = '', [1] = ''}

data/buff/adrenaline.lua

@@ -29,7 +29,7 @@ function Adrenaline:update()
   self.hurtTimer = self.hurtTimer - 1
   if self.hurtTimer <= 0 then
     local amt = math.min(Adrenaline.drain * Adrenaline.rate, self.owner.health - 1)
-    ctx.net:emit(app.net.core.events.damage, {id = self.owner.id, amount = amt, from = self.owner.id, tick = tick})
+    ctx.net:emit(app.net.events.damage, {id = self.owner.id, amount = amt, from = self.owner.id, tick = tick})
     self.hurtTimer = math.round(Adrenaline.rate / tickRate)
     for _ = 1, 8 do
       ctx.event:emit('particle.create', {

data/media/shaders/darkenBehind.glsl

@@ -14,4 +14,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result.rgb *= 1 - diminish;
 
   return result * color;
-}
+}

data/media/shaders/desaturate.glsl

@@ -24,4 +24,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result = vec4(hsv2rgb(hsv), result.a);
 
   return result * color;
-}
+}

data/media/shaders/horizontalBlur.glsl

@@ -13,4 +13,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result += Texel(texture, vec2(texture_coords.x + 4.0 * amount, texture_coords.y)) * .05;
 
   return result * color;
-}
+}

data/media/shaders/motionBlur.glsl

@@ -11,4 +11,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result += Texel(texture, texture_coords) * .2;
 
   return result * color;
-}
+}

data/media/shaders/threshold.glsl

@@ -7,4 +7,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result = vec4(val);
 
   return vec4(result.rgb * color.rgb, result.a);
-}
+}

data/media/shaders/verticalBlur.glsl

@@ -13,4 +13,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result += Texel(texture, vec2(texture_coords.x, texture_coords.y + 4.0 * amount)) * .05;
 
   return result * color;
-}
+}

data/media/shaders/vignette.glsl

@@ -11,4 +11,4 @@ vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords)
   result.rgb *= vignette;
 
   return result * color;
-}
+}