Merge dddcd0c7a7 into 6cf6568a57

funcs.lua

@@ -3,7 +3,13 @@ function copy(t)
 	if type(t) ~= "table" then return t end
 	local meta = getmetatable(t)
 	local target = {}
-	for k, v in pairs(t) do target[k] = v end
+	for k, v in pairs(t) do
+        if type(v) == "table" then
+            target[k] = copy(v)
+        else
+            target[k] = v
+        end
+    end
 	setmetatable(target, meta)
 	return target
 end

libs/inspect.lua

@@ -0,0 +1,335 @@
+local inspect ={
+    _VERSION = 'inspect.lua 3.1.0',
+    _URL     = 'http://github.com/kikito/inspect.lua',
+    _DESCRIPTION = 'human-readable representations of tables',
+    _LICENSE = [[
+      MIT LICENSE
+  
+      Copyright (c) 2013 Enrique García Cota
+  
+      Permission is hereby granted, free of charge, to any person obtaining a
+      copy of this software and associated documentation files (the
+      "Software"), to deal in the Software without restriction, including
+      without limitation the rights to use, copy, modify, merge, publish,
+      distribute, sublicense, and/or sell copies of the Software, and to
+      permit persons to whom the Software is furnished to do so, subject to
+      the following conditions:
+  
+      The above copyright notice and this permission notice shall be included
+      in all copies or substantial portions of the Software.
+  
+      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+      OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    ]]
+  }
+  
+  local tostring = tostring
+  
+  inspect.KEY       = setmetatable({}, {__tostring = function() return 'inspect.KEY' end})
+  inspect.METATABLE = setmetatable({}, {__tostring = function() return 'inspect.METATABLE' end})
+  
+  local function rawpairs(t)
+    return next, t, nil
+  end
+  
+  -- Apostrophizes the string if it has quotes, but not aphostrophes
+  -- Otherwise, it returns a regular quoted string
+  local function smartQuote(str)
+    if str:match('"') and not str:match("'") then
+      return "'" .. str .. "'"
+    end
+    return '"' .. str:gsub('"', '\\"') .. '"'
+  end
+  
+  -- \a => '\\a', \0 => '\\0', 31 => '\31'
+  local shortControlCharEscapes = {
+    ["\a"] = "\\a",  ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
+    ["\r"] = "\\r",  ["\t"] = "\\t", ["\v"] = "\\v"
+  }
+  local longControlCharEscapes = {} -- \a => nil, \0 => \000, 31 => \031
+  for i=0, 31 do
+    local ch = string.char(i)
+    if not shortControlCharEscapes[ch] then
+      shortControlCharEscapes[ch] = "\\"..i
+      longControlCharEscapes[ch]  = string.format("\\%03d", i)
+    end
+  end
+  
+  local function escape(str)
+    return (str:gsub("\\", "\\\\")
+               :gsub("(%c)%f[0-9]", longControlCharEscapes)
+               :gsub("%c", shortControlCharEscapes))
+  end
+  
+  local function isIdentifier(str)
+    return type(str) == 'string' and str:match( "^[_%a][_%a%d]*$" )
+  end
+  
+  local function isSequenceKey(k, sequenceLength)
+    return type(k) == 'number'
+       and 1 <= k
+       and k <= sequenceLength
+       and math.floor(k) == k
+  end
+  
+  local defaultTypeOrders = {
+    ['number']   = 1, ['boolean']  = 2, ['string'] = 3, ['table'] = 4,
+    ['function'] = 5, ['userdata'] = 6, ['thread'] = 7
+  }
+  
+  local function sortKeys(a, b)
+    local ta, tb = type(a), type(b)
+  
+    -- strings and numbers are sorted numerically/alphabetically
+    if ta == tb and (ta == 'string' or ta == 'number') then return a < b end
+  
+    local dta, dtb = defaultTypeOrders[ta], defaultTypeOrders[tb]
+    -- Two default types are compared according to the defaultTypeOrders table
+    if dta and dtb then return defaultTypeOrders[ta] < defaultTypeOrders[tb]
+    elseif dta     then return true  -- default types before custom ones
+    elseif dtb     then return false -- custom types after default ones
+    end
+  
+    -- custom types are sorted out alphabetically
+    return ta < tb
+  end
+  
+  -- For implementation reasons, the behavior of rawlen & # is "undefined" when
+  -- tables aren't pure sequences. So we implement our own # operator.
+  local function getSequenceLength(t)
+    local len = 1
+    local v = rawget(t,len)
+    while v ~= nil do
+      len = len + 1
+      v = rawget(t,len)
+    end
+    return len - 1
+  end
+  
+  local function getNonSequentialKeys(t)
+    local keys, keysLength = {}, 0
+    local sequenceLength = getSequenceLength(t)
+    for k,_ in rawpairs(t) do
+      if not isSequenceKey(k, sequenceLength) then
+        keysLength = keysLength + 1
+        keys[keysLength] = k
+      end
+    end
+    table.sort(keys, sortKeys)
+    return keys, keysLength, sequenceLength
+  end
+  
+  local function countTableAppearances(t, tableAppearances)
+    tableAppearances = tableAppearances or {}
+  
+    if type(t) == 'table' then
+      if not tableAppearances[t] then
+        tableAppearances[t] = 1
+        for k,v in rawpairs(t) do
+          countTableAppearances(k, tableAppearances)
+          countTableAppearances(v, tableAppearances)
+        end
+        countTableAppearances(getmetatable(t), tableAppearances)
+      else
+        tableAppearances[t] = tableAppearances[t] + 1
+      end
+    end
+  
+    return tableAppearances
+  end
+  
+  local copySequence = function(s)
+    local copy, len = {}, #s
+    for i=1, len do copy[i] = s[i] end
+    return copy, len
+  end
+  
+  local function makePath(path, ...)
+    local keys = {...}
+    local newPath, len = copySequence(path)
+    for i=1, #keys do
+      newPath[len + i] = keys[i]
+    end
+    return newPath
+  end
+  
+  local function processRecursive(process, item, path, visited)
+    if item == nil then return nil end
+    if visited[item] then return visited[item] end
+  
+    local processed = process(item, path)
+    if type(processed) == 'table' then
+      local processedCopy = {}
+      visited[item] = processedCopy
+      local processedKey
+  
+      for k,v in rawpairs(processed) do
+        processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
+        if processedKey ~= nil then
+          processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
+        end
+      end
+  
+      local mt  = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
+      if type(mt) ~= 'table' then mt = nil end -- ignore not nil/table __metatable field
+      setmetatable(processedCopy, mt)
+      processed = processedCopy
+    end
+    return processed
+  end
+  
+  
+  
+  -------------------------------------------------------------------
+  
+  local Inspector = {}
+  local Inspector_mt = {__index = Inspector}
+  
+  function Inspector:puts(...)
+    local args   = {...}
+    local buffer = self.buffer
+    local len    = #buffer
+    for i=1, #args do
+      len = len + 1
+      buffer[len] = args[i]
+    end
+  end
+  
+  function Inspector:down(f)
+    self.level = self.level + 1
+    f()
+    self.level = self.level - 1
+  end
+  
+  function Inspector:tabify()
+    self:puts(self.newline, string.rep(self.indent, self.level))
+  end
+  
+  function Inspector:alreadyVisited(v)
+    return self.ids[v] ~= nil
+  end
+  
+  function Inspector:getId(v)
+    local id = self.ids[v]
+    if not id then
+      local tv = type(v)
+      id              = (self.maxIds[tv] or 0) + 1
+      self.maxIds[tv] = id
+      self.ids[v]     = id
+    end
+    return tostring(id)
+  end
+  
+  function Inspector:putKey(k)
+    if isIdentifier(k) then return self:puts(k) end
+    self:puts("[")
+    self:putValue(k)
+    self:puts("]")
+  end
+  
+  function Inspector:putTable(t)
+    if t == inspect.KEY or t == inspect.METATABLE then
+      self:puts(tostring(t))
+    elseif self:alreadyVisited(t) then
+      self:puts('<table ', self:getId(t), '>')
+    elseif self.level >= self.depth then
+      self:puts('{...}')
+    else
+      if self.tableAppearances[t] > 1 then self:puts('<', self:getId(t), '>') end
+  
+      local nonSequentialKeys, nonSequentialKeysLength, sequenceLength = getNonSequentialKeys(t)
+      local mt                = getmetatable(t)
+  
+      self:puts('{')
+      self:down(function()
+        local count = 0
+        for i=1, sequenceLength do
+          if count > 0 then self:puts(',') end
+          self:puts(' ')
+          self:putValue(t[i])
+          count = count + 1
+        end
+  
+        for i=1, nonSequentialKeysLength do
+          local k = nonSequentialKeys[i]
+          if count > 0 then self:puts(',') end
+          self:tabify()
+          self:putKey(k)
+          self:puts(' = ')
+          self:putValue(t[k])
+          count = count + 1
+        end
+  
+        if type(mt) == 'table' then
+          if count > 0 then self:puts(',') end
+          self:tabify()
+          self:puts('<metatable> = ')
+          self:putValue(mt)
+        end
+      end)
+  
+      if nonSequentialKeysLength > 0 or type(mt) == 'table' then -- result is multi-lined. Justify closing }
+        self:tabify()
+      elseif sequenceLength > 0 then -- array tables have one extra space before closing }
+        self:puts(' ')
+      end
+  
+      self:puts('}')
+    end
+  end
+  
+  function Inspector:putValue(v)
+    local tv = type(v)
+  
+    if tv == 'string' then
+      self:puts(smartQuote(escape(v)))
+    elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
+           tv == 'cdata' or tv == 'ctype' then
+      self:puts(tostring(v))
+    elseif tv == 'table' then
+      self:putTable(v)
+    else
+      self:puts('<', tv, ' ', self:getId(v), '>')
+    end
+  end
+  
+  -------------------------------------------------------------------
+  
+  function inspect.inspect(root, options)
+    options       = options or {}
+  
+    local depth   = options.depth   or math.huge
+    local newline = options.newline or '\n'
+    local indent  = options.indent  or '  '
+    local process = options.process
+  
+    if process then
+      root = processRecursive(process, root, {}, {})
+    end
+  
+    local inspector = setmetatable({
+      depth            = depth,
+      level            = 0,
+      buffer           = {},
+      ids              = {},
+      maxIds           = {},
+      newline          = newline,
+      indent           = indent,
+      tableAppearances = countTableAppearances(root)
+    }, Inspector_mt)
+  
+    inspector:putValue(root)
+  
+    return table.concat(inspector.buffer)
+  end
+  
+  setmetatable(inspect, { __call = function(_, ...) return inspect.inspect(...) end })
+  
+  return inspect
+  
+  

