public virtual void Update(Timestep timestep, EntityUniverseFacade entityUniverseFacade, bool inherited = false)
{
if (TilePower == null)
{
return;
}
if (entityUniverseFacade.ReadTile(Location, TileAccessFlags.SynchronousWait, out var tile))
{
if (tile.Configuration.Components.Select <ChargeableComponent>().Any())
{
TilePower.GetPowerFromComponent(tile.Configuration.Components.Select <ChargeableComponent>().First());
}
else
{
entityUniverseFacade.RemoveEntity(Entity.Id);
return;
}
}
Universe = entityUniverseFacade;
if (!inherited)
{
Cycle.RunCycle(RunCycle);
}
}
public override void Update(Timestep timestep, EntityUniverseFacade entityUniverseFacade)
{
var locations = new List <Vector3I> {
new Vector3I(Location.X + 1, Location.Y, Location.Z),
new Vector3I(Location.X - 1, Location.Y, Location.Z),
new Vector3I(Location.X, Location.Y, Location.Z + 1),
new Vector3I(Location.X, Location.Y, Location.Z - 1)
};
var efficiency = 0;
foreach (var location in locations)
{
if (entityUniverseFacade.ReadTile(location, TileAccessFlags.SynchronousWait, out var tile))
{
var component = tile.Configuration.Components.Select <WaterWheelTileComponent>().FirstOrDefault();
if (component != default(WaterWheelTileComponent))
{
efficiency = component.Efficency;
break;
}
}
}
base.Update(timestep, entityUniverseFacade, efficiency);
}
public override void Update(Timestep timestep, EntityUniverseFacade entityUniverseFacade)
{
if (TilePower == null)
{
return;
}
Universe = entityUniverseFacade;
if (entityUniverseFacade.ReadTile(Location, TileAccessFlags.SynchronousWait, out var tile))
{
var config = GameContext.TileDatabase.GetTileConfiguration(Tile);
if (config.Components.Select <ChargeableComponent>().Any() && tile.Configuration.Code != "staxel.tile.Sky")
{
TilePower.GetPowerFromComponent(config.Components.Select <ChargeableComponent>().First());
}
else
{
var itemBlob = BlobAllocator.Blob(true);
itemBlob.SetString("kind", "staxel.item.Placer");
itemBlob.SetString("tile", Tile);
var item = GameContext.ItemDatabase.SpawnItemStack(itemBlob, null);
ItemEntityBuilder.SpawnDroppedItem(Entity, entityUniverseFacade, item, Entity.Physics.Position, new Vector3D(0, 1, 0), Vector3D.Zero, SpawnDroppedFlags.None);
entityUniverseFacade.RemoveEntity(Entity.Id);
return;
}
Cycle.RunCycle(RunCycle);
}
}
public override void Construct(Blob arguments, EntityUniverseFacade entityUniverseFacade)
{
Location = arguments.FetchBlob("location").GetVector3I();
Universe = entityUniverseFacade;
if (TilePower == null)
{
TilePower = new Power(ModelUpdate);
if (entityUniverseFacade.ReadTile(Location, TileAccessFlags.SynchronousWait, out var tile))
{
if (tile.Configuration.Components.Contains <ChargeableComponent>())
{
TilePower.GetPowerFromComponent(tile.Configuration.Components.Get <ChargeableComponent>());
}
Tile = tile.Configuration.Code;
}
}
if (arguments.Contains("charge"))
{
TilePower.SetPower(arguments.GetLong("charge"));
}
Entity.Physics.ForcedPosition(Location.ToTileCenterVector3D());
}
public override void Interact(Entity entity, EntityUniverseFacade facade, ControlState main, ControlState alt)
{
if (alt.DownClick)
{
if (facade.ReadTile(Location, TileAccessFlags.SynchronousWait, out var tile))
{
facade.DirectWriteTile(Location,
tile.Configuration == On ? Off.MakeTile(tile.Variant()) : On.MakeTile(tile.Variant()),
TileAccessFlags.SynchronousWait);
}
}
}
public override void ClientUpdate(Timestep timestep, Entity entity, AvatarController avatarController, EntityUniverseFacade facade)
{
Universe = facade;
if (Universe == null)
{
return;
}
var fail = true;
if (entity.Logic is ChargeableTileEntityLogic logic)
{
if (Universe.ReadTile(logic.Location, TileAccessFlags.None, out var tile))
{
if (tile.Configuration.Components.Select <ChargeableComponent>().Any())
{
if (ClientHook.NameTags.Contains(logic.Location))
{
if (NameTag == null)
{
NameTag = ClientContext.NameTagRenderer.RegisterNameTag(entity.Id);
}
NameTag.Setup(entity.Physics.Position, Constants.NameTagLowerOffset, logic.TilePower.CurrentCharge.ToString("N0") + " / " + logic.TilePower.MaxCharge.ToString("N0"), false, false, false);
fail = false;
}
}
}
if (entity.Logic is InnerCableTileEntityLogic innerLogic)
{
if (ClientHook.NameTags.Contains(innerLogic.Location))
{
if (NameTag == null)
{
NameTag = ClientContext.NameTagRenderer.RegisterNameTag(entity.Id);
}
NameTag.Setup(entity.Physics.Position, Constants.NameTagLowerOffset, innerLogic.TilePower.CurrentCharge.ToString("N0") + " / " + innerLogic.TilePower.MaxCharge.ToString("N0"), false, false, false);
fail = false;
}
}
if (fail)
{
if (NameTag != null)
{
ClientContext.NameTagRenderer.Unregister(NameTag);
NameTag = null;
}
}
}
}
public override void Construct(Blob arguments, EntityUniverseFacade entityUniverseFacade)
{
base.Construct(arguments, entityUniverseFacade);
if (entityUniverseFacade.ReadTile(Location, TileAccessFlags.SynchronousWait, out var tile))
{
if (tile.Configuration.Components.Select <GeneratorComponent>().Any())
{
var component = tile.Configuration.Components.Select <GeneratorComponent>().First();
_powerToGenerate = component.GeneratePerCycle;
}
}
}
public override void PreUpdate(Timestep timestep, EntityUniverseFacade universe)
{
base.PreUpdate(timestep, universe);
if (universe.ReadTile(Location, TileAccessFlags.SynchronousWait, out var tile))
{
if (tile.Configuration.Code == "staxel.tile.Sky")
{
CycleHook.RemoveCycle(Location);
universe.RemoveEntity(Entity.Id);
}
else
{
Cycle.RunCycle(RunCycle);
}
}
}
public List <Power> GetAdjacentTiles(bool ignoreFull = false)
{
var surrounding = new List <Vector3I> {
new Vector3I(Location.X + 1, Location.Y, Location.Z),
new Vector3I(Location.X - 1, Location.Y, Location.Z),
new Vector3I(Location.X, Location.Y + 1, Location.Z),
new Vector3I(Location.X, Location.Y - 1, Location.Z),
new Vector3I(Location.X, Location.Y, Location.Z + 1),
new Vector3I(Location.X, Location.Y, Location.Z - 1)
};
var output = new List <Power>();
foreach (var location in surrounding.ToArray())
{
if (_universe.ReadTile(location, TileAccessFlags.SynchronousWait, out var tile))
{
if (tile.Configuration.Code == "staxel.tile.Sky")
{
continue;
}
var logic = _universe.FetchTileStateEntityLogic(location, TileAccessFlags.SynchronousWait).GetPowerForTile(_universe);
if (logic != null)
{
if (ignoreFull)
{
if (logic.GetPower() != logic.TilePower?.MaxCharge && logic.InputFromTiles)
{
output.Add(logic.TilePower);
}
continue;
}
if (logic.InputFromTiles)
{
output.Add(logic.TilePower);
}
continue;
}
}
}
return(output);
}
public override void PostUpdate(Timestep timestep, EntityUniverseFacade universe)
{
Tile result;
if (!universe.ReadTile(Location, TileAccessFlags.None, out result))
{
return;
}
if (result.Configuration != _configuration)
{
if (result.Configuration.CanonicalConfiguration == _configuration.CanonicalConfiguration)
{
_configuration = result.Configuration;
_needsStore = true;
}
else
{
universe.RemoveEntity(Entity.Id);
}
}
}
public override void Update(Timestep timestep, EntityUniverseFacade universe)
{
Tile tile;
if (!universe.ReadTile(Location, TileAccessFlags.None, out tile))
{
return;
}
if ((tile.Configuration != _configuration) || (_variant != tile.Variant()) || (Component == null))
{
_done = true;
if (tile.Configuration == _configuration)
{
universe.RemoveTile(Entity, Location, TileAccessFlags.None);
}
}
if (!_ballSpawned && RoundStartedTimestep + 6 * Constants.TimestepsPerSecond < timestep)
{
ResetBall(universe);
}
CheckIfEntityExists();
}
/// <summary>
/// Update
/// </summary>
/// <param name="timestep"></param>
/// <param name="universe"></param>
public override void Update(Timestep timestep, EntityUniverseFacade universe)
{
// Following check is taken from Daemons mod
// Don't let this logic do anything if tile does not exist. Might be accessed after removal of tile.
if (!universe.ReadTile(Location, TileAccessFlags.None, out Tile tile))
{
return;
}
// Following check is taken from Daemons mod
// If the tile/variant has changed, or it doesn't have a Sprinkler Component set this logic to be removed.
if ((tile.Configuration != this._configuration) || this._variant != tile.Variant() || this._signComponent == null)
{
this._isRemoved = true;
if (tile.Configuration == this._configuration)
{
universe.RemoveTile(base.Entity, base.Location, TileAccessFlags.None);
}
return;
}
// If the centerPos is not set lets set it
if (this._centerPos == Vector3D.Zero)
{
uint rotation = tile.Configuration.Rotation(tile.Variant());
Vector3D offset = VectorHelper.RotatePosition(rotation, this._signComponent.offsetFromCenter);
this._centerPos = tile.Configuration.TileCenter(this.Location, tile.Variant()) + offset;
Vector3F tileOffset = default(Vector3F);
if (universe.TileOffset(base.Location, TileAccessFlags.None, out tileOffset))
{
this._centerPos += tileOffset.ToVector3D();
}
}
}
public override void Update(Timestep timestep, EntityUniverseFacade universe)
{
base.Update(timestep, universe);
Tile tile;
if (!universe.ReadTile(Location, TileAccessFlags.None, out tile))
{
return;
}
_tileCenter = tile.Configuration.TileCenter(Location, tile.Variant());
Vector3F tileOffset;
if (universe.TileOffset(Location, TileAccessFlags.None, out tileOffset))
{
_tileCenter.Y += tileOffset.Y;
}
if (_timer == Timestep.Null)
{
_timer = timestep;
}
if (timestep > _timer + 3000000)
{
_timer = timestep;
if (!IsReady())
{
ScanSurroundings();
BlueTeamScore = 0;
RedTeamScore = 0;
_gameStarted = false;
}
}
CheckIfEntitiesStillExists();
}
public override void Update(Timestep timestep, EntityUniverseFacade universe)
{
Tile tile;
if (!universe.ReadTile(Location, TileAccessFlags.None, out tile))
{
return;
}
if ((tile.Configuration != _configuration) || (_variant != tile.Variant()))
{
_done = true;
if (tile.Configuration == _configuration)
{
universe.RemoveTile(Entity, Location, TileAccessFlags.None);
}
return;
}
_countPosition = tile.Configuration.TileCenterTop(Location, tile);
Vector3F tileOffset;
if (universe.TileOffset(Location, TileAccessFlags.None, out tileOffset))
{
_countPosition.Y += tileOffset.Y;
}
CheckIfEntityExists();
if (!IsClaimed() || !Totem.HasGameStarted())
{
return;
}
if (SpawnFireworksStart + (long)(_goalComponent.FireworkLaunchingLength * Constants.TimestepsPerSecond) > timestep)
{
if (timestep - _lastSpawn > _goalComponent.FireworkTimeBetweenLaunch * Constants.TimestepsPerSecond)
{
_lastSpawn = timestep;
SpawnFireworks(universe);
}
return;
}
if (Totem.CanStartNewGame())
{
return;
}
// get all entities inside the goal area
var entities = universe.FindAllEntitiesInRange(tile.Configuration.TileCenter(Location, tile.Variant()), (float)_boundingShape.Radius.Length(),
FindEntityCondition);
if (entities == null || entities.Count <= 0)
{
return;
}
// if an item has moved into the goal area increase the score
Console.WriteLine("Checking all entities in collision.");
foreach (var entity in entities)
{
var itemlogic = entity.Logic as ItemEntityLogic;
if (itemlogic == null)
{
continue;
}
Console.WriteLine("There is an item logic.");
ItemStack stack = (ItemStack)GetInstanceField(typeof(ItemEntityLogic), itemlogic, "Stack"); //Use reflection to find internal stack
if (stack.Item.Configuration.Code == "mods.Deamon.Soccer.item.SoccerBall")
{
SetInstanceField(typeof(ItemEntityLogic), itemlogic, "Stack", new ItemStack());
Totem.IncreaseScore(Team, timestep); //Increase the score
}
}
}
/// <summary>
/// DailyVisit before function
/// </summary>
/// <param name="plantBlob"></param>
/// <param name="plantLocation"></param>
/// <param name="plantTile"></param>
/// <param name="soilLocation"></param>
/// <param name="soilTile"></param>
/// <param name="universe"></param>
/// <param name="weatherWatered"></param>
/// <returns></returns>
public bool DailyVisit(Blob plantBlob, Vector3I plantLocation, Tile plantTile, Vector3I soilLocation, Tile soilTile, EntityUniverseFacade universe, bool weatherWatered)
{
// Return true in case it concerns a greenhouse plant
int day = universe.DayNightCycle().Day;
int season = universe.DayNightCycle().GetSeason();
bool watered = GameContext.FarmingDatabase.IsWateredMaterial(soilTile.Configuration);
if (GameContext.PlantDatabase.IsGrowable(plantTile))
{
PlantConfiguration plantConfiguration = GameContext.PlantDatabase.GetByTile(plantTile.Configuration);
DeterministicRandom rnd = GameContext.RandomSource;
bool requiresWatering = GameContext.PlantDatabase.RequiresWatering(plantTile);
long lastChangedDay = plantBlob.GetLong("day", -1L);
int prevSeason2 = (int)plantBlob.GetLong("season", -1L);
List <Totem> totems;
Totem totem;
bool plantedInGreenhouse = (PlantLogic.GetValidTotemsOfType(PlantLogic.GreenhouseTotemCode, out totems) && PlantLogic.IsInTotemsRegion(totems, plantLocation, out totem));
if (plantConfiguration.LivesInSeason(SeasonHelper.FromInt(season)) ||
!plantConfiguration.LivesInSeason(SeasonHelper.FromInt(season)) && !plantedInGreenhouse)
{
return(true);
}
Logger.WriteLine("Custom plant DailyVisit");
if (prevSeason2 == -1)
{
prevSeason2 = season;
}
if (lastChangedDay == -1 || lastChangedDay > day)
{
lastChangedDay = day - 1;
PlantLogic.FarmDatabaseTileUpdated.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, lastChangedDay, plantConfiguration.GatherableIsHarvestable, season });
}
Vector2I window2 = default(Vector2I);
Vector2I window3 = default(Vector2I);
Logger.WriteLine("Plant: " + plantConfiguration.Code);
Logger.WriteLine("Watered: " + watered.ToString() + " | RequiresWatering: " + requiresWatering.ToString() + " | CanWilt: " + plantConfiguration.CanWilt(plantTile, out window2).ToString() + " | CanWither: " + plantConfiguration.CanWither(plantTile, out window3).ToString());
long totalDays = day - lastChangedDay;
int growthDays = 0;
int daysPassed = 1;
for (int i = 0; i < totalDays; i++)
{
Vector2I window = default(Vector2I);
if (!watered && requiresWatering && plantConfiguration.CanWilt(plantTile, out window))
{
Logger.WriteLine("Wilting result:" + ((bool)PlantLogic.FarmDatabaseChangeTile.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, plantConfiguration.MakeWiltedTile(plantTile), universe, plantConfiguration.GatherableIsHarvestable, null, TileAccessFlags.IgnoreEntities })).ToString());
int transitionPeriod3 = rnd.Next(window.X, window.Y);
if (transitionPeriod3 <= daysPassed - growthDays &&
(bool)PlantLogic.FarmDatabaseChangeTile.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, plantConfiguration.MakeWiltedTile(plantTile), universe, plantConfiguration.GatherableIsHarvestable, null, TileAccessFlags.IgnoreEntities }))
{
Logger.WriteLine("Wilting greenhouse plant");
break;
}
}
if (!watered && requiresWatering && plantConfiguration.CanWither(plantTile, out window))
{
Logger.WriteLine("Withering result: " + ((bool)PlantLogic.FarmDatabaseChangeTile.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, plantConfiguration.MakeWitheredTile(plantTile), universe, plantConfiguration.GatherableIsHarvestable, null, TileAccessFlags.IgnoreEntities })).ToString());
int transitionPeriod2 = rnd.Next(window.X, window.Y);
if (transitionPeriod2 <= daysPassed - growthDays &&
(bool)PlantLogic.FarmDatabaseChangeTile.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, plantConfiguration.MakeWitheredTile(plantTile), universe, plantConfiguration.GatherableIsHarvestable, null, TileAccessFlags.IgnoreEntities }))
{
Logger.WriteLine("Withering greenhouse plant");
break;
}
}
if (!watered && requiresWatering && !plantConfiguration.CanWilt(plantTile, out window) && !plantConfiguration.CanWither(plantTile, out window))
{
Logger.WriteLine("Set as harvestable");
PlantLogic.FarmDatabaseTileUpdated.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, day, plantConfiguration.GatherableIsHarvestable, season });
break;
}
if ((watered || !requiresWatering || (plantConfiguration.GatherableIsHarvestable && rnd.NextBool())) && plantConfiguration.CanGrow(plantTile, SeasonHelper.FromInt(season), out window))
{
int transitionPeriod = rnd.Next(window.X, window.Y);
if (transitionPeriod <= daysPassed - growthDays &&
(bool)PlantLogic.FarmDatabaseChangeTile.Invoke(GameContext.FarmingDatabase, new object[] { plantLocation, plantConfiguration.MakeGrowTile(plantTile, rnd), universe, plantConfiguration.GatherableIsHarvestable, null, TileAccessFlags.IgnoreEntities }))
{
growthDays += transitionPeriod;
if (!universe.ReadTile(plantLocation, TileAccessFlags.None, out plantTile))
{
return(true);
}
}
}
daysPassed++;
}
if (!weatherWatered && watered)
{
Tile unwateredTile = (Tile)PlantLogic.FarmDatabaseMakeUnwateredMaterial.Invoke(GameContext.FarmingDatabase, new object[] { soilTile });
PlantLogic.FarmDatabaseChangeTile.Invoke(null, new object[] { soilLocation, unwateredTile, universe, false, null, TileAccessFlags.IgnoreEntities });
}
Tile tempPlant = default(Tile);
PlantConfiguration config = default(PlantConfiguration);
bool isMaterialWaterable = (bool)PlantLogic.FarmDatabaseIsMaterialWaterable.Invoke(GameContext.FarmingDatabase, new object[] { soilTile.Configuration });
if (weatherWatered && !watered && isMaterialWaterable && universe.ReadTile(plantLocation, TileAccessFlags.None, out tempPlant) && GameContext.PlantDatabase.TryGetByTile(tempPlant, out config))
{
Tile wateredTile = (Tile)PlantLogic.FarmDatabaseMakeWateredMaterial.Invoke(GameContext.FarmingDatabase, new object[] { soilTile });
PlantLogic.FarmDatabaseChangeTile.Invoke(null, new object[] { soilLocation, wateredTile, universe, false, null, TileAccessFlags.IgnoreEntities });
}
return(false);
}
return(true);
}
public override void Control(Entity entity, EntityUniverseFacade facade, ControlState main, ControlState alt)
{
if (!main.DownClick && !alt.DownClick)
{
return;
}
if (main.DownClick)
{
if (entity.PlayerEntityLogic.LookingAtTile(out var target, out _))
{
if (facade.AnyInnerCableEntitiesInTile(target, out var entities))
{
foreach (var lEntity in entities)
{
var itemBlob = BlobAllocator.Blob(true);
itemBlob.SetString("code", ((InnerCableTileEntityLogic)lEntity.Logic).Tile);
var item = GameContext.ItemDatabase.SpawnItemStack(itemBlob, null);
if (item.IsNull())
{
itemBlob.Delete("code");
itemBlob.SetString("kind", "staxel.item.Placer");
itemBlob.SetString("tile", ((InnerCableTileEntityLogic)lEntity.Logic).Tile);
item = GameContext.ItemDatabase.SpawnItemStack(itemBlob, null);
}
ItemEntityBuilder.SpawnDroppedItem(entity, facade, item, target.ToVector3D(), Vector3D.Zero,
Vector3D.Zero, SpawnDroppedFlags.AttemptPickup);
facade.RemoveEntity(lEntity.Id);
}
}
else
{
if (_targetCode == "nimbusfox.powerapi.verb.none")
{
var notification = GameContext.NotificationDatabase.CreateNotificationFromCode(
"nimbusfox.powerapi.notifications.noCableSelected", facade.Step,
new NotificationParams(), true);
entity.PlayerEntityLogic.ShowNotification(notification);
return;
}
if (!entity.Inventory.HasItemWithCode(_targetCode))
{
var nparams = new NotificationParams(1);
nparams.SetTranslation(0, _targetCode + ".name");
var notification =
GameContext.NotificationDatabase.CreateNotificationFromCode(
"nimbusfox.powerapi.notifications.noCable", facade.Step, nparams, true);
entity.PlayerEntityLogic.ShowNotification(notification);
return;
}
if (facade.ReadTile(target, TileAccessFlags.SynchronousWait, out var tile))
{
if (!tile.Configuration.Components.Select <ChargeableComponent>().Any())
{
var config = BlobAllocator.Blob(true);
config.SetString("tile", _targetCode);
InnerCableTileEntityBuilder.Spawn(target, config, facade);
entity.Inventory.ConsumeItem(new ItemStack(entity.Inventory.GetItemStack(_slot).Item, 1));
}
}
}
}
}
if (alt.DownClick)
{
var orig = _targetCode;
var looped = false;
loop:
if (_slot + 1 >= entity.Inventory.SlotCount())
{
_slot = 0;
}
for (var i = _slot; i < entity.Inventory.SlotCount(); i++)
{
var current = entity.Inventory.GetItemStack(i);
if (current.IsNull())
{
continue;
}
if (current.Item.Configuration.Components.Select <CableComponent>().Any())
{
_slot = i;
_targetCode = current.Item.GetItemCode();
break;
}
}
if (orig == _targetCode)
{
if (!looped)
{
looped = true;
_slot = 0;
goto loop;
}
_targetCode = "nimbusfox.powerapi.verb.none";
}
}
entity.Inventory.ItemStoreNeedsStorage();
}
public override void Control(Entity entity, EntityUniverseFacade facade, ControlState main, ControlState alt)
{
//if (alt.DownClick) {
// if (_mode == Mode.PickUp) {
// _mode = Mode.Power;
// } else {
// _mode = Mode.PickUp;
// }
// entity.Inventory.ItemStoreNeedsStorage();
//}
if (!main.DownClick)
{
return;
}
if (_mode == Mode.Rotate)
{
if (entity.PlayerEntityLogic.LookingAtTile(out var target, out _))
{
if (facade.ReadTile(target, TileAccessFlags.SynchronousWait, out var tile))
{
facade.PlaceTile(entity, target, tile.Configuration.MakeTile(tile.Configuration.BuildRotationVariant(tile.Configuration.Rotation(0))),
TileAccessFlags.SynchronousWait);
}
}
}
else if (_mode == Mode.PickUp)
{
if (entity.PlayerEntityLogic.LookingAtTile(out var target, out _))
{
if (facade.ReadTile(target, TileAccessFlags.SynchronousWait, out var tile))
{
if (tile.Configuration.Components.Contains <WrenchableComponent>())
{
if (facade.TryFetchTileStateEntityLogic(target, TileAccessFlags.SynchronousWait,
out var logic))
{
if (logic is ChargeableTileStateEntityLogic chargeable)
{
if (facade.TryGetEntity(chargeable.GetOwner(), out var owner))
{
if (owner.Logic is ITileWithPower tileWithPower)
{
tileWithPower.ActiveNameTag = false;
}
facade.RemoveEntity(chargeable.GetOwner());
}
facade.RemoveEntity(chargeable.Entity.Id);
}
}
var destructor = DestructionEntityBuilder.Spawn(entity, target, facade, "");
destructor.AttemptPickup();
destructor.EnqueueDeferredDestructionQueue(facade.Step, target, tile);
}
}
}
}
}
public override void ClientUpdate(Timestep timestep, Entity entity, AvatarController avatarController, EntityUniverseFacade facade)
{
var fail = true;
if (entity.Logic is SolarPanelTileEntityLogic logic)
{
if (facade.ReadTile(logic.Location, TileAccessFlags.None, out var tile))
{
if (tile.Configuration.Components.Select <ChargeableComponent>().Any())
{
if (ClientHook.NameTags.Contains(logic.Location))
{
if (NameTag == null)
{
NameTag = ClientContext.NameTagRenderer.RegisterNameTag(entity.Id);
}
if (_efficienyTag == null)
{
_efficienyTag = ClientContext.NameTagRenderer.RegisterNameTag(entity.Id);
}
if (_chargeTag == null)
{
_chargeTag = ClientContext.NameTagRenderer.RegisterNameTag(entity.Id);
}
if (facade.TryGetLightPower(logic.Location, out var efficiency, out _, out _))
{
var pos = Constants.NameTagLowerOffset;
NameTag.Setup(entity.Physics.Position, new Vector3D(pos.X, pos.Y + 0.2, pos.Z), logic.TilePower.CurrentCharge.ToString("N0") + " / " + logic.TilePower.MaxCharge.ToString("N0"), false, false, false);
_efficienyTag.Setup(entity.Physics.Position, new Vector3D(pos.X, pos.Y, pos.Z), efficiency + "%", false, false, false);
_chargeTag.Setup(entity.Physics.Position, new Vector3D(pos.X, pos.Y - 0.2, pos.Z), logic.Generated + ClientContext.LanguageDatabase.GetTranslationString("nimbusfox.powerapi.perCycle"), false, false, false);
fail = false;
}
}
}
}
if (fail)
{
if (NameTag != null)
{
ClientContext.NameTagRenderer.Unregister(NameTag);
NameTag = null;
}
if (_efficienyTag != null)
{
ClientContext.NameTagRenderer.Unregister(_efficienyTag);
_efficienyTag = null;
}
if (_chargeTag != null)
{
ClientContext.NameTagRenderer.Unregister(_chargeTag);
_chargeTag = null;
}
}
}
}
