minetest-quake/_weapons/weapons.lua

local function get_pointed_players(pos, dir, dist, username) end
local function shoot(target) end


function quake.register_weapon(name, def)

  local weap_delay = def.weap_delay
  local weap_sound_shooting = def.weap_sound_shooting
  local is_hitscan = def.is_hitscan
  local range = def.range
  local has_knockback = def.has_knockback

  minetest.register_node(name, {

    description = def.description,
    drawtype = "mesh",
    mesh = def.mesh,
    tiles = def.tiles,
    wield_scale = def.wield_scale,
    inventory_image = def.inventory_image,
    stack_max = 1,
    groups = {oddly_breakable_by_hand = "2"},
    
    on_drop = function()
      return nil
    end,

    on_place = function()
      return nil
    end,

    on_use = function(itemstack, user, pointed_thing)

      ----- gestione delay dell'arma -----
      if user:get_meta():get_int("quake_weap_delay") == 1 then
        return end

      user:get_meta():set_int("quake_weap_delay", 1)

      local inv = user:get_inventory()

      minetest.after(weap_delay, function()
        if inv:contains_item("main", "quake:match_over") then return end
        user:get_meta():set_int("quake_weap_delay", 0)
        end)
      -----fine gestione delay -----


      --se sono immune e sparo, perdo l'immunità
      if inv:contains_item("main", "arena_lib:immunity") then
        inv:remove_item("main", "arena_lib:immunity")
      end

      -- riproduzione suono
      minetest.sound_play(weap_sound_shooting, {
        to_player = user:get_player_name(),
        max_hear_distance = 5,
        })

      local dir = user:get_look_dir()
      local pos = user:get_pos()
      local pos_head = {x = pos.x, y = pos.y+1.475, z = pos.z}            -- deve sparare all'altezza mirino, ovvero dalla testa
      local username = user:get_player_name()

      local target_pointed_thing

      if def.is_hitscan then
        target_pointed_thing = get_pointed_players(pos_head, dir, range, username)
      else
        --TODO armi con proiettili
      end

      if not target_pointed_thing then return end

    	local i = 0
    	for i = 2,(target_pointed_thing[1])+1 do
    		if target_pointed_thing[i] then
    		  shoot(user:get_player_name(), target_pointed_thing[i], def.weap_damage, has_knockback)
    		end
    	end

    end,

    })

end


-- ritorna un array di player con a index 1 il numero di player trovati. Se non
-- trova player diversi da se stessi ritorna nil
function get_pointed_players(head_pos, dir, dist, username)
	local p1 = vector.add(head_pos, vector.divide(dir,4))
	local p2 = vector.add(head_pos, vector.multiply(dir, dist))
	local ray = minetest.raycast(p1, p2, true, true)

	minetest.add_particlespawner({
  	amount = 20,
  	time = 0.3,
  	minpos = p1,
  	maxpos = p1,
  	minvel = vector.multiply(dir,120),
  	maxvel = vector.multiply(dir,120),
  	minexptime = 0.2,
  	maxexptime = 0.2,
  	size = 2,
  	collisiondetection = false,
  	vertical = false,
    texture = "quake_railgun_trail.png"
	})

	local array = {} --inizializzo array con numero di giocatori a 0
	array[1] = 0
	local i = 2
  -- check su ogni cosa attraversata dal raycast (p1 a p2)
	for hit in ray do
    -- se è un oggetto
		if hit.type == "object" and hit.ref then
      -- se è un giocatore
			if hit.ref:is_player() then
        -- e non è colui che spara
				if hit.ref:get_player_name() ~= username then
					array[i] = hit
					array[1] = i - 1 --incrementa il numero di giocatori
					i = i + 1
				end
			end

		else
      -- se è un nodo mi fermo, e ritorno l'array se > 0 (ovvero ha trovato giocatori)
			if hit.type == "node" then
				if array[1] > 0 then
					return array
				else
					return nil
				end
			end
		end
	end
  -- se ho sparato a qualcuno puntando in aria (quindi senza incrociare blocchi)
	if array[1] > 0 then
		return array
	end