load/inspect.lua

@@ -0,0 +1 @@
+table.inspect = require "libs.inspect"

load/save.lua

@@ -35,6 +35,27 @@ function initConfig()
 	if config.secret == nil then config.secret = false end
 
 	if not config.gamesettings then config.gamesettings = {} end
+    if not config.gamemodesettings then config.gamemodesettings = {} end
+
+--[[
+    {
+        marathonA1 = {
+            allowHold = 1,
+            ...
+        }
+    }
+]]
+
+    for _, a in ipairs(game_modes) do
+        -- load config options for every mode
+        local mc = {}
+        local conf = a:provideSettings()
+        for i, j in pairs(conf) do
+            mc[j[1]] = (config.gamemodesettings[a.hash] or {})[j[1]] or 1
+        end
+        config.gamemodesettings[a.hash] = mc
+    end
+
 	for _, option in ipairs(GameConfigScene.options) do
 		if not config.gamesettings[option[1]] then
 			config.gamesettings[option[1]] = 1

main.lua

@@ -9,6 +9,7 @@ function love.load()
 	require "load.save"
 	require "load.bigint"
 	require "load.version"
+    require "load.inspect"
 	loadSave()
 	require "funcs"
 	require "scene"
@@ -18,19 +19,31 @@ function love.load()
 	--config["das_last_key"] = false
 	--config["fullscreen"] = false
 
