minetest-quake/_weapons/weapons.lua

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)
        if not target_pointed_thing then return end
        local player_count = 0
      	local i = 0
      	for i = 2,(target_pointed_thing[1])+1 do
      		if target_pointed_thing[i] then
      		  quake.shoot(target_pointed_thing[1], user:get_player_name(), target_pointed_thing[i].ref, def.weap_damage, has_knockback)
      		end
      	end
        player_count = 0
      else
        local has_knockback = def.knockback
        local bullet_name = def.bullet
        --i parametri potrebbero essere inutili ma non ne sono sicuro. Lasciamo così finchè va.
        quake.shoot_bullet(user, pointed_thing, bullet_name, pos_head, dir)
        --TODO armi con proiettili
      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