Пример #1
0
        public void Init()
        {
            // Create the basic actor instances and behavior for test.
            this.witness = new Thing() { Name = "Witness", ID = TestThingID.Generate("testthing") };
            this.stalker1 = new Thing() { Name = "Stalker1", ID = TestThingID.Generate("testthing") };
            this.stalker2 = new Thing() { Name = "Stalker2", ID = TestThingID.Generate("testthing") };
            this.victim1 = new Thing() { Name = "Victim1", ID = TestThingID.Generate("testthing") };
            this.victim2 = new Thing() { Name = "Victim2", ID = TestThingID.Generate("testthing") };

            // Set up the rooms.
            this.room1 = new Thing() { Name = "Room", ID = TestThingID.Generate("room") };
            this.room2 = new Thing() { Name = "Room 2", ID = TestThingID.Generate("room") };

            // Set up an exit connecting the two rooms.
            this.exit = new Thing() { Name = "East Exit", ID = TestThingID.Generate("exit") };
            var exitBehavior = new ExitBehavior();
            ////exitBehavior.AddDestination("west", room1.ID);
            ////exitBehavior.AddDestination("east", room1.ID);
            ////this.exit.BehaviorManager.Add(exitBehavior);

            this.room1.Add(this.exit);
            this.room2.Add(this.exit);

            // Populate the first room.
            this.room1.Add(this.witness);
            this.room1.Add(this.stalker1);
            this.room1.Add(this.stalker2);
            this.room1.Add(this.victim1);
            this.room1.Add(this.victim2);

            // Prepare to verify correct eventing occurs.
            this.witness.Eventing.MovementRequest += (root, e) => { this.lastWitnessRequest = e; };
            this.witness.Eventing.MovementEvent += (root, e) => { this.lastWitnessEvent = e; };
            this.stalker1.Eventing.MovementRequest += (root, e) => { this.lastStalkerRequest = e; };
            this.stalker1.Eventing.MovementEvent += (root, e) => { this.lastStalkerEvent = e; };
            this.stalker2.Eventing.MovementRequest += (root, e) => { this.lastStalkerRequest = e; };
            this.stalker2.Eventing.MovementEvent += (root, e) => { this.lastStalkerEvent = e; };
            this.victim1.Eventing.MovementRequest += (root, e) => { this.lastVictimRequest = e; };
            this.victim1.Eventing.MovementEvent += (root, e) => { this.lastVictimEvent = e; };
            this.victim2.Eventing.MovementRequest += (root, e) => { this.lastVictimRequest = e; };
            this.victim2.Eventing.MovementEvent += (root, e) => { this.lastVictimEvent = e; };
        }
        public void Init()
        {
            // Create the basic actor instances and behavior for test.
            this.witnessThing = new Thing() { Name = "WitnessThing", ID = TestThingID.Generate("testthing") };
            this.actingThing = new Thing() { Name = "ActingThing", ID = TestThingID.Generate("testthing") };
            this.lockableThing = new Thing() { Name = "LockableThing", ID = TestThingID.Generate("testthing") };
            this.locksUnlocksBehavior = new LocksUnlocksBehavior();

            // Set up the actors inside another (which we'll call a "room" although it needn't actually be a room).
            this.room = new Thing() { Name = "Room", ID = TestThingID.Generate("room") };
            this.room.Add(witnessThing);
            this.room.Add(actingThing);
            this.room.Add(lockableThing);

            // Prepare to verify correct eventing occurs.
            this.witnessThing.Eventing.MiscellaneousRequest += (root, e) => { this.lastWitnessRequest = e; };
            this.witnessThing.Eventing.MiscellaneousEvent += (root, e) => { this.lastWitnessEvent = e; };
            this.actingThing.Eventing.MiscellaneousRequest += (root, e) => { this.lastActorRequest = e; };
            this.actingThing.Eventing.MiscellaneousEvent += (root, e) => { this.lastActorEvent = e; };
        }