+    runsystem = {
+        drawfps = 0,
+        updatefps = 0,
+        updatedelta = 0,
+        showperformancestatistics = false
+    }
+
 	love.window.setMode(love.graphics.getWidth(), love.graphics.getHeight(), {resizable = true});
 		
 	-- used for screenshots
 	GLOBAL_CANVAS = love.graphics.newCanvas()
 
+	-- import custom modules
+	initModules()
+
+    -- it is IMPORTANT that this comes before initConfig,
+    -- because modules' configuration options need to be
+    -- known at load-time!!! this will crash if this
+    -- is put back the way it used to be.
+
 	-- init config
 	initConfig()
 
 	love.window.setFullscreen(config["fullscreen"])
 	if config.secret then playSE("welcome") end
-
-	-- import custom modules
-	initModules()
 end
 
 function initModules()
@@ -74,6 +87,14 @@ function love.draw()
 	love.graphics.scale(scale_factor)
 		
 	scene:render()
+    
+    if runsystem.showperformancestatistics then
+        love.graphics.setColor(1, 1, 1, 1)
+        love.graphics.print('u='..tostring(runsystem.updatefps)..
+                            '\nd='..tostring(runsystem.drawfps)..
+                            '\ndel='..tostring(runsystem.updatedelta), 0, 0)
+    end
+
 	love.graphics.pop()
 		
 	love.graphics.setCanvas()
