public void OnEvent(Event evt)
        {
            switch (evt.Type)
            {
            case CreateEntityEvent.CREATE_ENTITY:
            {
                CreateEntityEvent createEvent = (CreateEntityEvent)evt;
                addEntity(createEvent.EntityType, createEvent.Attributes);
                break;
            }

            case NewEntityEvent.NEW_ENTITY:
            {
                NewEntityEvent newEvent = (NewEntityEvent)evt;
                Entity         entity   = Entities[newEvent.EntityID];
                if (entity.Type == "player_death")
                {
                    DestroyEntityEvent destroyEvent = DestroyEntityEvent.Destroy(entity.ID);
                    EventManager.Queue(destroyEvent);
                }
                break;
            }

            case DestroyEntityEvent.DESTROY_ENTITY:
            {
                DestroyEntityEvent destroyEvent = (DestroyEntityEvent)evt;
                removeEntity(destroyEvent.EntityID);
                break;
            }
            }
        }
        public override bool SnapshotEquals(NewEntityEvent other)
        {
            var cast = other as NewSkillEntityEvent;

            if (cast == null)
            {
                return(false);
            }
            return(SnapshotEquals(cast));
        }
        public void OnEvent(Event evt)
        {
            switch (evt.Type)
            {
            case AudioEvent.PLAY_SOUND: {
                AudioEvent audioEvent = (AudioEvent)evt;
                audioPlayer.PlayEvent(audioEvent.ToString(), audioEvent.Volume);
                break;
            }

            case AudioEvent.STOP_SOUND:
            {
                AudioEvent audioEvent = (AudioEvent)evt;
                audioPlayer.StopEvent(audioEvent.ToString());
                break;
            }

            case AudioEvent.PAUSE_SOUND:
            {
                AudioEvent audioEvent = (AudioEvent)evt;
                audioPlayer.PauseEvent(audioEvent.ToString());
                break;
            }

            case NewEntityEvent.NEW_ENTITY: {
                NewEntityEvent newEntityEvent = (NewEntityEvent)evt;
                Entity         entity         = Game.World.Entities[newEntityEvent.EntityID];
                if (entity.Type == "player")
                {
                    OnAttach(entity);

                    int lifes = playerEntity[HealthBehavior.Key_Lifes];
                    hud.Reset(lifes);
                }
                break;
            }

            case DestroyEntityEvent.DESTROY_ENTITY: {
                DestroyEntityEvent destroyEntityEvent = (DestroyEntityEvent)evt;
                Entity             entity             = Game.World.Entities[destroyEntityEvent.EntityID];
                if (entity.Type == "player")
                {
                    OnDetach();
                }
                break;
            }

            case GameStateChangedEvent.GAME_STATE_CHANGED: {
                GameStateChangedEvent stateChangedEvent = (GameStateChangedEvent)evt;
                onGameStateChanged(stateChangedEvent.NewState);
                break;
            }
            }
        }
        private void addNewEntities()
        {
            foreach (Entity entity in entityAddQueue)
            {
                Entities.Add(entity.ID, entity);

                NewEntityEvent newEntityEvent = NewEntityEvent.Announce(entity.ID);
                EventManager.Queue(newEntityEvent);

                System.Console.WriteLine("[" + this.GetType().Name + "] Added entity " + entity);
            }

            entityAddQueue.Clear();
        }
        public void OnEvent(Event evt)
        {
            switch (evt.Type)
            {
            case NewEntityEvent.NEW_ENTITY: {
                NewEntityEvent newEntityEvent = (NewEntityEvent)evt;
                Entity         entity         = Game.World.Entities[newEntityEvent.EntityID];
                OnAttach(entity);
                break;
            }

            case DestroyEntityEvent.DESTROY_ENTITY: {
                DestroyEntityEvent destroyEntityEvent = (DestroyEntityEvent)evt;
                Entity             entity             = Game.World.Entities[destroyEntityEvent.EntityID];
                OnDetach(entity);
                break;
            }
            }
        }
Example #6
0
        public override void OnEvent(Event evt)
        {
            AudioEvent audioEvent = null;
            AudioInfo  sounds     = entity[Key_SoundEffects];

            if (sounds == null)
            {
                throw new Exception(String.Format("No sound effects defined for Entity '{0}'", entity.ToString()));
            }

            AudioInfo.Sound sound = sounds.GetSoundForEvent(evt.Type);
            if (sound == null)
            {
                return;
            }

            switch (evt.Type)
            {
            case NewEntityEvent.NEW_ENTITY:
                NewEntityEvent newEntityEvent = (NewEntityEvent)evt;
                if (entity.ID != newEntityEvent.EntityID)
                {
                    return;
                }
                break;

            case DestroyEntityEvent.DESTROY_ENTITY:
                DestroyEntityEvent destroyEntityEvent = (DestroyEntityEvent)evt;
                if (entity.ID != destroyEntityEvent.EntityID || destroyEntityEvent.IsCausedByCleanup)
                {
                    return;
                }
                break;
            }

            audioEvent = AudioEvent.PlaySound(entity.ID, sound.EventName, sound.Project);

            if (audioEvent != null)
            {
                audioQueue.Add(audioEvent);
            }
        }
Example #7
0
 public override void Add(TEntity entity)
 {
     base.Add(entity);
     NewEntityEvent?.Invoke(entity);
 }