private void ServerRemote_OnActionCompletedInternal(IItem itemVehicleRemote, ICharacter character, Vector2D mousePosition)
{
if (!(itemVehicleRemote.ProtoItem is IProtoItemVehicleRemoteControl protoRemote))
{
return;
}
if (!CharacterEnergySystem.SharedHasEnergyCharge(character, protoRemote.EngeryUse))
{
return;
}
List <GarageVehicleEntry> list = VehicleGarageSystem.ServerGetCharacterVehicles(character, false);
TakeVehicleResult result = TakeVehicleResult.Unknown;
if (list.Count > 0)
{
var privateState = itemVehicleRemote.GetPrivateState <ItemVehicleRemoteControlPrivateState>();
result = this.ServerTakeVehicle(privateState, character, mousePosition);
}
if (result == TakeVehicleResult.Success)
{
CharacterEnergySystem.ServerDeductEnergyCharge(character, protoRemote.EngeryUse);
ItemDurabilitySystem.ServerModifyDurability(itemVehicleRemote, delta: -1);
}
}
private bool SharedIsRechargeNeeded(ICharacter character)
{
var availableCapacity = CharacterEnergySystem.SharedCalculateTotalEnergyCapacity(character);
var currentCharge = CharacterEnergySystem.SharedCalculateTotalEnergyCharge(character);
if (currentCharge < availableCapacity)
{
// need to recharge
return(true);
}
// no need to recharge
if (IsClient)
{
if (availableCapacity > 0)
{
NotificationSystem.ClientShowNotification(NotificationNoRechargingRequired,
icon: this.Icon);
}
else
{
NotificationSystem.ClientShowNotification(NotificationNoPowerBanksEquipped,
icon: this.Icon);
}
}
return(false);
}
public override void SharedOnHit(
WeaponFinalCache weaponCache,
IWorldObject damagedObject,
double damage,
WeaponHitData hitData,
out bool isDamageStop)
{
base.SharedOnHit(weaponCache,
damagedObject,
damage,
hitData,
out isDamageStop);
if (IsClient)
{
// on client we cannot consume energy
return;
}
// consume energy on hit
var byCharacter = weaponCache.Character;
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(byCharacter,
this.EnergyUsePerHit);
CharacterEnergySystem.ServerDeductEnergyCharge(byCharacter, requiredEnergyAmount);
}
public override void ServerOnDestroy(IItem gameObject)
{
// try to redistribute remaining energy to other energy bank devices
var energyRemains = GetPrivateState(gameObject).EnergyCharge;
CharacterEnergySystem.ServerAddEnergyCharge(gameObject.Container,
energyRemains);
}
private void Refresh()
{
this.TotalCharge = (uint)CharacterEnergySystem.ClientCalculateTotalEnergyCharge();
this.TotalCapacity = CharacterEnergySystem.ClientCalculateTotalEnergyCapacity();
this.IndicatorVisibility = this.TotalCapacity > 0
? Visibility.Visible
: Visibility.Collapsed;
}
private void ClientRemote_NoPower()
{
if (!ReferenceEquals(this, ClientCurrentCharacterHelper.PublicState?.SelectedItem?.ProtoItem))
{
return;
}
CharacterEnergySystem.ClientShowNotificationNotEnoughEnergyCharge(this);
}
// Please note: the check SharedCanFire() has been already passed
public override bool SharedOnFire(ICharacter character, WeaponState weaponState)
{
if (IsClient)
{
// on client we cannot consume energy
return true;
}
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(character,
this.EnergyUsePerShot);
return CharacterEnergySystem.ServerDeductEnergyCharge(character, requiredEnergyAmount);
}
private void ServerRemote_ConsumeItem(IItem item)
{
var character = ServerRemoteContext.Character;
this.ServerValidateItemForRemoteCall(item, character);
if (!this.SharedIsRechargeNeeded(character))
{
return;
}
Server.Items.SetCount(item, item.Count - 1);
CharacterEnergySystem.ServerAddEnergyCharge(character, this.FuelAmount);
}
public override bool SharedCanFire(ICharacter character, WeaponState weaponState)
{
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(character,
this.EnergyUsePerShot);
if (CharacterEnergySystem.SharedHasEnergyCharge(character, requiredEnergyAmount))
{
return true;
}
if (IsClient && weaponState.SharedGetInputIsFiring())
{
CharacterEnergySystem.ClientShowNotificationNotEnoughEnergyCharge(this);
// stop using weapon item!
weaponState.ProtoWeapon.ClientItemUseFinish(weaponState.ItemWeapon);
}
return false;
}
public override bool SharedCanSelect(IItem item, ICharacter character)
{
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(
character,
this.EnergyUsePerShot + this.EnergyUsePerHit);
if (CharacterEnergySystem.SharedHasEnergyCharge(character, requiredEnergyAmount))
{
return(true);
}
if (IsClient)
{
CharacterEnergySystem.ClientShowNotificationNotEnoughEnergyCharge(this);
}
return(false);
}
protected override void ClientItemUseStart(ClientItemData data)
{
if (data.PrivateState.VehicleID == 0)
{
WindowVehicleRemoteControl.Open(data.Item);
}
else
{
var character = Api.Client.Characters.CurrentPlayerCharacter;
if (!CharacterEnergySystem.SharedHasEnergyCharge(character, this.EngeryUse))
{
CharacterEnergySystem.ClientShowNotificationNotEnoughEnergyCharge(this);
return;
}
VehicleRemoteSystem.Instance.ClientTryStartAction();
}
}
public override bool SharedCanFire(ICharacter character, WeaponState weaponState)
{
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(
character,
this.EnergyUsePerShot + this.EnergyUsePerHit);
if (CharacterEnergySystem.SharedHasEnergyCharge(character, requiredEnergyAmount))
{
return(true);
}
if (IsClient && weaponState.SharedGetInputIsFiring())
{
CharacterEnergySystem.ClientShowNotificationNotEnoughEnergyCharge(this);
weaponState.ProtoWeapon.ClientItemUseFinish(weaponState.ItemWeapon);
ClientHotbarSelectedItemManager.SelectedSlotId = null;
}
return(false);
}
public override void ServerOnDamageApplied(
IItem weapon,
ICharacter byCharacter,
IWorldObject damagedObject,
double damage)
{
base.ServerOnDamageApplied(weapon, byCharacter, damagedObject, damage);
if (IsClient)
{
// on client we cannot deduct energy
return;
}
// deduct energy on hit
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(
byCharacter,
this.EnergyUsePerHit);
CharacterEnergySystem.ServerDeductEnergyCharge(byCharacter, requiredEnergyAmount);
}
public override bool SharedCanSelect(IItem item, ICharacter character, bool isAlreadySelected, bool isByPlayer)
{
if (!base.SharedCanSelect(item, character, isAlreadySelected, isByPlayer))
{
return(false);
}
var requiredEnergyAmount = SkillWeaponsEnergy.SharedGetRequiredEnergyAmount(
character,
this.EnergyUsePerShot + this.EnergyUsePerHit);
if (CharacterEnergySystem.SharedHasEnergyCharge(character, requiredEnergyAmount))
{
return(true);
}
// cannot select
if (IsClient && isByPlayer)
{
CharacterEnergySystem.ClientShowNotificationNotEnoughEnergyCharge(this);
}
return(false);
}
protected override void ServerUpdate(ServerUpdateData data)
{
var item = data.GameObject;
var privateState = data.PrivateState;
var character = item.Container.OwnerAsCharacter;
if (!IsItemSelectedByPlayer(character, item))
{
// not a selected player item
this.ServerSetUpdateRate(item, isRare: true);
return;
}
privateState.ServerTimeToPing -= data.DeltaTime;
if (privateState.ServerTimeToPing > 0)
{
return;
}
privateState.ServerTimeToPing = ServerScanInterval;
if (!CharacterEnergySystem.ServerDeductEnergyCharge(
character,
requiredEnergyAmount: this.EnergyConsumptionPerSecond * ServerScanInterval))
{
// no power
this.CallClient(character, _ => _.ClientRemote_NoPower());
return;
}
ItemDurabilitySystem.ServerModifyDurability(
item,
delta: -(int)Math.Round(this.DurabilityDecreasePerSecond * ServerScanInterval));
if (item.IsDestroyed)
{
// zero durability reached
return;
}
// update signal strength
using var tempSignalStrength = Api.Shared.GetTempList <byte>();
this.ServerCalculateStrengthToTheClosestPragmiumSpires(character,
tempSignalStrength.AsList(),
MaxNumberOfPongsPerScan);
var previousSignalStrength = -1;
foreach (var signalStrength in tempSignalStrength.AsList())
{
if (signalStrength == previousSignalStrength)
{
// don't send multiple pongs for the signals of the same strength
continue;
}
previousSignalStrength = signalStrength;
var serverTimeToPong = SharedCalculateTimeToPong(signalStrength);
ServerTimersSystem.AddAction(
serverTimeToPong,
() =>
{
var currentCharacter = item.Container.OwnerAsCharacter;
if (IsItemSelectedByPlayer(currentCharacter, item))
{
this.CallClient(currentCharacter,
_ => _.ClientRemote_OnSignal(item,
PragmiumSensorSignalKind.Pong));
}
});
//Logger.Dev(string.Format("Pragmium scanner signal: {0} strength. Time to send pong: {1} ms.",
// signalStrength,
// (int)(serverTimeToPong * 1000)));
}
this.CallClient(character, _ => _.ClientRemote_OnSignal(item, PragmiumSensorSignalKind.Ping));
bool IsItemSelectedByPlayer(ICharacter c, IItem i)
=> c is not null &&
ReferenceEquals(i, c.SharedGetPlayerSelectedHotbarItem());
}
