Example #1
0
 public LoggerView(XmasModel model, Logger log)
     : base(new ThreadSafeEventManager())
 {
     this.log = log;
     this.evtq = model.EventManager.ConstructEventQueue();
     this.ThreadSafeEventManager.AddEventQueue(evtq);
     this.evtq.Register(new Trigger<ActionFailedEvent>(engine_ActionFailed));
 }
Example #2
0
 // Use this for initialization
 void Start()
 {
     XmasWorldBuilder builder = retreiveBuilderFromMap();
     EventManager evtman = new EventManager();
     ActionManager actman = new ActionManager(evtman);
     XmasFactory factory = new GameFactory(actman);
     engine = new XmasModel(builder, actman, evtman, factory);
 }
Example #3
0
        /// <summary>
        /// Constructs a engine with all its components
        /// </summary>
        /// <param name="builder">The builder for constructing the world</param>
        /// <returns>The model</returns>
        public virtual XmasModel ConstructModel(XmasWorldBuilder builder)
        {
            EventManager evtman = ConstructEventManager();
            ActionManager actman = ConstructActionManager(evtman);
            XmasFactory fact = ConstructFactory(actman);
            XmasModel engine = new XmasModel(builder, actman, evtman, fact);

            return engine;
        }
 public void Initialize(UnityFactory factory, GuiInformation info, XmasModel engine, bool reversed)
 {
     this.Factory = factory;
     this.GUIInfo = info;
     this.Engine = engine;
     this.reversed = reversed;
     Engine.EventManager.Register(new Trigger<ManaCrystalAddedEvent>(evt=>evt.Owner==this.GUIInfo.Player,OnManaAdded));
     Engine.EventManager.Register(new Trigger<ManaCrystalSpentEvent>(evt => evt.Owner == this.GUIInfo.Player, OnManaSpent));
     Engine.EventManager.Register(new Trigger<ManaRechargedEvent>(evt => evt.Owner == this.GUIInfo.Player, OnManaRecharged));
 }
Example #5
0
        public VacuumWorldView(XmasModel model,Logger log)
            : base(model,log)
        {
            //Construct an ThreadSafe Event queue which triggers can be registered to while keeping the code thread safe
            this.evtq = model.EventManager.ConstructEventQueue();
            this.ThreadSafeEventManager.AddEventQueue(evtq);

            //Register the triggers that track the vacuum cleaners actions
            this.evtq.Register(new Trigger<VacuumMovedEvent>(vacuum_Moved));
            this.evtq.Register(new Trigger<VacuumSuckedEvent>(vacuum_Sucked));
        }
Example #6
0
 public ConsoleView(XmasModel model, Point drawPos, ConsoleWorldView viewWorld, ConsoleViewFactory entityFactory, ThreadSafeEventManager evtmanager)
     : base(evtmanager)
 {
     this.viewWorld = viewWorld;
     this.entityFactory = entityFactory;
     this.drawPos = drawPos;
     eventqueue = model.EventManager.ConstructEventQueue();
     evtmanager.AddEventQueue(eventqueue);
     eventqueue.Register(new Trigger<EntityAddedEvent>(Model_EntityAdded));
     eventqueue.Register(new Trigger<EntityRemovedEvent>(model_EntityRemoved));
 }
