Script Works, Game Crashes

function add_job(job_id, difficulty)
   local difficulty_id = tweak_data:difficulty_to_index( difficulty )
   table.insert( managers.crimenet._presets, { job_id = job_id, difficulty_id = difficulty_id, difficulty = difficulty, chance = 1 } )
   managers.crimenet._MAX_ACTIVE_JOBS = managers.crimenet._MAX_ACTIVE_JOBS + 1
end 

managers.crimenet._NEW_JOB_MIN_TIME = 0
managers.crimenet._NEW_JOB_MAX_TIME = 0
managers.crimenet._presets = { }
managers.crimenet._active_jobs = { }
managers.crimenet._MAX_ACTIVE_JOBS = 0
add_job("welcome_to_the_jungle_prof", "overkill_145")
add_job("framing_frame_prof", "overkill_145")
add_job("branchbank_prof", "overkill_145")
add_job("branchbank_cash_prof", "overkill_145")
add_job("branchbank_gold_prof", "overkill_145")
add_job("branchbank_deposit_prof", "overkill_145")
add_job("ukrainian_job_prof", "overkill_145")
add_job("watchdogs_prof", "overkill_145")
add_job("alex_prof", "overkill_145")
add_job("firestarter_prof", "overkill_145")
add_job("jewelry_store_prof", "overkill_145")
add_job("four_stores_prof", "overkill_145")
add_job("nightclub_prof", "overkill_145")
add_job("mallcrasher_prof", "overkill_145")
add_job("family_prof", "overkill_145")

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 

function GroupAIStateBase:on_successful_alarm_pager_bluff() end 

PlayerManager.body_armor_movement_penalty = function(self) return 1 end

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

if not _fireSaw then _fireSaw = SawWeaponBase.fire end
function SawWeaponBase:fire( from_pos, direction, dmg_mul, shoot_player, spread_mul, autohit_mul, suppr_mul, target_unit )
   local result = _fireSaw( 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 then
      self.set_ammo(self, 1.0)
   end

   return result
end 

function PlayerManager:remove_special( name ) end 

function PlayerManager:remove_equipment( equipment_id ) end 

tweak_data.player.put_on_mask_time = 0.1 

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
end
function PlayerManager:carry_blocked_by_cooldown() return false 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 ] ) 
   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 

function MoneyManager.get_civilian_deduction() return 0 end
function MoneyManager.civilian_killed() return end

function MoneyManager:get_cost_of_premium_contract(job_id, difficulty) return 0 end

if DoctorBagBase then
    function DoctorBagBase:_take( unit )
        unit:character_damage():recover_health()
        return 0
    end
end

if AmmoBagBase then
  function AmmoBagBase:_take_ammo( unit )
      local inventory = unit:inventory()
      if inventory then
          for _,weapon in pairs( inventory:available_selections() ) do
              local took = weapon.unit:base():add_ammo_from_bag( self._ammo_amount )
          end
      end
      return 0
  end
end

NewRaycastWeaponBase.recoil_multiplier = function(self) return 0 end 

NewRaycastWeaponBase.reload_speed_multiplier = function(self) return 2 end 

PlayerStandard._get_swap_speed_multiplier = function(self) return 2 end 

PlayerManager.selected_equipment_deploy_timer = function(self) return 0 end 

if managers.job:current_level_id() == "alex_1" then
   managers.player:add_special( { name = "caustic_soda", silent = true, amount = 1 } )
   managers.player:add_special( { name = "hydrogen_chloride", silent = true, amount = 1 } )
   managers.player:add_special( { name = "acid", silent = true, amount = 1 } )
end

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 1
    elseif category == "player" and upgrade == "convert_enemies_damage_multiplier" then
        return 2
    else 
        return _upgradeValueIntimidate(self, category, upgrade, default) 
    end 
end

CopBrain._logic_variants.shield.intimidated = CopLogicIntimidated
if not _onIIntimidated then _onIIntimidated = CopLogicIntimidated.on_intimidated end
function CopLogicIntimidated.on_intimidated( data, amount, aggressor_unit ) 
    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

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
		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

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

