Example #1
0
 public static IEnumerable <MapLocation> AccessibleMapLocations(
     AccessRequirement currentAccess,
     MapChange currentMapChanges,
     Dictionary <MapLocation, Tuple <List <MapChange>, AccessRequirement> > fullLocationRequirements)
 {
     return(fullLocationRequirements.Where(x => x.Value.Item1.Any(y => currentMapChanges.HasFlag(y) && currentAccess.HasFlag(x.Value.Item2))).Select(x => x.Key));
 }
Example #2
0
        private void BuildInitialRequirements(IVictoryConditionFlags victoryConditions)
        {
            airShipLocationAccessible = false;

            requirements = AccessRequirement.None;
            if ((bool)victoryConditions.FreeLute)
            {
                requirements |= AccessRequirement.Lute;
            }

            changes = MapChange.None;
            if (victoryConditions.IsBridgeFree ?? false)
            {
                changes |= MapChange.Bridge;
            }
            if (victoryConditions.IsShipFree ?? false)
            {
                changes |= MapChange.Ship;
                SetShipDock(255);
            }
            if (victoryConditions.IsAirshipFree ?? false)
            {
                changes |= MapChange.Airship;
                airShipLocationAccessible = true;
            }
            if (victoryConditions.IsCanalFree ?? false)
            {
                changes |= MapChange.Canal;
            }
            if (victoryConditions.IsCanoeFree ?? false)
            {
                changes |= MapChange.Canoe;
            }
        }
        public MapObject(ObjectId objectId, MapLocation mapLocation, Item item,
                         AccessRequirement accessRequirement = AccessRequirement.None,
                         ObjectId requiredGameEventFlag      = ObjectId.None,
                         Item requiredItemTrade             = Item.None,
                         MapLocation requiredSecondLocation = MapLocation.StartingLocation,
                         bool useVanillaRoutineAddress      = true)
            : base(_mapObjectTalkDataAddress + _giftItemIndex +
                   _mapObjectTalkDataSize * (byte)objectId,
                   Enum.GetName(typeof(ObjectId), objectId),
                   mapLocation,
                   item,
                   accessRequirement)
        {
            ObjectId = objectId;

            _objectRoutineAddress     = (byte)objectId * _mapObjTalkJumpTblDataSize + _mapObjTalkJumpTblAddress;
            _requiredGameEventFlag    = requiredGameEventFlag;
            _requiredItemTrade        = requiredItemTrade;
            _useVanillaRoutineAddress = useVanillaRoutineAddress;
            SecondLocation            = requiredSecondLocation;
            if (_requiredGameEventFlag != ObjectId.None && _requiredItemTrade != Item.None)
            {
                throw new InvalidOperationException(
                          $"Attempted to Put invalid npc item placement: \n{SpoilerText}");
            }
        }
Example #4
0
        public SCRequirementsSet(AccessRequirement accessRequirement)
        {
            var requirement = SCRequirements.None;

            if (accessRequirement.HasFlag(AccessRequirement.Key))
            {
                requirement |= SCRequirements.Key;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Rod))
            {
                requirement |= SCRequirements.Rod;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Oxyale))
            {
                requirement |= SCRequirements.Oxyale;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Cube))
            {
                requirement |= SCRequirements.Cube;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Bottle))
            {
                requirement |= SCRequirements.Bottle;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Lute))
            {
                requirement |= SCRequirements.Lute;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Crown))
            {
                requirement |= SCRequirements.Crown;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Crystal))
            {
                requirement |= SCRequirements.Crystal;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Herb))
            {
                requirement |= SCRequirements.Herb;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Tnt))
            {
                requirement |= SCRequirements.Tnt;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Adamant))
            {
                requirement |= SCRequirements.Adamant;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Slab))
            {
                requirement |= SCRequirements.Slab;
            }
            if (accessRequirement.HasFlag(AccessRequirement.Ruby))
            {
                requirement |= SCRequirements.Ruby;
            }

            Add(requirement);
        }
Example #5
0
 public StaticItemLocation(string name, MapLocation mapLocation, Item item,
                           AccessRequirement accessRequirement = AccessRequirement.None)
     : base(address++, name, mapLocation, item, accessRequirement)
 {
     if (address >= int.MaxValue)
     {
         address = 0x80000;
     }
 }
Example #6
0
 protected RewardSourceBase(int address, string name, MapLocation mapLocation, Item item,
                            AccessRequirement accessRequirement = AccessRequirement.None,
                            bool isUnused = false)
 {
     Address           = address;
     Name              = name;
     Item              = item;
     MapLocation       = mapLocation;
     AccessRequirement = accessRequirement;
     IsUnused          = isUnused;
 }
Example #7
0
        public void CanHandleDfdsAccessRequirements()
        {
            //Arrange
            var fakeRequirements = new AccessRequirement[] { new ExecuteAccessRequirement(), new ReadAccessRequirement(), new WriteAccessRequirement() };
            var fakeIdentity     = new ClaimsIdentity(new[] { new Claim("dfds.access", "dfds.all.execute"), new Claim("dfds.access", "dfds.all.read"), new Claim("dfds.access", "dfds.all.write") });
            var fakePrincipal    = new ClaimsPrincipal(fakeIdentity);
            var fakeAuthorizationHandlerContext = new AuthorizationHandlerContext(fakeRequirements, fakePrincipal, null);
            var sut = new AccessRequirementHandler();

            //Act
            var task = sut.HandleAsync(fakeAuthorizationHandlerContext);

            //Assert
            Assert.True(task.IsCompletedSuccessfully);
            Assert.True(fakeAuthorizationHandlerContext.HasSucceeded);
        }