Example #7
0
 // Use this for initialization
 void Start()
 {
     engmodel = Engine.EngineModel;
     engmodel.EventManager.Register(new Trigger<ActionFailedEvent>(evt => Debug.Log("Engine action("+evt.FailedAction+") failed: " + evt.Exception.Message+" at "+evt.Exception.StackTrace)));
     //engmodel.EventManager.Register(new Trigger<EndMoveEvent>(evt => Debug.Log("Unit has moved to " + evt.To)));
     engmodel.EventManager.Register(new Trigger<PlayersTurnChangedEvent>(evt => Debug.Log("Player turn changed to: "+evt.PlayersTurn.Name)));
     engmodel.EventManager.Register(new Trigger<PhaseChangedEvent>(evt => Debug.Log("Phase changed to: " + evt.NewPhase.ToString())));
     engmodel.EventManager.Register(new Trigger<PlayerGainedPriorityEvent>(evt => { if (evt.Player != null) Debug.Log("Player gained priority: " + evt.Player.Name); }));
     engmodel.EventManager.Register(new Trigger<PlayerJoinedEvent>(evt => Debug.Log("Player joined: " + evt.Player.Name )));
     engmodel.EventManager.Register(new Trigger<TriggerFailedEvent>(evt => Debug.Log(evt.FailedTrigger + " failed: " + evt.Exception.Message + " at " + evt.Exception.StackTrace)));
     engmodel.EventManager.Register(new Trigger<ActionCompletedEvent<AttackUnitAction>>(evt => Debug.Log("Attack dealt "+evt.Action.DamageOnResolve+" to "+evt.Action.Target)));
 }
Example #8
0
        public void Initialize()
        {
            guiinfo = this.gameObject.GetComponent<GuiInformation>();
            engmodel = Engine.EngineModel;

            engmodel.EventManager.Register(new Trigger<PlayerGainedPriorityEvent>(OnPlayerPriority));
            engmodel.EventManager.Register(new Trigger<PlayersTurnChangedEvent>(OnTurnChanged));
            engmodel.EventManager.Register(new Trigger<PhaseChangedEvent>(OnPhaseChanged));
            engmodel.EventManager.Register(new Trigger<PlayerDeclareMoveAttackEvent>(evt => evt.Player == this.guiinfo.Player,OnPlayerDeclare));
            engmodel.EventManager.Register(new Trigger<PhaseChangedEvent>(OnPhaseChangedEvt));
            engmodel.EventManager.Register(new Trigger<CardDrawnEvent>(evt => evt.Player == this.guiinfo.Player, OnPlayerDrawCard));
            setupHpText();
            this.initHPWidth = this.guiinfo.HealthBar.GetComponent<GUITextureAutoScaler>().CurPlacement.width;
        }
Example #9
0
        /// <summary>
        /// Starts the engine by providing the model and all its view and controllers with each their own thread.
        /// All actions queued to the engine is executed before the threads are started.
        /// </summary>
        /// <param name="model">The model of the engine</param>
        /// <param name="views">The views of the engine</param>
        /// <param name="controllers">The controllers of the engine</param>
        public void StartEngine(XmasModel model,ICollection<XmasView> views, ICollection<XmasController> controllers)
        {
            if (modelThread != null)
            {
                throw new EngineAlreadyStartedException();
            }
            XmasFactory fact = model.Factory;
            Thread modelt = fact.CreateThread(model.Start);

            model.Initialize();

            int i = 1;

            foreach (var xmasView in views)
            {
                model.AddActor(xmasView);
                xmasView.Initialize();
                Thread viewt = fact.CreateThread(xmasView.Start);
                viewt.Name = "View Thread "+i;
                i++;
                viewThreads.Add(viewt);
            }

            i = 1;
            foreach (var xmasController in controllers)
            {
                model.AddActor(xmasController);
                xmasController.Initialize();
                Thread cont = fact.CreateThread(xmasController.Start);
                cont.Name = xmasController.ThreadName()+" "+ i;
                i++;
                controllerThreads.Add(cont);
            }

            modelt.Name = "Model Thread";
            modelThread = modelt;

            model.ActionManager.ExecuteActions();

            modelt.Start();
            foreach (var viewThread in viewThreads)
            {
                viewThread.Start();
            }

            foreach (var controllerThread in controllerThreads)
            {
                controllerThread.Start();
            }
        }