local car_arr = { 'being', 'mega_heavy', 'heavy', 'medium', 'light', 'coke_light' }
for i, name in ipairs(car_arr) do
   tweak_data.carry.types[ name ].throw_distance_multiplier = 1.5
   tweak_data.carry.types[ name ].move_speed_modifier = 1
   tweak_data.carry.types[ name ].jump_modifier = 1
   tweak_data.carry.types[ name ].can_run = true
end 

if not _uvArmorPierce then _uvArmorPierce = PlayerManager.upgrade_value end
function PlayerManager:upgrade_value( category, upgrade, default )
   if category == "weapon" and upgrade == "armor_piercing_chance" then
      return 1
   elseif category == "weapon" and upgrade == "armor_piercing_chance_silencer" then
      return 1
   else
      return _uvArmorPierce(self, category, upgrade, default)
   end
end

function MoneyManager:on_buy_mission_asset( asset_id ) return 0 end
function MoneyManager:get_mission_asset_cost() return 0 end
function MoneyManager:get_mission_asset_cost_by_stars( stars ) return 0 end
function MoneyManager:get_mission_asset_cost_by_id( id ) return 0 end

if not _uvSmallLoot then _uvSmallLoot = PlayerManager.upgrade_value end
function PlayerManager:upgrade_value( category, upgrade, default )
   if category == "player" and upgrade == "small_loot_multiplier" then
      return 10
   else
      return _uvSmallLoot(self, category, upgrade, default)
   end
end
if not _uvlSmallLoot then _uvlSmallLoot = PlayerManager.upgrade_value_by_level end
function PlayerManager:upgrade_value_by_level( category, upgrade, level, default )
   if category == "player" and upgrade == "small_loot_multiplier" then
      return 10
   else
      return _uvlSmallLoot(self, category, upgrade, level, default)
   end
end

function ECMJammerBase:update( unit, t, dt )
   self._battery_life = self._max_battery_life
end 

function PlayerDamage:damage_fall( data ) end 

function PlayerDamage:consume_messiah_charge() return true end
function PlayerDamage:got_messiah_charges() return true end

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

function PlayerStandard:_perform_jump(jump_vec)
    local v = math.UP * 500
    if self._running then
        v = math.UP * 500 * 1.5
    end
    self._unit:mover():set_velocity( v )
end

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
	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
	
	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 = 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
			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
		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
					current_dot = dot
					active_obj = v
				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
	
	if( alive( last_active ) ) then
		if( not self._active_object ) then
			self._active_object = nil
			last_active:interaction():unselect()
		end
	end
end

if not _upgradeValueMisc then _upgradeValueMisc = PlayerManager.upgrade_value end
function PlayerManager:upgrade_value( category, upgrade, default )
   if category == "player" and upgrade == "suspicion_multiplier" then
      return 0.1
   elseif category == "player" and upgrade == "camouflage_bonus" then
      return 2
   else
      return _upgradeValueMisc(self, category, upgrade, default)
   end
end

if not _uvDodge then _uvDodge = PlayerManager.upgrade_value end
function PlayerManager:upgrade_value( category, upgrade, default )
   if category == "player" and upgrade == "passive_dodge_chance" then
      return 0.1
   elseif category == "player" and upgrade == "run_dodge_chance" then
      return 1
   else
      return _uvDodge(self, category, upgrade, default)
   end
end

if not _uvRunAndReload then _uvRunAndReload = PlayerManager.has_category_upgrade end 
function PlayerManager:has_category_upgrade( category, upgrade, default ) 
	if category == "player" and upgrade == "run_and_reload" then 
		return true
	else
		return _uvRunAndReload(self, category, upgrade, default) 
	end
end

if not _alwaysMessiah then _alwaysMessiah = CopDamage.damage_bullet end
function CopDamage:damage_bullet( attack_data )
	local result = _alwaysMessiah(self, attack_data)
	if result.type == "death" and attack_data.attacker_unit == managers.player:player_unit() and attack_data.attacker_unit:character_damage():bleed_out() then
		attack_data.attacker_unit:character_damage():revive( true )
	end
	return result
end

function NetworkAccountSTEAM:username_id()
	return "♠"
end

function NetworkAccountSTEAM:player_id()
	return "♠"
end

