Payday2 Lua

-- Infinite interact distance (except on cameras, shaped charges, body bags, burn money & place camera [Firestarters job], or trip mines)
function BaseInteractionExt:interact_distance()
    if self.tweak_data == "access_camera"
        or self.tweak_data == "shaped_sharge"
        or tostring(self._unit:name()) == "Idstring(@ID14f05c3d9ebb44b6@)"
        or self.tweak_data == "burning_money"
        or self.tweak_data == "stn_int_place_camera"
        or self.tweak_data == "trip_mine" then
        return self._tweak_data.interact_distance or tweak_data.interaction.INTERACT_DISTANCE
    end
    return 20000 -- default is 200
end

-- Infinite equipment
function PlayerManager:remove_equipment_possession( peer_id, equipment ) end

--Force no escape
function unlock_asset( asset_id )
    local asset = managers.assets:_get_asset_by_id( asset_id )
    if asset then
        if Network:is_server() and not managers.assets:get_asset_triggered_by_id( asset_id ) then
            managers.assets:server_unlock_asset( asset_id )
        elseif not managers.assets:get_asset_unlocked_by_id( asset_id ) then
            managers.network:session():send_to_host( "server_unlock_asset", asset_id )
        end
        asset.show = true
    else
        table.insert( managers.assets._global.assets, { id=asset_id, unlocked=true, show=true, can_unlock=false } )
    end
    managers.assets:init_finalize()
    managers.menu_component:create_asset_mission_briefing_gui()
end
unlock_asset("safe_escape")

-- Demi-God Mode
if not _upgradeValue then _upgradeValue = PlayerManager.upgrade_value end
function PlayerManager:upgrade_value( category, upgrade, default )
	if category == "player" and upgrade == "health_multiplier" then
		return 2
	elseif category == "player" and upgrade == "armor_multiplier" then
		return 2
	elseif category == "player" and upgrade == "passive_damage_multiplier" then
		return 2
	else
		return _upgradeValue(self, category, upgrade, default)
	end
end
managers.player:player_unit():character_damage():replenish()

-- Weapon spread
NewRaycastWeaponBase._get_spread = function(self) return 0 end

-- Instant mask on
tweak_data.player.put_on_mask_time = 0.1

-- Remove cooldown between picking up bags
function PlayerManager:carry_blocked_by_cooldown() return false end

-- No cash penalty for killing civillians
function MoneyManager.get_civilian_deduction() return 0 end
function MoneyManager.civilian_killed() return end

-- Super jump (when running, you jump 1.5x high)
function PlayerStandard:_perform_jump(jump_vec)
	local v = math.UP * 700
	if self._running then
		v = math.UP * 4000 * 1.5
	end
	self._unit:mover():set_velocity( v )
end

-- Sentry God Mode
function SentryGunDamage:damage_bullet( attack_data ) end
function SentryGunWeapon:fire( blanks, expend_ammo )
   local fire_obj = self._effect_align[ self._interleaving_fire ]
   local from_pos = fire_obj:position()
   local direction = fire_obj:rotation():y()
   mvector3.spread( direction, tweak_data.weapon[ self._name_id ].SPREAD * self._spread_mul )
   World:effect_manager():spawn( self._muzzle_effect_table[ self._interleaving_fire ] ) -- , normal = col_ray.normal } )
   if self._use_shell_ejection_effect then
      World:effect_manager():spawn( self._shell_ejection_effect_table )
   end
   local ray_res = self:_fire_raycast( from_pos, direction, blanks )
   if self._alert_events and ray_res.rays then
      RaycastWeaponBase._check_alert( self, ray_res.rays, from_pos, direction, self._unit )
   end
   return ray_res
end

-- No Weapon Recoil
NewRaycastWeaponBase.recoil_multiplier = function(self) return 0 end

-- Unlimited messiah charges (self-revive)
function PlayerDamage:consume_messiah_charge() return true
end
function PlayerDamage:got_messiah_charges() return true
end

-- Carry mods (throwing distance, movement speed, jumping, running)
local car_arr = { 'being', 'mega_heavy', 'heavy', 'medium', 'light', 'coke_light' }
for i, name in ipairs(car_arr) do
	tweak_data.carry.types[ name ].can_run = true
                   tweak_data.carry.types[ name ].jump_modifier = 10
end

-- Allow more enemies to be converted (after they are intimidated)
function PlayerManager:chk_minion_limit_reached() return false end

