예제 #1
0
        private static ILogicObject ServerGetOwningFaction(IWorldObject worldObject)
        {
            ILogicObject faction = null;

            if (worldObject is IStaticWorldObject staticWorldObject)
            {
                var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(staticWorldObject);
                if (areasGroup is null)
                {
                    throw new Exception(
                              "Cannot modify faction access mode for an object without a faction land claim area");
                }

                faction = LandClaimAreasGroup.GetPublicState(areasGroup).ServerFaction;
            }
            else if (worldObject.ProtoGameObject is IProtoVehicle)
            {
                var clanTag = worldObject.GetPublicState <VehiclePublicState>().ClanTag;
                if (string.IsNullOrEmpty(clanTag))
                {
                    throw new Exception("The vehicle doesn't belong to a faction: " + worldObject);
                }

                faction = FactionSystem.ServerGetFactionByClanTag(clanTag);
            }

            if (faction is null)
            {
                throw new Exception(
                          "Cannot modify faction access mode for an object without a faction land claim area");
            }

            return(faction);
        }
예제 #2
0
 public ObjectStructurePointsData(
     IWorldObject worldObject,
     float structurePointsMax)
 {
     this.WorldObject        = worldObject;
     this.State              = worldObject.GetPublicState <IPublicStateWithStructurePoints>();
     this.StructurePointsMax = structurePointsMax;
 }
예제 #3
0
        public static bool SharedIsOwner(ICharacter who, IWorldObject worldObject, out bool isFactionAccess)
        {
            isFactionAccess = false;

            switch (worldObject)
            {
            case IStaticWorldObject staticWorldObject:
            {
                var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(staticWorldObject);
                if (areasGroup is null ||
                    LandClaimAreasGroup.GetPublicState(areasGroup).FactionClanTag is not {
                    } clanTag ||
                    string.IsNullOrEmpty(clanTag))
                {
                    break;
                }

                // the static object is inside the faction-owned land claim,
                // verify permission
                isFactionAccess = true;
                return(SharedHasFactionAccessRights(who,
                                                    FactionMemberAccessRights.LandClaimManagement,
                                                    clanTag));
            }

            case IDynamicWorldObject when worldObject.ProtoGameObject is IProtoVehicle:
            {
                var clanTag = worldObject.GetPublicState <VehiclePublicState>().ClanTag;
                if (string.IsNullOrEmpty(clanTag))
                {
                    break;
                }

                // the vehicle is owned by faction
                // verify whether the character has the access right
                isFactionAccess = true;
                return(WorldObjectAccessModeSystem.SharedHasAccess(who, worldObject, writeToLog: true));
            }
            }

            return(SharedGetDirectOwners(worldObject).Contains(who.Name));
        }
예제 #4
0
        public static IReadOnlyList <string> SharedGetOwners(IWorldObject worldObject, out bool isFactionAccess)
        {
            isFactionAccess = false;

            switch (worldObject)
            {
            case IStaticWorldObject staticWorldObject:
            {
                var areasGroup = LandClaimSystem.SharedGetLandClaimAreasGroup(staticWorldObject);
                if (areasGroup is null ||
                    LandClaimAreasGroup.GetPublicState(areasGroup).FactionClanTag is not {
                    } clanTag ||
                    string.IsNullOrEmpty(clanTag))
                {
                    break;
                }

                // the static object is inside the faction-owned land claim,
                var faction = FactionSystem.ServerGetFactionByClanTag(clanTag);
                return(FactionSystem.ServerGetFactionMemberNames(faction).ToList());
            }

            case IDynamicWorldObject when worldObject.ProtoGameObject is IProtoVehicle:
            {
                var clanTag = worldObject.GetPublicState <VehiclePublicState>().ClanTag;
                if (string.IsNullOrEmpty(clanTag))
                {
                    break;
                }

                // the vehicle is owned by faction
                var faction = FactionSystem.ServerGetFactionByClanTag(clanTag);
                return(FactionSystem.ServerGetFactionMemberNames(faction).ToList());
            }
            }

            return(SharedGetDirectOwners(worldObject));
        }
예제 #5
0
        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);
            }
            }
        }