Example #10
0
        public ConsoleLoggerView( XmasModel model
		                         , LoggerViewFactory entityFactory
		                         , ThreadSafeEventManager evtman
		                         , Logger log
		                         )
            : base(evtman)
        {
            this.entityFactory = entityFactory;
            this.log = log;

            evtqueue = model.EventManager.ConstructEventQueue();
            ThreadSafeEventManager.AddEventQueue(evtqueue);

            evtqueue.Register (new Trigger<EntityAddedEvent> (model_EntityAdded));
            evtqueue.Register (new Trigger<ActionFailedEvent> (engine_ActionFailed));
            evtqueue.Register(new Trigger<EisAgentDisconnectedEvent>(controller_AgentDisconnected));
            evtqueue.Register(new Trigger<EntityRemovedEvent>(model_EntityRemoved));
            evtqueue.Register(new Trigger<EisAgentTimingEvent>(entity_TimerElapsedEvent));
        }
Example #11
0
        // Use this for initialization
        public void Initialize()
        {
            this.guiinfo = this.gameObject.GetComponent<GuiInformation>();
            this.GuiView = this.gameObject.GetComponent<GuiViewHandler>();

            hasPriority = false;
            if (PlayerCamera == null)
                PlayerCamera = Camera.main;

            engmodel = Engine.EngineModel;

            engmodel.EventManager.Register(new Trigger<PlayerGainedPriorityEvent>(evt => hasPriority = evt.Player == guiinfo.Player ));
            engmodel.EventManager.Register(new Trigger<PlayerAllowedToDeclareMoveAttackEvent>(evt => allowedToDeclare = (evt.Player == guiinfo.Player && evt.Allowed)));

            //foreach (var player in this.JoinedPlayers)
            //{
            //    foreach(Phases phase in (Phases[])Enum.GetValues(typeof(Phases)))
            //    {
            //        var texture = guiinfo.GetSkipPhaseButton(player, phase);
            //        if (texture == null)
            //            continue;

            //        var buttonHandler = texture.GetComponent<GUIButtonHandler>();
            //        var selectedPlayer = player;
            //        var selectedPhase = phase;
            //        buttonHandler.MouseDownEvent += (sender, evt) =>
            //        {
            //            if (this.hasPriority && this.ControllerType == ControllerType.Shared || this.ControllerType == ControllerType.Full)
            //            {
            //                //this.PerformCommand(new ToggleStopPriorityCommand(SkipController, selectedPlayer, selectedPhase));
            //            }
            //        };
            //    }
            //}

            foreach (Phases ph in (Phases[])Enum.GetValues(typeof(Phases)))
            {
                var texture = guiinfo[ph];
                var buttonhandler = texture.GetComponent<GUIButtonHandler>();
                var selectedPhase = ph;

                buttonhandler.MouseDownEvent += (sender, evt) =>
                    {
                        if(hasPriority)
                            this.PerformCommand(new SkipToPhaseCommand(SkipController, selectedPhase));
                    };

            }

            var buyXp = this.guiinfo.XPButton.GetComponent<GUIButtonHandler>();
            buyXp.MouseDownEvent += new EventHandler(buyXp_MouseDownEvent);
        }
Example #12
0
 public void Start()
 {
     this.engine = EngineHandler.EngineModel;
     this.engine.EventManager.Register(new Trigger<ActionCompletedEvent<CastCardCommand>>(OnCastCard));
     this.engine.EventManager.Register(new Trigger<DequeueAbilityEvent>(evt => evt.Ability is Spell,OnSpellRemovedFromStack));
 }
Example #13
0
    // Use this for initialization
    void Start()
    {
        engmodel = Engine.EngineModel;

        //Start turn manager
        TurnManager turnManager = new TurnManager();
        engmodel.AddActor(turnManager);

        AbilityManager abilityManager = new AbilityManager();
        engmodel.AddActor(abilityManager);

        engmodel.EventManager.Register(new Trigger<PlayerJoinedEvent>(OnPlayerJoin));
        Player[] players = Settings.LocalPlayers;

        foreach (Player p in players)
        {
            engmodel.ActionManager.Queue(new PlayerJoinAction(p));
        }
    }