void ClearLegInjury(FallDamage falldamage)
{
if (falldamage == null)
{
return;
}
falldamage.ClearInjury();
}
void cmdCurePlayer(NetUser netuser, string command, string[] args)
{
if (!permission.UserHasPermission(netuser.playerClient.userID.ToString(), "advmetabolism.allowed"))
{
SendReply(netuser, GetMessage("NoPermissionCure", netuser.userID.ToString()));
return;
}
else if (args.Length != 1)
{
var rootControllable = netuser.playerClient.rootControllable;
if (!rootControllable)
{
return;
}
var rootCharacter = rootControllable.rootCharacter;
if (!rootCharacter)
{
return;
}
Metabolism metabolism = rootControllable.GetComponent <Metabolism>();
metabolism.AddCalories(3000);
float radLevel = metabolism.GetRadLevel();
metabolism.AddAntiRad(radLevel);
FallDamage fallDamage = rootControllable.GetComponent <FallDamage>();
fallDamage.ClearInjury();
HumanBodyTakeDamage humanBodyTakeDamage = rootControllable.GetComponent <HumanBodyTakeDamage>();
humanBodyTakeDamage.SetBleedingLevel(0);
SendReply(netuser, GetMessage("CureSelf", netuser.userID.ToString()));
return;
}
else
{
NetUser targetuser = rust.FindPlayer(args[0]);
if (targetuser != null)
{
var rootControllable = netuser.playerClient.rootControllable;
if (!rootControllable)
{
return;
}
var rootCharacter = rootControllable.rootCharacter;
if (!rootCharacter)
{
return;
}
Metabolism metabolism = rootControllable.GetComponent <Metabolism>();
metabolism.AddCalories(3000);
float radLevel = metabolism.GetRadLevel();
metabolism.AddAntiRad(radLevel);
FallDamage fallDamage = rootControllable.GetComponent <FallDamage>();
fallDamage.ClearInjury();
HumanBodyTakeDamage humanBodyTakeDamage = rootControllable.GetComponent <HumanBodyTakeDamage>();
humanBodyTakeDamage.SetBleedingLevel(0);
SendReply(netuser, GetMessage("CureTargetReply", netuser.userID.ToString()) + targetuser.displayName);
SendReply(targetuser, GetMessage("CureTargetMessage", netuser.userID.ToString()) + netuser.displayName);
}
}
}
public FallDamageEvent(FallDamage fd, float speed, float num, bool flag, bool flag2)
{
_fd = fd;
_player = Fougerite.Server.Cache[fd.idMain.netUser.userID];
_fallspeed = speed;
_num = num;
_flag = flag;
_flag2 = flag2;
}
public static void FallDamage_FallImpact(FallDamage hook, float fallspeed)
{
object[] args = new object[]
{
hook,
fallspeed
};
Method.Invoke("RustExtended.RustHook.FallDamage_FallImpact", args);
}
public override void OnStateEnter()
{
_inputReader = stateMachine.GetComponent <InputReader>();
_stats = stateMachine.GetComponent <StatHolder>().held;
_motor = stateMachine.GetComponent <Motor>();
_crouch = stateMachine.GetComponent <Crouch>();
_grounded = stateMachine.GetComponent <Grounded>();
_falldmg = stateMachine.GetComponent <FallDamage>();
#region change motor vals
_motor.speed = _stats.runSpeed;
_motor.accelRate = _stats.runAccelRate;
_motor.sprintHorizontalInputReductionMult = 1f;
#endregion
}
public override void OnStateEnter()
{
_motor = stateMachine.GetComponent <Motor>();
_grounded = stateMachine.GetComponent <Grounded>();
_stats = stateMachine.GetComponent <StatHolder>().held;
_falldmg = stateMachine.GetComponent <FallDamage>();
_jump = stateMachine.GetComponent <Jump>();
_crouch = stateMachine.GetComponent <Crouch>();
_crouch.crouching = true;
if (_falldmg.landingFirm)
{
_motor.accelMult = Vector3.zero;
timeToExit = 0.01f;
_falldmg.landingFirm = false;
}
else if (_falldmg.landingHard)
{
_motor.accelMult = Vector3.zero;
_motor.speed = _stats.runSpeed * 0.6f;
_motor.accelRate = _stats.runAccelRate * 0.6f;
timeToExit = 0.9f;
_jump.disableOverride = true;
_falldmg.landingHard = false;
}
else if (_falldmg.landingSplat)
{
_motor.accelMult = Vector3.zero;
_motor.speed = _stats.runSpeed * 0.2f;
_motor.accelRate = _stats.runAccelRate * 0.2f;
timeToExit = 1.5f;
_jump.disableOverride = true;
_falldmg.landingSplat = false;
}
timer = 0;
}
public override void OnStateEnter()
{
_input = stateMachine.GetComponent <InputReader>();
_stats = stateMachine.GetComponent <StatHolder>().held;
_motor = stateMachine.GetComponent <Motor>();
_grounded = stateMachine.GetComponent <Grounded>();
_edgeDetect = stateMachine.GetComponent <EdgeDetect>();
_edgeDetect.enabled = true;
_climb = stateMachine.GetComponent <Climb>();
toggle = false;
_crouch = stateMachine.GetComponent <Crouch>();
_falldmg = stateMachine.GetComponent <FallDamage>();
#region change motor vals
_motor.speed = _stats.airSpeed;
_motor.accelRate = _stats.airAccelRate;
_motor.sprintHorizontalInputReductionMult = 1f;
#endregion
}
public static bool IsFriend(HurtEvent e) // ref
{
GodModeCommand command = (GodModeCommand)ChatCommand.GetCommand("god");
Fougerite.Player victim = e.Victim as Fougerite.Player;
if (victim != null)
{
if (command.IsOn(victim.UID))
{
FallDamage dmg = victim.FallDamage;
if (dmg != null)
{
dmg.ClearInjury();
}
return(true);
}
Fougerite.Player attacker = e.Attacker as Fougerite.Player;
if (attacker != null)
{
FriendsCommand command2 = (FriendsCommand)ChatCommand.GetCommand("amigos");
if (command2.ContainsException(attacker.UID) && command2.ContainsException(victim.UID))
{
return(false);
}
bool b = Core.config.GetBoolSetting("Settings", "friendly_fire");
try
{
FriendList list = (FriendList)command2.GetFriendsLists()[attacker.UID];
if (list == null || b)
{
return(false);
}
return(list.isFriendWith(victim.UID));
}
catch
{
return(false);
}
}
}
return(false);
}
void cmdChatTeleportCancel(NetUser netuser, string command, string[] args)
{
FallDamage falldamage = netuser.playerClient.rootControllable.GetComponent <FallDamage>();
if (TPIncoming.ContainsKey(netuser))
{
ClearLegInjury(falldamage);
var targetplayer = TPIncoming[netuser];
SendReply(netuser, string.Format("[color cyan]You have rejected [color orange]{0}'s request.", targetplayer.displayName));
SendReply(targetplayer, string.Format("{0} has rejected your request.", netuser.displayName));
TPIncoming.Remove(netuser);
if (timersList.ContainsKey(targetplayer))
{
timersList[targetplayer].Destroy();
timersList.Remove(targetplayer);
}
TPRequest.Remove(targetplayer);
return;
}
ClearLegInjury(falldamage);
ResetRequest(netuser);
SendReply(netuser, "[color orange]You have cancelled all current teleportations.");
}
public override void Bind(Entity entity, Main main, bool creating = false)
{
Main.Config settings = main.Settings;
Transform transform = entity.GetOrCreate <Transform>("Transform");
entity.CannotSuspend = true;
PlayerFactory.Instance = entity;
this.SetMain(entity, main);
FPSInput input = new FPSInput();
input.EnabledWhenPaused = false;
entity.Add("Input", input);
Updater parkour = entity.Create <Updater>();
Updater jumper = entity.Create <Updater>();
Player player = entity.GetOrCreate <Player>("Player");
AnimatedModel firstPersonModel = entity.GetOrCreate <AnimatedModel>("FirstPersonModel");
firstPersonModel.MapContent = false;
firstPersonModel.Serialize = false;
firstPersonModel.Filename.Value = "Models\\joan-firstperson";
firstPersonModel.CullBoundingBox.Value = false;
AnimatedModel model = entity.GetOrCreate <AnimatedModel>("Model");
model.MapContent = false;
model.Serialize = false;
model.Filename.Value = "Models\\joan";
model.CullBoundingBox.Value = false;
AnimationController anim = entity.GetOrCreate <AnimationController>("AnimationController");
RotationController rotation = entity.GetOrCreate <RotationController>("Rotation");
BlockPredictor predictor = entity.GetOrCreate <BlockPredictor>("BlockPredictor");
Jump jump = entity.GetOrCreate <Jump>("Jump");
RollKickSlide rollKickSlide = entity.GetOrCreate <RollKickSlide>("RollKickSlide");
Vault vault = entity.GetOrCreate <Vault>("Vault");
WallRun wallRun = entity.GetOrCreate <WallRun>("WallRun");
VoxelTools voxelTools = entity.GetOrCreate <VoxelTools>("VoxelTools");
Footsteps footsteps = entity.GetOrCreate <Footsteps>("Footsteps");
FallDamage fallDamage = entity.GetOrCreate <FallDamage>("FallDamage");
CameraController cameraControl = entity.GetOrCreate <CameraController>("CameraControl");
FPSCamera fpsCamera = entity.GetOrCreate <FPSCamera>("FPSCamera");
fpsCamera.Enabled.Value = false;
Rumble rumble = entity.GetOrCreate <Rumble>("Rumble");
Property <Vector3> floor = new Property <Vector3>();
transform.Add(new Binding <Vector3>(floor, () => transform.Position + new Vector3(0, player.Character.Height * -0.5f, 0), transform.Position, player.Character.Height));
AkGameObjectTracker.Attach(entity, floor);
predictor.Add(new Binding <Vector3>(predictor.FootPosition, floor));
predictor.Add(new Binding <Vector3>(predictor.LinearVelocity, player.Character.LinearVelocity));
predictor.Add(new Binding <float>(predictor.Rotation, rotation.Rotation));
predictor.Add(new Binding <float>(predictor.MaxSpeed, player.Character.MaxSpeed));
predictor.Add(new Binding <float>(predictor.JumpSpeed, player.Character.JumpSpeed));
predictor.Add(new Binding <bool>(predictor.IsSupported, player.Character.IsSupported));
jump.Add(new Binding <bool>(jump.Crouched, player.Character.Crouched));
jump.Add(new TwoWayBinding <bool>(player.Character.IsSupported, jump.IsSupported));
jump.Add(new TwoWayBinding <bool>(player.Character.HasTraction, jump.HasTraction));
jump.Add(new TwoWayBinding <Vector3>(player.Character.LinearVelocity, jump.LinearVelocity));
jump.Add(new TwoWayBinding <BEPUphysics.Entities.Entity>(jump.SupportEntity, player.Character.SupportEntity));
jump.Add(new TwoWayBinding <Vector3>(jump.SupportVelocity, player.Character.SupportVelocity));
jump.Add(new Binding <Vector2>(jump.AbsoluteMovementDirection, player.Character.MovementDirection));
jump.Add(new Binding <WallRun.State>(jump.WallRunState, wallRun.CurrentState));
jump.Add(new Binding <float>(jump.Rotation, rotation.Rotation));
jump.Add(new Binding <Vector3>(jump.Position, transform.Position));
jump.Add(new Binding <Vector3>(jump.FloorPosition, floor));
jump.Add(new Binding <float>(jump.MaxSpeed, player.Character.MaxSpeed));
jump.Add(new Binding <float>(jump.JumpSpeed, player.Character.JumpSpeed));
jump.Add(new Binding <float>(jump.Mass, player.Character.Mass));
jump.Add(new Binding <float>(jump.LastRollKickEnded, rollKickSlide.LastRollKickEnded));
jump.Add(new Binding <Voxel>(jump.WallRunMap, wallRun.WallRunVoxel));
jump.Add(new Binding <Direction>(jump.WallDirection, wallRun.WallDirection));
jump.Add(new CommandBinding <Voxel, Voxel.Coord, Direction>(jump.WalkedOn, footsteps.WalkedOn));
jump.Add(new CommandBinding(jump.DeactivateWallRun, (Action)wallRun.Deactivate));
jump.Add(new CommandBinding <float>(jump.FallDamage, fallDamage.ApplyJump));
jump.Predictor = predictor;
jump.Bind(model);
jump.Add(new TwoWayBinding <Voxel>(wallRun.LastWallRunMap, jump.LastWallRunMap));
jump.Add(new TwoWayBinding <Direction>(wallRun.LastWallDirection, jump.LastWallDirection));
jump.Add(new TwoWayBinding <bool>(rollKickSlide.CanKick, jump.CanKick));
jump.Add(new TwoWayBinding <float>(player.Character.LastSupportedSpeed, jump.LastSupportedSpeed));
wallRun.Add(new Binding <bool>(wallRun.IsSwimming, player.Character.IsSwimming));
wallRun.Add(new TwoWayBinding <Vector3>(player.Character.LinearVelocity, wallRun.LinearVelocity));
wallRun.Add(new TwoWayBinding <Vector3>(transform.Position, wallRun.Position));
wallRun.Add(new TwoWayBinding <bool>(player.Character.IsSupported, wallRun.IsSupported));
wallRun.Add(new CommandBinding(wallRun.LockRotation, (Action)rotation.Lock));
wallRun.Add(new CommandBinding <float>(wallRun.UpdateLockedRotation, rotation.UpdateLockedRotation));
vault.Add(new CommandBinding(wallRun.Vault, delegate() { vault.Go(true); }));
wallRun.Predictor = predictor;
wallRun.Add(new Binding <float>(wallRun.Height, player.Character.Height));
wallRun.Add(new Binding <float>(wallRun.JumpSpeed, player.Character.JumpSpeed));
wallRun.Add(new Binding <float>(wallRun.MaxSpeed, player.Character.MaxSpeed));
wallRun.Add(new TwoWayBinding <float>(rotation.Rotation, wallRun.Rotation));
wallRun.Add(new TwoWayBinding <bool>(player.Character.AllowUncrouch, wallRun.AllowUncrouch));
wallRun.Add(new TwoWayBinding <bool>(player.Character.HasTraction, wallRun.HasTraction));
wallRun.Add(new Binding <float>(wallRun.LastWallJump, jump.LastWallJump));
player.Add(new Binding <WallRun.State>(player.Character.WallRunState, wallRun.CurrentState));
input.Bind(rollKickSlide.RollKickButton, settings.RollKick);
rollKickSlide.Add(new Binding <bool>(rollKickSlide.EnableCrouch, player.EnableCrouch));
rollKickSlide.Add(new Binding <float>(rollKickSlide.Rotation, rotation.Rotation));
rollKickSlide.Add(new Binding <bool>(rollKickSlide.IsSwimming, player.Character.IsSwimming));
rollKickSlide.Add(new Binding <bool>(rollKickSlide.IsSupported, player.Character.IsSupported));
rollKickSlide.Add(new Binding <Vector3>(rollKickSlide.FloorPosition, floor));
rollKickSlide.Add(new Binding <float>(rollKickSlide.Height, player.Character.Height));
rollKickSlide.Add(new Binding <float>(rollKickSlide.MaxSpeed, player.Character.MaxSpeed));
rollKickSlide.Add(new Binding <float>(rollKickSlide.JumpSpeed, player.Character.JumpSpeed));
rollKickSlide.Add(new Binding <Vector3>(rollKickSlide.SupportVelocity, player.Character.SupportVelocity));
rollKickSlide.Add(new TwoWayBinding <bool>(wallRun.EnableEnhancedWallRun, rollKickSlide.EnableEnhancedRollSlide));
rollKickSlide.Add(new TwoWayBinding <bool>(player.Character.AllowUncrouch, rollKickSlide.AllowUncrouch));
rollKickSlide.Add(new TwoWayBinding <bool>(player.Character.Crouched, rollKickSlide.Crouched));
rollKickSlide.Add(new TwoWayBinding <bool>(player.Character.EnableWalking, rollKickSlide.EnableWalking));
rollKickSlide.Add(new TwoWayBinding <Vector3>(player.Character.LinearVelocity, rollKickSlide.LinearVelocity));
rollKickSlide.Add(new TwoWayBinding <Vector3>(transform.Position, rollKickSlide.Position));
rollKickSlide.Predictor = predictor;
rollKickSlide.Bind(model);
rollKickSlide.VoxelTools = voxelTools;
rollKickSlide.Add(new CommandBinding(rollKickSlide.DeactivateWallRun, (Action)wallRun.Deactivate));
rollKickSlide.Add(new CommandBinding(rollKickSlide.Footstep, footsteps.Footstep));
rollKickSlide.Add(new CommandBinding(rollKickSlide.LockRotation, (Action)rotation.Lock));
SoundKiller.Add(entity, AK.EVENTS.STOP_PLAYER_SLIDE_LOOP);
vault.Add(new Binding <Vector3>(vault.Position, transform.Position));
vault.Add(new Binding <Vector3>(vault.FloorPosition, floor));
vault.Add(new Binding <float>(vault.MaxSpeed, player.Character.MaxSpeed));
vault.Add(new Binding <WallRun.State>(vault.WallRunState, wallRun.CurrentState));
vault.Add(new CommandBinding(vault.LockRotation, (Action)rotation.Lock));
vault.Add(new CommandBinding(vault.DeactivateWallRun, (Action)wallRun.Deactivate));
vault.Add(new TwoWayBinding <float>(player.Character.LastSupportedSpeed, vault.LastSupportedSpeed));
vault.Add(new CommandBinding <float>(vault.FallDamage, fallDamage.Apply));
vault.Bind(model);
vault.Predictor = predictor;
vault.Add(new TwoWayBinding <float>(rotation.Rotation, vault.Rotation));
vault.Add(new TwoWayBinding <bool>(player.Character.IsSupported, vault.IsSupported));
vault.Add(new TwoWayBinding <bool>(player.Character.HasTraction, vault.HasTraction));
vault.Add(new TwoWayBinding <Vector3>(player.Character.LinearVelocity, vault.LinearVelocity));
vault.Add(new TwoWayBinding <bool>(player.Character.EnableWalking, vault.EnableWalking));
vault.Add(new TwoWayBinding <bool>(player.Character.AllowUncrouch, vault.AllowUncrouch));
vault.Add(new TwoWayBinding <bool>(player.Character.Crouched, vault.Crouched));
vault.Add(new Binding <float>(vault.Radius, player.Character.Radius));
rotation.Add(new TwoWayBinding <Vector2>(rotation.Mouse, input.Mouse));
rotation.Add(new Binding <bool>(rotation.Rolling, rollKickSlide.Rolling));
rotation.Add(new Binding <bool>(rotation.Kicking, rollKickSlide.Kicking));
rotation.Add(new Binding <Vault.State>(rotation.VaultState, vault.CurrentState));
rotation.Add(new Binding <WallRun.State>(rotation.WallRunState, wallRun.CurrentState));
voxelTools.Add(new Binding <float>(voxelTools.Height, player.Character.Height));
voxelTools.Add(new Binding <float>(voxelTools.SupportHeight, player.Character.SupportHeight));
voxelTools.Add(new Binding <Vector3>(voxelTools.Position, transform.Position));
anim.Add(new Binding <bool>(anim.IsSupported, player.Character.IsSupported));
anim.Add(new Binding <WallRun.State>(anim.WallRunState, wallRun.CurrentState));
anim.Add(new Binding <bool>(anim.EnableWalking, player.Character.EnableWalking));
anim.Add(new Binding <bool>(anim.Crouched, player.Character.Crouched));
anim.Add(new Binding <Vector3>(anim.LinearVelocity, player.Character.LinearVelocity));
anim.Add(new Binding <Vector2>(anim.Movement, input.Movement));
anim.Add(new Binding <Vector2>(anim.Mouse, input.Mouse));
anim.Add(new Binding <float>(anim.Rotation, rotation.Rotation));
anim.Add(new Binding <Voxel>(anim.WallRunMap, wallRun.WallRunVoxel));
anim.Add(new Binding <Direction>(anim.WallDirection, wallRun.WallDirection));
anim.Add(new Binding <bool>(anim.IsSwimming, player.Character.IsSwimming));
anim.Add(new Binding <bool>(anim.Kicking, rollKickSlide.Kicking));
anim.Add(new Binding <Vector3>(anim.SupportVelocity, player.Character.SupportVelocity));
anim.Add
(
new Binding <bool>
(
anim.EnableLean,
() => player.Character.EnableWalking.Value && player.Character.IsSupported.Value && input.Movement.Value.Y > 0.5f,
player.Character.EnableWalking, player.Character.IsSupported, input.Movement
)
);
anim.Bind(model);
// Camera control
model.UpdateWorldTransforms();
cameraControl.Add(new Binding <Vector2>(cameraControl.Mouse, input.Mouse));
cameraControl.Add(new Binding <float>(cameraControl.Lean, x => x * (float)Math.PI * 0.05f, anim.Lean));
cameraControl.Add(new Binding <Vector3>(cameraControl.LinearVelocity, player.Character.LinearVelocity));
cameraControl.Add(new Binding <float>(cameraControl.MaxSpeed, player.Character.MaxSpeed));
cameraControl.Add(new Binding <Matrix>(cameraControl.CameraBone, model.GetBoneTransform("Camera")));
cameraControl.Add(new Binding <Matrix>(cameraControl.HeadBone, model.GetBoneTransform("ORG-head")));
cameraControl.Add(new Binding <Matrix>(cameraControl.ModelTransform, model.Transform));
cameraControl.Add(new Binding <float>(cameraControl.BaseCameraShakeAmount, () => MathHelper.Clamp((player.Character.LinearVelocity.Value.Length() - (player.Character.MaxSpeed * 2.5f)) / (player.Character.MaxSpeed * 4.0f), 0, 1), player.Character.LinearVelocity, player.Character.MaxSpeed));
cameraControl.Offset = model.GetBoneTransform("Camera").Value.Translation - model.GetBoneTransform("ORG-head").Value.Translation;
float heightOffset = 0.1f;
#if VR
if (main.VR)
{
heightOffset = 0.4f;
}
#endif
cameraControl.Offset += new Vector3(0, heightOffset, 0);
rumble.Add(new Binding <float>(rumble.CameraShake, cameraControl.TotalCameraShake));
rumble.Add(new CommandBinding <float>(fallDamage.Rumble, rumble.Go));
rumble.Add(new CommandBinding <float>(player.Rumble, rumble.Go));
rumble.Add(new CommandBinding <float>(rollKickSlide.Rumble, rumble.Go));
firstPersonModel.Add(new Binding <bool>(firstPersonModel.Enabled, x => !x, cameraControl.ThirdPerson));
model.Add(new ChangeBinding <bool>(cameraControl.ThirdPerson, delegate(bool old, bool value)
{
if (value && !old)
{
model.UnsupportedTechniques.Remove(Technique.Clip);
model.UnsupportedTechniques.Remove(Technique.Render);
}
else if (old && !value)
{
model.UnsupportedTechniques.Add(Technique.Clip);
model.UnsupportedTechniques.Add(Technique.Render);
}
}));
Lemma.Console.Console.AddConCommand(new Console.ConCommand("third_person", "Toggle third-person view (WARNING: EXPERIMENTAL)", delegate(Console.ConCommand.ArgCollection args)
{
cameraControl.ThirdPerson.Value = !cameraControl.ThirdPerson;
}));
entity.Add(new CommandBinding(entity.Delete, delegate()
{
Lemma.Console.Console.RemoveConCommand("third_person");
}));
#if DEVELOPMENT
ModelAlpha debugCylinder = new ModelAlpha();
debugCylinder.Filename.Value = "AlphaModels\\cylinder";
debugCylinder.Add(new Binding <Matrix>(debugCylinder.Transform, transform.Matrix));
debugCylinder.Serialize = false;
debugCylinder.Alpha.Value = 0.25f;
debugCylinder.Add(new Binding <bool>(debugCylinder.Enabled, cameraControl.ThirdPerson));
debugCylinder.Add(new Binding <Vector3>(debugCylinder.Scale, delegate()
{
return(new Vector3(player.Character.Radius * 2.0f, player.Character.Height, player.Character.Radius * 2.0f));
}, player.Character.Height, player.Character.Radius));
entity.Add(debugCylinder);
#endif
// When rotation is locked, we want to make sure the player can't turn their head
// 180 degrees from the direction they're facing
#if VR
if (main.VR)
{
input.MaxY.Value = input.MinY.Value = 0;
}
else
#endif
input.Add(new Binding <float>(input.MaxY, () => rotation.Locked ? (float)Math.PI * 0.3f : (float)Math.PI * 0.4f, rotation.Locked));
input.Add(new Binding <float>(input.MinX, () => rotation.Locked ? rotation.Rotation + ((float)Math.PI * -0.4f) : 0.0f, rotation.Rotation, rotation.Locked));
input.Add(new Binding <float>(input.MaxX, () => rotation.Locked ? rotation.Rotation + ((float)Math.PI * 0.4f) : 0.0f, rotation.Rotation, rotation.Locked));
input.Add(new NotifyBinding(delegate() { input.Mouse.Changed(); }, rotation.Locked)); // Make sure the rotation locking takes effect even if the player doesn't move the mouse
// Setup rendering properties
model.Materials = firstPersonModel.Materials = new Model.Material[3];
// Hoodie and shoes
model.Materials[0] = new Model.Material
{
SpecularIntensity = 0.0f,
SpecularPower = 1.0f,
};
// Hands
model.Materials[1] = new Model.Material
{
SpecularIntensity = 0.3f,
SpecularPower = 2.0f,
};
// Pants and skin
model.Materials[2] = new Model.Material
{
SpecularIntensity = 0.5f,
SpecularPower = 20.0f,
};
firstPersonModel.Bind(model);
// Third person model only gets rendered for shadows. No regular rendering or reflections.
model.UnsupportedTechniques.Add(Technique.Clip);
model.UnsupportedTechniques.Add(Technique.Render);
// First-person model only used for regular rendering. No shadows or reflections.
firstPersonModel.UnsupportedTechniques.Add(Technique.Shadow);
firstPersonModel.UnsupportedTechniques.Add(Technique.Clip);
// Build UI
UIRenderer ui = new UIRenderer();
ui.DrawOrder.Value = -1;
ui.EnabledWhenPaused = true;
ui.EnabledInEditMode = false;
entity.Add("UI", ui);
input.Add(new Binding <float>(input.MouseSensitivity, settings.MouseSensitivity));
input.Add(new Binding <bool>(input.InvertMouseX, settings.InvertMouseX));
input.Add(new Binding <bool>(input.InvertMouseY, settings.InvertMouseY));
input.Add(new Binding <PCInput.PCInputBinding>(input.LeftKey, settings.Left));
input.Add(new Binding <PCInput.PCInputBinding>(input.RightKey, settings.Right));
input.Add(new Binding <PCInput.PCInputBinding>(input.BackwardKey, settings.Backward));
input.Add(new Binding <PCInput.PCInputBinding>(input.ForwardKey, settings.Forward));
model.StartClip("Idle", 0, true, AnimatedModel.DefaultBlendTime);
// Set up AI agent
Agent agent = entity.GetOrCreate <Agent>();
agent.Add(new TwoWayBinding <float>(player.Health, agent.Health));
agent.Add(new Binding <Vector3>(agent.Position, () => transform.Position.Value + new Vector3(0, player.Character.Height * -0.5f, 0), transform.Position, player.Character.Height));
agent.Add(new Binding <bool>(agent.Loud, () => player.Character.MovementDirection.Value.LengthSquared() > 0 && !player.Character.Crouched, player.Character.Crouched));
// Blocks
BlockCloud blockCloud = entity.GetOrCreate <BlockCloud>("BlockCloud");
blockCloud.Scale.Value = 0.5f;
blockCloud.Add(new Binding <Vector3>(blockCloud.Position, () => transform.Position.Value + new Vector3(0, player.Character.Height + player.Character.LinearVelocity.Value.Y, 0), transform.Position, player.Character.Height, player.Character.LinearVelocity));
blockCloud.Blocks.ItemAdded += delegate(int index, Entity.Handle block)
{
Entity e = block.Target;
if (e != null)
{
e.Serialize = false;
PhysicsBlock.CancelPlayerCollisions(e.Get <PhysicsBlock>());
}
};
PointLight blockLight = entity.Create <PointLight>();
blockLight.Add(new Binding <Vector3>(blockLight.Position, blockCloud.AveragePosition));
blockLight.Add(new Binding <bool, int>(blockLight.Enabled, x => x > 0, blockCloud.Blocks.Length));
blockLight.Attenuation.Value = 30.0f;
blockLight.Add(new Binding <Vector3, Voxel.t>(blockLight.Color, delegate(Voxel.t t)
{
switch (t)
{
case Voxel.t.GlowBlue:
return(new Vector3(0.7f, 0.7f, 0.9f));
case Voxel.t.GlowYellow:
return(new Vector3(0.9f, 0.9f, 0.7f));
default:
return(new Vector3(0.8f, 0.8f, 0.8f));
}
}, blockCloud.Type));
// Death
entity.Add(new CommandBinding(player.Die, blockCloud.Clear));
entity.Add(new CommandBinding(player.Die, delegate()
{
Session.Recorder.Event(main, "Die");
if (agent.Killed || Agent.Query(transform.Position, 0.0f, 10.0f, x => x != agent) != null)
{
Session.Recorder.Event(main, "Killed");
AkSoundEngine.PostEvent(AK.EVENTS.PLAY_PLAYER_DEATH, entity);
main.Spawner.RespawnDistance = Spawner.KilledRespawnDistance;
main.Spawner.RespawnInterval = Spawner.KilledRespawnInterval;
}
entity.Add(new Animation(new Animation.Execute(entity.Delete)));
}));
player.EnabledInEditMode = false;
Action updateFallSound = delegate()
{
float speed = player.Character.LinearVelocity.Value.Length();
float maxSpeed = player.Character.MaxSpeed * 1.25f;
float value;
if (speed > maxSpeed)
{
value = (speed - maxSpeed) / (maxSpeed * 2.0f);
}
else
{
value = 0.0f;
}
AkSoundEngine.SetRTPCValue(AK.GAME_PARAMETERS.SFX_PLAYER_FALL, value);
};
updateFallSound();
AkSoundEngine.PostEvent(AK.EVENTS.PLAY_PLAYER_FALL, entity);
player.Add(new NotifyBinding(updateFallSound, player.Character.LinearVelocity));
SoundKiller.Add(entity, AK.EVENTS.STOP_PLAYER_FALL);
player.Add(new TwoWayBinding <Matrix>(transform.Matrix, player.Character.Transform));
model.Add(new Binding <Matrix>(model.Transform, delegate()
{
const float leanAmount = (float)Math.PI * 0.1f;
return(Matrix.CreateTranslation(0, (player.Character.Height * -0.5f) - player.Character.SupportHeight, 0) * Matrix.CreateRotationZ(anim.Lean * leanAmount) * Matrix.CreateRotationY(rotation.Rotation) * transform.Matrix);
}, transform.Matrix, rotation.Rotation, player.Character.Height, player.Character.SupportHeight, anim.Lean));
firstPersonModel.Add(new Binding <Matrix>(firstPersonModel.Transform, model.Transform));
firstPersonModel.Add(new Binding <Vector3>(firstPersonModel.Scale, model.Scale));
WallRun.State[] footstepWallrunStates = new[]
{
WallRun.State.Left,
WallRun.State.Right,
WallRun.State.Straight,
WallRun.State.None,
};
footsteps.Add(new Binding <bool>(footsteps.SoundEnabled, () => !player.Character.Crouched && footstepWallrunStates.Contains(wallRun.CurrentState) || (player.Character.IsSupported && player.Character.EnableWalking), player.Character.IsSupported, player.Character.EnableWalking, wallRun.CurrentState, player.Character.Crouched));
footsteps.Add(new Binding <Vector3>(footsteps.Position, transform.Position));
footsteps.Add(new Binding <float>(footsteps.Rotation, rotation.Rotation));
footsteps.Add(new Binding <float>(footsteps.CharacterHeight, player.Character.Height));
footsteps.Add(new Binding <float>(footsteps.SupportHeight, player.Character.SupportHeight));
footsteps.Add(new Binding <bool>(footsteps.IsSupported, player.Character.IsSupported));
footsteps.Add(new Binding <bool>(footsteps.IsSwimming, player.Character.IsSwimming));
footsteps.Add(new CommandBinding <float>(footsteps.Damage, agent.Damage));
footsteps.Add(new CommandBinding <Voxel, Voxel.Coord, Direction>(wallRun.WalkedOn, footsteps.WalkedOn));
model.Trigger("Run", 0.16f, footsteps.Footstep);
model.Trigger("Run", 0.58f, footsteps.Footstep);
model.Trigger("WallRunLeft", 0.16f, footsteps.Footstep);
model.Trigger("WallRunLeft", 0.58f, footsteps.Footstep);
model.Trigger("WallRunRight", 0.16f, footsteps.Footstep);
model.Trigger("WallRunRight", 0.58f, footsteps.Footstep);
model.Trigger("WallRunStraight", 0.16f, footsteps.Footstep);
model.Trigger("WallRunStraight", 0.58f, footsteps.Footstep);
model.Trigger("TurnLeft", 0.15f, footsteps.Footstep);
model.Trigger("TurnRight", 0.15f, footsteps.Footstep);
model.Trigger("TopOut", 1.0f, new Command
{
Action = delegate()
{
AkSoundEngine.PostEvent(AK.EVENTS.PLAY_PLAYER_GRUNT, entity);
}
});
main.UI.IsMouseVisible.Value = false;
SkinnedModel.Clip sprintAnimation = model["Sprint"], runAnimation = model["Run"];
// Movement binding
player.Add(new Binding <Vector2>(player.Character.MovementDirection, delegate()
{
Vector2 movement = input.Movement;
if (movement.LengthSquared() == 0.0f)
{
return(Vector2.Zero);
}
Matrix matrix = Matrix.CreateRotationY(rotation.Rotation);
Vector2 forwardDir = new Vector2(matrix.Forward.X, matrix.Forward.Z);
Vector2 rightDir = new Vector2(matrix.Right.X, matrix.Right.Z);
return(-(forwardDir * movement.Y) - (rightDir * movement.X));
}, input.Movement, rotation.Rotation));
player.Character.Crouched.Value = true;
player.Character.AllowUncrouch.Value = true;
// Fall damage
fallDamage.Add(new Binding <bool>(fallDamage.IsSupported, player.Character.IsSupported));
fallDamage.Add(new TwoWayBinding <Vector3>(player.Character.LinearVelocity, fallDamage.LinearVelocity));
fallDamage.Add(new TwoWayBinding <float>(player.Health, fallDamage.Health));
fallDamage.Add(new CommandBinding <BEPUphysics.BroadPhaseEntries.Collidable, ContactCollection>(player.Character.Collided, fallDamage.Collided));
fallDamage.Add(new TwoWayBinding <bool>(player.Character.EnableWalking, fallDamage.EnableWalking));
fallDamage.Add(new TwoWayBinding <bool>(player.EnableMoves, fallDamage.EnableMoves));
fallDamage.Add(new TwoWayBinding <bool>(fallDamage.Landing, rotation.Landing));
fallDamage.Add(new CommandBinding(fallDamage.LockRotation, (Action)rotation.Lock));
fallDamage.Add(new CommandBinding <float>(fallDamage.PhysicsDamage, agent.Damage));
fallDamage.Bind(model);
// Swim up
input.Bind(player.Character.SwimUp, settings.Jump);
float parkourTime = 0;
float jumpTime = 0;
const float gracePeriod = 1.0f;
jumper.Action = delegate(float dt)
{
if (player.EnableMoves && player.Character.EnableWalking &&
vault.CurrentState.Value == Vault.State.None &&
!rollKickSlide.Rolling && !rollKickSlide.Kicking &&
jumpTime < gracePeriod)
{
if (jump.Go())
{
parkour.Enabled.Value = false;
jumper.Enabled.Value = false;
}
jumpTime += dt;
}
else
{
jumper.Enabled.Value = false;
}
};
jumper.Add(new CommandBinding(jumper.Enable, delegate() { jumpTime = 0; }));
jumper.Enabled.Value = false;
entity.Add(jumper);
// Jumping
input.Bind(settings.Jump, PCInput.InputState.Down, delegate()
{
jumper.Enabled.Value = true;
});
input.Bind(settings.Jump, PCInput.InputState.Up, delegate()
{
jumper.Enabled.Value = false;
});
// Wall-run, vault, predictive
parkour.Action = delegate(float dt)
{
if (player.EnableMoves &&
player.Character.EnableWalking &&
!(player.Character.Crouched && player.Character.IsSupported) &&
vault.CurrentState.Value == Vault.State.None &&
!rollKickSlide.Kicking &&
!rollKickSlide.Rolling &&
wallRun.CurrentState.Value == WallRun.State.None &&
parkourTime < gracePeriod)
{
bool didSomething = false;
bool parkourBeganThisFrame = parkourTime == 0;
if (predictor.PossibilityCount > 0)
{
// In slow motion, prefer left and right wall-running
if (!(didSomething = wallRun.Activate(WallRun.State.Left, parkourBeganThisFrame)))
{
if (!(didSomething = wallRun.Activate(WallRun.State.Right, parkourBeganThisFrame)))
{
if (!(didSomething = vault.Go(parkourBeganThisFrame)))
{
didSomething = wallRun.Activate(WallRun.State.Straight, parkourBeganThisFrame);
}
}
}
}
else
{
// In normal mode, prefer straight wall-running
if (!(didSomething = vault.Go(parkourBeganThisFrame)))
{
if (!(didSomething = wallRun.Activate(WallRun.State.Straight, parkourBeganThisFrame)))
{
if (!(didSomething = wallRun.Activate(WallRun.State.Left, parkourBeganThisFrame)))
{
didSomething = wallRun.Activate(WallRun.State.Right, parkourBeganThisFrame);
}
}
}
}
if (didSomething)
{
jumper.Enabled.Value = false;
player.SlowMotion.Value = false;
parkour.Enabled.Value = false;
}
else if (parkourBeganThisFrame)
{
if (blockCloud.Blocks.Length > 0)
{
player.SlowMotion.Value = true;
predictor.ClearPossibilities();
predictor.PredictPlatforms();
predictor.PredictWalls();
}
else if (player.EnableSlowMotion)
{
player.SlowMotion.Value = true;
}
}
parkourTime += dt;
}
else
{
parkour.Enabled.Value = false;
}
};
parkour.Add(new CommandBinding(parkour.Enable, delegate()
{
parkourTime = 0;
}));
entity.Add(parkour);
parkour.Enabled.Value = false;
input.Bind(settings.Parkour, PCInput.InputState.Down, delegate()
{
parkour.Enabled.Value = true;
});
input.Bind(settings.Parkour, PCInput.InputState.Up, delegate()
{
parkour.Enabled.Value = false;
wallRun.Deactivate();
if (player.SlowMotion)
{
player.SlowMotion.Value = false;
}
});
input.Bind(settings.RollKick, PCInput.InputState.Down, delegate()
{
if (player.EnableMoves && player.Character.EnableWalking)
{
rollKickSlide.Go();
parkour.Enabled.Value = false;
jumper.Enabled.Value = false;
}
});
input.Bind(settings.RollKick, PCInput.InputState.Up, delegate()
{
if (!rollKickSlide.Rolling && !rollKickSlide.Kicking)
{
player.Character.AllowUncrouch.Value = true;
}
});
// Special ability
/*
* input.Bind(settings.SpecialAbility, PCInput.InputState.Down, delegate()
* {
* Voxel.GlobalRaycastResult hit = Voxel.GlobalRaycast(main.Camera.Position, main.Camera.Forward, main.Camera.FarPlaneDistance, null);
* if (hit.Voxel != null && hit.Voxel.GetType() != typeof(DynamicVoxel))
* {
* VoxelRip.Go(hit.Voxel, hit.Coordinate.Value, 7, delegate(List<DynamicVoxel> results)
* {
* foreach (DynamicVoxel v in results)
* {
* v.IsAffectedByGravity.Value = false;
* v.LinearVelocity.Value = hit.Voxel.GetAbsoluteVector(hit.Normal.GetVector()) * 7.0f
+ new Vector3((float)this.random.NextDouble() * 2.0f - 1.0f, (float)this.random.NextDouble() * 2.0f - 1.0f, (float)this.random.NextDouble() * 2.0f - 1.0f);
+ }
+ });
+ }
+ });
*/
// Player data bindings
entity.Add(new PostInitialization
{
delegate()
{
Entity dataEntity = PlayerDataFactory.Instance;
PlayerData playerData = dataEntity.Get <PlayerData>();
// HACK. Overwriting the property rather than binding the two together. Oh well.
// This is because I haven't written a two-way list binding.
footsteps.RespawnLocations = playerData.RespawnLocations;
// Bind player data properties
entity.Add(new TwoWayBinding <float>(WorldFactory.Instance.Get <World>().CameraShakeAmount, cameraControl.CameraShakeAmount));
entity.Add(new TwoWayBinding <bool>(playerData.EnableRoll, rollKickSlide.EnableRoll));
entity.Add(new TwoWayBinding <bool>(playerData.EnableCrouch, player.EnableCrouch));
entity.Add(new TwoWayBinding <bool>(playerData.EnableKick, rollKickSlide.EnableKick));
entity.Add(new TwoWayBinding <bool>(playerData.EnableWallRun, wallRun.EnableWallRun));
entity.Add(new TwoWayBinding <bool>(playerData.EnableWallRunHorizontal, wallRun.EnableWallRunHorizontal));
entity.Add(new TwoWayBinding <bool>(playerData.EnableEnhancedWallRun, wallRun.EnableEnhancedWallRun));
entity.Add(new TwoWayBinding <bool>(playerData.EnableMoves, player.EnableMoves));
entity.Add(new TwoWayBinding <float>(playerData.MaxSpeed, player.Character.MaxSpeed));
entity.Add(new TwoWayBinding <Voxel.t>(playerData.CloudType, blockCloud.Type));
entity.Add(new TwoWayBinding <bool>(playerData.ThirdPerson, cameraControl.ThirdPerson));
entity.Add(new TwoWayBinding <bool>(playerData.EnableSlowMotion, player.EnableSlowMotion));
Phone phone = dataEntity.GetOrCreate <Phone>("Phone");
entity.Add
(
new Binding <bool>
(
phone.CanReceiveMessages,
() => player.Character.IsSupported && !player.Character.IsSwimming && !player.Character.Crouched,
player.Character.IsSupported,
player.Character.IsSwimming,
player.Character.Crouched
)
);
PhoneNote.Attach(main, entity, player, model, input, phone, player.Character.EnableWalking, playerData.PhoneActive, playerData.NoteActive);
PlayerUI.Attach(main, entity, ui, player.Health, rotation.Rotation, playerData.NoteActive, playerData.PhoneActive);
}
});
fpsCamera.Add(new Binding <Vector2>(fpsCamera.Mouse, input.Mouse));
fpsCamera.Add(new Binding <Vector2>(fpsCamera.Movement, input.Movement));
input.Bind(fpsCamera.SpeedMode, settings.Parkour);
input.Bind(fpsCamera.Up, settings.Jump);
fpsCamera.Add(new Binding <bool>(fpsCamera.Down, input.GetKey(Keys.LeftControl)));
Lemma.Console.Console.AddConCommand(new ConCommand("noclip", "Toggle free camera mode", delegate(ConCommand.ArgCollection args)
{
bool freeCameraMode = !fpsCamera.Enabled;
fpsCamera.Enabled.Value = freeCameraMode;
cameraControl.Enabled.Value = !freeCameraMode;
firstPersonModel.Enabled.Value = !freeCameraMode;
model.Enabled.Value = !freeCameraMode;
ui.Enabled.Value = !freeCameraMode;
player.Character.EnableWalking.Value = !freeCameraMode;
player.EnableMoves.Value = !freeCameraMode;
player.Character.Body.IsAffectedByGravity = !freeCameraMode;
if (freeCameraMode)
{
AkSoundEngine.PostEvent(AK.EVENTS.STOP_PLAYER_BREATHING_SOFT, entity);
}
else
{
transform.Position.Value = main.Camera.Position;
}
}));
entity.Add(new CommandBinding(entity.Delete, delegate()
{
Lemma.Console.Console.RemoveConCommand("noclip");
if (fpsCamera.Enabled) // Movement is disabled. Re-enable it.
{
player.Character.EnableWalking.Value = true;
player.EnableMoves.Value = true;
}
PlayerFactory.Instance = null;
}));
}
//Variables End_____________________________________
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
myTransform = transform;
motorScript = myTransform.GetComponent<CharacterMotor>();
playerGraphics = myTransform.FindChild("Graphics");
trigger = myTransform.FindChild("Trigger").gameObject;
cameraHead = myTransform.FindChild("CameraHead");
fallDamageScript = myTransform.GetComponent<FallDamage>();
changeScript = gameObject.GetComponent<ChangeWeapon>();
energyScript = gameObject.GetComponent<PlayerEnergy>();
}
else
{
enabled = false;
}
}
void DoTeleportation(NetUser netuser)
{
if (netuser == null || netuser.playerClient == null)
{
return;
}
FallDamage falldamage = netuser.playerClient.rootControllable.GetComponent <FallDamage>();
if (!TPRequest.ContainsKey(netuser))
{
SendReply(netuser, "Something went wrong, you dont have a target"); ClearLegInjury(falldamage); return;
}
var targetuser = TPRequest[netuser];
if (targetuser == null || targetuser.playerClient == null)
{
SendReply(netuser, "The target player that you were supposed to teleport to doesn't seem to be connected."); TPRequest.Remove(netuser); ClearLegInjury(falldamage); return;
}
object thereturn = Interface.GetMod().CallHook("canTeleport", new object[] { netuser });
if (thereturn != null)
{
SendReply(netuser, "You are not allowed to teleport from where you are.");
TPRequest.Remove(netuser);
return;
}
thereturn = Interface.GetMod().CallHook("canTeleport", new object[] { targetuser });
if (thereturn != null)
{
SendReply(netuser, "You are not allowed to teleport to where the target is.");
TPRequest.Remove(netuser);
return;
}
foreach (Collider collider in UnityEngine.Physics.OverlapSphere(targetuser.playerClient.lastKnownPosition, 0.5f, terrainLayer))
{
if (Physics.Raycast(targetuser.playerClient.lastKnownPosition, VectorDown, out cachedRaycast, 1f, terrainLayer))
{
if (cachedRaycast.collider == collider)
{
break;
}
}
SendReply(netuser, "[color red]The target seems to be under a rock, can't teleport you there.");
TPRequest.Remove(netuser);
return;
}
if (Ifinshack(targetuser))
{
SendReply(netuser, string.Format("[color cyan]{0} [color red]is in a shelter so you can't teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("[color cyan]You [color red]are in a shelter so [color cyan]{0} [color red]couldn't teleport to you.", netuser.displayName));
return;
}
if (IfNearStructure(targetuser))
{
SendReply(netuser, string.Format("[color cyan]{0} [color red]is standing to close to a wall. Unable to teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("[color cyan]You [color red]are standing to close to a wall so [color cyan]{0} [color red]couldn't teleport to you.", netuser.displayName));
TPRequest.Remove(netuser);
return;
}
if (!ifOnGround(targetuser))
{
SendReply(netuser, string.Format("{0} [color red]is on a building so you can't teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("You are on a building so {0} couldn't teleport to you.", netuser.displayName));
TPRequest.Remove(netuser);
return;
}
if (ifOnDeployable(targetuser))
{
SendReply(netuser, string.Format("{0} [color red]is on an object so you can't teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("You are on an object so {0} couldn't teleport to you.", netuser.displayName));
TPRequest.Remove(netuser);
return;
}
if (ifOnlootDeployable(targetuser))
{
SendReply(netuser, string.Format("{0} [color red]is on a lootable object so you can't teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("You are on a lotable object so {0} couldn't teleport to you.", netuser.displayName));
TPRequest.Remove(netuser);
return;
}
if (ifOnlootsackDeployable(targetuser))
{
SendReply(netuser, string.Format("{0} [color red]is on a lootable object so you can't teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("You are on a lotable object so {0} couldn't teleport to you.", netuser.displayName));
TPRequest.Remove(netuser);
return;
}
if (ifOnlootsackDeployable(targetuser))
{
SendReply(netuser, string.Format("{0} [color red]is on a lootable object so you can't teleport.", targetuser.displayName));
SendReply(targetuser, string.Format("You are on a lotable object so {0} couldn't teleport to you.", netuser.displayName));
TPRequest.Remove(netuser);
return;
}
if (lastRequest.ContainsKey(netuser))
{
lastRequest.Remove(netuser);
}
lastRequest.Add(netuser, Time.realtimeSinceStartup);
if (useTokens)
{
var tokensLeft = GetPlayerTokens(netuser) - 1;
PlayerDatabase.Call("SetPlayerData", netuser.playerClient.userID.ToString(), "tokens", tokensLeft);
}
var fixedpos = targetuser.playerClient.lastKnownPosition;
DoTeleportToPlayer(netuser, fixedpos, targetuser);
if (timersList.ContainsKey(netuser))
{
timersList[netuser].Destroy();
timersList.Remove(netuser);
}
TPRequest.Remove(netuser);
}
public static void FallImpact(float fallspeed, float min_vel, float max_vel, float healthFraction, Character idMain, float maxHealth, FallDamage fallDamage)
{
try
{
if (Vars.fallDamage)
{
float num = (fallspeed - min_vel) / (max_vel - min_vel);
bool flag = num > 0.25f;
bool flag2 = ((num > 0.35f) || (UnityEngine.Random.Range(0, 3) == 0)) || (healthFraction < 0.5f);
if (!godList.Contains(idMain.playerClient.userID.ToString()))
{
if (flag)
{
idMain.controllable.GetComponent<HumanBodyTakeDamage>().AddBleedingLevel(3f + ((num - 0.25f) * 10f));
}
if (flag2)
{
fallDamage.AddLegInjury(1f);
}
TakeDamage.HurtSelf(idMain, (float)(10f + (num * maxHealth)));
}
}
}
catch (Exception ex)
{
Vars.conLog.Error(ex.ToString());
}
}
public static bool Prefix(PlyMovementSync __instance, out bool wasChanged)
{
try
{
if (!NetworkServer.active)
{
wasChanged = false;
}
else
{
if (__instance._positionForced)
{
if (Vector3.Distance(__instance._receivedPosition, __instance._lastSafePosition) >= 4.0 &&
__instance._forcePositionTime <= 10.0)
{
__instance._receivedPosition = __instance._lastSafePosition;
__instance._forcePositionTime += Time.unscaledDeltaTime;
wasChanged = true;
return(false);
}
__instance._positionForced = false;
__instance._forcePositionTime = 0.0f;
}
wasChanged = false;
if (__instance.WhitelistPlayer || __instance.NoclipWhitelisted)
{
__instance.RealModelPosition = __instance._receivedPosition;
__instance._lastSafePosition = __instance._receivedPosition;
}
else
{
if (!__instance._successfullySpawned)
{
return(false);
}
float num1 = __instance._hub.characterClassManager.Classes
.SafeGet(__instance._hub.characterClassManager.CurClass).runSpeed;
if (__instance._sinkhole != null && __instance._sinkhole.Enabled)
{
num1 *= (float)(1.0 - __instance._sinkhole.slowAmount / 100.0);
}
if (__instance._receivedPosition.y > 1500.0)
{
if (__instance._hub.characterClassManager.CurClass != RoleType.Spectator)
{
__instance._receivedPosition = __instance.RealModelPosition;
wasChanged = true;
__instance.TargetForcePosition(
__instance._hub.characterClassManager.connectionToClient,
__instance.RealModelPosition);
}
else
{
__instance.RealModelPosition = Vector3.up * 2048f;
}
}
else
{
if (__instance._hub.characterClassManager.CurClass == RoleType.Scp079)
{
__instance.RealModelPosition = Vector3.up * 2080f;
}
else
{
__instance._hub.falldamage.CalculateGround();
__instance.TempAjustedPos = __instance.RealModelPosition;
if (!__instance._hub.falldamage.isGrounded)
{
__instance.RealModelPosition.y = __instance._receivedPosition.y;
}
Vector3 vector3_1 = __instance._receivedPosition - __instance.RealModelPosition;
__instance._debugDistance = vector3_1.magnitude;
if (__instance._hub.characterClassManager.CurClass == RoleType.Scp173)
{
__instance.RealModelPosition = __instance._receivedPosition;
}
else
{
float num2;
if (__instance._hub.animationController.sneaking)
{
float walkSpeed = __instance._hub.characterClassManager.Classes
.SafeGet(__instance._hub.characterClassManager.CurClass).walkSpeed;
num2 = walkSpeed * 0.4f * __instance.MaxLatency * __instance.Tolerance;
num1 = 0.4f * walkSpeed;
if (__instance._scp207.Enabled)
{
num1 = 0.8f * walkSpeed;
}
}
else
{
num2 = num1 * __instance.MaxLatency * __instance.Tolerance;
if (__instance._hub.characterClassManager.Scp096.iAm096)
{
num1 = __instance._hub.characterClassManager.Scp096.ServerGetTopSpeed();
}
if (__instance._scp207.Enabled)
{
num1 *= 1.2f;
}
}
if (__instance._debugDistance > __instance.MaxLatency * (double)(num1 * 5.2f))
{
if (__instance._safeTime > 0.0)
{
return(false);
}
//__instance.TargetForcePosition(__instance.connectionToClient, __instance.RealModelPosition);
wasChanged = true;
return(false);
}
if (__instance._receivedPosition.y - (double)__instance._lastSafePosition.y >
5.0 && __instance._hub.characterClassManager.CurClass != RoleType.Spectator)
{
__instance.RealModelPosition = __instance._lastSafePosition;
++__instance._violationsS;
++__instance._violationsL;
__instance.TargetForcePosition(__instance.connectionToClient,
__instance._lastSafePosition);
wasChanged = true;
return(false);
}
Vector3 vector3_2 =
num1 * __instance.Tolerance * Time.deltaTime * vector3_1.normalized;
/*float num3 = __instance.RealModelPosition.y - __instance._lastSafePosition.y;
* float num4 = Vector3.Distance(__instance._lastSafePosition,
* __instance.RealModelPosition);
* int num5 =
* (double) num4 < 10.0 && (double) Math.Abs(num3) < 3.0 ||
* (double) num3 < 0.0 && (double) num3 > -30.0 && (double) num4 < 30.0
* ? Physics.RaycastNonAlloc(
* new Ray(__instance.RealModelPosition + Vector3.up * 1f,
* __instance._receivedPosition - __instance.RealModelPosition),
* __instance._hits,
* (__instance._receivedPosition - __instance.RealModelPosition)
* .magnitude, __instance.CollidableSurfaces)
* : Physics.RaycastNonAlloc(
* new Ray(__instance._lastSafePosition + Vector3.up * 1f,
* __instance._receivedPosition - __instance._lastSafePosition),
* __instance._hits,
* (__instance._receivedPosition - __instance._lastSafePosition)
* .magnitude, __instance.CollidableSurfaces);
* for (int index = 0; index < num5; ++index)
* if (__instance._hub.characterClassManager.CurClass != RoleType.Scp106 &&
* __instance._hub.characterClassManager.CurClass != RoleType.Spectator &&
* (__instance._hits[index].collider.gameObject.layer != 27 ||
* __instance._hits[index].collider.GetComponentInParent<Door>()
* .curCooldown <= 0.0))
* {
* __instance.RealModelPosition = __instance._lastSafePosition;
* //++__instance._violationsS;
++__instance._violationsL;
* __instance.TargetForcePosition(__instance.connectionToClient, __instance._lastSafePosition);
* wasChanged = true;
* return false;
* }*/
__instance.RealModelPosition = __instance.TempAjustedPos;
if (FallDamage.CheckAnticheatSafe(__instance.RealModelPosition))
{
__instance._lastSafePosition = __instance.RealModelPosition;
}
if (__instance._debugDistance < __instance.MaxLatency * (double)num2)
{
if (vector3_2.magnitude > (double)__instance._debugDistance)
{
__instance.RealModelPosition = __instance._receivedPosition;
__instance._distanceTraveled += __instance._debugDistance;
}
else
{
__instance.RealModelPosition += vector3_2;
__instance._distanceTraveled += vector3_2.magnitude;
}
}
}
}
__instance._speedCounter += Time.deltaTime * 2f;
if (__instance._speedCounter < 1.0)
{
return(false);
}
--__instance._speedCounter;
__instance.AverageMovementSpeed = __instance._distanceTraveled * 2f;
__instance._distanceTraveled = 0.0f;
}
}
}
return(false);
}
catch (Exception e)
{
Log.Error(e.ToString());
wasChanged = false;
return(true);
}
}
private void SetPlayerDeathTags(HumanBodyTakeDamage humanBodyTakeDamage, DamageEvent damage, ref DeathTags tags)
{
Metabolism metabolism = damage.attacker.id.GetComponent <Metabolism>();
FallDamage fallDamage = damage.attacker.id.GetComponent <FallDamage>();
tags.killed = damage.victim.client?.netUser.displayName ?? UNKNOWN;
tags.killedId = damage.victim.client?.netUser.userID.ToString() ?? UNKNOWN;
tags.bodypart = damage.bodyPart.GetNiceName();
if (damage.attacker.id.GetComponentInChildren <BasicWildLifeAI>())
{
tags.deathType = DeathTypes.entity;
var mutant = damage.attacker.idMain?.ToString().Contains("Mutant") ?? false;
if (damage.attacker.id.GetComponent <WolfAI>())
{
tags.killer = (mutant) ? "Mutant Wolf" : "Wolf";
return;
}
if (damage.attacker.id.GetComponent <BearAI>())
{
tags.killer = (mutant) ? "Mutant Bear" : "Bear";
return;
}
}
if (damage.attacker.id.GetComponent <DeployableObject>())
{
tags.deathType = DeathTypes.human;
tags.killerId = damage.attacker.id.GetComponent <DeployableObject>().creatorID.ToString();
if (damage.attacker.id.GetComponent <SpikeWall>())
{
tags.weapon = "Spike Wall";
}
else if (damage.attacker.id.GetComponent <TimedExplosive>())
{
tags.weapon = "Explosive Charge";
}
return;
}
if (damage.attacker.id.GetComponent <TimedGrenade>())
{
tags.deathType = DeathTypes.human;
tags.weapon = "F1 Grenade";
return;
}
if (damage.attacker.client == damage.victim.client)
{
tags.deathType = DeathTypes.suicide;
tags.killerId = tags.killedId;
float fallDmg = (float)fallDamage?.GetType().GetField("injuredTime", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(fallDamage);
if (damage.damageTypes == 0 && WaterLine.Height != 0f && humanBodyTakeDamage.transform.position.y <= WaterLine.Height)
{
tags.weapon = tags.weapon.Equals(UNKNOWN) ? "Water" : tags.weapon;
}
else if (damage.attacker.id.GetComponent <Radiation>() && metabolism.GetRadLevel() >= 500f)
{
tags.weapon = tags.weapon.Equals(UNKNOWN) ? "Radiation" : tags.weapon;
}
else if (fallDamage != null && fallDamage.GetLegInjury() >= 1f)
{
tags.weapon = tags.weapon.Equals(UNKNOWN) ? "Falling" : tags.weapon;
}
else if (humanBodyTakeDamage.IsBleeding())
{
tags.weapon = tags.weapon.Equals(UNKNOWN) ? "Bleeding" : tags.weapon;
}
if (tags.weapon.Equals(UNKNOWN))
{
tags.weapon = "Suicide";
}
}
else if (damage.victim.client && damage.attacker.client)
{
tags.deathType = DeathTypes.human;
if (humanBodyTakeDamage.IsBleeding())
{
tags.weapon = tags.weapon.Equals(UNKNOWN) ? "Bleeding" : tags.weapon;
}
}
}