-- Player mode
PlayerStandard._get_walk_headbob = function(self) return 0 end
PlayerStandard._can_stand = function(self) return true end
PlayerManager.remove_equipment = function(self, equipment_id) end
PlayerManager.selected_equipment_deploy_timer = function(self) return 0.1 end
PlayerManager.chk_minion_limit_reached = function(self) return false end
PlayerManager.spread_multiplier = function(self) return 0 end
PlayerManager.spread_multiplier = function(self) return 0 end
PlayerMovement.is_stamina_drained = function(self) return false end
PlayerStandard._can_run_directional = function(self) return true end
BaseInteractionExt._get_timer = function(self) return 0.7 end
BaseInteractionExt.can_interact = function(self, player) return true end
function BaseInteractionExt:_has_required_upgrade() return true end
function BaseInteractionExt:_has_required_deployable() return true end
function BaseInteractionExt:can_interact(player) return true end
function PlayerManager:has_category_upgrade( category, upgrade)
    if category == "player" and (upgrade == "civ_harmless_melee" or upgrade == "civ_harmless_bullets") then return false end
    return true -- Other upgrades (eg. Joker)
end

--Interact
BaseInteractionExt._has_required_upgrade = function(self) return true end
BaseInteractionExt._has_required_deployable = function(self) return true end
BaseInteractionExt.can_interact = function(self, player) return true end

-- Unlimited [500 actually, but who cares] & instant intimidations
if not _upgradeValueIntimidate then _upgradeValueIntimidate = PlayerManager.upgrade_value end
function PlayerManager:upgrade_value( category, upgrade, default )
    if category == "player" and upgrade == "convert_enemies" then
        return true
    elseif category == "player" and upgrade == "convert_enemies_max_minions" then
        return 500
    elseif category == "player" and upgrade == "convert_enemies_health_multiplier" then
        return 0.25
    elseif category == "player" and upgrade == "convert_enemies_damage_multiplier" then
        return 4.5
    else
        return _upgradeValueIntimidate(self, category, upgrade, default)
    end
end
if not _onIntimidated then _onIntimidated = CopLogicIdle.on_intimidated end
function CopLogicIdle.on_intimidated( data, amount, aggressor_unit )
    CopLogicIdle._surrender( data, amount )
    return true
end
CopLogicAttack.on_intimidated = CopLogicIdle.on_intimidated
CopLogicArrest.on_intimidated = CopLogicIdle.on_intimidated
CopLogicSniper.on_intimidated = CopLogicIdle.on_intimidated

-- Setup logic for shields to be able to be intimidated
CopBrain._logic_variants.shield.intimidated = CopLogicIntimidated
if not _onIIntimidated then _onIIntimidated = CopLogicIntimidated.on_intimidated end
function CopLogicIntimidated.on_intimidated( data, amount, aggressor_unit )
    -- If shield we skip animations, go straight to conversion & spawn a new shield since it was destroyed during intimidation
    if data.unit:base()._tweak_table == "shield" then
        CopLogicIntimidated._do_tied( data, aggressor_unit )
        CopInventory._chk_spawn_shield( data.unit:inventory(), nil )
    else
        _onIIntimidated(data, amount, aggressor_unit)
    end
end

-- Setup a proper sniper-rifle for snipers (100% accuracy, no spread)
CopBrain._logic_variants.sniper = clone( CopBrain._logic_variants.security )
CopBrain._logic_variants.sniper.attack = CopLogicSniper
if not _onSniperEnter then _onSniperEnter = CopLogicSniper.enter end
function CopLogicSniper.enter( data, new_logic_name, enter_params )
    if data.unit:brain()._logic_data and data.unit:brain()._logic_data.objective and data.unit:brain()._logic_data.objective.type == "follow" then
        data.char_tweak.weapon[ data.unit:inventory():equipped_unit():base():weapon_tweak_data().usage ] = tweak_data.character.presets.weapon.sniper.m4
        data.char_tweak.weapon[ data.unit:inventory():equipped_unit():base():weapon_tweak_data().usage ].spread = 0
        -- Get dat 100% accuracy
        for distance=1, 3 do
            for interpolate=1,2 do
                data.char_tweak.weapon[ data.unit:inventory():equipped_unit():base():weapon_tweak_data().usage ].FALLOFF[distance].acc[interpolate] = 1
            end
        end
    end
    _onSniperEnter(data, new_logic_name, enter_params)