Пример #3
0
        private void OnRequest(Func <ThingEventing, CancellableGameEventHandler> handlerSelector, CancellableGameEvent e, EventScope eventScope)
        {
            // Determine what layer(s) we're broadcasting to; beyond the first layer, these should all be to Children.
            switch (eventScope)
            {
            case EventScope.ParentsDown:
                // Send the request to each parent, until cancellation is noticed or we've finished.
                Queue <Thing> requestQueue = new Queue <Thing>(this.owner.Parents);
                while (requestQueue.Count > 0 && !e.IsCancelled)
                {
                    Thing currentParent = requestQueue.Dequeue();
                    currentParent.Eventing.OnRequest(handlerSelector, e);
                }

                break;

            case EventScope.SelfDown:
                this.OnRequest(handlerSelector, e);
                break;

            default:
                throw new NotImplementedException();
            }
        }
Пример #4
0
        /// <summary>
        /// Shared code for request handling.
        /// </summary>
        /// <param name="handlerSelector">A function which returns the appropriate Handler for a given Thing.</param>
        /// <param name="e">The game event args to pass through.</param>
        private void OnRequest(Func <ThingEventing, CancellableGameEventHandler> handlerSelector, CancellableGameEvent e)
        {
            // Build a request target queue which starts with our owner Thing and visits all it's Children.
            // (This is a queue instead of recursion to help avoid stack overflows and such with very large object trees.)
            Queue <Thing> requestTargetQueue = new Queue <Thing>();

            requestTargetQueue.Enqueue(this.owner);

            while (requestTargetQueue.Count > 0)
            {
                // If anything (like one of the thing's Behaviors) is subscribed to this request, send it there.
                Thing currentRequestTarget = requestTargetQueue.Dequeue();
                var   handler = handlerSelector(currentRequestTarget.Eventing);
                if (handler != null)
                {
                    handler(currentRequestTarget, e);

                    // If the event has been cancelled by the handler, we no longer need to look for further permission.
                    if (e.IsCancelled)
                    {
                        break;
                    }
                }

                // Enqueue all the current target's children for processing.
                foreach (Thing child in currentRequestTarget.Children)
                {
                    requestTargetQueue.Enqueue(child);
                }
            }
        }
Пример #5
0
        /// <summary>
        /// Shared code for request handling.
        /// </summary>
        /// <param name="handlerSelector">A function which returns the appropriate Handler for a given Thing.</param>
        /// <param name="e">The game event args to pass through.</param>
        private void OnRequest(Func<ThingEventing, CancellableGameEventHandler> handlerSelector, CancellableGameEvent e)
        {
            // Build a request target queue which starts with our owner Thing and visits all it's Children.
            // (This is a queue instead of recursion to help avoid stack overflows and such with very large object trees.)
            Queue<Thing> requestTargetQueue = new Queue<Thing>();
            requestTargetQueue.Enqueue(this.owner);

            while (requestTargetQueue.Count > 0)
            {
                // If anything (like one of the thing's Behaviors) is subscribed to this request, send it there.
                Thing currentRequestTarget = requestTargetQueue.Dequeue();
                var handler = handlerSelector(currentRequestTarget.Eventing);
                if (handler != null)
                {
                    handler(currentRequestTarget, e);

                    // If the event has been cancelled by the handler, we no longer need to look for further permission.
                    if (e.IsCancelled)
                    {
                        break;
                    }
                }

                // Enqueue all the current target's children for processing.
                foreach (Thing child in currentRequestTarget.Children)
                {
                    requestTargetQueue.Enqueue(child);
                }
            }
        }
Пример #6
0
 /// <summary>
 /// Raises the <see cref="CombatRequest"/> event.
 /// </summary>
 /// <param name="e">The <see cref="WheelMUD.Core.Events.CancellableGameEvent"/> instance containing the event data.</param>
 /// <param name="eventScope">The base target(s) to broadcast to, including their children.</param>
 public void OnCombatRequest(CancellableGameEvent e, EventScope eventScope)
 {
     Func<ThingEventing, CancellableGameEventHandler> handlerSelector = (t) => { return t.CombatRequest; };
     this.OnRequest(handlerSelector, e, eventScope);
 }
