public void Execute(IRocketPlayer caller, string[] args)
{
PlayerLook look = ((UnturnedPlayer)caller).Player.look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE_INTERACT))
{
InteractableDoorHinge hinge = hit.transform.GetComponent <InteractableDoorHinge>();
if (hinge != null)
{
InteractableDoor door = hinge.door;
bool open = !door.isOpen;
Util.ToggleDoor(door, open);
UnturnedChat.Say(caller, Util.Translate("door_toggle", open ? "opened" : "closed"));
if (open && BreakAndEnter.instance.Configuration.Instance.AutoCloseDoors)
{
BreakAndEnter.instance.AutoCloseDoor(door);
}
}
else
{
UnturnedChat.Say(caller, Util.Translate("invalid_door"));
}
}
public void Execute(IRocketPlayer caller, string[] args)
{
Player player = ((UnturnedPlayer)caller).Player;
PlayerLook look = player.look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE_INTERACT))
{
InteractableStorage storage = hit.transform.GetComponent <InteractableStorage>();
if (storage != null)
{
storage.isOpen = true;
storage.opener = player;
player.inventory.isStoring = true;
player.inventory.isStorageTrunk = false;
player.inventory.storage = storage;
player.inventory.updateItems(PlayerInventory.STORAGE, storage.items);
player.inventory.sendStorage();
UnturnedChat.Say(caller, Util.Translate("storage_open"));
}
else
{
UnturnedChat.Say(caller, Util.Translate("invalid_storage"));
}
}
void CollisionForPushBox()
{
foreach (PhysicsComponent physicsEntity in m_PhysicsEntities)
{
foreach (PhysicsComponent other in m_PhysicsEntities)
{
if (physicsEntity == other)
{
continue;
}
BoxOverlap overlap = PhysicsUtility.GetOverlapOfBox(physicsEntity.PushBox, other.PushBox);
if (PhysicsUtility.AreBoxesIntersecting(physicsEntity.PushBox, other.PushBox))
{
physicsEntity.transform.Translate(new Vector3(overlap.x, 0) * 0.5f);
other.transform.Translate(new Vector3(overlap.x, 0) * -0.5f);
}
return;
}
}
}
public Ball(PhysicsBody physicsBody)
{
m_physicsBody = physicsBody;
this.TextureInfo = new TextureInfo(new Texture2D("Application/images/ball.png", false));
this.Scale = this.TextureInfo.TextureSizef;
this.Pivot = new Sce.PlayStation.Core.Vector2(0.5f, 0.5f);
this.Position = new Sce.PlayStation.Core.Vector2(
Director.Instance.GL.Context.GetViewport().Width / 2 - Scale.X / 2,
Director.Instance.GL.Context.GetViewport().Height / 2 - Scale.Y / 2);
//Right angles are exceedingly boring, so make sure we dont start on one
//So if our Random angle is between 90 +- 25 degrees or 270 +- 25 degrees
//we add 25 degree to value, ie, making 90 into 115 instead
System.Random rand = new System.Random();
float angle = (float)rand.Next(0, 360);
if ((angle % 90) <= 25)
{
angle += 25.0f;
}
this.m_physicsBody.Velocity = new Vector2(0.0f, BALL_VELOCITY).Rotate(PhysicsUtility.GetRadian(angle));
Scheduler.Instance.ScheduleUpdateForTarget(this, 0, false);
}
public void Execute(IRocketPlayer caller, string[] args)
{
PlayerLook look = ((UnturnedPlayer)caller).Player.look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE_INTERACT))
{
InteractableDoorHinge hinge = hit.transform.GetComponent <InteractableDoorHinge>();
if (hinge != null)
{
InteractableDoor door = hinge.door;
bool open = !door.isOpen;
BarricadeManager.tryGetInfo(door.transform, out byte x, out byte y, out ushort plant, out ushort index, out BarricadeRegion region);
door.updateToggle(open);
BarricadeManager.instance.channel.send("tellToggleDoor", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
plant,
index,
open
});
UnturnedChat.Say(caller, Util.Translate("door_toggle", open ? "opened" : "closed"));
}
else
{
UnturnedChat.Say(caller, Util.Translate("invalid_door"));
}
}
// Token: 0x06000093 RID: 147 RVA: 0x00006864 File Offset: 0x00004A64
public static bool NoShootthroughthewalls(Transform transform)
{
Vector3 direction = AimbotCoroutines.GetAimPosition(transform, "Skull") - Player.player.look.aim.position;
RaycastHit raycastHit;
return(PhysicsUtility.raycast(new Ray(Player.player.look.aim.position, direction), out raycastHit, direction.magnitude, RayMasks.DAMAGE_CLIENT, QueryTriggerInteraction.UseGlobal) && raycastHit.transform.IsChildOf(transform));
}
public InputInfo getInput(bool doOcclusionCheck)
{
if (this.inputs != null && this.inputs.Count > 0)
{
InputInfo inputInfo = this.inputs.Dequeue();
if (doOcclusionCheck && !this.hasDoneOcclusionCheck)
{
this.hasDoneOcclusionCheck = true;
if (inputInfo != null)
{
Vector3 vector = inputInfo.point - base.player.look.aim.position;
float magnitude = vector.magnitude;
Vector3 vector2 = vector / magnitude;
if (magnitude > 0.025f)
{
PhysicsUtility.raycast(new Ray(base.player.look.aim.position, vector2), out this.obstruction, magnitude - 0.025f, RayMasks.DAMAGE_SERVER, 0);
if (this.obstruction.transform != null)
{
return(null);
}
PhysicsUtility.raycast(new Ray(base.player.look.aim.position + vector2 * (magnitude - 0.025f), -vector2), out this.obstruction, magnitude - 0.025f, RayMasks.DAMAGE_SERVER, 0);
if (this.obstruction.transform != null)
{
return(null);
}
}
}
}
return(inputInfo);
}
return(null);
}
public override void tick()
{
if (!base.player.equipment.isEquipped)
{
return;
}
if ((base.channel.isOwner || Provider.isServer) && this.isSwinging && this.isThrowable)
{
Vector3 vector = base.player.look.aim.position;
Vector3 forward = base.player.look.aim.forward;
RaycastHit raycastHit;
if (!PhysicsUtility.raycast(new Ray(vector, forward), out raycastHit, 1f, RayMasks.DAMAGE_SERVER, 0))
{
vector += forward;
}
this.toss(vector, forward);
if (base.channel.isOwner)
{
int num;
if (Provider.provider.statisticsService.userStatisticsService.getStatistic("Found_Throwables", out num))
{
Provider.provider.statisticsService.userStatisticsService.setStatistic("Found_Throwables", num + 1);
}
}
else
{
base.channel.send("askToss", ESteamCall.NOT_OWNER, ESteamPacket.UPDATE_UNRELIABLE_BUFFER, new object[]
{
vector,
forward
});
}
this.isSwinging = false;
}
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var look = player.Look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE))
{
InteractableStorage storage = hit.transform.GetComponent <InteractableStorage>();
if (storage != null)
{
storage.isOpen = true;
storage.opener = player.UnturnedPlayer;
player.Inventory.isStoring = true;
player.Inventory.isStorageTrunk = false;
player.Inventory.storage = storage;
player.Inventory.updateItems(PlayerInventory.STORAGE, storage.items);
player.Inventory.sendStorage();
EssLang.Send(src, "STORAGE_OPEN");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("STORAGE_INVALID"));
}
}
private void Register()
{
barrier = PhysicsUtility.Overlap <BarrierObject>(Target, Constants.CellMask);
if (barrier)
{
barrier.Charges++;
}
}
public void SetFireAtDirection(Vector2 fireAtDirection, int shotSpeed, int aimOffset)
{
vectorMagnitude = PhysicsUtility.VectorMagnitude(GetBoundingBox().X, fireAtDirection.X, GetBoundingBox().Y, fireAtDirection.Y);
shotLenX = Math.Max((int)fireAtDirection.X, GetBoundingBox().X) - Math.Min((int)fireAtDirection.X, GetBoundingBox().X);
shotLenY = Math.Max((int)fireAtDirection.Y, GetBoundingBox().Y) - Math.Min((int)fireAtDirection.Y, GetBoundingBox().Y);
shotDirX = (fireAtDirection.X - GetBoundingBox().X + aimOffset) / vectorMagnitude * shotSpeed;
shotDirY = (fireAtDirection.Y - GetBoundingBox().Y + aimOffset) / vectorMagnitude * shotSpeed;
}
// Update is called once per frame
private void Update()
{
if (Input.GetKeyDown(KeyCode.M))
{
int result = PhysicsUtility.OverlapSphereNonAlloc(m_point.position, 10f, ref m_cols, 1 << LayerMask.NameToLayer("Default"));
Debug.Log(result);
}
}
Vector3 NormalSpawnPos()
{
Vector3 vector = this.LinearRand();
if (this._spawnOnFloor)
{
PhysicsUtility.GetFloorPoint(vector, 10f, 20f, this._floorLayer.value, out vector);
}
return(vector);
}
Vector3 FixedSpawnPos()
{
Vector3 position = base.transform.position;
if (this._spawnOnFloor)
{
PhysicsUtility.GetFloorPoint(position, 10f, 20f, this._floorLayer.value, out position);
}
return(position);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var look = player.Look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE | RayMasks.STRUCTURE))
{
Interactable2SalvageBarricade barri = hit.transform.GetComponent <Interactable2SalvageBarricade>();
Interactable2SalvageStructure struc = hit.transform.GetComponent <Interactable2SalvageStructure>();
if (barri != null)
{
BarricadeManager.tryGetInfo(barri.root, out byte x, out byte y, out ushort plant, out ushort index, out BarricadeRegion region);
region.barricades.RemoveAt(index);
BarricadeManager manager = (BarricadeManager)typeof(BarricadeManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
manager.channel.send("tellTakeBarricade", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
plant,
index
});
EssLang.Send(src, "BARRICADE_REMOVED");
return(CommandResult.Success());
}
else if (struc != null)
{
StructureManager.tryGetInfo(struc.transform, out byte x, out byte y, out ushort index, out StructureRegion region);
region.structures.RemoveAt(index);
StructureManager manager = (StructureManager)typeof(StructureManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
manager.channel.send("tellTakeStructure", ESteamCall.ALL, x, y, StructureManager.STRUCTURE_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
index,
(region.drops[index].model.position - player.UnturnedPlayer.transform.position).normalized * 100f
});
EssLang.Send(src, "STRUCTURE_REMOVED");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("DESTROY_INVALID"));
}
}
public void Execute(IRocketPlayer caller, string[] args)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (PhysicsUtility.raycast(new Ray(player.Player.look.aim.position, player.Player.look.aim.forward), out RaycastHit hit, 10f, RayMasks.BARRICADE_INTERACT))
{
byte x;
byte y;
ushort plant;
ushort index;
BarricadeRegion bRegion;
StructureRegion sRegion;
InteractableVehicle vehicle;
ulong ownerId;
var instance = ModerationPlugin.Instance;
if (BarricadeManager.tryGetInfo(hit.transform, out x, out y, out plant, out index, out bRegion))
{
ownerId = bRegion.barricades[index].owner;
}
else if (StructureManager.tryGetInfo(hit.transform, out x, out y, out index, out sRegion))
{
ownerId = sRegion.structures[index].owner;
}
else if ((vehicle = hit.transform.GetComponent <InteractableVehicle>()) != null && vehicle.isLocked)
{
ownerId = vehicle.lockedOwner.m_SteamID;
}
else
{
UnturnedChat.Say(caller, instance.Translate("CheckownerFail"));
return;
}
ThreadPool.QueueUserWorkItem((i) =>
{
var owner = instance.DatabaseManager.GetPlayer(ownerId);
if (owner == null)
{
owner = instance.DatabaseManager.CreatePlayer(new Models.Player(ownerId, ownerId.GetIP()));
}
TaskDispatcher.QueueOnMainThread(() =>
{
UnturnedChat.Say(caller, instance.Translate("CheckownerSuccess", owner.PlayerName, owner.PlayerId, owner.IsBanned(out var ban)));
});
});
}
}
public Ray(Vector2 start, Vector2 direction, double wavelength)
{
this.start = start;
this.direction = direction;
this.wavelength = wavelength;
color = PhysicsUtility.GetColor(wavelength);
collisionPoints = new List <Vector2> {
start
};
}
private void Burst()
{
var from = (Vector2)transform.position + .5f * Constants.Directions[Direction];
var to = from + Distance * Constants.Directions[Direction];
PhysicsUtility.OverlapArea(units, from, to, Constants.UnitMask);
foreach (var unit in units)
{
unit.Kill();
}
}
protected override async UniTask OnExecuteAsync()
{
if (Context.Parameters.Length > 2)
{
throw new CommandWrongUsageException(Context);
}
await UniTask.SwitchToMainThread();
float radius = 10f;
if (Context.Parameters.Length > 0)
{
string radiusTerm = Context.Parameters[0];
if (!float.TryParse(radiusTerm, out radius))
{
throw new UserFriendlyException(m_StringLocalizer["explode:bad_radius", new { Radius = radiusTerm }]);
}
}
float damage = 200f;
if (Context.Parameters.Length > 1)
{
string damageTerm = Context.Parameters[1];
if (!float.TryParse(damageTerm, out damage))
{
throw new UserFriendlyException(m_StringLocalizer["explode:bad_damage", new { Damage = damageTerm }]);
}
}
UnturnedUser uPlayer = (UnturnedUser)Context.Actor;
Transform aim = uPlayer.Player.Player.look.aim;
if (!PhysicsUtility.raycast(new Ray(aim.position, aim.forward), out RaycastHit hit, 512f,
RayMasks.DAMAGE_SERVER))
{
throw new UserFriendlyException(m_StringLocalizer["explode:failure"]);
}
if (hit.transform == null)
{
throw new UserFriendlyException(m_StringLocalizer["explode:failure"]);
}
await UniTask.SwitchToMainThread();
EffectManager.sendEffect(20, EffectManager.MEDIUM, hit.point);
DamageTool.explode(hit.point, radius, EDeathCause.KILL, uPlayer.SteamId, damage, damage, damage, damage,
damage, damage, damage, damage, out List <EPlayerKill> kills);
await Context.Actor.PrintMessageAsync(m_StringLocalizer["explode:success"]);
}
public static RaycastInfo OriginalRaycast(Ray ray, float range, int mask)
{
RaycastHit hit;
PhysicsUtility.raycast(ray, out hit, range, mask, QueryTriggerInteraction.UseGlobal);
RaycastInfo raycastInfo = new RaycastInfo(hit);
raycastInfo.direction = ray.direction;
if (raycastInfo.transform != null)
{
if (raycastInfo.transform.CompareTag("Barricade"))
{
raycastInfo.transform = DamageTool.getBarricadeRootTransform(raycastInfo.transform);
}
else if (raycastInfo.transform.CompareTag("Structure"))
{
raycastInfo.transform = DamageTool.getStructureRootTransform(raycastInfo.transform);
}
if (raycastInfo.transform.CompareTag("Enemy"))
{
raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
}
if (raycastInfo.transform.CompareTag("Zombie"))
{
raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
}
if (raycastInfo.transform.CompareTag("Animal"))
{
raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
}
raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);
if (raycastInfo.transform.CompareTag("Vehicle"))
{
raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
}
if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
{
raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
}
else
{
raycastInfo.material = DamageTool.getMaterial(hit.point, raycastInfo.transform, raycastInfo.collider);
}
}
return(raycastInfo);
}
public void Execute(IRocketPlayer caller, string[] args)
{
Player player = ((UnturnedPlayer)caller).Player;
PlayerLook look = player.look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE | RayMasks.STRUCTURE))
{
Interactable2SalvageBarricade barri = hit.transform.GetComponent <Interactable2SalvageBarricade>();
Interactable2SalvageStructure struc = hit.transform.GetComponent <Interactable2SalvageStructure>();
if (barri != null)
{
BarricadeManager.tryGetInfo(barri.root, out byte x, out byte y, out ushort plant, out ushort index, out BarricadeRegion region);
region.barricades.RemoveAt(index);
BarricadeManager manager = (BarricadeManager)typeof(BarricadeManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
manager.channel.send("tellTakeBarricade", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
plant,
index
});
UnturnedChat.Say(caller, Util.Translate("barricade_removed"));
}
else if (struc != null)
{
StructureManager.tryGetInfo(struc.transform, out byte x, out byte y, out ushort index, out StructureRegion region);
region.structures.RemoveAt(index);
StructureManager manager = (StructureManager)typeof(StructureManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
manager.channel.send("tellTakeStructure", ESteamCall.ALL, x, y, StructureManager.STRUCTURE_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
index,
(region.drops[index].model.position - player.transform.position).normalized * 100f
});
UnturnedChat.Say(caller, Util.Translate("structure_removed"));
}
else
{
UnturnedChat.Say(caller, Util.Translate("invalid_destroy"));
}
}
public override void Do(PlayerObject player)
{
var target = PhysicsUtility.Overlap <StateComponent>
(
player.Movable.IntPosition + Constants.Directions[player.Movable.Direction],
Constants.CellMask
);
if (target)
{
target.State++;
}
}
public static InteractableDoorHinge Getdoor(UnturnedPlayer player)
{
PlayerLook look = player.Player.look;
RaycastHit raycastHit;
if (!PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out raycastHit, 100, RayMasks.BARRICADE, 0))
{
return(null);
}
InteractableDoorHinge interactabledoorhinge = raycastHit.transform.GetComponent <InteractableDoorHinge>();
return(interactabledoorhinge);
}
public void Execute(int i)
{
var outerEntity = Entities[i];
for (int j = i + 1; j < Colliders.Length; j++)
{
var innerEntity = Entities[j];
if (PhysicsUtility.DoCirclesOverlap
(
Translations[i].Value, Colliders[i].Radius,
Translations[j].Value, Colliders[j].Radius,
OverlapError, out float overlapAmount
))
{
CommandBuffer.AppendToBuffer(i, outerEntity, new CollisionInfoElementData
(
innerEntity,
Translations[j].Value,
Colliders[j].Group,
overlapAmount,
math.normalize(Translations[i].Value - Translations[j].Value)
));
CommandBuffer.AppendToBuffer(i, innerEntity, new CollisionInfoElementData
(
outerEntity,
Translations[i].Value,
Colliders[i].Group,
overlapAmount,
math.normalize(Translations[j].Value - Translations[i].Value)
));
if (Colliders[i].Group == CollisionLayer.Obstacle ||
Colliders[j].Group == CollisionLayer.Obstacle ||
Colliders[j].Group == Colliders[i].Group)
{
CommandBuffer.AddComponent <HandleCollisionWithBounceTag>(i, outerEntity);
CommandBuffer.AddComponent <RigidbodyCollisionTag>(i, outerEntity);
CommandBuffer.AddComponent <HandleCollisionWithBounceTag>(i, innerEntity);
CommandBuffer.AddComponent <RigidbodyCollisionTag>(i, innerEntity);
}
else
{
CommandBuffer.AddComponent <HaveBattleTag>(i, outerEntity);
CommandBuffer.AddComponent <HaveBattleTag>(i, innerEntity);
}
}
}
}
void ChatCmd_Look(BasePlayer player)
{
var lookObject = PhysicsUtility.GetLookTarget(player);
if (lookObject == null)
{
player.ChatMessage("Nothing found.");
return;
}
string layerName = LayerMask.LayerToName(lookObject.layer);
player.ChatMessage("[" + lookObject.tag + "] " + layerName + ": " + lookObject.name + " (" + String.Join(", ", (lookObject.transform.GetComponents <Component>().Select(comp => comp.GetType().Name)).ToArray()) + ")");
}
public override void Do(PlayerObject player)
{
var target = PhysicsUtility.Raycast <MovableComponent>
(
player.Movable.Position + .1f * Constants.Directions[player.Movable.Direction],
player.Movable.Direction,
Constants.UnitMask,
.6f
);
if (target && target.CanMove(player.Movable.Direction))
{
target.Move(player.Movable.Direction);
}
}
protected virtual void addFoliage(FoliageInfoAsset foliageAsset, float weightMultiplier)
{
if (foliageAsset == null)
{
return;
}
float num = 3.14159274f * this.brushRadius * this.brushRadius;
float newRadius = Mathf.Sqrt(foliageAsset.density / DevkitFoliageToolOptions.instance.densityTarget / 3.14159274f);
float num2;
if (!this.addWeights.TryGetValue(foliageAsset, out num2))
{
this.addWeights.Add(foliageAsset, 0f);
}
num2 += DevkitFoliageToolOptions.addSensitivity * num * this.brushStrength * weightMultiplier * Time.deltaTime;
if (num2 > 1f)
{
this.previewSamples.Clear();
int num3 = Mathf.FloorToInt(num2);
num2 -= (float)num3;
for (int i = 0; i < num3; i++)
{
float num4 = this.brushRadius * Random.value;
float brushAlpha = this.getBrushAlpha(num4);
if (Random.value >= brushAlpha)
{
float num5 = 6.28318548f * Random.value;
float num6 = Mathf.Cos(num5) * num4;
float num7 = Mathf.Sin(num5) * num4;
Ray ray;
ray..ctor(this.brushWorldPosition + new Vector3(num6, this.brushRadius, num7), new Vector3(0f, -1f, 0f));
RaycastHit raycastHit;
if (PhysicsUtility.raycast(ray, out raycastHit, this.brushRadius * 2f, (int)DevkitFoliageToolOptions.instance.surfaceMask, 0))
{
SphereVolume sphereVolume = new SphereVolume(raycastHit.point, newRadius);
if (foliageAsset.getInstanceCountInVolume(sphereVolume) <= 0)
{
if (Input.GetKey(323))
{
foliageAsset.addFoliageToSurface(raycastHit.point, raycastHit.normal, false, false);
}
}
}
}
}
}
this.addWeights[foliageAsset] = num2;
}
public static Transform GetStructureTransform(Player player, out StructureData structureData)
{
structureData = null;
RaycastHit hit;
if (PhysicsUtility.raycast(new Ray(player.look.aim.position, player.look.aim.forward), out hit, 3, RayMasks.STRUCTURE_INTERACT))
{
if (StructureManager.tryGetInfo(hit.transform, out _, out _, out ushort index, out StructureRegion region))
{
structureData = region.structures[index];
return(region.drops[index].model);
}
}
return(null);
}
public void VerifyLandedPos()
{
if (isClientVerify)
{
return;
}
Vector3 tilePos = StreamerManager.GetTilePosition(currentPos);
RaycastHit hit;
if (PhysicsUtility.Raycast(tilePos, Vector3.down, height, LayerConfig.ParachuteMask, out hit))
{
isClientVerify = true;
Vector3 hitRealpos = StreamerManager.GetRealPosition(hit.point);
height = serverPos.y - hitRealpos.y;
}
}
public void Execute()
{
for (int index = 0; index < Colliders.Length; index++)
{
if (PhysicsUtility.DoCirclesOverlap
(
Position, Radius,
Translations[index].Value, Colliders[index].Radius,
CollisionError, out _
))
{
IsSuitable[0] = false;
return;
}
}
}