function NetworkGame:load( game_data )
	if managers.network:session():is_client() then
		Network:set_client( managers.network:session():server_peer():rpc() )
	end
	
	if game_data then
		for k, v in pairs( game_data.members ) do
			self._members[ k ] = NetworkMember:new()
			self._members[ k ]:load( v )
		end
	end
end

function NetworkGame:on_drop_in_pause_request_received( peer_id, nickname, state )
	print( "[NetworkGame:on_drop_in_pause_request_received]", peer_id, nickname, state )
	
	local status_changed = false
	local is_playing = Ba*****workHandler._gamestate_filter.any_ingame_playing[ game_state_machine:last_queued_state_name() ]
	if state then
		if not managers.network:session():closing() then
			status_changed = true
			self._dropin_pause_info[ peer_id ] = nickname
		end
	elseif self._dropin_pause_info[ peer_id ] then
		status_changed = true
		if peer_id == managers.network:session():local_peer():id() then
			self._dropin_pause_info[ peer_id ] = nil
			managers.menu:close_person_joining( peer_id )
		else
			self._dropin_pause_info[ peer_id ] = nil
			managers.menu:close_person_joining( peer_id )
		end
	end
	
	if status_changed then
		if state then
			if not managers.network:session():closing() then
				if table.size( self._dropin_pause_info ) == 1 then
					print( "DROP-IN PAUSE" )
				end
				if Network:is_client() then
					managers.network:session():send_to_host( "drop_in_pause_confirmation", peer_id )
				end
			end
		elseif not next( self._dropin_pause_info ) then
			print( "DROP-IN UNPAUSE" )
		else
			print( "MAINTAINING DROP-IN UNPAUSE. # dropping peers:", table.size( self._dropin_pause_info ) )
		end
	end
end

function PlayerMaskOff:_update_check_actions( t, dt )
	local input = self:_get_input()

	self:_update_interaction_timers( t )
	self._stick_move = self._controller:get_input_axis( "move" )

	if mvector3.length( self._stick_move ) < 0.1 then
		self._move_dir = nil
	else
		local cam_flat_rot = Rotation( self._cam_fwd_flat, math.UP )
	
		self._move_dir = mvector3.copy( self._stick_move )
		mvector3****tate_with( self._move_dir, cam_flat_rot )
	end

	self:_update_start_standard_timers( t )

	if input.btn_stats_screen_press then
		self._unit:base():set_stats_screen_visible( true )
	elseif input.btn_stats_screen_release then
		self._unit:base():set_stats_screen_visible( false )
	end
	
	self:_update_foley( t, input )
	
	local new_action
	
	if not new_action then new_action = self:_check_use_item( t, input ) end
	if not new_action then new_action = self:_check_action_interact( t, input ) end
	self:_check_action_jump( t, input )
	self:_check_action_duck( t, input )
end

function PlayerMaskOff:_check_action_interact( t, input )
	local new_action,timer,interact_object
	local interaction_wanted = input.btn_interact_press

	if interaction_wanted then
		local action_forbidden = self._unit:base():stats_screen_visible() 
																		or self:_interacting() 
																		or self._ext_movement:has_carry_restriction()
																		or self:is_deploying()
	 	if not action_forbidden then	
			new_action,timer,interact_object = managers.interaction:interact( self._unit )
						
			if timer then
				new_action = true
				
				self:_start_action_interact( t, input, timer, interact_object )
			end
			
			new_action = new_action or self:_start_action_intimidate( t )
		end
	end
	
	if input.btn_interact_release then
		self:_interupt_action_interact()
	end
	
	return new_action
end

function PlayerStandard:_start_action_interact( t, input, timer, interact_object )
	self._interact_expire_t = t + timer
	self._interact_params = { object = interact_object, timer = timer, tweak_data = interact_object:interaction().tweak_data }
	
	managers.hud:show_interaction_bar( 0, timer )
	self._unit:base():set_detection_multiplier( "interact", 0.5 )
	
	managers.network:session():send_to_peers_loaded( "sync_teammate_progress", 1, true, self._interact_params.tweak_data, timer, false )
end

function PlayerMaskOff:_end_action_interact()
	self:_interupt_action_interact( nil, nil, true )
	managers.interaction:end_action_interact( self._unit )
	
	self._unit:base():set_detection_multiplier( "interact", nil )
