discord rich presence, and MORE COLORS, video options, shiddddd so much stuff

src/core/Data.lua

@@ -97,6 +97,30 @@ function Data:seedDefaults()
   -- the overworld's Kanto literals, same fill-if-absent contract; required
   -- here rather than at the top so core keeps out of src/world at load time
   require("src.world.FieldDefaults").seed(self)
+  -- Cinnabar's quiz trainers are text_asm (no def_trainers), so the
+  -- extractor never writes headers for them.  Seed the EVENT_BEAT_* /
+  -- after-battle rows so Blaine's SetEventRange deactivation and talk
+  -- after-text work like the other gyms (scripts/CinnabarGym.asm).
+  self:seedCinnabarGymTrainerHeaders()
+end
+
+function Data:seedCinnabarGymTrainerHeaders()
+  local headers = self.trainer_headers
+  if not headers or headers.CinnabarGym then return end
+  local gym = {}
+  for i = 0, 6 do
+    local n = i + 1
+    -- object indices 2..8 are SUPER_NERD1..7; range 0 -- they only
+    -- engage via talk / wrong quiz answer, never sight lines
+    gym[i + 2] = {
+      event = "EVENT_BEAT_CINNABAR_GYM_TRAINER_" .. i,
+      range = 0,
+      battle = "_CinnabarGymSuperNerd" .. n .. "BattleText",
+      won = "_CinnabarGymSuperNerd" .. n .. "EndBattleText",
+      after = "_CinnabarGymSuperNerd" .. n .. "AfterBattleText",
+    }
+  end
+  headers.CinnabarGym = gym
 end
 
 -- POKEPORT_DATA_DIR points a test runner at another dataset root (the

src/core/DiscordPresence.lua

@@ -0,0 +1,658 @@
+-- Discord Rich Presence via the local Discord IPC pipe.  Shows the player's
+-- current map (and battle status) on their Discord profile.  Desktop only;
+-- no-ops on mobile, headless runs, or when Discord is not running.
+--
+-- Application ID is the only credential needed for presence.  The Discord
+-- Interactions public key is unused here (that is for verifying bot HTTP
+-- payloads, not Rich Presence).
+
+local Json = require("src.link.Json")
+local Logger = require("src.core.Logger")
+local Runtime = require("src.mods.Runtime")
+
+local DiscordPresence = {
+  APP_ID = "1529183141267374262",
+}
+
+local OP_HANDSHAKE, OP_FRAME, OP_CLOSE = 0, 1, 2
+
+local MIN_UPDATE_INTERVAL = 2.0
+local RECONNECT_INTERVAL = 30.0
+
+local state = {
+  enabled = false,
+  connected = false,
+  socket = nil,       -- Windows: file handle; Unix: ffi sockfd
+  isWindows = false,
+  ffi = nil,
+  ffiReady = false,
+  startedAt = 0,
+  dirty = false,
+  lastSentKey = nil,
+  lastSendAt = -1e9,
+  nextReconnectAt = 0,
+  location = nil,     -- display name
+  mapId = nil,
+  activity = "menu",  -- menu | exploring | battle
+  battleLabel = nil,
+  unsubs = {},
+  pid = nil,
+  loggedAbsent = false, -- one quiet note when Discord isn't running
+}
+
+local function disabledByEnv()
+  return os.getenv("POKEPORT_NO_DISCORD") == "1"
+      or os.getenv("POKEPORT_AUTOPILOT") ~= nil
+      or os.getenv("POKEPORT_DRIVER") ~= nil
+end
+
+local function isDesktop()
+  if not love or not love.system or not love.system.getOS then return false end
+  local osName = love.system.getOS()
+  return osName == "OS X" or osName == "Windows" or osName == "Linux"
+end
+
+local function packU32(n)
+  n = math.floor(n) % 0x100000000
+  local b1 = n % 256; n = math.floor(n / 256)
+  local b2 = n % 256; n = math.floor(n / 256)
+  local b3 = n % 256; n = math.floor(n / 256)
+  local b4 = n % 256
+  return string.char(b1, b2, b3, b4)
+end
+
+local function unpackU32(s)
+  local b1, b2, b3, b4 = s:byte(1, 4)
+  return b1 + b2 * 256 + b3 * 65536 + b4 * 16777216
+end
+
+local function nonce()
+  return string.format("%08x-%04x-4%03x-%04x-%04x%08x",
+    math.random(0, 0xffffffff),
+    math.random(0, 0xffff),
+    math.random(0, 0xfff),
+    math.random(0, 0x3fff) + 0x8000,
+    math.random(0, 0xffff),
+    math.random(0, 0xffffffff))
+end
+
+local function resolvePid()
+  if state.pid then return state.pid end
+  local ffi = state.ffi
+  if ffi then
+    if state.isWindows then
+      pcall(ffi.cdef, "unsigned long GetCurrentProcessId(void);")
+      local ok, p = pcall(function() return ffi.C.GetCurrentProcessId() end)
+      if ok and p and tonumber(p) and tonumber(p) > 0 then
+        state.pid = tonumber(p)
+        return state.pid
+      end
+    else
+      pcall(ffi.cdef, "int getpid(void);")
+      local ok, p = pcall(function() return ffi.C.getpid() end)
+      if ok and p and tonumber(p) and tonumber(p) > 0 then
+        state.pid = tonumber(p)
+        return state.pid
+      end
+    end
+  end
+  state.pid = 1000 + math.random(1, 8999)
+  return state.pid
+end
+
+local function ensureFfi()
+  if state.ffiReady then return state.ffi end
+  if state.ffi == false then return nil end
+  local ok, ffi = pcall(require, "ffi")
+  if not ok or not ffi then
+    state.ffi = false
+    return nil
+  end
+  state.ffi = ffi
+  if state.isWindows then
+    state.ffiReady = true
+    return ffi
+  end
+  -- Darwin sockaddr_un has sun_len + uint8_t family; Linux uses u16 family.
+  local osName = love.system.getOS()
+  local cdef
+  if osName == "OS X" then
+    cdef = [[
+      typedef unsigned int socklen_t;
+      typedef int ssize_t;
+      struct sockaddr_un {
+        uint8_t sun_len;
+        uint8_t sun_family;
+        char sun_path[104];
+      };
+      struct timeval { long tv_sec; int tv_usec; };
+      int socket(int domain, int type, int protocol);
+      int connect(int sockfd, const void *addr, socklen_t addrlen);
+      int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
+      ssize_t send(int sockfd, const void *buf, size_t len, int flags);
+      ssize_t recv(int sockfd, void *buf, size_t len, int flags);
+      int close(int fd);
+    ]]
+  else
+    cdef = [[
+      typedef unsigned int socklen_t;
+      typedef int ssize_t;
+      struct sockaddr_un {
+        unsigned short sun_family;
+        char sun_path[108];
+      };
+      struct timeval { long tv_sec; long tv_usec; };
+      int socket(int domain, int type, int protocol);
+      int connect(int sockfd, const void *addr, socklen_t addrlen);
+      int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
+      ssize_t send(int sockfd, const void *buf, size_t len, int flags);
+      ssize_t recv(int sockfd, void *buf, size_t len, int flags);
+      int close(int fd);
+    ]]
+  end
+  -- cdef may already be registered from a prior boot; either way we need
+  -- sockaddr_un usable before claiming readiness
+  pcall(ffi.cdef, cdef)
+  local ready = pcall(function() return ffi.new("struct sockaddr_un") end)
+  if not ready then
+    state.ffi = false
+    state.ffiReady = false
+    return nil
+  end
+  state.ffiReady = true
+  return ffi
+end
+
+local function closeSocket()
+  local sock = state.socket
+  state.socket = nil
+  state.connected = false
+  if not sock then return end
+  if state.isWindows then
+    pcall(function() sock:close() end)
+  elseif state.ffi then
+    pcall(state.ffi.C.close, sock)
+  end
+end
+
+local function writeRaw(bytes)
+  if not state.socket then return false end
+  if state.isWindows then
+    local ok = pcall(function()
+      state.socket:seek("end")
+      local _, writeErr = state.socket:write(bytes)
+      state.socket:flush()
+      if writeErr then error(writeErr) end
+    end)
+    return ok
+  end
+  local ffi = state.ffi
+  if not ffi then return false end
+  local ok, sent = pcall(ffi.C.send, state.socket, bytes, #bytes, 0)
+  return ok and sent == #bytes
+end
+
+local function sendFrame(opcode, payload)
+  local body = payload or ""
+  local ok, frame = pcall(function()
+    return packU32(opcode) .. packU32(#body) .. body
+  end)
+  if not ok or not frame then return false end
+  return writeRaw(frame)
+end
+
+local function readExact(n)
+  if not state.socket or n <= 0 then return nil end
+  if state.isWindows then
+    local ok, data = pcall(function() return state.socket:read(n) end)
+    if not ok or not data or #data < n then return nil end
+    return data
+  end
+  local ffi = state.ffi
+  if not ffi then return nil end
+  local ok, data = pcall(function()
+    local buf = ffi.new("char[?]", n)
+    local got = 0
+    while got < n do
+      local nread = ffi.C.recv(state.socket, buf + got, n - got, 0)
+      if not nread or nread <= 0 then return nil end
+      got = got + tonumber(nread)
+    end
+    return ffi.string(buf, n)
+  end)
+  if not ok then return nil end
+  return data
+end
+
+local function receiveFrame()
+  local header = readExact(8)
+  if not header then return nil end
+  local ok, opcode, length = pcall(function()
+    return unpackU32(header:sub(1, 4)), unpackU32(header:sub(5, 8))
+  end)
+  if not ok or not opcode or not length or length < 0 or length > 65536 then
+    return nil
+  end
+  local data = length > 0 and readExact(length) or ""
+  if data == nil then return nil end
+  return opcode, data
+end
+
+local function unixSocketPaths()
+  local paths = {}
+  local envs = { "XDG_RUNTIME_DIR", "TMPDIR", "TMP", "TEMP" }
+  local bases = {}
+  for _, key in ipairs(envs) do
+    local v = os.getenv(key)
+    if v and v ~= "" then
+      if v:sub(-1) == "/" then v = v:sub(1, -2) end
+      bases[#bases + 1] = v
+    end
+  end
+  bases[#bases + 1] = "/tmp"
+  local suffixes = {
+    "",
+    "/app/com.discordapp.Discord",
+    "/app/com.discordapp.DiscordCanary",
+    "/app/com.discordapp.DiscordPTB",
+    "/snap.discord",
+    "/snap.discord-canary",
+  }
+  local seen = {}
+  for i = 0, 9 do
+    local name = "discord-ipc-" .. i
+    for _, base in ipairs(bases) do
+      for _, suffix in ipairs(suffixes) do
+        local path = base .. suffix .. "/" .. name
+        if not seen[path] then
+          seen[path] = true
+          paths[#paths + 1] = path
+        end
+      end
+    end
+  end
+  return paths
+end
+
+local function setSocketTimeout(fd, seconds)
+  local ffi = state.ffi
+  if not ffi or not fd then return end
+  pcall(function()
+    local tv = ffi.new("struct timeval")
+    tv.tv_sec = seconds
+    tv.tv_usec = 0
+    -- SOL_SOCKET / SO_RCVTIMEO / SO_SNDTIMEO differ by OS
+    local sol, rcv, snd
+    if love.system.getOS() == "OS X" then
+      sol, rcv, snd = 0xffff, 0x1006, 0x1005
+    else
+      sol, rcv, snd = 1, 20, 21
+    end
+    ffi.C.setsockopt(fd, sol, rcv, tv, ffi.sizeof(tv))
+    ffi.C.setsockopt(fd, sol, snd, tv, ffi.sizeof(tv))
+  end)
+end
+
+local function connectUnix()
+  local ffi = ensureFfi()
+  if not ffi then return false end
+  local darwin = love.system.getOS() == "OS X"
+  local maxPath = darwin and 103 or 107
+  -- AF_UNIX=1, SOCK_STREAM=1 on Linux/macOS
+  local pathsOk, paths = pcall(unixSocketPaths)
+  if not pathsOk or not paths then return false end
+  for _, path in ipairs(paths) do
+    if #path <= maxPath then
+      local ok, connected = pcall(function()
+        local fd = ffi.C.socket(1, 1, 0)
+        if not fd or fd < 0 then return false end
+        local addr = ffi.new("struct sockaddr_un")
+        addr.sun_family = 1
+        if darwin then
+          -- SUN_LEN: sizeof(sun_len+sun_family) + path + NUL
+          addr.sun_len = 2 + #path + 1
+        end
+        ffi.copy(addr.sun_path, path)
+        local rc = ffi.C.connect(fd, ffi.cast("void*", addr), ffi.sizeof(addr))
+        if rc == 0 then
+          setSocketTimeout(fd, 1) -- handshake must not freeze the game
+          state.socket = fd
+          return true
+        end
+        ffi.C.close(fd)
+        return false
+      end)
+      if ok and connected then return true end
+    end
+  end
+  return false
+end
+
+local function connectWindows()
+  for i = 0, 9 do
+    local path = "\\\\.\\pipe\\discord-ipc-" .. i
+    local ok, file = pcall(io.open, path, "r+")
+    if ok and file then
+      state.socket = file
+      return true
+    end
+  end
+  return false
+end
+
+local function handshake()
+  local ok, payload = pcall(Json.encode, { v = 1, client_id = DiscordPresence.APP_ID })
+  if not ok or not payload then return false end
+  if not sendFrame(OP_HANDSHAKE, payload) then return false end
+  -- Discord echoes READY as a FRAME.  A timeout/missing client is a soft miss.
+  local opcode = receiveFrame()
+  if opcode == OP_FRAME then return true end
+  -- Windows named pipes have no easy read timeout: if the write succeeded
+  -- and Discord is present, proceed optimistically so boot never blocks.
+  if state.isWindows then return true end
+  return false
+end
+
+local function noteAbsent()
+  if state.loggedAbsent then return end
+  state.loggedAbsent = true
+  -- info, not warn: missing Discord is normal for many players
+  Logger.info("discord: rich presence unavailable (Discord not running)")
+end
+
+local function connect()
+  local ok, result = pcall(function()
+    closeSocket()
+    local linked
+    if state.isWindows then
+      linked = connectWindows()
+    else
+      linked = connectUnix()
+    end
+    if not linked then return false end
+    if not handshake() then
+      closeSocket()
+      return false
+    end
+    state.connected = true
+    state.dirty = true
+    state.lastSentKey = nil
+    state.loggedAbsent = false
+    Logger.info("discord: rich presence connected")
+    return true
+  end)
+  if not ok then
+    closeSocket()
+    return false
+  end
+  return result and true or false
+end
+
+local function locationName(game, mapId)
+  if not mapId then return nil end
+  local field = game and game.data and game.data.field
+  local townMap = field and field.townMap
+  local locations = townMap and (townMap.locations or townMap)
+  local entry = type(locations) == "table" and locations[mapId]
+  if type(entry) == "table" then
+    local name = entry.name or entry.label
+    if type(name) == "string" and name ~= "" then return name end
+  end
+  local def = game and game.data and game.data.maps and game.data.maps[mapId]
+  if def and type(def.label) == "string" and def.label ~= "" then
+    -- PalletTown -> Pallet Town
+    return def.label:gsub("(%l)(%u)", "%1 %2")
+  end
+  return tostring(mapId):gsub("_", " ")
+end
+
+local function speciesName(game, species)
+  if not species or not game or not game.data or not game.data.pokemon then
+    return nil
+  end
+  local def = game.data.pokemon[species]
+  return def and def.name or tostring(species):gsub("_", " ")
+end
+
+local function buildActivity()
+  local details, activityState
+  if state.activity == "battle" then
+    details = state.battleLabel or "In battle"
+    activityState = state.location and (state.location) or "Kanto"
+  elseif state.activity == "exploring" and state.location then
+    details = state.location
+    activityState = "Exploring the overworld"
+  else
+    details = state.location or "Kanto"
+    activityState = "At the title screen"
+  end
+
+  return {
+    details = details,
+    state = activityState,
+    timestamps = { start = state.startedAt },
+    assets = {
+      large_image = "logo",
+      large_text = "Pokemon Gen1Recomp",
+    },
+  }
+end
+
+local function activityKey(activity)
+  return (activity.details or "") .. "|" .. (activity.state or "")
+end
+
+local function flush(force)
+  if not state.enabled or not state.connected then return end
+  local ok = pcall(function()
+    local now = love.timer.getTime()
+    if not force and (now - state.lastSendAt) < MIN_UPDATE_INTERVAL then
+      state.dirty = true
+      return
+    end
+    local activity = buildActivity()
+    local key = activityKey(activity)
+    if not force and key == state.lastSentKey then
+      state.dirty = false
+      return
+    end
+    local payload = Json.encode({
+      cmd = "SET_ACTIVITY",
+      args = {
+        pid = resolvePid(),
+        activity = activity,
+      },
+      nonce = nonce(),
+    })
+    if not sendFrame(OP_FRAME, payload) then
+      closeSocket()
+      state.nextReconnectAt = now + RECONNECT_INTERVAL
+      return
+    end
+    state.lastSentKey = key
+    state.lastSendAt = now
+    state.dirty = false
+  end)
+  if not ok then
+    closeSocket()
+    local now = love and love.timer and love.timer.getTime and love.timer.getTime() or 0
+    state.nextReconnectAt = now + RECONNECT_INTERVAL
+  end
+end
+
+local function setPresence(fields)
+  -- event listeners must never throw into the overworld/battle path
+  pcall(function()
+    if fields.location ~= nil then state.location = fields.location end
+    if fields.mapId ~= nil then state.mapId = fields.mapId end
+    if fields.activity ~= nil then state.activity = fields.activity end
+    if fields.clearBattle then
+      state.battleLabel = nil
+    elseif fields.battleLabel ~= nil then
+      state.battleLabel = fields.battleLabel
+    end
+    state.dirty = true
+    flush(false)
+  end)
+end
+
+local function subscribe(game)
+  local events = Runtime.events
+  if not events or not events.on then return end
+
+  local function track(name, fn)
+    state.unsubs[#state.unsubs + 1] = events:on(name, fn, 0, "discord")
+  end
+
+  track("map.entered", function(ev)
+    local mapId = ev and ev.mapId
+    setPresence({
+      mapId = mapId,
+      location = locationName(game, mapId),
+      activity = "exploring",
+      clearBattle = true,
+    })
+  end)
+
+  track("battle.started", function(ev)
+    local battle = ev and ev.battle
+    local label = "In battle"
+    if ev and ev.kind == "wild" then
+      local name = speciesName(game, ev.species)
+      if name then
+        label = "Battling wild " .. name
+        if ev.level then label = label .. " Lv" .. tostring(ev.level) end
+      else
+        label = "Wild battle"
+      end
+    elseif ev and ev.kind == "trainer" then
+      local tname = battle and battle.trainer and battle.trainer.name
+      label = tname and ("Battling " .. tname) or "Trainer battle"
+    elseif ev and ev.kind == "link" then
+      label = "Link battle"
+    end
+    local mapId = state.mapId
+      or (game.save and game.save.player and game.save.player.map)
+    setPresence({
+      activity = "battle",
+      battleLabel = label,
+      location = locationName(game, mapId) or state.location,
+      mapId = mapId,
+    })
+  end)
+
+  track("battle.ended", function()
+    local mapId = state.mapId
+      or (game.save and game.save.player and game.save.player.map)
+    setPresence({
+      activity = mapId and "exploring" or "menu",
+      clearBattle = true,
+      location = locationName(game, mapId) or state.location,
+      mapId = mapId,
+    })
+  end)
+
+  track("screen.pushed", function(ev)
+    local s = ev and ev.state
+    local id = s and s.screenId
+    if not id and s and s.onNewGame then id = "TitleState" end
+    if id == "TitleState" or id == "IntroMovie" then
+      state.mapId = nil
+      setPresence({
+        activity = "menu",
+        location = id == "IntroMovie" and "Watching the intro" or "Title screen",
+        clearBattle = true,
+      })
+    end
+  end)
+end
+
+function DiscordPresence.init(game)
+  local ok, err = pcall(function()
+    DiscordPresence.shutdown()
+    if disabledByEnv() or not isDesktop() then return end
+
+    state.enabled = true
+    state.isWindows = love.system.getOS() == "Windows"
+    state.startedAt = os.time()
+    state.activity = "menu"
+    state.location = "Title screen"
+    state.mapId = nil
+    state.battleLabel = nil
+    state.dirty = true
+    state.nextReconnectAt = 0
+    state.loggedAbsent = false
+
+    if not state.isWindows and not ensureFfi() then
+      -- no FFI / broken cdef: stay disabled, never throw
+      state.enabled = false
+      return
+    end
+
+    subscribe(game)
+    if connect() then
+      flush(true)
+    else
+      noteAbsent()
+      local now = (love.timer and love.timer.getTime and love.timer.getTime()) or 0
+      state.nextReconnectAt = now + RECONNECT_INTERVAL
+    end
+  end)
+  if not ok then
+    closeSocket()
+    state.enabled = false
+    -- still soft: a broken presence stack must not abort boot
+    Logger.info("discord: rich presence disabled (%s)", tostring(err))
+  end
+end
+
+function DiscordPresence.update(_dt)
+  if not state.enabled then return end
+  pcall(function()
+    local now = love.timer.getTime()
+    if not state.connected then
+      if now >= state.nextReconnectAt then
+        state.nextReconnectAt = now + RECONNECT_INTERVAL
+        if connect() then
+          flush(true)
+        else
+          noteAbsent()
+        end
+      end
+      return
+    end
+    if state.dirty then flush(false) end
+  end)
+end
+
+function DiscordPresence.shutdown()
+  pcall(function()
+    for _, unsub in ipairs(state.unsubs) do
+      pcall(unsub)
+    end
+    state.unsubs = {}
+    if state.connected then
+      pcall(function()
+        -- omit activity to clear the presence
+        sendFrame(OP_FRAME, Json.encode({
+          cmd = "SET_ACTIVITY",
+          args = { pid = resolvePid() },
+          nonce = nonce(),
+        }))
+        sendFrame(OP_CLOSE, "{}")
+      end)
+    end
+    closeSocket()
+  end)
+  state.enabled = false
+  state.dirty = false
+  state.lastSentKey = nil
+  state.connected = false
+  state.socket = nil
+end
+
+-- test / debug helpers
+DiscordPresence._state = state
+DiscordPresence.locationName = locationName
+
+return DiscordPresence

src/core/Game.lua

@@ -68,6 +68,10 @@ function Game:load()
   local OverworldState = require("src.world.OverworldController")
   self.overworld = OverworldState
 
+  -- Discord Rich Presence: map name / battle status on the player's profile.
+  -- Soft-fail: missing Discord / IPC errors must never block boot.
+  pcall(function() require("src.core.DiscordPresence").init(self) end)
+
   -- every service is up but nothing is on the stack yet; this payload is
   -- the sanctioned way for a mod to obtain the Game object
   ModRuntime.emit("game.ready", { game = self })
@@ -103,7 +107,7 @@ end
 function Game:makeTitleState()
   local OverworldState = require("src.world.OverworldController")
   local factory = Screens.get(self, bootScreens(self).title or "TitleState")
-  return factory.new(self, {
+  local title = factory.new(self, {
     onNewGame = function()
       while self.stack:top() do self.stack:pop() end
       -- New Game keeps the standalone options.lua preferences
@@ -126,6 +130,8 @@ function Game:makeTitleState()
       end
     end,
   })
+  title.screenId = title.screenId or "TitleState"
+  return title
 end
 
 -- QUIT from the START menu: back to the title like a power-cycle,
@@ -187,6 +193,7 @@ function Game:update(dt)
   -- Overworld tilt toggle tween: presentational, so it runs on the real
   -- frame dt (not the fixed logic step) for a smooth ~0.25s glide.
   require("src.render.Tilt").update(dt)
+  pcall(function() require("src.core.DiscordPresence").update(dt) end)
 end
 
 -- render.zones' identity default: unhooked, the zone list reaches the blit
@@ -391,6 +398,7 @@ function Game:applyOptions(opts)
   require("src.render.PaletteFX").applyOptions(opts)
   require("src.render.Tilt").applyOptions(opts)
   require("src.render.GBCFX").applyOptions(opts)
+  require("src.core.VideoMode").applyOptions(opts)
 end
 
 function Game:restoreSave(loaded, recovered)

src/core/GameSpeed.lua

@@ -18,7 +18,7 @@ local GameSpeed = {}
 -- attempt is long enough that the iteration loop, not the engine, is the
 -- bottleneck. Vsync caps how much a real frame can do, so past 10X the
 -- multiplier is increasingly a ceiling rather than a rate.
-GameSpeed.LEVELS = { 1, 2, 4, 10, 20, 30, 50, 75, 100,500 }
+GameSpeed.LEVELS = { 1, 2, 4, 10, 20, 30, 50, 75, 100,200 }
 GameSpeed.DEFAULT = 1
 
 function GameSpeed.levelLabel(v)

src/core/SaveData.lua

@@ -47,6 +47,8 @@ function SaveData.defaultOptions()
     colors = "gbc",
     tilt = 0,
     gbcfx = 0,
+    -- windowed | borderless (desktop fullscreen); ignored on mobile
+    videoMode = "windowed",
     -- Native mod enablement is an installation option, not save-slot data.
     -- Missing entries mean enabled so newly installed mods work by default.
     mods = {},

src/core/VideoMode.lua

@@ -0,0 +1,54 @@
+-- Windowed vs borderless (desktop) fullscreen.
+--
+-- Persisted as save.options.videoMode.  Applied from OptionsMenu and on
+-- boot via Game:applyOptions.  No-ops on mobile and in headless stubs
+-- that lack love.window.
+
+local VideoMode = {}
+
+VideoMode.MODES = { "windowed", "borderless" }
+VideoMode.DEFAULT = "windowed"
+
+local LABELS = {
+  windowed = "WINDOWED",
+  borderless = "BORDERLESS",
+}
+
+function VideoMode.normalize(mode)
+  if mode == "borderless" then return "borderless" end
+  return VideoMode.DEFAULT
+end
+
+function VideoMode.modeLabel(mode)
+  return LABELS[VideoMode.normalize(mode)] or LABELS[VideoMode.DEFAULT]
+end
+
+function VideoMode.isMobile()
+  if not love or not love.system or not love.system.getOS then return false end
+  local osName = love.system.getOS()
+  return osName == "Android" or osName == "iOS"
+end
+
+-- Cycle windowed <-> borderless (dir ignored; two modes).
+function VideoMode.cycle(mode, _dir)
+  return VideoMode.normalize(mode) == "borderless" and "windowed" or "borderless"
+end
+
+-- Push the mode into the live window.  Safe when love.window is missing.
+function VideoMode.apply(mode)
+  if VideoMode.isMobile() then return end
+  if not love or not love.window or not love.window.setFullscreen then return end
+  mode = VideoMode.normalize(mode)
+  if mode == "borderless" then
+    -- "desktop" = borderless fullscreen matching the display
+    love.window.setFullscreen(true, "desktop")
+  else
+    love.window.setFullscreen(false)
+  end
+end
+
+function VideoMode.applyOptions(opts)
+  VideoMode.apply(opts and opts.videoMode)
+end
+
+return VideoMode