--- Gun class -- this is the system used to represent guns and their attributes directly. -- @module Gun local Vec = vector local gun_default = { --itemstack = Itemstack --gun_entity = ObjRef name = "__guns4d:default__", itemstring = "", registered = {}, property_modifiers = {}, --- properties properties = { infinite_inventory_overlay = "inventory_overlay_inf_ammo.png", -- defines the filename to to be used as the overlay on the item when the player has infinite ammo. breathing_scale = .5, -- the max angluler offset caused by breathing. flash_offset = Vec.new(), -- used by fire() (for fsx and ray start pos) [RENAME NEEDED] firerateRPM = 600, -- used by update() and by extent fire() + default controls. The firerate of the gun. Rounds per minute burst = 3, -- how many rounds in burst using when firemode is at "burst" ammo_handler = Ammo_handler, hip = { offset = Vec.new(), sway_vel_mul = 5, sway_angle_mul = 1, }, ads = { --used by player_handler, animation handler (eye bone offset from horizontal_offset), gun entity (attached offset) offset = Vec.new(), horizontal_offset = 0, aim_time = 1, }, firemodes = { "single", --not limited to semi-automatic. --"burst", --"auto" }, firemode_inventory_overlays = { single = "inventory_overlay_single.png", auto = "inventory_overlay_auto.png", burst = "inventory_overlay_burst.png", safe = "inventory_overlay_safe.png" }, --[[bloom = { not yet implemented. base_aiming = 0, --amount of bloom at a full rest while aiming down sights (if possible) base_hip = 0, --amount of bloom at rest while not aiming down sights. recoil = { decay = 1, --decay rate amount = 0, ratio = 0, --ratio of x to y }, walking = { decay = 1, amount = 0, ratio = 0, } },]] recoil = { --used by update_recoil() velocity_correction_factor = { --velocity correction factor is currently very broken. gun_axial = 1, player_axial = 1, }, target_correction_factor = { --angular correction rate per second: time_since_fire*target_correction_factor gun_axial = 1, player_axial = 1, }, angular_velocity_max = { --max velocity, so your gun doesnt "spin me right round baby round round" gun_axial = 1, player_axial = 1, }, angular_velocity = { --the velocity added per shot. This is the real "recoil" part of the recoil gun_axial = {x=0, y=0}, player_axial = {x=0, y=0}, }, bias = { --dictates the distribution bias for the direction angular_velocity is in. I.e. if you want recoil to always go up you set x to 1, more often to the right? y to -.5 gun_axial = {x=1, y=0}, player_axial = {x=1, y=0}, }, target_correction_max_rate = { --the cap for target_correction_fire (i.e. this is the maximum amount it will ever correct per second.) gun_axial = 1, player_axial = 1, }, hipfire_multiplier = { --the mutliplier for recoil (angular_velocity) at hipfire (can be fractional) gun_axial = 1, player_axial = 1 }, }, sway = { --used by update_sway() max_angle = { gun_axial = 0, player_axial = 0, }, angular_velocity = { gun_axial = 0, player_axial = 0, }, hipfire_angle_multiplier = { --the mutliplier for sway max_angle at hipfire (can be fractional) gun_axial = 2, player_axial = 2 }, hipfire_velocity_multiplier = { --same as above but for velocity. gun_axial = 2, player_axial = 2 } }, walking_offset = { --used by update_walking() (or something) gun_axial = {x=1, y=-1}, player_axial = {x=1,y=1}, }, pc_control_actions = { --used by control_handler __overfill=true, --this table will not be filled in. aim = Guns4d.default_controls.aim, auto = Guns4d.default_controls.auto, reload = Guns4d.default_controls.reload, on_use = Guns4d.default_controls.on_use, firemode = Guns4d.default_controls.firemode }, touch_control_actions = { __overfill=true, aim = Guns4d.default_touch_controls.aim, auto = Guns4d.default_touch_controls.auto, reload = Guns4d.default_touch_controls.reload, on_secondary_use = Guns4d.default_touch_controls.on_secondary_use, firemode = Guns4d.default_touch_controls.firemode }, charging = { --how the gun "cocks" require_draw_on_swap = true, bolt_charge_mode = "none", --"none"-chamber is always full, "catch"-when fired to dry bolt will not need to be charged after reload, "no_catch" bolt will always need to be charged after reload. default_draw_time = 1, --sound = soundspec }, reload = { --used by defualt controls. Still provides usefulness elsewhere. __overfill=true, --{type="unload_mag", time=1, anim="unload_mag", interupt="to_ground", hold = true, sound = {sound = "load magazine", pitch = {min=.9, max=1.1}}}, --{type="load", time=1, anim="load"} }, ammo = { --used by ammo_handler magazine_only = false, accepted_bullets = {}, accepted_magazines = {}, initial_mag = "empty" }, visuals = { --mesh backface_culling = true, root = "gun", magazine = "magazine", arm_right = "right_aimpoint", arm_left = "left_aimpoint", animations = { --used by animations handler for idle, and default controls empty = {x=0,y=0}, loaded = {x=1,y=1}, }, }, sounds = { --this does not contain reload sound effects. release_bolt = { __overfill=true, sound = "ar_release_bolt", max_hear_distance = 5, pitch = { min = .95, max = 1.05 }, gain = { min = .9, max = 1 } }, fire = { { __overfill=true, sound = "ar_firing", max_hear_distance = 40, --far min_hear_distance is also this. pitch = { min = .95, max = 1.05 }, gain = { min = .9, max = 1 } }, { __overfill=true, sound = "ar_firing_far", min_hear_distance = 40, max_hear_distance = 600, pitch = { min = .95, max = 1.05 }, gain = { min = .9, max = 1 } } }, }, --[[ ammo = { accepted_magazines = {}, accepted_bullets = {}, magazine_only = false } ]] initial_vertical_rotation = -60, --inventory_image --inventory_image_empty --used by ammo_handler }, offsets = { recoil = { gun_axial = Vec.new(), player_axial = Vec.new(), --move_dynamic_crosshair = false, this would make the dynamic crosshair move instead of get larger }, sway = { gun_axial = Vec.new(), player_axial = Vec.new(), }, walking = { gun_axial = Vec.new(), player_axial = Vec.new(), tick = 0, --velocity }, breathing = { gun_axial = Vec.new(), --gun axial unimplemented... player_axial = Vec.new(), }, }, --[[spread = { recoil = vector.new(), walking = vector.new() },]] animation_rotation = vector.new(), --[[total_offset_rotation = { --can't be in offsets, as they're added automatically. gun_axial = Vec.new(), player_axial = Vec.new(), },]] --player_rotation = Vec.new(), velocities = { recoil = { gun_axial = Vec.new(), player_axial = Vec.new(), }, sway = { gun_axial = Vec.new(), player_axial = Vec.new(), }, }, --magic number BEGONE consts = { HIP_PLAYER_GUN_ROT_RATIO = .75, AIM_OUT_AIM_IN_SPEED_RATIO = 2.5, HIPFIRE_BONE = "guns3d_hipfire_bone", --these shouldn't be here at all, these need to be model determinant. AIMING_BONE = "guns3d_aiming_bone", KEYFRAME_SAMPLE_PRECISION = .1, --[[what frequency to take precalcualted keyframe samples. The lower this is the higher the memory allocation it will need- though minimal. This will fuck shit up if you change it after gun construction/inheritence (interpolation between precalculated vectors will not work right)]] WAG_CYCLE_SPEED = 1.6, DEFAULT_MAX_HEAR_DISTANCE = 10, DEFAULT_FPS = 60, WAG_DECAY = 1, --divisions per second HAS_RECOIL = true, HAS_BREATHING = true, HAS_SWAY = true, HAS_WAG = true, HAS_GUN_AXIAL_OFFSETS = true, ANIMATIONS_OFFSET_AIM = false, LOOP_IDLE_ANIM = false }, --[[animation_data = { --where animations data is stored. anim_runtime = 0, length = 0, fps = 0, frames = {0,0}, current_frame = 0, --[[animations = { } },]] bolt_charged = false, particle_spawners = {}, current_firemode = 1, walking_tick = 0, time_since_last_fire = 0, time_since_creation = 0, rechamber_time = 0, burst_queue = 0, muzzle_flash = Guns4d.effects.muzzle_flash } --I dont remember why I made this, used it though lmao function gun_default.multiplier_coefficient(multiplier, ratio) return 1+((multiplier*ratio)-ratio) end function gun_default:draw() assert(self.instance, "attempt to call object method on a class") local props = self.properties if props.visuals.animations.draw then self:set_animation(props.visuals.animations.draw, props.charging.default_draw_time) end self.ammo_handler:chamber_round() self.rechamber_time = props.charging.default_draw_time end --update gun, the main function. function gun_default:update(dt) assert(self.instance, "attempt to call object method on a class") if not self:has_entity() then self:add_entity(); self:clear_animation() end local handler = self.handler local look_rotation = handler.look_rotation --remember that this is in counterclock-wise rotation. For 4dguns we use clockwise so it makes a bit more sense for recoil. So it needs to be inverted. local total_rot = self.total_offset_rotation local player_rot = self.player_rotation local constant = Guns4d.config.vertical_rotation_factor --player look rotation. I'm going to keep it real, I don't remember what this math does. Player handler just stores the player's rotation from MT in degrees, which is for some reason inverted player_rot.y = -handler.look_rotation.y local next_vert_aim = ((player_rot.x+look_rotation.x)/(1+constant*dt))-look_rotation.x if math.abs(look_rotation.x-next_vert_aim) > .005 then player_rot.x = next_vert_aim else player_rot.x = -look_rotation.x end --timers if self.rechamber_time > 0 then self.rechamber_time = self.rechamber_time - dt else self.rechamber_time = 0 end self.time_since_creation = self.time_since_creation + dt self.time_since_last_fire = self.time_since_last_fire + dt if self.burst_queue > 0 then self:update_burstfire() end --update some vectors if self.consts.HAS_SWAY then self:update_sway(dt) end if self.consts.HAS_RECOIL then self:update_recoil(dt) end if self.consts.HAS_BREATHING then self:update_breathing(dt) end if self.consts.HAS_WAG then self:update_wag(dt) end self:update_animation(dt) self.dir = self:get_dir() self.local_dir = self:get_dir(true) self.paxial_dir = self:get_player_axial_dir() self.local_paxial_dir = self:get_player_axial_dir(true) self.pos = self:get_pos()+self.handler:get_pos() if self.properties.sprite_scope then self.sprite_scope:update() end if self.properties.crosshair then self.crosshair:update() end --automatically cock if uncocked. local ammo = self.ammo_handler.ammo --[[if ammo.total_bullets and (ammo.total_bullets > 0 and ammo.next_bullet == "empty") then self:charge() end]] --print(dump(self.ammo_handler.ammo.next_bullet)) local offsets = self.offsets --local player_axial = offsets.recoil.player_axial + offsets.walking.player_axial + offsets.sway.player_axial + offsets.breathing.player_axial --local gun_axial = offsets.recoil.gun_axial + offsets.walking.gun_axial + offsets.sway.gun_axial --apply the offsets. total_rot.player_axial.x = 0; total_rot.player_axial.y = 0 total_rot.gun_axial.x = 0; total_rot.gun_axial.y = 0 for type, _ in pairs(total_rot) do for i, offset in pairs(offsets) do if self.consts.HAS_GUN_AXIAL_OFFSETS or type~="gun_axial" then total_rot[type] = total_rot[type]+offset[type] end end end end function gun_default:update_burstfire() if self.rechamber_time <= 0 then local success = self:attempt_fire() if not success then self.burst_queue = 0 else self.burst_queue = self.burst_queue - 1 end end end function gun_default:cycle_firemodes() self.current_firemode = ((self.current_firemode)%(#self.properties.firemodes))+1 self.meta:set_int("guns4d_firemode", self.current_firemode) self:update_image_and_text_meta() self.player:set_wielded_item(self.itemstack) end --remember to set_wielded_item to self.itemstack! otherwise these changes will not apply! function gun_default:update_image_and_text_meta(meta) meta = meta or self.meta local ammo = self.ammo_handler.ammo --set the counter if ammo.total_bullets == 0 then meta:set_string("count_meta", Guns4d.config.empty_symbol) else if Guns4d.config.show_gun_inv_ammo_count then meta:set_string("count_meta", tostring(ammo.total_bullets)) else meta:set_string("count_meta", "F") end end --pick the image local image = self.properties.inventory_image if (ammo.total_bullets > 0) and not ammo.magazine_psuedo_empty then image = self.properties.inventory_image elseif self.properties.inventory_image_magless and ( (ammo.loaded_mag == "empty") or (ammo.loaded_mag == "") or ammo.magazine_psuedo_empty) then image = self.properties.inventory_image_magless elseif self.properties.inventory_image_empty then image = self.properties.inventory_image_empty end --add the firemode overlay to the image if #self.properties.firemodes > 1 and self.properties.firemode_inventory_overlays[self.properties.firemodes[self.current_firemode]] then image = image.."^"..self.properties.firemode_inventory_overlays[self.properties.firemodes[self.current_firemode]] end if self.handler.infinite_ammo then image = image.."^"..self.properties.infinite_inventory_overlay end meta:set_string("inventory_image", image) end function gun_default:attempt_fire() assert(self.instance, "attempt to call object method on a class") if self.rechamber_time <= 0 and not self.ammo_handler.ammo.magazine_psuedo_empty then local spent_bullet = self.ammo_handler:spend_round() if spent_bullet and spent_bullet ~= "empty" then local dir = self.dir local pos = self.pos if not Guns4d.ammo.registered_bullets[spent_bullet] then minetest.log("error", "unregistered bullet itemstring"..tostring(spent_bullet)..", could not fire gun (player:"..self.player:get_player_name()..")"); return false end local bullet_def = Guns4d.table.fill(Guns4d.ammo.registered_bullets[spent_bullet], { player = self.player, --we don't want it to be doing fuckshit and letting players shoot through walls. pos = pos-((self.handler.control_handler.ads and dir*self.properties.ads.offset.z) or dir*self.properties.hip.offset.z), dir = dir, gun = self }) Guns4d.bullet_ray:new(bullet_def) if self.properties.visuals.animations.fire then self:set_animation(self.properties.visuals.animations.fire, nil, false) end self:recoil() self:muzzle_flash() print(dump(self.properties.sounds.fire)) local fire_sound = Guns4d.table.deep_copy(self.properties.sounds.fire) --important that we copy because play_sounds modifies it. fire_sound.pos = self.pos Guns4d.play_sounds(fire_sound) self.rechamber_time = 60/self.properties.firerateRPM return true end end end local function rand_sign(b) b = b or .5 local int = 1 if math.random() > b then int=-1 end return int end function gun_default:recoil() assert(self.instance, "attempt to call object method on a class") local rprops = self.properties.recoil for axis, recoil in pairs(self.velocities.recoil) do for _, i in pairs({"x","y"}) do recoil[i] = recoil[i] + (rprops.angular_velocity[axis][i] *rand_sign((rprops.bias[axis][i]/2)+.5)) *self.multiplier_coefficient(rprops.hipfire_multiplier[axis], 1-self.handler.ads_location) end end self.time_since_last_fire = 0 end --all of this dir shit needs to be optimized HARD function gun_default:get_gun_axial_dir() assert(self.instance, "attempt to call object method on a class") local rotation = self.total_offset_rotation local dir = Vec.new(Vec.rotate({x=0, y=0, z=1}, {y=0, x=rotation.gun_axial.x*math.pi/180, z=0})) dir = Vec.rotate(dir, {y=rotation.gun_axial.y*math.pi/180, x=0, z=0}) return dir end function gun_default:get_player_axial_dir(rltv) assert(self.instance, "attempt to call object method on a class") local handler = self.handler local rotation = self.total_offset_rotation local dir = Vec.new(Vec.rotate({x=0, y=0, z=1}, {y=0, x=((rotation.player_axial.x)*math.pi/180), z=0})) dir = Vec.rotate(dir, {y=((rotation.player_axial.y)*math.pi/180), x=0, z=0}) if not rltv then if (self.properties.sprite_scope and handler.control_handler.ads) or (self.properties.crosshair and not handler.control_handler.ads) then --we need the head rotation in either of these cases, as that's what they're showing. dir = Vec.rotate(dir, {x=-handler.look_rotation.x*math.pi/180,y=-handler.look_rotation.y*math.pi/180,z=0}) else dir = Vec.rotate(dir, {x=self.player_rotation.x*math.pi/180,y=self.player_rotation.y*math.pi/180,z=0}) end end --[[local hud_pos = Vec.rotate(dir, {x=0,y=self.player_rotation.y*math.pi/180,z=0})+player:get_pos()+{x=0,y=player:get_properties().eye_height,z=0}+vector.rotate(player:get_eye_offset()/10, {x=0,y=self.player_rotation.y*math.pi/180,z=0}) local hud = player:hud_add({ hud_elem_type = "image_waypoint", text = "muzzle_flash2.png", world_pos = hud_pos, scale = {x=10, y=10}, alignment = {x=0,y=0}, offset = {x=0,y=0}, }) minetest.after(0, function(hud) player:hud_remove(hud) end, hud)]] return dir end function gun_default:get_dir(rltv) assert(self.instance, "attempt to call object method on a class") local rotation = self.total_offset_rotation local handler = self.handler --rotate x and then y. local dir = Vec.new(Vec.rotate({x=0, y=0, z=1}, {y=0, x=((rotation.gun_axial.x+rotation.player_axial.x)*math.pi/180), z=0})) dir = Vec.rotate(dir, {y=((rotation.gun_axial.y+rotation.player_axial.y)*math.pi/180), x=0, z=0}) if not rltv then if (self.properties.sprite_scope and handler.control_handler.ads) or (self.properties.crosshair and not handler.control_handler.ads) then --we need the head rotation in either of these cases, as that's what they're showing. dir = Vec.rotate(dir, {x=-handler.look_rotation.x*math.pi/180,y=-handler.look_rotation.y*math.pi/180,z=0}) else dir = Vec.rotate(dir, {x=self.player_rotation.x*math.pi/180,y=self.player_rotation.y*math.pi/180,z=0}) end end --local hud_pos = dir+player:get_pos()+{x=0,y=player:get_properties().eye_height,z=0}+vector.rotate(player:get_eye_offset()/10, {x=0,y=player_rotation.y*math.pi/180,z=0}) --[[local hud = player:hud_add({ hud_elem_type = "image_waypoint", text = "muzzle_flash2.png", world_pos = hud_pos, scale = {x=10, y=10}, alignment = {x=0,y=0}, offset = {x=0,y=0}, }) minetest.after(0, function(hud) player:hud_remove(hud) end, hud)]] return dir end --broken! doesn't properly reflect values. function gun_default:get_pos(added_pos, relative, debug) assert(self.instance, "attempt to call object method on a class") local player = self.player local handler = self.handler local bone_location local gun_offset local pprops = handler:get_properties() if handler.control_handler.ads then gun_offset = self.properties.ads.offset bone_location = player:get_eye_offset() or vector.zero() bone_location.y = bone_location.y + pprops.eye_height bone_location.x = handler.horizontal_offset else --minetest is really wacky. gun_offset = self.properties.hip.offset bone_location = vector.new(handler.player_model_handler.offsets.global.hipfire) bone_location.x = (bone_location.x / 10)*pprops.visual_size.x bone_location.y = (bone_location.y / 10)*pprops.visual_size.y bone_location.z = (bone_location.z / 10)*pprops.visual_size.z end if added_pos then gun_offset = gun_offset+added_pos end --dir needs to be rotated twice seperately to avoid weirdness local pos if not relative then pos = Vec.rotate(bone_location, {x=0, y=-handler.look_rotation.y*math.pi/180, z=0}) pos = pos+Vec.rotate(gun_offset, Vec.dir_to_rotation(self.paxial_dir)) else pos = Vec.rotate(gun_offset, Vec.dir_to_rotation(self.local_paxial_dir)+{x=self.player_rotation.x*math.pi/180,y=0,z=0})+bone_location end if debug then local hud_pos if relative then hud_pos = vector.rotate(pos, {x=0,y=player:get_look_horizontal(),z=0})+handler:get_pos() else hud_pos = pos+handler:get_pos() end local hud = player:hud_add({ hud_elem_type = "image_waypoint", text = "muzzle_flash2.png", world_pos = hud_pos, scale = {x=10, y=10}, alignment = {x=0,y=0}, offset = {x=0,y=0}, }) minetest.after(0, function(hud) player:hud_remove(hud) end, hud) end --world pos, position of bone, offset of gun from bone (with added_pos) return pos end function gun_default:add_entity() assert(self.instance, "attempt to call object method on a class") self.entity = minetest.add_entity(self.player:get_pos(), self.name.."_visual") local obj = self.entity:get_luaentity() obj.parent_player = self.player Guns4d.gun_by_ObjRef[self.entity] = self obj:on_step() end function gun_default:has_entity() assert(self.instance, "attempt to call object method on a class") if not self.entity then return false end if not self.entity:get_pos() then return false end return true end function gun_default:update_wag(dt) local handler = self.handler local wag = self.offsets.walking local velocity = wag.velocity local old_tick if handler.walking then velocity = self.player:get_velocity() wag.velocity = velocity end old_tick = old_tick or wag.tick if velocity then if handler.walking then wag.tick = wag.tick + (dt*Vec.length(velocity)) else wag.tick = wag.tick + (dt*4) end end local walking_offset = self.offsets.walking if velocity and (not handler.walking) and (math.ceil(old_tick/self.consts.WAG_CYCLE_SPEED)+.5 < (math.ceil(wag.tick/self.consts.WAG_CYCLE_SPEED))+.5) and (wag.tick > old_tick) then wag.velocity = nil return end for _, i in ipairs({"x","y"}) do for _, axis in ipairs({"player_axial", "gun_axial"}) do if velocity then local multiplier = 1 if i == "x" then multiplier = 2 end --if the result is negative we know that it's flipped, and thus can be ended. local inp = (wag.tick/self.consts.WAG_CYCLE_SPEED)*math.pi*multiplier --this is a mess, I think that 1.6 is the frequency of human steps or something walking_offset[axis][i] = math.sin(inp)*self.properties.walking_offset[axis][i] else local old_value = walking_offset[axis][i] if math.abs(walking_offset[axis][i]) > .005 then local multiplier = 1/self.consts.WAG_DECAY walking_offset[axis][i] = walking_offset[axis][i]-(walking_offset[axis][i]*multiplier*dt) else walking_offset[axis][i] = 0 end if math.abs(walking_offset[axis][i]) > math.abs(old_value) then walking_offset[axis][i] = 0 end end end end end function gun_default:update_recoil(dt) for axis, _ in pairs(self.offsets.recoil) do for _, i in pairs({"x","y"}) do local recoil = self.offsets.recoil[axis][i] local recoil_vel = Guns4d.math.clamp(self.velocities.recoil[axis][i],-self.properties.recoil.angular_velocity_max[axis],self.properties.recoil.angular_velocity_max[axis]) local old_recoil_vel = recoil_vel recoil = recoil + recoil_vel if math.abs(recoil_vel) > 0.01 then --look, I know this doesn't really make sense, but this is the best I can do atm. I've looked for better and mroe intuitive methods, I cannot find them. --8-(8*(1-(8/100)) --recoil_vel = recoil_vel-((recoil_vel-(recoil_vel/(1+self.properties.recoil.velocity_correction_factor[axis])))*dt*10) recoil_vel = recoil_vel * (recoil_vel/(recoil_vel/(self.properties.recoil.velocity_correction_factor[axis]*2))*dt) else recoil_vel = 0 end if math.abs(recoil_vel)>math.abs(old_recoil_vel) then recoil_vel = 0 end --ax^2+bx+c --recoil_velocity_correction_rate --recoil_correction_rate local old_recoil = recoil if math.abs(recoil) > 0.001 then local correction_multiplier = self.time_since_last_fire*self.properties.recoil.target_correction_factor[axis] local correction_value = recoil*correction_multiplier correction_value = Guns4d.math.clamp(math.abs(correction_value), 0, self.properties.recoil.target_correction_max_rate[axis]) recoil=recoil-(correction_value*dt*(math.abs(recoil)/recoil)) --prevent overcorrection if math.abs(recoil) > math.abs(old_recoil) then recoil = 0 end end self.velocities.recoil[axis][i] = recoil_vel self.offsets.recoil[axis][i] = recoil end end end function gun_default:update_animation(dt) local ent = self.entity local data = self.animation_data data.runtime = data.runtime + dt data.current_frame = Guns4d.math.clamp(data.current_frame+(dt*data.fps), data.frames.x, data.frames.y) if data.loop and (data.current_frame > data.frames.y) then data.current_frame = data.frames.x end --track rotations and applies to aim. if self.consts.ANIMATIONS_OFFSET_AIM then self:update_animation_rotation() end end --IMPORTANT!!! this does not directly modify the animation_data table anymore, it's all hooked through ObjRef:set_animation() (init.lua) so if animation is set elsewhere it doesnt break. --this may be deprecated in the future- as it is no longer really needed now that I hook ObjRef functions. function gun_default:set_animation(frames, length, fps, loop) loop = loop or false --why the fuck default is true? I DONT FUCKIN KNOW (this undoes this) assert(type(frames)=="table" and frames.x and frames.y, "frames invalid or nil in set_animation()!") assert(not (length and fps), "cannot play animation with both specified length and specified fps. Only one parameter can be used.") local num_frames = math.abs(frames.x-frames.y) if length then fps = num_frames/length elseif not fps then fps = self.consts.DEFAULT_FPS end self.entity:set_animation(frames, fps, 0, loop) --see init.lua for modified ObjRef stuff. end function gun_default:clear_animation() local loaded = false if self.properties.ammo.magazine_only then if self.ammo_handler.ammo.loaded_mag ~= "empty" then loaded = true end elseif self.ammo_handler.ammo.total_bullets > 0 then loaded = true end if loaded then self.entity:set_animation({x=self.properties.visuals.animations.loaded.x, y=self.properties.visuals.animations.loaded.y}, 0, 0, self.consts.LOOP_IDLE_ANIM) else self.entity:set_animation({x=self.properties.visuals.animations.empty.x, y=self.properties.visuals.animations.empty.y}, 0, 0, self.consts.LOOP_IDLE_ANIM) end end function gun_default:update_breathing(dt) local breathing_info = {pause=1.4, rate=4.2} --we want X to be between 0 and 4.2. Since math.pi is a positive crest, we want X to be above it before it reaches our- --"length" (aka rate-pause), thus it will pi/length or pi/(rate-pause) will represent out slope of our control. local x = (self.time_since_creation%breathing_info.rate)*math.pi/(breathing_info.rate-breathing_info.pause) local scale = self.properties.breathing_scale --now if it's above math.pi we know it's in the pause half of the cycle. For smoothness, we cut the sine off early and decay the value non-linearly. --not sure why 8/9 is a constant here... I assume it's if it's 8/9 of the way through the cycle. Not going to worry about it. if x > math.pi*(8/9) then self.offsets.breathing.player_axial.x=self.offsets.breathing.player_axial.x-(self.offsets.breathing.player_axial.x*2*dt) else self.offsets.breathing.player_axial.x = scale*(math.sin(x)) end end function gun_default:update_sway(dt) assert(self.instance, "attempt to call object method from a base class") local sprops = self.properties.sway for axis, sway in pairs(self.offsets.sway) do local sway_vel = self.velocities.sway[axis] local ran ran = Vec.apply(Vec.new(), function(i,v) if i ~= "x" then return (math.random()-.5)*2 end end) ran.z = 0 local vel_mul = self.multiplier_coefficient(sprops.hipfire_velocity_multiplier[axis], 1-self.handler.ads_location) sway_vel = Vec.normalize(sway_vel+(ran*dt))*sprops.angular_velocity[axis]*vel_mul sway=sway+(sway_vel*dt) local len_mul = self.multiplier_coefficient(sprops.hipfire_angle_multiplier[axis], 1-self.handler.ads_location) if Vec.length(sway) > sprops.max_angle[axis]*len_mul then sway=Vec.normalize(sway)*sprops.max_angle[axis]*len_mul sway_vel = Vec.new() end self.offsets.sway[axis] = sway self.velocities.sway[axis] = sway_vel end end function gun_default:update_animation_rotation() local current_frame = self.animation_data.current_frame+self.consts.KEYFRAME_SAMPLE_PRECISION local frame1 = math.floor(current_frame/self.consts.KEYFRAME_SAMPLE_PRECISION) local frame2 = math.floor(current_frame/self.consts.KEYFRAME_SAMPLE_PRECISION)+1 current_frame = current_frame/self.consts.KEYFRAME_SAMPLE_PRECISION local out if self.b3d_model.global_frames.rotation then if self.b3d_model.global_frames.rotation[frame1] then if (not self.b3d_model.global_frames.rotation[frame2]) or (current_frame==frame1) then out = vector.new(self.b3d_model.global_frames.rotation[frame1]:to_euler_angles_unpack())*180/math.pi --print("rawsent") else --to stop nan local ip_ratio = current_frame-frame1 local vec1 = self.b3d_model.global_frames.rotation[frame1] local vec2 = self.b3d_model.global_frames.rotation[frame2] out = vector.new(vec1:slerp(vec2, ip_ratio):to_euler_angles_unpack())*180/math.pi --out = vec1+((vec1-vec2)*ip_ratio) --they're euler angles... actually I wouldnt think this works, but it's good enough for my purposes. --print("interpolated") end else out = vector.copy(self.b3d_model.global_frames.rotation[1]) end --print(frame1, frame2, current_frame, dump(out)) else out = vector.new() end self.animation_rotation = out end --relative to the gun's entity. Returns left, right vectors. local out = {arm_left=vector.new(), arm_right=vector.new()} function gun_default:get_arm_aim_pos() local current_frame = self.animation_data.current_frame+1 local frame1 = (math.floor(current_frame)/self.consts.KEYFRAME_SAMPLE_PRECISION) local frame2 = (math.floor(current_frame)/self.consts.KEYFRAME_SAMPLE_PRECISION)+1 current_frame = current_frame/self.consts.KEYFRAME_SAMPLE_PRECISION for i, v in pairs(out) do if self.b3d_model.global_frames[i] then if self.b3d_model.global_frames[i][frame1] then if (not self.b3d_model.global_frames[i][frame2]) or (current_frame==frame1) then out[i] = vector.copy(self.b3d_model.global_frames[i][frame1]) else --to stop nan local ip_ratio = current_frame-frame1 local vec1 = self.b3d_model.global_frames[i][frame1] local vec2 = self.b3d_model.global_frames[i][frame2] out[i] = vec1+((vec1-vec2)*ip_ratio) end else out[i]=vector.copy(self.b3d_model.global_frames[i][1]) end else out[i] = vector.new() end end return out.arm_left, out.arm_right --return vector.copy(self.b3d_model.global_frames.arm_left[1]), vector.copy(self.b3d_model.global_frames.arm_right[1]) end function gun_default:prepare_deletion() self.released = true assert(self.instance, "attempt to call object method on a class") if self:has_entity() then self.entity:remove() end if self.sprite_scope then self.sprite_scope:prepare_deletion() end if self.crosshair then self.crosshair:prepare_deletion() end end Guns4d.gun = gun_default dofile(minetest.get_modpath("guns4d").."/classes/gun_construct.lua") gun_default.construct = function(def) if def.instance then gun_default.construct_instance(def) elseif def.name ~= "__guns4d:default__" then --print(dump(def)) gun_default.construct_base_class(def) end end Guns4d.gun = Instantiatable_class:inherit(gun_default)