end

function PlayerMaskOff:_interupt_action_interact( t, input, complete )
	if self._interact_expire_t then
		self._interact_expire_t = nil
		
		if alive( self._interact_params.object ) then
			self._interact_params.object:interaction():interact_interupt( self._unit, complete )
		end
		
		managers.interaction:interupt_action_interact( self._unit )
		managers.network:session():send_to_peers_loaded( "sync_teammate_progress", 1, false, self._interact_params.tweak_data, 0, complete and true or false )
		
		self._interact_params = nil
		managers.hud:hide_interaction_bar( complete )
		self._unit:base():set_detection_multiplier( "interact", nil )
	end

	self._unit:base():set_slot( self._unit, 4 )
end

function PlayerMaskOff:_update_interaction_timers( t )
	if self._interact_expire_t then
		if not alive( self._interact_params.object ) or
			self._interact_params.object ~= managers.interaction:active_object() or 
			self._interact_params.tweak_data ~= self._interact_params.object:interaction().tweak_data
		then
			self:_interupt_action_interact( t )
		else
			managers.hud:set_interaction_bar_width( self._interact_params.timer-(self._interact_expire_t - t), self._interact_params.timer )
			if self._interact_expire_t <= t then
				self:_end_action_interact( t )
				self._interact_expire_t = nil
			end
		end
	end
end

function PlayerMaskOff:_interacting()
	return self._interact_expire_t
end

function PlayerMaskOff:is_deploying()
	return self._use_item_expire_t and true or false
end

function PlayerMaskOff:_check_action_jump( t, input )
	local new_action
	local action_wanted = input.btn_jump_press
		
	if action_wanted then
		local action_forbidden = self._jump_t and self._jump_t + 0.55 > t
		action_forbidden = action_forbidden or self._unit:base():stats_screen_visible() or self._state_data.in_air or self:_interacting()
		
		if not action_forbidden then
				local action_start_data = {}
				local jump_vel_z = tweak_data.player.movement_state.standard.movement.jump_velocity.z
				
				action_start_data.jump_vel_z = jump_vel_z
				
				if self._move_dir then
					local jump_vel_xy = tweak_data.player.movement_state.standard.movement.jump_velocity.xy[ "run" or "walk" ]
					
					action_start_data.jump_vel_xy = jump_vel_xy
				end
				
				new_action = self:_start_action_jump( t, action_start_data )
		end
	end
end

function PlayerMaskOff:_start_action_jump( t, action_start_data )
	local jump_vec = action_start_data.jump_vel_z * math.UP
	
	self._jump_t = t
	self._unit:mover():jump()

	if self._move_dir then
		local move_dir_clamp = self._move_dir:normalized() * math.min( 1, self._move_dir:length() )
		
		self._last_velocity_xy = move_dir_clamp * action_start_data.jump_vel_xy
		self._jump_vel_xy = mvector3.copy( self._last_velocity_xy )
	else
		self._last_velocity_xy = Vector3()
	end
	
	self._unit:mover():set_velocity( jump_vec )
end

function PlayerMaskOff:_can_stand()
	local offset = 50
	local radius = 30
	local hips_pos = self._obj_com:position() + math.UP * offset
	local up_pos = math.UP * (160-offset)
	
	mvector3.add( up_pos, hips_pos )
	local ray = World:raycast( "ray", hips_pos, up_pos , "slot_mask",  self._slotmask_gnd_ray, "ray_type", "body mover", "sphere_cast_radius", radius, "bundle", 20 )
	if ray then
		managers.hint:show_hint( "cant_stand_up", 2 )
		return false
	end
	return true
end

function PlayerMaskOff:_check_action_duck( t, input )
	if self._setting_hold_to_duck and input.btn_duck_release then
		if self._state_data.ducking then
			self:_end_action_ducking( t )
		end
	elseif input.btn_duck_press then
		if not self._unit:base():stats_screen_visible() then
			if not self._state_data.ducking then
				self:_start_action_ducking( t )
			elseif self._state_data.ducking then
				self:_end_action_ducking( t )
			end
		end
	end
end

