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); }