public static void ServerOnObjectLandClaimBuilt( ICharacter byCharacter, IStaticWorldObject landClaimStructure) { if (!(landClaimStructure?.ProtoStaticWorldObject is IProtoObjectLandClaim)) { throw new Exception("Not a land claim structure: " + landClaimStructure); } // create new area for this land claim structure var area = Api.Server.World.CreateLogicObject <LandClaimArea>(); var areaPrivateState = LandClaimArea.GetPrivateState(area); var areaPublicState = LandClaimArea.GetPublicState(area); var founderName = byCharacter.Name; // setup it areaPrivateState.ServerLandClaimWorldObject = landClaimStructure; areaPrivateState.LandClaimFounder = founderName; areaPrivateState.LandOwners = new NetworkSyncList <string>() { founderName }; areaPublicState.Title = founderName; areaPublicState.SetupAreaProperties(areaPrivateState); // set this area to the structure public state landClaimStructure.GetPublicState <ObjectLandClaimPublicState>() .LandClaimAreaObject = area; ServerOnAddLandOwner(area, byCharacter, notify: false); Logger.Important("Land claim area added: " + area); }
private static void ServerTransferAreasGroupToFactionOwnership( ILogicObject faction, ICharacter byCharacter, ILogicObject areasGroup) { var areas = LandClaimAreasGroup.GetPrivateState(areasGroup).ServerLandClaimsAreas; foreach (var area in areas) { ServerUnregisterArea(area); } var publicState = LandClaimAreasGroup.GetPublicState(areasGroup); publicState.ServerSetFaction(faction); var centerTilePosition = new Vector2Ushort( (ushort)areas.Average(a => LandClaimArea.GetPublicState(a).LandClaimCenterTilePosition.X), (ushort)areas.Average(a => LandClaimArea.GetPublicState(a).LandClaimCenterTilePosition.Y)); Logger.Important( $"Transferred land claim areas group to the faction ownership: {areasGroup} at {centerTilePosition}"); FactionSystem.ServerOnLandClaimExpanded(faction, centerTilePosition, byCharacter); foreach (var area in areas) { ServerRegisterArea(area); } }
/// <summary> /// This method should be called only by LandClaimSystem. /// </summary> internal static void AddArea(ILogicObject area) { if (StateSubscriptionStorages.ContainsKey(area)) { return; } // register for group change event var stateSubscriptionStorage = new StateSubscriptionStorage(); StateSubscriptionStorages[area] = stateSubscriptionStorage; var areaPublicState = LandClaimArea.GetPublicState(area); areaPublicState.ClientSubscribe( o => o.LandClaimAreasGroup, newValue => { //Api.Logger.Dev($"Received LandClaimAreasGroup changed: {newValue} for {area}"); OnAreaModified(area); }, stateSubscriptionStorage); // register area RendererManagerGraceAreas.RegisterArea(area); var renderer = LandClaimSystem.ClientIsOwnedArea(area) ? RendererManagerOwnedByPlayer : RendererManagerNotOwnedByPlayer; renderer.RegisterArea(area); AreaAdded?.Invoke(area); }
public static bool ServerIsVehicleInsideOwnerBase(IDynamicWorldObject vehicle) { var vehicleCurrentBase = LandClaimSystem.SharedGetLandClaimAreasGroup(vehicle.TilePosition); if (vehicleCurrentBase is null) { return(false); } var vehicleOwners = vehicle.GetPrivateState <VehiclePrivateState>().Owners; foreach (var area in LandClaimAreasGroup.GetPrivateState(vehicleCurrentBase) .ServerLandClaimsAreas) { using var areaOwners = Api.Shared.WrapInTempList( LandClaimArea.GetPrivateState(area) .ServerGetLandOwners()); foreach (var ownerName in vehicleOwners) { if (areaOwners.Contains(ownerName)) { return(true); } } } return(false); }
private static bool AppendInfoAboutPlayerLandClaims(ICharacter player, StringBuilder result) { var ownedLandClaimAreas = PlayerCharacter.GetPrivateState(player) .OwnedLandClaimAreas; if (ownedLandClaimAreas is null || ownedLandClaimAreas.Count == 0) { return(false); } var worldBoundsOffset = Server.World.WorldBounds.Offset; result.Append("Owned land claims by ") .Append(player) .Append(":"); foreach (var ownedLandClaimArea in ownedLandClaimAreas) { result.AppendLine(); var publicState = LandClaimArea.GetPublicState(ownedLandClaimArea); result.AppendFormat(" * {0} at {1}", publicState.ProtoObjectLandClaim.ShortId, publicState.LandClaimCenterTilePosition - worldBoundsOffset); } return(true); }
public static string ServerSetOwner(ushort x, ushort y, string newOwnerName) { using var tempList = Api.Shared.GetTempList <ILogicObject>(); LandClaimSystem.SharedGetAreasInBounds(new RectangleInt(x, y, 1, 1), tempList, addGracePadding: false); var landClaimsModified = 0; foreach (var area in tempList.AsList()) { var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(area); if (LandClaimAreasGroup.GetPublicState(areasGroup).ServerFaction is not null) { // cannot change an owner of the faction land claim continue; } var privateState = LandClaimArea.GetPrivateState(area); privateState.LandClaimFounder = newOwnerName; privateState.DirectLandOwners.Clear(); privateState.DirectLandOwners.Add(newOwnerName); landClaimsModified++; } return($"Modified {landClaimsModified} land claims"); }
public void Register(ILogicObject area) { Controller controller; foreach (var pair in this.groupControllers) { controller = pair.Value; if (controller.Areas.Contains(area)) { throw new Exception("Already has area registered: " + area); } } var areasGroup = LandClaimArea.GetPublicState(area).LandClaimAreasGroup; if (areasGroup is null) { return; } if (!this.groupControllers.TryGetValue(areasGroup, out controller)) { controller = new Controller(areasGroup, this.worldMapController); this.groupControllers[areasGroup] = controller; } controller.Areas.Add(area); }
private static void ServerResetDecayTimerForLandClaimAreasGroup(ILogicObject areasGroup) { var areasGroupPrivateState = LandClaimAreasGroup.GetPrivateState(areasGroup); var areasGroupPublicState = LandClaimAreasGroup.GetPublicState(areasGroup); var areas = areasGroupPrivateState.ServerLandClaimsAreas; // TODO: it's better to move this code to another place as this property is used in several other places areasGroupPublicState.IsFounderDemoPlayer = ServerGetIsFounderDemoPlayer(areas); // reset the decay timer for all land claim buildings inside this areas group var decayDelayDuration = LandClaimSystem.ServerGetDecayDelayDurationForLandClaimAreas( areas, areasGroupPublicState.IsFounderDemoPlayer, out _); foreach (var area in areas) { var worldObject = LandClaimArea.GetPrivateState(area) .ServerLandClaimWorldObject; StructureDecaySystem.ServerResetDecayTimer( worldObject.GetPrivateState <StructurePrivateState>(), decayDelayDuration); } }
private static bool ServerGetIsFounderDemoPlayer(List <ILogicObject> areas) { var isFounderDemoPlayer = false; foreach (var area in areas) { var areaPrivateState = LandClaimArea.GetPrivateState(area); var landClaimFounder = areaPrivateState.LandClaimFounder; if (string.IsNullOrEmpty(landClaimFounder)) { // there is no founder (transferred to the faction) return(false); } var founder = ServerCharacters.GetPlayerCharacter(landClaimFounder); if (founder.ServerIsDemoVersion) { isFounderDemoPlayer = true; } else { // one of the areas' founder is not a demo player return(false); } } return(isFounderDemoPlayer); }
public static bool ServerIsVehicleInsideOwnerBase(IDynamicWorldObject vehicle) { var vehicleCurrentBase = LandClaimSystem.SharedGetLandClaimAreasGroup(vehicle.TilePosition); if (vehicleCurrentBase == null) { return(false); } var vehicleOwners = vehicle.GetPrivateState <VehiclePrivateState>().Owners; foreach (var area in LandClaimAreasGroup.GetPrivateState(vehicleCurrentBase).ServerLandClaimsAreas) { var areaOwners = LandClaimArea.GetPrivateState(area).LandOwners; foreach (var ownerName in vehicleOwners) { if (areaOwners.Contains(ownerName, StringComparer.Ordinal)) { return(true); } } } return(false); }
private static void ServerLoadSystem() { const string key = nameof(LandClaimAreaManager); if (Server.Database.TryGet(key, key, out ILogicObject savedManager)) { Server.World.DestroyObject(savedManager); } serverLandClaimManagerInstance = Server.World.CreateLogicObject <LandClaimAreaManager>(); var publicState = LandClaimAreaManager.GetPublicState(serverLandClaimManagerInstance); publicState.LandClaimAreas = new NetworkSyncList <ILogicObject>(); Server.Database.Set(key, key, serverLandClaimManagerInstance); sharedLandClaimAreas = LandClaimAreaManager.GetPublicState(serverLandClaimManagerInstance) .LandClaimAreas; foreach (var area in sharedLandClaimAreas) { var areaPrivateState = LandClaimArea.GetPrivateState(area); var areaPublicState = LandClaimArea.GetPublicState(area); areaPublicState.SetupAreaProperties(areaPrivateState); } }
private void RefreshSafeStorageAndPowerGrid() { var objectPublicState = this.landClaimWorldObject.GetPublicState <ObjectLandClaimPublicState>(); var area = objectPublicState.LandClaimAreaObject; var areasGroup = LandClaimArea.GetPublicState(area).LandClaimAreasGroup; var areasGroupPrivateState = LandClaimAreasGroup.GetPrivateState(areasGroup); // setup power grid var powerGrid = areasGroupPrivateState.PowerGrid; var oldViewModelPowerGridState = this.ViewModelPowerGridState; this.ViewModelPowerGridState = new ViewModelPowerGridState(PowerGrid.GetPublicState(powerGrid)); oldViewModelPowerGridState?.Dispose(); // setup safe storage this.DisposeViewModelItemsContainerExchange(); this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange( areasGroupPrivateState.ItemsContainer, callbackTakeAllItemsSuccess: () => { }, enableShortcuts: this.IsSafeStorageAvailable) { IsContainerTitleVisible = false, }; this.ViewModelItemsContainerExchange.Container.SlotsCountChanged += this.SafeStorageSlotsChangedHandler; this.ViewModelItemsContainerExchange.Container.ItemsReset += this.SafeStorageSlotsChangedHandler; }
public string Execute( double chargePercent = 100, [CurrentCharacterIfNull] ICharacter character = null) { var chargeFraction = MathHelper.Clamp(chargePercent / 100, min: 0, max: 1); using var tempLandClaims = Api.Shared.GetTempList <ILogicObject>(); LandClaimSystem.SharedGetAreasInBounds( new RectangleInt(character.TilePosition, (1, 1)), tempLandClaims, addGracePadding: false); var landClaim = tempLandClaims.AsList().FirstOrDefault(); if (landClaim is null) { return("No power grid exist near " + character.Name); } var landClaimAreasGroup = LandClaimArea.GetPublicState(landClaim).LandClaimAreasGroup; var powerGrid = LandClaimAreasGroup.GetPrivateState(landClaimAreasGroup).PowerGrid; var powerGridState = PowerGrid.GetPublicState(powerGrid); powerGridState.ElectricityAmount = powerGridState.ElectricityCapacity * chargeFraction; return($"Charge amount of the power grid modified to {chargeFraction * 100}%"); }
public static RectangleInt SharedGetLandClaimAreaBounds(ILogicObject area) { var publicState = LandClaimArea.GetPublicState(area); return(SharedCalculateLandClaimAreaBounds( publicState.LandClaimCenterTilePosition, publicState.LandClaimSize)); }
private static void ServerOnRemoveLandOwner(ILogicObject area, ICharacter removedPlayer) { InteractableStaticWorldObjectHelper.ServerTryAbortInteraction( removedPlayer, LandClaimArea.GetPrivateState(area).ServerLandClaimWorldObject); ServerWorld.ExitPrivateScope(removedPlayer, area); Instance.CallClient(removedPlayer, _ => _.ClientRemote_OnLandOwnerStateChanged(area, false)); }
public ViewModelWindowLandClaim( IStaticWorldObject landClaimWorldObject, ILogicObject area) { this.landClaimWorldObject = landClaimWorldObject; this.privateState = LandClaimArea.GetPrivateState(area); var protoLandClaim = (IProtoObjectLandClaim)landClaimWorldObject.ProtoStaticWorldObject; var canEditOwners = protoLandClaim .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, maxOwnersListLength: LandClaimSystemConstants.SharedLandClaimOwnersMax, displayedOwnersNumberAdjustment: -1); this.protoObjectLandClaim = (IProtoObjectLandClaim)this.landClaimWorldObject.ProtoStaticWorldObject; var upgrade = this.protoObjectLandClaim.ConfigUpgrade.Entries.FirstOrDefault(); if (upgrade is not null) { this.ViewModelStructureUpgrade = new ViewModelStructureUpgrade(upgrade); this.ViewModelProtoLandClaimInfoUpgrade = new ViewModelProtoLandClaimInfo( (IProtoObjectLandClaim)upgrade.ProtoStructure); } var objectPublicState = landClaimWorldObject.GetPublicState <ObjectLandClaimPublicState>(); objectPublicState.ClientSubscribe( _ => _.LandClaimAreaObject, _ => this.RefreshSafeStorageAndPowerGrid(), this); this.RefreshSafeStorageAndPowerGrid(); this.ViewModelProtoLandClaimInfoCurrent = new ViewModelProtoLandClaimInfo(this.protoObjectLandClaim); ItemsContainerLandClaimSafeStorage.ClientSafeItemsSlotsCapacityChanged += this.SafeItemsSlotsCapacityChangedHandler; this.RequestDecayInfoTextAsync(); this.ViewModelShieldProtectionControl = new ViewModelShieldProtectionControl( LandClaimSystem.SharedGetLandClaimAreasGroup(area)); }
private void ServerRemote_TransferLandClaimToFactionOwnership(ILogicObject area) { var character = ServerRemoteContext.Character; var areasGroup = SharedGetLandClaimAreasGroup(area); if (LandClaimAreasGroup.GetPublicState(areasGroup).ServerFaction is not null) { // already has a faction (and it's not possible to change the faction) Logger.Warning("The land claim areas group is already transferred to a faction."); return; } FactionSystem.ServerValidateHasAccessRights(character, FactionMemberAccessRights.LandClaimManagement, out var faction); var factionOwnedAreas = SharedEnumerateAllFactionAreas(FactionSystem.SharedGetClanTag(faction)); var claimLimitRemains = FactionConstants.SharedGetFactionLandClaimsLimit( Faction.GetPublicState(faction).Level) - factionOwnedAreas.Count(); claimLimitRemains -= LandClaimAreasGroup.GetPrivateState(areasGroup).ServerLandClaimsAreas.Count; if (claimLimitRemains < 0) { Logger.Warning( "Cannot transfer land claims to the faction as it will exceed the land claims number limit"); return; } Logger.Important("Will transfer land claims to the faction: after upgrade the remaining limit will be " + claimLimitRemains); // verify user has access to the land claim var owner = ServerRemoteContext.Character; if (!Server.World.IsInPrivateScope(area, owner)) { throw new Exception( "Cannot interact with the land claim object as the area is not in private scope: " + area); } if (!LandClaimArea.GetPrivateState(area).ServerGetLandOwners() .Contains(owner.Name)) { throw new Exception("Player is not an owner of the land claim area"); } ServerTransferAreasGroupToFactionOwnership(faction, character, areasGroup); var worldObject = InteractionCheckerSystem.SharedGetCurrentInteraction(character); InteractableWorldObjectHelper.ServerTryAbortInteraction(character, worldObject); }
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 ServerIsOwnedArea(ILogicObject area, ICharacter character) { if (area == null) { Logger.Warning(nameof(ServerIsOwnedArea) + " - argument area is null"); return(false); } var privateState = LandClaimArea.GetPrivateState(area); return(privateState.LandOwners .Contains(character.Name)); }
public string Execute(byte minOwnersNumber = 1) { if (minOwnersNumber < 1) { minOwnersNumber = 1; } var result = new StringBuilder("List of all land claims with their access lists: (with at least ") .Append(minOwnersNumber) .Append(" owner(s))") .AppendLine(); var worldBoundsOffset = Server.World.WorldBounds.Offset; foreach (var area in LandClaimSystem.SharedEnumerateAllAreas()) { var privateState = LandClaimArea.GetPrivateState(area); var landClaimOwners = privateState.ServerGetLandOwners(); var ownersCount = landClaimOwners.Count(); if (ownersCount < minOwnersNumber) { continue; } var publicState = LandClaimArea.GetPublicState(area); result.AppendLine() .Append(publicState.ProtoObjectLandClaim.ShortId) .Append(" at ") .Append(publicState.LandClaimCenterTilePosition - worldBoundsOffset) .Append(" — "); var factionClanTag = LandClaimSystem.SharedGetAreaOwnerFactionClanTag(area); if (!string.IsNullOrEmpty(factionClanTag)) { result.AppendFormat("faction [{0}] — ", factionClanTag); } result.Append(ownersCount) .Append(" owner(s)"); foreach (var ownerName in landClaimOwners) { result.AppendLine() .Append(" * ") .Append(ownerName); } } return(result.ToString()); }
private static void ServerAreasGroupChangedHandler( ILogicObject area, [CanBeNull] ILogicObject areasGroupFrom, [CanBeNull] ILogicObject areasGroupTo) { var byMember = ServerPlayerCharacterCurrentActionStateContext.CurrentCharacter ?? (ServerRemoteContext.IsRemoteCall ? ServerRemoteContext.Character : null); if (areasGroupTo is not null) { var clanTag = LandClaimAreasGroup.GetPublicState(areasGroupTo).FactionClanTag; if (string.IsNullOrEmpty(clanTag)) { return; } var faction = FactionSystem.ServerGetFactionByClanTag(clanTag); var centerTilePosition = LandClaimArea.GetPublicState(area).LandClaimCenterTilePosition; Logger.Important( string.Format("Faction-owned land claim areas group expanded with a new claim area: {0} at {1}", areasGroupTo, centerTilePosition)); FactionSystem.ServerOnLandClaimExpanded(faction, centerTilePosition, byMember: byMember); } else if (areasGroupFrom is not null) { var clanTag = LandClaimAreasGroup.GetPublicState(areasGroupFrom).FactionClanTag; if (string.IsNullOrEmpty(clanTag)) { return; } var faction = FactionSystem.ServerGetFactionByClanTag(clanTag); var centerTilePosition = LandClaimArea.GetPublicState(area).LandClaimCenterTilePosition; Logger.Important( string.Format("Faction-owned land claim areas group removed: {0} at {1}", areasGroupFrom, centerTilePosition)); FactionSystem.ServerOnLandClaimRemoved(faction, centerTilePosition, byMember: byMember); } }
private static void ServerRaidBlockStartedOrExtendedHandler( ILogicObject area, ICharacter raiderCharacter, bool isNewRaidBlock, bool isStructureDestroyed) { if (!isNewRaidBlock) { return; } var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(area); if (ServerNotifiedCharactersForAreasGroups.ContainsKey( ServerAllyBaseUnderRaidMark.CreateKeyOnly(areasGroup))) { // notification for this areas group is already sent return; } ILogicObject faction; var clanTag = LandClaimSystem.SharedGetAreaOwnerFactionClanTag(area); if (!string.IsNullOrEmpty(clanTag)) { // owned by a faction, notify allies faction = FactionSystem.ServerGetFactionByClanTag(clanTag); ServerNotifyFactionAllies(faction, area, areasGroup); return; } // not owned by faction, // check whether its founder is a member of any faction and notify its members var founderName = LandClaimArea.GetPrivateState(area) .LandClaimFounder; var founderCharacter = Server.Characters.GetPlayerCharacter(founderName); if (founderCharacter is null) { return; } faction = FactionSystem.ServerGetFaction(founderCharacter); if (faction is not null) { ServerNotifyFactionMembers(faction, founderCharacter, area, areasGroup); } }
private static bool IsBaseMusicShouldPlay(ICharacter character) { using var tempListAreasNearby = Api.Shared.GetTempList <ILogicObject>(); using var tempListOwnedAreaGroupsNearby = Api.Shared.GetTempList <ILogicObject>(); LandClaimSystem.SharedGetAreasInBounds( new RectangleInt(character.TilePosition.X, character.TilePosition.Y, 1, 1).Inflate(2), tempListAreasNearby, addGracePadding: true); // find owned bases (area groups) nearby foreach (var area in tempListAreasNearby.AsList()) { if (LandClaimSystem.SharedIsOwnedArea(area, character, requireFactionPermission: false)) { var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(area); tempListOwnedAreaGroupsNearby.AddIfNotContains(areasGroup); } } if (tempListOwnedAreaGroupsNearby.Count == 0) { return(false); } var allAreas = (List <ILogicObject>)LandClaimSystem.SharedEnumerateAllAreas(); // check every owned base whether it has at least single T2 or higher tier land claim foreach (var areasGroup in tempListOwnedAreaGroupsNearby.AsList()) { foreach (var area in allAreas) { var areaPublicState = LandClaimArea.GetPublicState(area); if (areaPublicState.LandClaimAreasGroup == areasGroup && areaPublicState.LandClaimTier > 1) { // found an area on the base with land claim tier > 1 return(true); } } } return(false); }
private static void ServerRefreshLandClaimAreasGroup(ILogicObject areasGroup) { var areas = LandClaimAreasGroup.GetPrivateState(areasGroup).ServerLandClaimsAreas; foreach (var area in areas) { var areaBounds = LandClaimSystem.SharedGetLandClaimAreaBounds(area, addGracePadding: true); var owners = LandClaimArea.GetPrivateState(area).LandOwners; foreach (var owner in owners) { var character = Server.Characters.GetPlayerCharacter(owner); if (character == null || !character.ServerIsOnline) { continue; } if (!areaBounds.Contains(character.TilePosition)) { continue; } // the land claim area contains an online owner character ServerResetDecayTimer(); return; } } // helper method to reset the decay timer for all land claim buildings inside this areas group void ServerResetDecayTimer() { var decayDelayDuration = LandClaimSystem.ServerGetDecayDelayDurationForLandClaimAreas(areas); foreach (var area in areas) { var worldObject = LandClaimArea.GetPrivateState(area) .ServerLandClaimWorldObject; StructureDecaySystem.ServerResetDecayTimer( worldObject.GetPrivateState <StructurePrivateState>(), decayDelayDuration); } } }
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 static string ServerSetOwner(ushort x, ushort y, string newOwnerName) { using var tempList = Api.Shared.GetTempList <ILogicObject>(); LandClaimSystem.SharedGetAreasInBounds(new RectangleInt(x, y, 1, 1), tempList, addGracePadding: false); var landClaimsModified = 0; foreach (var area in tempList.AsList()) { var privateState = LandClaimArea.GetPrivateState(area); privateState.LandClaimFounder = newOwnerName; privateState.LandOwners.Clear(); privateState.LandOwners.Add(newOwnerName); landClaimsModified++; } return($"Modified {landClaimsModified} land claims"); }
public static bool SharedIsFoundedArea(ILogicObject area, ICharacter forCharacter) { if (area == null) { Logger.Warning(nameof(ServerIsOwnedArea) + " - argument area is null"); return(false); } if (IsClient && !area.ClientHasPrivateState) { // not an owner so not a founder for sure return(false); } var privateState = LandClaimArea.GetPrivateState(area); return(privateState.LandClaimFounder == forCharacter.Name); }
public string Execute( ShieldProtectionStatus status, [CurrentCharacterIfNull] ICharacter character = null) { if (!LandClaimShieldProtectionConstants.SharedIsEnabled) { return("S.H.I.E.L.D. protection is not available"); } if (status == ShieldProtectionStatus.Active) { status = ShieldProtectionStatus.Activating; } using var tempLandClaims = Api.Shared.GetTempList <ILogicObject>(); LandClaimSystem.SharedGetAreasInBounds( new RectangleInt(character.TilePosition, (1, 1)), tempLandClaims, addGracePadding: false); var landClaim = tempLandClaims.AsList().FirstOrDefault(); if (landClaim is null) { return("No base exist near " + character.Name); } var landClaimAreasGroup = LandClaimArea.GetPublicState(landClaim).LandClaimAreasGroup; LandClaimShieldProtectionSystem.SharedGetShieldProtectionMaxStatsForBase(landClaimAreasGroup, out _, out _); var privateState = LandClaimAreasGroup.GetPrivateState(landClaimAreasGroup); privateState.ShieldProtectionCooldownExpirationTime = 0; var publicState = LandClaimAreasGroup.GetPublicState(landClaimAreasGroup); publicState.Status = status; publicState.ShieldActivationTime = Server.Game.FrameTime; return($"Status of the S.H.I.E.L.D. changed to {status}."); }
public static IStaticWorldObject ServerUpgrade( IStaticWorldObject oldStructure, IProtoObjectStructure upgradeStructure, ICharacter character) { if (!(oldStructure?.ProtoStaticWorldObject is IProtoObjectLandClaim)) { throw new Exception("Not a land claim structure: " + oldStructure); } var tilePosition = oldStructure.TilePosition; var area = ServerGetLandClaimArea(oldStructure); // release area oldStructure.GetPublicState <ObjectLandClaimPublicState>().LandClaimAreaObject = null; // destroy old structure ServerWorld.DestroyObject(oldStructure); // create new structure var upgradedObject = ServerWorld.CreateStaticWorldObject(upgradeStructure, tilePosition); // get area for the old land claim structure var areaPrivateState = LandClaimArea.GetPrivateState(area); var areaPublicState = LandClaimArea.GetPublicState(area); // update it to use upgraded land claim structure areaPrivateState.ServerLandClaimWorldObject = upgradedObject; areaPublicState.SetupAreaProperties(areaPrivateState); // set this area to the structure public state upgradedObject.GetPublicState <ObjectLandClaimPublicState>() .LandClaimAreaObject = area; Logger.Important($"Successfully upgraded: {oldStructure} to {upgradedObject}", character); Instance.CallClient( Server.Characters.EnumerateAllPlayerCharacters(onlyOnline: true), _ => _.ClientRemote_OnLandClaimUpgraded(area)); return(upgradedObject); }
private void AreaAddedHandler(ILogicObject area) { if (!LandClaimSystem.ClientIsOwnedArea(area)) { return; } if (this.visualizedAreas.ContainsKey(area)) { Api.Logger.Error("Land claim area already has the map visualizer: " + area); return; } var isFounder = string.Equals(LandClaimArea.GetPrivateState(area).LandClaimFounder, ClientCurrentCharacterHelper.Character.Name, StringComparison.Ordinal); this.visualizedAreas[area] = new LandClaimMapData(area, this.worldMapController, this.landClaimGroupVisualizer, isFounder: isFounder); }