protected override void ServerInitialize(ServerInitializeData data)
{
base.ServerInitialize(data);
var worldObject = data.GameObject;
WorldObjectOwnersSystem.ServerInitialize(worldObject);
if (!data.IsFirstTimeInit)
{
return;
}
var publicState = data.PublicState;
var privateState = data.PrivateState;
privateState.AccessMode = WorldObjectAccessMode.OpensToObjectOwnersOrAreaOwners;
// refresh door type
publicState.IsHorizontalDoor = DoorHelper.IsHorizontalDoorNeeded(worldObject.OccupiedTile,
checkExistingDoor: false);
publicState.IsOpened = true;
// refresh nearby door types (horizontal/vertical)
DoorHelper.RefreshNeighborDoorType(worldObject.OccupiedTile);
SharedWallConstructionRefreshHelper.SharedRefreshNeighborObjects(
data.GameObject.OccupiedTile,
isDestroy: false);
}
public ViewModelWindowDoor(IStaticWorldObject worldObjectDoor)
{
var protoObjectDoor = (IProtoObjectDoor)worldObjectDoor.ProtoStaticWorldObject;
this.privateState = protoObjectDoor.GetPrivateState(worldObjectDoor);
this.IsInsideFactionClaim = LandClaimSystem.SharedIsWorldObjectOwnedByFaction(worldObjectDoor);
if (this.IsInsideFactionClaim)
{
this.ViewModelFactionAccessEditor = new ViewModelWorldObjectFactionAccessEditorControl(
worldObjectDoor);
}
else
{
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
this.privateState.Owners,
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(worldObjectDoor,
ownersList),
title: CoreStrings.ObjectOwnersList_Title2,
maxOwnersListLength: StructureConstants.SharedDoorOwnersMax);
this.ViewModelDirectAccessEditor = new ViewModelWorldObjectDirectAccessEditor(
worldObjectDoor,
canSetAccessMode: true);
}
this.privateState.ClientSubscribe(_ => _.IsBlockedByShield,
_ => this.NotifyPropertyChanged(nameof(this.IsBlockedByShield)),
this);
}
public override bool SharedCanInteract(ICharacter character, IStaticWorldObject worldObject, bool writeToLog)
{
if (!base.SharedCanInteract(character, worldObject, writeToLog))
{
return(false);
}
if (LandClaimSystem.SharedIsObjectInsideOwnedOrFreeArea(worldObject, character) ||
CreativeModeSystem.SharedIsInCreativeMode(character))
{
return(true);
}
// not the land owner
if (writeToLog)
{
Logger.Warning(
$"Character cannot interact with {worldObject} - not the land owner.",
character);
if (IsClient)
{
WorldObjectOwnersSystem.ClientOnCannotInteractNotOwner(worldObject);
}
}
return(false);
}
public ViewModelWindowTradingStationAdmin(
IStaticWorldObject worldObjectTradingStation,
ObjectTradingStationPrivateState privateState,
ObjectTradingStationPublicState publicState)
{
this.worldObjectTradingStation = worldObjectTradingStation;
this.IsInsideFactionClaim = LandClaimSystem.SharedIsWorldObjectOwnedByFaction(worldObjectTradingStation);
if (!this.IsInsideFactionClaim)
{
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
privateState.Owners,
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(worldObjectTradingStation, ownersList),
title: CoreStrings.ObjectOwnersList_Title);
}
this.ViewModelStockContainerExchange = new ViewModelItemsContainerExchange(
privateState.StockItemsContainer);
this.Lots = publicState.Lots.Select(l => new ViewModelTradingStationLot(l, this.LotEditorSaveHandler))
.ToList();
this.isStationSellingMode = publicState.Mode == TradingStationMode.StationSelling;
}
private static List <GarageVehicleEntry> ServerGetCharacterVehicles(
ICharacter character,
bool onlyVehiclesInGarage)
{
var result = new List <GarageVehicleEntry>();
var allVehicles = Server.World.GetWorldObjectsOfProto <IProtoVehicle>();
// ReSharper disable once PossibleInvalidCastExceptionInForeachLoop
foreach (IDynamicWorldObject vehicle in allVehicles)
{
if (WorldObjectOwnersSystem.SharedIsOwner(character, vehicle))
{
var vehicleStatus = ServerGetVehicleStatus(vehicle, forCharacter: character);
if (onlyVehiclesInGarage &&
vehicleStatus != VehicleStatus.InGarage)
{
continue;
}
result.Add(new GarageVehicleEntry(vehicle,
vehicleStatus));
}
}
return(result);
}
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 static bool ServerHasAccess(
IStaticWorldObject worldObject,
ICharacter character,
WorldObjectAccessMode currentAccessMode,
bool writeToLog)
{
if (CreativeModeSystem.SharedIsInCreativeMode(character))
{
return(true);
}
switch (currentAccessMode)
{
case WorldObjectAccessMode.Closed:
default:
if (writeToLog)
{
Logger.Warning(
$"Character cannot interact with {worldObject} - no access.",
character);
Instance.CallClient(
character,
_ => _.ClientRemote_OnCannotInteractNoAccess(worldObject));
}
return(false);
case WorldObjectAccessMode.OpensToEveryone:
return(true);
case WorldObjectAccessMode.OpensToObjectOwners:
case WorldObjectAccessMode.OpensToObjectOwnersOrAreaOwners:
{
if (WorldObjectOwnersSystem.SharedIsOwner(character, worldObject))
{
// an object owner
return(true);
}
// not an object owner
if (currentAccessMode == WorldObjectAccessMode.OpensToObjectOwnersOrAreaOwners)
{
if (LandClaimSystem.SharedIsOwnedLand(worldObject.TilePosition, character, out _))
{
// an area owner
return(true);
}
}
// not an object owner and not an area owner
if (writeToLog)
{
WorldObjectOwnersSystem.ServerNotifyNotOwner(character, worldObject);
}
return(false);
}
}
}
public ViewModelWindowCrateContainer(
IStaticWorldObject worldObjectCrate,
ObjectCratePrivateState privateState,
Action callbackCloseWindow)
{
this.WorldObjectCrate = worldObjectCrate;
this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange(
privateState.ItemsContainer,
callbackCloseWindow)
{
IsContainerTitleVisible = false
};
var isOwner = WorldObjectOwnersSystem.SharedIsOwner(
ClientCurrentCharacterHelper.Character,
worldObjectCrate);
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
privateState.Owners,
canEditOwners: isOwner ||
CreativeModeSystem.ClientIsInCreativeMode(),
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(this.WorldObjectCrate,
ownersList),
title: CoreStrings.ObjectOwnersList_Title2);
this.ViewModelAccessModeEditor = new ViewModelWorldObjectAccessModeEditor(
worldObjectCrate,
canSetAccessMode: isOwner);
}
public static void ServerTryAddMark(IStaticWorldObject tradingStation)
{
var owners = WorldObjectOwnersSystem.SharedGetOwners(tradingStation);
if (owners.Count == 0)
{
// no owners - incomplete trading station
// (first owner set when the trading station instance spawned and ServerOnBuilt method called in ProtoTradingStation)
return;
}
if (!ServerIsTradingStationHasActiveLots(tradingStation))
{
return;
}
if (!ServerActiveTradingStations.Add(tradingStation))
{
// already added
return;
}
var allOnlinePlayers = Server.Characters.EnumerateAllPlayerCharacters(onlyOnline: true);
foreach (var onlinePlayer in allOnlinePlayers)
{
var isOwner = owners.Contains(onlinePlayer.Name);
var mark = new TradingStationMark(tradingStation.Id,
tradingStation.TilePosition,
isOwner);
Instance.CallClient(onlinePlayer,
_ => _.ClientRemote_MarkAdded(mark));
}
}
void IInteractableProtoStaticWorldObject.ServerOnClientInteract(ICharacter who, IStaticWorldObject worldObject)
{
if (WorldObjectOwnersSystem.SharedIsOwner(who, worldObject))
{
Server.World.EnterPrivateScope(who, worldObject);
}
}
protected override void ServerInitialize(ServerInitializeData data)
{
base.ServerInitialize(data);
var worldObject = data.GameObject;
var privateState = data.PrivateState;
if (data.IsFirstTimeInit)
{
privateState.AccessMode = WorldObjectAccessMode.OpensToObjectOwnersOrAreaOwners;
}
WorldObjectOwnersSystem.ServerInitialize(worldObject);
var itemsContainer = privateState.ItemsContainer;
if (itemsContainer != null)
{
// container already created - update slots count
Server.Items.SetSlotsCount(itemsContainer, slotsCount: this.ItemsSlotsCount);
return;
}
itemsContainer = Server.Items.CreateContainer(
owner: worldObject,
itemsContainerType: this.ItemsContainerType,
slotsCount: this.ItemsSlotsCount);
privateState.ItemsContainer = itemsContainer;
}
void IInteractableProtoWorldObject.ServerOnClientInteract(ICharacter who, IWorldObject worldObject)
{
if (WorldObjectOwnersSystem.SharedIsOwner(who, (IStaticWorldObject)worldObject) ||
CreativeModeSystem.SharedIsInCreativeMode(who))
{
Server.World.EnterPrivateScope(who, worldObject);
}
}
private static bool ServerCanCharacterPutVehicleIntoGarage(IDynamicWorldObject vehicle, ICharacter byCharacter)
{
if (!WorldObjectOwnersSystem.SharedIsOwner(byCharacter, vehicle))
{
return(false);
}
var status = ServerGetVehicleStatus(vehicle, byCharacter);
return(status == VehicleStatus.Docked ||
status == VehicleStatus.InWorld);
}
private void ServerRemote_TransferToFactionOwnership(IDynamicWorldObject vehicle)
{
var character = ServerRemoteContext.Character;
if (vehicle.ProtoGameObject is not IProtoVehicle)
{
throw new Exception("Not a vehicle");
}
if (!vehicle.ProtoWorldObject.SharedCanInteract(character,
vehicle,
writeToLog: true))
{
return;
}
var publicState = vehicle.GetPublicState <VehiclePublicState>();
if (!string.IsNullOrEmpty(publicState.ClanTag))
{
Logger.Warning("Already in faction ownership: " + vehicle, character);
return;
}
var faction = FactionSystem.ServerGetFaction(character);
if (faction is null)
{
throw new Exception("Player has no faction");
}
/*if (FactionSystem.SharedGetFactionKind(faction)
* == FactionKind.Public)
* {
* throw new Exception("Cannot transfer a vehicle to ownership of a public faction");
* }*/
var clanTag = FactionSystem.SharedGetClanTag(faction);
publicState.ClanTag = clanTag;
var privateState = vehicle.GetPrivateState <VehiclePrivateState>();
//privateState.Owners.Clear(); // keep the original owners list in case the faction is dissolved
privateState.FactionAccessMode = WorldObjectFactionAccessModes.Leader
| WorldObjectFactionAccessModes.Officer1
| WorldObjectFactionAccessModes.Officer2
| WorldObjectFactionAccessModes.Officer3;
Logger.Important($"Vehicle transferred to faction ownership: {vehicle} - [{clanTag}]", character);
WorldObjectOwnersSystem.ServerOnOwnersChanged(vehicle);
}
private static void ValidateCanAdminAndInteract(ICharacter character, IStaticWorldObject tradingStation)
{
if (!tradingStation.ProtoStaticWorldObject
.SharedCanInteract(character, tradingStation, writeToLog: true))
{
throw new Exception($"{character} cannot interact with {tradingStation}");
}
if (!WorldObjectOwnersSystem.SharedIsOwner(character, tradingStation))
{
throw new Exception($"{character} is not owner of {tradingStation}");
}
}
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 ViewModelWindowCrateContainer(
IStaticWorldObject worldObjectCrate,
ObjectCratePrivateState privateState,
Action callbackCloseWindow)
{
this.WorldObjectCrate = worldObjectCrate;
this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange(
privateState.ItemsContainer,
callbackCloseWindow)
{
IsContainerTitleVisible = false
};
this.IsInsideFactionClaim = LandClaimSystem.SharedIsWorldObjectOwnedByFaction(worldObjectCrate);
if (!this.HasOwnersList)
{
return;
}
if (this.IsInsideFactionClaim)
{
if (FactionSystem.ClientHasAccessRight(FactionMemberAccessRights.LandClaimManagement))
{
this.ViewModelFactionAccessEditor = new ViewModelWorldObjectFactionAccessEditorControl(
worldObjectCrate);
}
}
else
{
var isOwner = WorldObjectOwnersSystem.SharedIsOwner(
ClientCurrentCharacterHelper.Character,
worldObjectCrate);
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
privateState.Owners,
canEditOwners: isOwner ||
CreativeModeSystem.ClientIsInCreativeMode(),
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(this.WorldObjectCrate,
ownersList),
title: CoreStrings.ObjectOwnersList_Title2);
this.ViewModelDirectAccessEditor = new ViewModelWorldObjectDirectAccessEditor(
worldObjectCrate,
canSetAccessMode: isOwner);
}
}
public ViewModelWindowDoor(
IStaticWorldObject worldObjectDoor)
{
var protoObjectDoor = (IProtoObjectDoor)worldObjectDoor.ProtoStaticWorldObject;
var privateState = protoObjectDoor.GetPrivateState(worldObjectDoor);
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
privateState.Owners,
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(worldObjectDoor, ownersList),
title: CoreStrings.ObjectOwnersList_Title + ":");
this.ViewModelAccessModeEditor = new ViewModelWorldObjectAccessModeEditor(
worldObjectDoor,
canSetAccessMode: true);
}
private static void ServerFactionDissolvedHandler(string clanTag)
{
foreach (var vehicle in Server.World.GetWorldObjectsOfProto <IProtoVehicle>())
{
var publicState = vehicle.GetPublicState <VehiclePublicState>();
if (publicState.ClanTag != clanTag)
{
continue;
}
publicState.ClanTag = null;
Logger.Important("Faction-owned vehicle returned to non-faction ownership: " + vehicle);
WorldObjectOwnersSystem.ServerOnOwnersChanged(vehicle);
}
}
private void ServerRemote_RequestMarks()
{
var character = ServerRemoteContext.Character;
var result = new List <TradingStationMark>(capacity: ServerTradingStationsList.Count);
// add to the character private scope all owned areas
foreach (var tradingStation in ServerTradingStationsList)
{
var isOwner = WorldObjectOwnersSystem.SharedIsOwner(character, tradingStation);
result.Add(new TradingStationMark(tradingStation.Id,
tradingStation.TilePosition,
isOwner));
}
this.CallClient(character, _ => _.ClientRemote_MarksRequestResult(result));
}
public IReadOnlyList <GarageVehicleEntry> ServerRemote_GetCharacterVehicles()
{
var character = ServerRemoteContext.Character;
var result = new List <GarageVehicleEntry>();
var allVehicles = Server.World.GetWorldObjectsOfProto <IProtoVehicle>();
foreach (IDynamicWorldObject vehicle in allVehicles)
{
if (!WorldObjectOwnersSystem.SharedIsOwner(character, vehicle))
{
continue;
}
var vehicleStatus = ServerGetVehicleStatus(vehicle, forCharacter: character);
result.Add(new GarageVehicleEntry(vehicle,
vehicleStatus));
}
return(result);
}
public ViewModelWindowTradingStationAdmin(
IStaticWorldObject worldObjectTradingStation,
ObjectTradingStationPrivateState privateState,
ObjectTradingStationPublicState publicState)
{
this.worldObjectTradingStation = worldObjectTradingStation;
this.ViewModelOwnersEditor = new ViewModelWorldObjectOwnersEditor(
privateState.Owners,
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(worldObjectTradingStation, ownersList),
title: CoreStrings.ObjectOwnersList_Title);
this.ViewModelStockContainerExchange = new ViewModelItemsContainerExchange(
privateState.StockItemsContainer,
callbackTakeAllItemsSuccess: () => { });
this.Lots = publicState.Lots.Select(l => new ViewModelTradingStationLot(l, this.LotEditorSaveHandler))
.ToList();
this.isStationSellingMode = publicState.Mode == TradingStationMode.StationSelling;
}
protected override void ServerInitialize(ServerInitializeData data)
{
base.ServerInitialize(data);
var worldObject = data.GameObject;
var privateState = data.PrivateState;
if (data.IsFirstTimeInit)
{
privateState.DirectAccessMode = this.HasOwnersList
? WorldObjectDirectAccessMode.OpensToObjectOwnersOrAreaOwners
: WorldObjectDirectAccessMode.OpensToEveryone;
privateState.FactionAccessMode = WorldObjectFactionAccessModes.AllFactionMembers;
}
else if (!this.HasOwnersList)
{
privateState.DirectAccessMode = WorldObjectDirectAccessMode.OpensToEveryone;
}
WorldObjectOwnersSystem.ServerInitialize(worldObject);
var itemsContainer = privateState.ItemsContainer;
if (itemsContainer is not null)
{
// container already created - update slots count
Server.Items.SetSlotsCount(itemsContainer, slotsCount: this.ItemsSlotsCount);
return;
}
itemsContainer = Server.Items.CreateContainer(
owner: worldObject,
itemsContainerType: this.ItemsContainerType,
slotsCount: this.ItemsSlotsCount);
privateState.ItemsContainer = itemsContainer;
}
protected override void ServerInitialize(ServerInitializeData data)
{
base.ServerInitialize(data);
var worldObject = data.GameObject;
var privateState = data.PrivateState;
WorldObjectOwnersSystem.ServerInitialize(worldObject);
if (!data.IsFirstTimeInit)
{
if (!this.HasOwnersList)
{
privateState.AccessMode = WorldObjectAccessMode.OpensToEveryone;
}
return;
}
var publicState = data.PublicState;
privateState.AccessMode = this.HasOwnersList
? WorldObjectAccessMode.OpensToObjectOwnersOrAreaOwners
: WorldObjectAccessMode.OpensToEveryone;
// refresh door type
publicState.IsHorizontalDoor = this.IsHorizontalDoorOnly
?? DoorHelper.IsHorizontalDoorNeeded(worldObject.OccupiedTile,
checkExistingDoor: false);
publicState.IsOpened = true;
foreach (var occupiedTile in worldObject.OccupiedTiles)
{
SharedWallConstructionRefreshHelper.SharedRefreshNeighborObjects(occupiedTile,
isDestroy: false);
}
}
public override bool SharedCanInteract(ICharacter character, IStaticWorldObject worldObject, bool writeToLog)
{
return(base.SharedCanInteract(character, worldObject, writeToLog) &&
WorldObjectOwnersSystem.SharedCanInteract(character, worldObject, writeToLog));
}
public override void ServerOnBuilt(IStaticWorldObject structure, ICharacter byCharacter)
{
WorldObjectOwnersSystem.ServerOnBuilt(structure, byCharacter);
}
public static bool ServerHasAccess(
IWorldObject worldObject,
ICharacter character,
WorldObjectDirectAccessMode directAccessMode,
WorldObjectFactionAccessModes factionAccessModes,
bool writeToLog)
{
if (worldObject is IStaticWorldObject staticWorldObject)
{
if (LandClaimSystem.SharedIsWorldObjectOwnedByFaction(staticWorldObject, out var clanTag))
{
if (ServerHasFactionAccess(character, clanTag, factionAccessModes))
{
return(true);
}
if (writeToLog)
{
Logger.Warning(
$"Character cannot interact with {worldObject} - no access.",
character);
Instance.CallClient(
character,
_ => _.ClientRemote_OnCannotInteractNoAccess(worldObject));
}
return(false);
}
}
else if (worldObject.ProtoGameObject is IProtoVehicle)
{
var clanTag = worldObject.GetPublicState <VehiclePublicState>().ClanTag;
if (string.IsNullOrEmpty(clanTag))
{
// the vehicles don't have direct access mode, any owner has access
return(false);
}
return(ServerHasFactionAccess(character, clanTag, factionAccessModes));
}
switch (directAccessMode)
{
case WorldObjectDirectAccessMode.Closed:
default:
if (writeToLog)
{
Logger.Warning(
$"Character cannot interact with {worldObject} - no access.",
character);
Instance.CallClient(
character,
_ => _.ClientRemote_OnCannotInteractNoAccess(worldObject));
}
return(false);
case WorldObjectDirectAccessMode.OpensToEveryone:
return(true);
case WorldObjectDirectAccessMode.OpensToObjectOwners:
case WorldObjectDirectAccessMode.OpensToObjectOwnersOrAreaOwners:
{
if (WorldObjectOwnersSystem.SharedIsOwner(character, worldObject))
{
// an object owner
return(true);
}
// not an object owner
if (directAccessMode == WorldObjectDirectAccessMode.OpensToObjectOwnersOrAreaOwners)
{
if (LandClaimSystem.SharedIsOwnedLand(worldObject.TilePosition,
character,
requireFactionPermission: false,
out _))
{
// an area owner
return(true);
}
}
if (CreativeModeSystem.SharedIsInCreativeMode(character))
{
return(true);
}
// not an object owner and not an area owner
if (writeToLog)
{
WorldObjectOwnersSystem.ServerNotifyNotOwner(character,
worldObject,
isFactionAccess: false);
}
return(false);
}
}
}
private TakeVehicleResult ServerRemote_TakeVehicle(uint vehicleGameObjectId)
{
var character = ServerRemoteContext.Character;
var currentInteractionObject = InteractionCheckerSystem.SharedGetCurrentInteraction(character);
if (!(currentInteractionObject?.ProtoWorldObject is IProtoVehicleAssemblyBay protoVehicleAssemblyBay))
{
Logger.Warning("Player is not interacting with an vehicle assembly bay", character);
return(TakeVehicleResult.Unknown);
}
var vehicleAssemblyBay = (IStaticWorldObject)currentInteractionObject;
var vehicle = Server.World.GetGameObjectById <IDynamicWorldObject>(GameObjectType.DynamicObject,
vehicleGameObjectId);
if (vehicle == null)
{
Logger.Warning("Vehicle is not found", character);
return(TakeVehicleResult.Unknown);
}
if (!WorldObjectOwnersSystem.SharedIsOwner(character, vehicle))
{
Logger.Warning("Not an owner of the vehicle: " + vehicle, character);
return(TakeVehicleResult.NotOwner);
}
var status = ServerGetVehicleStatus(vehicle, forCharacter: character);
switch (status)
{
case VehicleStatus.InGarage:
// allow to take
break;
case VehicleStatus.InWorld:
if (!PveSystem.ServerIsPvE)
{
Logger.Warning("Cannot take a vehicle from world on a PvP server", character);
return(TakeVehicleResult.Unknown);
}
// allow to take a vehicle from world in PvE only
break;
case VehicleStatus.InUse:
return(TakeVehicleResult.Error_InUse);
case VehicleStatus.Docked:
return(TakeVehicleResult.Error_Docked);
default:
return(TakeVehicleResult.Unknown);
}
if (IsServer &&
LandClaimSystem.SharedIsUnderRaidBlock(character, vehicleAssemblyBay))
{
return(TakeVehicleResult.BaseUnderRaidblock);
}
if (protoVehicleAssemblyBay.SharedIsBaySpaceBlocked(
vehicleAssemblyBay: vehicleAssemblyBay))
{
return(TakeVehicleResult.SpaceBlocked);
}
var position = currentInteractionObject.TilePosition.ToVector2D()
+ protoVehicleAssemblyBay.PlatformCenterWorldOffset;
var vehiclePrivateState = vehicle.GetPrivateState <VehiclePrivateState>();
vehiclePrivateState.IsInGarage = false;
vehiclePrivateState.ServerTimeSincePilotOffline = 0;
vehiclePrivateState.ServerTimeSinceLastUse = ThresholdNoPilotSeconds + 1;
Server.World.SetPosition(vehicle,
position,
writeToLog: false);
vehicle.ProtoWorldObject.SharedCreatePhysics(vehicle);
Logger.Important("Vehicle taken out of the garage: " + vehicle, character);
// notify other players in scope
var soundPosition = currentInteractionObject.TilePosition.ToVector2D()
+ protoVehicleAssemblyBay.PlatformCenterWorldOffset;
using var tempPlayers = Api.Shared.GetTempList <ICharacter>();
Server.World.GetScopedByPlayers(currentInteractionObject, tempPlayers);
tempPlayers.Remove(character);
Instance.CallClient(tempPlayers.AsList(),
_ => _.ClientRemote_OnVehicleTakenFromGarageByOtherPlayer(soundPosition));
return(TakeVehicleResult.Success);
}
public ViewModelWindowObjectVehicle(
IDynamicWorldObject vehicle,
FrameworkElement vehicleExtraControl,
IViewModelWithActiveState vehicleExtraControlViewModel)
{
this.VehicleExtraControl = vehicleExtraControl;
this.VehicleExtraControlViewModel = vehicleExtraControlViewModel;
if (vehicleExtraControl != null)
{
vehicleExtraControl.DataContext = vehicleExtraControlViewModel;
}
var currentCharacter = Api.Client.Characters.CurrentPlayerCharacter;
this.ContainerPlayerInventory = (IClientItemsContainer)currentCharacter.SharedGetPlayerContainerInventory();
this.ProtoVehicle = (IProtoVehicle)vehicle.ProtoGameObject;
this.vehiclePublicState = vehicle.GetPublicState <VehiclePublicState>();
this.vehiclePrivateState = vehicle.GetPrivateState <VehiclePrivateState>();
var structurePointsMax = this.ProtoVehicle.SharedGetStructurePointsMax(vehicle);
this.ViewModelStructurePoints = new ViewModelStructurePointsBarControl()
{
ObjectStructurePointsData = new ObjectStructurePointsData(vehicle, structurePointsMax)
};
this.ViewModelVehicleEnergy = new ViewModelVehicleEnergy(vehicle);
this.cargoItemsContainer = this.vehiclePrivateState.CargoItemsContainer as IClientItemsContainer;
this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange(this.cargoItemsContainer,
callbackTakeAllItemsSuccess:
null)
{
IsContainerTitleVisible = false
};
this.ViewModelItemsContainerExchange.IsActive = false;
var isOwner = WorldObjectOwnersSystem.SharedIsOwner(
ClientCurrentCharacterHelper.Character,
vehicle);
this.ViewModelOwnersEditor =
new ViewModelWorldObjectOwnersEditor(this.vehiclePrivateState.Owners,
canEditOwners: isOwner ||
CreativeModeSystem.ClientIsInCreativeMode(),
callbackServerSetOwnersList:
ownersList => WorldObjectOwnersSystem.ClientSetOwners(
vehicle,
ownersList),
title: CoreStrings.ObjectOwnersList_Title2);
this.RefreshCanRepair();
this.IsVehicleTabActive = true;
this.ViewModelItemsContainerExchange.IsActive = true;
if (this.cargoItemsContainer != null)
{
this.cargoItemsContainer.ItemAdded += this.CargoItemsContainerItemAddedHandler;
this.cargoItemsContainer.ItemCountChanged += this.CargoItemsContainerItemCountChangedHandler;
}
}
protected TakeVehicleResult ServerTakeVehicle(ItemVehicleRemoteControlPrivateState privateState, ICharacter character, Vector2D mousePosition)
{
var vehicle = Server.World.GetGameObjectById <IDynamicWorldObject>(GameObjectType.DynamicObject, privateState.VehicleID);
if (vehicle is null)
{
Logger.Warning("Vehicle is not found", character);
return(TakeVehicleResult.Unknown);
}
if (!WorldObjectOwnersSystem.SharedIsOwner(character, vehicle))
{
Logger.Warning("Not an owner of the vehicle: " + vehicle, character);
return(TakeVehicleResult.NotOwner);
}
var vehiclePublicState = vehicle.GetPublicState <VehiclePublicState>();
var status = ServerGetVehicleStatus(vehicle, forCharacter: character);
switch (status)
{
case VehicleStatus.InGarage:
// allow to take
break;
case VehicleStatus.InWorld:
//if (!PveSystem.ServerIsPvE)
//{
// Logger.Warning("Cannot take a vehicle from world on a PvP server", character);
// return TakeVehicleResult.Unknown;
//}
// allow to take
break;
case VehicleStatus.InUse:
return(TakeVehicleResult.Error_InUse);
case VehicleStatus.Docked:
//return TakeVehicleResult.Error_Docked;
// allow to take
break;
default:
return(TakeVehicleResult.Unknown);
}
var position = ServerGetVehicleSpawnPosition(mousePosition, character);
if (!position.HasValue)
{
return(TakeVehicleResult.SpaceBlocked);
}
var vehiclePrivateState = vehicle.GetPrivateState <VehiclePrivateState>();
vehiclePrivateState.IsInGarage = false;
vehiclePrivateState.ServerTimeSincePilotOffline = 0;
vehiclePrivateState.ServerTimeSinceLastUse = ThresholdNoPilotSeconds + 1;
Server.World.SetPosition(vehicle,
position.Value,
writeToLog: false);
vehicle.ProtoWorldObject.SharedCreatePhysics(vehicle);
Logger.Important("Vehicle taken out of the garage: " + vehicle, character);
// notify other players in scope
using var tempPlayers = Api.Shared.GetTempList <ICharacter>();
Server.World.GetScopedByPlayers(vehicle, tempPlayers);
//tempPlayers.Remove(character);
Instance.CallClient(tempPlayers.AsList(),
_ => _.ClientRemote_OnVehicleTakenFromGarageByOtherPlayer(vehicle, position.Value));
return(TakeVehicleResult.Success);
}
