2015-05-15 21:55:11 -07:00
|
|
|
require = require "depend"
|
2015-03-07 07:53:11 -08:00
|
|
|
require "boilerplate"
|
2015-03-20 19:46:08 -07:00
|
|
|
require "addrs.init"
|
2015-05-03 16:46:09 -07:00
|
|
|
require "classes"
|
2015-05-07 15:27:26 -07:00
|
|
|
require "messages"
|
2015-03-07 07:53:11 -08:00
|
|
|
|
2015-03-27 02:32:23 -07:00
|
|
|
-- check for errors in the actor linked lists
|
2015-05-01 20:36:02 -07:00
|
|
|
local validate = false
|
2015-03-27 02:32:23 -07:00
|
|
|
|
2015-05-15 21:55:11 -07:00
|
|
|
-- for figuring out actor variables
|
|
|
|
local debug_mode = true
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
-- creating an object every time is a bit slow, so
|
2015-03-08 09:38:43 -07:00
|
|
|
-- using a template to offset from will do for now.
|
2015-03-07 07:53:11 -08:00
|
|
|
local actor_t = Actor(0)
|
|
|
|
|
2015-03-27 02:32:23 -07:00
|
|
|
local suffix = oot and " oot" or ""
|
2015-05-01 09:59:16 -07:00
|
|
|
local actor_names = require("data.actor names"..suffix)
|
|
|
|
local damage_names = require("data.damage names"..suffix)
|
2015-03-17 14:58:07 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
-- hack to avoid N64 logo spitting errors
|
|
|
|
local stupid = addrs.actor_counts[0].addr - 0x8
|
|
|
|
|
2015-03-18 22:19:25 -07:00
|
|
|
function sort_by_key(t)
|
|
|
|
local sorted = {}
|
|
|
|
local i = 1
|
|
|
|
for k, v in pairs(t) do
|
|
|
|
sorted[i] = {k=k, v=v}
|
|
|
|
i = i + 1
|
|
|
|
end
|
|
|
|
table.sort(sorted, function(a, b) return a.k < b.k end)
|
|
|
|
return sorted
|
|
|
|
end
|
|
|
|
|
2015-03-07 07:53:11 -08:00
|
|
|
function get_actor_count(i)
|
2015-03-18 21:50:35 -07:00
|
|
|
return R4(addrs.actor_counts[i].addr)
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
|
|
|
function get_first_actor(i)
|
2015-03-26 16:36:44 -07:00
|
|
|
return deref(R4(addrs.actor_firsts[i].addr))
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
|
|
|
function get_next_actor(addr)
|
2015-03-26 16:36:44 -07:00
|
|
|
return deref(R4(addr + actor_t.next.addr))
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
2015-03-27 01:59:40 -07:00
|
|
|
function get_prev_actor(addr)
|
|
|
|
return deref(R4(addr + actor_t.prev.addr))
|
|
|
|
end
|
|
|
|
|
2015-03-17 19:10:06 -07:00
|
|
|
function count_actors()
|
|
|
|
local counts = {}
|
|
|
|
for i = 0, 11 do
|
|
|
|
counts[i] = get_actor_count(i)
|
|
|
|
end
|
|
|
|
return counts
|
|
|
|
end
|
|
|
|
|
|
|
|
function iter_actors(counts)
|
|
|
|
local at, ai = 0, 0
|
|
|
|
local addr
|
|
|
|
|
2015-03-27 01:59:40 -07:00
|
|
|
local y = 1
|
|
|
|
local complain = function(s)
|
|
|
|
s = s..(" (%2i:%3i)"):format(at, ai)
|
2015-03-27 02:41:27 -07:00
|
|
|
T_TR(0, y, "yellow", s)
|
2015-03-27 01:59:40 -07:00
|
|
|
y = y + 1
|
|
|
|
end
|
2015-03-17 19:10:06 -07:00
|
|
|
|
2015-03-27 01:59:40 -07:00
|
|
|
local iterate
|
|
|
|
iterate = function()
|
2015-03-17 19:10:06 -07:00
|
|
|
if ai == 0 then
|
|
|
|
addr = get_first_actor(at)
|
2015-03-27 01:59:40 -07:00
|
|
|
if validate and addr and get_prev_actor(addr) then
|
|
|
|
complain("item before first")
|
|
|
|
end
|
2015-03-17 19:10:06 -07:00
|
|
|
else
|
2015-03-27 01:59:40 -07:00
|
|
|
local prev = addr
|
2015-03-17 19:10:06 -07:00
|
|
|
addr = get_next_actor(addr)
|
2015-03-27 01:59:40 -07:00
|
|
|
if validate then
|
|
|
|
if addr and prev ~= get_prev_actor(addr) then
|
|
|
|
complain("previous mismatch")
|
|
|
|
end
|
|
|
|
end
|
2015-03-26 16:36:44 -07:00
|
|
|
end
|
2015-03-27 01:59:40 -07:00
|
|
|
|
2015-03-26 16:36:44 -07:00
|
|
|
if not addr then
|
2015-03-27 01:59:40 -07:00
|
|
|
if validate then
|
|
|
|
if ai < counts[at] then
|
|
|
|
-- known case: romani ranch on first/third night
|
|
|
|
complain("list ended early")
|
|
|
|
elseif ai > counts[at] then
|
|
|
|
complain("list ended late")
|
|
|
|
end
|
|
|
|
end
|
2015-03-17 19:10:06 -07:00
|
|
|
|
2015-03-27 01:59:40 -07:00
|
|
|
ai = 0
|
|
|
|
at = at + 1
|
|
|
|
if at == 12 then return nil end
|
|
|
|
return iterate()
|
|
|
|
else
|
|
|
|
local temp = ai
|
|
|
|
ai = ai + 1
|
|
|
|
return at, temp, addr
|
|
|
|
end
|
2015-03-17 19:10:06 -07:00
|
|
|
end
|
2015-03-27 01:59:40 -07:00
|
|
|
|
|
|
|
return iterate
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
2015-05-02 06:35:15 -07:00
|
|
|
function longbinary(x)
|
|
|
|
return ('%032s'):format(bizstring.binary(x))
|
|
|
|
end
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
function focus(actor, dump)
|
|
|
|
local color = actor.name:sub(1,1) == "?" and "red" or "orange"
|
2015-05-02 06:35:15 -07:00
|
|
|
local flags = longbinary(actor.flags)
|
2015-05-15 21:55:11 -07:00
|
|
|
local y = debug_mode and 24 or 9
|
|
|
|
local write = function(color, fmt, ...)
|
|
|
|
T_BL(0, y, color, fmt, ...)
|
|
|
|
y = y - 1
|
|
|
|
return y + 1
|
|
|
|
end
|
|
|
|
|
|
|
|
write(nil, 'Hi: %s', flags:sub(1,16))
|
|
|
|
write(nil, 'Lo: %s', flags:sub(17,32))
|
|
|
|
write(color, actor.name)
|
|
|
|
write(nil, 'HP: %02X', actor.hp)
|
|
|
|
write('cyan', 'No.: %03X', actor.num)
|
|
|
|
write(nil, 'Var: %04X', actor.var)
|
|
|
|
write(nil, '80%06X', actor.addr)
|
|
|
|
write(nil, 'type: %3i', actor.at)
|
|
|
|
write(nil, 'index: %3i', actor.ai)
|
|
|
|
write(nil, 'count: %3i', actor.type_count)
|
|
|
|
|
|
|
|
if debug_mode then
|
|
|
|
local a = Actor(actor.addr)
|
|
|
|
local watch = {
|
|
|
|
{'room_number', '%02X'},
|
|
|
|
--{'x_rot_init', '%04X'},
|
|
|
|
--{'y_rot_init', '%04X'},
|
|
|
|
--{'z_rot_init', '%04X'},
|
|
|
|
--{'unk_1A', '%02X'},
|
|
|
|
{'unk_1E', '%02X'},
|
|
|
|
{'unk_20', '%04X'},
|
|
|
|
{'unk_22', '%04X'},
|
|
|
|
--{'unnamed_x_rot', '%04X'},
|
|
|
|
--{'unnamed_y_rot', '%04X'},
|
|
|
|
--{'unnamed_z_rot', '%04X'},
|
|
|
|
{'unk_36', '%04X'},
|
|
|
|
{'unk_38', '%02X'},
|
|
|
|
{'x', '%9.3f'},
|
|
|
|
{'y', '%9.3f'},
|
|
|
|
{'z', '%9.3f'},
|
|
|
|
{'lin_vel_old', '%9.3f'},
|
|
|
|
{'unk_74', '%9.3f'},
|
|
|
|
{'unk_78', '%9.3f'},
|
|
|
|
{'foot_left_x', '%9.3f'},
|
|
|
|
{'foot_left_y', '%9.3f'},
|
|
|
|
{'foot_left_z', '%9.3f'},
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, t in ipairs(watch) do
|
|
|
|
write(nil, '%12s: '..t[2], t[1], a[t[1]]())
|
|
|
|
end
|
|
|
|
|
|
|
|
if dump then
|
|
|
|
a.unk_38(math.random(0, 0xFF))
|
|
|
|
end
|
|
|
|
--a.x_old(a.x())
|
|
|
|
--a.y_old(a.y())
|
|
|
|
--a.z_old(a.z())
|
|
|
|
|
|
|
|
return -- skip damage table crap
|
|
|
|
end
|
2015-05-01 20:36:02 -07:00
|
|
|
|
|
|
|
local dmg = deref(R4(actor.addr + actor_t.damage_table.addr))
|
|
|
|
if dmg then
|
|
|
|
for i = 0, 31 do
|
|
|
|
local name = damage_names[i]
|
|
|
|
local str = ('%9s: %02X'):format(name, R1(dmg + i))
|
|
|
|
|
|
|
|
if i >= 16 then
|
|
|
|
T_TR(0, i - 16, nil, str)
|
|
|
|
else
|
|
|
|
T_TL(0, i, nil, str)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2015-03-18 10:27:45 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
if dump then
|
|
|
|
console.clear()
|
|
|
|
s = ("%04X\t%02X\t%02X"):format(actor.num, actor.at, actor.hp)
|
|
|
|
if dmg then
|
|
|
|
for i = 0, 31 do
|
|
|
|
s = s..("\t%02X"):format(R1(dmg + i))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
print(s)
|
2015-05-15 21:55:11 -07:00
|
|
|
|
|
|
|
--[[
|
|
|
|
for _, v in ipairs{'x', 'y', 'z', 'x_copy', 'y_copy', 'z_copy'} do
|
|
|
|
WF(actor.addr + actor_t[v].addr, 0)
|
|
|
|
end
|
|
|
|
--]]
|
|
|
|
print(R1(actor.addr + 0x1E))
|
|
|
|
W1(actor.addr + 0x1E, 0xFF)
|
2015-05-01 20:36:02 -07:00
|
|
|
end
|
|
|
|
end
|
2015-03-18 10:27:45 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
function collect_actors()
|
|
|
|
local game_counts = count_actors()
|
|
|
|
local any = 0
|
|
|
|
for i = 0, 11 do
|
|
|
|
any = any + game_counts[i]
|
|
|
|
--FIXME: T_BR(0, 13 - i, nil, "#%2i: %2i", i, game_counts[i])
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
2015-05-01 20:36:02 -07:00
|
|
|
--FIXME: T_BR(0, 1, nil, "sum:%3i", any)
|
2015-03-18 10:27:45 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
local actors_by_type = {[0]={},{},{},{},{},{},{},{},{},{},{},{}} -- 12
|
|
|
|
local new_counts = {[0]=0,0,0,0,0,0,0,0,0,0,0,0} -- 12
|
|
|
|
if any > 0 then
|
|
|
|
any = 0
|
|
|
|
for at, ai, addr in iter_actors(game_counts) do
|
|
|
|
actors_by_type[at][ai] = addr
|
|
|
|
new_counts[at] = new_counts[at] + 1
|
|
|
|
any = any + 1
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return any > 0, actors_by_type, new_counts
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
ActorLister = Class()
|
|
|
|
function ActorLister:init()
|
|
|
|
self.before = 0
|
|
|
|
self.wait = 0
|
|
|
|
self.focus_at = 2
|
|
|
|
self.focus_ai = 0
|
|
|
|
self.seen_once = {}
|
|
|
|
self.seen_strs = {}
|
|
|
|
self.seen_strs_sorted = {}
|
|
|
|
self.input = InputHandler{
|
|
|
|
enter = "P1 L",
|
|
|
|
up = "P1 DPad U",
|
|
|
|
down = "P1 DPad D",
|
|
|
|
left = "P1 DPad L",
|
|
|
|
right = "P1 DPad R",
|
|
|
|
}
|
|
|
|
end
|
2015-03-19 01:23:50 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
function ActorLister:wipe()
|
|
|
|
if #self.seen_strs_sorted > 0 then
|
2015-03-19 01:23:50 -07:00
|
|
|
print()
|
|
|
|
print("# actors wiped #")
|
|
|
|
print()
|
|
|
|
end
|
2015-05-01 20:36:02 -07:00
|
|
|
self.seen_once = {}
|
|
|
|
self.seen_strs = {}
|
|
|
|
self.seen_strs_sorted = {}
|
2015-03-19 01:23:50 -07:00
|
|
|
end
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
function ActorLister:run(now)
|
2015-03-27 02:32:23 -07:00
|
|
|
local game_counts = nil
|
2015-03-18 22:19:25 -07:00
|
|
|
local seen = {}
|
2015-03-26 16:48:29 -07:00
|
|
|
local cursor, target
|
2015-03-17 14:58:07 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
local ctrl, pressed = self.input:update()
|
2015-03-18 10:27:45 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
if pressed.left then self.focus_ai = self.focus_ai - 1 end
|
|
|
|
if pressed.right then self.focus_ai = self.focus_ai + 1 end
|
2015-03-18 10:27:45 -07:00
|
|
|
if pressed.down then
|
|
|
|
-- follow Link again
|
2015-05-01 20:36:02 -07:00
|
|
|
self.focus_at = 2
|
|
|
|
self.focus_ai = 0
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
|
|
|
|
2015-03-17 14:58:07 -07:00
|
|
|
if R4(stupid) ~= 0 then
|
2015-03-27 02:41:27 -07:00
|
|
|
T_BR(0, 0, "red", "stupid")
|
2015-03-27 02:32:23 -07:00
|
|
|
return
|
|
|
|
end
|
2015-03-17 19:10:06 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
local any, actors_by_type, new_counts = collect_actors()
|
2015-03-27 01:59:40 -07:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
if not any then
|
|
|
|
self:wipe()
|
2015-03-18 10:27:45 -07:00
|
|
|
else
|
2015-05-01 20:36:02 -07:00
|
|
|
while self.focus_ai < 0 do
|
|
|
|
self.focus_at = (self.focus_at - 1) % 12
|
|
|
|
self.focus_ai = new_counts[self.focus_at] - 1
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
2015-05-01 20:36:02 -07:00
|
|
|
while self.focus_ai >= new_counts[self.focus_at] do
|
|
|
|
self.focus_at = (self.focus_at + 1) % 12
|
|
|
|
self.focus_ai = 0
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
2015-03-26 16:48:29 -07:00
|
|
|
cursor = deref(addrs.z_cursor_actor())
|
|
|
|
target = deref(addrs.z_target_actor())
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
local focus_link = self.focus_at == 2 and self.focus_ai == 0
|
2015-05-15 21:55:11 -07:00
|
|
|
if debug_mode then focus_link = false end
|
2015-03-17 19:10:06 -07:00
|
|
|
local needs_update = false
|
2015-03-18 22:19:25 -07:00
|
|
|
|
2015-03-27 01:59:40 -07:00
|
|
|
for at, actors in pairs(actors_by_type) do
|
|
|
|
for ai, addr in pairs(actors) do -- FIXME: sorry for this pseudo-indent
|
2015-05-01 20:36:02 -07:00
|
|
|
local var = R2(addr + actor_t.var.addr)
|
|
|
|
local hp = R1(addr + actor_t.hp.addr)
|
2015-03-18 10:27:45 -07:00
|
|
|
local num = R2(addr + actor_t.num.addr)
|
2015-03-17 19:10:06 -07:00
|
|
|
local name = actor_names[num]
|
2015-05-02 06:35:15 -07:00
|
|
|
local fa = addr + actor_t.flags.addr
|
|
|
|
local flags = R4(fa)
|
2015-05-01 20:36:02 -07:00
|
|
|
|
|
|
|
local focus_this = at == self.focus_at and ai == self.focus_ai
|
2015-03-18 22:19:25 -07:00
|
|
|
|
|
|
|
seen[num] = true
|
2015-03-17 19:10:06 -07:00
|
|
|
|
2015-03-18 10:27:45 -07:00
|
|
|
if not name then
|
2015-03-17 19:10:06 -07:00
|
|
|
name = "NEW"
|
|
|
|
actor_names[num] = name
|
|
|
|
print(("\t[0x%03X]=\"NEW\","):format(num))
|
|
|
|
end
|
2015-03-07 07:53:11 -08:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
if not self.seen_once[num] then
|
|
|
|
self.seen_once[num] = now
|
2015-03-17 19:10:06 -07:00
|
|
|
needs_update = true
|
|
|
|
local str
|
|
|
|
if name:sub(1,1) == "?" then
|
|
|
|
str = ("%s (%03X)"):format(name, num)
|
|
|
|
else
|
|
|
|
str = ("%s"):format(name)
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
2015-05-01 20:36:02 -07:00
|
|
|
self.seen_strs[num] = str
|
2015-03-17 19:10:06 -07:00
|
|
|
print(str)
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
2015-05-15 21:55:11 -07:00
|
|
|
local focal = false
|
|
|
|
if not debug_mode then
|
|
|
|
focal = focal or (focus_this and not focus_link)
|
|
|
|
focal = focal or (focus_link and addr == target)
|
|
|
|
else
|
|
|
|
if target then
|
|
|
|
focal = addr == target
|
|
|
|
else
|
|
|
|
focal = focus_this
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if focal then
|
2015-05-01 20:36:02 -07:00
|
|
|
local actor = {
|
2015-05-02 06:35:15 -07:00
|
|
|
name = name,
|
2015-05-01 20:36:02 -07:00
|
|
|
addr = addr,
|
|
|
|
ai = ai,
|
|
|
|
type_count = new_counts[at],
|
2015-05-02 06:35:15 -07:00
|
|
|
|
|
|
|
at = at,
|
2015-05-01 20:36:02 -07:00
|
|
|
var = var,
|
2015-05-02 06:35:15 -07:00
|
|
|
flags = flags,
|
|
|
|
hp = hp,
|
2015-05-01 20:36:02 -07:00
|
|
|
num = num,
|
|
|
|
}
|
|
|
|
focus(actor, pressed.up)
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
|
|
|
|
|
|
|
if focus_this then
|
|
|
|
W1(addrs.camera_target.addr, 0x80)
|
|
|
|
W3(addrs.camera_target.addr + 1, addr)
|
2015-03-17 14:58:07 -07:00
|
|
|
end
|
2015-05-02 06:35:15 -07:00
|
|
|
|
|
|
|
-- make all actors z-targetable
|
|
|
|
if not (focus_this and focus_link) then
|
|
|
|
flags = bit.bor(flags, 0x00000001)
|
|
|
|
W4(fa, flags)
|
|
|
|
end
|
2015-03-27 01:59:40 -07:00
|
|
|
end
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
2015-03-17 19:10:06 -07:00
|
|
|
if needs_update then
|
2015-05-01 20:36:02 -07:00
|
|
|
self.seen_strs_sorted = sort_by_key(self.seen_strs)
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
2015-03-18 10:27:45 -07:00
|
|
|
|
2015-03-26 16:48:29 -07:00
|
|
|
if focus_link and not target then
|
2015-05-01 20:36:02 -07:00
|
|
|
for i, t in ipairs(self.seen_strs_sorted) do
|
2015-03-19 01:23:50 -07:00
|
|
|
local color = 'white'
|
2015-05-01 20:36:02 -07:00
|
|
|
if self.seen_once[t.k] and now - 60 <= self.seen_once[t.k] then
|
2015-03-19 01:23:50 -07:00
|
|
|
color = 'lime'
|
|
|
|
end
|
|
|
|
if not seen[t.k] then
|
|
|
|
color = 'orange'
|
|
|
|
end
|
2015-03-27 02:41:27 -07:00
|
|
|
T_TL(0, i - 1, color, t.v)
|
2015-03-18 10:27:45 -07:00
|
|
|
end
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
T_BR(0, 0, nil, "unique:%3i", #self.seen_strs_sorted)
|
2015-03-07 07:53:11 -08:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
if any then
|
2015-03-17 14:58:07 -07:00
|
|
|
local z = target or cursor
|
|
|
|
if z then
|
|
|
|
local num = R2(z)
|
2015-05-01 20:36:02 -07:00
|
|
|
T_TR(0, 0, nil, self.seen_strs[num])
|
2015-03-17 14:58:07 -07:00
|
|
|
end
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|
2015-03-19 01:23:50 -07:00
|
|
|
end
|
2015-03-07 07:53:11 -08:00
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
-- TODO: abstract to wrapper class or something
|
|
|
|
function ActorLister:runwrap(now)
|
|
|
|
if now < self.before then self.wait = 2 end
|
|
|
|
self.before = now
|
|
|
|
if self.wait > 0 then
|
2015-03-27 02:32:23 -07:00
|
|
|
-- prevent script from lagging reversing
|
2015-05-01 20:36:02 -07:00
|
|
|
self.wait = self.wait - 1
|
|
|
|
if self.wait == 0 then self:wipe() end
|
2015-03-27 02:32:23 -07:00
|
|
|
else
|
2015-05-01 20:36:02 -07:00
|
|
|
self:run(now)
|
2015-03-27 02:32:23 -07:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-05-01 20:36:02 -07:00
|
|
|
al = ActorLister()
|
2015-05-10 11:30:45 -07:00
|
|
|
event.onloadstate(function() al:wipe() end, 'actor wipe')
|
2015-05-01 11:48:49 -07:00
|
|
|
while oot or mm do
|
2015-03-27 02:32:23 -07:00
|
|
|
local now = emu.framecount()
|
2015-05-01 20:36:02 -07:00
|
|
|
al:runwrap(now)
|
2015-03-17 14:58:07 -07:00
|
|
|
emu.frameadvance()
|
2015-03-07 07:53:11 -08:00
|
|
|
end
|