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