public static void PlaceInRoom(Room room, Vector3 position)
{
GameManager gameManager = GameManager.Instance();
if (gameManager.FundingAmount >= 400)
{
gameManager.FundingAmount -= 400;
}
else
{
return;
}
GameObject listeningDevice = Resources.Load <GameObject>("ListeningDevice");
Vector3 placementPosition = new Vector3(position.x, position.y - 0.83f, position.z);
listeningDevice = UnityEngine.Object.Instantiate(listeningDevice, placementPosition, Quaternion.identity);
listeningDevice.GetComponent <ListeningDevice>().CurrentRoom = room;
gameManager.ListeningDevList.Add(listeningDevice);
ListeningDevicePlacedPacket eventPacket = new ListeningDevicePlacedPacket
{
Device = listeningDevice,
PlacedRoom = room
};
EventMessenger.Instance().FireEvent(Event.LISTENING_DEVICE_PLACED, eventPacket);
}
private IEnumerator _TriggerEffect()
{
Running = true;
var vignetteSettings = profile.vignette.settings;
var dofSettings = profile.depthOfField.settings;
var switched = false;
profile.depthOfField.enabled = true;
for (float t = 0; t < 1.0f; t += Time.unscaledDeltaTime)
{
vignetteSettings.intensity = vignetteIntensityCurve.Evaluate(t);
vignetteSettings.smoothness = vignetteSmoothnessCurve.Evaluate(t);
dofSettings.aperture = dofCurve.Evaluate(t);
profile.vignette.settings = vignetteSettings;
profile.depthOfField.settings = dofSettings;
Time.timeScale = timeScaleCurve.Evaluate(t);
if (t > switchPoint && !switched)
{
EventMessenger.TriggerEvent(Events.WORLD_SWITCH_POINT);
switched = true;
}
yield return(null);
}
if (!switched)
{
EventMessenger.TriggerEvent(Events.WORLD_SWITCH_POINT);
}
Time.timeScale = 1.0f;
ResetProfile();
Running = false;
}
private void Start()
{
EventMessenger.Subscribe(GameEvent.ConnetorSwitchToOn, this, OnConnetorSwitchToOn);
_UIRoot = GameObject.Find("UI Root");
if (_UIRoot == null)
{
Debug.LogError("UI Root not found");
}
if (_needRoomContentGeneration)
{
RoomContentGenerator.Generate();
EventMessenger.SendMessage(GameEvent.CompleteContentGeneration, this);
}
if (_needShapesGeneration)
{
ShapesGenerator.Generate();
EventMessenger.SendMessage(GameEvent.CompleteNodesGeneration, this);
}
Invoke("StartGameProcess", 0.3f);
//StartGameProcess();
}
void AttackCompleted()
{
IsAttackInProgress = false;
CurrentFightSettings.isPlayerTurn = !CurrentFightSettings.isPlayerTurn;
IsPlayerTurn = CurrentFightSettings.isPlayerTurn;
// Save Game State
if (m_AlivePlayerHeroCount == 0)
{
EventMessenger.NotifyEvent(FightEvents.ALL_ALLY_DEAD);
}
else if (m_AliveEnemyHeroCount == 0)
{
EventMessenger.NotifyEvent(FightEvents.ALL_ENEMY_DEAD);
}
CurrentFightSettings.selectedAllyHeroIndex = -1;
CurrentFightSettings.selectedEnemyIndex = -1;
EventMessenger.NotifyEvent(SaveEvents.SAVE_GAME_STATE);
if (m_AliveEnemyHeroCount != 0 &&
m_AlivePlayerHeroCount != 0)
{
UpdateTurnText();
}
if (!IsPlayerTurn)
{
EnemyPlay();
}
}
public void SubscribeToEvents()
{
EventMessenger.Instance().SubscribeToEvent(this, EventSystem.Event.LISTENING_DEVICE_PLACED);
EventMessenger.Instance().SubscribeToEvent(this, EventSystem.Event.LISTENING_DEVICE_DESTROYED);
EventMessenger.Instance().SubscribeToEvent(this, EventSystem.Event.LISTENING_DEVICE_CYCLED);
EventMessenger.Instance().SubscribeToEvent(this, EventSystem.Event.LISTENING_DESK_OFF);
}
public async Task DispatchAsync(ICommand <TEntity> command)
{
// Retreive events
IEnumerable <IEvent> events = await EventStore.GetEventsAsync(command.Id);
// Apply events to hydrate the aggregate
Aggregate.ApplyEvents(events);
// Handle the command
events = Aggregate.HandleCommand(command);
if (events.Nada())
{
return;
}
// Persist the events if there were no failed.
if (!events.Any(e => e.GetType() == typeof(Failed)))
{
var persisted = await EventStore.PersistEventsAsync(events);
if (!persisted)
{
events = new IEvent[] { new Failed("Failed to persist events.") };
}
}
else
{
events = events.Where(e => e.GetType() == typeof(Failed));
}
// Forward resulting events
await EventMessenger.SendAsync(events);
}
private void OnStartDragEvent_Response(EventMessenger obj)
{
if (obj != this)
{
TriggerRespondFlag = false;
}
}
void LoadMenu()
{
SetupUIForMenu();
EventMessenger.NotifyEvent <int, int>(LoadingEvents.LOADING_PROGRESS, 1, 1);
EventMessenger.NotifyEvent(LoadingEvents.LOADING_FINISHED);
}
void DamageDoneOnHero(BattleHero hero, int damage)
{
AttackEffect attackEffect = m_AttackEffecPool.GetItem();
attackEffect.transform.position = hero.transform.position;
attackEffect.RegulateSize(hero.GetComponent <RectTransform>());
attackEffect.gameObject.SetActive(true);
StringBuilder builder = new StringBuilder(AttributeChange.HEALTH_DECREASE_TEXT);
builder.Replace("{DECREASE}", damage.ToString());
AttributeChange attributeChange = AttribueChangeEffectPool.GetItem();
attributeChange.PrepareForActivation(hero.transform, false, builder.ToString());
attributeChange.gameObject.SetActive(true);
if (!hero.IsEnemy)
{
CurrentFightSettings.selectedAllyHeroIndex = FindHeroIndex(m_PlayerHeroes, hero);
}
EventMessenger.NotifyEvent(SaveEvents.SAVE_GAME_STATE);
bool isDead = hero.TakeDamage(damage);
}
// Ready the game state for battle scene
IEnumerator ConfigureBattle()
{
int currentStep = 0;
int stepCount = 3;
EventMessenger.NotifyEvent(LoadingEvents.LOADING_STARTED);
CreateEnemyHeroes();
yield return(null);
EventMessenger.NotifyEvent <int, int>(LoadingEvents.LOADING_PROGRESS, currentStep++, stepCount);
fightSettings.UpdateSettings(true, true, false, m_SelectedHeroes.ToArray(), m_EnemyHeroes.ToArray());
EventMessenger.NotifyEvent(SaveEvents.SAVE_GAME_STATE);
yield return(null);
EventMessenger.NotifyEvent <int, int>(LoadingEvents.LOADING_PROGRESS, currentStep++, stepCount);
m_BattleScene.PrepareBattleScene(fightSettings);
yield return(null);
EventMessenger.NotifyEvent <int, int>(LoadingEvents.LOADING_PROGRESS, currentStep++, stepCount);
EventMessenger.NotifyEvent(LoadingEvents.LOADING_FINISHED);
}
static void ApplyBrush(ref TileDrawingOpData opDat, Vector3 pos)
{
var e = Event.current;
// todo: Fix Later
//if (opDat.IsVariationOnly)
//{
// pos -= Vector3.one * 0.5f;
// opDat.StartPos -= Vector3.one * 0.5f;
//}
//TODO ROOM: Fix this
//Undo.RecordObject(_Room, "Paint");
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (e.button == 0)
{
ApplyBrush(ref opDat, pos, true);
}
else if (e.button == 1)
{
ApplyBrush(ref opDat, pos, false);
}
//TODO ROOM: FIX!!
//MeshOperationData.Room = _RoomOpDat;
//GenerateMesh(MeshOperationData);
if (opDat.FireEvent)
{
EventMessenger.TriggerEvent(new TilesDrawn());
}
opDat.StartPos = null;
}
private void OnDestroy()
{
EventMessenger.RemoveListener <HeroData>(SelectionEvents.HERO_FRAME_SELECTED, OnMenuHeroSelected);
EventMessenger.RemoveListener <HeroData>(SelectionEvents.HERO_FRAME_DESELECTED, OnMenuHeroDeselected);
EventMessenger.RemoveListener(SceneEvents.BATTLE_START_SIGNAL, OnBattleStart);
EventMessenger.RemoveListener(SceneEvents.REWARDING_COMPLETE, LoadMenu);
}
private void OnClick()
{
if (MainSceneManager.CurrentGameMode == MainSceneManager.GameMode.Normal)
{
EventMessenger.SendMessage(GameEvent.InvokeAdjuster, this);
MainSceneManager.CurrentGameMode = MainSceneManager.GameMode.InvokeAdjuster;
}
}
public UpdateEliteAPI(
LibraryUpdater updater,
IDialogCoordinator dialogCoordinator,
EventMessenger events) : base(events)
{
_updater = updater;
_dialogCoordinator = dialogCoordinator;
}
private void OnDestroy()
{
EventMessenger.RemoveListener <HeroData>(SelectionEvents.HERO_FRAME_SELECTED, PlaySelectionSound);
EventMessenger.RemoveListener <HeroData>(SelectionEvents.HERO_FRAME_DESELECTED, PlaySelectionSound);
EventMessenger.RemoveListener <BattleHero, int>(FightEvents.DAMAGE_DONE, PlayAttackSound);
EventMessenger.RemoveListener(SceneEvents.BATTLE_START_SIGNAL, PlayButtonSound);
}
protected void OnTriggerEnter(Collider col)
{
EventMessenger <Player, Collider> .TriggerEvent(GameEvents.PLAYER_TAKE_DAMAGE, this, col);
EventMessenger <Collector, Collider> .TriggerEvent(GameEvents.COLLECT_CRISTAL, collector, col);
EventMessenger <Collector, Collider> .TriggerEvent(GameEvents.WARP_CRISTAL, collector, col);
}
public AutoAttachCharacter(
SelectCharacter characterSelecter,
SelectProcessViewModel processSelecter,
IDialogCoordinator dialogCoordinator,
EventMessenger events) : base(events)
{
_characterSelecter = characterSelecter;
_processSelecter = processSelecter;
}
void IPointerUpHandler.OnPointerUp(PointerEventData eventData)
{
if (m_Hero == null)
{
return;
}
EventMessenger.NotifyEvent <Action>(SelectionEvents.HERO_FRAME_CLICKED_UP, MakeSelection);
}
private void UpdateCristalCount()
{
stats.cristals--;
EventMessenger.TriggerEvent(GameEvents.UPDATE_HUD);
if (stats.cristals == 0)
{
EventMessenger.TriggerEvent(GameEvents.VICTORY);
}
}
private void Awake()
{
m_BattleScene = FindObjectOfType <BattleScene>();
fightSettings = new FightSettings();
EventMessenger.AddListener <HeroData>(SelectionEvents.HERO_FRAME_SELECTED, OnMenuHeroSelected);
EventMessenger.AddListener <HeroData>(SelectionEvents.HERO_FRAME_DESELECTED, OnMenuHeroDeselected);
EventMessenger.AddListener(SceneEvents.BATTLE_START_SIGNAL, OnBattleStart);
EventMessenger.AddListener(SceneEvents.REWARDING_COMPLETE, LoadMenu);
}
void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
{
if (m_Hero == null)
{
return;
}
EventMessenger.NotifyEvent <HeroBase>(SelectionEvents.HERO_FRAME_CLICKED_DOWN, this);
}
public void Pick(Transform cristalTransform)
{
cristals.Add(cristalTransform);
cristalTransform.SetParent(playerBody);
cristalTransform.position = new Vector3(playerBody.position.x,
playerBody.position.y + cristals.Count - (cristals.Count - 0.8f) * 0.6f, playerBody.position.z);
cristalTransform.GetComponent <Cristal>().Collect();
EventMessenger <int> .TriggerEvent(GameEvents.CHANGE_SPEED, cristals.Count);
}
private void Start()
{
_uiItem = this.GetSafeComponent <UIRect>();
_uiItem.enabled = false;
EventMessenger.Subscribe(GameEvent.OnTutorialCompleteShowText, this, () => Invoke("ShowSprite", _clickInterval));
EventMessenger.Subscribe(GameEvent.OnTutorial_ClickByTarget, this, () => Invoke("MoveToButtonStart", 0f));
Invoke("SetStartPos", 2f);
}
protected void Start()
{
status = GameStatus.INITIALIZE;
hud.StartListeners();
EventMessenger.StartListener(GameEvents.START_GAME, StartGame);
EventMessenger.StartListener(GameEvents.DEFEATE, Defeat);
EventMessenger.StartListener(GameEvents.VICTORY, Victory);
EventMessenger.StartListener(GameEvents.UPDATE_CRISTAL_COUNT, UpdateCristalCount);
status = GameStatus.READY;
}
private void OnDestroy()
{
EventMessenger.RemoveListener(FightEvents.ATTACK_SIGNAL_GIVEN, AttackSignalGiven);
EventMessenger.RemoveListener(FightEvents.ATTACK_COMPLETED, AttackCompleted);
EventMessenger.RemoveListener <BattleHero, int>(FightEvents.DAMAGE_DONE, DamageDoneOnHero);
EventMessenger.RemoveListener <BattleHero>(FightEvents.HERO_DIED, OnHeroDied);
EventMessenger.RemoveListener(FightEvents.ALL_ALLY_DEAD, OnDefeat);
EventMessenger.RemoveListener(FightEvents.ALL_ENEMY_DEAD, OnVictory);
EventMessenger.RemoveListener(SaveEvents.LOADING_SAVE_COMPLETED, LoadBattleSceneSettings);
}
private void Awake()
{
m_AudioSource = GetComponent <AudioSource>();
EventMessenger.AddListener <HeroData>(SelectionEvents.HERO_FRAME_SELECTED, PlaySelectionSound);
EventMessenger.AddListener <HeroData>(SelectionEvents.HERO_FRAME_DESELECTED, PlaySelectionSound);
EventMessenger.AddListener <BattleHero, int>(FightEvents.DAMAGE_DONE, PlayAttackSound);
EventMessenger.AddListener(SceneEvents.BATTLE_START_SIGNAL, PlayButtonSound);
}
private void Awake()
{
if (!Instance)
{
Instance = this;
}
else
{
Destroy(gameObject);
}
}
private void BrocastData()
{
Debug.Log("Brocast Event!");
string title = "MyEventMessage";
string data = "That's a new event be brocast!";
int size = 1024;
MyEventMessage msg = new MyEventMessage(EventMessage.ID.MyEventID, title, data, size);
EventMessenger.Broadcast(msg);
}
public void SubscribeToEvents()
{
if (JobType == JobType.GENERAL)
{
EventMessenger.Instance().SubscribeToEvent(this, Event.PLACE_LISTENING_DEVICE);
}
else
{
EventMessenger.Instance().SubscribeToEvent(this, Event.LEFT_MOUSE_CLICK);
}
}
public MainPageViewModel()
{
HasFiles = true;
AddDocumentCommand = new DelegateCommand(NavigateAddDocument);
AddImageCommand = new DelegateCommand(NavigateAddImage);
DeleteFileCommand = new DelegateCommand <StorageDocumentContainer>(DeleteFile);
FetchFilesCommand = new DelegateCommand(FetchStorageFiles);
Files = new ObservableCollection <StorageDocumentContainer>();
_modelUpdateToken = EventMessenger.GetEvent <ModelUpdatedMessageEvent <StorageDocument> >().Subscribe(OnModelUpdated);
FetchStorageFiles();
}
