685 lines
26 KiB
C#
685 lines
26 KiB
C#
using Audio;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
|
|
public class BlockVehicleRebirth : BlockCarExplodeLoot
|
|
{
|
|
public GameRandom rng = null;
|
|
|
|
public bool isRepairable = false;
|
|
public bool isLootable = false;
|
|
|
|
public bool canContainGas = false;
|
|
public bool canContainOil = false;
|
|
|
|
public bool canContainFLHeadlight = false;
|
|
public bool canContainFRHeadlight = false;
|
|
|
|
public bool canContainEngine = false;
|
|
public bool canContainBattery = false;
|
|
public bool canContainCarburetor = false;
|
|
public bool canContainAltenator = false;
|
|
public bool canContainTransmission = false;
|
|
|
|
public bool canContainFLTire = false;
|
|
public bool canContainFRTire = false;
|
|
public bool canContainRLTire = false;
|
|
public bool canContainRRTire = false;
|
|
|
|
public float spawn_min_gas_percent = 0f;
|
|
public float spawn_max_gas_percent = 0f;
|
|
|
|
public float spawn_min_repaired_percent = 0f;
|
|
public float spawn_max_repaired_percent = 0f;
|
|
|
|
public float spawn_entity_y_offset = 0f;
|
|
public string vehicle_entity_class = "";
|
|
|
|
public override int OnBlockDamaged(
|
|
WorldBase _world,
|
|
int _clrIdx,
|
|
Vector3i _blockPos,
|
|
BlockValue _blockValue,
|
|
int _damagePoints,
|
|
int _entityIdThatDamaged,
|
|
ItemActionAttack.AttackHitInfo _attackHitInfo,
|
|
bool _bUseHarvestTool,
|
|
bool _bBypassMaxDamage,
|
|
int _recDepth = 0)
|
|
{
|
|
//Log.Out("BlockVehicleRebirth-OnBlockDamaged _bUseHarvestTool: " + _bUseHarvestTool);
|
|
|
|
if (_bUseHarvestTool && _entityIdThatDamaged > 0)
|
|
{
|
|
if ((EntityPlayer)_world.GetEntity(_entityIdThatDamaged) is EntityPlayer player && _world.GetTileEntity(_clrIdx, _blockPos) is TileEntityDriveableLootContainer tileEntity)
|
|
{
|
|
if (tileEntity.bPlayerStorage && player.inventory.holdingItem.HasAnyTags(FastTags<TagGroup.Global>.Parse("salvageTool")))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return base.OnBlockDamaged(_world, _clrIdx, _blockPos, _blockValue, _damagePoints, _entityIdThatDamaged, _attackHitInfo, _bUseHarvestTool, _bBypassMaxDamage, _recDepth);
|
|
}
|
|
|
|
public override void Init()
|
|
{
|
|
base.Init();
|
|
CanPickup = true;
|
|
|
|
rng = new GameRandom();
|
|
|
|
if (Properties.Values.ContainsKey("isRepairable"))
|
|
{
|
|
isRepairable = Convert.ToBoolean(Properties.Values["isRepairable"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("isLootable"))
|
|
{
|
|
isLootable = Convert.ToBoolean(Properties.Values["isLootable"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainGas"))
|
|
{
|
|
canContainGas = Convert.ToBoolean(Properties.Values["canContainGas"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainOil"))
|
|
{
|
|
canContainOil = Convert.ToBoolean(Properties.Values["canContainOil"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainFLHeadlight"))
|
|
{
|
|
canContainFLHeadlight = Convert.ToBoolean(Properties.Values["canContainFLHeadlight"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainFRHeadlight"))
|
|
{
|
|
canContainFRHeadlight = Convert.ToBoolean(Properties.Values["canContainFRHeadlight"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainEngine"))
|
|
{
|
|
canContainEngine = Convert.ToBoolean(Properties.Values["canContainEngine"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainBattery"))
|
|
{
|
|
canContainBattery = Convert.ToBoolean(Properties.Values["canContainBattery"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainCarburetor"))
|
|
{
|
|
canContainCarburetor = Convert.ToBoolean(Properties.Values["canContainCarburetor"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainAltenator"))
|
|
{
|
|
canContainAltenator = Convert.ToBoolean(Properties.Values["canContainAltenator"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainTransmission"))
|
|
{
|
|
canContainTransmission = Convert.ToBoolean(Properties.Values["canContainTransmission"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainFLTire"))
|
|
{
|
|
canContainFLTire = Convert.ToBoolean(Properties.Values["canContainFLTire"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainFRTire"))
|
|
{
|
|
canContainFRTire = Convert.ToBoolean(Properties.Values["canContainFRTire"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainRLTire"))
|
|
{
|
|
canContainRLTire = Convert.ToBoolean(Properties.Values["canContainRLTire"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("canContainRRTire"))
|
|
{
|
|
canContainRRTire = Convert.ToBoolean(Properties.Values["canContainRRTire"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("spawn_min_gas_percent"))
|
|
{
|
|
spawn_min_gas_percent = Mathf.Clamp01(Convert.ToSingle(Properties.Values["spawn_min_gas_percent"]));
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("spawn_max_gas_percent"))
|
|
{
|
|
spawn_max_gas_percent = Mathf.Clamp01(Convert.ToSingle(Properties.Values["spawn_max_gas_percent"]));
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("spawn_min_repaired_percent"))
|
|
{
|
|
spawn_min_repaired_percent = Mathf.Clamp01(Convert.ToSingle(Properties.Values["spawn_min_repaired_percent"]));
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("spawn_max_repaired_percent"))
|
|
{
|
|
spawn_max_repaired_percent = Mathf.Clamp01(Convert.ToSingle(Properties.Values["spawn_max_repaired_percent"]));
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("spawn_entity_y_offset"))
|
|
{
|
|
spawn_entity_y_offset = Convert.ToSingle(Properties.Values["spawn_entity_y_offset"]);
|
|
}
|
|
|
|
if (Properties.Values.ContainsKey("vehicle_entity_class"))
|
|
{
|
|
vehicle_entity_class = Properties.Values["vehicle_entity_class"];
|
|
}
|
|
}
|
|
|
|
public override void LateInit()
|
|
{
|
|
base.LateInit();
|
|
|
|
cmds = new BlockActivationCommand[]
|
|
{
|
|
new BlockActivationCommand("Search", "loot_sack", false, false),
|
|
new BlockActivationCommand("Siphon", "gas", false, false),
|
|
new BlockActivationCommand("Repair", "wrench", false, false),
|
|
};
|
|
}
|
|
|
|
|
|
public override BlockActivationCommand[] GetBlockActivationCommands(WorldBase _world, BlockValue _blockValue, int _clrIdx, Vector3i _blockPos, EntityAlive _entityFocusing)
|
|
{
|
|
//Log.Out($"BlockVehicleRebirth-OnBlockActivated GetBlockActivationCommands isLootable: {isLootable}");
|
|
TileEntityDriveableLootContainer vehicleTE = _world.GetTileEntity(_clrIdx, _blockPos) as TileEntityDriveableLootContainer;
|
|
string vehicleType = "";
|
|
|
|
if (Properties.Values.ContainsKey("VehicleType"))
|
|
{
|
|
vehicleType = Properties.Values["VehicleType"];
|
|
}
|
|
|
|
//bool cantSearch = !RebirthUtilities.CanBeLooted(_blockPos, _blockValue, _cIdx);
|
|
|
|
cmds[0].enabled = false; // !cantSearch && isLootable;
|
|
cmds[1].enabled = false; // vehicleType != "BicycleRepair" && vehicleTE.GasPerc > 0f; // && spawn_max_repaired_percent > 0f;
|
|
cmds[2].enabled = isRepairable && !string.IsNullOrEmpty(vehicle_entity_class);
|
|
|
|
return cmds;
|
|
}
|
|
|
|
public override void OnBlockAdded(WorldBase _world, Chunk _chunk, Vector3i _blockPos, BlockValue _blockValue)
|
|
{
|
|
if (!_blockValue.ischild)
|
|
{
|
|
shape.OnBlockAdded(_world, _chunk, _blockPos, _blockValue);
|
|
|
|
if (isMultiBlock)
|
|
{
|
|
multiBlockPos.AddChilds(_world, _chunk, _blockPos, _blockValue);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(blockAddedEvent))
|
|
{
|
|
GameEventManager.Current.HandleAction(blockAddedEvent, null, null, twitchActivated: false, _blockPos);
|
|
}
|
|
}
|
|
|
|
addTileEntity(_world, _chunk, _blockPos, _blockValue);
|
|
TileEntityDriveableLootContainer vehicleTE = _chunk.GetTileEntity(World.toBlock(_blockPos)) as TileEntityDriveableLootContainer;
|
|
|
|
if (canContainGas)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + (int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount)));
|
|
vehicleTE.GasPerc = rng.RandomRange(spawn_min_gas_percent, spawn_max_gas_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.GasPerc = 0.0f;
|
|
}
|
|
|
|
if (spawn_max_repaired_percent > 0f)
|
|
{
|
|
if (canContainOil)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.OilPerc = rng.RandomRange(0, 1f);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.OilPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainFLHeadlight)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.FLHeadlightPerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.FLHeadlightPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainFRHeadlight)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.FRHeadlightPerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.FRHeadlightPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainEngine)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.EnginePerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.EnginePerc = 0.0f;
|
|
}
|
|
|
|
if (canContainBattery)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.BatteryPerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.BatteryPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainCarburetor)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.CarburetorPerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.CarburetorPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainAltenator)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.AltenatorPerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.AltenatorPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainTransmission)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.TransmissionPerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.TransmissionPerc = 0.0f;
|
|
}
|
|
|
|
if (canContainFLTire)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.FLTirePerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.FLTirePerc = 0.0f;
|
|
}
|
|
|
|
if (canContainFRTire)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.FRTirePerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.FRTirePerc = 0.0f;
|
|
}
|
|
|
|
if (canContainRLTire)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.RLTirePerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.RLTirePerc = 0.0f;
|
|
}
|
|
|
|
if (canContainRRTire)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
vehicleTE.RRTirePerc = rng.RandomRange(spawn_min_repaired_percent, spawn_max_repaired_percent);
|
|
}
|
|
|
|
else
|
|
{
|
|
vehicleTE.RRTirePerc = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void OnBlockValueChanged(WorldBase _world, Chunk _chunk, int _clrIdx, Vector3i _blockPos, BlockValue _oldBlockValue, BlockValue _newBlockValue)
|
|
{
|
|
base.OnBlockValueChanged(_world, _chunk, _clrIdx, _blockPos, _oldBlockValue, _newBlockValue);
|
|
|
|
if (_newBlockValue.isair)
|
|
{
|
|
removeTileEntity(_world, _chunk, _blockPos, _newBlockValue);
|
|
}
|
|
}
|
|
|
|
public override bool OnBlockActivated(string _commandName, WorldBase _world, int _cIdx, Vector3i _blockPos, BlockValue _blockValue, EntityPlayerLocal _player)
|
|
{
|
|
//Log.Out($"BlockVehicleRebirth-OnBlockActivated _commandName: {_commandName}, player: {_player}");
|
|
|
|
TileEntityDriveableLootContainer vehicleTE = _world.GetTileEntity(_cIdx, _blockPos) as TileEntityDriveableLootContainer;
|
|
|
|
switch (_commandName)
|
|
{
|
|
case "Search":
|
|
//Log.Out("<color=cyan>Vehicle was searched!</color>");
|
|
|
|
if (_player.inventory.IsHoldingItemActionRunning())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_commandName == "Search" && !RebirthUtilities.CanBeLooted(_blockPos, _blockValue, _cIdx))
|
|
{
|
|
Manager.PlayInsidePlayerHead("ui_denied");
|
|
GameManager.ShowTooltip(_player as EntityPlayerLocal, Localization.Get("ttBelongsToTrader"), string.Empty, "ui_denied", null);
|
|
return false;
|
|
}
|
|
|
|
_player.AimingGun = false;
|
|
Vector3i blockPos = vehicleTE.ToWorldPos();
|
|
vehicleTE.bWasTouched = vehicleTE.bTouched;
|
|
_world.GetGameManager().TELockServer(_cIdx, blockPos, vehicleTE.entityId, _player.entityId);
|
|
return true;
|
|
|
|
/*case "inspect":
|
|
Log.Out($"<color=cyan>Vehicle was inspected!</color>");
|
|
Log.Out($"<color=yellow>Gas is at {vehicleTE.GasPerc}!</color>");
|
|
Log.Out($"<color=yellow>Oil is at {vehicleTE.OilPerc}!</color>");
|
|
Log.Out($"<color=yellow>Front left headlight is at {vehicleTE.FLHeadlightPerc}!</color>");
|
|
Log.Out($"<color=yellow>Front right headlight is at {vehicleTE.FRHeadlightPerc}!</color>");
|
|
|
|
Log.Out($"<color=yellow>Engine is at {vehicleTE.EnginePerc}!</color>");
|
|
Log.Out($"<color=yellow>Battery is at {vehicleTE.BatteryPerc}!</color>");
|
|
Log.Out($"<color=yellow>Carburetor is at {vehicleTE.CarburetorPerc}!</color>");
|
|
Log.Out($"<color=yellow>Altenator is at {vehicleTE.AltenatorPerc}!</color>");
|
|
Log.Out($"<color=yellow>Transmission is at {vehicleTE.TransmissionPerc}!</color>");
|
|
|
|
Log.Out($"<color=yellow>Front left tire is at {vehicleTE.FLTirePerc}!</color>");
|
|
Log.Out($"<color=yellow>Front right tire is at {vehicleTE.FRTirePerc}!</color>");
|
|
Log.Out($"<color=yellow>Rear left tire is at {vehicleTE.RLTirePerc}!</color>");
|
|
Log.Out($"<color=yellow>Rear right tire is at {vehicleTE.RRTirePerc}!</color>");
|
|
break;*/
|
|
|
|
case "Repair":
|
|
if (Properties.Values.ContainsKey("VehicleType"))
|
|
{
|
|
string vehicleType = Properties.Values["VehicleType"];
|
|
RebirthUtilities.OpenTileEntity(_player, _blockPos, vehicleType, "window" + vehicleType, "UseActions/service_vehicle");
|
|
}
|
|
|
|
break;
|
|
|
|
case "Siphon":
|
|
RebirthUtilities.addToPlayerBag(ItemClass.GetItem("ammoGasCan"), _player, Mathf.RoundToInt(vehicleTE.GasPerc * 500), "useactions/gas_refill");
|
|
vehicleTE.GasPerc = 0f;
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override void OnBlockRemoved(WorldBase world, Chunk _chunk, Vector3i _blockPos, BlockValue _blockValue)
|
|
{
|
|
base.OnBlockRemoved(world, _chunk, _blockPos, _blockValue);
|
|
removeTileEntity(world, _chunk, _blockPos, _blockValue);
|
|
}
|
|
|
|
public override void addTileEntity(WorldBase world, Chunk _chunk, Vector3i _blockPos, BlockValue _blockValue)
|
|
{
|
|
TileEntityDriveableLootContainer vehicleTE = new TileEntityDriveableLootContainer(_chunk)
|
|
{
|
|
localChunkPos = World.toBlock(_blockPos),
|
|
lootListName = lootList,
|
|
};
|
|
|
|
vehicleTE.SetContainerSize(LootContainer.GetLootContainer(lootList).size);
|
|
vehicleTE.InitRepairableVehicleParts();
|
|
|
|
_chunk.AddTileEntity(vehicleTE);
|
|
}
|
|
|
|
public override void removeTileEntity(WorldBase world, Chunk _chunk, Vector3i _blockPos, BlockValue _blockValue)
|
|
{
|
|
_chunk.RemoveTileEntityAt<TileEntityDriveableLootContainer>((World)world, World.toBlock(_blockPos));
|
|
}
|
|
}
|
|
|
|
public class TileEntityDriveableLootContainer : TileEntityLootContainer
|
|
{
|
|
public Block block = null;
|
|
public ItemValue[] itemValues = new ItemValue[] { };
|
|
|
|
public float Durability, baseDurability, maxDurability, vehicleHealth, baseVehicleHealth, GasPerc, OilPerc, FLHeadlightPerc, FRHeadlightPerc, EnginePerc, BatteryPerc, CarburetorPerc, AltenatorPerc, TransmissionPerc, FLTirePerc, FRTirePerc, RLTirePerc, RRTirePerc;
|
|
|
|
public TileEntityDriveableLootContainer(Chunk _chunk) : base(_chunk)
|
|
{
|
|
block = base.blockValue.Block;
|
|
|
|
for (int i = 0; i < itemValues.Length; i++)
|
|
{
|
|
itemValues[i] = ItemValue.None;
|
|
}
|
|
|
|
Durability = 0f;
|
|
baseDurability = 0f;
|
|
maxDurability = 0f;
|
|
vehicleHealth = 0f;
|
|
baseVehicleHealth = 0f;
|
|
GasPerc = 0f;
|
|
OilPerc = 0f;
|
|
|
|
FLHeadlightPerc = 0f;
|
|
FRHeadlightPerc = 0f;
|
|
|
|
EnginePerc = 0f;
|
|
BatteryPerc = 0f;
|
|
CarburetorPerc = 0f;
|
|
AltenatorPerc = 0f;
|
|
TransmissionPerc = 0f;
|
|
|
|
FLTirePerc = 0f;
|
|
FRTirePerc = 0f;
|
|
RLTirePerc = 0f;
|
|
RRTirePerc = 0f;
|
|
}
|
|
|
|
public override void read(PooledBinaryReader _br, StreamModeRead _eStreamMode)
|
|
{
|
|
base.read(_br, _eStreamMode);
|
|
|
|
try
|
|
{
|
|
itemValues = GameUtils.ReadItemValueArray(_br);
|
|
}
|
|
catch
|
|
{
|
|
//Log.Error("BlockVehicleRebirth-read block: " + this.block.GetBlockName());
|
|
return;
|
|
}
|
|
|
|
Durability = _br.ReadSingle();
|
|
baseDurability = _br.ReadSingle();
|
|
maxDurability = _br.ReadSingle();
|
|
vehicleHealth = _br.ReadSingle();
|
|
baseVehicleHealth = _br.ReadSingle();
|
|
GasPerc = _br.ReadSingle();
|
|
OilPerc = _br.ReadSingle();
|
|
FLHeadlightPerc = _br.ReadSingle();
|
|
FRHeadlightPerc = _br.ReadSingle();
|
|
EnginePerc = _br.ReadSingle();
|
|
BatteryPerc = _br.ReadSingle();
|
|
CarburetorPerc = _br.ReadSingle();
|
|
AltenatorPerc = _br.ReadSingle();
|
|
TransmissionPerc = _br.ReadSingle();
|
|
FLTirePerc = _br.ReadSingle();
|
|
FRTirePerc = _br.ReadSingle();
|
|
RLTirePerc = _br.ReadSingle();
|
|
RRTirePerc = _br.ReadSingle();
|
|
}
|
|
|
|
public override void write(PooledBinaryWriter stream, StreamModeWrite _eStreamMode)
|
|
{
|
|
base.write(stream, _eStreamMode);
|
|
|
|
GameUtils.WriteItemValueArray(stream, itemValues);
|
|
|
|
stream.Write(Durability);
|
|
stream.Write(baseDurability);
|
|
stream.Write(maxDurability);
|
|
stream.Write(vehicleHealth);
|
|
stream.Write(baseVehicleHealth);
|
|
stream.Write(GasPerc);
|
|
stream.Write(OilPerc);
|
|
stream.Write(FLHeadlightPerc);
|
|
stream.Write(FRHeadlightPerc);
|
|
stream.Write(EnginePerc);
|
|
stream.Write(BatteryPerc);
|
|
stream.Write(CarburetorPerc);
|
|
stream.Write(AltenatorPerc);
|
|
stream.Write(TransmissionPerc);
|
|
stream.Write(FLTirePerc);
|
|
stream.Write(FRTirePerc);
|
|
stream.Write(RLTirePerc);
|
|
stream.Write(RRTirePerc);
|
|
}
|
|
|
|
public void InitRepairableVehicleParts()
|
|
{
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts BEFORE block: " + block.GetBlockName());
|
|
block = blockValue.Block as BlockVehicleRebirth;
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts AFTER block: " + block.GetBlockName());
|
|
GameRandom rng = new GameRandom();
|
|
|
|
if (block.Properties.Values.ContainsKey("VehicleType"))
|
|
{
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts VehicleType: " + block.Properties.Values["VehicleType"]);
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount));
|
|
|
|
int health = 0;
|
|
|
|
if (block.Properties.Values.ContainsKey("vehicle_entity_class"))
|
|
{
|
|
ItemValue itemVehicle = ItemClass.GetItem(block.Properties.Values["vehicle_entity_class"] + "Placeable", false);
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts A");
|
|
|
|
if (itemVehicle != null)
|
|
{
|
|
health = (int)EffectManager.GetValue(PassiveEffects.DegradationMax, itemVehicle, 0f, null, null, (itemVehicle.ItemClass != null) ? itemVehicle.ItemClass.ItemTags : FastTags<TagGroup.Global>.none, true, true, true, true, true, 1, false);
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts health: " + health);
|
|
}
|
|
}
|
|
|
|
vehicleHealth = health; // * 0.75f;
|
|
baseVehicleHealth = vehicleHealth;
|
|
|
|
maxDurability = vehicleHealth;
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts maxDurability: " + maxDurability);
|
|
|
|
baseDurability = rng.RandomRange(Convert.ToSingle(block.Properties.Values["spawn_min_repaired_percent"]) * vehicleHealth, Convert.ToSingle(block.Properties.Values["spawn_max_repaired_percent"]) * vehicleHealth);
|
|
Durability = baseDurability;
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts baseDurability: " + baseDurability);
|
|
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts spawn_max_repaired_percent: " + block.Properties.Values["spawn_max_repaired_percent"]);
|
|
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts baseVehicleHealth: " + baseVehicleHealth);
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts Durability: " + Durability);
|
|
|
|
List<RepairableVehicleSlotsEnum> itemValueEnums = RebirthVariables.localVehicleTypes[block.Properties.Values["VehicleType"]];
|
|
itemValues = new ItemValue[itemValueEnums.Count];
|
|
|
|
foreach (RepairableVehicleSlotsEnum part in itemValueEnums)
|
|
{
|
|
ItemValue item = ItemClass.GetItem(RebirthVariables.localVehicleParts[part].itemName);
|
|
DictionarySave<string, string> propValues = item.ItemClass.Properties.Values;
|
|
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts part: " + part);
|
|
//Log.Out("TileEntityDriveableLootContainer-InitRepairableVehicleParts item: " + item.ItemClass.GetItemName());
|
|
|
|
RepairableVehicleSlotsEnum slot = (RepairableVehicleSlotsEnum)Enum.Parse(typeof(RepairableVehicleSlotsEnum), propValues["VehicleSlot"]);
|
|
|
|
for (int i = 0; i < itemValueEnums.Count; i++)
|
|
{
|
|
rng.SetSeed((int)((float)Stopwatch.GetTimestamp() + GameManager.frameCount) + i);
|
|
itemValues[i] = ItemValue.None;
|
|
}
|
|
}
|
|
|
|
float increase = 0;
|
|
|
|
foreach (ItemValue item in itemValues)
|
|
{
|
|
if (item != ItemValue.None)
|
|
{
|
|
string itemName = item.ItemClass.GetItemName();
|
|
foreach (RepairableVehicleSlotsEnum part in itemValueEnums)
|
|
{
|
|
if (RebirthVariables.localVehicleParts[part].itemName == itemName)
|
|
{
|
|
increase += ((item.MaxUseTimes - item.UseTimes) / item.MaxUseTimes) * RebirthVariables.localVehicleParts[part].durabilityPerQuality * item.Quality;
|
|
//maxDurability += RebirthVariables.localVehicleParts[part].durabilityPerQuality * item.Quality;
|
|
/*Log.Out("XUiC_RepairableVehicleWindow-BtnHotwire_OnPress itemName: " + itemName);
|
|
Log.Out("XUiC_RepairableVehicleWindow-BtnHotwire_OnPress PercUsed: " + ((item.MaxUseTimes - item.UseTimes) / item.MaxUseTimes));
|
|
Log.Out("XUiC_RepairableVehicleWindow-BtnHotwire_OnPress Quality: " + item.Quality);
|
|
Log.Out("XUiC_RepairableVehicleWindow-BtnHotwire_OnPress durabilityPerQuality: " + RebirthVariables.localVehicleParts[part].durabilityPerQuality);
|
|
Log.Out("XUiC_RepairableVehicleWindow-BtnHotwire_OnPress durability: " + durability);*/
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vehicleHealth += increase;
|
|
setModified();
|
|
}
|
|
}
|
|
public void SetRepairableVehicleParts(ItemValue[] newItemValues)
|
|
{
|
|
itemValues = newItemValues;
|
|
}
|
|
|
|
public ItemValue[] GetRepairableVehicleParts()
|
|
{
|
|
return itemValues;
|
|
}
|
|
|
|
public override TileEntityType GetTileEntityType()
|
|
{
|
|
//return (TileEntityType)243;
|
|
return (TileEntityType)RebirthUtilities.TileEntityRebirth.TileEntityDriveableLootContainer;
|
|
}
|
|
}
|