@@ -107,6 +128,9 @@ function love.keypressed(key, scancode)
 		end
 		print("Saving screenshot as "..ss_name)
 		GLOBAL_CANVAS:newImageData():encode("png", ss_name)
+    -- F9 toggles performance statistics for the new runsystem
+    elseif scancode == "f9" then
+        runsystem.showperformancestatistics = not runsystem.showperformancestatistics
 	-- function keys are reserved
 	elseif string.match(scancode, "^f[1-9]$") or string.match(scancode, "^f[1-9][0-9]+$") then
 		return	
@@ -273,7 +297,10 @@ function love.resize(w, h)
 end
 
 local TARGET_FPS = 60
+local TARGET_UPS = 1000
 
+--[[
+-- OLD RUN CODE BELOW
 function love.run()
 	if love.load then love.load(love.arg.parseGameArguments(arg), arg) end
 
@@ -324,3 +351,77 @@ function love.run()
 		last_time = love.timer.getTime()
 	end
 end
+]]
+
+function love.run()
+    -- New Run system
+    -- by rin
+    -- aims to speedup the responsiveness of the game by
+    -- only updating 60 times per second, but letting
+    -- it poll as fast as it wants
+
+    if not love.timer then
+        error('new run system requires love.timer to function.')
+    end
+
+    if love.load then love.load(love.arg.parseGameArguments(arg), arg) end
+
+	if love.timer then love.timer.step() end
+
+    local u_tacc = 0
+    local tacc = 0
+    local start_time = love.timer.getTime()
+
+    return function()
+        local ut = love.timer.getTime() 
+        runsystem.updatedelta = ut - start_time
+
+        if love.event then
+            u_tacc = u_tacc + runsystem.updatedelta
+            
+            if u_tacc >= 1 / TARGET_UPS then
+                runsystem.updatefps = 1 / u_tacc
+
+                if scene and scene.fastUpdate then
+                    scene:fastUpdate(u_tacc)
+                end
+
+                u_tacc = 0
+
+                love.event.pump()
+                for n, a, b, c, d, e, f in love.event.poll() do
+                    if n == 'quit' then
+                        if not love.quit or not love.quit() then
+                            return a or 0
+                        end
+                    end
+                    love.handlers[n](a, b, c, d, e, f)
+                end
+            end
+        end
+
+        if love.timer then
+			processBGMFadeout(love.timer.step())
+		end
+
+        if scene and scene.update and love.timer then
+            local delta = ut - start_time
+            start_time = ut
+            tacc = tacc + delta
+        
+            if tacc >= 1 / TARGET_FPS then
+                runsystem.drawfps = 1 / tacc
+                tacc = 0
+
+                scene:update()
+
+				if love.graphics and love.graphics.isActive() and love.draw then                    
+					love.graphics.origin()
+					love.graphics.clear(love.graphics.getBackgroundColor())
+					love.draw()
+					love.graphics.present()
+				end
+            end
+        end
+    end
+end

