Add standalone API

README.md

@@ -0,0 +1,62 @@
+# Gunslinger
+
+This mod provides an API to add a variety of realistic and enjoyable guns to Minetest. A variety of different guns are provided with the mod, and can be disabled if required.
+
+## License
+
+- **Code**: MIT
+- **Media**: CC0
+
+## Architecture
+
+Gunslinger makes use of gun _types_ in order to ease registration of similar guns. A `type` is made up of a name and a table of default values to be applied to all guns registered with that type. At least one type needs to be registered in order to register guns.
+
+`Raycast` is used to find target in line-of-sight, and all objects take damage. Damage is calculated as detailed in [Damage calculation](###Damage-calculation)
+
+## API
+
+### Damage calculation
+
+Weapon damage = `def.type.base_dmg * def.dmg_mult`
+
+If headshot, damage is increased by 50%
+
+If shooter was looking through scope, damage is increased by 20%
+
+### Methods
+
+#### `gunslinger.register_type(name, def)`
+
+- Registers a def table for the type `name`.
+- The def table contains the default values for all the guns registered with this type. e.g. `style_of_fire`, `enable_scope`, etc.
+
+#### `gunslinger.register_gun(name, def)`
+
+- Registers a gun with the type `def.type`, and assigns the type defaults to the gun.
+- The def table contains gun-specific values like `clip_size`, `wield_image`, `scope_image`, etc.
+- Default type values can also be overridden per gun by just including that value in the def table.
+
+### Definition table fields used by API methods
+
+#### Fields passed to `gunslinger.register_type`
+
+- `type` [string]: Name of a valid type (i.e. type registered by `gunslinger.register_type`)
+- `style_of_fire` [string]: Sets style of fire
+  - `"manual"`: One shot per-click.
+  - `"burst"`: Three shots per-click.
+  - `"splash"`: Shotgun-style pellets; one burst per-click.
+  - `"automatic"`: Fully automatic; shoots as long as primary button is held down.
+  - `"semi-automatic"`: Same as `"automatic"`, but switches to `"burst"` when scope view is toggled.
+- `scope` [string]: Sets style of scope.
+  - `"none"`: Default. No scope functionality.
+  - `"ironsight"`: Ironsight, without zoom. Unrestricted peripheral vision
+  - `"scope"`: Proper scope, with zoom. Restricted peripheral vision.
+- `base_dmg` [number]: Base amount of damage dealt in HP.
+
+#### Fields passed to `gunslinger.register_gun`
+
+- `itemdef` [table]: Item definition table passed to `minetest.register_item`.
+- `scope_overlay` [string]: Name of scope overlay texture. Must be provided if `scope` is defined. Overlay texture would be stretched across the screen.
+- `clip_size` [number]: Number of bullets per-clip.
+- `fire_rate` [number]: Number of shots per-second.
+- `dmg_mult` [number]: Damage multiplier value. Final damage is calculated by multiplying `dmg_mult` with the type's `base_dmg`.

api.lua

@@ -0,0 +1,191 @@
+gunslinger = {}
+local guns = {}
+local types = {}
+local automatic = {}
+local scope_overlay = {}
+
+--
+-- Internal API functions
+--
+
+local function get_def(name)
+	return guns[name]
+end
+
+local function play_sound(sound, player)
+	minetest.sound_play(sound, {
+		object = player,
+		loop = false
+	})
+end
+
+local function show_scope(player, def)
+	if not player then
+		return
+	end
+
+	-- Create HUD image
+	scope_overlay[player:get_player_name()] = player:hud_add({
+		hud_elem_type = "image",
+		position = {x = 0.5, y = 0.5},
+		alignment = {x = 0, y = 0},
+		text = def.scope_overlay
+	})
+end
+
+local function hide_scope(player)
+	if not player then
+		return
+	end
+
+	local name = player:get_player_name()
+	player:hud_remove(scope_overlay[name])
+	scope_overlay[name] = nil
+end
+
+local function fire(stack, player)
+	-- Take aim
+	local def = get_def(stack:get_name())
+	local eye_offset = player:get_eye_offset().offset_first
+	local p1 = vector.add(player:get_pos(), eye_offset)
+	p1 = vector.add(p1, player:get_look_dir())
+	local p2 = vector.add(p1, vector.multiply(player:get_look_dir(), max_dist))
+	local ray = minetest.raycast(p1, p2)
+	local pointed = ray:next()
+
+	-- Fire!
+	if pointed and pointed.type == "object" then
+		local target = pointed.ref
+		local point = pointed.intersection_point
+		local dmg = base_dmg * def.dmg_mult
+
+		-- Add 50% damage if headshot
+		if point.y > target:get_pos().y + 1.5 then
+			dmg = dmg * 1.5
+		end
+
+		-- Add 20% more damage if player using scope
+		if scope_overlay[player:get_player_name()] then
+			dmg = dmg * 1.2
+		end
+
+		target:set_hp(target:get_hp() - dmg)
+	end
+
+	-- Update wear
+	wear = wear + def.wear_step
+	stack:set_wear(wear)
+
+	return stack
+end
+
+local function reload(stack, player)
+	-- Check for ammo
+	local inv = player:get_inventory()
+	if inv:contains_item("main", "gunslinger:ammo") then
+		-- Ammo exists, reload and reset wear
+		inv:remove_item("main", "gunslinger:ammo")
+		stack:set_wear(0)
+	else
+		-- No ammo, play click sound
+		play_sound("gunslinger_ooa", player)
+	end
+
+	return stack
+end
+
+local function on_lclick(stack, player)
+	local wear = stack:get_wear()
+	local def = get_def(stack:get_name())
+	if wear >= 65535 then
+		--Reload
+		stack = reload(stack, player)
+	else
+		if def.style_of_fire == "automatic" then
+			automatic[player:get_player_name()] = {
+				stack  = stack,
+				def    = def
+			}
+		else
+			stack = fire(stack, player)
+		end
+	end
+
+	return stack
+end
+
+local function on_rclick(stack, player)
+	local def = get_def(stack:get_name())
+	local hud = scope_overlay[player:get_player_name()]
+	if hud then
+		hide_scope(player)
+	else
+		show_scope(player, def)
+	end
+
+	return stack
+end
+
+local function verify_def(def, is_gun)
+
+end
+
+-- Globalstep to handle firing of automatic guns
+minetest.register_globalstep(function(dtime)
+	for name, info in pairs(automatic) do
+		local player = minetest.get_player_by_name(name)
+		if player:get_player_control().LMB then
+			-- If LMB pressed, fire
+			info.stack = fire(info.stack, player)
+		else
+			-- If LMB not pressed, remove player from list
+			automatic[name] = nil
+		end
+	end
+end)
+
+--
+-- Ammo
+--
+
+
+
+--
+-- Gun registration
+--
+
+function gunslinger.register_type(name, def)
+	assert(type(name) == "string" and type(def) == "table",
+			   "gunslinger.register_type: Invalid params!")
+	assert(not types[name], "gunslinger.register_type:"
+			.. " Attempt to register a type with an existing name!")
+
+	types[name] = def
+end
+
+function gunslinger.register_gun(name, def)
+	assert(type(name) == "string" and type(def) == "table",
+			   "gunslinger.register_type: Invalid params!")
+	assert(not guns[name], "gunslinger.register_gun:"
+			.. " Attempt to register a gun with an existing name!")
+	assert(types[def.type], "gunslinger.register_gun: Attempt to"
+			.. " register gun of non-existent type (" .. def.type .. ")!")
+
+	def.itemdef.on_use = on_lclick
+	def.itemdef.on_secondary_use = on_rclick
+	def.itemdef.on_place = function(stack, player, pointed)
+		if pointed.type == "node" then
+			local node = minetest.get_node_or_nil(pointed.under)
+			local nodedef = minetest.registered_items[node.name]
+			return nodedef.on_rightclick or on_rclick(stack, player)
+		elseif pointed.type == "object" then
+			local entity = pointed.ref:get_luaentity()
+		end
+	end
+
+	def.style_of_fire = def.style_of_fire or def.type.style_of_fire
+
+	def.wear = math.ceil(65534 / def.clip_size)
+	guns[name] = def
+	minetest.register_tool(name, def.itemdef)
+end

init.lua

@@ -0,0 +1,11 @@
+local modpath = minetest.get_modpath("gunslinger") .. "/"
+
+-- Import API
+dofile(modpath .. "api.lua")
+
+if not minetest.settings:get_bool("gunslinger.disable_builtin") then
+	dofile(modpath .. "assault_rifle.lua")
+	dofile(modpath .. "shotgun.lua")
+	dofile(modpath .. "sniper_rifle.lua")
+	dofile(modpath .. "handgun.lua")
+end