public UnturnedStructureBuildable(StructureData data, StructureDrop drop) : this(drop)
{
if (data != drop.GetServersideData())
{
throw new Exception($"{nameof(data)} is incorrect structure data for {nameof(drop)}");
}
}
private void Events_OnStructureTransformed(StructureData data, StructureDrop drop)
{
var @event =
new UnturnedStructureTransformedEvent(new UnturnedStructureBuildable(data, drop));
Emit(@event);
}
private void OnTransformStructureRequested(CSteamID instigator, byte x, byte y, uint instanceID,
ref Vector3 point, ref byte angle_x, ref byte angle_y, ref byte angle_z, ref bool shouldAllow)
{
StructureRegion region = StructureManager.regions[x, y];
int index = region.structures.FindIndex(k => k.instanceID == instanceID);
StructureData data = region.structures[index];
StructureDrop drop = region.drops[index];
Player nativePlayer = Provider.clients.FirstOrDefault(x => x?.playerID.steamID == instigator)?.player;
UnturnedPlayer player = nativePlayer == null ? null : new UnturnedPlayer(nativePlayer);
UnturnedStructureTransformingEvent @event = new UnturnedStructureTransformingEvent(
new UnturnedStructureBuildable(data, drop), player, instigator, point,
Quaternion.Euler(angle_x * 2, angle_y * 2, angle_z * 2));
Emit(@event);
shouldAllow = [email protected];
point = @event.Point;
Vector3 eulerAngles = @event.Rotation.eulerAngles;
angle_x = MeasurementTool.angleToByte(Mathf.RoundToInt(eulerAngles.x / 2f) * 2);
angle_y = MeasurementTool.angleToByte(Mathf.RoundToInt(eulerAngles.y / 2f) * 2);
angle_z = MeasurementTool.angleToByte(Mathf.RoundToInt(eulerAngles.z / 2f) * 2);
}
private void Events_OnStructureDestroyed(StructureData data, StructureDrop drop)
{
UnturnedStructureDestroyedEvent @event =
new UnturnedStructureDestroyedEvent(new UnturnedStructureBuildable(data, drop));
Emit(@event);
}
private void Events_OnStructureTransformed(StructureDrop drop)
{
var player = GetUnturnedPlayer(s_CurrentTransformingPlayer);
var @event = new UnturnedStructureTransformedEvent(new UnturnedStructureBuildable(drop), player);
Emit(@event);
}
private void StructureSpawned(StructureRegion region, StructureDrop drop)
{
var data = region.structures.Find(k => k.instanceID == drop.instanceID);
var build = new StructureBuildable(data, drop);
m_StructureBuildables.Add(build.InstanceId, build);
m_DeferredAdd.Enqueue(build);
}
private static void DestroyStructure(StructureRegion region, ushort index)
{
ThreadUtil.assertIsGameThread();
StructureData data = region.structures[index];
StructureDrop drop = region.drops[index];
OnStructureDestroyed?.Invoke(data, drop);
}
public UnturnedStructureBuildable(StructureDrop drop) : base(
new UnturnedBuildableAsset(drop.GetServersideData().structure.asset),
new UnityTransform(drop.model),
new UnturnedBuildableState(drop.GetServersideData().structure),
new UnturnedBuildableOwnership(drop.GetServersideData()),
drop.instanceID.ToString())
{
StructureDrop = drop;
}
private void Events_OnStructureTransformed(StructureData data, StructureDrop drop, CSteamID instigatorSteamId)
{
var nativePlayer = PlayerTool.getPlayer(instigatorSteamId);
var player = GetUnturnedPlayer(nativePlayer);
var @event = new UnturnedStructureTransformedEvent(new UnturnedStructureBuildable(data, drop),
instigatorSteamId, player !);
Emit(@event);
}
public UnturnedStructureBuildable(StructureData data, StructureDrop drop)
{
StructureData = data;
StructureDrop = drop;
Asset = new UnturnedBuildableAsset(data.structure.asset);
Transform = new UnityTransform(drop.model);
State = new UnturnedBuildableState(data.structure);
Ownership = new UnturnedBuildableOwnership(data);
BuildableInstanceId = drop.instanceID.ToString();
}
private void OnSalvageStructureRequested(CSteamID steamID, byte x, byte y, ushort index, ref bool shouldAllow)
{
StructureData data = StructureManager.regions[x, y].structures[index];
StructureDrop drop = StructureManager.regions[x, y].drops[index];
UnturnedStructureSalvagingEvent @event =
new UnturnedStructureSalvagingEvent(new UnturnedStructureBuildable(data, drop));
Emit(@event);
shouldAllow = [email protected];
}
private void OnSalvageStructureRequested(StructureDrop drop, SteamPlayer instigator, ref bool shouldAllow)
{
var player = GetUnturnedPlayer(instigator);
var @event = new UnturnedStructureSalvagingEvent(new UnturnedStructureBuildable(drop), player !)
{
IsCancelled = !shouldAllow
};
Emit(@event);
shouldAllow = [email protected];
}
public static void AskTransformStructure(byte x, byte y, uint instanceID)
{
ThreadUtil.assertIsGameThread();
if (!StructureManager.tryGetRegion(x, y, out StructureRegion region))
{
return;
}
int index = region.structures.FindIndex(k => k.instanceID == instanceID);
StructureData data = region.structures[index];
StructureDrop drop = region.drops[index];
OnStructureTransformed?.Invoke(data, drop);
}
private static void DropStructure(Structure structure, Vector3 point, Quaternion rotation, ulong owner,
ulong group, bool __result, uint ___instanceCount)
{
if (__result)
{
if (Regions.tryGetCoordinate(point, out byte b, out byte b2))
{
if (StructureManager.tryGetRegion(b, b2, out StructureRegion region))
{
StructureData data = region.structures.LastOrDefault();
StructureDrop drop = region.drops.LastOrDefault();
if (data?.instanceID == ___instanceCount && drop?.instanceID == ___instanceCount)
{
OnStructureDeployed?.Invoke(data, drop);
}
}
}
}
}
private void OnStructureDamaged(CSteamID instigatorSteamID, Transform structureTransform, ref ushort pendingTotalDamage, ref bool shouldAllow, EDamageOrigin damageOrigin)
{
SteamPlayer steamPlayer;
if (!Configuration.Instance.AllowRaid && (steamPlayer = PlayerTool.getSteamPlayer(instigatorSteamID)) != null)
{
StructureDrop drop = StructureManager.FindStructureByRootTransform(structureTransform);
StructureData data = drop.GetServersideData();
// return if structure owner is instigator
if (data.owner == instigatorSteamID.m_SteamID || data.group == steamPlayer.player.quests.groupID.m_SteamID)
{
return;
}
// return if structure owner is offline
if (!Provider.clients.Exists(x => x.playerID.steamID.m_SteamID == data.owner || x.player.quests.groupID.m_SteamID == data.group))
{
return;
}
this.StartPlayerRaid(instigatorSteamID);
}
}
private void Events_OnStructureDeployed(StructureRegion region, StructureDrop drop)
{
var @event = new UnturnedStructureDeployedEvent(new UnturnedStructureBuildable(drop));
Emit(@event);
}
/// <summary>
/// Creates a new instance of <see cref="StructureBuildable"/> with the specified data and drop.
/// </summary>
/// <param name="data">The data to add.</param>
/// <param name="drop">The drop to add.</param>
public StructureBuildable(StructureData data, StructureDrop drop)
{
m_StructureData = data;
m_StructureDrop = drop;
}