Пример #7
0
 /// <summary>
 /// Handle any requests this behavior is registered to.
 /// </summary>
 /// <param name="root">The root Thing where this event broadcast started.</param>
 /// <param name="e">The cancellable event/request arguments.</param>
 private void RequestHandler(Thing root, CancellableGameEvent e)
 {
     // Only cancel requestes to open our parent if it is currently locked.
     if (this.IsLocked)
     {
         var parent = this.Parent;
         if (parent != null)
         {
             // If this is a standard open request, find out if we need to cancel it.
             var openCloseEvent = e as OpenCloseEvent;
             if (openCloseEvent != null && openCloseEvent.IsBeingOpened && openCloseEvent.Target == this.Parent)
             {
                 string message = string.Format("You cannot open {0} since it is locked!", this.Parent.Name);
                 openCloseEvent.Cancel(message);
             }
         }
     }
 }
Пример #8
0
        private void OnRequest(Func<ThingEventing, CancellableGameEventHandler> handlerSelector, CancellableGameEvent e, EventScope eventScope)
        {
            // Determine what layer(s) we're broadcasting to; beyond the first layer, these should all be to Children.
            switch (eventScope)
            {
                case EventScope.ParentsDown:
                    // Send the request to each parent, until cancellation is noticed or we've finished.
                    Queue<Thing> requestQueue = new Queue<Thing>(this.owner.Parents);
                    while (requestQueue.Count > 0 && !e.IsCancelled)
                    {
                        Thing currentParent = requestQueue.Dequeue();
                        currentParent.Eventing.OnRequest(handlerSelector, e);
                    }

                    break;
                case EventScope.SelfDown:
                    this.OnRequest(handlerSelector, e);
                    break;
                default:
                    throw new NotImplementedException();
            }
        }
Пример #9
0
 /// <summary>
 /// Clear all potentially tracked events so we can verify new ones.
 /// </summary>
 private void ClearTrackedEvents()
 {
     this.lastStalkerEvent = null;
     this.lastStalkerRequest = null;
     this.lastVictimEvent = null;
     this.lastVictimRequest = null;
     this.lastWitnessEvent = null;
     this.lastWitnessRequest = null;
 }
Пример #10
0
 /// <summary>
 /// Clear all potentially tracked events so we can verify new ones.
 /// </summary>
 private void ClearTrackedEvents()
 {
     this.lastActorEvent = null;
     this.lastActorRequest = null;
     this.lastWitnessEvent = null;
     this.lastWitnessRequest = null;
 }
Пример #11
0
 /// <summary>Raises the <see cref="CommunicationRequest"/> event.</summary>
 /// <param name="e">The <see cref="WheelMUD.Core.Events.CancellableGameEvent"/> instance containing the event data.</param>
 /// <param name="eventScope">The base target(s) to broadcast to, including their children.</param>
 public void OnCommunicationRequest(CancellableGameEvent e, EventScope eventScope)
 {
     this.OnRequest(t => t.CommunicationRequest, e, eventScope);
 }
Пример #12
0
 /// <summary>Raises the <see cref="MiscellaneousRequest"/> event.</summary>
 /// <param name="e">The <see cref="WheelMUD.Core.Events.CancellableGameEvent"/> instance containing the event data.</param>
 /// <param name="eventScope">The base target(s) to broadcast to, including their children.</param>
 public void OnMiscellaneousRequest(CancellableGameEvent e, EventScope eventScope)
 {
     this.OnRequest(t => t.MiscellaneousRequest, e, eventScope);
 }
Пример #13
0
 /// <summary>Raises the <see cref="MovementRequest"/> event.</summary>
 /// <param name="e">The <see cref="WheelMUD.Core.Events.CancellableGameEvent"/> instance containing the event data.</param>
 /// <param name="eventScope">The base target(s) to broadcast to, including their children.</param>
 public void OnMovementRequest(CancellableGameEvent e, EventScope eventScope)
 {
     this.OnRequest(t => t.MovementRequest, e, eventScope);
 }
Пример #14
0
 /// <summary>Raises the <see cref="CombatRequest"/> event.</summary>
 /// <param name="e">The <see cref="WheelMUD.Core.Events.CancellableGameEvent"/> instance containing the event data.</param>
 /// <param name="eventScope">The base target(s) to broadcast to, including their children.</param>
 public void OnCombatRequest(CancellableGameEvent e, EventScope eventScope)
 {
     OnRequest(t => t.CombatRequest, e, eventScope);
 }