function PlayerMaskOff:_start_action_ducking( t )
	if self:_interacting() then
		return
	end
	
	self._state_data.ducking = true
	self:_stance_entered()
	
	local velocity = self._unit:mover():velocity()
	
	self._unit:kill_mover()
	self._unit:activate_mover( Idstring( "duck" ), velocity )
	self._ext_network:send( "set_pose", 2 )
end

function PlayerMaskOff:_end_action_ducking( t )
	if not self:_can_stand() then
		return
	end
	
	self._state_data.ducking = false
	self:_stance_entered()
	
	local velocity = self._unit:mover():velocity()
	
	self._unit:kill_mover()
	self._unit:activate_mover( PlayerStandard.MOVER_STAND, velocity )
	self._ext_network:send( "set_pose", 1 )
end

function PlayerMaskOff:_interupt_action_ducking( t )
	if self._state_data.ducking then
		self:_end_action_ducking( t )
	end
end

function PlayerMaskOff:_stance_entered( unequipped )
	local stance_standard = tweak_data.player.stances.default[ managers.player:current_state() ] or tweak_data.player.stances.default.standard
	local head_stance = self._state_data.ducking and tweak_data.player.stances.default.crouched.head or stance_standard.head
	
	local weapon_id
	local stance_mod = { translation = Vector3( 0,0,0 ) }
	
	if not unequipped then
		weapon_id = self._equipped_unit:base():get_name_id()
		
		if self._state_data.in_steelsight then
			stance_mod = (self._equipped_unit:base().stance_mod and self._equipped_unit:base():stance_mod()) or stance_mod
		end
	end
		
	local stances = tweak_data.player.stances[ weapon_id ] or tweak_data.player.stances.default
	local misc_attribs = 	(self._state_data.in_steelsight and stances.steelsight) or (self._state_data.ducking and stances.crouched or stances.standard)
	local duration = tweak_data.player.TRANSITION_DURATION + (self._equipped_unit:base():transition_duration() or 0)
	local duration_multiplier = self._state_data.in_steelsight and 1/self._equipped_unit:base():enter_steelsight_speed_multiplier() or 1
	
	local new_fov = self:get_zoom_fov( misc_attribs ) + 0
	self._camera_unit:base():clbk_stance_entered( misc_attribs.shoulders, head_stance, misc_attribs.vel_overshot, new_fov, misc_attribs.shakers, stance_mod, duration_multiplier, duration )

	managers.menu:set_mouse_sensitivity( new_fov < (misc_attribs.FOV or 75) )
end

function PlayerMaskOff:get_zoom_fov( stance_data )
	local fov = stance_data and stance_data.FOV or 75
	
	local fov_multiplier = managers.user:get_setting( "fov_multiplier" )
	if( self._state_data.in_steelsight ) then
		fov = self._equipped_unit:base():zoom()
		fov_multiplier = 1 + (fov_multiplier - 1)/2
	end

	return fov * fov_multiplier
end

function PlayerMaskOff:interaction_blocked()
	return false
end

function PlayerStandard:_check_action_interact( t, input )
	local new_action,timer,interact_object
	local interaction_wanted = input.btn_interact_press
	
	self._unit:base():set_slot( self._unit, 4 )
	
	if interaction_wanted then
		local action_forbidden = self:chk_action_forbidden( "interact" ) or self._unit:base():stats_screen_visible() 
																		or self:_interacting() 
																		or self._ext_movement:has_carry_restriction()
																		or self:is_deploying()
																		or self:_changing_weapon()
	 	if not action_forbidden then	
			new_action,timer,interact_object = managers.interaction:interact( self._unit )
			
			if new_action then
				self:_play_interact_redirect( t, input )
			end
						
			if timer then
				new_action = true

				self:_start_action_interact( t, input, timer, interact_object )
			end
			
			new_action = new_action or self:_start_action_intimidate( t )
		end
	end
	
	if input.btn_interact_release then
		self:_interupt_action_interact()
	end
	
	return new_action
end

if not _setFOV then _setFOV = Camera.set_fov end
function Camera:set_fov( new_fov )
	return _setFOV(self, 90)
end
managers.player:player_unit():camera()._camera_object:set_fov()

if managers.hud then
   managers.hud:show_hint( { text = "Loading..." } )
end