end


function shoot(p_name, pointed_thing, damage, has_knockback)

  local pos = minetest.get_pointed_thing_position(pointed_thing)
  local target = pointed_thing.ref
  local arena = arena_lib.get_arena_by_player(p_name)

  if not arena then return end -- uno potrebbe sparare nel decimo di secondo di sostituzione arma a fine match e far crashare

  if target:get_hp() <= 0 or arena.in_celebration then return end

  -- controllo le immunità
  if target:get_inventory():contains_item("main", "arena_lib:immunity") then
    minetest.chat_send_player(p_name, "Non puoi colpire " .. target:get_player_name() .. ", è immune")
    --TODO: sostituire con un suono
  return end

  -- eventuale knockback
  if has_knockback then
    local dir = minetest.get_player_by_name(p_name):get_look_dir()
    local knockback = vector.multiply(dir,14)
    target:add_player_velocity(knockback)
  end

  -- applico il danno
  target:set_hp(target:get_hp() - damage)

  if target:get_hp() > 0 then return end


  ----- applico la morte -----

  -- riproduco suono morte
  minetest.sound_play("quake_kill", {
    to_player = p_name,
    max_hear_distance = 1,
  })

  -- uccido il giocatore
  local t_name = target:get_player_name()
  minetest.chat_send_player(p_name, "[Quake] Hai ucciso " .. minetest.colorize("#eea160", t_name))
  minetest.chat_send_player(t_name, "[Quake] Sei stato ucciso da " .. minetest.colorize("#eea160", p_name))

  -- aggiungo la kill
  local p_stats = arena.players[p_name]
  p_stats.kills = p_stats.kills +1
  p_stats.killstreak = p_stats.killstreak +1
  quake.calc_kill_leader(arena, p_name)

  -- visibilità kill leader
  local kill_leader = arena.kill_leader
  for pl_name, stats in pairs(arena.players) do
    quake.update_HUD(arena, pl_name, "KLR_data", arena.players[kill_leader].kills .. "  |  " .. kill_leader)
  end

  --TODO: aggiungere effetti sonori
  -- eventuale killstreak
  if p_stats.killstreak == 3 then
    arena_lib.send_message_players_in_arena(arena, "[Quake] " .. minetest.colorize("#eea160", p_name) .. " è in una " .. minetest.colorize("#eea160", "serie d'uccisioni").. "!")
    quake.add_xp(p_name, 10)
    quake.add_achievement(p_name, 1)
    quake.show_achievement(p_name, 1)
  elseif p_stats.killstreak == 5 then
    arena_lib.send_message_players_in_arena(arena, "[Quake] " .. minetest.colorize("#eea160", p_name) .. " è " .. minetest.colorize("#eea160", "inarrestabile").. "!")
    quake.add_xp(p_name, 25)
    quake.add_achievement(p_name, 2)
    quake.show_achievement(p_name, 2)
  elseif p_stats.killstreak == 7 then
    arena_lib.send_message_players_in_arena(arena, "[Quake] " .. minetest.colorize("#eea160", p_name) .. " è una " .. minetest.colorize("#eea160", "FURIA OMICIDA").. "!")
    quake.add_xp(p_name, 50)
    quake.add_achievement(p_name, 3)
    quake.show_achievement(p_name, 3)
  end

  -- aggiorno HUD
  quake.update_HUD(arena, p_name, "KLS_data", p_stats.kills)
  quake.update_stats(arena)

  -- aggiungo XP
  quake.add_xp(p_name, 5)

  -- se kill cap raggiunto finisce match
  if arena.players[p_name].kills == arena.kill_cap then

    local mod = arena_lib.get_mod_by_player(p_name)
    arena_lib.load_celebration(mod, arena, p_name)
  end

end