end

-- No fall damage (useless if you have god mode on)
function PlayerDamage:damage_fall( data ) end

-- Infinite stamina
function PlayerMovement:_change_stamina( value ) end
function PlayerMovement:is_stamina_drained() return false end
function PlayerStandard:_can_run_directional() return true end

-- debug menu
if managers.menu then
        managers.menu:set_debug_menu_enabled(true)
end

-- Allow restart on pro jobs
if not _oldIsProfessional then _oldIsProfessional = JobManager.is_current_job_professional end
if not _newIsProfessional then _newIsProfessional = function(self) return false end end
if not _lobbyStateEnter then _lobbyStateEnter = IngameLobbyMenuState.at_enter end
function IngameLobbyMenuState:at_enter()
	JobManager.is_current_job_professional = _newIsProfessional
	_lobbyStateEnter(self)
	JobManager.is_current_job_professional = _oldIsProfessional
end
if not _lobbyContinue then _lobbyContinue = GameOverState.continue end
function GameOverState:continue()
	JobManager.is_current_job_professional = _newIsProfessional
	_lobbyContinue(self)
	JobManager.is_current_job_professional = _oldIsProfessional
end
if not _lobbyShutDownNetwork then _lobbyShutDownNetwork = GameOverState._shut_down_network end
function GameOverState:_shut_down_network( ... )
	JobManager.is_current_job_professional = _newIsProfessional
	_lobbyShutDownNetwork(self, ...)
	JobManager.is_current_job_professional = _oldIsProfessional
end
if not _lobbyLoadStartMenu then _lobbyLoadStartMenu = GameOverState._load_start_menu end
function GameOverState:_load_start_menu( ... )
	JobManager.is_current_job_professional = _newIsProfessional
	_lobbyLoadStartMenu(self, ...)
	JobManager.is_current_job_professional = _oldIsProfessional
end
if not _lobbySetBtnText then _lobbySetBtnText = GameOverState._set_continue_button_text end
function GameOverState:_set_continue_button_text()
	JobManager.is_current_job_professional = _newIsProfessional
	_lobbySetBtnText(self)
	JobManager.is_current_job_professional = _oldIsProfessional
end
function MenuCallbackHandler:singleplayer_restart() return true end

-- Fast Drilling
function TimerGui:_set_jamming_values() return end
function TimerGui:start( timer )
        timer = 0.1
        if self._jammed then
                self:_set_jammed( false )
                return
        end

        if not self._powered then
                self:_set_powered( true )
                return
        end

        if self._started then
                return
        end

        self:_start( timer )
        if managers.network:session() then
                managers.network:session():send_to_peers_synched( "start_timer_gui", self._unit, timer )
        end
end

-- Allow infinite pagers
function GroupAIStateBase:on_successful_alarm_pager_bluff() end

-- No flashbangs
function CoreEnvironmentControllerManager:set_flashbang( flashbang_pos, line_of_sight, travel_dis, linear_dis ) end

-- Don't taze me bro
function PlayerTased:enter( state_data, enter_data )
	PlayerTased.super.enter( self, state_data, enter_data )
	self._next_shock = Application:time() + 10
	self._taser_value = 1
	self._recover_delayed_clbk = "PlayerTased_recover_delayed_clbk"
	managers.enemy:add_delayed_clbk( self._recover_delayed_clbk, callback( self, self, "clbk_exit_to_std" ), Application:time() )
end

-- No hit disorientation
Interception.Backup(CoreEnvironmentControllerManager, "hit_feedback_front")
Interception.Backup(CoreEnvironmentControllerManager, "hit_feedback_back")
Interception.Backup(CoreEnvironmentControllerManager, "hit_feedback_right")
Interception.Backup(CoreEnvironmentControllerManager, "hit_feedback_left")
Interception.Backup(CoreEnvironmentControllerManager, "hit_feedback_up")
Interception.Backup(CoreEnvironmentControllerManager, "hit_feedback_down")
function CoreEnvironmentControllerManager:hit_feedback_front() end
function CoreEnvironmentControllerManager:hit_feedback_back() end
function CoreEnvironmentControllerManager:hit_feedback_right() end
function CoreEnvironmentControllerManager:hit_feedback_left() end
function CoreEnvironmentControllerManager:hit_feedback_up() end
function CoreEnvironmentControllerManager:hit_feedback_down() end