scene.lua

@@ -4,6 +4,7 @@ Scene = Object:extend()
 
 function Scene:new() end
 function Scene:update() end
+function Scene:fastUpdate(dt) end -- Equivalent to GameMode:fastUpdate(dt)
 function Scene:render() end
 function Scene:onInputPress() end
 function Scene:onInputRelease() end
@@ -19,3 +20,4 @@ TuningScene = require "scene.tuning"
 SettingsScene = require "scene.settings"
 CreditsScene = require "scene.credits"
 TitleScene = require "scene.title"
+GamemodeConfigScene = require "scene.gamemode_config"

scene/game.lua

@@ -8,7 +8,7 @@ function GameScene:new(game_mode, ruleset, inputs)
 	self.retry_mode = game_mode
 	self.retry_ruleset = ruleset
 	self.secret_inputs = inputs
-	self.game = game_mode(self.secret_inputs)
+	self.game = game_mode(self.secret_inputs, config.gamemodesettings[game_mode.hash])
 	self.ruleset = ruleset(self.game)
 	self.game:initialize(self.ruleset)
 	self.inputs = {
@@ -45,6 +45,10 @@ function GameScene:render()
 	self.game:draw(self.paused)
 end
 
+function GameScene:fastUpdate(d)
+    self.game:fastUpdate(d) -- Propagate the fast updates
+end
+
 function GameScene:onInputPress(e)
 	if (
 		self.game.game_over or self.game.completed

scene/gamemode_config.lua

@@ -0,0 +1,114 @@
+local GamemodeConfigScene = Scene:extend()
+
+GamemodeConfigScene.title = "Gamemode Configuration"
+
+local selected_mode = {}
+local mode_config = {}
+local new_config = {}
+local optioncount = 1
+
+function GamemodeConfigScene:new(gamemode)
+    selected_mode = gamemode
+    mode_config = gamemode:provideSettings() or {}
+    optioncount = #mode_config
+
+    print(selected_mode.hash)
+
+    self.highlight = 1
+
+    for i, j in pairs(mode_config) do
+        new_config[j[1]] = config.gamemodesettings[selected_mode.hash][j[1]] or 1
+    end
+
+    DiscordRPC:update({
+		details = "In menus",
+		state = "Configuring "..selected_mode.name,
+	})
+end
+
+function GamemodeConfigScene:save()
+    config.gamemodesettings[selected_mode.hash] = copy(new_config)
+end
+
+function GamemodeConfigScene:render()
+	love.graphics.setColor(1, 1, 1, 1)
+	love.graphics.draw(
+		backgrounds["game_config"],
+		0, 0, 0,
+		0.5, 0.5
+	)
+
+	love.graphics.setFont(font_3x5_4)
+	love.graphics.print(string.upper(selected_mode.name).." SETTINGS", 80, 40)
+    love.graphics.setFont(font_3x5_2)
+
+    if #mode_config == 0 then
+        love.graphics.print("This mode does not offer any settings.\n"..
+                            "Press Backspace to return to mode select.", 40, 100)
+        return
+    end
+
+    love.graphics.setColor(1, 1, 1, 0.5)
+	love.graphics.rectangle("fill", 25, 98 + self.highlight * 20, 170, 22)
+
+    for i, option in ipairs(mode_config) do
+        love.graphics.setColor(1, 1, 1, 1)
+        love.graphics.printf(option[2], 40, 100 + i * 20, 150, "left")
+
+        if #option[3] <= 4 then
+            for j, setting in ipairs(option[3]) do
+                love.graphics.setColor(1, 1, 1, new_config[option[1]] == j and 1 or 0.5)
+                love.graphics.printf(setting, 100 + 110 * j, 100 + i * 20, 100, "center")
+            end
+        else
+            local curr_index = new_config[option[1]]
+            local prev_index = Mod1(curr_index-1, #option[3])
+            local next_index = Mod1(curr_index+1, #option[3])
+
+            love.graphics.setColor(1, 1, 1, 0.5)
+            love.graphics.printf("<<< "..option[3][prev_index],
+                                 100 + 110 * 1, 100 + i * 20, 100, 'center')
+
+            love.graphics.setColor(1, 1, 1, 1)
+            love.graphics.printf(option[3][curr_index],
+                                100 + 110 * 2.5, 100 + i * 20, 100, 'center')
+
+            love.graphics.setColor(1, 1, 1, 0.5)
+            love.graphics.printf(option[3][next_index].." >>>",
+                                 100 + 110 * 4, 100 + i * 20, 100, 'center')
+
+            love.graphics.setColor(1, 1, 1, 1)
+        end
+	end
+end
+
+function GamemodeConfigScene:onInputPress(e)
+    if e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
+        scene = ModeSelectScene()
+    elseif e.input == "menu_decide" then
+        playSE("mode_decide")
+        self:save()
+        saveConfig()
+        scene = ModeSelectScene()
+    end
+
+    if #mode_config == 0 then return end
+
+    if e.input == "up" or e.scancode == "up" then
+        playSE("cursor")
+        self.highlight = Mod1(self.highlight-1, optioncount)
+    elseif e.input == "down" or e.scancode == "down" then
+        playSE("cursor")
+        self.highlight = Mod1(self.highlight+1, optioncount)
+    elseif e.input == "left" or e.scancode == "left" then
+        playSE("cursor_lr")
+        local option = mode_config[self.highlight]
+        new_config[option[1]] = Mod1(new_config[option[1]]-1, #option[3])
+    elseif e.input == "right" or e.scancode == "right" then
+        playSE("cursor_lr")
+        local option = mode_config[self.highlight]
+        new_config[option[1]] = Mod1(new_config[option[1]]+1, #option[3])
+    end
+end
+
+return GamemodeConfigScene

scene/mode_select.lua

@@ -87,6 +87,12 @@ function ModeSelectScene:onInputPress(e)
 		playSE("cursor_lr")
 	elseif e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
 		scene = TitleScene()
+    elseif e.input == "hold" or e.scancode == "tab" then
+		current_mode = self.menu_state.mode
+		current_ruleset = self.menu_state.ruleset
+		config.current_mode = current_mode
+		config.current_ruleset = current_ruleset
+        scene = GamemodeConfigScene(game_modes[self.menu_state.mode])
 	elseif e.input then
 		self.secret_inputs[e.input] = true
 	end

tetris/modes/big_a2.lua

@@ -7,8 +7,8 @@ BigA2Game.name = "Big A2"
 BigA2Game.hash = "BigA2"
 BigA2Game.tagline = "Big blocks in the most celebrated TGM mode!"
 
-function BigA2Game:new()
+function BigA2Game:new(_, c)
-	BigA2Game.super:new()
+	BigA2Game.super:new(_, c)
 	self.big_mode = true
 end
 

tetris/modes/gamemode.lua

@@ -15,7 +15,7 @@ GameMode.hash = ""
 GameMode.tagline = ""
 GameMode.rollOpacityFunction = function(age) return 0 end
 
-function GameMode:new(secret_inputs)
+function GameMode:new(secret_inputs, config)
 	self.grid = Grid(10, 24)
 	self.randomizer = Randomizer()
 	self.piece = nil
@@ -72,6 +72,8 @@ function GameMode:new(secret_inputs)
 	self.section_start_time = 0
 	self.section_times = { [0] = 0 }
 	self.secondary_section_times = { [0] = 0 }
+    
+    self.config = config
 end
 
 function GameMode:getARR() return 1 end
@@ -946,4 +948,15 @@ function GameMode:draw(paused)
 	end
 end
 
+function GameMode:provideSettings()
+    return {} 
+end
+
+-- This function is called on every love.event.poll
+-- aka up to the UPS specified in main.lua.
+-- By default this is 1000, so this function will run
+-- up to 1000 times per second! Don't do anything
+-- expensive in here, as this WILL slow the game down.
+function GameMode:fastUpdate(deltaTime) end
+
 return GameMode

tetris/modes/marathon_a1.lua

@@ -14,8 +14,8 @@ MarathonA1Game.tagline = "Can you score enough points to reach the title of Gran
 
 
 
-function MarathonA1Game:new()
+function MarathonA1Game:new(_, cfg)
-	MarathonA1Game.super:new()
+	MarathonA1Game.super:new(_, cfg)
 	
 	self.roll_frames = 0
 	self.combo = 1
@@ -35,9 +35,9 @@ function MarathonA1Game:new()
 
 	self.additive_gravity = false
 	self.lock_drop = false
-	self.enable_hard_drop = false
+	self.enable_hard_drop = self.config.allowHardDrop == 2
-	self.enable_hold = false
+	self.enable_hold = self.config.allowHold == 2
-	self.next_queue_length = 1
+	self.next_queue_length = self.config.nextQueue == 2 and 3 or 1
 end
 
 function MarathonA1Game:getARE()
@@ -247,4 +247,23 @@ function MarathonA1Game:getHighscoreData()
 	}
 end
 
+function MarathonA1Game:provideSettings()
+    local t = {
+        {"allowHold", "Allow hold", {"No", "Yes"}},
+        {"nextQueue", "Next pieces", {"One", "Three"}},
+        {"allowHardDrop", "Allow hard drop", {"No", "Yes"}}
+    }
+
+--[[
+    local opts = {}
+    for i=1, 10 do
+        opts[i] = i
+    end
+
+    table.insert(t, {"manyOptions", "Many options", opts})
+]]
+
+    return t
+end
+
 return MarathonA1Game

tetris/modes/marathon_a2.lua

@@ -14,8 +14,8 @@ MarathonA2Game.tagline = "The points don't matter! Can you reach the invisible r
 
 
 
-function MarathonA2Game:new()
+function MarathonA2Game:new(_, cfg)
-	MarathonA2Game.super:new()
+	MarathonA2Game.super:new(_, cfg)
 
 	self.roll_frames = 0
 	self.combo = 1
@@ -38,8 +38,8 @@ function MarathonA2Game:new()
 	self.additive_gravity = false
 	self.lock_drop = false
 	self.lock_hard_drop = false
-	self.enable_hold = false
+	self.enable_hold = cfg.allowHold == 2
-	self.next_queue_length = 1
+	self.next_queue_length = cfg.nextQueue == 2 and 3 or 1
 end
 
 function MarathonA2Game:getARE()
@@ -403,4 +403,11 @@ function MarathonA2Game:getBackground()
 	return math.floor(self.level / 100)
 end
 
+function MarathonA2Game:provideSettings()
+    return {
+        {"allowHold", "Allow hold", {"No", "Yes"}},
+        {"nextQueue", "Next pieces", {"One", "Three"}}
+    }
+end
+
 return MarathonA2Game

tetris/modes/survival_a2.lua

@@ -14,8 +14,8 @@ SurvivalA2Game.tagline = "The game starts fast and only gets faster!"
 
 
 
-function SurvivalA2Game:new()
+function SurvivalA2Game:new(_, cfg)
-	SurvivalA2Game.super:new()
+	SurvivalA2Game.super:new(_, cfg)
 	self.roll_frames = 0
 	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
@@ -28,6 +28,8 @@ function SurvivalA2Game:new()
 
 	self.lock_drop = true
 	self.lock_hard_drop = true
+    self.enable_hold = cfg.allowHold == 2
+	self.next_queue_length = cfg.nextQueue == 2 and 3 or 1
 end
 
 function SurvivalA2Game:getARE()
@@ -185,4 +187,11 @@ function SurvivalA2Game:getHighscoreData()
 	}
 end
 
+function SurvivalA2Game:provideSettings()
+    return {
+        {"allowHold", "Allow hold", {"No", "Yes"}},
+        {"nextQueue", "Next pieces", {"One", "Three"}}
+    }
+end
+
 return SurvivalA2Game