minetest-quake/quake/init.lua

-- load other scripts
dofile(minetest.get_modpath("quake") .. "/api.lua")
dofile(minetest.get_modpath("quake") .. "/chatcmdbuilder.lua")
dofile(minetest.get_modpath("quake") .. "/commands.lua")
dofile(minetest.get_modpath("quake") .. "/playermanager.lua")
dofile(minetest.get_modpath("quake") .. "/privs.lua")
dofile(minetest.get_modpath("quake") .. "/weapons.lua")


--[[sovrascrizione "on_punch" nodo base dei cartelli per farli entrare
    nell'arena se sono cartelli appositi e "on_timer" per teletrasportali in partita quando la queue finisce]]
minetest.override_item("default:sign_wall", {

    on_punch = function(pos, node, puncher, pointed_thing)

      local arenaID = minetest.get_meta(pos):get_int("arenaID")
      if arenaID == 0 then return end

      local sign_arena = quake.arenas[arenaID]
      local p_name = puncher:get_player_name()

      if not sign_arena then return end -- nel caso qualche cartello dovesse buggarsi, si può rompere e non fa crashare

      -- se è già in coda o viene fermato (cartello diverso) o si toglie dalla coda (cartello uguale)
      if quake.is_player_in_arena(p_name) then

        if quake.get_arenaID_by_player(p_name) ~= arenaID then
          minetest.chat_send_player(p_name, "[Quake]" .. minetest.colorize("#e6482e", "Devi prima uscire dalla coda di " .. arena.name .. "!"))
        else

          sign_arena.players[p_name] = nil
          quake.update_sign(pos, sign_arena)
          minetest.chat_send_player(p_name, "[Quake] Sei uscito dalla coda")
          quake.send_message_players_in_arena(arenaID, "[Quake] " .. p_name .. " ha abbandonato la coda")

          -- se non ci sono più abbastanza giocatori, annullo la coda
          if quake.get_arena_players_count(arenaID) < sign_arena.min_players and sign_arena.in_queue then
            timer:stop()
            quake.send_message_players_in_arena(arenaID, "[Quake] La coda è stata annullata per troppi pochi giocatori")
          end
        end
      return end

      -- se l'arena è piena
      if quake.get_arena_players_count(arenaID) == sign_arena.max_players then
        minetest.chat_send_player(p_name, minetest.colorize("#e6482e", "[!] L'arena è già piena!"))
        return end

      -- notifico i vari giocatori del nuovo player
      if sign_arena.in_game then

        --TODO: butta dentro alla partita in corso. Sì, si può entrare mentre è in corso -------- quake.join_arena(arenaID)

        quake.send_message_players_in_arena(arenaID, "[Quake] " .. p_name .. " si è aggiunto alla partita")
        minetest.chat_send_player(p_name, "[Quake] Sei entrato nell'arena " .. sign_arena.name)
      else
        quake.send_message_players_in_arena(arenaID, "[Quake] " .. p_name .. " si è aggiunto alla coda")
        minetest.chat_send_player(p_name, "[Quake] Ti sei aggiunto alla coda per " .. sign_arena.name)
      end

      -- aggiungo il giocatore e aggiorno il cartello
      sign_arena.players[p_name] = {kills = 0, deaths = 0, killstreak = 0}
      quake.update_storage()
      quake.update_sign(pos, sign_arena)

      local timer = minetest.get_node_timer(pos)
      local waiting_time = 5

      -- se ci sono abbastanza giocatori, parte il timer di attesa
      if quake.get_arena_players_count(arenaID) == sign_arena.min_players and not sign_arena.in_queue and not sign_arena.in_game then
        quake.send_message_players_in_arena(arenaID, "[Quake] La partita inizierà tra " .. waiting_time .. " secondi!")
        sign_arena.in_queue = true
        timer:start(waiting_time)
      end

      -- se raggiungo i giocatori massimi e la partita non è iniziata, parte subito
      if quake.get_arena_players_count(arenaID) == sign_arena.max_players and sign_arena.in_queue then
        timer:stop()
        timer:start(0.01)
      end

      --TODO: timer ciclico che avvisa i giocatori quanto tempo manca ogni N secondi

    end,

    -- quello che succede una volta che il timer raggiunge lo 0
    on_timer = function(pos)

      local arenaID = minetest.get_meta(pos):get_int("arenaID")
      local sign_arena = quake.arenas[arenaID]

      sign_arena.in_queue = false
      sign_arena.in_game = true
      quake.update_sign(pos, sign_arena)

      quake.load_arena(arenaID)

      return false
    end,

})


minetest.register_node("quake:create_sign", {

    description = "Left click on a sign to create an entrance or to remove it",
    tiles = {"trickerytown.png"},
    groups = {oddly_breakable_by_hand = "2"},

    on_use = function(itemstack, user, pointed_thing)

      local pos = minetest.get_pointed_thing_position(pointed_thing)
      if pos == nil then return end -- nel caso sia aria, sennò crasha

      local node = minetest.get_node(pos)
      local def = minetest.registered_items[node.name]

      --controllo se è un cartello
      if def and def.entity_info then
        def.number_of_lines = 5

        local arena_ID = itemstack:get_meta():get_int("arenaID")
        local arena = quake.arenas[arena_ID]

        -- controllo se c'è già un cartello assegnato a quell'arena. Se è lo stesso lo rimuovo, sennò annullo
        if next(arena.sign) ~= nil then
          if minetest.serialize(pos) == minetest.serialize(arena.sign) then
            minetest.set_node(pos, {name = "air"})
            arena.sign = {}
            minetest.chat_send_player(user:get_player_name(), "Cartello dell'arena " .. arena.name .. " rimosso con successo")
          else
            minetest.chat_send_player(user:get_player_name(), minetest.colorize("#e6482e", "[!] Esiste già un cartello per quest'arena!"))
          end
        return end

        -- cambio la scritta
        quake.update_sign(pos, arena)

        -- aggiungo il cartello ai cartelli dell'arena
        arena.sign = pos

        -- salvo l'ID come metadato nel cartello
        minetest.get_meta(pos):set_int("arenaID", arena_ID)

        --TODO: rimuovere item
      else
        minetest.chat_send_player(user:get_player_name(), minetest.colorize("#e6482e", "[!] L'oggetto non è un cartello!"))
      end
    end,

})