Пример #15
0
 private void DenyCommunicationRequest(IThing root, CancellableGameEvent e)
 {
     var communicationRequest = e as VerbalCommunicationEvent;
     if (communicationRequest != null && communicationRequest.ActiveThing == this.Parent)
     {
         e.Cancel("You are currently muted.");
     }
 }
Пример #16
0
        /// <summary>
        /// Raises the <see cref="MiscellaneousRequest"/> event.
        /// </summary>
        /// <param name="e">The <see cref="WheelMUD.Core.Events.CancellableGameEvent"/> instance containing the event data.</param>
        /// <param name="eventScope">The base target(s) to broadcast to, including their children.</param>
        public void OnMiscellaneousRequest(CancellableGameEvent e, EventScope eventScope)
        {
            Func <ThingEventing, CancellableGameEventHandler> handlerSelector = (t) => { return(t.MiscellaneousRequest); };

            this.OnRequest(handlerSelector, e, eventScope);
        }
Пример #17
0
 /// <summary>Called when a player is trying to log out, to raise the player log out request.</summary>
 /// <param name="player">The player.</param>
 /// <param name="e">The event arguments.</param>
 public static void OnPlayerLogOutRequest(Thing player, CancellableGameEvent e)
 {
     var eventHandler = GlobalPlayerLogOutRequest;
     if (eventHandler != null)
     {
         eventHandler(player.Parent, e);
     }
 }
Пример #18
0
 /// <summary>
 /// Event handler for denying the changing of the parent of a Thing which has a WorldBehavior since World should be highest.
 /// </summary>
 /// <param name="sender">The sender of the event.</param>
 /// <param name="e">The event arguments.</param>
 private void DenyWorldParentChanges(Thing sender, CancellableGameEvent e)
 {
     if (e.ActiveThing == this.Parent)
     {
         var addChildRequest = e as AddChildEvent;
         if (addChildRequest != null)
         {
             addChildRequest.Cancel("World cannot become a child of anything.");
         }
     }
 }
Пример #19
0
 /// <summary>
 /// Handle any movement requests.
 /// </summary>
 /// <param name="root">The root Thing where this event broadcast started.</param>
 /// <param name="e">The cancellable event/request arguments.</param>
 private void MovementRequestHandler(Thing root, CancellableGameEvent e)
 {
     // Only cancel movement requests through our parent if it is currently closed.
     if (!this.IsOpen)
     {
         var parent = this.Parent;
         if (parent != null)
         {
             // If this is a standard movement request, find out if we need to cancel it.
             var movementEvent = e as MovementEvent;
             if (movementEvent != null && movementEvent.GoingVia == this.Parent)
             {
                 // @@@ TODO: If the actor also cannot perceive our parent properly, perhaps broadcast
                 //     a sensory event like "Dude blindly ran into a door."
                 string message = string.Format("You cannot move through {0} since it is closed!", this.Parent.Name);
                 movementEvent.Cancel(message);
             }
         }
     }
 }
Пример #20
0
 private void Parent_MovementRequest(Thing root, CancellableGameEvent e)
 {
     // @@@ TODO: When our parent Thing gets an Arrive request (such as when a thing is attempting to enter an
     // enterable portal), we want to cancel the event and replace it with our own movement request to enter the
     // portal's target location.
 }
Пример #21
0
 /// <summary>
 /// Intercepts and cancels a movement request for the wielded item.
 /// This way a player will not accidentally drop a wielded weapon, etc.
 /// </summary>
 /// <param name="root">The root.</param>
 /// <param name="e">The event.</param>
 private void Eventing_MovementRequest(Thing root, CancellableGameEvent e)
 {
     var evt = e as ChangeOwnerEvent;
     if (evt != null)
     {
         if (evt.Thing.ID == this.itemToWield.ID)
         {
             evt.Cancel(string.Format("The {0} is still wielded!", this.itemToWield.Name));
         }
     }
 }