Example #8
0
        private void ProcessOrb(SCPointOfInterest poi)
        {
            switch (poi.ItemId)
            {
            case Item.EarthOrb:
                requirements |= AccessRequirement.EarthOrb;
                break;

            case Item.FireOrb:
                requirements |= AccessRequirement.FireOrb;
                break;

            case Item.WaterOrb:
                requirements |= AccessRequirement.WaterOrb;
                break;

            case Item.AirOrb:
                requirements |= AccessRequirement.AirOrb;
                break;
            }

            poi.Done = true;
        }
Example #9
0
        public bool IsAccessible(AccessRequirement req, MapChange chg)
        {
            SCBitFlags v2req = SCBitFlags.None;

            if (req.HasFlag(AccessRequirement.Key))
            {
                v2req |= SCBitFlags.Key;
            }
            if (req.HasFlag(AccessRequirement.Rod))
            {
                v2req |= SCBitFlags.Rod;
            }
            if (req.HasFlag(AccessRequirement.Oxyale))
            {
                v2req |= SCBitFlags.Oxyale;
            }
            if (req.HasFlag(AccessRequirement.Cube))
            {
                v2req |= SCBitFlags.Cube;
            }
            if (req.HasFlag(AccessRequirement.Lute))
            {
                v2req |= SCBitFlags.Lute;
            }
            if (req.HasFlag(AccessRequirement.Crown))
            {
                v2req |= SCBitFlags.Crown;
            }
            if (req.HasFlag(AccessRequirement.Ruby))
            {
                v2req |= SCBitFlags.Ruby;
            }
            if (req.HasFlag(AccessRequirement.BlackOrb))
            {
                v2req |= SCBitFlags.Orbs;
            }
            if (req.HasFlag(AccessRequirement.Tnt))
            {
                v2req |= SCBitFlags.Tnt;
            }

            if (chg.HasFlag(MapChange.Chime))
            {
                v2req |= SCBitFlags.Chime;
            }
            if (chg.HasFlag(MapChange.Canoe))
            {
                v2req |= SCBitFlags.Canoe;
            }
            if (chg.HasFlag(MapChange.Airship))
            {
                v2req |= SCBitFlags.Floater;
            }

            foreach (var flag in this)
            {
                if (v2req.IsSupersetOf(flag))
                {
                    return(true);
                }
            }

            return(false);
        }
Example #10
0
        private void ProcessItem(Item item, byte dungeonIndex)
        {
            switch (item)
            {
            case Item.Lute:
                requirements |= AccessRequirement.Lute;
                break;

            case Item.Crown:
                requirements |= AccessRequirement.Crown;
                break;

            case Item.Crystal:
                requirements |= AccessRequirement.Crystal;
                break;

            case Item.Herb:
                requirements |= AccessRequirement.Herb;
                break;

            case Item.Key:
                requirements |= AccessRequirement.Key;
                break;

            case Item.Tnt:
                requirements |= AccessRequirement.Tnt;
                break;

            case Item.Adamant:
                requirements |= AccessRequirement.Adamant;
                break;

            case Item.Slab:
                requirements |= AccessRequirement.Slab;
                break;

            case Item.Ruby:
                requirements |= AccessRequirement.Ruby;
                changes      |= MapChange.TitanFed;
                break;

            case Item.Rod:
                requirements |= AccessRequirement.Rod;
                break;

            case Item.Floater:
                changes |= MapChange.Airship;
                break;

            case Item.Chime:
                changes |= MapChange.Chime;
                break;

            case Item.Cube:
                requirements |= AccessRequirement.Cube;
                break;

            case Item.Bottle:
                requirements |= AccessRequirement.Bottle;
                break;

            case Item.Oxyale:
                requirements |= AccessRequirement.Oxyale;
                break;

            case Item.Ship:
                changes |= MapChange.Ship;
                SetShipDock(dungeonIndex);
                break;

            case Item.Bridge:
                changes |= MapChange.Bridge;
                break;

            case Item.Canal:
                changes |= MapChange.Canal;
                break;

            case Item.Canoe:
                changes |= MapChange.Canoe;
                break;
            }
        }
Example #11
0
        public bool IsRewardSourceAccessible(IRewardSource source, AccessRequirement currentAccess, List <MapLocation> locations)
        {
            //if (currentAccess != requirements) throw new InvalidOperationException("no can do");

            return(rewardSources.Contains(source));
        }
Example #12
0
 public List <MapLocation> AccessibleMapLocations(AccessRequirement currentAccess, MapChange currentMapChanges, Dictionary <MapLocation, Tuple <List <MapChange>, AccessRequirement> > fullLocationRequirements)
 {
     throw new NotSupportedException("not needed?");
 }
Example #13
0
 public bool IsRewardSourceAccessible(IRewardSource source, AccessRequirement currentAccess, List <MapLocation> locations)
 {
     return(locations.Contains(source.MapLocation) && currentAccess.HasFlag(source.AccessRequirement) &&
            locations.Contains((source as MapObject)?.SecondLocation ?? MapLocation.StartingLocation));
 }
Example #14
0
 public TreasureChest(IRewardSource copyFromRewardSource, Item item, AccessRequirement access)
     : base(copyFromRewardSource, item)
 {
     AccessRequirement = access;
 }
Example #15
0
 public TreasureChest(int address, string name, MapLocation mapLocation, Item item,
                      AccessRequirement accessRequirement = AccessRequirement.None,
                      bool isUnused = false)
     : base(address, name, mapLocation, item, accessRequirement, isUnused)
 {
 }