private static bool ServerProcessDecay(IStaticWorldObject worldObject, double serverTime, double deltaTime)
{
if (worldObject.IsDestroyed)
{
return(false);
}
if (!(worldObject.ProtoStaticWorldObject is IProtoObjectStructure protoObjectStructure))
{
// not a structure
return(false);
}
var privateState = worldObject.GetPrivateState <StructurePrivateState>();
if (serverTime < privateState.ServerDecayStartTime)
{
// this structure is not decaying
return(false);
}
// need to decay this object
if (LandClaimSystem.SharedIsLandClaimedByAnyone(worldObject.TilePosition))
{
// the object is in a land claim area
if (!(worldObject.ProtoStaticWorldObject is IProtoObjectLandClaim))
{
// only the land claim object can decay in the land claim area
return(false);
}
}
protoObjectStructure.ServerApplyDecay(worldObject, deltaTime);
return(true);
}
public ViewModelWindowTurret(IStaticWorldObject worldObjectTurret)
{
this.worldObjectTurret = worldObjectTurret;
this.privateState = worldObjectTurret.GetPrivateState <ObjectTurretPrivateState>();
this.TurretModes = Enum.GetValues(typeof(TurretMode))
.Cast <TurretMode>()
.ExceptOne(TurretMode.Disabled)
.Select(e => new ViewModelEnum <TurretMode>(e))
.OrderBy(vm => vm.Order)
.ToArray();
this.selectedTurretMode = this.privateState.TurretMode;
this.privateState.ClientSubscribe(_ => _.TurretMode,
_ => this.RefreshTurretMode(),
this);
this.containerAmmo = this.privateState.ContainerAmmo as IClientItemsContainer;
if (this.containerAmmo is not null)
{
this.containerAmmo.StateHashChanged += this.ContainerAmmoStateHashChanged;
this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange(this.containerAmmo)
{
ContainerTitle = CoreStrings.Vehicle_Ammo,
IsManagementButtonsVisible = false
};
this.ProtoItemWeapon =
((BaseItemsContainerTurretAmmo)this.ViewModelItemsContainerExchange.Container.ProtoGameObject)
.ProtoWeapon;
}
this.RefreshTurretMode();
}
private void ServerRemote_SetMode(IStaticWorldObject worldObject, WorldObjectAccessMode mode)
{
var character = ServerRemoteContext.Character;
if (!InteractionCheckerSystem.SharedHasInteraction(character,
worldObject,
requirePrivateScope: true))
{
throw new Exception("The player character is not interacting with " + worldObject);
}
if (!WorldObjectOwnersSystem.SharedIsOwner(character, worldObject) &&
!CreativeModeSystem.SharedIsInCreativeMode(character))
{
throw new Exception("The player character is not the owner of " + worldObject);
}
if (!(worldObject.ProtoStaticWorldObject is IProtoObjectWithAccessMode protoObjectWithAccessMode))
{
throw new Exception("This world object doesn't have an access mode");
}
if (mode == WorldObjectAccessMode.Closed &&
!protoObjectWithAccessMode.IsClosedAccessModeAvailable)
{
throw new Exception("Closed access mode is not supported for " + protoObjectWithAccessMode);
}
var privateState = worldObject.GetPrivateState <IObjectWithAccessModePrivateState>();
privateState.AccessMode = mode;
Logger.Important($"Access mode changed: {mode}; {worldObject}", character);
}
public ViewModelWindowLaunchpad(IStaticWorldObject worldObject)
{
this.worldObject = worldObject;
this.protoObjectLaunchpad = (ProtoObjectLaunchpad)worldObject.ProtoGameObject;
this.privateState = worldObject.GetPrivateState <ObjectLaunchpadPrivateState>();
this.publicState = worldObject.GetPublicState <ObjectLaunchpadPublicState>();
this.publicState.ClientSubscribe(_ => _.LaunchServerFrameTime,
_ => this.NotifyPropertyChanged(nameof(this.IsLaunched)),
this);
this.publicState.ClientSubscribe(_ => _.LaunchedByPlayerName,
_ => this.NotifyPropertyChanged(nameof(this.LaunchedByPlayerName)),
this);
this.Tasks = this.protoObjectLaunchpad
.TasksList
.Select((task, taskIndex) =>
new ViewModelLaunchpadTask(worldObject, task, taskIndex, this.privateState))
.ToArray();
this.privateState.ClientSubscribe(_ => _.TaskCompletionState,
_ => this.NotifyPropertyChanged(nameof(this.IsUpgradeAvailable)),
this);
if (this.protoObjectLaunchpad.ConfigUpgrade.Entries.Count > 0)
{
this.ViewModelStructureUpgrade =
new ViewModelStructureUpgrade(this.protoObjectLaunchpad.ConfigUpgrade.Entries[0]);
}
}
public ViewModelWorldObjectAccessModeEditor(IStaticWorldObject worldObject, bool canSetAccessMode)
{
this.worldObject = worldObject;
this.CanSetAccessMode = canSetAccessMode;
if (!(worldObject.ProtoStaticWorldObject is IProtoObjectWithAccessMode protoObjectWithAccessMode))
{
throw new Exception("This world object doesn't have an access mode");
}
var accessModes = Enum.GetValues(typeof(WorldObjectAccessMode))
.Cast <WorldObjectAccessMode>();
if (!protoObjectWithAccessMode.IsClosedAccessModeAvailable)
{
accessModes = accessModes.ExceptOne(WorldObjectAccessMode.Closed);
}
this.AccessModes = accessModes
.Select(e => new ViewModelEnum <WorldObjectAccessMode>(e))
.OrderBy(vm => vm.Order)
.ToArray();
this.privateState = worldObject.GetPrivateState <IObjectWithAccessModePrivateState>();
this.privateState.ClientSubscribe(
_ => _.AccessMode,
_ => this.RefreshAccessMode(),
this);
this.RefreshAccessMode();
}
public static void ServerRefreshLandClaimObject(IStaticWorldObject worldObject)
{
if (worldObject.IsDestroyed)
{
return;
}
if (!(worldObject.ProtoStaticWorldObject is IProtoObjectLandClaim))
{
// not a land claim structure
return;
}
var area = LandClaimSystem.ServerGetLandClaimArea(worldObject);
if (area == null)
{
// incorrect land claim - no area attached
return;
}
var areaBounds = LandClaimSystem.SharedGetLandClaimAreaBounds(area);
var owners = LandClaimArea.GetPrivateState(area).LandOwners;
foreach (var owner in owners)
{
var character = Server.Characters.GetPlayerCharacter(owner);
if (character == null ||
!character.IsOnline)
{
continue;
}
if (!areaBounds.Contains(character.TilePosition))
{
continue;
}
// the land claim contains an online owner character
// reset the decay timer for this land claim
StructureDecaySystem.ServerResetDecayTimer(
worldObject.GetPrivateState <StructurePrivateState>());
using (var tempVisitedAreas = Api.Shared.WrapObjectInTempList(area))
{
ServerResetDecayTimerRecursively(tempVisitedAreas.AsList(),
areaBounds,
character);
}
return;
}
}
public static bool ServerHasAccess(
IStaticWorldObject worldObject,
ICharacter character,
bool writeToLog)
{
var privateState = worldObject.GetPrivateState <IObjectWithAccessModePrivateState>();
return(ServerHasAccess(worldObject,
character,
privateState.AccessMode,
writeToLog));
}
private static bool ServerProcessDecay(IStaticWorldObject worldObject, double serverTime)
{
if (worldObject.IsDestroyed)
{
return(false);
}
var protoObjectStructure = worldObject.ProtoStaticWorldObject as IProtoObjectStructure;
if (protoObjectStructure == null)
{
// not a structure
return(false);
}
var privateState = worldObject.GetPrivateState <StructurePrivateState>();
if (serverTime < privateState.ServerDecayStartTime)
{
// this structure is not decaying
return(false);
}
// need to decay this object
var landClaimArea = LandClaimSystem.SharedGetAreaAtPosition(worldObject.TilePosition);
if (landClaimArea != null)
{
// the object is in a land claim area
if (!(worldObject.ProtoStaticWorldObject is IProtoObjectLandClaim))
{
// only the land claim object can decay in the land claim area
return(false);
}
// this is a land claim object so it could decay
// but first, ensure that it will not decay if there are any online owners nearby
StructureLandClaimDecayResetSystem.ServerRefreshLandClaimObject(worldObject);
if (serverTime < privateState.ServerDecayStartTime)
{
// this land claim object is not decaying anymore (the timer has been just reset)
return(false);
}
}
protoObjectStructure.ServerApplyDecay(
worldObject,
deltaTime: StructureConstants.StructureDecaySystemUpdateIntervalSeconds);
return(true);
}
private void ServerRemote_SetDirectAccessMode(IStaticWorldObject worldObject, WorldObjectDirectAccessMode mode)
{
var character = ServerRemoteContext.Character;
if (!(worldObject.ProtoGameObject is IProtoObjectWithAccessMode protoObjectWithAccessMode))
{
throw new Exception("This world object doesn't have an access mode");
}
if (!protoObjectWithAccessMode.SharedCanInteract(character, worldObject, writeToLog: true))
{
return;
}
var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(worldObject);
if (areasGroup is not null &&
LandClaimAreasGroup.GetPublicState(areasGroup).ServerFaction is not null)
{
throw new Exception(
"Cannot modify direct access mode for an object within a faction land claim area");
}
if (!WorldObjectOwnersSystem.SharedIsOwner(character, worldObject) &&
!CreativeModeSystem.SharedIsInCreativeMode(character))
{
throw new Exception("The player character is not an owner of " + worldObject);
}
if (mode == WorldObjectDirectAccessMode.Closed &&
!protoObjectWithAccessMode.IsClosedAccessModeAvailable)
{
throw new Exception("Closed access mode is not supported for " + protoObjectWithAccessMode);
}
if (mode == WorldObjectDirectAccessMode.OpensToEveryone &&
!protoObjectWithAccessMode.IsEveryoneAccessModeAvailable)
{
throw new Exception("Everyone access mode is not supported for " + protoObjectWithAccessMode);
}
var privateState = worldObject.GetPrivateState <IObjectWithAccessModePrivateState>();
if (privateState.DirectAccessMode == mode)
{
return;
}
privateState.DirectAccessMode = mode;
Logger.Info($"Direct access mode changed: {mode}; {worldObject}", character);
}
public ViewModelWindowPowerThresholdsConfiguration(
IStaticWorldObject worldObject,
Action callbackSave,
Action callbackCancel)
{
this.worldObject = worldObject;
this.callbackCancel = callbackCancel;
this.callbackSave = callbackSave;
this.IsElectricityProducer = worldObject.ProtoGameObject is IProtoObjectElectricityProducer;
var privateState = worldObject.GetPrivateState <IObjectElectricityStructurePrivateState>();
this.ApplyPreset(privateState.ElectricityThresholds);
}
public static void ClientSetElectricityThresholds(
IStaticWorldObject worldObject,
ElectricityThresholdsPreset thresholds)
{
thresholds = thresholds.Normalize(
isProducer: worldObject.ProtoGameObject is IProtoObjectElectricityProducer);
if (thresholds.Equals(worldObject.GetPrivateState <IObjectElectricityStructurePrivateState>()
.ElectricityThresholds))
{
// no changes
return;
}
Instance.CallServer(_ => _.ServerRemote_SetElectricityThresholds(worldObject, thresholds));
}
public ViewModelWindowLandClaim(
IStaticWorldObject landClaimWorldObject,
ILogicObject area)
{
this.landClaimWorldObject = landClaimWorldObject;
this.privateState = LandClaimArea.GetPrivateState(area);
var protoStructureWithOwnersList =
((IProtoObjectWithOwnersList)landClaimWorldObject.ProtoStaticWorldObject);
var canEditOwners = protoStructureWithOwnersList
.SharedCanEditOwners(landClaimWorldObject, ClientCurrentCharacterHelper.Character);
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
this.privateState.LandOwners,
callbackServerSetOwnersList: ownersList => LandClaimSystem.ClientSetAreaOwners(
area,
ownersList),
title: AccessListTitle + ":",
emptyListMessage: AccessListEmpty,
canEditOwners: canEditOwners,
// exclude founder name
ownersListFilter: name => name != this.FounderName);
this.protoObjectLandClaim =
(IProtoObjectLandClaim)this.landClaimWorldObject.ProtoStaticWorldObject;
var upgrade = this.protoObjectLandClaim.ConfigUpgrade.Entries.FirstOrDefault();
if (upgrade != null)
{
this.ViewModelStructureUpgrade = new ViewModelStructureUpgrade(upgrade);
this.ViewModelProtoLandClaimInfoUpgrade = new ViewModelProtoLandClaimInfo(
(IProtoObjectLandClaim)upgrade.ProtoStructure);
}
this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange(
landClaimWorldObject.GetPrivateState <ObjectLandClaimPrivateState>().ItemsContainer,
callbackTakeAllItemsSuccess: () => { })
{
IsContainerTitleVisible = false
};
this.ViewModelProtoLandClaimInfoCurrent = new ViewModelProtoLandClaimInfo(this.protoObjectLandClaim);
}
public ViewModelWorldObjectDirectAccessEditor(IStaticWorldObject worldObject, bool canSetAccessMode)
{
this.worldObject = worldObject;
this.CanSetAccessMode = canSetAccessMode;
if (!(worldObject.ProtoGameObject is IProtoObjectWithAccessMode protoObjectWithAccessMode))
{
throw new Exception("This world object doesn't have an access mode");
}
IEnumerable <WorldObjectDirectAccessMode> accessModes
= EnumExtensions.GetValues <WorldObjectDirectAccessMode>();
if (!protoObjectWithAccessMode.IsClosedAccessModeAvailable)
{
accessModes = accessModes.ExceptOne(WorldObjectDirectAccessMode.Closed);
}
if (!protoObjectWithAccessMode.IsEveryoneAccessModeAvailable)
{
accessModes = accessModes.ExceptOne(WorldObjectDirectAccessMode.OpensToEveryone);
}
this.AccessModes = accessModes
.Select(e => new ViewModelAccessMode(e))
.OrderBy(vm => vm.Order)
.ToArray();
this.privateState = worldObject.GetPrivateState <IObjectWithAccessModePrivateState>();
this.privateState.ClientSubscribe(
_ => _.DirectAccessMode,
_ => this.RefreshAccessMode(),
this);
this.RefreshAccessMode();
}
private static ObjectTradingStationPrivateState GetPrivateState(IStaticWorldObject tradingStation)
{
return(tradingStation.GetPrivateState <ObjectTradingStationPrivateState>());
}
private static IObjectWithOwnersPrivateState GetPrivateState(IStaticWorldObject structure)
{
return(structure.GetPrivateState <IObjectWithOwnersPrivateState>());
}