public IEnumerator makeUnitSelection(List <Unit> possibleUnits)
{
bool selectionMade = false;
Unit selectedUnit;
while (!selectionMade)
{
Debug.Log("Waiting for game unit selection");
yield return(StartCoroutine(GameEventHandler.WaitForKeyDown(KeyCode.Mouse0)));
RaycastHit hitInfo = new RaycastHit();
bool hit = Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hitInfo);
if (hit)
{
if (hitInfo.transform.parent.gameObject.tag == "Unit")
{
selectedUnit = hitInfo.transform.gameObject.GetComponentInParent <Unit>();
if (selectedUnit != null && possibleUnits.Contains(selectedUnit))
{
selectionMade = true;
lastUnitSelection = selectedUnit;
}
}
}
}
}
public GameAI(GameEventHandler forminteract)
{
guiContext = SynchronizationContext.Current;
if (guiContext == null)
guiContext = new SynchronizationContext();
// threads
threadDelegate = new Dictionary<string, ThreadStart>();
threadDelegate.Add("MGO", MGO_Thread);
threadDelegate.Add("Paint", Paint_Thread);
threadDelegate.Add("Checker1", Checker1_Thread);
threadDelegate.Add("Checker2", Checker2_Thread);
threadDelegate.Add("Checker3", Checker3_Thread);
watch = new Dictionary<string, StopwatchExtended>();
watch[""] = new StopwatchExtended(); // GUI-Thread
thread = new Dictionary<string, Thread>();
foreach (string s in threadDelegate.Keys)
{
watch[s] = new StopwatchExtended();
thread[s] = null;
}
scrollTop = 0;
this.guiinteract = forminteract;
this.curkeys = new List<Keys>();
this.pressedKeys = new List<GameKey>();
mainTimer = new System.Windows.Forms.Timer();
mainTimer.Tick += new EventHandler(Check);
mainTimer.Interval = 1;
mainTimer.Enabled = false;
}
public IEnumerator makeIntersectionSelection(List <Intersection> possibleIntersections)
{
bool selectionMade = false;
Intersection selectedIntersection;
while (!selectionMade)
{
yield return(StartCoroutine(GameEventHandler.WaitForKeyDown(KeyCode.Mouse0)));
RaycastHit hitInfo = new RaycastHit();
bool hit = Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hitInfo);
if (hit)
{
if (hitInfo.transform.gameObject.tag == "Intersection")
{
selectedIntersection = hitInfo.transform.gameObject.GetComponent <Intersection>();
if (selectedIntersection != null && selectedIntersection.occupier == null && possibleIntersections.Contains(selectedIntersection))
{
selectionMade = true;
lastIntersectionSelection = selectedIntersection;
}
}
}
}
}
public IEnumerator makeOccupiedEdgeSelection(List <Edge> possibleEdges) //, TradeUnit unitToBuild) {
{
bool selectionMade = false;
Edge selectedEdge;
while (!selectionMade)
{
Debug.Log("waiting for edge selection");
yield return(StartCoroutine(GameEventHandler.WaitForKeyDown(KeyCode.Mouse0)));
RaycastHit hitInfo = new RaycastHit();
bool hit = Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hitInfo);
if (hit)
{
if (hitInfo.transform.gameObject.tag == "Edge")
{
Debug.Log("hit edge");
selectedEdge = hitInfo.transform.gameObject.GetComponent <Edge>();
if (selectedEdge != null && possibleEdges.Contains(selectedEdge))
{
Debug.Log("edge is valid");
selectionMade = true;
lastEdgeSelection = selectedEdge;
}
}
}
}
}
void Start()
{
SpawnSignal(null);
gameover = false;
GameEventHandler.Subscribe(GameEvent.BeamDisrupted, SpawnSignal);
GameEventHandler.Subscribe(GameEvent.GameOver, stopSpawning);
}
private void Awake()
{
dao = new RoomDAO();
eventHandler = GameEventHandler.Instance;
eventHandler.AddHandler(this, UserManager.USER_LOGIN_COMPLETE, OnLoginCompleteHandler);
eventHandler.AddHandler(this, ResponseManager.ON_DATA_RECIEVE, OnDataReceive);
gameEvent = GameEvent.Instance;
}
private void Awake()
{
_playerShipBehavior = FindObjectOfType <PlayerShipBehavior>();
_gameEventHandler = FindObjectOfType <GameEventHandler>();
activeWeaponModel = weaponModels[0];
activeProjectile = projectiles[0];
}
// Use this for initialization
void Start()
{
gameHandler = GameHandler.instance;
missingPlayers.text = 2 - numPlayers + " Players Missing";
GameEventHandler.Subscribe(GameEvent.GameStarted, GameStarted);
sphereCollider = GetComponent <SphereCollider>();
}
public void Setup()
{
Core.Game = null;
_game = new GameV2();
Core.Game = _game;
_gameEventHandler = new GameEventHandler(_game);
_heroPlayer = CreateNewEntity("HERO_01");
_heroPlayer.SetTag(GameTag.CARDTYPE, (int)CardType.HERO);
_heroPlayer.IsPlayer = true;
_heroOpponent = CreateNewEntity("HERO_02");
_heroOpponent.SetTag(GameTag.CARDTYPE, (int)CardType.HERO);
_heroOpponent.SetTag(GameTag.CONTROLLER, _heroOpponent.Id);
_heroOpponent.IsPlayer = false;
_game.Entities.Add(0, _heroPlayer);
_game.Player.Id = _heroPlayer.Id;
_game.Entities.Add(1, _heroOpponent);
_game.Opponent.Id = _heroOpponent.Id;
_playerMinion1 = CreateNewEntity("EX1_010");
_playerMinion1.SetTag(GameTag.CARDTYPE, (int)CardType.MINION);
_playerMinion1.SetTag(GameTag.CONTROLLER, _heroPlayer.Id);
_opponentMinion1 = CreateNewEntity("EX1_020");
_opponentMinion1.SetTag(GameTag.CARDTYPE, (int)CardType.MINION);
_opponentMinion1.SetTag(GameTag.CONTROLLER, _heroOpponent.Id);
_opponentMinion2 = CreateNewEntity("EX1_021");
_opponentMinion2.SetTag(GameTag.CARDTYPE, (int)CardType.MINION);
_opponentMinion2.SetTag(GameTag.CONTROLLER, _heroOpponent.Id);
_playerSpell1 = CreateNewEntity("CS2_029");
_playerSpell1.SetTag(GameTag.CARDTYPE, (int)CardType.SPELL);
_playerSpell1.SetTag(GameTag.CARD_TARGET, _opponentMinion1.Id);
_playerSpell1.SetTag(GameTag.CONTROLLER, _heroPlayer.Id);
_playerSpell2 = CreateNewEntity("CS2_025");
_playerSpell2.SetTag(GameTag.CARDTYPE, (int)CardType.SPELL);
_playerSpell2.SetTag(GameTag.CONTROLLER, _heroPlayer.Id);
_game.Entities.Add(2, _playerMinion1);
_game.Entities.Add(3, _opponentMinion1);
_game.Entities.Add(4, _opponentMinion2);
_secretHunter1 = CreateNewEntity("");
_secretHunter1.SetTag(GameTag.CLASS, (int)CardClass.HUNTER);
_secretHunter2 = CreateNewEntity("");
_secretHunter2.SetTag(GameTag.CLASS, (int)CardClass.HUNTER);
_secretMage1 = CreateNewEntity("");
_secretMage1.SetTag(GameTag.CLASS, (int)CardClass.MAGE);
_secretMage2 = CreateNewEntity("");
_secretMage2.SetTag(GameTag.CLASS, (int)CardClass.MAGE);
_secretPaladin1 = CreateNewEntity("");
_secretPaladin1.SetTag(GameTag.CLASS, (int)CardClass.PALADIN);
_secretPaladin2 = CreateNewEntity("");
_secretPaladin2.SetTag(GameTag.CLASS, (int)CardClass.PALADIN);
_gameEventHandler.HandleOpponentSecretPlayed(_secretHunter1, "", 0, 0, Zone.HAND, _secretHunter1.Id);
_gameEventHandler.HandleOpponentSecretPlayed(_secretMage1, "", 0, 0, Zone.HAND, _secretMage1.Id);
_gameEventHandler.HandleOpponentSecretPlayed(_secretPaladin1, "", 0, 0, Zone.HAND, _secretPaladin1.Id);
}
// new world with the game
public World(string filename, Drawing.DrawHandler drawHandler, GameEventHandler aiEventHandler, GameSession session, PlayMode playMode)
: this(playMode)
{
this.DrawHandler = drawHandler;
this.fileName = filename;
this.aiEventHandler = aiEventHandler;
this.session = session;
Deserialize();
}
void OnTriggerExit(Collider other)
{
if (other.tag.Equals("SignalZone"))
{
isWithinSignal = false;
signalArgument.teamID = (int)roverType;
GameEventHandler.TriggerEvent(GameEvent.SignalExit, signalArgument);
}
}
public void OnDamageDone(PlayerController player, Damage damage)
{
CurrentLevelDamage += damage.amount;
if (CurrentLevelDamage > NeededLevelDamage)
{
WinScreen.gameObject.SetActive(true);
GameEventHandler.TriggerOnPause();
}
}
public override void Init(World world, GameEventHandler aiEventHandler)
{
base.Init(world, aiEventHandler);
Dictionary<GameEventArg, object> args = new Dictionary<GameEventArg, object>();
args[GameEventArg.points] = 1;
World.MGO.getEvent(GameEvent.gotPoints, args);
}
public IEnumerator waitUntilButtonDown()
{
yield return(StartCoroutine(GameEventHandler.WaitForKeyDown(KeyCode.Mouse0)));
while (!selectionMade)
{
yield return(new WaitForEndOfFrame());
}
}
private void Awake()
{
_eventHandler = FindObjectOfType <GameEventHandler>();
_playerObject = GameObject.FindWithTag("Player");
_genericFunctions = FindObjectOfType <GenericFunctions>();
_rb = GetComponent <Rigidbody2D>();
_parentBubbleCenter = GenericFunctions.GetClosestCircle(transform.position);
}
public void Awake()
{
if (instance != null)
{
Destroy(gameObject);
return;
}
instance = this;
GameEventHandler.Initialize();
}
protected override void Start()
{
type = TriggerType.DisplayInfo;
events = this.transform.GetComponent <GameEventHandler> ();
if (events == null)
{
events = this.transform.GetComponentInParent <GameEventHandler> ();
}
}
protected override void Start()
{
type = TriggerType.PlayerFace;
thisCollider = this.transform.GetComponent <Collider2D> ();
facingObject = false;
player = this.transform.GetComponentInParent <OW_PlayerController> ();
events = this.transform.GetComponentInParent <GameEventHandler> ();
}
public void AddEventListenerTarget(IGameEvent target, Enum type, GameEventHandler handler, bool isUseOnce = false, bool isFirst = false)
{
mListenerEventList.Push(new ViewListenerEventInfo()
{
handler = handler,
type = type,
target = target
});
target.AddEvent(type, handler, isUseOnce, isFirst);
}
/// <summary>
/// Initializes a new instance of the <see cref="Entities.Overworld.PlayerMoveState"/> class.
/// </summary>
/// <param name="controller">Controller.</param>
/// <param name="character">Character.</param>
/// <param name="moveSpeed">Move speed.</param>
public PlayerMoveState(StateMachine controller, Transform character, float moveSpeed) : base(controller)
{
StateID = (int)OWStates.PlayerMove;
_character = character;
_moveSpeed = moveSpeed;
rb = _character.gameObject.GetComponent <Rigidbody2D>();
anim = _character.gameObject.GetComponent <Animator>();
events = _character.gameObject.GetComponent <GameEventHandler>();
}
void OnTriggerEnter(Collider other)
{
if (other.tag == "Player")
{
roundManager.PlayerDeath(other.gameObject.GetComponent <Player>());
playerArgument.gameObject = other.gameObject;
GameEventHandler.TriggerEvent(GameEvent.PlayerDeath, (GameEventArgs)playerArgument);
}
}
public GameEventInfo(Enum type, GameEventHandler handler, params object[] args)
{
this.type = type;
if (mHandler == null)
{
mHandler = new List <GameEventHandler>();
}
mHandler.Add(handler);
mArgs = args;
}
void Start()
{
GameEventHandler.Subscribe(GameEvent.PlayerHit, OnPlayerHit);
GameEventHandler.Subscribe(GameEvent.Dash, OnDash);
GameEventHandler.Subscribe(GameEvent.Jump, OnJump);
GameEventHandler.Subscribe(GameEvent.Land, OnLand);
GameEventHandler.Subscribe(GameEvent.Push, OnPush);
GameEventHandler.Subscribe(GameEvent.CooldownDash, OnCooldownDash);
GameEventHandler.Subscribe(GameEvent.CooldownPush, OnCooldownPush);
}
public void GameStarted(GameEventArgs eventArgs)
{
if (startHasRun)
{
return;
}
StartCoroutine(LerpToGame(startDuration));
GameEventHandler.Unsubscribe(GameEvent.GameStarted, GameStarted);
}
public void FAIL()
{
GameEventHandler.TriggerEvent(GameEvent.BeamDisrupted);
beam.distrupt();
beamCollider.enabled = false;
PlayerSwap(0);
pattern.ResetIntensity();
}
public void registerListener(object eventType, GameEventHandler callback)
{
if (_listeners.ContainsKey(eventType))
{
_listeners[eventType] += callback;
}
else
{
_listeners[eventType] = callback;
}
}
void OnTriggerEnter2D(Collider2D other)
{
CancelInvoke();
//apply bullet damage
this.e.ShotDamage = this.Damage;
this.e.HitCollider = other;
GameEventHandler.OnBulletHit(this, this.e);
this.Kill();
}
private void AddRenderEvents()
{
foreach (Transform ent in entities)
{
GameEventHandler handler = ent.GetComponent <GameEventHandler> ();
if (handler != null)
{
handler.moveEvent += UpdateEntityRenderingOrders;
}
}
}
public IEnumerator waitUntilButtonDown()
{
yield return(StartCoroutine(GameEventHandler.WaitForKeyDown(KeyCode.Mouse0)));
while (!selectionMade)
{
Debug.Log("waiting key down");
yield return(new WaitForEndOfFrame());
}
Debug.Log("Keydown recieved");
}
public void GameStarted(GameEventArgs eventArgs)
{
Collider c = GetComponent <Collider>();
Destroy(c);
Destroy(this);
missingPlayers.enabled = false;
GameEventHandler.Unsubscribe(GameEvent.GameStarted, GameStarted);
}
public void RegisterEvent(int code, GameEventDelegate dele)
{
GameEventHandler handler;
if (!values.TryGetValue(code, out handler))
{
handler = new GameEventHandler();
values.Add(code, handler);
}
handler.Add(dele);
}
public void Bind(GameEventType type, GameEventHandler handler)
{
if (m_handlerDict.ContainsKey(type) && m_handlerDict[type] != null)
{
m_handlerDict[type] += handler;
}
else
{
m_handlerDict[type] = handler;
}
}
private void AddDisplayEvents()
{
foreach (Transform ent in entities)
{
GameEventHandler handler = ent.GetComponent <GameEventHandler> ();
if (handler != null)
{
handler.displayStringTextboxEvent += DisplayText;
handler.displayTextFileTextboxEvent += DisplayTextFromFile;
}
}
}
public World(int gameWindowWidth, int gameWindowHeight,
int levelWidth, int levelHeight,
Drawing.DrawHandler drawHandler, PlayMode playMode)
: this(playMode)
{
Settings = new LevelSettings();
Settings.GameWindowWidth = gameWindowWidth;
Settings.GameWindowHeight = gameWindowHeight;
Settings.LevelWidth = levelWidth;
Settings.LevelHeight = levelHeight;
this.DrawHandler = drawHandler;
this.aiEventHandler = GameAI.NullAiEventHandlerMethod;
enemies = new List<Enemy>();
stickyelements = new List<StickyElement>();
movingelements = new List<MovingElement>();
}
private void TestQueueWithMultipleDelegates()
{
var newActorEvent = new EventData_New_Actor(1, 1);
QueueNewActorHandler = HandleQueueNewActor;
QueueNewActorRenderHandler = HandleQueueRenderNewActor;
EventManager.Instance.AddListener(EventData_New_Actor.Type, QueueNewActorHandler);
EventManager.Instance.AddListener(EventData_New_Actor.Type, QueueNewActorRenderHandler);
Logger.Debug("Two methods should fire");
EventManager.Instance.QueueEvent(newActorEvent);
EventManager.Instance.Update(1000);
EventManager.Instance.RemoveListener(EventData_New_Actor.Type, QueueNewActorHandler);
QueueNewActorHandler = null;
EventManager.Instance.RemoveListener(EventData_New_Actor.Type, QueueNewActorRenderHandler);
QueueNewActorRenderHandler = null;
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
{
switch (World.MGO.Mode)
{
case MainGameObjectMode.Small:
case MainGameObjectMode.Normal:
geventhandler(GameEvent.gotFireFlower, new Dictionary<GameEventArg, object>());
break;
case MainGameObjectMode.NormalFire:
Dictionary<GameEventArg, object> pointsArgs = new Dictionary<GameEventArg,object>();
pointsArgs[GameEventArg.points] = 10;
geventhandler(GameEvent.gotPoints, pointsArgs);
break;
}
World.StickyElements.Remove(this);
}
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (color == BrickColor.Ice && who == GameElement.MGO && direction == GameDirection.Top)
{
switch (World.MGO.Direction)
{
case GameDirection.Left:
for (int i = 0; i < 2; i++)
{
fillMgoMoveQueue(MoveType.goLeft);
}
break;
case GameDirection.Right:
for (int i = 0; i < 2; i++)
{
fillMgoMoveQueue(MoveType.goRight);
}
break;
}
}
}
private void TestAbortEvent()
{
var newActorEvent = new EventData_New_Actor(1, 1);
QueueNewActorHandler = HandleQueueNewActor;
EventManager.Instance.AddListener(EventData_New_Actor.Type, QueueNewActorHandler);
EventManager.Instance.QueueEvent(newActorEvent);
EventManager.Instance.QueueEvent(newActorEvent);
EventManager.Instance.AbortEvent(newActorEvent.EventType, false);
Logger.Debug("One event should fire");
EventManager.Instance.Update(1000);
EventManager.Instance.QueueEvent(newActorEvent);
EventManager.Instance.QueueEvent(newActorEvent);
EventManager.Instance.AbortEvent(newActorEvent.EventType, true);
Logger.Debug("No events should fire");
EventManager.Instance.Update(1000);
EventManager.Instance.RemoveListener(newActorEvent.EventType, QueueNewActorHandler);
QueueNewActorHandler = null;
}
public virtual void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
if (base.Name != null && base.Name != "" && World.Script != null)
World.Script.callFunction(base.Name, "onOver", geventhandler, who, direction);
}
/// <summary>
/// Takes a <see cref="Common.Person">Person</see> and allows them
/// to join the chat room, if there is not already a chatter with
/// the same name
/// </summary>
/// <param name="person"><see cref="Common.Person">Person</see> joining</param>
/// <returns>An array of <see cref="Common.Person">Person</see> objects</returns>
public JoinResult Join(XmlUserCredentials person)
{
MessageFromServerAction message = new MessageFromServerAction();
message.Sender = _ServerUser.ID;
if (person == null)
{
message.Message = "No valid person passed (Usercredentials object == null)";
return new JoinResult() { FailMessage = message };
}
if (String.IsNullOrEmpty(person.Name) ||
String.IsNullOrEmpty(person.Password))
{
message.Message = "either password or username isnt valid: empty password or username";
return new JoinResult() { FailMessage = message };
}
/*
XmlUser user = _UserAdministration.Authenticate(person);
// we failed to authenticate, communicate this back to user
if (user == null)
{
message.Message = "either password or username isnt valid, or both";
return new JoinResult() { FailMessage = message };
}
*/
//Yey! we are authenticated. Add user to list of users and
// return the lobby state
bool userAdded = false;
//create a new ChatEventHandler delegate, pointing to the MyEventHandler() method
myEventHandler = new GameEventHandler(MyEventHandler);
//carry out a critical section that checks to see if the new chatter
//name is already in use, if its not allow the new chatter to be
//added to the list of chatters, using the person as the key, and the
//ChatEventHandler delegate as the value, for later invocation
lock (threadSync)
{
/*
if (!PlayerExists(user.ID))
{
_Users.Add(user, MyEventHandler);
userAdded = true;
_CurrentPerson = user;
}
else
{
message.Message = "It seems that you are already logged in.";
return new JoinResult() { FailMessage = message };
}
*/
}
//if the new chatter could be successfully added, get a callback instance
//create a new message, and broadcast it to all other chatters, and then
//return the list of al chatters such that connected clients may show a
//list of all the chatters
if (userAdded)
{
_Callback = OperationContext.Current.GetCallbackChannel<IChatCallback>();
//add this newly joined chatters ChatEventHandler delegate, to the global
//multicast delegate for invocation
ChatEvent += myEventHandler;
XmlLobbyState lobbyState = new XmlLobbyState();
//carry out a critical section that copy all chatters to a new list
lock (threadSync)
{
//copy chatlog
if (_LobbyChatLog != null)
{
lobbyState.LobbyChat = _LobbyChatLog.Copy();
}
//copy users
if (_Users != null)
{
lobbyState.Users = new List<XmlUser>();
foreach (KeyValuePair<XmlUser, GameEventHandler> lobbyUser in _Users)
lobbyState.Users.Add(lobbyUser.Key.Copy());
}
//copy games
if (_Games != null)
{
lobbyState.Games = CreateGameList();
}
}
/*
//Say to all other players we have a new player joined in the lobby
LobbyJoinedAction lobbyJoined = new LobbyJoinedAction() { NewPlayer = user, Sender = _ServerUser.ID };
BroadcastMessage(lobbyJoined, user);
return new JoinResult() { User = user, LobbyState = lobbyState };
*/
return null;
}
else
{
message.Message = "You are already in the list of logged in players!";
message.Sender = _ServerUser.ID;
return null;
}
}
public virtual void Init(World world, GameEventHandler aiEventHandler)
{
this.world = world;
this.aiEventHandler = aiEventHandler;
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (got < canGet && DateTime.Now > canGetNext &&
direction == GameDirection.Bottom && who == GameElement.MGO)
{
switch (btype)
{
case BoxType.GoodMushroom: getGoodie(BoxType.GoodMushroom); break;
case BoxType.PoisonMushroom: getGoodie(BoxType.PoisonMushroom); break;
case BoxType.LiveMushroom: getGoodie(BoxType.LiveMushroom); break;
case BoxType.FireFlower: getGoodie(BoxType.FireFlower); break;
case BoxType.ModeDependent:
switch(World.MGO.Mode)
{
case MainGameObjectMode.Small:
getGoodie(BoxType.GoodMushroom); break;
case MainGameObjectMode.Normal:
case MainGameObjectMode.NormalFire:
getGoodie(BoxType.FireFlower); break;
}
break;
case BoxType.Star: getGoodie(BoxType.Star); break;
case BoxType.ImmortializeStar: getGoodie(BoxType.ImmortializeStar); break;
}
got++;
canGetNext = DateTime.Now.AddMilliseconds(200);
}
}
public void UnRegister(ObjectShell eventComponent)
{
this.GameEvent -= eventComponent.ReceiveEvent;
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
{
geventhandler(GameEvent.gotImmortialize, new Dictionary<GameEventArg, object>());
World.MovingElements.Remove(this);
}
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
GotMushroom();
}
private void TestQueuing()
{
var newActorEvent = new EventData_New_Actor(1, 1);
// Testing queuing of an event
QueueNewActorHandler = HandleQueueNewActor;
EventManager.Instance.AddListener(EventData_New_Actor.Type, QueueNewActorHandler);
for (var i = 0; i < 5; i++)
{
EventManager.Instance.QueueEvent(newActorEvent);
}
// Simulate multiple calls to the update to test each queue.
Logger.Debug("5 events should fire.");
EventManager.Instance.Update(1000);
Logger.Debug("1 event should fire.");
EventManager.Instance.QueueEvent(newActorEvent);
EventManager.Instance.Update(1000);
Logger.Debug("No events should fire.");
EventManager.Instance.Update(1000);
EventManager.Instance.RemoveListener(EventData_New_Actor.Type, QueueNewActorHandler);
QueueNewActorHandler = null;
}
public override void onOver(GameEventHandler geventhandler, GameElement who, GameDirection direction)
{
base.onOver(geventhandler, who, direction);
if (who == GameElement.MGO)
{
if (base.Name != null && base.Name != "" && World.Script != null)
World.Script.callFunction(base.Name, "finishedLevel", geventhandler);
Dictionary<GameEventArg, object> args = new Dictionary<GameEventArg, object>();
args[GameEventArg.nextLevel] = nextLevel;
args[GameEventArg.nextLevelStartAt] = startAt;
geventhandler(GameEvent.finishedLevel, args);
}
}
private void TestTrigger()
{
var newActorEvent = new EventData_New_Actor(1, 1);
TriggerNewActorHandler = HandleTriggerNewActor;
EventManager.Instance.AddListener(EventData_New_Actor.Type, TriggerNewActorHandler);
Logger.Debug("One event should fire.");
EventManager.Instance.TriggerEvent(newActorEvent);
EventManager.Instance.RemoveListener(EventData_New_Actor.Type, TriggerNewActorHandler);
TriggerNewActorHandler = null;
}