-- Infinite reload
if not _onReload then _onReload = RaycastWeaponBase.on_reload end
function RaycastWeaponBase:on_reload()
    if managers.player:player_unit() == self._setup.user_unit then
        self.set_ammo(self, 1.0)
    else
        _onReload(self)
    end
end

if not _fireWep then _fireWep = NewRaycastWeaponBase.fire end
function NewRaycastWeaponBase:fire( from_pos, direction, dmg_mul, shoot_player, spread_mul, autohit_mul, suppr_mul, target_unit )
    local result = _fireWep( self, from_pos, direction, dmg_mul, shoot_player, spread_mul, autohit_mul, suppr_mul, target_unit )

    if managers.player:player_unit() == self._setup.user_unit and self:get_ammo_total() == 0 then
        self.set_ammo(self, 1.0)
    end

    return result
end

-- Interact through walls
function ObjectInteractionManager:interact( player )
	if( alive( self._active_object ) ) then
		local interacted,timer = self._active_object:interaction():interact_start( player )
		if timer then
			self._active_object_locked_data = true
		end
		return interacted or interacted == nil or false, timer, self._active_object
	end
	return false
end
local mvec1 = Vector3()
function ObjectInteractionManager:_update_targeted( player_pos, player_unit )
	local mvec3_dis = mvector3.distance
	--clean out far away objects
	if( #self._close_objects > 0 ) then
		for k, v in pairs( self._close_objects ) do
			if( alive( v ) and v:interaction():active() ) then
				if mvec3_dis( player_pos, v:interaction():interact_position() ) > v:interaction():interact_distance() then
					table.remove( self._close_objects, k )
				end
			else
				table.remove( self._close_objects, k )
			end
		end
	end

	--check for new objects
	for i = 1, self._close_freq, 1 do
		if( self._close_index >= self._interactive_count ) then
			self._close_index = 1
		else
			self._close_index = self._close_index + 1
		end

		local obj = self._interactive_objects[ self._close_index ]
		if( alive(obj) and obj:interaction():active() and not self:_in_close_list( obj ) ) then
			if( mvec3_dis(player_pos, obj:interaction():interact_position()) <= obj:interaction():interact_distance()  ) then
				table.insert( self._close_objects, obj )
			end
		end
	end

	-- local locked = self._active_object_locked_data and alive( self._active_object )
	local locked = false
	if self._active_object_locked_data then
		if not alive( self._active_object ) or not self._active_object:interaction():active() then
			self._active_object_locked_data = nil
		else
			-- print( "dist", mvec3_dis(player_pos, self._active_object:interaction():interact_position()) )
			-- locked = ( mvec3_dis(player_pos, self._active_object:interaction():interact_position()) - self._active_object_locked_data.distance ) < 20
			locked = ( mvec3_dis(player_pos, self._active_object:interaction():interact_position()) <= self._active_object:interaction():interact_distance() )
		end
	end

	if locked then
		return
	end

	local last_active = self._active_object
	local blocked = player_unit:movement():object_interaction_blocked()
	if( #self._close_objects > 0 ) and not blocked then
		--find the one the player is looking at
		local active_obj = nil
		local current_dot = 0.9

		local player_fwd = player_unit:camera():forward()
		local camera_pos = player_unit:camera():position()
		for k, v in pairs( self._close_objects ) do
			if( alive( v ) ) then
				mvector3.set( mvec1, v:interaction():interact_position() )
				mvector3.subtract( mvec1, camera_pos )
				mvector3.normalize( mvec1 )
				local dot = mvector3.dot( player_fwd, mvec1 )
				if( dot > current_dot ) then
					local interact_axis = v:interaction():interact_axis()
					-- Check if we only are allowed to access it from one side
					if not interact_axis or mvector3.dot( mvec1, interact_axis ) < 0.0 then
						current_dot = dot
						active_obj = v
					end
				end
			end
		end

		if( active_obj and self._active_object ~= active_obj ) then
			if alive( self._active_object ) then
				self._active_object:interaction():unselect()
			end
			if not active_obj:interaction():selected( player_unit ) then
				active_obj = nil
			end
		end
		self._active_object = active_obj
	else
		self._active_object = nil
	end

	--unselect the last one
	if( alive( last_active ) ) then
		if( not self._active_object ) then
			self._active_object = nil
			last_active:interaction():unselect()
		end
	end
end