public void OnTileEntityChanged(TileEntity _te, int _dataObject)
{
Log.Out(_te.GetTileEntityType().ToString() + " - " + _dataObject);
TileEntityPoweredBlock poweredBlock = _te as TileEntityPoweredBlock;
if (poweredBlock.PowerUsed != this.powerUsed)
{
this.powerUsed = poweredBlock.PowerUsed;
Log.Out("Power Block Used:" + this.powerUsed.ToString());
}
if (poweredBlock.RequiredPower != this.requiredPower)
{
this.requiredPower = poweredBlock.RequiredPower;
Log.Out("Power Block Required:" + this.requiredPower.ToString());
}
if (poweredBlock.IsToggled != this.isToggled)
{
this.isToggled = poweredBlock.IsToggled;
Log.Out("Power Block Toggled:" + this.isToggled.ToString());
}
if (poweredBlock.IsPowered != this.isPowered)
{
this.isPowered = poweredBlock.IsPowered;
Log.Out("Power Block Powered:" + this.isPowered.ToString());
}
}
public void OnTileEntityChanged(TileEntity _te, int _dataObject)
{
Log.Out(_te.GetTileEntityType().ToString() + " - " + _dataObject);
TileEntityPowered powered = _te as TileEntityPowered;
if (powered.IsPowered != this.isPowered)
{
bool oldIsPowered = this.isPowered;
this.isPowered = powered.IsPowered;
//notify handlers
API.Events.NotifyPoweredIsPoweredChangeHandlers(powered, oldIsPowered, this.isPowered);
}
if (powered.PowerUsed != this.powerUsed)
{
int oldPowerUsed = this.powerUsed;
this.powerUsed = powered.PowerUsed;
//notify handlers
API.Events.NotifyPoweredPowerUsedChangeHandlers(powered, oldPowerUsed, this.powerUsed);
}
if (powered.RequiredPower != this.requiredPower)
{
int oldRequiredPower = this.requiredPower;
this.requiredPower = powered.RequiredPower;
//notify handlers
API.Events.NotifyPoweredRequiredPowerChangeHandlers(powered, oldRequiredPower, this.requiredPower);
}
}
public static string ToStringBetter([CanBeNull] this TileEntity te)
{
if (te == null)
{
return("TileEntity (null)");
}
return($"{te.GetType()} ({te.GetTileEntityType()}) [{te.ToWorldPos()}]");
}
public new void OnTileEntityChanged(TileEntity _te, int _dataObject)
{
base.OnTileEntityChanged(_te, _dataObject);
Log.Out(_te.GetTileEntityType().ToString() + " - " + _dataObject);
TileEntityPoweredTrigger trigger = _te as TileEntityPoweredTrigger;
if (trigger.IsTriggered != this.isTriggered)
{
bool oldIsTriggered = this.isTriggered;
this.isTriggered = trigger.IsTriggered;
API.Events.NotifyPoweredTriggerIsTriggeredHandlers(trigger, oldIsTriggered, this.isTriggered);
}
if (trigger.Property1 != this.property1)
{
byte oldProperty1 = this.property1;
this.property1 = trigger.Property1;
API.Events.NotifyPoweredTriggerProperty1ChangeHandlers(trigger, oldProperty1, this.property1);
}
if (trigger.Property2 != this.property2)
{
byte oldProperty2 = this.property2;
this.property2 = trigger.Property2;
API.Events.NotifyPoweredTriggerProperty2ChangeHandlers(trigger, oldProperty2, this.property2);
}
if (trigger.TargetSelf != this.targetSelf)
{
bool oldTargetSelf = this.targetSelf;
this.targetSelf = trigger.TargetSelf;
API.Events.NotifyPoweredTriggerTargetSelfChangeHandlers(trigger, oldTargetSelf, this.targetSelf);
}
if (trigger.TargetAllies != this.targetAllies)
{
bool oldTargetAllies = this.targetAllies;
this.targetAllies = trigger.TargetAllies;
API.Events.NotifyPoweredTriggerTargetAlliesChangeHandlers(trigger, oldTargetAllies, this.targetAllies);
}
if (trigger.TargetStrangers != this.targetStrangers)
{
bool oldTargetStrangers = this.targetStrangers;
this.targetStrangers = trigger.TargetStrangers;
API.Events.NotifyPoweredTriggerTargetStrangersChangeHandlers(trigger, oldTargetStrangers, this.targetStrangers);
}
if (trigger.TargetZombies != this.targetZombies)
{
bool oldTargetZombies = this.targetZombies;
this.targetZombies = trigger.TargetZombies;
API.Events.NotifyPoweredTriggerTargetZombieChangeHandlers(trigger, oldTargetZombies, this.targetZombies);
}
}
/// <summary>
/// Deletes the given tile entity from it's chunk and creates a new one based on the tile entity type
/// </summary>
private void RecreateTileEntity([NotNull] TileEntity tileEntity)
{
var chunk = tileEntity.GetChunk();
// Prevent further errors on client updates; crucial when removing power item!
tileEntity.SetDisableModifiedCheck(true);
// Remove corrupt tile entity
chunk.RemoveTileEntity(World, tileEntity);
// Remove power item
var tePowered = tileEntity as TileEntityPowered;
var powerItem = tePowered?.GetPowerItem();
if (powerItem != null)
{
PowerManager.Instance.RemovePowerNode(powerItem);
}
// Create new tile entity
var newTileEntity = TileEntity.Instantiate(tileEntity.GetTileEntityType(), chunk);
newTileEntity.localChunkPos = tileEntity.localChunkPos;
chunk.AddTileEntity(newTileEntity);
// Recreate power item if necessary
var newPowered = newTileEntity as TileEntityPowered;
if (newPowered != null)
{
// Restore old PowerItemType and TriggerType values
if (tePowered != null)
{
newPowered.PowerItemType = tePowered.PowerItemType;
}
// fancy new C#7 syntax, isn't it? :)
if (tileEntity is TileEntityPoweredTrigger teTrigger && newPowered is TileEntityPoweredTrigger newTrigger)
{
newTrigger.TriggerType = teTrigger.TriggerType;
}
// Create power item according to PowerItemType and TriggerType
newPowered.InitializePowerData();
// Wires to the corrupt block are cut and not restored. We could try to reattach everything, but meh...
}
var newPowerItem = newPowered?.GetPowerItem();
Log.Debug($"[{tileEntity.ToWorldPos()}] Replaced old {tileEntity.GetType()} with new {newTileEntity.GetType()}" +
$"{(newPowerItem != null ? " and new power item " + newPowerItem.GetType() : "")}.");
}
internal void Write(BinaryWriter writer)
{
writer.Write(SaveVersionConstants.ENTITY_CREATION_DATA);
writer.Write(entityClass.Get());
writer.Write(id.Get());
writer.Write(lifetime.Get());
writer.Write(pos.x.Get());
writer.Write(pos.y.Get());
writer.Write(pos.z.Get());
writer.Write(rot.x.Get());
writer.Write(rot.y.Get());
writer.Write(rot.z.Get());
writer.Write(onGround.Get());
bodyDamage.Write(writer);
writer.Write(stats != null);
if (stats != null)
{
stats.Write(writer);
}
writer.Write(deathTime.Get());
writer.Write(lootContainer != null);
if (lootContainer != null)
{
writer.Write((int)lootContainer.GetTileEntityType());
lootContainer.Write(writer);
}
writer.Write(homePosition.x.Get());
writer.Write(homePosition.y.Get());
writer.Write(homePosition.z.Get());
writer.Write(homeRange.Get());
writer.Write((byte)spawnerSource);
if (entityClass.Get() == Utils.GetMonoHash("item"))
{
writer.Write(belongsPlayerId.Get());
itemStack.Write(writer);
writer.Write((sbyte)0);
}
else if (entityClass.Get() == Utils.GetMonoHash("fallingBlock"))
{
writer.Write(blockValue.Get());
}
else if (entityClass.Get() == Utils.GetMonoHash("fallingTree"))
{
writer.Write(blockPosition.x.Get());
writer.Write(blockPosition.y.Get());
writer.Write(blockPosition.z.Get());
writer.Write(fallTreeDir.x.Get());
writer.Write(fallTreeDir.y.Get());
writer.Write(fallTreeDir.z.Get());
}
else if ((entityClass.Get() == Utils.GetMonoHash("playerMale")) || (entityClass.Get() == Utils.GetMonoHash("playerFemale")))
{
holdingItem.Write(writer);
writer.Write((byte)teamNumber.Get());
writer.Write(entityName.Get());
writer.Write(skinTexture.Get());
writer.Write(playerProfile != null);
if (playerProfile != null)
{
playerProfile.Write(writer);
}
}
int num = (int)entityData.Length;
writer.Write((ushort)num);
if (num > 0)
{
writer.Write(entityData.ToArray());
}
writer.Write(traderData != null);
if (traderData != null)
{
writer.Write((int)traderData.GetTileEntityType());
traderData.Write(writer);
}
}
public void OnTileEntityChanged(TileEntity _te, int _dataObject)
{
Log.Out(_te.GetTileEntityType().ToString() + " - " + _dataObject);
}
public BCMTileEntity(Vector3i pos, [NotNull] TileEntity te)
{
Type = te.GetTileEntityType().ToString();
Pos = new BCMVector3(pos);
}
public void OnTileEntityChanged(TileEntity _te, int _dataObject)
{
if (_te == null)
{
return;
}
TileEntityTrader npc = _te as TileEntityTrader;
bool primaryChanged = false;
bool stashChanged = false;
//check for inventory changes
if (npc.TraderData.PrimaryInventory.Count != this.PrimaryInventory.Count)
{
//certainly have a change
primaryChanged = true;
}
else
{
//check to make sure everything is still the same
for (int i = 0; i < npc.TraderData.PrimaryInventory.Count; i++)
{
ItemStack oldItem = this.PrimaryInventory [i];
ItemStack currentItem = npc.TraderData.PrimaryInventory [i];
if (oldItem.itemValue.type != currentItem.itemValue.type || oldItem.count != currentItem.count)
{
primaryChanged = true;
break;
}
}
}
if (npc.TraderData.TierItemGroups.Count != this.TierGroupItems.Count)
{
stashChanged = true;
}
else
{
for (int grp = 0; grp < npc.TraderData.TierItemGroups.Count; grp++)
{
ItemStack[] oldItemGroup = this.TierGroupItems [grp];
ItemStack[] itemGroup = npc.TraderData.TierItemGroups [grp];
for (int i = 0; i < itemGroup.Length; i++)
{
if (oldItemGroup [i].itemValue.type != itemGroup [i].itemValue.type || oldItemGroup [i].count != itemGroup [i].count)
{
stashChanged = true;
break;
}
}
}
}
Entity e = GameManager.Instance.World.GetEntity(_te.entityId);
if (primaryChanged)
{
API.Events.NotifyTraderPrimaryInventoryChangedHandlers(e as EntityNPC, this.lastPrimaryInventory);
}
if (stashChanged)
{
API.Events.NotifyTraderSecretStashChangedHandlers(e as EntityNPC, this.lastTierGroupItems);
}
SetHistory(npc);
Log.Out(_te.GetTileEntityType().ToString() + " - " + primaryChanged);
}
