IEnumerator CreateDelayCoroutine(Transform t, DelayCommand dc, float time)
{
Image image = t.GetComponent <Image>();
if (!image)
{
image = t.GetComponentInChildren <Image>();
}
//Store the color of the image
Color color = image.color;
//Store the color's original alpha value
float originalAlpha = color.a;
//Change the alpha to 0
color.a = 0;
image.color = color;
while (image.color.a < 1) //use "< 1" when fading in
{
color.a += Time.deltaTime / time; //fades out over 1 second. change to += to fade in
image.color = color;
yield return(null);
}
//Set the alpha back to it's original value
color.a = originalAlpha;
image.color = color;
dc.CommandExecutionComplete();
}
// delayExecute是命令延时执行的时间,默认为0,只有new出来的命令才能延时执行
// 子线程中发出的命令必须是延时执行的命令!
public void pushDelayCommand(Command cmd, CommandReceiver cmdReceiver, float delayExecute = 0.001f)
{
if (cmd == null || cmdReceiver == null)
{
UnityUtility.logError("cmd or receiver is null!");
return;
}
if (!cmd.isValid())
{
UnityUtility.logError("cmd is invalid! make sure create cmd use CommandSystem.newCmd! pushDelayCommand cmd type : "
+ cmd.GetType().ToString() + "cmd id : " + cmd.mAssignID);
return;
}
if (!cmd.isDelayCommand())
{
UnityUtility.logError("cmd is not a delay command, Command : " + cmd.mAssignID + ", " + cmd.showDebugInfo());
return;
}
if (delayExecute < 0.0f)
{
delayExecute = 0.0f;
}
if (cmd.getShowDebugInfo())
{
UnityUtility.logInfo("CommandSystem : delay cmd : " + cmd.mAssignID + ", " + delayExecute + ", info : " + cmd.showDebugInfo() + ", receiver : " + cmdReceiver.getName(), LOG_LEVEL.LL_NORMAL);
}
DelayCommand delayCommand = new DelayCommand(delayExecute, cmd, cmdReceiver);
mBufferLock.waitForUnlock(LOCK_TYPE.LT_READ);
mCommandBufferInput.Add(delayCommand);
mBufferLock.unlock(LOCK_TYPE.LT_READ);
}
private IEnumerator PromoteMinion(Transform card, CardVisual cv)
{
yield return(new WaitForSeconds(1));
int cost = int.Parse(cv.cost.text);
GameManager.Instance.ActiveHero(true).AdjustMana(cost, false);
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
yield return(new WaitForSeconds(1));
MoveCardCommand mc = new MoveCardCommand(card.gameObject, GameManager.Instance.GetActiveMinionZone(true));
mc.AddToQueue();
cv.AdjustHealth(2, true);
cv.PromotedHealth = cv.CurrentHealth;
if (cv.Md != null)
{
RemoveCardFromHand(cv.Md);
}
else
{
RemoveCardFromHand(cv.Sd);
}
card.Find("CardBack").gameObject.SetActive(false);
}
private IEnumerator PlayResource(Transform card, Card cardData)
{
card.Find("CardBack").gameObject.SetActive(false);
AdjustHeroResources(cardData);
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
yield return(new WaitForSeconds(1));
MoveCardCommand mc = new MoveCardCommand(card.gameObject, GameManager.Instance.GetActiveDiscardPile(true));
mc.AddToQueue();
if (cardData is StarterData)
{
StarterData sd = (StarterData)cardData;
RemoveCardFromHand(sd);
AddCardToDiscardPile(sd);
}
else if (cardData is EssentialsData)
{
EssentialsData ed = (EssentialsData)cardData;
RemoveCardFromHand(ed);
AddCardToDiscardPile(ed);
}
}
// delayExecute是命令延时执行的时间,默认为0,只有new出来的命令才能延时执行
// 子线程中发出的命令必须是延时执行的命令!
public void pushDelayCommand(Command cmd, CommandReceiver cmdReceiver, float delayExecute = 0.001f)
{
if (cmd == null || cmdReceiver == null)
{
UnityUtility.logError("cmd or receiver is null!");
return;
}
if (!cmd.isValid())
{
UnityUtility.logError("cmd is invalid! make sure create cmd use CommandSystem.newCmd!");
return;
}
if (!cmd.isDelayCommand())
{
UnityUtility.logError("cmd is not a delay command, Command : " + cmd.showDebugInfo());
return;
}
if (delayExecute < 0.0f)
{
delayExecute = 0.0f;
}
if (mShowDebugInfo && cmd.getShowDebugInfo())
{
UnityUtility.logInfo("CommandSystem : delay cmd : " + delayExecute + ", info : " + cmd.showDebugInfo() + ", receiver : " + cmdReceiver.getName());
}
DelayCommand delayCommand = new DelayCommand(delayExecute, cmd, cmdReceiver);
// 等待解锁缓冲区并锁定缓冲区
waitAndLockBuffer();
mCommandBufferInput.Add(delayCommand);
// 解锁缓冲区
unlockBuffer();
}
public NormalFixPageWithDynamicTemplate()
{
this.InitializeComponent();
DataContext = this;
AddSwipeTemplate();
Contacts = Contact.GetContacts(140);
EditCommand = new DelayCommand<Contact>(async itemData =>
{
var dlg = new MessageDialog("Edit " + itemData.Name);
dlg.Commands.Add(new UICommand("OK"));
dlg.Commands.Add(new UICommand("Cancel"));
await dlg.ShowAsync();
});
DelCommand = new DelayCommand<Contact>(async itemData =>
{
var dlg = new MessageDialog("Comfire Delete " + itemData.Name + "?");
dlg.Commands.Add(new UICommand("OK", new UICommandInvokedHandler(param =>
{
_contacts.Remove(itemData);
})));
dlg.Commands.Add(new UICommand("Cancel"));
await dlg.ShowAsync();
});
}
/// <summary>
/// Generate a new <see cref="DelayCommand"/>.
/// </summary>
/// <param name="bufferOffset">The target buffer offset.</param>
/// <param name="parameter">The delay parameter.</param>
/// <param name="state">The delay state.</param>
/// <param name="isEnabled">Set to true if the effect should be active.</param>
/// <param name="workBuffer">The work buffer to use for processing.</param>
/// <param name="nodeId">The node id associated to this command.</param>
/// <param name="newEffectChannelMappingSupported">If set to true, the new effect channel mapping for 5.1 is supported.</param>
public void GenerateDelayEffect(uint bufferOffset, DelayParameter parameter, Memory <DelayState> state, bool isEnabled, CpuAddress workBuffer, int nodeId, bool newEffectChannelMappingSupported)
{
if (parameter.IsChannelCountValid())
{
DelayCommand command = new DelayCommand(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, newEffectChannelMappingSupported);
command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
AddCommand(command);
}
}
public IEnumerator InvokeDelay(InvokeEventCommand iec)
{
ConditionListener cl = iec.card.GetComponent <ConditionListener>();
int position = iec.card.transform.GetSiblingIndex();
object[] data = new object[] { position };
if (!StartGameController.Instance.tutorial)
{
if (cl.ConditionEvent == EVENT_TYPE.TAP_MINION)
{
PhotonNetwork.RaiseEvent(TAP_ANIMATION_SYNC_EVENT, data, new RaiseEventOptions {
Receivers = ReceiverGroup.Others
},
SendOptions.SendReliable);
}
else
{
PhotonNetwork.RaiseEvent(ANIMATION_SYNC_EVENT, data, new RaiseEventOptions {
Receivers = ReceiverGroup.Others
},
SendOptions.SendReliable);
}
}
DelayCommand dc = new DelayCommand(iec.card.transform, 2f);
dc.AddToQueue();
GameManager.Instance.effectText.gameObject.SetActive(true);
yield return(new WaitForSeconds(2.5f));
GameManager.Instance.effectText.gameObject.SetActive(false);
iec.method.Invoke(iec.cardType, new object[] { });
CardVisual cv = iec.card.GetComponent <CardVisual>();
if (!StartGameController.Instance.tutorial)
{
if (cl.ConditionEvent == EVENT_TYPE.TAP_MINION && InvokeEventCommand.InvokeEventQueue.Count == 0)
{
cv.AdjustHealth(1, false);
}
}
else
{
if (InvokeEventCommand.InvokeEventQueue.Count == 0)
{
cv.AdjustHealth(1, false);
}
}
}
//This function is called when PostNotification is called on the SACRIFICE_SELECTED event and isPromoting is true
public void PromoteMinionWithPlayback()
{
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
MoveCardCommand mc = new MoveCardCommand(GameManager.Instance.MinionToSacrifice,
GameManager.Instance.GetActiveDiscardPile(true), UIManager.Instance.GetActiveDiscardList(true));
mc.AddToQueue();
//GameManager.Instance.MoveCard(GameManager.Instance.MinionToSacrifice, GameManager.Instance.GetActiveDiscardPile(true), GameManager.Instance.GetActiveDiscardPileList(true), true);
MoveCardFromHand(true);
}
private IEnumerator LevelUp()
{
Transform hero = GameManager.Instance.ActiveHero(true).gameObject.transform;
int cnt = 4;
for (int i = 0; i < cnt; i++)
{
DelayCommand dc = new DelayCommand(hero.Find("ExpBarBorder"), 1f);
dc.AddToQueue();
GameManager.Instance.ActiveHero(true).GainExp(1);
yield return(new WaitForSeconds(1f));
}
UpdateUI();
}
// delayExecute是命令延时执行的时间,默认为0,只有new出来的命令才能延时执行
// 子线程中发出的命令必须是延时执行的命令!
public new void pushDelayCommand(Command cmd, CommandReceiver cmdReceiver, float delayExecute = 0.001f)
{
// 如果命令系统已经销毁了,则不能再发送命令
if (mSystemDestroy)
{
return;
}
if (cmd == null)
{
logError("cmd is null! receiver : " + (cmdReceiver != null ? cmdReceiver.getName() : ""));
return;
}
if (cmdReceiver == null)
{
logError("receiver is null! cmd : " + (cmd != null ? cmd.getType().ToString() : ""));
return;
}
if (!cmd.isValid())
{
logError("cmd is invalid! make sure create cmd use CommandSystem.newCmd! pushDelayCommand cmd type : "
+ cmd.GetType().ToString() + "cmd id : " + cmd.mAssignID);
return;
}
if (!cmd.isDelayCommand())
{
logError("cmd is not a delay command, Command : " + cmd.mAssignID + ", " + cmd.showDebugInfo());
return;
}
if (delayExecute < 0.0f)
{
delayExecute = 0.0f;
}
if (cmd.getShowDebugInfo())
{
logInfo("CommandSystem : delay cmd : " + cmd.mAssignID + ", " + delayExecute + ", info : " + cmd.showDebugInfo() + ", receiver : " + cmdReceiver.getName(), LOG_LEVEL.LL_NORMAL);
}
DelayCommand delayCommand = new DelayCommand(delayExecute, cmd, cmdReceiver);
mBufferLock.waitForUnlock();
mCommandBufferInput.Add(delayCommand);
mBufferLock.unlock();
}
private IEnumerator SendCardToDiscard(Transform card, CardVisual cv)
{
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
yield return(new WaitForSeconds(1f));
MoveCardCommand mc = new MoveCardCommand(card.gameObject, GameManager.Instance.GetActiveDiscardPile(true));
mc.AddToQueue();
if (cv.Md != null)
{
AddCardToDiscardPile(cv.Md);
}
else
{
AddCardToDiscardPile(cv.Sd);
}
}
//This function is called when PostNotification is called on the SACRIFICE_SELECTED event and isPromoting is true
public void PromoteMinionWithPlayback()
{
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
MoveCardCommand mc = new MoveCardCommand(GameManager.Instance.MinionToSacrifice,
GameManager.Instance.GetActiveDiscardPile(true), UIManager.Instance.GetActiveDiscardList(true));
mc.AddToQueue();
//GameManager.Instance.MoveCard(GameManager.Instance.MinionToSacrifice, GameManager.Instance.GetActiveDiscardPile(true), GameManager.Instance.GetActiveDiscardPileList(true), true);
CardVisual cv = GameManager.Instance.MinionToSacrifice.GetComponent <CardVisual>();
MinionDataPhoton mdp;
StarterDataPhoton sdp;
byte[] cardByte;
string type;
if (cv.Md != null)
{
mdp = new MinionDataPhoton(cv.Md);
cardByte = DataHandler.Instance.ObjectToByteArray(mdp);
type = "Minion";
}
else
{
sdp = new StarterDataPhoton(cv.Sd);
cardByte = DataHandler.Instance.ObjectToByteArray(sdp);
type = "Starter";
}
object[] data = new object[] { cardByte, type };
PlayCardPun.Instance.SendData(REMOVE_MINION, data);
MoveCardFromHand(true);
}
private void MoveCardFromHand(bool isMinion)
{
bool promote = false;
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
card = gameObject;
CardVisual cv = card.GetComponent <CardVisual>();
byte[] cardByte;
MinionDataPhoton mdp;
StarterDataPhoton sdp;
EssentialsDataPhoton edp;
string type;
if (isMinion)
{
Card cardData = card.GetComponent <CardVisual>().CardData;
if (UIManager.Instance.GetActiveHandList(true).Contains(cardData))
{
UIManager.Instance.GetActiveHandList(true).Remove(cardData);
}
if (GameManager.Instance.IsPromoting)
{
card = GameManager.Instance.MinionToPromote;
StartOrCancelPromotionEvent(false);
summonPanel.SetActive(false);
cv.AdjustHealth(2, true);
cv.IsPromoted = true;
cv.PromotedHealth = cv.CurrentHealth;
promote = true;
}
MoveCardCommand mc = new MoveCardCommand(card, GameManager.Instance.GetActiveMinionZone(true));
mc.AddToQueue();
//Add Condition Scripts
if (thisCard is MinionData)
{
GameManager.Instance.GetComponent <ConditionAndEffectAssigner>().Md = thisCard as MinionData;
GameManager.Instance.GetComponent <ConditionAndEffectAssigner>().Card = card;
EventManager.Instance.PostNotification(EVENT_TYPE.ASSIGN_CONDITIONS);
}
if (!StartGameController.Instance.tutorial)
{
if (thisCard is MinionData)
{
mdp = new MinionDataPhoton(cv.Md);
cardByte = DataHandler.Instance.ObjectToByteArray(mdp);
type = "Minion";
}
else
{
sdp = new StarterDataPhoton(cv.Sd);
cardByte = DataHandler.Instance.ObjectToByteArray(sdp);
type = "Starter";
}
object[] data = new object[] { cardByte, type };
if (!promote)
{
PlayCardPun.Instance.SendData(PLAY_MINION, data);
}
else
{
PlayCardPun.Instance.SendData(PROMOTE_MINION, data);
}
}
}
else
{
Card cardData = card.GetComponent <CardVisual>().CardData;
if (UIManager.Instance.GetActiveHandList(true).Contains(cardData))
{
UIManager.Instance.GetActiveHandList(true).Remove(cardData);
}
//GameManager.Instance.MoveCard(card, GameManager.Instance.GetActiveDiscardPile(true), GameManager.Instance.GetActiveDiscardPileList(true), true);
int position = 0;
if (thisCard is StarterData)
{
position = gameObject.transform.GetSiblingIndex();
type = "Starter";
}
else
{
position = gameObject.transform.GetSiblingIndex();
type = "Essential";
}
if (!StartGameController.Instance.tutorial)
{
object[] data = new object[] { position, type };
PlayCardPun.Instance.SendData(PLAY_RESOURCE, data);
}
MoveCardCommand mc = new MoveCardCommand(card, GameManager.Instance.GetActiveDiscardPile(true), UIManager.Instance.GetActiveDiscardList(true));
mc.AddToQueue();
}
AdjustHeroResources();
}
protected internal override void VisitDelayCommand(DelayCommand delayCommand)
{
this.WriteIndent();
this.writer.WriteLine("delay {0}", delayCommand.Time);
}
private void MoveCardFromHand(bool isMinion)
{
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), 1f);
dc.AddToQueue();
card = gameObject;
CardVisual cv = card.GetComponent <CardVisual>();
if (isMinion)
{
Card cardData = card.GetComponent <CardVisual>().CardData;
if (UIManager.Instance.GetActiveHandList(true).Contains(cardData))
{
UIManager.Instance.GetActiveHandList(true).Remove(cardData);
}
if (GameManager.Instance.IsPromoting)
{
card = GameManager.Instance.MinionToPromote;
StartOrCancelPromotionEvent(false);
summonPanel.SetActive(false);
cv.AdjustHealth(2, true);
cv.IsPromoted = true;
cv.PromotedHealth = cv.CurrentHealth;
}
MoveCardCommand mc = new MoveCardCommand(card, GameManager.Instance.GetActiveMinionZone(true));
mc.AddToQueue();
//Add Condition Scripts
if (thisCard is MinionData)
{
//GameManager.Instance.GetComponent<ConditionAndEffectAssigner>().Md = thisCard as MinionData;
//GameManager.Instance.GetComponent<ConditionAndEffectAssigner>().Card = card;
//EventManager.Instance.PostNotification(EVENT_TYPE.ASSIGN_CONDITIONS);
gameObject.AddComponent <TutorialConditionListener>();
gameObject.GetComponent <TutorialConditionListener>().ConditionEvent = EVENT_TYPE.TAP_MINION;
if (thisCard.MinionID == 4)
{
gameObject.AddComponent <DrawCardListener>();
}
else if (thisCard.MinionID == 101)
{
gameObject.AddComponent <BuffMinionStarter>();
gameObject.AddComponent <EssentialListener>();
gameObject.GetComponent <EssentialListener>().Type = "Gold";
}
gameObject.GetComponent <TutorialConditionListener>().Card = gameObject;
gameObject.GetComponent <TutorialConditionListener>().Md = thisCard as MinionData;
gameObject.GetComponent <TutorialConditionListener>().enabled = true;
}
cv.particleGlow.gameObject.SetActive(false);
}
else
{
Card cardData = card.GetComponent <CardVisual>().CardData;
if (UIManager.Instance.GetActiveHandList(true).Contains(cardData))
{
UIManager.Instance.GetActiveHandList(true).Remove(cardData);
}
MoveCardCommand mc = new MoveCardCommand(card, GameManager.Instance.GetActiveDiscardPile(true), UIManager.Instance.GetActiveDiscardList(true));
mc.AddToQueue();
//GameManager.Instance.MoveCard(card, GameManager.Instance.GetActiveDiscardPile(true), GameManager.Instance.GetActiveDiscardPileList(true), true);
}
AdjustHeroResources();
//Increase Count in TutorialUI
int count = StartGameController.Instance.TutorialObject.GetComponent <TutorialTextController>().count;
int maxCount = StartGameController.Instance.TutorialObject.GetComponent <TutorialTextController>().maxCount;
if (count < maxCount)
{
StartGameController.Instance.TutorialObject.GetComponent <TutorialTextController>().count++;
}
else
{
StartGameController.Instance.TutorialObject.GetComponent <TutorialTextController>().ShowUI();
}
TutorialPlayCard tpc = gameObject.GetComponent <TutorialPlayCard>();
Destroy(tpc);
}
public override uint Estimate(DelayCommand command)
{
Debug.Assert(_sampleCount == 160 || _sampleCount == 240);
if (_sampleCount == 160)
{
if (command.Enabled)
{
switch (command.Parameter.ChannelCount)
{
case 1:
return(8929);
case 2:
return(25501);
case 4:
return(47760);
case 6:
return(82203);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
else
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)1295.20f);
case 2:
return((uint)1213.60f);
case 4:
return((uint)942.03f);
case 6:
return((uint)1001.6f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
}
if (command.Enabled)
{
switch (command.Parameter.ChannelCount)
{
case 1:
return(11941);
case 2:
return(37197);
case 4:
return(69750);
case 6:
return(12004);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
else
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)997.67f);
case 2:
return((uint)977.63f);
case 4:
return((uint)792.31f);
case 6:
return((uint)875.43f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
}
private void DelayOnHero(string type, float time)
{
Hero heroObject = GameManager.Instance.ActiveHero(true);
Transform hero = GameManager.Instance.ActiveHero(true).gameObject.transform;
if (type.Equals("Hero"))
{
DelayCommand dc = new DelayCommand(heroObject.HeroImage.transform, time);
dc.AddToQueue();
}
else if (type.Equals("ResourcesAndLevel"))
{
Transform topObject = hero.Find("TopUiElements");
DelayCommand dc = new DelayCommand(topObject.Find("HeroDamage"), time);
dc.AddToQueue();
dc = new DelayCommand(hero.Find("HealthBarBorder"), time);
dc.AddToQueue();
dc = new DelayCommand(hero.Find("ManaBarBorder"), time);
dc.AddToQueue();
dc = new DelayCommand(hero.Find("Level"), time);
dc.AddToQueue();
}
else if (type.Equals("Damage"))
{
Transform topObject = hero.Find("TopUiElements");
DelayCommand dc = new DelayCommand(topObject.Find("HeroDamage"), time);
dc.AddToQueue();
}
else if (type.Equals("Gold"))
{
Transform topObject = hero.Find("TopUiElements");
DelayCommand dc = new DelayCommand(topObject.Find("GoldOwned"), time);
dc.AddToQueue();
}
else if (type.Equals("Shop"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.shopButton.transform, time);
dc.AddToQueue();
}
else if (type.Equals("Opponent"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.ActiveHero(false).HeroImage.transform, time);
dc.AddToQueue();
}
else if (type.Equals("Hand"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.GetActiveHand(true), time);
dc.AddToQueue();
}
else if (type.Equals("Mana"))
{
DelayCommand dc = new DelayCommand(hero.Find("ManaBarBorder"), time);
dc.AddToQueue();
}
else if (type.Equals("Exp"))
{
DelayCommand dc = new DelayCommand(hero.Find("ExpBarBorder"), time);
dc.AddToQueue();
}
else if (type.Equals("ChangeButton"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.changeButton.transform, time);
dc.AddToQueue();
}
else if (type.Equals("Attack"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.ActiveHero(true).AttackButton, time);
dc.AddToQueue();
}
else if (type.Equals("Submit"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.ActiveHero(true).SubmitButton, time);
dc.AddToQueue();
}
else if (type.Equals("Cancel"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.ActiveHero(true).CancelButton, time);
dc.AddToQueue();
}
else if (type.Equals("EndTurn"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.endButton.transform, time);
dc.AddToQueue();
}
else if (type.Equals("SkillEffect"))
{
DelayCommand dc = new DelayCommand(GameManager.Instance.skillTree.GetComponent <SkillTreeController>().buffIcon.transform, time);
dc.AddToQueue();
}
StartCoroutine(ButtonDelay(2f));
}
public uint Estimate(DelayCommand command)
{
return((uint)(_sampleCount * command.Parameter.ChannelCount * 202.5f));
}
private async Task ExecuteCommandAsync(DelayCommand command) => await Task.Delay(command.DelayTime);
public uint Estimate(DelayCommand command)
{
Debug.Assert(_sampleCount == 160 || _sampleCount == 240);
if (_sampleCount == 160)
{
if (command.Enabled)
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)41636.0f);
case 2:
return((uint)97861.0f);
case 4:
return((uint)192520.0f);
case 6:
return((uint)301760.0f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
else
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)578.53f);
case 2:
return((uint)663.06f);
case 4:
return((uint)703.98f);
case 6:
return((uint)760.03f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
}
if (command.Enabled)
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)8770.3f);
case 2:
return((uint)25741.0f);
case 4:
return((uint)47551.0f);
case 6:
return((uint)81629.0f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
else
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)521.28f);
case 2:
return((uint)585.4f);
case 4:
return((uint)629.88f);
case 6:
return((uint)713.57f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
}
private void OnEvent(EventData photonData)
{
byte eventCode = photonData.Code;
if (eventCode == TAP_ANIMATION_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int index = (int)data[0];
Transform card = GameManager.Instance.GetActiveMinionZone(true).GetChild(index);
CardVisual cv = card.GetComponent <CardVisual>();
cv.IsTapped = true;
cv.ChangeTappedAppearance();
DelayCommand dc = new DelayCommand(card, 2f);
dc.AddToQueue();
StartCoroutine(ShowEffectAnimation());
cv.AdjustHealth(1, false);
}
else if (eventCode == ANIMATION_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int index = (int)data[0];
Transform card = GameManager.Instance.GetActiveMinionZone(true).GetChild(index);
DelayCommand dc = new DelayCommand(card, 2f);
dc.AddToQueue();
StartCoroutine(ShowEffectAnimation());
}
else if (eventCode == PEEK_SHOP_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
string cardClass = (string)data[0];
int[] cards = (int[])data[1];
List <MinionData> cardList = new List <MinionData>();
foreach (int id in cards)
{
MinionData minion = Resources.Load("Minions/" + id) as MinionData;
cardList.Add(minion);
}
UIManager.Instance.MoveTopCardsToBottom(cardClass, cardList);
}
else if (eventCode == ADJUST_HEALTH_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int position = (int)data[0];
int healthAmount = (int)data[1];
bool increaseOrDecrease = (bool)data[2];
bool activeOrInactive = (bool)data[3];
Transform card = GameManager.Instance.GetActiveMinionZone(activeOrInactive).GetChild(position);
CardVisual cv = card.GetComponent <CardVisual>();
cv.AdjustHealth(healthAmount, increaseOrDecrease);
}
else if (eventCode == ADJUST_DAMAGE_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int position = (int)data[0];
int damageAmount = (int)data[1];
bool increaseOrDecrease = (bool)data[2];
Transform card = GameManager.Instance.GetActiveMinionZone(true).GetChild(position);
CardVisual cv = card.GetComponent <CardVisual>();
cv.AdjustDamage(damageAmount, increaseOrDecrease);
}
else if (eventCode == ADJUST_GOLD_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int amount = (int)data[0];
GameManager.Instance.ActiveHero(true).AdjustGold(2, true);
}
else if (eventCode == ADJUST_EXP_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int amount = (int)data[0];
GameManager.Instance.ActiveHero(true).EnemyGainExp(2);
}
else if (eventCode == ADJUST_HERO_HEALTH_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int amount = (int)data[0];
GameManager.Instance.ActiveHero(false).AdjustHealth(amount, false);
}
else if (eventCode == DRAW_DISCARD_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int position = (int)data[0];
Transform card = GameManager.Instance.GetActiveHand(true).GetChild(position);
GameManager.Instance.DiscardCard(card.gameObject);
}
else if (eventCode == ACTIVATE_SILENCE_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int position = (int)data[0];
Transform card = GameManager.Instance.GetActiveMinionZone(false).GetChild(position);
CardVisual cv = card.GetComponent <CardVisual>();
cv.ActivateSilence(true);
}
else if (eventCode == ADJUST_DISCARD_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
bool increase = (bool)data[0];
GameManager.Instance.ActiveHero(false).AdjustEnemyDiscard(increase);
}
else if (eventCode == ANIMATION_MESSAGE_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
string message = (string)data[0];
StartCoroutine(ShowEffectAnimation(message));
}
else if (eventCode == COMBAT_EFFECT_SYNC_EVENT)
{
object[] data = (object[])photonData.CustomData;
int position = (int)data[0];
bool enableOrDisable = (bool)data[1];
string to = (string)data[2];
Transform card;
if (to.Equals("Hand"))
{
card = GameManager.Instance.GetActiveHand(true).GetChild(position);
}
else
{
card = GameManager.Instance.GetActiveMinionZone(true).GetChild(position);
}
CardVisual cv = card.GetComponent <CardVisual>();
cv.IsCombatEffectActivated = enableOrDisable;
cv.CombatEffectActivated(enableOrDisable);
}
}
public uint Estimate(DelayCommand command)
{
Debug.Assert(_sampleCount == 160 || _sampleCount == 240);
if (_sampleCount == 160)
{
if (command.Enabled)
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)8929.04f);
case 2:
return((uint)25500.75f);
case 4:
return((uint)47759.62f);
case 6:
return((uint)82203.07f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
else
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)1295.20f);
case 2:
return((uint)1213.60f);
case 4:
return((uint)942.03f);
case 6:
return((uint)1001.55f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
}
if (command.Enabled)
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)11941.05f);
case 2:
return((uint)37197.37f);
case 4:
return((uint)69749.84f);
case 6:
return((uint)120042.40f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
else
{
switch (command.Parameter.ChannelCount)
{
case 1:
return((uint)997.67f);
case 2:
return((uint)977.63f);
case 4:
return((uint)792.30f);
case 6:
return((uint)875.43f);
default:
throw new NotImplementedException($"{command.Parameter.ChannelCount}");
}
}
}
public void CreateDelay(Transform t, DelayCommand dc, float time)
{
StartCoroutine(CreateDelayCoroutine(t, dc, time));
}
