local module = {
	_NAME = "first"
}

local mode = {}

eventOnModeChange = function()
	-- Here you reset all the global info (not related to a specific mode)
	-- as removing password, textareas, images...
	-- Read the spoiler 1 for a help with that ^
end

-- You can also make a timer to avoid mode change several
-- times in the same minute...
local getModule = function(moduleName, triggerEvent)
	-- not not is a good practice to make any value a boolean, so the
	-- variable will be way smoother than saving the whole module in it
	-- (without not not)
	local exists = not not mode[moduleName]

	if exists then
		module._NAME = moduleName

		-- We just want to refresh the stuff when it is a mode change,
		-- but not when it's the first time the script is triggered.
		if triggerEvent then
			eventOnModeChange()
		end
	end

	return exists
end

-- We'll create a table to say the character and the function that handles the value post-character.
-- Read the spoiler 2 for an admin system according to the name of the room.

local roomSettings= {}
roomSettings[1] = {
	-- My default is #, but i'll use & to avoid mixing it with some stuff.
	char = "&", -- character that will be used to define the mode.
	-- The _execute_ function will always receive a value, that is the characterVALUE_HERE
	execute = function(moduleName)
		if moduleName then
			-- First time that it is executed, so the event won't be triggered
			-- The module will be set only if it exists. Otherwise the default
			-- module (initial module._NAME) will be active.
			getModule(moduleName, false)
		end
	end
}
-- Here you'll be able to create more settings with different characters to your module.
-- Avoid: letters, numbers, characters that are not in the keyboard, +, %, $

-- Now we'll create a function to handle this table.

-- We need to check if the room is a #room or a tribe house.
-- For that, we'll check if the second byte of the name of the room is
-- different of 3 (that weirdo unicode in the tribe house names)
local isRoom = string.byte(tfm.get.room.name, 2) ~= 3

-- We'll also get the room parameters (if it is a room).
-- The pattern in the code below is defined by:
--[[
	May start with *, but may not;
	There must be a # after that;
	Then, there must be the main module name (initial module._NAME);
	So we need a number sequence (obligatory, [0:99999])
	Finally, (.*), that means "everything after the number sequence". Its value
		will be the _roomAttributes_.
]]
local roomAttributes = isRoom and string.match(tfm.get.room.name, "%*?#" .. module._NAME .. "%d+(.*)")

local setRoomSettings= function()
	if roomAttributes then -- Verifies automatically if it is a room too
		-- We'll check a "&letters_and_underscores"
		-- So we'll run the _execute_ function of the & character
		roomSettings[1].execute(string.match(roomAttributes, roomSettings[1].char .. "([%a_]+)"))
		
		-- To handle more characters, read the spoiler 2
	end
end

-- Use functions in the format NAME = function(parameters)

-- Firstly, make the default module (initial module._NAME)
mode.first = {
	time = 0,

	printf = function(where, who, message)
		print(string.format("[#%s] [%s] %s", where, who, message))
	end,
	-- In all the modules, make two functions (mandatory): init / reset

	reset = function()
		-- Here you reset all the local info (related to the specific mode)
		-- as, reseting variables, player cash, time, etc...
		-- It's the _eventOnModeChange_ of the module

		mode.first.time = 10000
	end,

	init = function()
		-- Here you put all the initial local informations (related to the module only)
		-- as the disable functions (AutoScore, AutoShaman, etc...)

		tfm.exec.disableAutoShaman()
		
		-- Use mode.first.FUNCTION to access a function in the table.
		-- Putting mode.first in a variable won't improve the performance.
		mode.first.printf("chat", "game", "this sheeet started")

		mode.first.time = 10000
	end,

	-- Now you can create the official events
	eventLoop = function(time)
		mode.first.time = time
	end,
	eventNewGame = function()
		mode.first.printf("tribe", "game", "yaaaay come to play guys")
	end
}

-- Make how many modules you want.
-- Take care, the bigger your code is, the more time it'll take to load.

-- We'll make a table with the names of all the official events
local eventNames = {"eventLoop", "eventNewGame", "eventPlayerDied", "eventPlayerGetCheese", "eventPlayerVampire", "eventPlayerWon", "eventPlayerLeft", "eventEmotePlayed", "eventKeyboard", "eventMouse", "eventPopupAnswer", "eventTextAreaCallback", "eventChatCommand", "eventChatMessage", "eventSummoningStart", "eventSummoningEnd", "eventSummoningCancel", "eventNewPlayer", "eventPlayerRespawn", "eventColorPicked"}

-- And another table that will maintain all the events of the current module.
local events = {}

-- We'll make an empty function for the nonexistent events
-- As default, we'll call it foo
foo = function() end

initialize = function(refresh)
	-- We refresh the event table every time the function is called
	events = {}

	-- Now we'll make a loop will all the functions
	for _, event in next, eventNames do

		-- Puts in the event table the respective function that is in the module.
		-- as events["eventLoop"] = mode.first.eventLoop
		-- If it is nonexistent, the associated function will be _foo_, that doesn't do anything.
		events[event] = mode[module._NAME][event] or foo
	end

	-- If _refresh_ is true, then we'll refresh the module
	if refresh then
		if mode[module._NAME].reset then
			mode[module._NAME].reset()
		end
	end

	-- Finally, we initialize the module
	mode[module._NAME].init()

	-- For good practices, we loop the eventNewPlayer for all the players
	table.foreach(tfm.get.room.playerList, eventNewPlayer)
end

--- Now the 3 most important steps:
-- Create all the official events
for _, event in next, eventNames do
	_G[event] = events[event]
end

-- Run the room settings
setRoomSettings()

-- Initialize our module for the first time
initialize(false) -- not refreshing