text was slightly off-center

This only applies to modes that allow it.
This feature does not apply to main modes (yet)

.gitignore

@@ -2,3 +2,5 @@
 *.love
 dist/*.zip
 dist/**/cambridge.exe
+dist/**/libs
+dist/**/*.md

README.md

@@ -1,33 +1,65 @@
+![Cambridge Banner](https://cdn.discordapp.com/attachments/764432435802013709/767724895076614154/cambridge_logo_lt.png)
+
+Important notice
+================
+
+![Tetra Online Notice](https://pbs.twimg.com/media/Eo3CkIHW8AEoK_U?format=png&name=small)
+
 Cambridge
 =========
 
 Welcome to Cambridge, the next open-source falling-block game engine!
 
+This fork is written and maintained exclusively by [SashLilac](https://github.com/SashLilac), [joezeng](https://github.com/joezeng) and [Oshisaure](https://github.com/oshisaure)!
 
-Installation instructions
--------------------------
+Join our Discord server for help and a welcoming community! https://discord.gg/mteMJw4
 
-Pre-built releases are available on the releases page.
+Credits
+-------
+
+- [Lilla Oshisaure](https://www.youtube.com/user/LeSpyroshisaure) for being my co-dev!
+- [joezeng](https://github.com/joezeng) for the original project, and for offering to help with the expansion!
+- [The Tetra Legends Discord](http://discord.com/invite/7hMx5r2) for supporting me and playtesting!
+- [The Absolute Plus](https://discord.gg/6Gf2awJ) for being another source of motivation!
+
+The following people in no particular order also helped with the project:
+- [Hailey](https://github.com/haileylgbt)
+- CylinderKnot
+- MarkGamed7794
+- [Mizu](https://github.com/rexxt)
+- MattMayuga
+- Kitaru
+- switchpalacecorner
+- [sinefuse](https://github.com/sinefuse)
+- [2Tie](https://github.com/2Tie)
+- [nightmareci](https://github.com/nightmareci)
+- [MyPasswordIsWeak](https://github.com/MyPasswordIsWeak)
+- [Dr Ocelot](https://github.com/Dr-Ocelot)
+
+![Cambridge Logo](https://cdn.discordapp.com/attachments/625496179433668635/763363717730664458/Icon_2.png)
+
+Playing the game
+----------------
 
 ### Windows
 
-Unzip the exe file and run it directly. All assets are currently bundled inside the executable.
+You do not need LÖVE on Windows, as it comes bundled with the program.  
 
-### macOS
+To get the stable release, simply download the ZIP in the latest release. All assets needed are bundled with the executable.
 
-For the time being, the file `cambridge.love` only works on the command line. Install `love` with [https://brew.sh/](Homebrew), and run:
+If you want the bleeding edge version, download [this](https://github.com/SashLilac/cambridge/archive/master.zip).
 
-    $ love cambridge.love
+Extract the ZIP, open a Command Prompt at the folder you extracted Cambridge to, then run this command:
 
-### Linux
+	dist\windows\love.exe .
 
-Same as macOS, except install `love` with your favourite package manager.
+Alternatively, if you're on a 32-bit system, run this instead:
 
+	dist\win32\love.exe .
 
-Running from source
--------------------
+32-bit systems do not support rich presence integration.
 
-If you want the bleeding-edge release, you can also clone the code straight from this repository.
+Then, check the mod pack section at the bottom of this page.
 
 ### macOS, Linux
 
@@ -35,14 +67,21 @@ If you haven't already, install `love` with your favourite package manager (Home
 
 Clone the repository in git:
 
-    git clone https://github.com/joezeng/cambridge
+	git clone https://github.com/SashLilac/cambridge
+
+Alternatively, download the source code ZIP in the latest release.
 
 Then, navigate to the root directory that you just cloned, and type:
 
-    love .
+	love .
 
 It should run automatically!
 
+## Installing modpacks
+
+Simply drag your mode, ruleset, and randomizer Lua files into their respective [directory](https://love2d.org/wiki/love.filesystem), and they should appear automatically.  
+
+For more detailed instructions, install [this](https://github.com/SashLilac/cambridge-modpack) mod pack to get a taste of the mod potential.
 
 License
 -------

SOURCES.md

@@ -8,7 +8,7 @@ Some of the assets are used without proper licenses. We aim to have fully licens
 Backgrounds
 -----------
 
-1. Title: "Motus Glacies." Contributed by Daniel "Explo" McCarthy.
+1. Title: Original picrute found on the Wikipedia article for Cambridge
 
 1. *Gameplay level 0: "Quantum foam." Alex Sukontsev. https://www.flickr.com/photos/control9/14957509814/
 2. *Gameplay level 1: No name. http://www.onekind.tv/univision-mqb/q5mqh5brlvuuj2nhdx7ch7eum183uu
@@ -34,6 +34,14 @@ Backgrounds
 Backgrounds marked with a * are placeholders that will be replaced in later versions due to incompatible licenses. We are generally aiming for public domain background images, but will also accept backgrounds given proper licenses to be included within Cambridge.
 
 
+Sounds
+------
+
+All piece sounds are (c) 2020 Damian Yerrick.
+Other sounds from:
+- NullpoMino
+- DTET, (c) 2003 Mihys.
+
 Music
 -----
 
@@ -106,3 +114,29 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 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.
+
+simple-slider (https://love2d.org/forums/viewtopic.php?t=80711)
+--------------------
+
+Copyright (c) 2016 George Prosser
+
+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.

clean.bat

@@ -0,0 +1,11 @@
+@del cambridge.love
+@del dist\windows\cambridge.exe
+@del dist\windows\SOURCES.md
+@del dist\windows\LICENSE.md
+@rmdir /Q /S dist\windows\libs
+@del dist\win32\cambridge.exe
+@del dist\win32\SOURCES.md
+@del dist\win32\LICENSE.md
+@rmdir /Q /S dist\win32\libs
+@del dist\cambridge-windows.zip
+@del dist\cambridge-win32.zip

docs/gamemodes.md

@@ -4,17 +4,17 @@ Game modes
 There are several classes of game modes. The modes that originate from other games are organized by suffix:
 
 * The "C" series stand for "Classic" games, games that were produced before around 1992-1993 and generally have no wallkicks or lock delay.
-    * C84 - The original version from the Electronika 60.
-    * C88 - Sega Tetris.
-    * C89 - Nintendo / NES Tetris.
+	* C84 - The original version from the Electronika 60.
+	* C88 - Sega Tetris.
+	* C89 - Nintendo / NES Tetris.
 * The "A" series stand for "Arika" games, or games in the Tetris the Grand Master series.
-    * A1 - Tetris The Grand Master (the original from 1998).
-    * A2 - Tetris The Absolute The Grand Master 2 PLUS.
-    * A3 - Tetris The Grand Master 3 Terror-Instinct.
-    * AX - Tetris The Grand Master ACE (X for Xbox).
+	* A1 - Tetris The Grand Master (the original from 1998).
+	* A2 - Tetris The Absolute The Grand Master 2 PLUS.
+	* A3 - Tetris The Grand Master 3 Terror-Instinct.
+	* AX - Tetris The Grand Master ACE (X for Xbox).
 * The "G" series stand for "Guideline" games, or games that follow the Tetris Guideline.
-    * GF - Tetris Friends (2007-2019)
-    * GJ - Tetris Online Japan (2005-2011)
+	* GF - Tetris Friends (2007-2019)
+	* GJ - Tetris Online Japan (2005-2011)
 * N stands for Nullpomino, only used for Phantom Mania N.
 
 MARATHON

funcs.lua

@@ -1,13 +1,15 @@
 function copy(t)
+	-- returns deep copy of t (as opposed to the shallow copy you get from var = 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
-    setmetatable(target, meta)
-    return target
+	local meta = getmetatable(t)
+	local target = {}
+	for k, v in pairs(t) do target[k] = v end
+	setmetatable(target, meta)
+	return target
 end
 
-function st(tbl)
+function strTrueValues(tbl)
+	-- returns a concatenation of all the keys in tbl with value true, separated with spaces
 	str = ""
 	for k, v in pairs(tbl) do
 		if v == true then
@@ -17,14 +19,16 @@ function st(tbl)
 	return str
 end
 
-function sp(m, s, f)
-	if m == nil then m = 0 end
-	if s == nil then s = 0 end
-	if f == nil then f = 0 end
-	return m*3600 + s*60 + math.ceil(f * 0.6)
+function frameTime(min, sec, hth)
+	-- returns a time in frames from a time in minutes-seconds-hundredths format
+	if min == nil then min = 0 end
+	if sec == nil then sec = 0 end
+	if hth == nil then hth = 0 end
+	return min*3600 + sec*60 + math.ceil(hth * 0.6)
 end
 
 function vAdd(v1, v2)
+	-- returns the sum of vectors v1 and v2
 	return {
 		x = v1.x + v2.x,
 		y = v1.y + v2.y
@@ -32,6 +36,7 @@ function vAdd(v1, v2)
 end
 
 function vNeg(v)
+	-- returns the opposite of vector v
 	return {
 		x = -v.x,
 		y = -v.y
@@ -39,17 +44,26 @@ function vNeg(v)
 end
 
 function formatTime(frames)
+	-- returns a mm:ss:hh (h=hundredths) representation of the time in frames given 
 	if frames < 0 then return formatTime(0) end
-	str = string.format("%02d", math.floor(frames / 3600)) .. ":"
-		.. string.format("%02d", math.floor(frames / 60) % 60) .. "."
-		.. string.format("%02d", math.floor(frames / 0.6) % 100)
+	local min, sec, hund
+	min  = math.floor(frames/3600)
+	sec  = math.floor(frames/60) % 60
+	hund = math.floor(frames/.6) % 100
+	str = string.format("%02d:%02d.%02d", min, sec, hund)
 	return str
 end
 
 function formatBigNum(number)
+	-- returns a string representing a number with commas as thousands separator (e.g. 12,345,678)
 	local s = string.format("%d", number)
 	local pos = string.len(s) % 3
 	if pos == 0 then pos = 3 end
 	return string.sub(s, 1, pos)
 		.. string.gsub(string.sub(s, pos+1), "(...)", ",%1")
+end
+
+function Mod1(n, m)
+	-- returns a number congruent to n modulo m in the range [1;m] (as opposed to [0;m-1])
+	return ((n-1) % m) + 1
 end

libs/discordRPC.lua

@@ -0,0 +1,282 @@
+local ffi = require "ffi"
+
+
+-- Get the host os to load correct lib
+local osname = love.system.getOS()
+local discordRPClib = nil
+
+-- FFI requires the libraries really be files just sitting in the filesystem. It
+-- can't load libraries from a .love archive, nor a fused executable on Windows.
+-- Merely using love.filesystem.getSource() only works when running LOVE with
+-- the game unarchived from command line, like "love .".
+--
+-- The code here setting "source" will set the directory where the game was run
+-- from, so FFI can load discordRPC. We assume that the discordRPC library's
+-- libs directory is in the same directory as the .love archive; if it's
+-- missing, it just won't load.
+local source = love.filesystem.getSource()
+if string.sub(source, -5) == ".love" or love.filesystem.isFused() then
+    source = love.filesystem.getSourceBaseDirectory()
+end
+
+if osname == "Linux" then
+    discordRPClib = ffi.load(source.."/libs/discord-rpc.so")
+elseif osname == "OS X" then
+    discordRPClib = ffi.load(source.."/libs/discord-rpc.dylib")
+elseif osname == "Windows" then
+    discordRPClib = ffi.load(source.."/libs/discord-rpc.dll")
+else
+    -- Else it crashes later on
+    error(string.format("Discord rpc not supported on platform (%s)", osname))
+end
+
+
+ffi.cdef[[
+typedef struct DiscordRichPresence {
+    const char* state;   /* max 128 bytes */
+    const char* details; /* max 128 bytes */
+    int64_t startTimestamp;
+    int64_t endTimestamp;
+    const char* largeImageKey;  /* max 32 bytes */
+    const char* largeImageText; /* max 128 bytes */
+    const char* smallImageKey;  /* max 32 bytes */
+    const char* smallImageText; /* max 128 bytes */
+    const char* partyId;        /* max 128 bytes */
+    int partySize;
+    int partyMax;
+    const char* matchSecret;    /* max 128 bytes */
+    const char* joinSecret;     /* max 128 bytes */
+    const char* spectateSecret; /* max 128 bytes */
+    int8_t instance;
+} DiscordRichPresence;
+
+typedef struct DiscordUser {
+    const char* userId;
+    const char* username;
+    const char* discriminator;
+    const char* avatar;
+} DiscordUser;
+
+typedef void (*readyPtr)(const DiscordUser* request);
+typedef void (*disconnectedPtr)(int errorCode, const char* message);
+typedef void (*erroredPtr)(int errorCode, const char* message);
+typedef void (*joinGamePtr)(const char* joinSecret);
+typedef void (*spectateGamePtr)(const char* spectateSecret);
+typedef void (*joinRequestPtr)(const DiscordUser* request);
+
+typedef struct DiscordEventHandlers {
+    readyPtr ready;
+    disconnectedPtr disconnected;
+    erroredPtr errored;
+    joinGamePtr joinGame;
+    spectateGamePtr spectateGame;
+    joinRequestPtr joinRequest;
+} DiscordEventHandlers;
+
+void Discord_Initialize(const char* applicationId,
+                        DiscordEventHandlers* handlers,
+                        int autoRegister,
+                        const char* optionalSteamId);
+
+void Discord_Shutdown(void);
+
+void Discord_RunCallbacks(void);
+
+void Discord_UpdatePresence(const DiscordRichPresence* presence);
+
+void Discord_ClearPresence(void);
+
+void Discord_Respond(const char* userid, int reply);
+
+void Discord_UpdateHandlers(DiscordEventHandlers* handlers);
+]]
+
+local discordRPC = {} -- module table
+
+-- proxy to detect garbage collection of the module
+discordRPC.gcDummy = newproxy(true)
+
+local function unpackDiscordUser(request)
+    return ffi.string(request.userId), ffi.string(request.username),
+        ffi.string(request.discriminator), ffi.string(request.avatar)
+end
+
+-- callback proxies
+-- note: callbacks are not JIT compiled (= SLOW), try to avoid doing performance critical tasks in them
+-- luajit.org/ext_ffi_semantics.html
+local ready_proxy = ffi.cast("readyPtr", function(request)
+    if discordRPC.ready then
+        discordRPC.ready(unpackDiscordUser(request))
+    end
+end)
+
+local disconnected_proxy = ffi.cast("disconnectedPtr", function(errorCode, message)
+    if discordRPC.disconnected then
+        discordRPC.disconnected(errorCode, ffi.string(message))
+    end
+end)
+
+local errored_proxy = ffi.cast("erroredPtr", function(errorCode, message)
+    if discordRPC.errored then
+        discordRPC.errored(errorCode, ffi.string(message))
+    end
+end)
+
+local joinGame_proxy = ffi.cast("joinGamePtr", function(joinSecret)
+    if discordRPC.joinGame then
+        discordRPC.joinGame(ffi.string(joinSecret))
+    end
+end)
+
+local spectateGame_proxy = ffi.cast("spectateGamePtr", function(spectateSecret)
+    if discordRPC.spectateGame then
+        discordRPC.spectateGame(ffi.string(spectateSecret))
+    end
+end)
+
+local joinRequest_proxy = ffi.cast("joinRequestPtr", function(request)
+    if discordRPC.joinRequest then
+        discordRPC.joinRequest(unpackDiscordUser(request))
+    end
+end)
+
+-- helpers
+local function checkArg(arg, argType, argName, func, maybeNil)
+    assert(type(arg) == argType or (maybeNil and arg == nil),
+        string.format("Argument \"%s\" to function \"%s\" has to be of type \"%s\"",
+            argName, func, argType))
+end
+
+local function checkStrArg(arg, maxLen, argName, func, maybeNil)
+    if maxLen then
+        assert(type(arg) == "string" and arg:len() <= maxLen or (maybeNil and arg == nil),
+            string.format("Argument \"%s\" of function \"%s\" has to be of type string with maximum length %d",
+                argName, func, maxLen))
+    else
+        checkArg(arg, "string", argName, func, true)
+    end
+end
+
+local function checkIntArg(arg, maxBits, argName, func, maybeNil)
+    maxBits = math.min(maxBits or 32, 52) -- lua number (double) can only store integers < 2^53
+    local maxVal = 2^(maxBits-1) -- assuming signed integers, which, for now, are the only ones in use
+    assert(type(arg) == "number" and math.floor(arg) == arg
+        and arg < maxVal and arg >= -maxVal
+        or (maybeNil and arg == nil),
+        string.format("Argument \"%s\" of function \"%s\" has to be a whole number <= %d",
+            argName, func, maxVal))
+end
+
+-- function wrappers
+function discordRPC.initialize(applicationId, autoRegister, optionalSteamId)
+    local func = "discordRPC.Initialize"
+    checkStrArg(applicationId, nil, "applicationId", func)
+    checkArg(autoRegister, "boolean", "autoRegister", func)
+    if optionalSteamId ~= nil then
+        checkStrArg(optionalSteamId, nil, "optionalSteamId", func)
+    end
+
+    local eventHandlers = ffi.new("struct DiscordEventHandlers")
+    eventHandlers.ready = ready_proxy
+    eventHandlers.disconnected = disconnected_proxy
+    eventHandlers.errored = errored_proxy
+    eventHandlers.joinGame = joinGame_proxy
+    eventHandlers.spectateGame = spectateGame_proxy
+    eventHandlers.joinRequest = joinRequest_proxy
+
+    discordRPClib.Discord_Initialize(applicationId, eventHandlers,
+        autoRegister and 1 or 0, optionalSteamId)
+end
+
+function discordRPC.shutdown()
+    discordRPClib.Discord_Shutdown()
+end
+
+function discordRPC.runCallbacks()
+    discordRPClib.Discord_RunCallbacks()
+end
+-- http://luajit.org/ext_ffi_semantics.html#callback :
+-- It is not allowed, to let an FFI call into a C function (runCallbacks)
+-- get JIT-compiled, which in turn calls a callback, calling into Lua again (e.g. discordRPC.ready).
+-- Usually this attempt is caught by the interpreter first and the C function
+-- is blacklisted for compilation.
+-- solution:
+-- "Then you'll need to manually turn off JIT-compilation with jit.off() for
+-- the surrounding Lua function that invokes such a message polling function."
+jit.off(discordRPC.runCallbacks)
+
+function discordRPC.updatePresence(presence)
+    local func = "discordRPC.updatePresence"
+    checkArg(presence, "table", "presence", func)
+
+    -- -1 for string length because of 0-termination
+    checkStrArg(presence.state, 127, "presence.state", func, true)
+    checkStrArg(presence.details, 127, "presence.details", func, true)
+
+    checkIntArg(presence.startTimestamp, 64, "presence.startTimestamp", func, true)
+    checkIntArg(presence.endTimestamp, 64, "presence.endTimestamp", func, true)
+
+    checkStrArg(presence.largeImageKey, 31, "presence.largeImageKey", func, true)
+    checkStrArg(presence.largeImageText, 127, "presence.largeImageText", func, true)
+    checkStrArg(presence.smallImageKey, 31, "presence.smallImageKey", func, true)
+    checkStrArg(presence.smallImageText, 127, "presence.smallImageText", func, true)
+    checkStrArg(presence.partyId, 127, "presence.partyId", func, true)
+
+    checkIntArg(presence.partySize, 32, "presence.partySize", func, true)
+    checkIntArg(presence.partyMax, 32, "presence.partyMax", func, true)
+
+    checkStrArg(presence.matchSecret, 127, "presence.matchSecret", func, true)
+    checkStrArg(presence.joinSecret, 127, "presence.joinSecret", func, true)
+    checkStrArg(presence.spectateSecret, 127, "presence.spectateSecret", func, true)
+
+    checkIntArg(presence.instance, 8, "presence.instance", func, true)
+
+    local cpresence = ffi.new("struct DiscordRichPresence")
+    cpresence.state = presence.state
+    cpresence.details = presence.details
+    cpresence.startTimestamp = presence.startTimestamp or 0
+    cpresence.endTimestamp = presence.endTimestamp or 0
+    cpresence.largeImageKey = presence.largeImageKey
+    cpresence.largeImageText = presence.largeImageText
+    cpresence.smallImageKey = presence.smallImageKey
+    cpresence.smallImageText = presence.smallImageText
+    cpresence.partyId = presence.partyId
+    cpresence.partySize = presence.partySize or 0
+    cpresence.partyMax = presence.partyMax or 0
+    cpresence.matchSecret = presence.matchSecret
+    cpresence.joinSecret = presence.joinSecret
+    cpresence.spectateSecret = presence.spectateSecret
+    cpresence.instance = presence.instance or 0
+
+    discordRPClib.Discord_UpdatePresence(cpresence)
+end
+
+function discordRPC.clearPresence()
+    discordRPClib.Discord_ClearPresence()
+end
+
+local replyMap = {
+    no = 0,
+    yes = 1,
+    ignore = 2
+}
+
+-- maybe let reply take ints too (0, 1, 2) and add constants to the module
+function discordRPC.respond(userId, reply)
+    checkStrArg(userId, nil, "userId", "discordRPC.respond")
+    assert(replyMap[reply], "Argument 'reply' to discordRPC.respond has to be one of \"yes\", \"no\" or \"ignore\"")
+    discordRPClib.Discord_Respond(userId, replyMap[reply])
+end
+
+-- garbage collection callback
+getmetatable(discordRPC.gcDummy).__gc = function()
+    discordRPC.shutdown()
+    ready_proxy:free()
+    disconnected_proxy:free()
+    errored_proxy:free()
+    joinGame_proxy:free()
+    spectateGame_proxy:free()
+    joinRequest_proxy:free()
+end
+
+return discordRPC

libs/simple-slider.lua

@@ -0,0 +1,138 @@
+--[[
+Copyright (c) 2016 George Prosser
+
+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 slider = {}
+slider.__index = slider
+
+function newSlider(x, y, length, value, min, max, setter, style)
+    local s = {}
+    s.value = (value - min) / (max - min)
+    s.min = min
+    s.max = max
+    s.setter = setter
+    s.x = x
+    s.y = y
+    s.length = length
+
+    local p = style or {}
+    s.width = p.width or length * 0.1
+    s.orientation = p.orientation or 'horizontal'
+    s.track = p.track or 'rectangle'
+    s.knob = p.knob or 'rectangle'
+
+    s.grabbed = false
+    s.wasDown = true
+    s.ox = 0
+    s.oy = 0
+
+    return setmetatable(s, slider)
+end
+
+function slider:update(mouseX, mouseY, mouseDown)
+    local x = mouseX or love.mouse.getX()
+    local y = mouseY or love.mouse.getY()
+    local down = love.mouse.isDown(1)
+    if mouseDown ~= nil then
+        down = mouseDown
+    end
+
+    local knobX = self.x
+    local knobY = self.y
+    if self.orientation == 'horizontal' then
+        knobX = self.x - self.length/2 + self.length * self.value
+    elseif self.orientation == 'vertical' then
+        knobY = self.y + self.length/2 - self.length * self.value
+    end
+
+    local ox = x - knobX
+    local oy = y - knobY
+
+    local dx = ox - self.ox
+    local dy = oy - self.oy
+
+    if down then
+        if self.grabbed then
+            if self.orientation == 'horizontal' then
+                self.value = self.value + dx / self.length
+            elseif self.orientation == 'vertical' then
+                self.value = self.value - dy / self.length
+            end
+        elseif (x > knobX - self.width/2 and x < knobX + self.width/2 and y > knobY - self.width/2 and y < knobY + self.width/2) and not self.wasDown then
+            self.ox = ox
+            self.oy = oy
+            self.grabbed = true
+        end
+    else
+        self.grabbed = false
+    end
+
+    self.value = math.max(0, math.min(1, self.value))
+
+    if self.setter ~= nil then
+        self.setter(self.min + self.value * (self.max - self.min))
+    end
+
+    self.wasDown = down
+end
+
+function slider:draw()
+    if self.track == 'rectangle' then
+        if self.orientation == 'horizontal' then
+            love.graphics.rectangle('line', self.x - self.length/2 - self.width/2, self.y - self.width/2, self.length + self.width, self.width)
+        elseif self.orientation == 'vertical' then
+            love.graphics.rectangle('line', self.x - self.width/2, self.y - self.length/2 - self.width/2, self.width, self.length + self.width)
+        end
+    elseif self.track == 'line' then
+        if self.orientation == 'horizontal' then
+            love.graphics.line(self.x - self.length/2, self.y, self.x + self.length/2, self.y)
+        elseif self.orientation == 'vertical' then
+            love.graphics.line(self.x, self.y - self.length/2, self.x, self.y + self.length/2)
+        end
+    elseif self.track == 'roundrect' then
+        if self.orientation == 'horizontal' then
+            love.graphics.rectangle('line', self.x - self.length/2 - self.width/2, self.y - self.width/2, self.length + self.width, self.width, self.width/2, self.width)
+        elseif self.orientation == 'vertical' then
+            love.graphics.rectangle('line', self.x - self.width/2, self.y - self.length/2 - self.width/2, self.width, self.length + self.width, self.width, self.width/2)
+        end
+    end
+
+    local knobX = self.x
+    local knobY = self.y
+    if self.orientation == 'horizontal' then
+        knobX = self.x - self.length/2 + self.length * self.value
+    elseif self.orientation == 'vertical' then
+        knobY = self.y + self.length/2 - self.length * self.value
+    end
+
+    if self.knob == 'rectangle' then
+        love.graphics.rectangle('fill', knobX - self.width/2, knobY - self.width/2, self.width, self.width)
+    elseif self.knob == 'circle' then
+        love.graphics.circle('fill', knobX, knobY, self.width/2)
+    end
+end
+
+function slider:getValue()
+    return self.min + self.value * (self.max - self.min)
+end

load/bgm.lua

@@ -47,7 +47,7 @@ function fadeoutBGM(time)
 end
 
 function resetBGMFadeout(time)
-	current_bgm:setVolume(1)
+	current_bgm:setVolume(config.bgm_volume)
 	fading_bgm = false
 	current_bgm:play()
 end
@@ -59,7 +59,7 @@ function processBGMFadeout(dt)
 			fadeout_time = 0
 			fading_bgm = false
 		end
-		current_bgm:setVolume(fadeout_time / total_fadeout_time)
+		current_bgm:setVolume(fadeout_time * config.bgm_volume / total_fadeout_time)
 	end
 end
 

load/graphics.lua

@@ -1,54 +1,77 @@
 backgrounds = {
-	[0] = love.graphics.newImage("res/backgrounds/0-quantum-foam.png"),
-	love.graphics.newImage("res/backgrounds/100-big-bang.png"),
-	love.graphics.newImage("res/backgrounds/200-spiral-galaxy.png"),
-	love.graphics.newImage("res/backgrounds/300-sun-and-dust.png"),
-	love.graphics.newImage("res/backgrounds/400-earth-and-moon.png"),
-	love.graphics.newImage("res/backgrounds/500-cambrian-explosion.png"),
-	love.graphics.newImage("res/backgrounds/600-dinosaurs.png"),
-	love.graphics.newImage("res/backgrounds/700-asteroid.png"),
-	love.graphics.newImage("res/backgrounds/800-human-fire.png"),
-	love.graphics.newImage("res/backgrounds/900-early-civilization.png"),
-	love.graphics.newImage("res/backgrounds/1000-vikings.png"),
-	love.graphics.newImage("res/backgrounds/1100-crusades.png"),
-	love.graphics.newImage("res/backgrounds/1200-genghis-khan.png"),
-	love.graphics.newImage("res/backgrounds/1300-black-death.png"),
-	love.graphics.newImage("res/backgrounds/1400-columbus-discovery.png"),
-	love.graphics.newImage("res/backgrounds/1500-aztecas.png"),
-	love.graphics.newImage("res/backgrounds/1600-telescope.png"),
-	love.graphics.newImage("res/backgrounds/1700-american-revolution.png"),
-	love.graphics.newImage("res/backgrounds/1800-railways.png"),
-	love.graphics.newImage("res/backgrounds/1900-world-wide-web.png"),
-	title = love.graphics.newImage("res/backgrounds/title_v0.1.png"),
+	[0] = love.graphics.newImage("res/backgrounds/0.png"),
+	love.graphics.newImage("res/backgrounds/100.png"),
+	love.graphics.newImage("res/backgrounds/200.png"),
+	love.graphics.newImage("res/backgrounds/300.png"),
+	love.graphics.newImage("res/backgrounds/400.png"),
+	love.graphics.newImage("res/backgrounds/500.png"),
+	love.graphics.newImage("res/backgrounds/600.png"),
+	love.graphics.newImage("res/backgrounds/700.png"),
+	love.graphics.newImage("res/backgrounds/800.png"),
+	love.graphics.newImage("res/backgrounds/900.png"),
+	love.graphics.newImage("res/backgrounds/1000.png"),
+	love.graphics.newImage("res/backgrounds/1100.png"),
+	love.graphics.newImage("res/backgrounds/1200.png"),
+	love.graphics.newImage("res/backgrounds/1300.png"),
+	love.graphics.newImage("res/backgrounds/1400.png"),
+	love.graphics.newImage("res/backgrounds/1500.png"),
+	love.graphics.newImage("res/backgrounds/1600.png"),
+	love.graphics.newImage("res/backgrounds/1700.png"),
+	love.graphics.newImage("res/backgrounds/1800.png"),
+	love.graphics.newImage("res/backgrounds/1900.png"),
+	title = love.graphics.newImage("res/backgrounds/title.png"),
+	input_config = love.graphics.newImage("res/backgrounds/options-input.png"),
+	game_config = love.graphics.newImage("res/backgrounds/options-game.png"),
 }
 
 blocks = {
 	["2tie"] = {
-		I = love.graphics.newImage("res/img/s1.png"),
-		J = love.graphics.newImage("res/img/s4.png"),
-		L = love.graphics.newImage("res/img/s3.png"),
-		O = love.graphics.newImage("res/img/s7.png"),
-		S = love.graphics.newImage("res/img/s5.png"),
-		T = love.graphics.newImage("res/img/s2.png"),
-		Z = love.graphics.newImage("res/img/s6.png"),
+		R = love.graphics.newImage("res/img/s1.png"),
+		O = love.graphics.newImage("res/img/s3.png"),
+		Y = love.graphics.newImage("res/img/s7.png"),
+		G = love.graphics.newImage("res/img/s6.png"),
+		C = love.graphics.newImage("res/img/s2.png"),
+		B = love.graphics.newImage("res/img/s4.png"),
+		M = love.graphics.newImage("res/img/s5.png"),
 		F = love.graphics.newImage("res/img/s9.png"),
-		G = love.graphics.newImage("res/img/s9.png"),
+		A = love.graphics.newImage("res/img/s8.png"),
 		X = love.graphics.newImage("res/img/s9.png"),
 	},
 	["bone"] = {
-		I = love.graphics.newImage("res/img/bone.png"),
-		J = love.graphics.newImage("res/img/bone.png"),
-		L = love.graphics.newImage("res/img/bone.png"),
+		R = love.graphics.newImage("res/img/bone.png"),
 		O = love.graphics.newImage("res/img/bone.png"),
-		S = love.graphics.newImage("res/img/bone.png"),
-		T = love.graphics.newImage("res/img/bone.png"),
-		Z = love.graphics.newImage("res/img/bone.png"),
-		F = love.graphics.newImage("res/img/bone.png"),
+		Y = love.graphics.newImage("res/img/bone.png"),
 		G = love.graphics.newImage("res/img/bone.png"),
+		C = love.graphics.newImage("res/img/bone.png"),
+		B = love.graphics.newImage("res/img/bone.png"),
+		M = love.graphics.newImage("res/img/bone.png"),
+		F = love.graphics.newImage("res/img/bone.png"),
+		A = love.graphics.newImage("res/img/bone.png"),
 		X = love.graphics.newImage("res/img/bone.png"),
 	}
 }
 
+ColourSchemes = {
+	Arika = {
+		I = "R",
+		L = "O",
+		J = "B",
+		S = "M",
+		Z = "G",
+		O = "Y",
+		T = "C",
+	},
+	TTC = {
+		I = "C",
+		L = "O",
+		J = "B",
+		S = "G",
+		Z = "R",
+		O = "Y",
+		T = "M",
+	},
+}
+
 for name, blockset in pairs(blocks) do
 	for shape, image in pairs(blockset) do
 		image:setFilter("nearest")
@@ -61,4 +84,4 @@ misc_graphics = {
 	go = love.graphics.newImage("res/img/go.png"),
 	select_mode = love.graphics.newImage("res/img/select_mode.png"),
 	strike = love.graphics.newImage("res/img/strike.png"),
-}
+}

load/rpc.lua

@@ -0,0 +1,58 @@
+print("Loading discord RPC...")
+DiscordRPC = {
+	loaded = false
+}
+local success, RPC = pcall(require, "libs.discordRPC")
+if success then
+	DiscordRPC.loaded = true
+	DiscordRPC.appId = "599778517789573120"
+
+	function RPC.ready(userId, username, discriminator, avatar)
+		print(string.format("Discord: ready (%s, %s, %s, %s)", userId, username, discriminator, avatar))
+	end
+
+	function RPC.disconnected(errorCode, message)
+		print(string.format("Discord: disconnected (%d: %s)", errorCode, message))
+	end
+
+	function RPC.errored(errorCode, message)
+		print(string.format("Discord: error (%d: %s)", errorCode, message))
+	end
+
+	function RPC.joinGame(joinSecret)
+		print(string.format("Discord: join (%s)", joinSecret))
+	end
+
+	function RPC.spectateGame(spectateSecret)
+		print(string.format("Discord: spectate (%s)", spectateSecret))
+	end
+
+	function RPC.joinRequest(userId, username, discriminator, avatar)
+		print(string.format("Discord: join request (%s, %s, %s, %s)", userId, username, discriminator, avatar))
+		RPC.respond(userId, "yes")
+	end
+
+	RPC.initialize(DiscordRPC.appId, true)
+	local now = os.time(os.date("*t"))
+	
+	DiscordRPC.RPC = RPC
+	print("DiscordRPC successfully loaded.")
+else
+	print("DiscordRPC failed to load!")
+	print(RPC)
+end
+
+DiscordRPC.presence = {
+		startTimestamp = now,
+		details = "Loading game...",
+		state = "",
+		largeImageKey = "icon2",
+		largeImageText = "Arcade Stacker",
+		smallImageKey = "",
+		smallImageText = ""
+}
+
+function DiscordRPC:update(newstuff)
+	for k, v in pairs(newstuff) do self.presence[k] = v end
+	if self.loaded then self.RPC.updatePresence(self.presence) end
+end

load/sounds.lua

@@ -10,20 +10,50 @@ sounds = {
 	},
 	move = love.audio.newSource("res/se/move.wav", "static"),
 	bottom = love.audio.newSource("res/se/bottom.wav", "static"),
+	cursor = love.audio.newSource("res/se/cursor.wav", "static"),
+	cursor_lr = love.audio.newSource("res/se/cursor_lr.wav", "static"),
+	main_decide = love.audio.newSource("res/se/main_decide.wav", "static"),
+	mode_decide = love.audio.newSource("res/se/mode_decide.wav", "static"),
+	lock = love.audio.newSource("res/se/lock.wav", "static"),
+	hold = love.audio.newSource("res/se/hold.wav", "static"),
+	erase = love.audio.newSource("res/se/erase.wav", "static"),
+	fall = love.audio.newSource("res/se/fall.wav", "static"),
+	ready = love.audio.newSource("res/se/ready.wav", "static"),
+	go = love.audio.newSource("res/se/go.wav", "static"),
+	irs = love.audio.newSource("res/se/irs.wav", "static"),
+	ihs = love.audio.newSource("res/se/ihs.wav", "static"),
+	-- a secret sound!
+	welcome = love.audio.newSource("res/se/welcomeToCambridge.wav", "static"),
 }
 
 function playSE(sound, subsound)
 	if subsound == nil then
-		sounds[sound]:setVolume(0.1)
+		sounds[sound]:setVolume(config.sfx_volume)
 		if sounds[sound]:isPlaying() then
 			sounds[sound]:stop()
 		end
 		sounds[sound]:play()
 	else
-		sounds[sound][subsound]:setVolume(0.1)
+		sounds[sound][subsound]:setVolume(config.sfx_volume)
 		if sounds[sound][subsound]:isPlaying() then
 			sounds[sound][subsound]:stop()
 		end
 		sounds[sound][subsound]:play()
 	end
 end
+
+function playSEOnce(sound, subsound)
+	if subsound == nil then
+		sounds[sound]:setVolume(config.sfx_volume)
+		if sounds[sound]:isPlaying() then
+			return
+		end
+		sounds[sound]:play()
+	else
+		sounds[sound][subsound]:setVolume(config.sfx_volume)
+		if sounds[sound][subsound]:isPlaying() then
+			return
+		end
+		sounds[sound][subsound]:play()
+	end
+end

main.lua

@@ -1,6 +1,7 @@
 function love.load()
 	math.randomseed(os.time())
 	highscores = {}
+	require "load.rpc"
 	require "load.graphics"
 	require "load.fonts"
 	require "load.sounds"
@@ -8,20 +9,61 @@ function love.load()
 	require "load.save"
 	loadSave()
 	require "scene"
-	config["side_next"] = false
-	config["reverse_rotate"] = true
+	--config["side_next"] = false
+	--config["reverse_rotate"] = true
 	config["fullscreen"] = false
 
 	love.window.setMode(love.graphics.getWidth(), love.graphics.getHeight(), {resizable = true});
 
+	if not config.das then config.das = 10 end
+	if not config.arr then config.arr = 2 end
+	if not config.sfx_volume then config.sfx_volume = 0.5 end
+	if not config.bgm_volume then config.bgm_volume = 0.5 end
+	
+	if config.secret == nil  then config.secret = false
+	elseif config.secret == true then playSE("welcome") end
+
+	if not config.gamesettings then
+		config.gamesettings = {}
+		config["das_last_key"] = false
+	else
+		config["das_last_key"] = config.gamesettings.das_last_key == 2
+	end
+	for _, option in ipairs(GameConfigScene.options) do
+		if not config.gamesettings[option[1]] then
+			config.gamesettings[option[1]] = 1
+		end
+	end
+	
 	if not config.input then
-		config.input = {}
 		scene = InputConfigScene()
 	else
 		if config.current_mode then current_mode = config.current_mode end
 		if config.current_ruleset then current_ruleset = config.current_ruleset end
 		scene = TitleScene()
 	end
+
+	game_modes = {}
+	mode_list = love.filesystem.getDirectoryItems("tetris/modes")
+	for i=1,#mode_list do
+		if(mode_list[i] ~= "gamemode.lua" and mode_list[i] ~= "unrefactored_modes") then
+			game_modes[#game_modes+1] = require ("tetris.modes."..string.sub(mode_list[i],1,-5))
+		end
+	end
+	rulesets = {}
+	rule_list = love.filesystem.getDirectoryItems("tetris/rulesets")
+	for i=1,#rule_list do
+		if(rule_list[i] ~= "ruleset.lua" and rule_list[i] ~= "unrefactored_rulesets") then
+			rulesets[#rulesets+1] = require ("tetris.rulesets."..string.sub(rule_list[i],1,-5))
+		end
+	end
+	--sort mode/rule lists
+	local function padnum(d) return ("%03d%s"):format(#d, d) end
+	table.sort(game_modes, function(a,b)
+	return tostring(a.name):gsub("%d+",padnum) < tostring(b.name):gsub("%d+",padnum) end)
+	table.sort(rulesets, function(a,b)
+	return tostring(a.name):gsub("%d+",padnum) < tostring(b.name):gsub("%d+",padnum) end)
+	
 end
 
 local TARGET_FPS = 60
@@ -64,7 +106,7 @@ end
 
 function love.draw()
 	love.graphics.push()
-	
+
 	-- get offset matrix
 	love.graphics.setDefaultFilter("linear", "nearest")
 	local width = love.graphics.getWidth()
@@ -80,13 +122,131 @@ function love.draw()
 	love.graphics.pop()
 end
 
-function love.keypressed(key, scancode, isrepeat)
+function love.keypressed(key, scancode)
 	-- global hotkeys
 	if scancode == "f4" then
 		config["fullscreen"] = not config["fullscreen"]
 		love.window.setFullscreen(config["fullscreen"])
+	elseif scancode == "f2" and scene.title ~= "Input Config" and scene.title ~= "Game" then
+		scene = InputConfigScene()
+	-- secret sound playing :eyes:
+	elseif scancode == "f8" and scene.title == "Title" then
+		config.secret = not config.secret
+		saveConfig()
+		scene.restart_message = true
+		if config.secret then playSE("mode_decide")
+		else playSE("erase") end
+	-- function keys are reserved
+	elseif string.match(scancode, "^f[1-9]$") or string.match(scancode, "^f[1-9][0-9]+$") then
+		return	
+	-- escape is reserved for menu_back
+	elseif scancode == "escape" then
+		scene:onInputPress({input="menu_back", type="key", key=key, scancode=scancode})
+	-- pass any other key to the scene, with its configured mapping
 	else
-		scene:onKeyPress({key=key, scancode=scancode, isRepeat=isrepeat})
+		local input_pressed = nil
+		if config.input and config.input.keys then
+			input_pressed = config.input.keys[scancode]
+		end
+		scene:onInputPress({input=input_pressed, type="key", key=key, scancode=scancode})
+	end
+end
+
+function love.keyreleased(key, scancode)
+	-- escape is reserved for menu_back
+	if scancode == "escape" then
+		scene:onInputRelease({input="menu_back", type="key", key=key, scancode=scancode})
+	-- function keys are reserved
+	elseif string.match(scancode, "^f[1-9]$") or string.match(scancode, "^f[1-9][0-9]+$") then
+		return	
+	-- handle all other keys; tab is reserved, but the input config scene keeps it from getting configured as a game input, so pass tab to the scene here
+	else
+		local input_released = nil
+		if config.input and config.input.keys then
+			input_released = config.input.keys[scancode]
+		end
+		scene:onInputRelease({input=input_released, type="key", key=key, scancode=scancode})
+	end
+end
+
+function love.joystickpressed(joystick, button)
+	local input_pressed = nil
+	if
+		config.input and
+		config.input.joysticks and
+		config.input.joysticks[joystick:getName()] and
+		config.input.joysticks[joystick:getName()].buttons
+	then
+		input_pressed = config.input.joysticks[joystick:getName()].buttons[button]
+	end
+	scene:onInputPress({input=input_pressed, type="joybutton", name=joystick:getName(), button=button})
+end
+
+function love.joystickreleased(joystick, button)
+	local input_released = nil
+	if
+		config.input and
+		config.input.joysticks and
+		config.input.joysticks[joystick:getName()] and
+		config.input.joysticks[joystick:getName()].buttons
+	then
+		input_released = config.input.joysticks[joystick:getName()].buttons[button]
+	end
+	scene:onInputRelease({input=input_released, type="joybutton", name=joystick:getName(), button=button})
+end
+
+function love.joystickaxis(joystick, axis, value)
+	local input_pressed = nil
+	local positive_released = nil
+	local negative_released = nil
+	if
+		config.input and
+		config.input.joysticks and
+		config.input.joysticks[joystick:getName()] and
+		config.input.joysticks[joystick:getName()].axes and
+		config.input.joysticks[joystick:getName()].axes[axis] 
+	then
+		if math.abs(value) >= 0.5 then
+			input_pressed = config.input.joysticks[joystick:getName()].axes[axis][value >= 0.5 and "positive" or "negative"]
+		end
+		positive_released = config.input.joysticks[joystick:getName()].axes[axis].positive
+		negative_released = config.input.joysticks[joystick:getName()].axes[axis].negative
+	end
+	if math.abs(value) >= 0.5 then
+		scene:onInputPress({input=input_pressed, type="joyaxis", name=joystick:getName(), axis=axis, value=value})
+	else
+		scene:onInputRelease({input=positive_released, type="joyaxis", name=joystick:getName(), axis=axis, value=value})
+		scene:onInputRelease({input=negative_released, type="joyaxis", name=joystick:getName(), axis=axis, value=value})
+	end
+end
+
+function love.joystickhat(joystick, hat, direction)
+	local input_pressed = nil
+	local has_hat = false
+	if
+		config.input and
+		config.input.joysticks and
+		config.input.joysticks[joystick:getName()] and
+		config.input.joysticks[joystick:getName()].hats and
+		config.input.joysticks[joystick:getName()].hats[hat]
+	then
+		if direction ~= "c" then
+			input_pressed = config.input.joysticks[joystick:getName()].hats[hat][direction]
+		end
+		has_hat = true
+	end
+	if input_pressed then
+		scene:onInputPress({input=input_pressed, type="joyhat", name=joystick:getName(), hat=hat, direction=direction})
+	elseif has_hat then
+		for i, direction in ipairs{"d", "l", "ld", "lu", "r", "rd", "ru", "u"} do
+			scene:onInputRelease({input=config.input.joysticks[joystick:getName()].hats[hat][direction], type="joyhat", name=joystick:getName(), hat=hat, direction=direction})
+		end
+	elseif direction ~= "c" then
+		scene:onInputPress({input=nil, type="joyhat", name=joystick:getName(), hat=hat, direction=direction})
+	else
+		for i, direction in ipairs{"d", "l", "ld", "lu", "r", "rd", "ru", "u"} do
+			scene:onInputRelease({input=nil, type="joyhat", name=joystick:getName(), hat=hat, direction=direction})
+		end
 	end
 end
 

package.bat

@@ -0,0 +1,2 @@
+tar -a -c -f cambridge.zip libs/binser.lua libs/classic.lua libs/discordRPC.lua load res scene tetris conf.lua main.lua scene.lua funcs.lua
+rename cambridge.zip cambridge.love

release

@@ -4,6 +4,6 @@ mkdir dist/windows
 mkdir dist/win32
 cp cambridge.love dist/
 cat dist/windows/love.exe cambridge.love > dist/windows/cambridge.exe
-zip dist/cambridge-windows.zip dist/windows/* SOURCES.md LICENSE
+zip dist/cambridge-windows.zip dist/windows/* SOURCES.md LICENSE.md
 cat dist/win32/love.exe cambridge.love > dist/win32/cambridge.exe
-zip dist/cambridge-win32.zip dist/win32/* SOURCES.md LICENSE
+zip dist/cambridge-win32.zip dist/win32/* SOURCES.md LICENSE.md

release.bat

@@ -0,0 +1,26 @@
+call package.bat
+
+mkdir dist
+mkdir dist\windows
+mkdir dist\windows\libs
+mkdir dist\win32
+mkdir dist\win32\libs
+
+copy /b dist\windows\love.exe+cambridge.love dist\windows\cambridge.exe
+copy /b dist\win32\love.exe+cambridge.love dist\win32\cambridge.exe
+
+copy libs\discord-rpc.dll dist\windows\libs
+copy libs\discord-rpc.dll dist\win32\libs
+
+copy SOURCES.md dist\windows
+copy LICENSE.md dist\windows
+copy SOURCES.md dist\win32
+copy LICENSE.md dist\win32
+
+cd dist\windows
+tar -a -c -f ..\cambridge-windows.zip cambridge.exe *.dll libs *.md
+cd ..\..
+
+cd dist\win32
+tar -a -c -f ..\cambridge-win32.zip cambridge.exe *.dll libs *.md
+cd ..\..

scene.lua

@@ -5,10 +5,15 @@ Scene = Object:extend()
 function Scene:new() end
 function Scene:update() end
 function Scene:render() end
-function Scene:onKeyPress() end
+function Scene:onInputPress() end
+function Scene:onInputRelease() end
 
+ExitScene = require "scene.exit"
 GameScene = require "scene.game"
 ModeSelectScene = require "scene.mode_select"
 InputConfigScene = require "scene.input_config"
-ConfigScene = require "scene.config"
+GameConfigScene = require "scene.game_config"
+TuningScene = require "scene.tuning"
+SettingsScene = require "scene.settings"
+CreditsScene = require "scene.credits"
 TitleScene = require "scene.title"

scene/config.lua

@@ -17,7 +17,7 @@ function ConfigScene:changeOption(rel)
 	self.main_menu_state = (self.main_menu_state + len + rel - 1) % len + 1
 end
 
-function ConfigScene:onKeyPress(e)
+function ConfigScene:onInputPress(e)
 end
 
 return ConfigScene

scene/credits.lua

@@ -0,0 +1,57 @@
+local CreditsScene = Scene:extend()
+
+CreditsScene.title = "Credits"
+
+function CreditsScene:new()
+    self.frames = 0
+end
+
+function CreditsScene:update()
+    self.frames = self.frames + 1
+    if self.frames >= 2200 then
+        playSE("mode_decide")
+        scene = TitleScene()
+    end
+end
+
+function CreditsScene:render()
+    love.graphics.setColor(1, 1, 1, 1)
+	love.graphics.draw(
+		backgrounds[19],
+		0, 0, 0,
+		0.5, 0.5
+    )
+
+    love.graphics.setFont(font_3x5_4)
+    love.graphics.print("Cambridge Credits", 320, 500 - self.frames)
+    love.graphics.print("THANK YOU\nFOR PLAYING!", 320, math.max(1500 - self.frames, 240))
+
+    love.graphics.setFont(font_3x5_3)
+    love.graphics.print("Game Developers", 320, 550 - self.frames)
+    love.graphics.print("Project Heads", 320, 640 - self.frames)
+    love.graphics.print("Other Game Developers", 320, 730 - self.frames)
+    love.graphics.print("Special Thanks", 320, 900 - self.frames)
+    love.graphics.print("- SashLilac / SpinTriple", 320, math.max(2000 - self.frames, 320))
+
+    love.graphics.setFont(font_3x5_2)
+    love.graphics.print("Oshisaure\nJoe Zeng", 320, 590 - self.frames)
+    love.graphics.print("Mizu\nHailey", 320, 680 - self.frames)
+    love.graphics.print("Axel Fox - Multimino\nMine - Tetra Online\nDr Ocelot - Tetra Legends\nFelicity / nightmareci - Shiromino\n2Tie - TGMsim\nPhoenix Flare - Master of Blocks", 320, 770 - self.frames)
+    love.graphics.print(
+        "RocketLanterns\nCylinderKnot\nHammrTime\nKirby703\nMattMayuga\nMyPasswordIsWeak\n" ..
+        "Nikki Karissa\noffwo\nsinefuse\nTetro48\nTimmSkiller\nuser74003\nAgentBasey\n" ..
+        "CheeZed_Fish\neightsixfivezero\nEricICX\ngizmo4487\nM1ssing0\nMarkGamed7794\n" ..
+        "pokemonfan1937\nSimon\nstratus\nZaptorZap\nThe Absolute PLUS Discord\nTetra Legends Discord\n" ..
+        "Tetra Online Discord\nMultimino Discord\nCambridge Discord\nAnd to you, the player!",
+        320, 940 - self.frames
+    )
+end
+
+function CreditsScene:onInputPress(e)
+    if e.input == "menu_decide" or e.scancode == "return" or
+       e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
+		scene = TitleScene()
+	end
+end
+
+return CreditsScene

scene/exit.lua

@@ -0,0 +1,23 @@
+local ExitScene = Scene:extend()
+require 'load.save'
+
+ExitScene.title = "Exit Game"
+
+function ExitScene:new()
+end
+
+function ExitScene:update()
+	love.event.quit()
+end
+
+function ExitScene:render()
+end
+
+function ExitScene:changeOption(rel)
+end
+
+function ExitScene:onInputPress(e)
+end
+
+return ExitScene
+

scene/game.lua

@@ -1,26 +1,41 @@
 local GameScene = Scene:extend()
+
+GameScene.title = "Game"
+
 require 'load.save'
 
 function GameScene:new(game_mode, ruleset)
+	self.retry_mode = game_mode
+	self.retry_ruleset = ruleset
 	self.game = game_mode()
 	self.ruleset = ruleset()
 	self.game:initialize(self.ruleset)
+	self.inputs = {
+		left=false,
+		right=false,
+		up=false,
+		down=false,
+		rotate_left=false,
+		rotate_left2=false,
+		rotate_right=false,
+		rotate_right2=false,
+		rotate_180=false,
+		hold=false,
+	}
+	self.paused = false
+	DiscordRPC:update({
+		details = self.game.rpc_details,
+		state = self.game.name,
+	})
 end
 
 function GameScene:update()
-	if love.window.hasFocus() then
-		self.game:update({
-			left = love.keyboard.isScancodeDown(config.input.left),
-			right = love.keyboard.isScancodeDown(config.input.right),
-			up = love.keyboard.isScancodeDown(config.input.up),
-			down = love.keyboard.isScancodeDown(config.input.down),
-			rotate_left = love.keyboard.isScancodeDown(config.input.rotate_left),
-			rotate_left2 = love.keyboard.isScancodeDown(config.input.rotate_left2),
-			rotate_right = love.keyboard.isScancodeDown(config.input.rotate_right),
-			rotate_right2 = love.keyboard.isScancodeDown(config.input.rotate_right2),
-			rotate_180 = love.keyboard.isScancodeDown(config.input.rotate_180),
-			hold = love.keyboard.isScancodeDown(config.input.hold),
-		}, self.ruleset)
+	if love.window.hasFocus() and not self.paused then
+		local inputs = {}
+		for input, value in pairs(self.inputs) do
+			inputs[input] = value
+		end
+		self.game:update(inputs, self.ruleset)
 	end
 
 	self.game.grid:update()
@@ -45,6 +60,7 @@ function GameScene:render()
 	self.game:drawScoringInfo()
 
 	-- ready/go graphics
+
 	if self.game.ready_frames <= 100 and self.game.ready_frames > 52 then
 		love.graphics.draw(misc_graphics["ready"], 144 - 50, 240 - 14)
 	elseif self.game.ready_frames <= 50 and self.game.ready_frames > 2 then
@@ -53,15 +69,37 @@ function GameScene:render()
 
 	self.game:drawCustom()
 
+	love.graphics.setFont(font_3x5_2)
+	if config.gamesettings.display_gamemode == 1 then
+		love.graphics.printf(self.game.name .. " - " .. self.ruleset.name, 0, 460, 640, "left")
+	end
+
+	love.graphics.setFont(font_3x5_3)
+	if self.paused then love.graphics.print("PAUSED!", 80, 100) end
 end
 
-function GameScene:onKeyPress(e)
-	if (self.game.completed) and
-		e.scancode == "return" and e.isRepeat == false then
+function GameScene:onInputPress(e)
+	if self.game.completed and (e.input == "menu_decide" or e.input == "menu_back" or e.input == "retry") then
 		highscore_entry = self.game:getHighscoreData()
 		highscore_hash = self.game.hash .. "-" .. self.ruleset.hash
 		submitHighscore(highscore_hash, highscore_entry)
+		scene = e.input == "retry" and GameScene(self.retry_mode, self.retry_ruleset) or ModeSelectScene()
+	elseif e.input == "retry" then
+		scene = GameScene(self.retry_mode, self.retry_ruleset)
+	elseif e.input == "pause" and not (self.game.game_over or self.game.completed) then
+		if not self.paused then pauseBGM()
+		else resumeBGM() end
+		self.paused = not self.paused
+	elseif e.input == "menu_back" then
 		scene = ModeSelectScene()
+	elseif e.input and string.sub(e.input, 1, 5) ~= "menu_" then
+		self.inputs[e.input] = true
+	end
+end
+
+function GameScene:onInputRelease(e)
+	if e.input and string.sub(e.input, 1, 5) ~= "menu_" then
+		self.inputs[e.input] = false
 	end
 end
 

scene/game_config.lua

@@ -0,0 +1,99 @@
+local ConfigScene = Scene:extend()
+
+ConfigScene.title = "Game Settings"
+
+require 'load.save'
+require 'libs.simple-slider'
+
+ConfigScene.options = {
+	-- this serves as reference to what the options' values mean i guess?
+	{"manlock",			"Manual Locking",{"Per ruleset","Per gamemode","Harddrop", "Softdrop"}},
+	{"piece_colour", "Piece Colours", {"Per ruleset","Arika"			 ,"TTC"}},
+	{"world_reverse","A Button Rotation", {"Left"				 ,"Auto"		,"Right"}},
+	{"display_gamemode", "Display Gamemode", {"On", "Off"}},
+	{"das_last_key", "DAS Switch", {"Default", "Instant"}},
+	{"smooth_movement", "Smooth Piece Drop", {"On", "Off"}},
+	{"synchroes_allowed", "Synchroes", {"Per ruleset", "On", "Off"}},
+	{"diagonal_input", "Diagonal Input", {"On", "Off"}}
+}
+local optioncount = #ConfigScene.options
+
+function ConfigScene:new()
+	-- load current config
+	self.config = config.input
+	self.highlight = 1
+	
+	DiscordRPC:update({
+		details = "In menus",
+		state = "Changing game settings",
+	})
+
+	self.sfxSlider = newSlider(165, 375, 225, config.sfx_volume * 100, 0, 100, function(v) config.sfx_volume = v / 100 end, {width=20})
+	self.bgmSlider = newSlider(465, 375, 225, config.bgm_volume * 100, 0, 100, function(v) config.bgm_volume = v / 100 end, {width=20})
+end
+
+function ConfigScene:update()
+	config["das_last_key"] = config.gamesettings.das_last_key == 2
+	self.sfxSlider:update()
+	self.bgmSlider:update()
+end
+
+function ConfigScene: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_3)
+	love.graphics.print("SFX Volume: " .. math.floor(self.sfxSlider:getValue()) .. "%", 75, 325)
+	love.graphics.print("BGM Volume: " .. math.floor(self.bgmSlider:getValue()) .. "%", 375, 325)
+
+	love.graphics.setFont(font_3x5_4)
+	love.graphics.print("GAME SETTINGS", 80, 40)
+	
+	love.graphics.setColor(1, 1, 1, 0.5)
+	love.graphics.rectangle("fill", 20, 98 + self.highlight * 20, 170, 22)
+	
+	love.graphics.setFont(font_3x5_2)
+	for i, option in ipairs(ConfigScene.options) do
+		love.graphics.setColor(1, 1, 1, 1)
+		love.graphics.printf(option[2], 40, 100 + i * 20, 150, "left")
+		for j, setting in ipairs(option[3]) do
+			love.graphics.setColor(1, 1, 1, config.gamesettings[option[1]] == j and 1 or 0.5)
+			love.graphics.printf(setting, 100 + 110 * j, 100 + i * 20, 100, "center")
+		end
+	end
+
+	love.graphics.setColor(1, 1, 1, 0.75)
+	self.sfxSlider:draw()
+	self.bgmSlider:draw()
+end
+
+function ConfigScene:onInputPress(e)
+	if e.input == "menu_decide" or e.scancode == "return" then
+		playSE("mode_decide")
+		saveConfig()
+		scene = SettingsScene()
+	elseif 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 = ConfigScene.options[self.highlight]
+		config.gamesettings[option[1]] = Mod1(config.gamesettings[option[1]]-1, #option[3])
+	elseif e.input == "right" or e.scancode == "right" then
+		playSE("cursor_lr")
+		local option = ConfigScene.options[self.highlight]
+		config.gamesettings[option[1]] = Mod1(config.gamesettings[option[1]]+1, #option[3])
+	elseif e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
+		loadSave()
+		scene = SettingsScene()
+	end
+end
+
+return ConfigScene

scene/input_config.lua

@@ -5,57 +5,158 @@ ConfigScene.title = "Input Config"
 require 'load.save'
 
 local configurable_inputs = {
+	"menu_decide",
+	"menu_back",
 	"left",
-    "right",
-    "up",
-    "down",
+	"right",
+	"up",
+	"down",
 	"rotate_left",
 	"rotate_left2",
-    "rotate_right",
-    "rotate_right2",
-    "rotate_180",
-    "hold",
+	"rotate_right",
+	"rotate_right2",
+	"rotate_180",
+	"hold",
+	"retry",
+	"pause",
 }
 
+local function newSetInputs()
+	local set_inputs = {}
+	for i, input in ipairs(configurable_inputs) do
+		set_inputs[input] = false
+	end
+	return set_inputs
+end
+
 function ConfigScene:new()
-	-- load current config
-	self.config = config.input
 	self.input_state = 1
+	self.set_inputs = newSetInputs()
+	self.new_input = {}
+	self.axis_timer = 0
+
+	DiscordRPC:update({
+		details = "In menus",
+		state = "Changing input config",
+	})
 end
 
 function ConfigScene:update()
 end
 
 function ConfigScene:render()
+	love.graphics.setColor(1, 1, 1, 1)
+	love.graphics.draw(
+		backgrounds["input_config"],
+		0, 0, 0,
+		0.5, 0.5
+	)
+
 	love.graphics.setFont(font_3x5_2)
-	for i, input in pairs(configurable_inputs) do
-		if config.input[input] then
-			love.graphics.printf(input, 40, 50 + i * 20, 200, "left")
-			love.graphics.printf(
-				love.keyboard.getKeyFromScancode(config.input[input]) .. " (" .. config.input[input] .. ")",
-				240, 50 + i * 20, 200, "left"
-			)
+	for i, input in ipairs(configurable_inputs) do
+		love.graphics.printf(input, 40, 50 + i * 20, 200, "left")
+		if self.set_inputs[input] then
+			love.graphics.printf(self.set_inputs[input], 240, 50 + i * 20, 300, "left")
 		end
 	end
 	if self.input_state > table.getn(configurable_inputs) then
-		love.graphics.print("press enter to confirm, delete to retry")
+		love.graphics.print("press enter to confirm, delete/backspace to retry" .. (config.input and ", escape to cancel" or ""))
 	else
-		love.graphics.print("press key for " .. configurable_inputs[self.input_state])
+		love.graphics.print("press key or joystick input for " .. configurable_inputs[self.input_state] .. ", tab to skip" .. (config.input and ", escape to cancel" or ""), 0, 0)
+		love.graphics.print("function keys (F1, F2, etc.), escape, and tab can't be changed", 0, 20)
+	end
+
+	self.axis_timer = self.axis_timer + 1
+end
+
+local function addJoystick(input, name)
+	if not input.joysticks then
+		input.joysticks = {}
+	end
+	if not input.joysticks[name] then
+		input.joysticks[name] = {}
 	end
 end
 
-function ConfigScene:onKeyPress(e)
-	if self.input_state > table.getn(configurable_inputs) then
-		if e.scancode == "return" then
-			-- save, then load next scene
-			saveConfig()
-			scene = TitleScene()
-		elseif e.scancode == "delete" or e.scancode == "backspace" then
-			self.input_state = 1
+function ConfigScene:onInputPress(e)
+	if e.type == "key" then
+		-- function keys, escape, and tab are reserved and can't be remapped
+		if e.scancode == "escape" and config.input then
+			-- cancel only if there was an input config already
+			scene = SettingsScene()
+		elseif self.input_state > table.getn(configurable_inputs) then
+			if e.scancode == "return" then
+				-- save new input, then load next scene
+				config.input = self.new_input
+				saveConfig()
+				scene = TitleScene()
+			elseif e.scancode == "delete" or e.scancode == "backspace" then
+				-- retry
+				self.input_state = 1
+				self.set_inputs = newSetInputs()
+				self.new_input = {}
+			end
+		elseif e.scancode == "tab" then
+			self.set_inputs[configurable_inputs[self.input_state]] = "skipped"
+			self.input_state = self.input_state + 1
+		elseif e.scancode ~= "escape" then
+			-- all other keys can be configured
+			if not self.new_input.keys then
+				self.new_input.keys = {}
+			end
+			self.set_inputs[configurable_inputs[self.input_state]] = "key " .. love.keyboard.getKeyFromScancode(e.scancode) .. " (" .. e.scancode .. ")"
+			self.new_input.keys[e.scancode] = configurable_inputs[self.input_state]
+			self.input_state = self.input_state + 1
+		end
+	elseif string.sub(e.type, 1, 3) == "joy" then
+		if self.input_state <= table.getn(configurable_inputs) then
+			if e.type == "joybutton" then
+				addJoystick(self.new_input, e.name)
+				if not self.new_input.joysticks[e.name].buttons then
+					self.new_input.joysticks[e.name].buttons = {}
+				end
+				self.set_inputs[configurable_inputs[self.input_state]] =
+					"jbtn " ..
+					e.button ..
+					" " .. string.sub(e.name, 1, 10) .. (string.len(e.name) > 10 and "..." or "")
+				self.new_input.joysticks[e.name].buttons[e.button] = configurable_inputs[self.input_state]
+				self.input_state = self.input_state + 1
+			elseif e.type == "joyaxis" then
+				if (e.axis ~= self.last_axis or self.axis_timer > 30) and math.abs(e.value) >= 1 then
+					addJoystick(self.new_input, e.name)
+					if not self.new_input.joysticks[e.name].axes then
+						self.new_input.joysticks[e.name].axes = {}
+					end
+					if not self.new_input.joysticks[e.name].axes[e.axis] then
+						self.new_input.joysticks[e.name].axes[e.axis] = {}
+					end
+					self.set_inputs[configurable_inputs[self.input_state]] =
+						"jaxis " ..
+						(e.value >= 1 and "+" or "-") .. e.axis ..
+						" " .. string.sub(e.name, 1, 10) .. (string.len(e.name) > 10 and "..." or "")
+					self.new_input.joysticks[e.name].axes[e.axis][e.value >= 1 and "positive" or "negative"] = configurable_inputs[self.input_state]
+					self.input_state = self.input_state + 1
+					self.last_axis = e.axis
+					self.axis_timer = 0
+				end
+			elseif e.type == "joyhat" then
+				if e.direction ~= "c" then
+					addJoystick(self.new_input, e.name)
+					if not self.new_input.joysticks[e.name].hats then
+						self.new_input.joysticks[e.name].hats = {}
+					end
+					if not self.new_input.joysticks[e.name].hats[e.hat] then
+						self.new_input.joysticks[e.name].hats[e.hat] = {}
+					end
+					self.set_inputs[configurable_inputs[self.input_state]] =
+						"jhat " ..
+						e.hat .. " " .. e.direction ..
+						" " .. string.sub(e.name, 1, 10) .. (string.len(e.name) > 10 and "..." or "")
+					self.new_input.joysticks[e.name].hats[e.hat][e.direction] = configurable_inputs[self.input_state]
+					self.input_state = self.input_state + 1
+				end
+			end
 		end
-	else
-		config.input[configurable_inputs[self.input_state]] = e.scancode
-		self.input_state = self.input_state + 1
 	end
 end
 

scene/mode_select.lua

@@ -5,46 +5,20 @@ ModeSelectScene.title = "Game Start"
 current_mode = 1
 current_ruleset = 1
 
-game_modes = {
-	require 'tetris.modes.marathon_2020',
-	require 'tetris.modes.survival_2020',
-	require 'tetris.modes.strategy',
-	require 'tetris.modes.interval_training',
-	require 'tetris.modes.pacer_test',
-	require 'tetris.modes.demon_mode',
-	require 'tetris.modes.phantom_mania',
-	require 'tetris.modes.phantom_mania2',
-	require 'tetris.modes.phantom_mania_n',
-	require 'tetris.modes.race_40',
-	require 'tetris.modes.marathon_a1',
-	require 'tetris.modes.marathon_a2',
-	require 'tetris.modes.marathon_a3',
-	require 'tetris.modes.marathon_ax4',
-	require 'tetris.modes.marathon_c89',
-	require 'tetris.modes.survival_a1',
-	require 'tetris.modes.survival_a2',
-	require 'tetris.modes.survival_a3',
-}
-
-rulesets = {
-	require 'tetris.rulesets.cambridge',
-	require 'tetris.rulesets.arika',
-	require 'tetris.rulesets.arika_ti',
-	require 'tetris.rulesets.standard_exp',
-	--require 'tetris.rulesets.bonkers',
-	--require 'tetris.rulesets.shirase',
-	--require 'tetris.rulesets.super302',
-}
-
 function ModeSelectScene:new()
 	self.menu_state = {
 		mode = current_mode,
 		ruleset = current_ruleset,
 		select = "mode",
 	}
+	DiscordRPC:update({
+		details = "In menus",
+		state = "Choosing a mode",
+	})
 end
 
 function ModeSelectScene:update()
+	switchBGM(nil) -- experimental
 end
 
 function ModeSelectScene:render()
@@ -53,49 +27,58 @@ function ModeSelectScene:render()
 		0, 0, 0,
 		0.5, 0.5
 	)
-	
+
 	if self.menu_state.select == "mode" then
 		love.graphics.setColor(1, 1, 1, 0.5)
 	elseif self.menu_state.select == "ruleset" then
 		love.graphics.setColor(1, 1, 1, 0.25)
 	end
-	love.graphics.rectangle("fill", 20, 78 + 20 * self.menu_state.mode, 240, 22)
+	love.graphics.rectangle("fill", 20, 258, 240, 22)
 
 	if self.menu_state.select == "mode" then
 		love.graphics.setColor(1, 1, 1, 0.25)
 	elseif self.menu_state.select == "ruleset" then
 		love.graphics.setColor(1, 1, 1, 0.5)
 	end
-	love.graphics.rectangle("fill", 340, 78 + 20 * self.menu_state.ruleset, 200, 22)
-	
+	love.graphics.rectangle("fill", 340, 258, 200, 22)
+
 	love.graphics.setColor(1, 1, 1, 1)
 
 	love.graphics.draw(misc_graphics["select_mode"], 20, 40)
 
 	love.graphics.setFont(font_3x5_2)
 	for idx, mode in pairs(game_modes) do
-		love.graphics.printf(mode.name, 40, 80 + 20 * idx, 200, "left")
+		if(idx >= self.menu_state.mode-9 and idx <= self.menu_state.mode+9) then
+			love.graphics.printf(mode.name, 40, (260 - 20*(self.menu_state.mode)) + 20 * idx, 200, "left")
+		end
 	end
 	for idx, ruleset in pairs(rulesets) do
-		love.graphics.printf(ruleset.name, 360, 80 + 20 * idx, 160, "left")
+		if(idx >= self.menu_state.ruleset-9 and idx <= self.menu_state.ruleset+9) then
+			love.graphics.printf(ruleset.name, 360, (260 - 20*(self.menu_state.ruleset)) + 20 * idx, 160, "left")
+		end
 	end
 end
 
-function ModeSelectScene:onKeyPress(e)
-	if e.scancode == "return" and e.isRepeat == false then
+function ModeSelectScene:onInputPress(e)
+	if e.input == "menu_decide" or e.scancode == "return" then
 		current_mode = self.menu_state.mode
 		current_ruleset = self.menu_state.ruleset
 		config.current_mode = current_mode
 		config.current_ruleset = current_ruleset
+		playSE("mode_decide")
 		saveConfig()
 		scene = GameScene(game_modes[self.menu_state.mode], rulesets[self.menu_state.ruleset])
-	elseif (e.scancode == config.input["up"] or e.scancode == "up") and e.isRepeat == false then
+	elseif e.input == "up" or e.scancode == "up" then
 		self:changeOption(-1)
-	elseif (e.scancode == config.input["down"] or e.scancode == "down") and e.isRepeat == false then
+		playSE("cursor")
+	elseif e.input == "down" or e.scancode == "down" then
 		self:changeOption(1)
-	elseif (e.scancode == config.input["left"] or e.scancode == "left") or
-		(e.scancode == config.input["right"] or e.scancode == "right") then
+		playSE("cursor")
+	elseif e.input == "left" or e.input == "right" or e.scancode == "left" or e.scancode == "right" then
 		self:switchSelect()
+		playSE("cursor_lr")
+	elseif e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
+		scene = TitleScene()
 	end
 end
 

scene/settings.lua

@@ -0,0 +1,65 @@
+local SettingsScene = Scene:extend()
+
+SettingsScene.title = "Settings"
+
+local menu_screens = {
+    InputConfigScene,
+    GameConfigScene,
+    TuningScene
+}
+
+function SettingsScene:new()
+    self.menu_state = 1
+    DiscordRPC:update({
+        details = "In menus",
+        state = "Changing settings",
+    })
+end
+
+function SettingsScene:update() end
+
+function SettingsScene: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("SETTINGS", 80, 40)
+
+    love.graphics.setFont(font_3x5_2)
+    love.graphics.print("Here, you can change some settings that change\nthe look and feel of the game.", 80, 90)
+
+    love.graphics.setColor(1, 1, 1, 0.5)
+	love.graphics.rectangle("fill", 75, 118 + 50 * self.menu_state, 200, 33)
+
+    love.graphics.setFont(font_3x5_3)
+	love.graphics.setColor(1, 1, 1, 1)
+	for i, screen in pairs(menu_screens) do
+		love.graphics.printf(screen.title, 80, 120 + 50 * i, 200, "left")
+    end
+end
+
+function SettingsScene:changeOption(rel)
+	local len = table.getn(menu_screens)
+	self.menu_state = (self.menu_state + len + rel - 1) % len + 1
+end
+
+function SettingsScene:onInputPress(e)
+	if e.input == "menu_decide" or e.scancode == "return" then
+		playSE("main_decide")
+		scene = menu_screens[self.menu_state]()
+	elseif e.input == "up" or e.scancode == "up" then
+		self:changeOption(-1)
+		playSE("cursor")
+	elseif e.input == "down" or e.scancode == "down" then
+		self:changeOption(1)
+		playSE("cursor")
+	elseif e.input == "menu_back" or e.scancode == "backspace" or e.scancode == "delete" then
+		scene = TitleScene()
+	end
+end
+
+return SettingsScene

scene/title.lua

@@ -1,12 +1,36 @@
 local TitleScene = Scene:extend()
 
+TitleScene.title = "Title"
+TitleScene.restart_message = false
+
 local main_menu_screens = {
 	ModeSelectScene,
-	InputConfigScene,
+	SettingsScene,
+	CreditsScene,
+	ExitScene,
+}
+
+local mainmenuidle = {
+	"Idle",
+	"On title screen",
+	"On main menu screen",
+	"Twiddling their thumbs",
+	"Admiring the main menu's BG",
+	"Waiting for spring to come",
+	"Actually not playing",
+	"Contemplating collecting stars",
+	"Preparing to put the block!!",
+	"Having a nap",
+	"In menus",
+	"Bottom text",
 }
 
 function TitleScene:new()
 	self.main_menu_state = 1
+	DiscordRPC:update({
+		details = "In menus",
+		state = mainmenuidle[math.random(#mainmenuidle)],
+	})
 end
 
 function TitleScene:update()
@@ -21,6 +45,8 @@ function TitleScene:render()
 		0.5, 0.5
 	)
 
+	love.graphics.print(self.restart_message and "Restart Cambridge..." or "", 0, 0)
+
 	love.graphics.setColor(1, 1, 1, 0.5)
 	love.graphics.rectangle("fill", 20, 278 + 20 * self.main_menu_state, 160, 22)
 
@@ -36,13 +62,18 @@ function TitleScene:changeOption(rel)
 	self.main_menu_state = (self.main_menu_state + len + rel - 1) % len + 1
 end
 
-function TitleScene:onKeyPress(e)
-	if e.scancode == "return" and e.isRepeat == false then
+function TitleScene:onInputPress(e)
+	if e.input == "menu_decide" or e.scancode == "return" then
+		playSE("main_decide")
 		scene = main_menu_screens[self.main_menu_state]()
-	elseif (e.scancode == config.input["up"] or e.scancode == "up") and e.isRepeat == false then
+	elseif e.input == "up" or e.scancode == "up" then
 		self:changeOption(-1)
-	elseif (e.scancode == config.input["down"] or e.scancode == "down") and e.isRepeat == false then
+		playSE("cursor")
+	elseif e.input == "down" or e.scancode == "down" then
 		self:changeOption(1)
+		playSE("cursor")
+	elseif e.input == "menu_back" or e.scancode == "backspace" or e.scancode == "delete" then
+		love.event.quit()
 	end
 end
 

scene/tuning.lua

@@ -0,0 +1,57 @@
+local TuningScene = Scene:extend()
+
+TuningScene.title = "Tuning Settings"
+
+require 'load.save'
+require 'libs.simple-slider'
+
+function TuningScene:new()
+    DiscordRPC:update({
+        details = "In menus",
+        state = "Changing tuning settings",
+    })
+
+    self.dasSlider = newSlider(290, 225, 400, config.das, 0, 20, function(v) config.das = math.floor(v) end, {width=20})
+    self.arrSlider = newSlider(290, 325, 400, config.arr, 0, 6, function(v) config.arr = math.floor(v) end, {width=20})
+end
+
+function TuningScene:update()
+    self.dasSlider:update()
+    self.arrSlider:update()
+end
+
+function TuningScene: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("TUNING SETTINGS", 80, 40)
+    
+    love.graphics.setFont(font_3x5_2)
+    love.graphics.print("These settings will only apply to modes\nthat do not use their own tunings.", 80, 90)
+    
+    love.graphics.setFont(font_3x5_3)
+    love.graphics.print("Delayed Auto-Shift (DAS): " .. math.floor(self.dasSlider:getValue()) .. "F", 80, 175)
+    love.graphics.print("Auto-Repeat Rate (ARR): " .. math.floor(self.arrSlider:getValue()) .. "F", 80, 275)
+
+    love.graphics.setColor(1, 1, 1, 0.75)
+    self.dasSlider:draw()
+    self.arrSlider:draw()
+end
+
+function TuningScene:onInputPress(e)
+	if e.input == "menu_decide" or e.scancode == "return" then
+		playSE("mode_decide")
+		saveConfig()
+		scene = SettingsScene()
+	elseif e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
+		loadSave()
+		scene = SettingsScene()
+	end
+end
+
+return TuningScene

tetris/components/grid.lua

@@ -3,6 +3,8 @@ local Object = require 'libs.classic'
 local Grid = Object:extend()
 
 local empty = { skin = "", colour = "" }
+local oob = { skin = "", colour = "" }
+local block = { skin = "2tie", colour = "A" }
 
 function Grid:new()
 	self.grid = {}
@@ -26,8 +28,15 @@ function Grid:clear()
 	end
 end
 
+function Grid:getCell(x, y)
+	if x < 1 or x > 10 or y > 24 then return oob
+	elseif y < 1 then return empty
+	else return self.grid[y][x]
+	end
+end
+
 function Grid:isOccupied(x, y)
-	return self.grid[y+1][x+1] ~= empty
+	return self:getCell(x+1, y+1) ~= empty
 end
 
 function Grid:isRowFull(row)
@@ -46,7 +55,7 @@ function Grid:canPlacePiece(piece)
 	for index, offset in pairs(offsets) do
 		local x = piece.position.x + offset.x
 		local y = piece.position.y + offset.y
-		if x >= 10 or x < 0 or y >= 24 or y < 0 or self.grid[y+1][x+1] ~= empty then
+		if self:isOccupied(x, y) then
 			return false
 		end
 	end
@@ -58,12 +67,12 @@ function Grid:canPlaceBigPiece(piece)
 	for index, offset in pairs(offsets) do
 		local x = piece.position.x + offset.x
 		local y = piece.position.y + offset.y
-		if x >= 5 or x < 0 or y >= 12 or y < 0 or
-			self.grid[y * 2 + 1][x * 2 + 1] ~= empty or
-			self.grid[y * 2 + 1][x * 2 + 2] ~= empty or
-			self.grid[y * 2 + 2][x * 2 + 1] ~= empty or
-			self.grid[y * 2 + 2][x * 2 + 2] ~= empty
-		then
+		if (
+		   self:isOccupied(x * 2 + 0, y * 2 + 0)
+		or self:isOccupied(x * 2 + 1, y * 2 + 0)
+		or self:isOccupied(x * 2 + 0, y * 2 + 1)
+		or self:isOccupied(x * 2 + 1, y * 2 + 1)
+		) then
 			return false
 		end
 	end
@@ -80,7 +89,7 @@ function Grid:canPlacePieceInVisibleGrid(piece)
 	for index, offset in pairs(offsets) do
 		local x = piece.position.x + offset.x
 		local y = piece.position.y + offset.y
-		if x >= 10 or x < 0 or y >= 24 or y < 4 or self.grid[y+1][x+1] ~= empty then
+		if y < 4 or self:isOccupied(x, y) ~= empty then
 			return false
 		end
 	end
@@ -133,14 +142,49 @@ function Grid:copyBottomRow()
 	self.grid[24] = {empty, empty, empty, empty, empty, empty, empty, empty, empty, empty}
 	self.grid_age[24] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 	for col = 1, 10 do
-		self.grid[24][col] = (self.grid[23][col] == empty) and empty or {
-			skin = self.grid[23][col].skin,
-			colour = "G"
-		}
+		self.grid[24][col] = (self.grid[23][col] == empty) and empty or block
 	end
 	return true
 end
 
+function Grid:garbageRise(row_vals)
+		for row = 1, 23 do
+				self.grid[row] = self.grid[row+1]
+				self.grid_age[row] = self.grid_age[row+1]
+		end
+		self.grid[24] = {empty, empty, empty, empty, empty, empty, empty, empty, empty, empty}
+		self.grid_age[24] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+	for col = 1, 10 do
+		self.grid[24][col] = (row_vals[col] == "e") and empty or block
+	end
+end
+
+function Grid:applyFourWide()
+		for row = 1, 24 do
+				local x = self.grid[row]
+				x[1] = x[1]~=block and block or x[1]
+				x[2] = x[2]~=block and block or x[2]
+				x[3] = x[3]~=block and block or x[3]
+				x[8] = x[8]~=block and block or x[8]
+				x[9] = x[9]~=block and block or x[9]
+				x[10] = x[10]~=block and block or x[10]
+		end
+end
+
+function Grid:applyCeiling(lines)
+	for row = 1, lines do
+		for col = 1, 9 do
+			self.grid[row][col] = block
+		end
+	end
+end
+
+function Grid:clearSpecificRow(row)
+	for col = 1, 10 do
+		self.grid[row][col] = empty
+	end
+end
+
 function Grid:applyPiece(piece)
 	if piece.big then
 		self:applyBigPiece(piece)
@@ -150,10 +194,12 @@ function Grid:applyPiece(piece)
 	for index, offset in pairs(offsets) do
 		x = piece.position.x + offset.x
 		y = piece.position.y + offset.y
-		self.grid[y+1][x+1] = {
-			skin = piece.skin,
-			colour = piece.shape
-		}
+		if y + 1 > 0 then
+			self.grid[y+1][x+1] = {
+				skin = piece.skin,
+				colour = piece.colour
+			}
+		end
 	end
 end
 
@@ -164,15 +210,69 @@ function Grid:applyBigPiece(piece)
 		y = piece.position.y + offset.y
 		for a = 1, 2 do
 			for b = 1, 2 do
-				self.grid[y*2+a][x*2+b] = {
-					skin = piece.skin,
-					colour = piece.shape
-				}
+				if y*2+a > 0 then
+					self.grid[y*2+a][x*2+b] = {
+						skin = piece.skin,
+						colour = piece.colour
+					}
+				end
 			end
 		end
 	end
 end
 
+function Grid:checkForBravo(cleared_row_count)
+	for i = 0, 23 - cleared_row_count do
+				for j = 0, 9 do
+						if self:isOccupied(j, i) then return false end
+				end
+		end
+	return true
+end
+
+function Grid:checkStackHeight()
+	for i = 0, 23 do
+		for j = 0, 9 do
+			if self:isOccupied(j, i) then return 24 - i end
+		end
+	end
+	return 0
+end
+
+function Grid:checkSecretGrade()
+	local sgrade = 0
+	for i=23,5,-1 do
+		local validLine = true
+		local emptyCell = 0
+		if i > 13 then
+			emptyCell = 23-i
+		end
+		if i <= 13 then
+			emptyCell = i-5
+		end
+		for j=0,9 do
+			if (not self:isOccupied(j,i) and j ~= emptyCell) or (j == emptyCell and self:isOccupied(j,i)) then
+				validLine = false
+			end
+		end
+		if not self:isOccupied(emptyCell,i-1) then
+			validLine = false
+		end
+		if(validLine) then
+				sgrade = sgrade + 1
+		else
+				return sgrade
+		end
+	end
+	--[[
+	if(sgrade == 0) then return ""
+	elseif(sgrade < 10) then return 10-sgrade
+	elseif(sgrade < 19) then return "S"..(sgrade-9) end
+	return "GM"
+	--]]
+	return sgrade
+end
+
 function Grid:update()
 	for y = 1, 24 do
 		for x = 1, 10 do
@@ -184,14 +284,18 @@ function Grid:update()
 end
 
 function Grid:draw()
-	for y = 1, 24 do
+	for y = 5, 24 do
 		for x = 1, 10 do
 			if self.grid[y][x] ~= empty then
-				if self.grid_age[y][x] < 1 then
+				if self.grid_age[y][x] < 2 then
 					love.graphics.setColor(1, 1, 1, 1)
 					love.graphics.draw(blocks[self.grid[y][x].skin]["F"], 48+x*16, y*16)
 				else
-					love.graphics.setColor(0.5, 0.5, 0.5, 1)
+					if self.grid[y][x].skin == "bone" then
+						love.graphics.setColor(1, 1, 1, 1)
+					else 
+						love.graphics.setColor(0.5, 0.5, 0.5, 1)
+					end
 					love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
 				end
 				if self.grid[y][x].skin ~= "bone" then
@@ -215,33 +319,60 @@ function Grid:draw()
 	end
 end
 
-function Grid:drawInvisible(opacity_function, garbage_opacity_function)
-	for y = 1, 24 do
+function Grid:drawOutline()
+	for y = 5, 24 do
+		for x = 1, 10 do
+			if self.grid[y][x] ~= empty then
+				love.graphics.setColor(0.8, 0.8, 0.8, 1)
+				love.graphics.setLineWidth(1)
+				if y > 1 and self.grid[y-1][x] == empty then
+					love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
+				end
+				if y < 24 and self.grid[y+1][x] == empty then
+					love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
+				end
+				if x > 1 and self.grid[y][x-1] == empty then
+					love.graphics.line(47.5+x*16, -0.0+y*16, 47.5+x*16, 16.0+y*16)
+				end
+				if x < 10 and self.grid[y][x+1] == empty then
+					love.graphics.line(64.5+x*16, -0.0+y*16, 64.5+x*16, 16.0+y*16)
+				end
+			end
+		end
+	end
+end
+
+function Grid:drawInvisible(opacity_function, garbage_opacity_function, lock_flash, brightness)
+	lock_flash = lock_flash == nil and true or lock_flash
+	brightness = brightness == nil and 0.5 or brightness
+	for y = 5, 24 do
 		for x = 1, 10 do
 			if self.grid[y][x] ~= empty then
 				if self.grid[y][x].colour == "X" then
 					opacity = 1
-				elseif garbage_opacity_function and self.grid[y][x].colour == "G" then
+				elseif garbage_opacity_function and self.grid[y][x].colour == "A" then
 					opacity = garbage_opacity_function(self.grid_age[y][x])
 				else
 					opacity = opacity_function(self.grid_age[y][x])
 				end
-				love.graphics.setColor(0.5, 0.5, 0.5, opacity)
+				love.graphics.setColor(brightness, brightness, brightness, opacity)
 				love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
-				if opacity > 0 and self.grid[y][x].colour ~= "X" then
-					love.graphics.setColor(0.64, 0.64, 0.64)
-					love.graphics.setLineWidth(1)
-					if y > 1 and self.grid[y-1][x] == empty then
-						love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
-					end
-					if y < 24 and self.grid[y+1][x] == empty then
-						love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
-					end
-					if x > 1 and self.grid[y][x-1] == empty then
-						love.graphics.line(47.5+x*16, -0.0+y*16, 47.5+x*16, 16.0+y*16)
-					end
-					if x < 10 and self.grid[y][x+1] == empty then
-						love.graphics.line(64.5+x*16, -0.0+y*16, 64.5+x*16, 16.0+y*16)
+				if lock_flash then
+					if opacity > 0 and self.grid[y][x].colour ~= "X" then
+						love.graphics.setColor(0.64, 0.64, 0.64)
+						love.graphics.setLineWidth(1)
+						if y > 1 and self.grid[y-1][x] == empty then
+							love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
+						end
+						if y < 24 and self.grid[y+1][x] == empty then
+							love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
+						end
+						if x > 1 and self.grid[y][x-1] == empty then
+							love.graphics.line(47.5+x*16, -0.0+y*16, 47.5+x*16, 16.0+y*16)
+						end
+						if x < 10 and self.grid[y][x+1] == empty then
+							love.graphics.line(64.5+x*16, -0.0+y*16, 64.5+x*16, 16.0+y*16)
+						end
 					end
 				end
 			end

tetris/components/piece.lua

@@ -2,7 +2,7 @@ local Object = require 'libs.classic'
 
 local Piece = Object:extend()
 
-function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay, skin, big)
+function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay, skin, colour, big)
 	self.shape = shape
 	self.rotation = rotation
 	self.position = position
@@ -10,6 +10,7 @@ function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay
 	self.gravity = gravity
 	self.lock_delay = lock_delay
 	self.skin = skin
+	self.colour = colour
 	self.ghost = false
 	self.locked = false
 	self.big = big
@@ -21,7 +22,7 @@ function Piece:withOffset(offset)
 	return Piece(
 		self.shape, self.rotation,
 		{x = self.position.x + offset.x, y = self.position.y + offset.y},
-		self.block_offsets, self.gravity, self.lock_delay, self.skin, self.big
+		self.block_offsets, self.gravity, self.lock_delay, self.skin, self.colour, self.big
 	)
 end
 
@@ -31,7 +32,7 @@ function Piece:withRelativeRotation(rot)
 	while new_rot >= 4 do new_rot = new_rot - 4 end
 	return Piece(
 		self.shape, new_rot, self.position,
-		self.block_offsets, self.gravity, self.lock_delay, self.skin, self.big
+		self.block_offsets, self.gravity, self.lock_delay, self.skin, self.colour, self.big
 	)
 end
 
@@ -77,12 +78,15 @@ function Piece:setRelativeRotation(rot)
 	return self
 end
 
-function Piece:moveInGrid(step, squares, grid)
+function Piece:moveInGrid(step, squares, grid, instant)
 	local moved = false
 	for x = 1, squares do
 		if grid:canPlacePiece(self:withOffset(step)) then
 			moved = true
 			self:setOffset(step)
+			if instant then
+				self:dropToBottom(grid)
+			end
 		else
 			break
 		end
@@ -97,7 +101,7 @@ end
 
 function Piece:dropToBottom(grid)
 	local piece_y = self.position.y
-	self:dropSquares(20, grid)
+	self:dropSquares(math.huge, grid)
 	self.gravity = 0
 	if self.position.y > piece_y then
 		-- if it got dropped any, also reset lock delay
@@ -139,22 +143,23 @@ function Piece:draw(opacity, brightness, grid, partial_das)
 	love.graphics.setColor(brightness, brightness, brightness, opacity)
 	local offsets = self:getBlockOffsets()
 	local gravity_offset = 0
-	--if grid ~= nil and not self:isDropBlocked(grid) then
-	--	gravity_offset = self.gravity * 16
-	--end
+	if config.gamesettings.smooth_movement == 1 and 
+	   grid ~= nil and not self:isDropBlocked(grid) then
+		gravity_offset = self.gravity * 16
+	end
 	if partial_das == nil then partial_das = 0 end
 	for index, offset in pairs(offsets) do
 		local x = self.position.x + offset.x
 		local y = self.position.y + offset.y
 		if self.big then
 			love.graphics.draw(
-				blocks[self.skin][self.shape],
+				blocks[self.skin][self.colour],
 				64+x*32+partial_das*2, 16+y*32+gravity_offset*2,
 				0, 2, 2
 			)
 		else
 			love.graphics.draw(
-				blocks[self.skin][self.shape],
+				blocks[self.skin][self.colour],
 				64+x*16+partial_das, 16+y*16+gravity_offset
 			)
 		end

tetris/modes/big_a2.lua

@@ -0,0 +1,307 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
+
+local MarathonA2Game = GameMode:extend()
+
+MarathonA2Game.name = "Big A2"
+MarathonA2Game.hash = "BigA2"
+MarathonA2Game.tagline = "The points don't matter! Can you reach the invisible roll? Big mode too!"
+
+
+
+
+function MarathonA2Game:new()
+	self.super:new()
+	self.big_mode = true
+	self.roll_frames = 0
+	self.combo = 1
+
+	self.grade = 0
+	self.grade_points = 0
+	self.grade_point_decay_counter = 0
+	
+	self.randomizer = History6RollsRandomizer()
+
+	self.lock_drop = false
+	self.lock_hard_drop = false
+	self.enable_hold = false
+	self.next_queue_length = 1
+end
+
+function MarathonA2Game:getARE()
+		if self.level < 700 then return 27
+	elseif self.level < 800 then return 18
+	else return 14 end
+end
+
+function MarathonA2Game:getLineARE()
+		if self.level < 600 then return 27
+	elseif self.level < 700 then return 18
+	elseif self.level < 800 then return 14
+	else return 8 end
+end
+
+function MarathonA2Game:getDasLimit()
+		if self.level < 500 then return 15
+	elseif self.level < 900 then return 9
+	else return 7 end
+end
+
+function MarathonA2Game:getLineClearDelay()
+		if self.level < 500 then return 40
+	elseif self.level < 600 then return 25
+	elseif self.level < 700 then return 16
+	elseif self.level < 800 then return 12
+	else return 6 end
+end
+
+function MarathonA2Game:getLockDelay()
+		if self.level < 900 then return 30
+	else return 17 end
+end
+
+function MarathonA2Game:getGravity()
+		if (self.level < 30)  then return 4/256
+	elseif (self.level < 35)  then return 6/256
+	elseif (self.level < 40)  then return 8/256
+	elseif (self.level < 50)  then return 10/256
+	elseif (self.level < 60)  then return 12/256
+	elseif (self.level < 70)  then return 16/256
+	elseif (self.level < 80)  then return 32/256
+	elseif (self.level < 90)  then return 48/256
+	elseif (self.level < 100) then return 64/256
+	elseif (self.level < 120) then return 80/256
+	elseif (self.level < 140) then return 96/256
+	elseif (self.level < 160) then return 112/256
+	elseif (self.level < 170) then return 128/256
+	elseif (self.level < 200) then return 144/256
+	elseif (self.level < 220) then return 4/256
+	elseif (self.level < 230) then return 32/256
+	elseif (self.level < 233) then return 64/256
+	elseif (self.level < 236) then return 96/256
+	elseif (self.level < 239) then return 128/256
+	elseif (self.level < 243) then return 160/256
+	elseif (self.level < 247) then return 192/256
+	elseif (self.level < 251) then return 224/256
+	elseif (self.level < 300) then return 1
+	elseif (self.level < 330) then return 2
+	elseif (self.level < 360) then return 3
+	elseif (self.level < 400) then return 4
+	elseif (self.level < 420) then return 5
+	elseif (self.level < 450) then return 4
+	elseif (self.level < 500) then return 3
+	else return 20
+	end
+end
+
+function MarathonA2Game:advanceOneFrame()
+	if self.clear then
+		self.roll_frames = self.roll_frames + 1
+		if self.roll_frames < 0 then return false end
+		if self.roll_frames > 3694 then
+			self.completed = true
+		end
+	elseif self.ready_frames == 0 then
+		self.frames = self.frames + 1
+	end
+	return true
+end
+
+function MarathonA2Game:onPieceEnter()
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
+		self.level = self.level + 1
+	end
+end
+
+function MarathonA2Game:onLineClear(cleared_row_count)
+	cleared_row_count = cleared_row_count / 2
+	self.level = math.min(self.level + cleared_row_count, 999)
+	if self.level == 999 and not self.clear then
+		self.clear = true
+		self.grid:clear()
+		self.roll_frames = -150
+	end
+	self.lock_drop = self.level >= 900
+	self.lock_hard_drop = self.level >= 900
+end
+
+function MarathonA2Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
+		cleared_lines = cleared_lines / 2
+		self:updateGrade(cleared_lines)
+		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
+		self.drop_bonus = 0
+	end
+end
+
+local grade_point_bonuses = {
+	{10, 20, 40, 50},
+	{10, 20, 30, 40},
+	{10, 20, 30, 40},
+	{10, 15, 30, 40},
+	{10, 15, 20, 40},
+	{5, 15, 20, 30},
+	{5, 10, 20, 30},
+	{5, 10, 15, 30},
+	{5, 10, 15, 30},
+	{5, 10, 15, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+}
+
+local grade_point_decays = {
+	125, 80, 80, 50, 45, 45, 45,
+	40, 40, 40, 40, 40, 30, 30, 30,
+	20, 20, 20, 20, 20,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	10, 10
+}
+
+local combo_multipliers = {
+	{1.0, 1.0, 1.0, 1.0},
+	{1.2, 1.4, 1.5, 1.0},
+	{1.2, 1.5, 1.8, 1.0},
+	{1.4, 1.6, 2.0, 1.0},
+	{1.4, 1.7, 2.2, 1.0},
+	{1.4, 1.8, 2.3, 1.0},
+	{1.4, 1.9, 2.4, 1.0},
+	{1.5, 2.0, 2.5, 1.0},
+	{1.5, 2.1, 2.6, 1.0},
+	{2.0, 2.5, 3.0, 1.0},
+}
+
+local grade_conversion = {
+	[0] = 0,
+	1, 2, 3, 4, 5, 5, 6, 6, 7, 7,
+	7, 8, 8, 8, 9, 9, 9, 10, 11, 12,
+	12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
+	17
+}
+
+function MarathonA2Game:updateGrade(cleared_lines)
+	if self.clear then return end
+	if cleared_lines == 0 then
+		self.grade_point_decay_counter = self.grade_point_decay_counter + 1
+		if self.grade_point_decay_counter >= grade_point_decays[self.grade + 1] then
+			self.grade_point_decay_counter = 0
+			self.grade_points = math.max(0, self.grade_points - 1)
+		end
+	else
+		self.grade_points = self.grade_points + (
+			math.ceil(
+				grade_point_bonuses[self.grade + 1][cleared_lines] *
+				combo_multipliers[math.min(self.combo, 10)][cleared_lines]
+			) * (1 + math.floor(self.level / 250))
+		)
+		if self.grade_points >= 100 and self.grade < 31 then
+			self.grade_points = 0
+			self.grade = self.grade + 1
+		end
+	end
+end
+
+function MarathonA2Game:getLetterGrade()
+	local grade = grade_conversion[self.grade]
+	if grade < 9 then
+		return tostring(9 - grade)
+	elseif grade < 18 then
+		return "S" .. tostring(grade - 8)
+	end
+end
+
+MarathonA2Game.rollOpacityFunction = function(age)
+	if age < 240 then return 1
+	elseif age > 300 then return 0
+	else return 1 - (age - 240) / 60 end
+end
+
+function MarathonA2Game:drawGrid(ruleset)
+	if self.clear and not (self.completed or self.game_over) then
+		self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
+	else
+		self.grid:draw()
+		if self.piece ~= nil and self.level < 100 then
+			self:drawGhostPiece(ruleset)
+		end
+	end
+end
+
+function MarathonA2Game:drawScoringInfo()
+	love.graphics.setColor(1, 1, 1, 1)
+
+	love.graphics.setFont(font_3x5_2)
+	love.graphics.print(
+		self.das.direction .. " " ..
+		self.das.frames .. " " ..
+		strTrueValues(self.prev_inputs)
+	)
+	love.graphics.printf("NEXT", 64, 40, 40, "left")
+	love.graphics.printf("GRADE", 240, 120, 40, "left")
+	love.graphics.printf("SCORE", 240, 200, 40, "left")
+	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+
+	love.graphics.setFont(font_3x5_3)
+	if self.roll_frames > 3694 then love.graphics.setColor(1, 0.5, 0, 1)
+	elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
+	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
+	love.graphics.printf(self.score, 240, 220, 90, "left")
+	love.graphics.printf(self.level, 240, 340, 40, "right")
+	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
+
+	love.graphics.setFont(font_8x11)
+	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
+end
+
+function MarathonA2Game:getHighscoreData()
+	return {
+		grade = grade_conversion[self.grade],
+		score = self.score,
+		level = self.level,
+		frames = self.frames,
+	}
+end
+
+function MarathonA2Game:getSectionEndLevel()
+	if self.level >= 900 then return 999
+	else return math.floor(self.level / 100 + 1) * 100 end
+end
+
+function MarathonA2Game:getBackground()
+	return math.floor(self.level / 100)
+end
+
+return MarathonA2Game

tetris/modes/demon_mode.lua

@@ -1,258 +0,0 @@
-require 'funcs'
-
-local GameMode = require 'tetris.modes.gamemode'
-local Piece = require 'tetris.components.piece'
-
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
-
-local DemonModeGame = GameMode:extend()
-
-DemonModeGame.name = "Demon Mode"
-DemonModeGame.hash = "DemonMode"
-DemonModeGame.tagline = "Can you handle the ludicrous speed past level 20?"
-
-
-
-
-function DemonModeGame:new()
-	DemonModeGame.super:new()
-	self.roll_frames = 0
-	self.combo = 1
-	self.randomizer = History6RollsRandomizer()
-
-	self.grade = 0
-	self.section_start_time = 0
-	self.section_times = { [0] = 0 }
-	self.section_tetris_count = 0
-	self.section_tries = 0
-
-	self.enable_hold = true
-	self.lock_drop = true
-	self.next_queue_length = 3
-end
-
-function DemonModeGame:getARE()
-	    if self.level < 500 then return 30
-	elseif self.level < 600 then return 25
-	elseif self.level < 700 then return 15
-	elseif self.level < 800 then return 14
-	elseif self.level < 900 then return 12
-	elseif self.level < 1000 then return 11
-	elseif self.level < 1100 then return 10
-	elseif self.level < 1300 then return 8
-	elseif self.level < 1400 then return 6
-	elseif self.level < 1700 then return 4
-	elseif self.level < 1800 then return 3
-	elseif self.level < 1900 then return 2
-	elseif self.level < 2000 then return 1
-	else return 0 end
-end
-
-function DemonModeGame:getLineARE()
-	return self:getARE()
-end
-
-function DemonModeGame:getDasLimit()
-	    if self.level < 500 then return 15
-	elseif self.level < 1000 then return 10
-	elseif self.level < 1500 then return 5
-	elseif self.level < 1700 then return 4
-	elseif self.level < 1900 then return 3
-	elseif self.level < 2000 then return 2
-	else return 1 end
-end
-
-function DemonModeGame:getLineClearDelay()
-		if self.level < 600 then return 15
-	elseif self.level < 800 then return 10
-	elseif self.level < 1000 then return 8
-	elseif self.level < 1500 then return 5
-	elseif self.level < 1700 then return 3
-	elseif self.level < 1900 then return 2
-	elseif self.level < 2000 then return 1
-	else return 0 end
-end
-
-function DemonModeGame:getLockDelay()
-		if self.level < 100 then return 30
-	elseif self.level < 200 then return 25
-	elseif self.level < 300 then return 22
-	elseif self.level < 400 then return 20
-	elseif self.level < 1000 then return 15
-	elseif self.level < 1200 then return 10
-	elseif self.level < 1400 then return 9
-	elseif self.level < 1500 then return 8
-	elseif self.level < 1600 then return 7
-	elseif self.level < 1700 then return 6
-	elseif self.level < 1800 then return 5
-	elseif self.level < 1900 then return 4
-	elseif self.level < 2000 then return 3
-	else return 2 end
-end
-
-function DemonModeGame:getGravity()
-	return 20
-end
-
-local function getSectionForLevel(level)
-	return math.floor(level / 100) + 1
-end
-
-local cleared_row_levels = {1, 3, 6, 10}
-
-function DemonModeGame:advanceOneFrame()
-	if self.clear then
-		self.roll_frames = self.roll_frames + 1
-		if self.roll_frames < 0 then
-			return false
-		elseif self.roll_frames >= 1337 then
-			self.completed = true
-		end
-	elseif self.ready_frames == 0 then
-		self.frames = self.frames + 1
-	end
-end
-
-function DemonModeGame:onPieceEnter()
-	if (self.level % 100 ~= 99) and self.frames ~= 0 then
-		self.level = self.level + 1
-	end
-end
-
-function DemonModeGame:onLineClear(cleared_row_count)
-	if cleared_row_count == 4 then
-		self.section_tetris_count = self.section_tetris_count + 1
-	end
-	local advanced_levels = cleared_row_levels[cleared_row_count]
-	if not self.clear then
-		self:updateSectionTimes(self.level, self.level + advanced_levels)
-	end
-end
-
-function DemonModeGame:updateSectionTimes(old_level, new_level)
-	local section = math.floor(old_level / 100) + 1
-	if math.floor(old_level / 100) < math.floor(new_level / 100) then
-		-- If at least one Tetris in this section hasn't been made,
-		-- deny section passage.
-		if old_level > 500 then
-			if self.section_tetris_count == 0 then
-				self.level = 100 * math.floor(old_level / 100)
-				self.section_tries = self.section_tries + 1
-			else
-				self.level = math.min(new_level, 2500)
-				-- if this is first try (no denials, add a grade)
-				if self.section_tries == 0 then
-					self.grade = self.grade + 1
-				end
-				self.section_tries = 0
-				self.section_tetris_count = 0
-				-- record new section
-				section_time = self.frames - self.section_start_time
-				table.insert(self.section_times, section_time)
-				self.section_start_time = self.frames
-				-- maybe clear
-				if self.level == 2500 and not self.clear then
-					self.clear = true
-					self.grid:clear()
-					self.roll_frames = -150
-				end
-			end
-		elseif old_level < 100 then
-			-- If section time is under cutoff, skip to level 500.
-			if self.frames < sp(1,00) then
-				self.level = 500
-				self.grade = 5
-				self.section_tries = 0
-				self.section_tetris_count = 0
-			else
-				self.level = math.min(new_level, 2500)
-			end
-			-- record new section
-			section_time = self.frames - self.section_start_time
-			table.insert(self.section_times, section_time)
-			self.section_start_time = self.frames
-		end
-	else
-		self.level = math.min(new_level, 2500)
-	end
-end
-
-function DemonModeGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
-		self.drop_bonus = 0
-		self.combo = 1
-	end
-end
-
-local letter_grades = {
-	[0] = "", "D", "C", "B", "A",
-	"S", "S-A", "S-B", "S-C", "S-D",
-	"X", "X-A", "X-B", "X-C", "X-D",
-	"W", "W-A", "W-B", "W-C", "W-D",
-	"Master", "MasterS", "MasterX", "MasterW", "Grand Master",
-	"Demon Master"
-}
-
-function DemonModeGame:getLetterGrade()
-	return letter_grades[self.grade]
-end
-
-function DemonModeGame:drawGrid()
-	if self.clear and not (self.completed or self.game_over) then
-		self.grid:drawInvisible(self.rollOpacityFunction)
-	else
-		self.grid:draw()
-	end
-end
-
-DemonModeGame.rollOpacityFunction = function(age)
-	if age > 4 then return 0
-	else return 1 - age / 4 end
-end
-
-function DemonModeGame:drawScoringInfo()
-	DemonModeGame.super.drawScoringInfo(self)
-	
-	love.graphics.setColor(1, 1, 1, 1)
-
-	love.graphics.setFont(font_3x5_2)
-	love.graphics.print(
-		self.das.direction .. " " ..
-		self.das.frames .. " " ..
-		st(self.prev_inputs)
-	)
-	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("GRADE", 240, 120, 40, "left")
-	love.graphics.printf("SCORE", 240, 200, 40, "left")
-	love.graphics.printf("LEVEL", 240, 320, 40, "left")
-
-	-- draw section time data
-	local current_section = getSectionForLevel(self.level)
-	self:drawSectionTimesWithSecondary(current_section)
-
-	love.graphics.setFont(font_3x5_3)
-	love.graphics.printf(self.score, 240, 220, 90, "left")
-	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
-	love.graphics.printf(string.format("%.2f", self.level / 100), 240, 340, 70, "right")
-end
-
-function DemonModeGame:getHighscoreData()
-	return {
-		grade = self.grade,
-		level = self.level,
-		frames = self.frames,
-	}
-end
-
-function DemonModeGame:getBackground()
-	return math.floor(self.level / 100)
-end
-
-return DemonModeGame

tetris/modes/gamemode.lua

@@ -1,6 +1,9 @@
 local Object = require 'libs.classic'
 require 'funcs'
 
+local playedReadySE = false
+local playedGoSE = false
+
 local Grid = require 'tetris.components.grid'
 local Randomizer = require 'tetris.randomizers.randomizer'
 
@@ -40,9 +43,19 @@ function GameMode:new()
 	self.draw_section_times = false
 	self.draw_secondary_section_times = false
 	self.big_mode = false
+	self.irs = true
+	self.ihs = true
+	self.rpc_details = "In game"
+	self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
 	-- variables related to configurable parameters
 	self.drop_locked = false
 	self.hard_drop_locked = false
+	self.lock_on_soft_drop = false
+	self.lock_on_hard_drop = false
 	self.hold_queue = nil
 	self.held = false
 	self.section_start_time = 0
@@ -50,13 +63,6 @@ function GameMode:new()
 	self.secondary_section_times = { [0] = 0 }
 end
 
-function GameMode:initialize()
-	-- after all the variables are initialized, run initialization procedures
-	for i = 1, 30 do
-		table.insert(self.next_queue, self:getNextPiece(ruleset))
-	end
-end
-
 function GameMode:getARR() return 1 end
 function GameMode:getDropSpeed() return 1 end
 function GameMode:getARE() return 25 end
@@ -66,6 +72,7 @@ function GameMode:getLineClearDelay() return 40 end
 function GameMode:getDasLimit() return 15 end
 
 function GameMode:getNextPiece(ruleset)
+	
 	return {
 		skin = "2tie",
 		shape = self.randomizer:nextPiece(),
@@ -75,9 +82,12 @@ end
 
 function GameMode:initialize(ruleset)
 	-- generate next queue
+	self:new()
 	for i = 1, self.next_queue_length do
 		table.insert(self.next_queue, self:getNextPiece(ruleset))
 	end
+	self.lock_on_soft_drop = ({ruleset.softdrop_lock, self.instant_soft_drop, false, true })[config.gamesettings.manlock]
+	self.lock_on_hard_drop = ({ruleset.harddrop_lock, self.instant_hard_drop, true,  false})[config.gamesettings.manlock]
 end
 
 function GameMode:update(inputs, ruleset)
@@ -90,11 +100,31 @@ function GameMode:update(inputs, ruleset)
 	end
 	if self.completed then return end
 
+	if config.gamesettings.diagonal_input == 2 then
+		if inputs["left"] or inputs["right"] then
+			inputs["up"] = false
+			inputs["down"] = false
+		elseif inputs["up"] or inputs["down"] then
+			inputs["left"] = false
+			inputs["right"] = false
+		end
+	end
+
 	-- advance one frame
-	if self:advanceOneFrame(inputs) == false then return end
+	if self:advanceOneFrame(inputs, ruleset) == false then return end
 
 	self:chargeDAS(inputs, self:getDasLimit(), self.getARR())
 
+	-- set attempt flags
+	if inputs["left"] or inputs["right"] then self:onAttemptPieceMove(self.piece) end
+	if
+		inputs["rotate_left"] or inputs["rotate_right"] or
+		inputs["rotate_left2"] or inputs["rotate_right2"] or
+		inputs["rotate_180"]
+	then
+		self:onAttemptPieceRotate(self.piece)
+	end
+	
 	if self.piece == nil then
 		self:processDelays(inputs, ruleset)
 	else
@@ -102,7 +132,7 @@ function GameMode:update(inputs, ruleset)
 		self:whilePieceActive()
 		local gravity = self:getGravity()
 
-		if self.enable_hold and inputs["hold"] == true and self.held == false then
+		if self.enable_hold and inputs["hold"] == true and self.held == false and self.prev_inputs["hold"] == false then
 			self:hold(inputs, ruleset)
 			self.prev_inputs = inputs
 			return
@@ -131,7 +161,7 @@ function GameMode:update(inputs, ruleset)
 			self.piece:isDropBlocked(self.grid) and
 			not self.hard_drop_locked then
 			self:onHardDrop(piece_dy)
-			if self.instant_hard_drop then
+			if self.lock_on_hard_drop then
 				self.piece.locked = true
 			end
 		end
@@ -140,7 +170,7 @@ function GameMode:update(inputs, ruleset)
 			self:onSoftDrop(piece_dy)
 			if self.piece:isDropBlocked(self.grid) and
 				not self.drop_locked and
-				self.instant_soft_drop
+				self.lock_on_soft_drop
 			then
 				self.piece.locked = true
 			end
@@ -161,6 +191,7 @@ function GameMode:update(inputs, ruleset)
 			end
 
 			if cleared_row_count > 0 then
+				playSE("erase")
 				self.lcd = self:getLineClearDelay()
 				self.are = self:getLineARE()
 				if self.lcd == 0 then
@@ -194,8 +225,14 @@ end
 
 -- event functions
 function GameMode:whilePieceActive() end
-function GameMode:onPieceLock(piece, cleared_row_count) end
+function GameMode:onAttemptPieceMove(piece) end
+function GameMode:onAttemptPieceRotate(piece) end
+function GameMode:onPieceLock(piece, cleared_row_count) 
+	playSE("lock")
+end
+
 function GameMode:onLineClear(cleared_row_count) end
+
 function GameMode:onPieceEnter() end
 function GameMode:onHold() end
 
@@ -211,49 +248,121 @@ function GameMode:onGameOver()
 	switchBGM(nil)
 end
 
-function GameMode:chargeDAS(inputs)
-	if inputs[self.das.direction] == true then
-		local das_frames = self.das.frames + 1
-		if das_frames >= self:getDasLimit() then
-			if self.das.direction == "left" then
-				self.move = (self:getARR() == 0 and "speed" or "") .. "left"
-				self.das.frames = self:getDasLimit() - self:getARR()
-			elseif self.das.direction == "right" then
-				self.move = (self:getARR() == 0 and "speed" or "") .. "right"
-				self.das.frames = self:getDasLimit() - self:getARR()
-			end
-		else
-			self.move = "none"
-			self.das.frames = das_frames
+-- DAS functions
+
+function GameMode:startRightDAS()
+	self.move = "right"
+	self.das = { direction = "right", frames = 0 }
+	if self:getDasLimit() == 0 then
+		self:continueDAS()
+	end
+end
+
+function GameMode:startLeftDAS()
+	self.move = "left"
+	self.das = { direction = "left", frames = 0 }
+	if self:getDasLimit() == 0 then
+		self:continueDAS()
+	end
+end
+
+function GameMode:continueDAS()
+	local das_frames = self.das.frames + 1
+	if das_frames >= self:getDasLimit() then
+		if self.das.direction == "left" then
+			self.move = (self:getARR() == 0 and "speed" or "") .. "left"
+			self.das.frames = self:getDasLimit() - self:getARR()
+		elseif self.das.direction == "right" then
+			self.move = (self:getARR() == 0 and "speed" or "") .. "right"
+			self.das.frames = self:getDasLimit() - self:getARR()
 		end
-	elseif inputs["right"] == true then
-		self.move = "right"
-		self.das = { direction = "right", frames = 0 }
-	elseif inputs["left"] == true then
-		self.move = "left"
-		self.das = { direction = "left", frames = 0 }
 	else
 		self.move = "none"
-		self.das = { direction = "none", frames = -1 }
+		self.das.frames = das_frames
+	end
+end
+
+function GameMode:stopDAS()
+	self.move = "none"
+	self.das = { direction = "none", frames = -1 }
+end
+
+function GameMode:chargeDAS(inputs)
+	if config["das_last_key"] then
+		if inputs["right"] == true and self.das.direction ~= "right" and not self.prev_inputs["right"] then
+			self:startRightDAS()
+		elseif inputs["left"] == true and self.das.direction ~= "left" and not self.prev_inputs["left"] then
+			self:startLeftDAS()
+		elseif inputs[self.das.direction] == true then
+			self:continueDAS()
+		else
+			self:stopDAS()
+		end
+	else  -- default behaviour, das first key pressed
+		if inputs[self.das.direction] == true then
+			self:continueDAS()
+		elseif inputs["right"] == true then
+			self:startRightDAS()
+		elseif inputs["left"] == true then
+			self:startLeftDAS()
+		else
+			self:stopDAS()
+		end
 	end
 end
 
 function GameMode:processDelays(inputs, ruleset, drop_speed)
+	if self.ready_frames == 100 then
+		playedReadySE = false
+		playedGoSE = false
+	end
 	if self.ready_frames > 0 then
+		if not playedReadySE then
+			playedReadySE = true
+			playSEOnce("ready")
+		end
 		self.ready_frames = self.ready_frames - 1
+		if self.ready_frames == 50 and not playedGoSE then
+			playedGoSE = true
+			playSEOnce("go")
+		end
 		if self.ready_frames == 0 then
 			self:initializeOrHold(inputs, ruleset)
 		end
 	elseif self.lcd > 0 then
 		self.lcd = self.lcd - 1
+		if ruleset.are_cancel and
+			(self.move == "none" and not self.prev_inputs["up"] and
+			not self.prev_inputs["rotate_left"] and not self.prev_inputs["rotate_left2"] and
+			not self.prev_inputs["rotate_right"] and not self.prev_inputs["rotate_right2"] and
+			not self.prev_inputs["rotate_180"]) and
+			(inputs["left"] or inputs["right"] or inputs["up"] or
+			inputs["rotate_left"] or inputs["rotate_left2"] or
+			inputs["rotate_right"] or inputs["rotate_right2"] or
+			inputs["rotate_180"]) then
+			self.lcd = 0
+			self.are = 0
+		end
 		if self.lcd == 0 then
 			self.grid:clearClearedRows()
+			playSE("fall")
 			if self.are == 0 then
 				self:initializeOrHold(inputs, ruleset)
 			end
 		end
 	elseif self.are > 0 then
 		self.are = self.are - 1
+		if ruleset.are_cancel and
+			(self.move == "none" and not self.prev_inputs["up"] and
+			not self.prev_inputs["rotate_left"] and not self.prev_inputs["rotate_left2"] and
+			not self.prev_inputs["rotate_right"] and not self.prev_inputs["rotate_right2"] and
+			not self.prev_inputs["rotate_180"]) and
+			(inputs["left"] or inputs["right"] or inputs["up"] or
+			inputs["rotate_left"] or inputs["rotate_left2"] or
+			inputs["rotate_right"] or inputs["rotate_right2"] or
+			inputs["rotate_180"]) then
+			self.are = 0
+		end
 		if self.are == 0 then
 			self:initializeOrHold(inputs, ruleset)
 		end
@@ -261,8 +370,8 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 end
 
 function GameMode:initializeOrHold(inputs, ruleset)
-	if self.enable_hold and inputs["hold"] == true then
-		self:hold(inputs, ruleset)
+	if self.ihs and self.enable_hold and inputs["hold"] == true then
+		self:hold(inputs, ruleset, true)
 	else
 		self:initializeNextPiece(inputs, ruleset, self.next_queue[1])
 	end
@@ -273,7 +382,7 @@ function GameMode:initializeOrHold(inputs, ruleset)
 	end
 end
 
-function GameMode:hold(inputs, ruleset)
+function GameMode:hold(inputs, ruleset, ihs)
 	local data = copy(self.hold_queue)
 	if self.piece == nil then
 		self.hold_queue = self.next_queue[1]
@@ -292,6 +401,8 @@ function GameMode:hold(inputs, ruleset)
 		self:initializeNextPiece(inputs, ruleset, data, false)
 	end
 	self.held = true
+	if ihs then playSE("ihs")
+	else playSE("hold") end
 	self:onHold()
 end
 
@@ -301,7 +412,8 @@ function GameMode:initializeNextPiece(inputs, ruleset, piece_data, generate_next
 		inputs, piece_data, self.grid, gravity,
 		self.prev_inputs, self.move,
 		self:getLockDelay(), self:getDropSpeed(),
-		self.lock_drop, self.lock_hard_drop, self.big_mode
+		self.lock_drop, self.lock_hard_drop, self.big_mode,
+		self.irs
 	)
 	if self.lock_drop then
 		self.drop_locked = true
@@ -346,11 +458,12 @@ function GameMode:drawGhostPiece(ruleset)
 end
 
 function GameMode:drawNextQueue(ruleset)
+	local colourscheme = ({ruleset.colourscheme, ColourSchemes.Arika, ColourSchemes.TTC})[config.gamesettings.piece_colour]
 	function drawPiece(piece, skin, offsets, pos_x, pos_y)
 		for index, offset in pairs(offsets) do
-			local x = ruleset.spawn_positions[piece].x + offset.x
-			local y = ruleset.spawn_positions[piece].y + offset.y
-			love.graphics.draw(blocks[skin][piece], pos_x+x*16, pos_y+y*16)
+			local x = offset.x + ruleset.spawn_positions[piece].x
+			local y = offset.y + 4.7
+			love.graphics.draw(blocks[skin][colourscheme[piece]], pos_x+x*16, pos_y+y*16)
 		end
 	end
 	for i = 1, self.next_queue_length do
@@ -364,8 +477,9 @@ function GameMode:drawNextQueue(ruleset)
 			drawPiece(next_piece, skin, ruleset.block_offsets[next_piece][rotation], -16+i*80, -32)
 		end
 	end
-	if self.hold_queue ~= nil then
-		self:setHoldOpacity()
+	if self.hold_queue ~= nil and self.enable_hold then
+		local hold_color = self.held and 0.6 or 1
+		self:setHoldOpacity(1, hold_color)
 		drawPiece(
 			self.hold_queue.shape, 
 			self.hold_queue.skin, 
@@ -376,8 +490,16 @@ function GameMode:drawNextQueue(ruleset)
 	return false
 end
 
-function GameMode:setNextOpacity(i) love.graphics.setColor(1, 1, 1, 1) end
-function GameMode:setHoldOpacity() love.graphics.setColor(1, 1, 1, 1) end
+function GameMode:setNextOpacity(i, j)
+		i = i ~= nil and i or 1
+		j = j ~= nil and j or 1
+		love.graphics.setColor(j, j, j, i)
+end
+function GameMode:setHoldOpacity(i, j)
+	i = i ~= nil and i or 1
+	j = j ~= nil and j or 1
+	love.graphics.setColor(j, j, j, i)
+end
 
 function GameMode:drawScoringInfo()
 	love.graphics.setColor(1, 1, 1, 1)
@@ -392,7 +514,7 @@ function GameMode:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs) ..
+		strTrueValues(self.prev_inputs) ..
 		self.drop_bonus
 	)
 
@@ -412,6 +534,10 @@ function GameMode:drawSectionTimes(current_section)
 	love.graphics.printf(formatTime(self.frames - self.section_start_time), section_x, 40 + 20 * current_section, 90, "left")
 end
 
+function GameMode:sectionColourFunction(section)
+	return { 1, 1, 1, 1 }
+end
+
 function GameMode:drawSectionTimesWithSecondary(current_section)
 	local section_x = 530
 	local section_secondary_x = 440
@@ -423,9 +549,11 @@ function GameMode:drawSectionTimesWithSecondary(current_section)
 	end
 
 	for section, time in pairs(self.secondary_section_times) do
+		love.graphics.setColor(self:sectionColourFunction(section))
 		if section > 0 then
 			love.graphics.printf(formatTime(time), section_secondary_x, 40 + 20 * section, 90, "left")
 		end
+		love.graphics.setColor(1, 1, 1, 1)
 	end
 
 	local current_x

tetris/modes/interval_training.lua

@@ -1,155 +0,0 @@
-require 'funcs'
-
-local GameMode = require 'tetris.modes.gamemode'
-local Piece = require 'tetris.components.piece'
-
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
-
-local IntervalTrainingGame = GameMode:extend()
-
-IntervalTrainingGame.name = "Interval Training"
-IntervalTrainingGame.hash = "IntervalTraining"
-IntervalTrainingGame.tagline = "Can you clear the time hurdles when the game goes this fast?"
-
-
-
-
-function IntervalTrainingGame:new()
-	IntervalTrainingGame.super:new()
-	self.roll_frames = 0
-	self.combo = 1
-	self.randomizer = History6RollsRandomizer()
-	self.section_time_limit = 1800
-	self.section_start_time = 0
-	self.section_times = { [0] = 0 }
-	self.lock_drop = true
-	self.enable_hold = true
-	self.next_queue_length = 3
-end
-
-function IntervalTrainingGame:getARE()
-	return 4
-end
-
-function IntervalTrainingGame:getLineARE()
-	return 4
-end
-
-function IntervalTrainingGame:getDasLimit()
-	return 6
-end
-
-function IntervalTrainingGame:getLineClearDelay()
-	return 6
-end
-
-function IntervalTrainingGame:getLockDelay()
-	return 15
-end
-
-function IntervalTrainingGame:getGravity()
-	return 20
-end
-
-function IntervalTrainingGame:getSection()
-	return math.floor(level / 100) + 1
-end
-
-function IntervalTrainingGame:advanceOneFrame()
-	if self.clear then
-		self.roll_frames = self.roll_frames + 1
-		if self.roll_frames > 2968 then
-			self.completed = true
-		end
-		return false
-	elseif self.ready_frames == 0 then
-		self.frames = self.frames + 1
-		if self:getSectionTime() >= self.section_time_limit then
-			self.game_over = true
-		end
-	end
-	return true
-end
-
-function IntervalTrainingGame:onPieceEnter()
-	if (self.level % 100 ~= 99 or self.level == 998) and not self.clear and self.frames ~= 0 then
-		self.level = self.level + 1
-	end
-end
-
-function IntervalTrainingGame:onLineClear(cleared_row_count)
-	if not self.clear then
-		local new_level = self.level + cleared_row_count
-		self:updateSectionTimes(self.level, new_level)
-		self.level = math.min(new_level, 999)
-		if self.level == 999 then
-			self.clear = true
-		end
-	end
-end
-
-function IntervalTrainingGame:getSectionTime()
-	return self.frames - self.section_start_time
-end
-
-function IntervalTrainingGame:updateSectionTimes(old_level, new_level)
-	if math.floor(old_level / 100) < math.floor(new_level / 100) then
-		-- record new section
-		table.insert(self.section_times, self:getSectionTime())
-		self.section_start_time = self.frames
-	else
-		self.level = math.min(new_level, 999)
-	end
-end
-
-function IntervalTrainingGame:drawGrid(ruleset)
-	self.grid:draw()
-end
-
-function IntervalTrainingGame:getHighscoreData()
-	return {
-		level = self.level,
-		frames = self.frames,
-	}
-end
-
-function IntervalTrainingGame:drawScoringInfo()
-	love.graphics.setColor(1, 1, 1, 1)
-
-	love.graphics.setFont(font_3x5_2)
-	love.graphics.print(
-		self.das.direction .. " " ..
-		self.das.frames .. " " ..
-		st(self.prev_inputs)
-	)
-	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
-	love.graphics.printf("LEVEL", 240, 320, 40, "left")
-
-	local current_section = math.floor(self.level / 100) + 1
-	self:drawSectionTimesWithSplits(current_section)
-
-	love.graphics.setFont(font_3x5_3)
-	love.graphics.printf(self.level, 240, 340, 40, "right")
-
-	-- draw time left, flash red if necessary
-	local time_left = self.section_time_limit - math.max(self:getSectionTime(), 0)
-	if not self.game_over and not self.clear and time_left < sp(0,10) and time_left % 4 < 2 then
-		love.graphics.setColor(1, 0.3, 0.3, 1)
-	end
-	love.graphics.printf(formatTime(time_left), 240, 270, 160, "left")
-
-	love.graphics.setColor(1, 1, 1, 1)
-	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
-end
-
-function IntervalTrainingGame:getSectionEndLevel()
-	if self.level >= 900 then return 999
-	else return math.floor(self.level / 100 + 1) * 100 end
-end
-
-function IntervalTrainingGame:getBackground()
-	return math.floor(self.level / 100)
-end
-
-return IntervalTrainingGame

tetris/modes/marathon_2020.lua

@@ -36,10 +36,12 @@ function Marathon2020Game:new()
 	self.grade_points = 0
 	self.grade_point_decay_counter = 0
 	self.max_grade_points = 0
+
+	self.cool_timer = 0
 end
 
 function Marathon2020Game:getARE()
-	    if self.delay_level < 1 then return 27
+		if self.delay_level < 1 then return 27
 	elseif self.delay_level < 2 then return 24
 	elseif self.delay_level < 3 then return 21
 	elseif self.delay_level < 4 then return 18
@@ -58,7 +60,7 @@ function Marathon2020Game:getLineARE()
 end
 
 function Marathon2020Game:getDasLimit()
-	    if self.delay_level < 1 then return 15
+		if self.delay_level < 1 then return 15
 	elseif self.delay_level < 3 then return 12
 	elseif self.delay_level < 5 then return 9
 	elseif self.delay_level < 8 then return 8
@@ -70,7 +72,7 @@ function Marathon2020Game:getDasLimit()
 end
 
 function Marathon2020Game:getLineClearDelay()
-	    if self.delay_level < 1 then return 40
+		if self.delay_level < 1 then return 40
 	elseif self.delay_level < 3 then return 25
 	elseif self.delay_level < 4 then return 20
 	elseif self.delay_level < 5 then return 15
@@ -82,7 +84,7 @@ function Marathon2020Game:getLineClearDelay()
 end
 
 function Marathon2020Game:getLockDelay()
-	    if self.delay_level < 6 then return 30
+		if self.delay_level < 6 then return 30
 	elseif self.delay_level < 7 then return 26
 	elseif self.delay_level < 8 then return 22
 	elseif self.delay_level < 9 then return 19
@@ -96,35 +98,35 @@ function Marathon2020Game:getLockDelay()
 end
 
 function Marathon2020Game:getGravity()
-	    if self.level < 30  then return 4/256
+		if self.level < 30  then return 4/256
 	elseif self.level < 35  then return 6/256
-    elseif self.level < 40  then return 8/256
-    elseif self.level < 50  then return 10/256
-    elseif self.level < 60  then return 12/256
-    elseif self.level < 70  then return 16/256
-    elseif self.level < 80  then return 32/256
-    elseif self.level < 90  then return 48/256
-    elseif self.level < 100 then return 64/256
-    elseif self.level < 120 then return 80/256
-    elseif self.level < 140 then return 96/256
-    elseif self.level < 160 then return 112/256
-    elseif self.level < 170 then return 128/256
-    elseif self.level < 200 then return 144/256
-    elseif self.level < 220 then return 4/256
-    elseif self.level < 230 then return 32/256
-    elseif self.level < 233 then return 64/256
-    elseif self.level < 236 then return 96/256
-    elseif self.level < 239 then return 128/256
-    elseif self.level < 243 then return 160/256
-    elseif self.level < 247 then return 192/256
-    elseif self.level < 251 then return 224/256
+	elseif self.level < 40  then return 8/256
+	elseif self.level < 50  then return 10/256
+	elseif self.level < 60  then return 12/256
+	elseif self.level < 70  then return 16/256
+	elseif self.level < 80  then return 32/256
+	elseif self.level < 90  then return 48/256
+	elseif self.level < 100 then return 64/256
+	elseif self.level < 120 then return 80/256
+	elseif self.level < 140 then return 96/256
+	elseif self.level < 160 then return 112/256
+	elseif self.level < 170 then return 128/256
+	elseif self.level < 200 then return 144/256
+	elseif self.level < 220 then return 4/256
+	elseif self.level < 230 then return 32/256
+	elseif self.level < 233 then return 64/256
+	elseif self.level < 236 then return 96/256
+	elseif self.level < 239 then return 128/256
+	elseif self.level < 243 then return 160/256
+	elseif self.level < 247 then return 192/256
+	elseif self.level < 251 then return 224/256
 	elseif self.level < 300 then return 1
-    elseif self.level < 330 then return 2
-    elseif self.level < 360 then return 3
-    elseif self.level < 400 then return 4
-    elseif self.level < 420 then return 5
-    elseif self.level < 450 then return 4
-    elseif self.level < 500 then return 3
+	elseif self.level < 330 then return 2
+	elseif self.level < 360 then return 3
+	elseif self.level < 400 then return 4
+	elseif self.level < 420 then return 5
+	elseif self.level < 450 then return 4
+	elseif self.level < 500 then return 3
 	else return 20 end
 end
 
@@ -142,6 +144,7 @@ function Marathon2020Game:advanceOneFrame()
 		if self.roll_frames < 0 then
 			return false
 		elseif self.roll_frames > 4000 then
+			if self.grade >= 30 and self.section_cool_count >= 20 then self.grade = 31 end
 			self.completed = true
 		end
 	elseif self.ready_frames == 0 then
@@ -151,11 +154,11 @@ function Marathon2020Game:advanceOneFrame()
 end
 
 local cool_cutoffs = {
-	sp(0,45,00), sp(0,41,50), sp(0,38,50), sp(0,35,00), sp(0,32,50),
-	sp(0,29,20), sp(0,27,20), sp(0,24,80), sp(0,22,80), sp(0,20,60),
-	sp(0,19,60), sp(0,19,40), sp(0,19,40), sp(0,18,40), sp(0,18,20),
-	sp(0,16,20), sp(0,16,20), sp(0,16,20), sp(0,16,20), sp(0,16,20),
-	sp(0,15,20)
+	frameTime(0,45,00), frameTime(0,41,50), frameTime(0,38,50), frameTime(0,35,00), frameTime(0,32,50),
+	frameTime(0,29,20), frameTime(0,27,20), frameTime(0,24,80), frameTime(0,22,80), frameTime(0,20,60),
+	frameTime(0,19,60), frameTime(0,19,40), frameTime(0,19,40), frameTime(0,18,40), frameTime(0,18,20),
+	frameTime(0,16,20), frameTime(0,16,20), frameTime(0,16,20), frameTime(0,16,20), frameTime(0,16,20),
+	frameTime(0,15,20)
 }
 
 local levels_for_cleared_rows = { 1, 2, 4, 6 }
@@ -246,6 +249,7 @@ function Marathon2020Game:updateGrade(cleared_lines)
 end
 
 function Marathon2020Game:getTotalGrade()
+	if self.grade + self.section_cool_count > 50 then return "GM" end
 	return self.grade + self.section_cool_count
 end
 
@@ -258,7 +262,7 @@ local function getSectionForLevel(level)
 end
 
 function Marathon2020Game:getEndOfSectionForSection(section)
-	    if self.torikan_passed[900] == false and section == 10 then return 999
+		if self.torikan_passed[900] == false and section == 10 then return 999
 	elseif self.torikan_passed[1900] == false and section == 20 then return 2000
 	elseif section == 20 then return 2020
 	else return section * 100 end
@@ -284,11 +288,11 @@ function Marathon2020Game:sectionPassed(old_level, new_level)
 end
 
 function Marathon2020Game:checkTorikan(section)
-	if section == 5 and self.frames < sp(6,00,00) then self.torikan_passed[500] = true end
-	if section == 9 and self.frames < sp(8,30,00) then self.torikan_passed[900] = true end
-	if section == 10 and self.frames < sp(8,45,00) then self.torikan_passed[1000] = true end
-	if section == 15 and self.frames < sp(11,30,00) then self.torikan_passed[1500] = true end
-	if section == 19 and self.frames < sp(13,15,00) then self.torikan_passed[1900] = true end
+	if section == 5 and self.frames < frameTime(6,00,00) then self.torikan_passed[500] = true end
+	if section == 9 and self.frames < frameTime(8,30,00) then self.torikan_passed[900] = true end
+	if section == 10 and self.frames < frameTime(8,45,00) then self.torikan_passed[1000] = true end
+	if section == 15 and self.frames < frameTime(11,30,00) then self.torikan_passed[1500] = true end
+	if section == 19 and self.frames < frameTime(13,15,00) then self.torikan_passed[1900] = true end
 end
 
 function Marathon2020Game:checkClear(level)
@@ -301,7 +305,7 @@ function Marathon2020Game:checkClear(level)
 		level >= 2020
 	) then
 
-		    if self.torikan_passed[500] == false then self.level = 500
+			if self.torikan_passed[500] == false then self.level = 500
 		elseif self.torikan_passed[900] == false then self.level = 999
 		elseif self.torikan_passed[1000] == false then self.level = 1000
 		elseif self.torikan_passed[1500] == false then self.level = 1500
@@ -323,10 +327,11 @@ function Marathon2020Game:checkClear(level)
 end
 
 function Marathon2020Game:updateSectionTimes(old_level, new_level)
-	function sectionCool()
+	function sectionCool(section)
 		self.section_cool_count = self.section_cool_count + 1
 		self.delay_level = math.min(20, self.delay_level + 1)
-		table.insert(self.section_status, "cool")
+		if section < 10 then table.insert(self.section_status, "cool") end
+		self.cool_timer = 300
 	end
 
 	local section = getSectionForLevel(old_level)
@@ -343,7 +348,7 @@ function Marathon2020Game:updateSectionTimes(old_level, new_level)
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
 
-		if section > 4 then self.delay_level = math.min(20, self.delay_level + 1) end
+		if section > 5 then self.delay_level = math.min(20, self.delay_level + 1) end
 		self:checkTorikan(section)
 		self:checkClear(new_level)
 
@@ -352,11 +357,11 @@ function Marathon2020Game:updateSectionTimes(old_level, new_level)
 			self.secondary_section_times[section] < self.secondary_section_times[section - 1] + 120 and
 			self.secondary_section_times[section] < cool_cutoffs[section]
 		) then
-			sectionCool()
+			sectionCool(section)
 		elseif self.section_status[section - 1] == "cool" then
 			table.insert(self.section_status, "none")
 		elseif section <= 19 and self.secondary_section_times[section] < cool_cutoffs[section] then
-			sectionCool()
+			sectionCool(section)
 		else
 			table.insert(self.section_status, "none")
 		end
@@ -389,7 +394,6 @@ Marathon2020Game.mRollOpacityFunction = function(age)
 end
 
 function Marathon2020Game:qualifiesForMRoll()
-	return false -- until I actually have grading working
 --[[
 
 GM-roll requirements
@@ -400,6 +404,8 @@ You qualify for the GM roll if you:
 - in less than 13:30.00 total.
 
 ]]--
+	
+	return self.level >= 2020 and self:getTotalGrade() == 50 and self.frames <= frameTime(13,30)
 end
 
 function Marathon2020Game:drawGrid()
@@ -417,6 +423,14 @@ function Marathon2020Game:drawGrid()
 	end
 end
 
+function Marathon2020Game:sectionColourFunction(section)
+	if self.section_status[section] == "cool" then
+		return { 0, 1, 0, 1 }
+	else
+		return { 1, 1, 1, 1 }
+	end
+end
+
 function Marathon2020Game:drawScoringInfo()
 	Marathon2020Game.super.drawScoringInfo(self)
 
@@ -430,6 +444,11 @@ function Marathon2020Game:drawScoringInfo()
 
 	self:drawSectionTimesWithSecondary(current_section)
 
+	if (self.cool_timer > 0) then
+				love.graphics.printf("COOL!!", 64, 400, 160, "center")
+				self.cool_timer = self.cool_timer - 1
+		end	
+
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self:getTotalGrade(), text_x, 120, 90, "left")
 	love.graphics.printf(self.grade_points, text_x, 220, 90, "left")

tetris/modes/marathon_a1.lua

@@ -14,20 +14,26 @@ MarathonA1Game.tagline = "Can you score enough points to reach the title of Gran
 
 
 function MarathonA1Game:new()
-    MarathonA1Game.super:new()
-    
+	MarathonA1Game.super:new()
+	
 	self.roll_frames = 0
-    self.combo = 1
+	self.combo = 1
+	self.bravos = 0
 	self.gm_conditions = {
 		level300 = false,
 		level500 = false,
 		level999 = false
-    }
-    
+	}
+	self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
+	
 	self.randomizer = History4RollsRandomizer()
 
-    self.lock_drop = false
-    self.enable_hard_drop = false
+	self.lock_drop = false
+	self.enable_hard_drop = false
 	self.enable_hold = false
 	self.next_queue_length = 1
 end
@@ -53,60 +59,60 @@ function MarathonA1Game:getLockDelay()
 end
 
 local function getRankForScore(score)
-        if score <    400 then return {rank = "9", next = 400}
-    elseif score <    800 then return {rank = "8", next = 800}
-    elseif score <   1400 then return {rank = "7", next = 1400}
-    elseif score <   2000 then return {rank = "6", next = 2000}
-    elseif score <   3500 then return {rank = "5", next = 3500}
-    elseif score <   5500 then return {rank = "4", next = 5500}
-    elseif score <   8000 then return {rank = "3", next = 8000}
-    elseif score <  12000 then return {rank = "2", next = 12000}
-    elseif score <  16000 then return {rank = "1", next = 16000}
-    elseif score <  22000 then return {rank = "S1", next = 22000}
-    elseif score <  30000 then return {rank = "S2", next = 30000}
-    elseif score <  40000 then return {rank = "S3", next = 40000}
-    elseif score <  52000 then return {rank = "S4", next = 52000}
-    elseif score <  66000 then return {rank = "S5", next = 66000}
-    elseif score <  82000 then return {rank = "S6", next = 82000}
-    elseif score < 100000 then return {rank = "S7", next = 100000}
-    elseif score < 120000 then return {rank = "S8", next = 120000}
-    else return {rank = "S9", next = "???"}
-    end
+		if score <	400 then return {rank = "9", next = 400}
+	elseif score <	800 then return {rank = "8", next = 800}
+	elseif score <   1400 then return {rank = "7", next = 1400}
+	elseif score <   2000 then return {rank = "6", next = 2000}
+	elseif score <   3500 then return {rank = "5", next = 3500}
+	elseif score <   5500 then return {rank = "4", next = 5500}
+	elseif score <   8000 then return {rank = "3", next = 8000}
+	elseif score <  12000 then return {rank = "2", next = 12000}
+	elseif score <  16000 then return {rank = "1", next = 16000}
+	elseif score <  22000 then return {rank = "S1", next = 22000}
+	elseif score <  30000 then return {rank = "S2", next = 30000}
+	elseif score <  40000 then return {rank = "S3", next = 40000}
+	elseif score <  52000 then return {rank = "S4", next = 52000}
+	elseif score <  66000 then return {rank = "S5", next = 66000}
+	elseif score <  82000 then return {rank = "S6", next = 82000}
+	elseif score < 100000 then return {rank = "S7", next = 100000}
+	elseif score < 120000 then return {rank = "S8", next = 120000}
+	else return {rank = "S9", next = "???"}
+	end
 end
 
 function MarathonA1Game:getGravity()
-    local level = self.level
-        if (level < 30)  then return 4/256
-    elseif (level < 35)  then return 6/256
-    elseif (level < 40)  then return 8/256
-    elseif (level < 50)  then return 10/256
-    elseif (level < 60)  then return 12/256
-    elseif (level < 70)  then return 16/256
-    elseif (level < 80)  then return 32/256
-    elseif (level < 90)  then return 48/256
-    elseif (level < 100) then return 64/256
-    elseif (level < 120) then return 80/256
-    elseif (level < 140) then return 96/256
-    elseif (level < 160) then return 112/256
-    elseif (level < 170) then return 128/256
-    elseif (level < 200) then return 144/256
-    elseif (level < 220) then return 4/256
-    elseif (level < 230) then return 32/256
-    elseif (level < 233) then return 64/256
-    elseif (level < 236) then return 96/256
-    elseif (level < 239) then return 128/256
-    elseif (level < 243) then return 160/256
-    elseif (level < 247) then return 192/256
-    elseif (level < 251) then return 224/256
-    elseif (level < 300) then return 1
-    elseif (level < 330) then return 2
-    elseif (level < 360) then return 3
-    elseif (level < 400) then return 4
-    elseif (level < 420) then return 5
-    elseif (level < 450) then return 4
-    elseif (level < 500) then return 3
-    else return 20
-    end
+	local level = self.level
+		if (level < 30)  then return 4/256
+	elseif (level < 35)  then return 6/256
+	elseif (level < 40)  then return 8/256
+	elseif (level < 50)  then return 10/256
+	elseif (level < 60)  then return 12/256
+	elseif (level < 70)  then return 16/256
+	elseif (level < 80)  then return 32/256
+	elseif (level < 90)  then return 48/256
+	elseif (level < 100) then return 64/256
+	elseif (level < 120) then return 80/256
+	elseif (level < 140) then return 96/256
+	elseif (level < 160) then return 112/256
+	elseif (level < 170) then return 128/256
+	elseif (level < 200) then return 144/256
+	elseif (level < 220) then return 4/256
+	elseif (level < 230) then return 32/256
+	elseif (level < 233) then return 64/256
+	elseif (level < 236) then return 96/256
+	elseif (level < 239) then return 128/256
+	elseif (level < 243) then return 160/256
+	elseif (level < 247) then return 192/256
+	elseif (level < 251) then return 224/256
+	elseif (level < 300) then return 1
+	elseif (level < 330) then return 2
+	elseif (level < 360) then return 3
+	elseif (level < 400) then return 4
+	elseif (level < 420) then return 5
+	elseif (level < 450) then return 4
+	elseif (level < 500) then return 3
+	else return 20
+	end
 end
 
 function MarathonA1Game:advanceOneFrame()
@@ -128,43 +134,47 @@ function MarathonA1Game:onPieceEnter()
 end
 
 function MarathonA1Game:onLineClear(cleared_row_count)
-    self:checkGMRequirements(self.level, self.level + cleared_row_count)
+	self:checkGMRequirements(self.level, self.level + cleared_row_count)
 	if not self.clear then
 		local new_level = math.min(self.level + cleared_row_count, 999)
-		if self.level == 999 then
+		if new_level == 999 then
 			self.clear = true
-		else
-			self.level = new_level
 		end
+		self.level = new_level
 	end
 end
 
 function MarathonA1Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.combo = self.combo + (cleared_lines - 1) * 2
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * self.combo
-		)
-        self.lines = self.lines + cleared_lines
-	else
+	if not self.clear then
+		if self.grid:checkForBravo(cleared_lines) then
+			self.bravo = 4
+			self.bravos = self.bravos + 1
+		else self.bravo = 1 end
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
 function MarathonA1Game:checkGMRequirements(old_level, new_level)
 	if old_level < 300 and new_level >= 300 then
-		if self.score > 12000 and self.frames <= sp(4,15) then
+		if self.score >= 12000 and self.frames <= frameTime(4,15) then
 			self.gm_conditions["level300"] = true
 		end
 	elseif old_level < 500 and new_level >= 500 then
-		if self.score > 40000 and self.frames <= sp(7,30) then
+		if self.score >= 40000 and self.frames <= frameTime(7,30) then
 			self.gm_conditions["level500"] = true
 		end
 	elseif old_level < 999 and new_level >= 999 then
-		if self.score > 126000 and self.frames <= sp(13,30) then
-			self.gm_conditions["level900"] = true
+		if self.score >= 126000 and self.frames <= frameTime(13,30) then
+			self.gm_conditions["level999"] = true
 		end
 	end
 end
@@ -184,17 +194,23 @@ function MarathonA1Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")
 	love.graphics.printf("SCORE", 240, 200, 40, "left")
 	love.graphics.printf("NEXT RANK", 240, 260, 90, "left")
 	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
+
+	if self.bravos > 0 then love.graphics.printf("BRAVO", 300, 120, 40, "left") end
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
-	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level900"] then
+	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level999"] then
 		love.graphics.printf("GM", 240, 140, 90, "left")
 	else
 		love.graphics.printf(getRankForScore(self.score).rank, 240, 140, 90, "left")
@@ -202,7 +218,11 @@ function MarathonA1Game:drawScoringInfo()
 	love.graphics.printf(getRankForScore(self.score).next, 240, 280, 90, "left")
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
-
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
+	if self.bravos > 0 then love.graphics.printf(self.bravos, 300, 140, 40, "left") end
+	
 	love.graphics.setFont(font_8x11)
 	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
 end

tetris/modes/marathon_a2.lua

@@ -15,10 +15,10 @@ MarathonA2Game.tagline = "The points don't matter! Can you reach the invisible r
 
 
 function MarathonA2Game:new()
-    MarathonA2Game.super:new()
-    
+	MarathonA2Game.super:new()
+
 	self.roll_frames = 0
-    self.combo = 1
+	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
 	self.grade = 0
 	self.grade_points = 0
@@ -26,83 +26,89 @@ function MarathonA2Game:new()
 	self.section_start_time = 0
 	self.section_times = { [0] = 0 }
 	self.section_tetrises = { [0] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
-    
-	self.randomizer = History6RollsRandomizer()
+	
+	self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
 
-    self.lock_drop = false
+	self.lock_drop = false
+	self.lock_hard_drop = false
 	self.enable_hold = false
 	self.next_queue_length = 1
 end
 
 function MarathonA2Game:getARE()
-        if self.level < 700 then return 27
-    elseif self.level < 800 then return 18
-    else return 14 end
+		if self.level < 700 then return 27
+	elseif self.level < 800 then return 18
+	else return 14 end
 end
 
 function MarathonA2Game:getLineARE()
-        if self.level < 600 then return 27
-    elseif self.level < 700 then return 18
-    elseif self.level < 800 then return 14
-    else return 8 end
+		if self.level < 600 then return 27
+	elseif self.level < 700 then return 18
+	elseif self.level < 800 then return 14
+	else return 8 end
 end
 
 function MarathonA2Game:getDasLimit()
-        if self.level < 500 then return 15
-    elseif self.level < 900 then return 9
-    else return 7 end
+		if self.level < 500 then return 15
+	elseif self.level < 900 then return 9
+	else return 7 end
 end
 
 function MarathonA2Game:getLineClearDelay()
-        if self.level < 500 then return 40
-    elseif self.level < 600 then return 25
-    elseif self.level < 700 then return 16
-    elseif self.level < 800 then return 12
-    else return 6 end
+		if self.level < 500 then return 40
+	elseif self.level < 600 then return 25
+	elseif self.level < 700 then return 16
+	elseif self.level < 800 then return 12
+	else return 6 end
 end
 
 function MarathonA2Game:getLockDelay()
-        if self.level < 900 then return 30
-    else return 17 end
+		if self.level < 900 then return 30
+	else return 17 end
 end
 
 function MarathonA2Game:getGravity()
-        if (self.level < 30)  then return 4/256
-    elseif (self.level < 35)  then return 6/256
-    elseif (self.level < 40)  then return 8/256
-    elseif (self.level < 50)  then return 10/256
-    elseif (self.level < 60)  then return 12/256
-    elseif (self.level < 70)  then return 16/256
-    elseif (self.level < 80)  then return 32/256
-    elseif (self.level < 90)  then return 48/256
-    elseif (self.level < 100) then return 64/256
-    elseif (self.level < 120) then return 80/256
-    elseif (self.level < 140) then return 96/256
-    elseif (self.level < 160) then return 112/256
-    elseif (self.level < 170) then return 128/256
-    elseif (self.level < 200) then return 144/256
-    elseif (self.level < 220) then return 4/256
-    elseif (self.level < 230) then return 32/256
-    elseif (self.level < 233) then return 64/256
-    elseif (self.level < 236) then return 96/256
-    elseif (self.level < 239) then return 128/256
-    elseif (self.level < 243) then return 160/256
-    elseif (self.level < 247) then return 192/256
-    elseif (self.level < 251) then return 224/256
-    elseif (self.level < 300) then return 1
-    elseif (self.level < 330) then return 2
-    elseif (self.level < 360) then return 3
-    elseif (self.level < 400) then return 4
-    elseif (self.level < 420) then return 5
-    elseif (self.level < 450) then return 4
-    elseif (self.level < 500) then return 3
-    else return 20
-    end
+		if (self.level < 30)  then return 4/256
+	elseif (self.level < 35)  then return 6/256
+	elseif (self.level < 40)  then return 8/256
+	elseif (self.level < 50)  then return 10/256
+	elseif (self.level < 60)  then return 12/256
+	elseif (self.level < 70)  then return 16/256
+	elseif (self.level < 80)  then return 32/256
+	elseif (self.level < 90)  then return 48/256
+	elseif (self.level < 100) then return 64/256
+	elseif (self.level < 120) then return 80/256
+	elseif (self.level < 140) then return 96/256
+	elseif (self.level < 160) then return 112/256
+	elseif (self.level < 170) then return 128/256
+	elseif (self.level < 200) then return 144/256
+	elseif (self.level < 220) then return 4/256
+	elseif (self.level < 230) then return 32/256
+	elseif (self.level < 233) then return 64/256
+	elseif (self.level < 236) then return 96/256
+	elseif (self.level < 239) then return 128/256
+	elseif (self.level < 243) then return 160/256
+	elseif (self.level < 247) then return 192/256
+	elseif (self.level < 251) then return 224/256
+	elseif (self.level < 300) then return 1
+	elseif (self.level < 330) then return 2
+	elseif (self.level < 360) then return 3
+	elseif (self.level < 400) then return 4
+	elseif (self.level < 420) then return 5
+	elseif (self.level < 450) then return 4
+	elseif (self.level < 500) then return 3
+	else return 20
+	end
 end
 
 function MarathonA2Game:advanceOneFrame()
 	if self.clear then
 		self.roll_frames = self.roll_frames + 1
+		if self.roll_frames < 0 then return false end
 		if self.roll_frames > 3694 then
 			self.completed = true
 			if self.grade == 32 then
@@ -121,32 +127,33 @@ function MarathonA2Game:onPieceEnter()
 	end
 end
 
-function MarathonA2Game:onLineClear(cleared_row_count)
-    self:updateSectionTimes(self.level, self.level + cleared_row_count)
-    self.level = math.min(self.level + cleared_row_count, 999)
-    if self.level == 999 and not self.clear then
-        self.clear = true
-        if self:qualifiesForMRoll() then
-            self.grade = 32
-        end
-        self.grid:clear()
-        self.roll_frames = -150
-    end
+function MarathonA2Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
+		self:updateGrade(cleared_lines)
+		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
+		self.drop_bonus = 0
+	else self.lines = self.lines + cleared_lines end
 end
 
-function MarathonA2Game:updateScore(level, drop_bonus, cleared_lines)
-    self:updateGrade(cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
-		self.drop_bonus = 0
-		self.combo = 1
+function MarathonA2Game:onLineClear(cleared_row_count)
+	self.level = math.min(self.level + cleared_row_count, 999)
+	if self.level == 999 and not self.clear then
+		self.clear = true
+		self.grid:clear()
+		if self:qualifiesForMRoll() then self.grade = 32 end
+		self.roll_frames = -150
 	end
+	self.lock_drop = self.level >= 900
+	self.lock_hard_drop = self.level >= 900
 end
 
 function MarathonA2Game:updateSectionTimes(old_level, new_level)
@@ -246,7 +253,7 @@ function MarathonA2Game:updateGrade(cleared_lines)
 	end
 end
 
-local tetris_requirements = { [0] = 2, 2, 2, 2, 2, 1, 1, 1, 1, 1 }
+local tetris_requirements = { [0] = 2, 2, 2, 2, 2, 1, 1, 1, 1, 0 }
 
 function MarathonA2Game:qualifiesForMRoll()
 	if not self.clear then return false end
@@ -260,7 +267,7 @@ function MarathonA2Game:qualifiesForMRoll()
 	local section_average = 0
 	for section = 0, 4 do
 		section_average = section_average + self.section_times[section]
-		if self.section_times[section] > sp(1,05) then
+		if self.section_times[section] > frameTime(1,05) then
 			return false
 		end
 	end
@@ -273,7 +280,7 @@ function MarathonA2Game:qualifiesForMRoll()
 			return false
 		end
 	end
-	if self.grade < 17 or self.frames > sp(8,45) then
+	if self.grade < 31 or self.frames > frameTime(8,45) then
 		return false
 	end
 	return true
@@ -303,12 +310,12 @@ MarathonA2Game.mRollOpacityFunction = function(age)
 	else return 1 - age / 4 end
 end
 
-function MarathonA2Game:drawGrid(ruleset)
+function MarathonA2Game:drawGrid()
 	if self.clear and not (self.completed or self.game_over) then
 		if self:qualifiesForMRoll() then
-			self.grid:drawInvisible(self.mRollOpacityFunction)
+			self.grid:drawInvisible(self.mRollOpacityFunction, nil, false)
 		else
-			self.grid:drawInvisible(self.rollOpacityFunction)
+			self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
 		end
 	else
 		self.grid:draw()
@@ -325,18 +332,35 @@ function MarathonA2Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")
 	love.graphics.printf("SCORE", 240, 200, 40, "left")
 	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
 
 	love.graphics.setFont(font_3x5_3)
+	if self.clear then
+		if self:qualifiesForMRoll() then
+			if self.lines >= 32 and self.roll_frames > 3694 then love.graphics.setColor(1, 0.5, 0, 1)
+			else love.graphics.setColor(0, 1, 0, 1) end
+		else
+			if self.roll_frames > 3694 then love.graphics.setColor(1, 0.5, 0, 1)
+			else love.graphics.setColor(0, 1, 0, 1) end
+		end
+	end	
 	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
 
 	love.graphics.setFont(font_8x11)
 	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")

tetris/modes/marathon_a3.lua

@@ -15,11 +15,11 @@ MarathonA3Game.tagline = "The game gets faster way more quickly! Can you get all
 
 
 function MarathonA3Game:new()
-    MarathonA3Game.super:new()
-    
-    self.speed_level = 0
+	MarathonA3Game.super:new()
+	
+	self.speed_level = 0
 	self.roll_frames = 0
-    self.combo = 1
+	self.combo = 1
 	self.grade = 0
 	self.grade_points = 0
 	self.roll_points = 0
@@ -29,87 +29,99 @@ function MarathonA3Game:new()
 	self.section_start_time = 0
 	self.section_70_times = { [0] = 0 }
 	self.section_times = { [0] = 0 }
-    
+	self.section_cool = false
+	
 	self.randomizer = History6RollsRandomizer()
 
-    self.lock_drop = true
-    self.lock_hard_drop = true
+self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
+	
+	self.lock_drop = true
+	self.lock_hard_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
+	
+	self.coolregret_message = "COOL!!"
+	self.coolregret_timer = 0
+	
+	self.torikan_passed = false
 end
 
 function MarathonA3Game:getARE()
-        if self.speed_level < 700 then return 27
-    elseif self.speed_level < 800 then return 18
-    elseif self.speed_level < 1000 then return 14
-    elseif self.speed_level < 1100 then return 8
-    elseif self.speed_level < 1200 then return 7
-    else return 6 end
+		if self.speed_level < 700 then return 27
+	elseif self.speed_level < 800 then return 18
+	elseif self.speed_level < 1000 then return 14
+	elseif self.speed_level < 1100 then return 8
+	elseif self.speed_level < 1200 then return 7
+	else return 6 end
 end
 
 function MarathonA3Game:getLineARE()
-        if self.speed_level < 600 then return 27
-    elseif self.speed_level < 700 then return 18
-    elseif self.speed_level < 800 then return 14
-    elseif self.speed_level < 1100 then return 8
-    elseif self.speed_level < 1200 then return 7
-    else return 6 end
+		if self.speed_level < 600 then return 27
+	elseif self.speed_level < 700 then return 18
+	elseif self.speed_level < 800 then return 14
+	elseif self.speed_level < 1100 then return 8
+	elseif self.speed_level < 1200 then return 7
+	else return 6 end
 end
 
 function MarathonA3Game:getDasLimit()
-        if self.speed_level < 500 then return 15
-    elseif self.speed_level < 900 then return 9
-    else return 7 end
+		if self.speed_level < 500 then return 15
+	elseif self.speed_level < 900 then return 9
+	else return 7 end
 end
 
 function MarathonA3Game:getLineClearDelay()
-        if self.speed_level < 500 then return 40
-    elseif self.speed_level < 600 then return 25
-    elseif self.speed_level < 700 then return 16
-    elseif self.speed_level < 800 then return 12
-    elseif self.speed_level < 1100 then return 6
-    elseif self.speed_level < 1200 then return 5
-    else return 4 end
+		if self.speed_level < 500 then return 40
+	elseif self.speed_level < 600 then return 25
+	elseif self.speed_level < 700 then return 16
+	elseif self.speed_level < 800 then return 12
+	elseif self.speed_level < 1100 then return 6
+	elseif self.speed_level < 1200 then return 5
+	else return 4 end
 end
 
 function MarathonA3Game:getLockDelay()
-        if self.speed_level < 900 then return 30
-    elseif self.speed_level < 1100 then return 17
-    else return 15 end
+		if self.speed_level < 900 then return 30
+	elseif self.speed_level < 1100 then return 17
+	else return 15 end
 end
 
 function MarathonA3Game:getGravity()
-        if (self.speed_level < 30)  then return 4/256
-    elseif (self.speed_level < 35)  then return 6/256
-    elseif (self.speed_level < 40)  then return 8/256
-    elseif (self.speed_level < 50)  then return 10/256
-    elseif (self.speed_level < 60)  then return 12/256
-    elseif (self.speed_level < 70)  then return 16/256
-    elseif (self.speed_level < 80)  then return 32/256
-    elseif (self.speed_level < 90)  then return 48/256
-    elseif (self.speed_level < 100) then return 64/256
-    elseif (self.speed_level < 120) then return 80/256
-    elseif (self.speed_level < 140) then return 96/256
-    elseif (self.speed_level < 160) then return 112/256
-    elseif (self.speed_level < 170) then return 128/256
-    elseif (self.speed_level < 200) then return 144/256
-    elseif (self.speed_level < 220) then return 4/256
-    elseif (self.speed_level < 230) then return 32/256
-    elseif (self.speed_level < 233) then return 64/256
-    elseif (self.speed_level < 236) then return 96/256
-    elseif (self.speed_level < 239) then return 128/256
-    elseif (self.speed_level < 243) then return 160/256
-    elseif (self.speed_level < 247) then return 192/256
-    elseif (self.speed_level < 251) then return 224/256
-    elseif (self.speed_level < 300) then return 1
-    elseif (self.speed_level < 330) then return 2
-    elseif (self.speed_level < 360) then return 3
-    elseif (self.speed_level < 400) then return 4
-    elseif (self.speed_level < 420) then return 5
-    elseif (self.speed_level < 450) then return 4
-    elseif (self.speed_level < 500) then return 3
-    else return 20
-    end
+		if (self.speed_level < 30)  then return 4/256
+	elseif (self.speed_level < 35)  then return 6/256
+	elseif (self.speed_level < 40)  then return 8/256
+	elseif (self.speed_level < 50)  then return 10/256
+	elseif (self.speed_level < 60)  then return 12/256
+	elseif (self.speed_level < 70)  then return 16/256
+	elseif (self.speed_level < 80)  then return 32/256
+	elseif (self.speed_level < 90)  then return 48/256
+	elseif (self.speed_level < 100) then return 64/256
+	elseif (self.speed_level < 120) then return 80/256
+	elseif (self.speed_level < 140) then return 96/256
+	elseif (self.speed_level < 160) then return 112/256
+	elseif (self.speed_level < 170) then return 128/256
+	elseif (self.speed_level < 200) then return 144/256
+	elseif (self.speed_level < 220) then return 4/256
+	elseif (self.speed_level < 230) then return 32/256
+	elseif (self.speed_level < 233) then return 64/256
+	elseif (self.speed_level < 236) then return 96/256
+	elseif (self.speed_level < 239) then return 128/256
+	elseif (self.speed_level < 243) then return 160/256
+	elseif (self.speed_level < 247) then return 192/256
+	elseif (self.speed_level < 251) then return 224/256
+	elseif (self.speed_level < 300) then return 1
+	elseif (self.speed_level < 330) then return 2
+	elseif (self.speed_level < 360) then return 3
+	elseif (self.speed_level < 400) then return 4
+	elseif (self.speed_level < 420) then return 5
+	elseif (self.speed_level < 450) then return 4
+	elseif (self.speed_level < 500) then return 3
+	else return 20
+	end
 end
 
 function MarathonA3Game:advanceOneFrame()
@@ -137,36 +149,41 @@ end
 
 function MarathonA3Game:onPieceEnter()
 	if (self.level % 100 ~= 99) and self.level ~= 998 and self.frames ~= 0 then
-        self:updateSectionTimes(self.level, self.level + 1)
-        self.level = self.level + 1
-        self.speed_level = self.speed_level + 1
-    end
+		self:updateSectionTimes(self.level, self.level + 1)
+		self.level = self.level + 1
+		self.speed_level = self.speed_level + 1
+		self.torikan_passed = self.level >= 500 and true or false
+	end
 end
 
 local cleared_row_levels = {1, 2, 4, 6}
 
 function MarathonA3Game:onLineClear(cleared_row_count)
-    local advanced_levels = cleared_row_levels[cleared_row_count]
-    self:updateSectionTimes(self.level, self.level + advanced_levels)
-    if not self.clear then
-        self.level = math.min(self.level + advanced_levels, 999)
-    end
-    self.speed_level = self.speed_level + advanced_levels
-    if self.level == 999 and not self.clear then
-        self.clear = true
-        self.grid:clear()
-        self.roll_frames = -150
-    end
+	local advanced_levels = cleared_row_levels[cleared_row_count]
+	self:updateSectionTimes(self.level, self.level + advanced_levels)
+	if not self.clear then
+		self.level = math.min(self.level + advanced_levels, 999)
+	end
+	self.speed_level = self.speed_level + advanced_levels
+	if self.level == 999 and not self.clear then
+		self.clear = true
+		self.grid:clear()
+		self.roll_frames = -150
+	end
+	if not self.torikan_passed and self.level >= 500 and self.frames >= 25200 then
+	self.level = 500
+	self.game_over = true
+	end
 end
 
 local cool_cutoffs = {
-	sp(0,52), sp(0,52), sp(0,49), sp(0,45), sp(0,45),
-	sp(0,42), sp(0,42), sp(0,38), sp(0,38), 
+	frameTime(0,52), frameTime(0,52), frameTime(0,49), frameTime(0,45), frameTime(0,45),
+	frameTime(0,42), frameTime(0,42), frameTime(0,38), frameTime(0,38), 
 }
 
 local regret_cutoffs = {
-	sp(0,90), sp(0,75), sp(0,75), sp(0,68), sp(0,60),
-	sp(0,60), sp(0,50), sp(0,50), sp(0,50), sp(0,50),
+	frameTime(0,90), frameTime(0,75), frameTime(0,75), frameTime(0,68), frameTime(0,60),
+	frameTime(0,60), frameTime(0,50), frameTime(0,50), frameTime(0,50), frameTime(0,50),
 }
 
 function MarathonA3Game:updateSectionTimes(old_level, new_level)
@@ -179,42 +196,53 @@ function MarathonA3Game:updateSectionTimes(old_level, new_level)
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
 
+		self.speed_level = self.section_cool and self.speed_level + 100 or self.speed_level
+
 		if section_time > regret_cutoffs[section] then
 			self.section_cool_grade = self.section_cool_grade - 1
 			table.insert(self.section_status, "regret")
-		elseif section <= 9 and self.section_status[section - 1] == "cool" and
-		self.section_70_times[section] < self.section_70_times[section - 1] + 120 then
+			self.coolregret_message = "REGRET!!"
+			self.coolregret_timer = 300
+		elseif self.section_cool then
 			self.section_cool_grade = self.section_cool_grade + 1
-			self.speed_level = self.speed_level + 100
-			table.insert(self.section_status, "cool")
-		elseif self.section_status[section - 1] == "cool" then
-			table.insert(self.section_status, "none")
-		elseif section <= 9 and self.section_70_times[section] < cool_cutoffs[section] then
-			self.section_cool_grade = self.section_cool_grade + 1
-			self.speed_level = self.speed_level + 100
 			table.insert(self.section_status, "cool")
 		else
 			table.insert(self.section_status, "none")
 		end
-	elseif section <= 9 and old_level % 100 < 70 and new_level % 100 >= 70 then
+
+		self.section_cool = false
+	elseif old_level % 100 < 70 and new_level % 100 >= 70 then
 		-- record section 70 time
 		section_70_time = self.frames - self.section_start_time
 		table.insert(self.section_70_times, section_70_time)
+
+		if section <= 9 and self.section_status[section - 1] == "cool" and
+				self.section_70_times[section] < self.section_70_times[section - 1] + 120 then
+			self.section_cool = true
+			self.coolregret_message = "COOL!!"
+						self.coolregret_timer = 300
+				elseif self.section_status[section - 1] == "cool" then self.section_cool = false
+				elseif section <= 9 and self.section_70_times[section] < cool_cutoffs[section] then
+			self.section_cool = true
+			self.coolregret_message = "COOL!!"
+						self.coolregret_timer = 300
+		end
 	end
 end
 
 function MarathonA3Game:updateScore(level, drop_bonus, cleared_lines)
-    self:updateGrade(cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	self:updateGrade(cleared_lines)
+	if not self.clear then	
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
@@ -334,6 +362,8 @@ function MarathonA3Game:getLetterGrade()
 		return "M" .. tostring(grade - 17)
 	elseif grade < 32 then
 		return master_grades[grade - 26]
+	elseif grade >= 32 and self.roll_frames < 3238 then
+		return "MM"
 	else
 		return "GM"
 	end
@@ -372,12 +402,16 @@ function MarathonA3Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")
 	love.graphics.printf("SCORE", 240, 200, 40, "left")
 	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
 
 	-- draw section time data
 	current_section = math.floor(self.level / 100) + 1
@@ -404,14 +438,25 @@ function MarathonA3Game:drawScoringInfo()
 		current_x = section_70_x
 	end
 
-	love.graphics.printf(formatTime(self.frames - self.section_start_time), current_x, 40 + 20 * current_section, 90, "left")
+	if not self.clear then love.graphics.printf(formatTime(self.frames - self.section_start_time), current_x, 40 + 20 * current_section, 90, "left") end
+	
+	if(self.coolregret_timer > 0) then
+				love.graphics.printf(self.coolregret_message, 64, 400, 160, "center")
+				self.coolregret_timer = self.coolregret_timer - 1
+		end
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
+	if self.roll_frames > 3238 then love.graphics.setColor(1, 0.5, 0, 1)
+	elseif self.level >= 999 and self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
-	
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
+
 	love.graphics.setFont(font_8x11)
 	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
 end

tetris/modes/marathon_ax4.lua

@@ -3,7 +3,7 @@ require 'funcs'
 local GameMode = require 'tetris.modes.gamemode'
 local Piece = require 'tetris.components.piece'
 
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
+local Bag7NoSZOStartRandomizer = require 'tetris.randomizers.bag7noSZOstart'
 
 local MarathonAX4Game = GameMode:extend()
 
@@ -16,7 +16,7 @@ function MarathonAX4Game:new()
 	MarathonAX4Game.super:new()
 
 	self.roll_frames = 0
-	self.randomizer = History6RollsRandomizer()
+	self.randomizer = Bag7NoSZOStartRandomizer()
 
 	self.section_time_limit = 3600
 	self.section_start_time = 0
@@ -24,12 +24,13 @@ function MarathonAX4Game:new()
 	self.section_clear = false
 
 	self.lock_drop = true
+	self.lock_hard_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
 end
 
 function MarathonAX4Game:getARE()
-	    if self.lines < 10 then return 18
+		if self.lines < 10 then return 18
 	elseif self.lines < 40 then return 14
 	elseif self.lines < 60 then return 12
 	elseif self.lines < 70 then return 10
@@ -43,14 +44,14 @@ function MarathonAX4Game:getLineARE()
 end
 
 function MarathonAX4Game:getDasLimit()
-	    if self.lines < 20 then return 10
+		if self.lines < 20 then return 10
 	elseif self.lines < 50 then return 9
 	elseif self.lines < 70 then return 8
 	else return 7 end
 end
 
 function MarathonAX4Game:getLineClearDelay()
-	    if self.lines < 10 then return 14
+		if self.lines < 10 then return 14
 	elseif self.lines < 30 then return 9
 	else return 5 end
 end
@@ -98,6 +99,7 @@ function MarathonAX4Game:onLineClear(cleared_row_count)
 		self:updateSectionTimes(self.lines, new_lines)
 		self.lines = math.min(new_lines, 150)
 		if self.lines == 150 then
+			self.grid:clear()
 			self.clear = true
 			self.roll_frames = -150
 		end
@@ -141,10 +143,10 @@ function MarathonAX4Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
+	if self.lines < 150 then love.graphics.printf("TIME LEFT", 240, 250, 80, "left") end
 	love.graphics.printf("LINES", 240, 320, 40, "left")
 
 	local current_section = math.floor(self.lines / 10) + 1
@@ -156,10 +158,10 @@ function MarathonAX4Game:drawScoringInfo()
 
 	-- draw time left, flash red if necessary
 	local time_left = self.section_time_limit - math.max(self:getSectionTime(), 0)
-	if not self.game_over and not self.clear and time_left < sp(0,10) and time_left % 4 < 2 then
+	if not self.game_over and not self.clear and time_left < frameTime(0,10) and time_left % 4 < 2 then
 		love.graphics.setColor(1, 0.3, 0.3, 1)
 	end
-	love.graphics.printf(formatTime(time_left), 240, 270, 160, "left")
+	if self.lines < 150 then love.graphics.printf(formatTime(time_left), 240, 270, 160, "left") end
 	love.graphics.setColor(1, 1, 1, 1)
 end
 

tetris/modes/marathon_c89.lua

@@ -1,185 +0,0 @@
-require 'funcs'
-
-local GameMode = require 'tetris.modes.gamemode'
-local Piece = require 'tetris.components.piece'
-
-local Randomizer = require 'tetris.randomizers.randomizer'
-
-local MarathonC89Game = GameMode:extend()
-
-MarathonC89Game.name = "Marathon C89"
-MarathonC89Game.hash = "MarathonC89"
-MarathonC89Game.tagline = "Can you play fast enough to reach the killscreen?"
-
-
-function MarathonC89Game:new()
-    MarathonC89Game.super:new()
-    
-	self.randomizer = Randomizer()
-
-	self.ready_frames = 1
-	self.waiting_frames = 72
-
-	self.start_level = 12
-	self.level = 12
-
-    self.lock_drop = true
-    self.enable_hard_drop = false
-	self.enable_hold = false
-	self.next_queue_length = 1
-	self.additive_gravity = false
-end
-
-function MarathonC89Game:getDropSpeed() return 1/2 end
-function MarathonC89Game:getDasLimit() return 16 end
-function MarathonC89Game:getARR() return 6 end
-
-function MarathonC89Game:getARE() return 6 end
-function MarathonC89Game:getLineARE() return 6 end
-function MarathonC89Game:getLineClearDelay() return 30 end
-function MarathonC89Game:getLockDelay() return 0 end
-
-function MarathonC89Game:chargeDAS(inputs)
-	if inputs[self.das.direction] == true and
-		self.prev_inputs[self.das.direction] == true and
-		not inputs["down"] and
-		self.piece ~= nil
-	then
-		local das_frames = self.das.frames + 1
-		if das_frames >= self:getDasLimit() then
-			if self.das.direction == "left" then
-				self.move = (self:getARR() == 0 and "speed" or "") .. "left"
-				self.das.frames = self:getDasLimit() - self:getARR()
-			elseif self.das.direction == "right" then
-				self.move = (self:getARR() == 0 and "speed" or "") .. "right"
-				self.das.frames = self:getDasLimit() - self:getARR()
-			end
-		else
-			self.move = "none"
-			self.das.frames = das_frames
-		end
-	elseif inputs["right"] == true then
-		self.das.direction = "right"
-		if not inputs["down"] and self.piece ~= nil then
-			self.move = "right"
-			self.das.frames = 0
-		else 
-			self.move = "none"
-		end
-	elseif inputs["left"] == true then
-		self.das.direction = "left"
-		if not inputs["down"] and self.piece ~= nil then
-			self.move = "left"
-			self.das.frames = 0
-		else 
-			self.move = "none"
-		end
-	else
-		self.move = "none"
-	end
-
-	if self.das.direction == "left" and self.piece ~= nil and self.piece:isMoveBlocked(self.grid, {x=-1, y=0}) or
-		self.das.direction == "right" and self.piece ~= nil and self.piece:isMoveBlocked(self.grid, {x=1, y=0})
-	then
-		self.das.frames = self:getDasLimit()
-	end
-
-	if inputs["down"] == false and self.prev_inputs["down"] == true then
-		self.drop_bonus = 0
-	end
-end
-
-local gravity_table = {
-	[0] =
-	1366/65536,  1525/65536,  1725/65536,  1986/65536,  2341/65536,
-	2850/65536,  3641/65536,  5042/65536,  8192/65536,  10923/65536,
-	13108/65536, 13108/65536, 13108/65536, 16384/65536, 16384/65536,
-	16384/65536, 21846/65536, 21846/65536, 21846/65536
-}
-
-function MarathonC89Game:getGravity()
-	if self.waiting_frames > 0 then return 0 end
-	    if self.level >= 29 then return 1
-	elseif self.level >= 19 then return 1/2
-	else return gravity_table[self.level] end
-end
-
-function MarathonC89Game:advanceOneFrame()
-	if self.waiting_frames > 0 then
-		self.waiting_frames = self.waiting_frames - 1
-	else
-		self.frames = self.frames + 1
-	end
-	return true
-end
-
-function MarathonC89Game:onPieceLock()
-	self.score = self.score + self.drop_bonus
-	self.drop_bonus = 0
-end
-
-local cleared_line_scores = { 40, 100, 300, 1200 }
-
-function MarathonC89Game:getLevelForLines()
-	if self.start_level < 10 then
-		return math.max(self.start_level, math.floor(self.lines / 10))
-	elseif self.start_level < 16 then
-		return math.max(self.start_level, self.start_level + math.floor((self.lines - 100) / 10))
-	else
-		return math.max(self.start_level, math.floor((self.lines - 60) / 10))
-	end
-end
-
-function MarathonC89Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + cleared_line_scores[cleared_lines] * (self.level + 1)
-		self.lines = self.lines + cleared_lines
-		self.level = self:getLevelForLines()
-	else
-		self.drop_bonus = 0
-		self.combo = 1
-	end
-end
-
-function MarathonC89Game:drawGrid()
-	self.grid:draw()
-	if self.piece ~= nil and self.level < 100 then
-		self:drawGhostPiece(ruleset)
-	end
-end
-
-function MarathonC89Game:drawScoringInfo()
-	MarathonC89Game.super.drawScoringInfo(self)
-	love.graphics.setColor(1, 1, 1, 1)
-
-	love.graphics.setFont(font_3x5_2)
-	love.graphics.print(
-		self.das.direction .. " " ..
-		self.das.frames .. " " ..
-		st(self.prev_inputs)
-	)
-	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("LINES", 240, 120, 40, "left")
-	love.graphics.printf("SCORE", 240, 200, 40, "left")
-
-	love.graphics.setFont(font_3x5_3)
-	love.graphics.printf(self.lines, 240, 140, 90, "left")
-	love.graphics.printf(self.score, 240, 220, 90, "left")
-
-	love.graphics.setFont(font_8x11)
-	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
-end
-
-
-function MarathonC89Game:getBackground()
-	return math.min(self.level, 19)
-end
-
-function MarathonC89Game:getHighscoreData()
-	return {
-		score = self.score,
-		level = self.level,
-	}
-end
-
-return MarathonC89Game

tetris/modes/pacer_test.lua

@@ -1,170 +0,0 @@
-require 'funcs'
-
-local GameMode = require 'tetris.modes.gamemode'
-local Piece = require 'tetris.components.piece'
-
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
-
-local PacerTest = GameMode:extend()
-
-PacerTest.name = "TetrisGram™ Pacer Test"
-PacerTest.hash = "PacerTest"
-PacerTest.tagline = ""
-
-
-
-
-local function getLevelFrames(level)
-	if level == 1 then return 72 * 60 / 8.0
-	else return 72 * 60 / (8 + level * 0.5)
-	end
-end
-
-local level_end_sections = {
-	7, 15, 23, 32, 41, 51, 61, 72, 83, 94,
-	106, 118, 131, 144, 157, 171, 185, 200,
-	215, 231, 247
-}
-
-function PacerTest:new()
-	PacerTest.super:new()
-
-	self.ready_frames = 2430
-	self.clear_frames = 0
-	self.randomizer = History6RollsRandomizer()
-
-	self.level = 1
-	self.section = 0
-	self.level_frames = 0
-
-	self.section_lines = 0
-	self.section_clear = false
-	self.strikes = 0
-
-	self.lock_drop = true
-	self.lock_hard_drop = true
-	self.enable_hold = true
-	self.instant_hard_drop = true
-	self.instant_soft_drop = false
-	self.next_queue_length = 3
-end
-
-function PacerTest:initialize(ruleset)
-	for i = 1, 30 do
-		table.insert(self.next_queue, self:getNextPiece(ruleset))
-	end
-	self.level_frames = getLevelFrames(1)
-	switchBGM("pacer_test")
-end
-
-function PacerTest:getARE()
-	return 0
-end
-
-function PacerTest:getLineARE()
-	return 0
-end
-
-function PacerTest:getDasLimit()
-	return 8
-end
-
-function PacerTest:getLineClearDelay()
-	return 6
-end
-
-function PacerTest:getLockDelay()
-	return 30
-end
-
-function PacerTest:getGravity()
-	return 1/64
-end
-
-function PacerTest:getSection()
-	return math.floor(level / 100) + 1
-end
-
-function PacerTest:advanceOneFrame()
-	if self.clear then
-		self.clear_frames = self.clear_frames + 1
-		if self.clear_frames > 600 then
-			self.completed = true
-		end
-		return false
-	elseif self.ready_frames == 0 then
-		self.frames = self.frames + 1
-		self.level_frames = self.level_frames - 1
-		if self.level_frames <= 0 then
-			self:checkSectionStatus()
-			self.section = self.section + 1
-			if self.section >= level_end_sections[self.level] then
-				self.level = self.level + 1
-			end
-			self.level_frames = self.level_frames + getLevelFrames(self.level)
-		end
-	end
-	return true
-end
-
-function PacerTest:checkSectionStatus()
-	if self.section_clear then
-		self.strikes = 0
-		self.section_clear = false
-	else
-		self.strikes = self.strikes + 1
-		if self.strikes >= 2 then
-			self.game_over = true
-			fadeoutBGM(2.5)
-		end
-	end
-	self.section_lines = 0
-end
-
-function PacerTest:onLineClear(cleared_row_count)
-	self.section_lines = self.section_lines + cleared_row_count
-	if self.section_lines >= 3 then
-		self.section_clear = true
-	end
-end
-
-function PacerTest:drawGrid(ruleset)
-	self.grid:draw()
-	if self.piece ~= nil then
-		self:drawGhostPiece(ruleset)
-	end
-end
-
-function PacerTest:getHighscoreData()
-	return {
-		level = self.level,
-		frames = self.frames,
-	}
-end
-
-function PacerTest:drawScoringInfo()
-	PacerTest.super.drawScoringInfo(self)
-	love.graphics.setColor(1, 1, 1, 1)
-
-	local text_x = config["side_next"] and 320 or 240
-
-	love.graphics.setFont(font_3x5_2)
-	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("LINES", text_x, 224, 70, "left")
-	love.graphics.printf("LEVEL", text_x, 320, 40, "left")
-
-	for i = 1, math.min(self.strikes, 3) do
-		love.graphics.draw(misc_graphics["strike"], text_x + (i - 1) * 30, 280)
-	end
-
-	love.graphics.setFont(font_3x5_3)
-	love.graphics.printf(self.section_lines .. "/3", text_x, 244, 40, "left")
-	love.graphics.printf(self.level, text_x, 340, 40, "right")
-	love.graphics.printf(self.section, text_x, 370, 40, "right")
-end
-
-function PacerTest:getBackground()
-	return math.min(self.level - 1, 19)
-end
-
-return PacerTest

tetris/modes/phantom_mania.lua

@@ -15,7 +15,14 @@ function PhantomManiaGame:new()
 	PhantomManiaGame.super:new()
 
 	self.lock_drop = true
+	self.lock_hard_drop = true
 	self.next_queue_length = 1
+	
+	self.SGnames = {
+		"9",  "8",  "7",  "6",  "5",  "4",  "3",  "2",  "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
 
 	self.roll_frames = 0
 	self.combo = 1
@@ -23,7 +30,7 @@ function PhantomManiaGame:new()
 end
 
 function PhantomManiaGame:getARE()
-	    if self.level < 100 then return 18
+		if self.level < 100 then return 18
 	elseif self.level < 200 then return 14
 	elseif self.level < 400 then return 8
 	elseif self.level < 500 then return 7
@@ -31,14 +38,14 @@ function PhantomManiaGame:getARE()
 end
 
 function PhantomManiaGame:getLineARE()
-	    if self.level < 100 then return 18
+		if self.level < 100 then return 18
 	elseif self.level < 400 then return 8
 	elseif self.level < 500 then return 7
 	else return 6 end
 end
 
 function PhantomManiaGame:getDasLimit()
-	    if self.level < 200 then return 11
+		if self.level < 200 then return 11
 	elseif self.level < 300 then return 10
 	elseif self.level < 400 then return 9
 	else return 7 end
@@ -49,7 +56,7 @@ function PhantomManiaGame:getLineClearDelay()
 end
 
 function PhantomManiaGame:getLockDelay()
-	    if self.level < 100 then return 30
+		if self.level < 100 then return 30
 	elseif self.level < 200 then return 26
 	elseif self.level < 300 then return 22
 	elseif self.level < 400 then return 18
@@ -61,15 +68,15 @@ function PhantomManiaGame:getGravity()
 end
 
 function PhantomManiaGame:hitTorikan(old_level, new_level)
-	if old_level < 300 and new_level >= 300 and self.frames > sp(2,28) then
+	if old_level < 300 and new_level >= 300 and self.frames > frameTime(2,28) then
 		self.level = 300
 		return true
 	end
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,38) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,38) then
 		self.level = 500
 		return true
 	end
-	if old_level < 800 and new_level >= 800 and self.frames > sp(5,23) then
+	if old_level < 800 and new_level >= 800 and self.frames > frameTime(5,23) then
 		self.level = 800
 		return true
 	end
@@ -111,16 +118,17 @@ function PhantomManiaGame:onLineClear(cleared_row_count)
 end
 
 function PhantomManiaGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	if not self.clear then
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
@@ -131,7 +139,7 @@ end
 
 function PhantomManiaGame:drawGrid()
 	if not (self.game_over or self.clear) then
-		self.grid:drawInvisible(self.rollOpacityFunction)
+		self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
 	else
 		self.grid:draw()
 	end
@@ -161,12 +169,16 @@ function PhantomManiaGame:drawScoringInfo()
 	local text_x = config["side_next"] and 320 or 240
 
 	love.graphics.setFont(font_3x5_2)
-	love.graphics.printf("GRADE", text_x, 120, 40, "left")
+	if getLetterGrade(self.level, self.clear) ~= "" then love.graphics.printf("GRADE", text_x, 120, 40, "left") end
 	love.graphics.printf("SCORE", text_x, 200, 40, "left")
 	love.graphics.printf("LEVEL", text_x, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
 
 	love.graphics.setFont(font_3x5_3)
-	love.graphics.printf(getLetterGrade(self.level, self.clear), text_x, 140, 90, "left")
+	if getLetterGrade(self.level, self.clear) ~= "" then love.graphics.printf(getLetterGrade(self.level, self.clear), text_x, 140, 90, "left") end
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
 	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	if self.clear then
@@ -175,6 +187,9 @@ function PhantomManiaGame:drawScoringInfo()
 		love.graphics.printf(self:getSectionEndLevel(), text_x, 370, 40, "right")
 	end
 
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
 end
 
 function PhantomManiaGame:getSectionEndLevel()

tetris/modes/phantom_mania2.lua

@@ -16,7 +16,6 @@ PhantomMania2Game.tagline = "The blocks disappear even faster now! Can you make
 
 function PhantomMania2Game:new()
 	PhantomMania2Game.super:new()
-	self.level = 0
 	self.grade = 0
 	self.garbage = 0
 	self.clear = false
@@ -26,21 +25,31 @@ function PhantomMania2Game:new()
 	self.hold_age = 0
 	self.queue_age = 0
 	self.roll_points = 0
+	
+	self.SGnames = {
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9",
+		"GM"
+	}
 
 	self.randomizer = History6RollsRandomizer()
 
 	self.lock_drop = true
+	self.lock_hard_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
+
+	self.coolregret_message = ""
+	self.coolregret_timer = 0
 end
 
 function PhantomMania2Game:getARE()
-	    if self.level < 300 then return 12
+		if self.level < 300 then return 12
 	else return 6 end
 end
 
 function PhantomMania2Game:getLineARE()
-	    if self.level < 100 then return 8
+		if self.level < 100 then return 8
 	elseif self.level < 200 then return 7
 	elseif self.level < 500 then return 6
 	elseif self.level < 1300 then return 5
@@ -48,7 +57,7 @@ function PhantomMania2Game:getLineARE()
 end
 
 function PhantomMania2Game:getDasLimit()
-	    if self.level < 200 then return 9
+		if self.level < 200 then return 9
 	elseif self.level < 500 then return 7
 	else return 5 end
 end
@@ -58,7 +67,7 @@ function PhantomMania2Game:getLineClearDelay()
 end
 
 function PhantomMania2Game:getLockDelay()
-	    if self.level < 200 then return 18
+		if self.level < 200 then return 18
 	elseif self.level < 300 then return 17
 	elseif self.level < 500 then return 15
 	elseif self.level < 600 then return 13
@@ -86,19 +95,19 @@ function PhantomMania2Game:getNextPiece(ruleset)
 end
 
 function PhantomMania2Game:hitTorikan(old_level, new_level)
-	if old_level < 300 and new_level >= 300 and self.frames > sp(2,02) then
+	if old_level < 300 and new_level >= 300 and self.frames > frameTime(2,02) then
 		self.level = 300
 		return true
 	end
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,03) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,03) then
 		self.level = 500
 		return true
 	end
-	if old_level < 800 and new_level >= 800 and self.frames > sp(4,45) then
+	if old_level < 800 and new_level >= 800 and self.frames > frameTime(4,45) then
 		self.level = 800
 		return true
 	end
-	if old_level < 1000 and new_level >= 1000 and self.frames > sp(5,38) then
+	if old_level < 1000 and new_level >= 1000 and self.frames > frameTime(5,38) then
 		self.level = 1000
 		return true
 	end
@@ -116,6 +125,8 @@ function PhantomMania2Game:advanceOneFrame()
 			return false
 		elseif self.roll_frames > 3238 then
 			switchBGM(nil)
+			self.roll_points = self.level >= 1300 and self.roll_points + 150 or self.roll_points
+			self.grade = self.grade + math.floor(self.roll_points / 100)
 			self.completed = true
 		end
 	elseif self.ready_frames == 0 then
@@ -137,7 +148,8 @@ function PhantomMania2Game:onPieceEnter()
 end
 
 local cleared_row_levels = {1, 2, 4, 6}
-local cleared_row_points = {2, 6, 15, 40}
+local torikan_roll_points = {10, 20, 30, 100}
+local big_roll_points = {10, 20, 100, 200}
 
 function PhantomMania2Game:onLineClear(cleared_row_count)
 	if not self.clear then
@@ -156,7 +168,8 @@ function PhantomMania2Game:onLineClear(cleared_row_count)
 		end
 		self:advanceBottomRow(-cleared_row_count)
 	else
-		self.roll_points = self.roll_points + cleared_row_points[cleared_row_count / 2]
+		if self.big_mode then self.roll_points = self.roll_points + big_roll_points[cleared_row_count / 2]
+		else self.roll_points = self.roll_points + torikan_roll_points[cleared_row_count] end
 		if self.roll_points >= 100 then
 			self.roll_points = self.roll_points - 100
 			self.grade = self.grade + 1
@@ -165,38 +178,41 @@ function PhantomMania2Game:onLineClear(cleared_row_count)
 end
 
 function PhantomMania2Game:onPieceLock(piece, cleared_row_count)
+	self.super:onPieceLock()
 	if cleared_row_count == 0 then self:advanceBottomRow(1) end
 end
 
 function PhantomMania2Game:onHold()
+	self.super.onHold()
 	self.hold_age = 0
 end
 
 function PhantomMania2Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	if not self.clear then
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
 
 local cool_cutoffs = {
-	sp(0,36), sp(0,36), sp(0,36), sp(0,36), sp(0,36),
-	sp(0,30), sp(0,30), sp(0,30), sp(0,30), sp(0,30),
-	sp(0,27), sp(0,27), sp(0,27),
+	frameTime(0,36), frameTime(0,36), frameTime(0,36), frameTime(0,36), frameTime(0,36),
+	frameTime(0,30), frameTime(0,30), frameTime(0,30), frameTime(0,30), frameTime(0,30),
+	frameTime(0,27), frameTime(0,27), frameTime(0,27),
 }
 
 local regret_cutoffs = {
-	sp(0,50), sp(0,50), sp(0,50), sp(0,50), sp(0,50),
-	sp(0,40), sp(0,40), sp(0,40), sp(0,40), sp(0,40),
-	sp(0,35), sp(0,35), sp(0,35),
+	frameTime(0,50), frameTime(0,50), frameTime(0,50), frameTime(0,50), frameTime(0,50),
+	frameTime(0,40), frameTime(0,40), frameTime(0,40), frameTime(0,40), frameTime(0,40),
+	frameTime(0,35), frameTime(0,35), frameTime(0,35),
 }
 
 function PhantomMania2Game:updateSectionTimes(old_level, new_level)
@@ -207,8 +223,13 @@ function PhantomMania2Game:updateSectionTimes(old_level, new_level)
 		self.section_start_time = self.frames
 		if section_time <= cool_cutoffs[section] then
 			self.grade = self.grade + 2
+			self.coolregret_message = "COOL!!"
+			self.coolregret_timer = 300
 		elseif section_time <= regret_cutoffs[section] then
 			self.grade = self.grade + 1
+		else
+			self.coolregret_message = "REGRET!!"
+			self.coolregret_timer = 300
 		end
 	end
 end
@@ -234,7 +255,7 @@ PhantomMania2Game.garbageOpacityFunction = function(age)
 end
 
 function PhantomMania2Game:drawGrid()
-	if not (self.game_over or (self.clear and self.level < 1300)) then
+	if not (self.game_over) then
 		self.grid:drawInvisible(self.rollOpacityFunction, self.garbageOpacityFunction)
 	else
 		self.grid:draw()
@@ -270,7 +291,7 @@ function PhantomMania2Game:setHoldOpacity()
 	if self.level > 1000 and self.level < 1300 then
 		love.graphics.setColor(1, 1, 1, 1 - math.min(1, self.hold_age / 15))
 	else
-		love.graphics.setColor(1, 1, 1, 1)
+		self.super:setHoldOpacity(1, self.held and 0.6 or 1)
 	end
 end
 
@@ -285,6 +306,17 @@ function PhantomMania2Game:drawScoringInfo()
 	love.graphics.printf("GRADE", text_x, 120, 40, "left")
 	love.graphics.printf("SCORE", text_x, 200, 40, "left")
 	love.graphics.printf("LEVEL", text_x, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
+
+	self:drawSectionTimesWithSplits(math.floor(self.level / 100) + 1)
+
+	if(self.coolregret_timer > 0) then
+				love.graphics.printf(self.coolregret_message, 64, 400, 160, "center")
+				self.coolregret_timer = self.coolregret_timer - 1
+		end
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(getLetterGrade(math.floor(self.grade)), text_x, 140, 90, "left")
@@ -295,6 +327,10 @@ function PhantomMania2Game:drawScoringInfo()
 	else
 		love.graphics.printf(math.floor(self.level / 100 + 1) * 100, text_x, 370, 50, "right")
 	end
+	
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
 end
 
 function PhantomMania2Game:getBackground()

tetris/modes/phantom_mania_n.lua

@@ -8,6 +8,12 @@ PhantomManiaNGame.tagline = "The old mode from Nullpomino, for Ti-ARS and SRS su
 
 function PhantomManiaNGame:new()
 	PhantomManiaNGame.super:new()
+	
+	self.SGnames = {
+		"M1",  "M2",  "M3",  "M4",  "M5",  "M6",  "M7",  "M8",  "M9",
+		"M10", "M11", "M12", "M13", "M14", "M15", "M16", "M17", "M18",
+		"GM"
+	}
 
 	self.next_queue_length = 3
 	self.enable_hold = true

tetris/modes/race_40.lua

@@ -1,129 +0,0 @@
-require 'funcs'
-
-local GameMode = require 'tetris.modes.gamemode'
-local Piece = require 'tetris.components.piece'
-
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
-
-local Race40Game = GameMode:extend()
-
-Race40Game.name = "Race 40"
-Race40Game.hash = "Race40"
-Race40Game.tagline = "How fast can you clear 40 lines?"
-
-
-function Race40Game:new()
-	Race40Game.super:new()
-
-	self.lines = 0
-	self.line_goal = 40
-	self.pieces = 0
-	self.randomizer = History6RollsRandomizer()
-
-	self.roll_frames = 0
-	
-	self.lock_drop = true
-	self.lock_hard_drop = true
-	self.instant_hard_drop = true
-	self.instant_soft_drop = false
-	self.enable_hold = true
-	self.next_queue_length = 3
-end
-
-function Race40Game:getDropSpeed()
-	return 20
-end
-
-function Race40Game:getARR()
-	return 0
-end
-
-function Race40Game:getARE()
-	return 0
-end
-
-function Race40Game:getLineARE()
-	return self:getARE()
-end
-
-function Race40Game:getDasLimit()
-	return 6
-end
-
-function Race40Game:getLineClearDelay()
-	return 0
-end
-
-function Race40Game:getLockDelay()
-	return 15
-end
-
-function Race40Game:getGravity()
-	return 1/64
-end
-
-function Race40Game:advanceOneFrame()
-	if self.clear then
-		self.roll_frames = self.roll_frames + 1
-		if self.roll_frames > 150 then
-			self.completed = true
-		end
-		return false
-	elseif self.ready_frames == 0 then
-		self.frames = self.frames + 1
-	end
-	return true
-end
-
-function Race40Game:onPieceLock()
-	self.pieces = self.pieces + 1
-end
-
-function Race40Game:onLineClear(cleared_row_count)
-	if not self.clear then
-		self.lines = self.lines + cleared_row_count
-		if self.lines >= self.line_goal then
-			self.clear = true
-		end
-	end
-end
-
-function Race40Game:drawGrid(ruleset)
-	self.grid:draw()
-	if self.piece ~= nil then
-		self:drawGhostPiece(ruleset)
-	end
-end
-
-function Race40Game:getHighscoreData()
-	return {
-		level = self.level,
-		frames = self.frames,
-	}
-end
-
-function Race40Game:drawScoringInfo()
-	Race40Game.super.drawScoringInfo(self)
-	love.graphics.setColor(1, 1, 1, 1)
-
-	local text_x = config["side_next"] and 320 or 240
-	
-	love.graphics.setFont(font_3x5_2)
-	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("LINES", text_x, 320, 40, "left")
-	love.graphics.printf("line/min", text_x, 160, 80, "left")
-	love.graphics.printf("piece/sec", text_x, 220, 80, "left")
-
-	love.graphics.setFont(font_3x5_3)
-	love.graphics.printf(string.format("%.02f", self.lines / math.max(1, self.frames) * 3600), text_x, 180, 80, "left")
-	love.graphics.printf(string.format("%.04f", self.pieces / math.max(1, self.frames) * 60), text_x, 240, 80, "left")
-
-	love.graphics.setFont(font_3x5_4)
-	love.graphics.printf(math.max(0, self.line_goal - self.lines), text_x, 340, 40, "left")
-end
-
-function Race40Game:getBackground()
-	return 2
-end
-
-return Race40Game

tetris/modes/strategy.lua

@@ -16,7 +16,6 @@ StrategyGame.tagline = "You have lots of time to think! Can you use it to place
 
 function StrategyGame:new()
 	StrategyGame.super:new()
-	self.level = 0
 	self.clear = false
 	self.completed = false
 	self.roll_frames = 0
@@ -28,7 +27,7 @@ function StrategyGame:new()
 end
 
 function StrategyGame:getARE()
-	    if self.level < 100 then return 60
+		if self.level < 100 then return 60
 	elseif self.level < 200 then return 54
 	elseif self.level < 300 then return 48
 	elseif self.level < 400 then return 42
@@ -53,7 +52,7 @@ function StrategyGame:getLineClearDelay()
 end
 
 function StrategyGame:getLockDelay()
-	    if self.level < 500 then return 8
+		if self.level < 500 then return 8
 	elseif self.level < 700 then return 6
 	else return 4 end
 end
@@ -84,7 +83,7 @@ function StrategyGame:advanceOneFrame()
 end
 
 function StrategyGame:onPieceEnter()
-	if (self.level % 100 ~= 99) and not self.clear and self.frames ~= 0 then
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
 		self.level = self.level + 1
 	end
 end
@@ -99,16 +98,17 @@ function StrategyGame:onLineClear(cleared_row_count)
 end
 
 function StrategyGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	if not self.clear then
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
@@ -135,11 +135,11 @@ function StrategyGame:drawScoringInfo()
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
-	love.graphics.printf(self.level, text_x, 340, 50, "right")
+	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	if self.clear then
-		love.graphics.printf(self.level, text_x, 370, 50, "right")
+		love.graphics.printf(self.level, text_x, 370, 40, "right")
 	else
-		love.graphics.printf(math.floor(self.level / 100 + 1) * 100, text_x, 370, 50, "right")
+		love.graphics.printf(self.level < 900 and math.floor(self.level / 100 + 1) * 100 or 999, text_x, 370, 40, "right")
 	end
 end
 

tetris/modes/survival_2020.lua

@@ -27,6 +27,7 @@ function Survival2020Game:new()
 	self.randomizer = History6RollsRandomizer()
 
 	self.lock_drop = true
+	self.lock_hard_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
 end
@@ -45,7 +46,7 @@ function Survival2020Game:getLineARE()
 end
  
 function Survival2020Game:getDasLimit()
-	    if self.level < 200 then return 9
+		if self.level < 200 then return 9
 	elseif self.level < 500 then return 7
 	elseif self.level < 1000 then return 5
 	elseif self.level < 1500 then return 4
@@ -102,15 +103,15 @@ function Survival2020Game:getNextPiece(ruleset)
 end
 
 function Survival2020Game:hitTorikan(old_level, new_level)
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,00) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,00) then
 		self.level = 500
 		return true
 	end
-	if old_level < 1000 and new_level >= 1000 and self.frames > sp(5,00) then
+	if old_level < 1000 and new_level >= 1000 and self.frames > frameTime(5,00) then
 		self.level = 1000
 		return true
 	end
-	if old_level < 1500 and new_level >= 1500 and self.frames > sp(7,00) then
+	if old_level < 1500 and new_level >= 1500 and self.frames > frameTime(7,00) then
 		self.level = 1500
 		return true
 	end
@@ -174,16 +175,17 @@ function Survival2020Game:onLineClear(cleared_row_count)
 end
 
 function Survival2020Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	if not self.clear then
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
@@ -193,7 +195,7 @@ function Survival2020Game:updateSectionTimes(old_level, new_level)
 		section_time = self.frames - self.section_start_time
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
-		if section_time <= sp(0,30) then
+		if section_time <= frameTime(0,30) then
 			self.grade = self.grade + 2
 		else
 			self.grade = self.grade + 1

tetris/modes/survival_a1.lua

@@ -15,20 +15,28 @@ SurvivalA1Game.tagline = "The game starts fast and only gets faster!"
 
 
 function SurvivalA1Game:new()
-    SurvivalA1Game.super:new()
-    
+	SurvivalA1Game.super:new()
+	
 	self.roll_frames = 0
-    self.combo = 1
+	self.combo = 1
+	self.bravos = 0
+	
 	self.gm_conditions = {
 		level300 = false,
 		level500 = false,
 		level999 = false
-    }
-    
+	}
+	
+	self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
+	
 	self.randomizer = History4RollsRandomizer()
 
-    self.lock_drop = false
-    self.enable_hard_drop = false
+	self.lock_drop = false
+	self.enable_hard_drop = false
 	self.enable_hold = false
 	self.next_queue_length = 1
 end
@@ -54,29 +62,29 @@ function SurvivalA1Game:getLockDelay()
 end
 
 function SurvivalA1Game:getGravity()
-    return 20
+	return 20
 end
 
 local function getRankForScore(score)
-        if score <    400 then return {rank = "9", next = 400}
-    elseif score <    800 then return {rank = "8", next = 800}
-    elseif score <   1400 then return {rank = "7", next = 1400}
-    elseif score <   2000 then return {rank = "6", next = 2000}
-    elseif score <   3500 then return {rank = "5", next = 3500}
-    elseif score <   5500 then return {rank = "4", next = 5500}
-    elseif score <   8000 then return {rank = "3", next = 8000}
-    elseif score <  12000 then return {rank = "2", next = 12000}
-    elseif score <  16000 then return {rank = "1", next = 16000}
-    elseif score <  22000 then return {rank = "S1", next = 22000}
-    elseif score <  30000 then return {rank = "S2", next = 30000}
-    elseif score <  40000 then return {rank = "S3", next = 40000}
-    elseif score <  52000 then return {rank = "S4", next = 52000}
-    elseif score <  66000 then return {rank = "S5", next = 66000}
-    elseif score <  82000 then return {rank = "S6", next = 82000}
-    elseif score < 100000 then return {rank = "S7", next = 100000}
-    elseif score < 120000 then return {rank = "S8", next = 120000}
-    else return {rank = "S9", next = "???"}
-    end
+		if score <	400 then return {rank = "9", next = 400}
+	elseif score <	800 then return {rank = "8", next = 800}
+	elseif score <   1400 then return {rank = "7", next = 1400}
+	elseif score <   2000 then return {rank = "6", next = 2000}
+	elseif score <   3500 then return {rank = "5", next = 3500}
+	elseif score <   5500 then return {rank = "4", next = 5500}
+	elseif score <   8000 then return {rank = "3", next = 8000}
+	elseif score <  12000 then return {rank = "2", next = 12000}
+	elseif score <  16000 then return {rank = "1", next = 16000}
+	elseif score <  22000 then return {rank = "S1", next = 22000}
+	elseif score <  30000 then return {rank = "S2", next = 30000}
+	elseif score <  40000 then return {rank = "S3", next = 40000}
+	elseif score <  52000 then return {rank = "S4", next = 52000}
+	elseif score <  66000 then return {rank = "S5", next = 66000}
+	elseif score <  82000 then return {rank = "S6", next = 82000}
+	elseif score < 100000 then return {rank = "S7", next = 100000}
+	elseif score < 120000 then return {rank = "S8", next = 120000}
+	else return {rank = "S9", next = "???"}
+	end
 end
 
 function SurvivalA1Game:advanceOneFrame()
@@ -98,43 +106,48 @@ function SurvivalA1Game:onPieceEnter()
 end
 
 function SurvivalA1Game:onLineClear(cleared_row_count)
-    self:checkGMRequirements(self.level, self.level + cleared_row_count)
+	self:checkGMRequirements(self.level, self.level + cleared_row_count)
 	if not self.clear then
 		local new_level = math.min(self.level + cleared_row_count, 999)
-		if self.level == 999 then
+		if new_level == 999 then
 			self.clear = true
 		else
-			self.level = new_level
+		self.level = new_level
 		end
 	end
 end
 
 function SurvivalA1Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * self.combo
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
-	else
+	if not self.clear then
+		if self.grid:checkForBravo(cleared_lines) then
+			self.bravo = 4
+			self.bravos = self.bravos + 1
+		else self.bravo = 1 end
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
 function SurvivalA1Game:checkGMRequirements(old_level, new_level)
 	if old_level < 300 and new_level >= 300 then
-		if self.score > 12000 and self.frames <= sp(4,15) then
+		if self.score >= 12000 and self.frames <= frameTime(4,15) then
 			self.gm_conditions["level300"] = true
 		end
 	elseif old_level < 500 and new_level >= 500 then
-		if self.score > 40000 and self.frames <= sp(7,30) then
+		if self.score >= 40000 and self.frames <= frameTime(7,30) then
 			self.gm_conditions["level500"] = true
 		end
 	elseif old_level < 999 and new_level >= 999 then
-		if self.score > 126000 and self.frames <= sp(13,30) then
-			self.gm_conditions["level900"] = true
+		if self.score >= 126000 and self.frames <= frameTime(13,30) then
+			self.gm_conditions["level999"] = true
 		end
 	end
 end
@@ -151,17 +164,23 @@ function SurvivalA1Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")
 	love.graphics.printf("SCORE", 240, 200, 40, "left")
 	love.graphics.printf("NEXT RANK", 240, 260, 90, "left")
 	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
+
+	if self.bravos > 0 then love.graphics.printf("BRAVO", 300, 120, 40, "left") end
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
-	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level900"] then
+	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level999"] then
 		love.graphics.printf("GM", 240, 140, 90, "left")
 	else
 		love.graphics.printf(getRankForScore(self.score).rank, 240, 140, 90, "left")
@@ -169,6 +188,10 @@ function SurvivalA1Game:drawScoringInfo()
 	love.graphics.printf(getRankForScore(self.score).next, 240, 280, 90, "left")
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
+	if self.bravos > 0 then love.graphics.printf(self.bravos, 300, 140, 40, "left") end
 
 	love.graphics.setFont(font_8x11)
 	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")

tetris/modes/survival_a2.lua

@@ -19,8 +19,15 @@ function SurvivalA2Game:new()
 	self.roll_frames = 0
 	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
+	
+	self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
 
 	self.lock_drop = true
+	self.lock_hard_drop = true
 end
 
 function SurvivalA2Game:getARE()
@@ -62,7 +69,7 @@ function SurvivalA2Game:getGravity()
 end
 
 function SurvivalA2Game:hitTorikan(old_level, new_level)
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,25) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,25) then
 		self.level = 500
 		return true
 	end
@@ -82,7 +89,7 @@ function SurvivalA2Game:advanceOneFrame()
 end
 
 function SurvivalA2Game:onPieceEnter()
-	if (self.level % 100 ~= 99 or self.level == 998) and not self.clear and self.frames ~= 0 then
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
 		self.level = self.level + 1
 	end
 end
@@ -92,6 +99,9 @@ function SurvivalA2Game:onLineClear(cleared_row_count)
 		local new_level = math.min(self.level + cleared_row_count, 999)
 		if self.level == 999 or self:hitTorikan(self.level, new_level) then
 			self.clear = true
+			if self.level < 999 then
+				self.game_over = true
+			end
 		else
 			self.level = new_level
 		end
@@ -99,22 +109,25 @@ function SurvivalA2Game:onLineClear(cleared_row_count)
 end
 
 function SurvivalA2Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * self.combo
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
-	else
+	if not self.clear then
+		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
 function SurvivalA2Game:getLetterGrade()
 		if self.level >= 999 then return "GM"
-	elseif self.level >= 500 then return "M" 
+	elseif self.level >  500 then return "M" 
+	elseif self.level == 500 and not self.clear then return "M" 
 	else return "" end
 end
 
@@ -132,18 +145,28 @@ function SurvivalA2Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("GRADE", text_x, 120, 40, "left")
+	if self:getLetterGrade() ~= "" then love.graphics.printf("GRADE", text_x, 120, 40, "left") end
 	love.graphics.printf("SCORE", text_x, 200, 40, "left")
 	love.graphics.printf("LEVEL", text_x, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
-	love.graphics.printf(self:getLetterGrade(), text_x, 140, 90, "left")
+	if self.roll_frames > 2968 then love.graphics.setColor(1, 0.5, 0, 1)
+	elseif self.level >= 999 and self.clear then love.graphics.setColor(0, 1, 0, 1) end
+	if self:getLetterGrade() ~= "" then love.graphics.printf(self:getLetterGrade(), text_x, 140, 90, "left") end
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), text_x, 370, 40, "right")
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
 end
 
 function SurvivalA2Game:getSectionEndLevel()

tetris/modes/survival_a3.lua

@@ -12,11 +12,8 @@ SurvivalA3Game.hash = "SurvivalA3"
 SurvivalA3Game.tagline = "The blocks turn black and white! Can you make it to level 1300?"
 
 
-
-
 function SurvivalA3Game:new()
 	SurvivalA3Game.super:new()
-	self.level = 0
 	self.grade = 0
 	self.garbage = 0
 	self.clear = false
@@ -24,19 +21,37 @@ function SurvivalA3Game:new()
 	self.roll_frames = 0
 	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
-
+	
+	self.SGnames = {
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9",
+		"GM"
+	}
+	
 	self.lock_drop = true
+	self.lock_hard_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
+
+	self.coolregret_message = "COOL!!"
+	self.coolregret_timer = 0
+end
+
+function SurvivalA3Game:initialize(ruleset)
+
+	self.torikan_time = frameTime(2,28)
+	if ruleset.world then self.torikan_time = frameTime(3,03) end
+	self.super.initialize(self, ruleset)
+	--		^ notice the . here instead of the :
 end
 
 function SurvivalA3Game:getARE()
-	    if self.level < 300 then return 12
+		if self.level < 300 then return 12
 	else return 6 end
 end
 
 function SurvivalA3Game:getLineARE()
-	    if self.level < 100 then return 8
+		if self.level < 100 then return 8
 	elseif self.level < 200 then return 7
 	elseif self.level < 500 then return 6
 	elseif self.level < 1300 then return 5
@@ -44,7 +59,7 @@ function SurvivalA3Game:getLineARE()
 end
 
 function SurvivalA3Game:getDasLimit()
-	    if self.level < 100 then return 9
+		if self.level < 100 then return 9
 	elseif self.level < 500 then return 7
 	else return 5 end
 end
@@ -55,7 +70,7 @@ function SurvivalA3Game:getLineClearDelay()
 end
 
 function SurvivalA3Game:getLockDelay()
-	    if self.level < 200 then return 18
+		if self.level < 200 then return 18
 	elseif self.level < 300 then return 17
 	elseif self.level < 500 then return 15
 	elseif self.level < 600 then return 13
@@ -86,11 +101,11 @@ function SurvivalA3Game:getNextPiece(ruleset)
 end
 
 function SurvivalA3Game:hitTorikan(old_level, new_level)
-	if old_level < 500 and new_level >= 500 and self.frames > sp(2,28) then
+	if old_level < 500 and new_level >= 500 and self.frames > self.torikan_time then
 		self.level = 500
 		return true
 	end
-	if old_level < 1000 and new_level >= 1000 and self.frames > sp(4,56) then
+	if old_level < 1000 and new_level >= 1000 and self.frames > self.torikan_time*2 then
 		self.level = 1000
 		return true
 	end
@@ -123,20 +138,21 @@ function SurvivalA3Game:onPieceEnter()
 end
 
 local cleared_row_levels = {1, 2, 4, 6}
-local cleared_row_points = {0.02, 0.05, 0.15, 0.6}
 
 function SurvivalA3Game:onLineClear(cleared_row_count)
 	if not self.clear then
 		local new_level = self.level + cleared_row_levels[cleared_row_count]
 		self:updateSectionTimes(self.level, new_level)
 		if new_level >= 1300 or self:hitTorikan(self.level, new_level) then
+			self.clear = true
 			if new_level >= 1300 then
 				self.level = 1300
+				self.grid:clear()
+				self.big_mode = true
+				self.roll_frames = -150
+			else
+				self.game_over = true
 			end
-			self.clear = true
-			self.grid:clear()
-			self.big_mode = true
-			self.roll_frames = -150
 		else
 			self.level = math.min(new_level, 1300)
 		end
@@ -145,20 +161,22 @@ function SurvivalA3Game:onLineClear(cleared_row_count)
 end
 
 function SurvivalA3Game:onPieceLock(piece, cleared_row_count)
+	self.super:onPieceLock()
 	if cleared_row_count == 0 then self:advanceBottomRow(1) end
 end
 
 function SurvivalA3Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	if not self.clear then
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end
 
@@ -168,8 +186,11 @@ function SurvivalA3Game:updateSectionTimes(old_level, new_level)
 		section_time = self.frames - self.section_start_time
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
-		if section_time <= sp(1,00) then
+		if section_time <= frameTime(1,00) then
 			self.grade = self.grade + 1
+		else
+			self.coolregret_message = "REGRET!!"
+			self.coolregret_timer = 300
 		end
 	end
 end
@@ -207,12 +228,24 @@ function SurvivalA3Game:drawScoringInfo()
 	love.graphics.printf("GRADE", text_x, 120, 40, "left")
 	love.graphics.printf("SCORE", text_x, 200, 40, "left")
 	love.graphics.printf("LEVEL", text_x, 320, 40, "left")
+	local sg = self.grid:checkSecretGrade()
+	if sg >= 5 then 
+		love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+	end
+	
+	if(self.coolregret_timer > 0) then
+		love.graphics.printf(self.coolregret_message, 64, 400, 160, "center")
+		self.coolregret_timer = self.coolregret_timer - 1
+	end
 
 	local current_section = math.floor(self.level / 100) + 1
 	self:drawSectionTimesWithSplits(current_section)
 
 	love.graphics.setFont(font_3x5_3)
+	if self.roll_frames > 3238 then love.graphics.setColor(1, 0.5, 0, 1)
+		elseif self.level >= 1300 and self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	love.graphics.printf(getLetterGrade(math.floor(self.grade)), text_x, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
 	love.graphics.printf(self.level, text_x, 340, 50, "right")
 	if self.clear then
@@ -220,6 +253,9 @@ function SurvivalA3Game:drawScoringInfo()
 	else
 		love.graphics.printf(math.floor(self.level / 100 + 1) * 100, text_x, 370, 50, "right")
 	end
+	if sg >= 5 then
+		love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+	end
 end
 
 function SurvivalA3Game:getBackground()

tetris/randomizers/always.lua

@@ -2,17 +2,8 @@ local Randomizer = require 'tetris.randomizers.randomizer'
 
 local AlwaysRandomizer = Randomizer:extend()
 
-function AlwaysRandomizer:new(piece)
-	self.piece = piece
-	self:initialize()
-	self.next_queue = {}
-	for i = 1, 30 do
-		table.insert(self.next_queue, self:generatePiece())
-	end
-end
-
 function AlwaysRandomizer:generatePiece()
-	return self.piece
+	return "I"
 end
 
 return AlwaysRandomizer