public void AddActiveEffect(ActiveEffect activeEffect)
{
if (activeEffects.Contains(activeEffect))
{
return;
}
AddBotEffects(activeEffect);
activeEffects.Add(activeEffect);
}
void ActiveEffectDamage(CharacterModel target, ActiveEffect effect)
{
int damage = calculate.DoSkillDamageCalc(turnTaker, target, effect);
bm.WriteLog(turnTaker.name + " attack " + target.name + " for " + damage + " damage.");
target.battleAttribute.ModifyHp(-damage);
if (target.battleAttribute.currHp < 0)
{
target.battleAttribute.currHp = 0;
}
}
public static bool IsBeneficialEffect(this ActiveEffect effect)
{
if (effect.Effect.EffectType != EffectTypes.LightBonusAmount)
{
if (effect.Effect.IsDamagingEffect())
{
return(false);
}
}
return(effect.Effect.Potency >= 0);
}
private IEnumerator Apply(ActiveEffect effect)
{
effect.Effect.Do(player);
while (effect.LeftTime > 0)
{
yield return(new WaitForEndOfFrame());
effect.LeftTime -= Time.deltaTime;
}
effect.Effect.Undo(player);
_activeEffects.Remove(effect.Effect.GetType());
}
public void CheckCover(List <ActiveEffect> coverEffectList)
{
foreach (var memBaseSkill in Skills)//技能造成的特效
{
if (memBaseSkill.SkillConfig.Cover != "")
{
ActiveEffect ef = new ActiveEffect(EffectBook.GetEffect(memBaseSkill.SkillConfig.Cover), self, true);
ef.Repeat = true;
BattleManager.Instance.EffectQueue.Add(ef);
coverEffectList.Add(ef);
}
}
}
private void EffectUpdateFrame()
{
lock (this)
{
if (State == TankState.Idle && ActiveEffect.IsSensorDriven)
{
IdleEffect.Update();
}
else
{
ActiveEffect.Update();
}
}
}
private void EffectUpdate()
{
lock (this)
{
if (ActiveEffect.IsSensorDriven && State == TankState.Idle)
{
IdleEffect.Update();
}
else
{
ActiveEffect.Update();
}
}
}
public void CheckCover()
{
string cover = liveMonster.Avatar.MonsterConfig.Cover;
if (!string.IsNullOrEmpty(cover))
{
ActiveEffect ef = new ActiveEffect(EffectBook.GetEffect(cover), liveMonster, true);
ef.Repeat = true;
BattleManager.Instance.EffectQueue.Add(ef);
coverEffectList.Add(ef);
}
liveMonster.SkillManager.CheckCover(coverEffectList);
}
public void BindView(GameObject view, ActiveEffect effect)
{
var buffImage = view.transform.Find("Image").GetComponent <Image>();
var buffText = view.transform.Find("Text").GetComponent <Text>();
var updateSubscription = Observable.EveryUpdate().Subscribe(x =>
{
var timeLeft = effect.Effect.Duration - effect.ActiveTime;
var timeSpan = TimeSpan.FromMilliseconds(timeLeft);
buffText.text = $"{timeSpan.Minutes:00}:{timeSpan.Seconds:00}";
});
_effectSubscription.Add(effect, updateSubscription);
}
public int DoSkillDamageCalc(CharacterModel user, CharacterModel target, ActiveEffect effect)
{//TODO do a real calculation here
switch (effect.formula)
{
case "PAtk":
return(FormulaPAtk(GetValue(effect.formulaParam), user.battleAttribute.pAtk));
case "MAtk":
return(FormulaMAtk(GetValue(effect.formulaParam), user.battleAttribute.pAtk));
default:
Debug.Log("Formula ID " + effect.formula + " not found.");
return(0);
}
}
public bool ResolveCollision(GameObject go, MovableGameObject mover)
{
var currentEffect = new ActiveEffect
{
Bot = mover,
Effect = Effects.GasCloud
};
if (mover is BotObject bot)
{
if (worldStateService.GetActiveEffectByType(bot.Id, Effects.GasCloud) != default)
{
if (bot.Size < engineConfig.MinimumPlayerSize)
{
worldStateService.RemoveGameObjectById(bot.Id);
}
return(bot.Size >= engineConfig.MinimumPlayerSize);
}
worldStateService.AddActiveEffect(currentEffect);
bot.Size -= engineConfig.GasClouds.AffectPerTick;
if (bot.Size < engineConfig.MinimumPlayerSize)
{
worldStateService.RemoveGameObjectById(bot.Id);
}
return(bot.Size >= engineConfig.MinimumPlayerSize);
}
else
{
var moverStartingSize = mover.Size;
mover.Size -= go.Size;
go.Size -= moverStartingSize;
if (go.Size <= 0)
{
go.Size = 0;
worldStateService.RemoveGameObjectById(go.Id);
}
if (mover.Size <= 0)
{
mover.Size = 0;
worldStateService.RemoveGameObjectById(mover.Id);
}
return(mover.Size > 0);
}
}
private void button1_Click(object sender, EventArgs e)
{
currentItem = new Item();
int id;
if (int.TryParse(itemIDTextBox.Text, out id))
{
currentItem.itemID = id;
currentItem.name = nameBox.Text;
currentItem.description = descriptionTextBox.Text;
HashSet <int> reqs = new HashSet <int>();
List <ActiveEffect> aeList = new List <ActiveEffect>();
List <PassiveEffect> peList = new List <PassiveEffect>();
foreach (int req in requirementsList)
{
reqs.Add(req);
}
currentItem.requirements = reqs;
foreach (String ae in itemActiveList)
{
ActiveEffect temp = new ActiveEffect(ae);
aeList.Add(temp);
}
currentItem.activeEffects = aeList;
foreach (String pe in itemPassiveList)
{
PassiveEffect temp = new PassiveEffect(pe);
peList.Add(temp);
}
currentItem.passiveEffects = peList;
currentItem.iconFileName = iconSelect.SelectedValue.ToString();
String output = currentItem.ParseToString();
if (Item.IsValidItem(output))
{
itemStringTextBox.Text = output;
itemList.Add(currentItem.itemID, currentItem);
}
else
{
MessageBox.Show(this, output);
}
}
}
private void SendAreaEffect(Point pos)
{
//播放特效
RegionTypes rt = BattleTargetManager.GetRegionType(SkillInfo.SkillConfig.Target[2]);
var cardSize = BattleManager.Instance.MemMap.CardSize;
foreach (var memMapPoint in BattleManager.Instance.MemMap.Cells)
{
var pointData = memMapPoint.ToPoint();
if (BattleLocationManager.IsPointInRegionType(rt, pos.X, pos.Y, pointData, SkillInfo.SkillConfig.Range, Self.IsLeft))
{
var effectData = new ActiveEffect(EffectBook.GetEffect(SkillInfo.SkillConfig.EffectArea), pointData + new Size(cardSize / 2, cardSize / 2), false);
BattleManager.Instance.EffectQueue.Add(effectData);
}
}
}
public void AddEffect(IEffect effect)
{
var type = effect.GetType();
if (_activeEffects.ContainsKey(type))
{
//reseting effect duration to max
_activeEffects[type].LeftTime = effect.Duration;
}
else
{
var activeEffect = new ActiveEffect(effect);
_activeEffects.Add(type, activeEffect);
StartCoroutine(activeEffect);
}
}
public bool ResolveCollision(GameObject gameObject, BotObject bot)
{
var currentEffect = new ActiveEffect
{
Bot = bot,
Effect = Effects.AsteroidField
};
/* If the effect is not registered, add it to the list. */
if (worldStateService.GetActiveEffectByType(bot.Id, Effects.AsteroidField) == default)
{
worldStateService.AddActiveEffect(currentEffect);
worldStateService.UpdateBotSpeed(bot);
}
return(true);
}
void ActiveEffectBuff(CharacterModel target, ActiveEffect effect)
{
BattleBuff buff = BuffManager.CreateBuff(effect.formula, effect.formulaParam);
buff.model = target;
buff.log = bm;
for (int i = 0; i < target.battleAttribute.buffs.Count; i++)
{
if (target.battleAttribute.buffs[i].id.Equals(buff.id))
{
target.battleAttribute.buffs.RemoveAt(i);
break;
}
}
target.battleAttribute.buffs.Add(buff);
buff.BuffOnGet();
}
/// <summary>
/// Clears the current effect
/// </summary>
public void ClearEffect()
{
if (ActiveEffect == null)
{
return;
}
lock (ActiveEffect)
{
ActiveEffect.Dispose();
ActiveEffect = null;
_generalSettings.LastEffect = null;
_generalSettings.Save();
}
_logger.Debug("Cleared active effect");
}
public BaseSkillLevel(BaseSkillLevel Clone)
{
ListActivation = new List <BaseSkillActivation>(Clone.ListActivation.Count);
foreach (BaseSkillActivation ActiveActivation in Clone.ListActivation)
{
//Some effect will need to update global parameters so to clones can copy the right values.
foreach (BaseEffect ActiveEffect in ActiveActivation.ListEffect)
{
ActiveEffect.SetupParamsBeforeCopy();
}
}
foreach (BaseSkillActivation ActiveActivation in Clone.ListActivation)
{
ListActivation.Add(new BaseSkillActivation(ActiveActivation));
}
_ActivationsCount = Clone.ActivationsCount;
Price = Clone.Price;
}
internal void OnDeserializedMethod(StreamingContext context)
{
//TODO: v0.5: remove this
if (ScriptEvents == null)
{
ScriptEvents = new Dictionary <LuaEngine.EDungeonMapCallbacks, ScriptEvent>();
}
if (MapEffect == null)
{
MapEffect = new ActiveEffect();
}
if (AllyTeams == null)
{
AllyTeams = new List <Team>();
}
if (Layers == null)
{
Layers = new List <MapLayer>();
}
}
public bool ResolveCollision(GameObject go, MovableGameObject mover)
{
var currentEffect = new ActiveEffect
{
Bot = mover,
Effect = Effects.AsteroidField
};
if (mover is BotObject bot)
{
/* If the effect is not registered, add it to the list. */
if (worldStateService.GetActiveEffectByType(mover.Id, Effects.AsteroidField) == default)
{
worldStateService.AddActiveEffect(currentEffect);
worldStateService.UpdateBotSpeed(mover);
}
}
else
{
var moverStartingSize = mover.Size;
mover.Size -= go.Size;
go.Size -= moverStartingSize;
if (go.Size <= 0)
{
go.Size = 0;
worldStateService.RemoveGameObjectById(go.Id);
}
if (mover.Size <= 0)
{
mover.Size = 0;
worldStateService.RemoveGameObjectById(mover.Id);
}
return(mover.Size > 0);
}
return(true);
}
internal string GenerateMessage(dynamic data)
{
var message = new Data();
switch (ActiveEffect)
{
case Effect.ChromaNone:
message.Effect = ActiveEffect.GetStringValue();
message.Param = null;
break;
case Effect.ChromaStatic:
message.Effect = ActiveEffect.GetStringValue();
message.Param = new { color = ((Color)data).ToBgr() };
break;
case Effect.ChromaCustom2:
case Effect.ChromaCustom:
message.Effect = ActiveEffect.GetStringValue();
var parammatrix = data.ToMatrix();
message.Param = (parammatrix.Length == 1) ? parammatrix[0] : parammatrix;
break;
case Effect.ChromaCustomKey:
message.Effect = ActiveEffect.GetStringValue();
message.Param = new
{
color = data.color.ToMatrix(),
key = data.key.ToMatrix()
};
break;
}
var jsonString = JsonConvert.SerializeObject(message, Formatting.Indented,
new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
return(jsonString);
}
protected List <Targetable> GetTargets(ActiveEffect effect, TargetType targetType)
{
List <Targetable> targets = new List <Targetable>();
if (targetType == TargetType.Self)
{
return(new List <Targetable> {
activeUnit
});
}
if (targetType == TargetType.LinkedTowers)
{
Tower tower = activeUnit as Tower;
if (tower != null)
{
List <Tower> connectedTowers = tower.connectedTowers;
foreach (Tower connectedTower in connectedTowers)
{
targets.Add(connectedTower);
}
}
}
if (targetType == TargetType.SingleEnemy)
{
return(new List <Targetable> {
activeUnit.targetter.GetTarget()
});
}
if (targetType == TargetType.AllTargets)
{
return(activeUnit.targetter.GetAllTargets());
}
if (targetType == TargetType.MultipleTargets)
{
ParameterModiferValue multishotValue = effect.parameterValues[Modifier.MultishotTargets];
return(activeUnit.targetter.GetTargets(Mathf.RoundToInt(multishotValue.value)));
}
return(targets);
}
public void ProcessAction(BotObject bot)
{
/* Bot does not have enough resources to consume for the afterburner. */
if (bot.Size <= engineConfig.Afterburners.SizeConsumptionPerTick ||
bot.Size <= engineConfig.MinimumPlayerSize)
{
return;
}
var currentEffect = new ActiveEffect
{
Bot = bot,
Effect = Effects.Afterburner
};
/* If the effect is not registered, add speed boost and add it to the list. */
if (worldStateService.GetActiveEffectByType(bot.Id, Effects.Afterburner) == default)
{
worldStateService.AddActiveEffect(currentEffect);
worldStateService.UpdateBotSpeed(bot);
}
}
void ActorGetSkillEffect(CharacterModel target, ActiveEffect effect)
{//TODO add another skill effects
switch (effect.type)
{
case EffectType.damage:
ActiveEffectDamage(target, effect);
break;
case EffectType.buff:
ActiveEffectBuff(target, effect);
break;
case EffectType.debuff:
break;
case EffectType.heal:
break;
default:
break;
}
switch (effect.special)
{
case SpecialEffect.none:
break;
case SpecialEffect.lifeleech:
break;
case SpecialEffect.poison:
ActiveEffectBuff(target, SpecialPoison(effect.specialVal));
break;
default:
break;
}
bm.UpdateAllTeam();
}
public override void ActivatePassiveBuffs()
{
foreach (BaseSkillActivation Activation in Skill.ListSkillLevel[0].ListActivation)
{
bool IsPassive = false;
foreach (BaseSkillRequirement ActiveRequirement in Activation.ListRequirement)
{
IsPassive = ActiveRequirement.CanActivatePassive();
}
if (IsPassive)
{
foreach (BaseEffect ActiveEffect in Activation.ListEffect)
{
if (ActiveEffect.EffectTypeName == "Unit Stat Effect")
{
ActiveEffect.ResetState();
ActiveEffect.ExecuteEffect();
}
}
}
}
}
private Dictionary <Modifier, ParameterModiferValue> GetEffectValue(ActiveEffect effect, Targetable target)
{
Dictionary <Modifier, ParameterModiferValue> finalValues = new Dictionary <Modifier, ParameterModiferValue>();
Tower tower = target as Tower;
foreach (KeyValuePair <Modifier, ParameterModiferValue> paramValue in effect.parameterValues)
{
ParameterModiferValue paramMod = paramValue.Value;
float value = effect.parameterValues[paramValue.Key].value;
if (tower)
{
if (effect.rankUpParameterValues.ContainsKey(paramValue.Key))
{
float rank = tower.towerInfo.currentRank;
value += effect.rankUpParameterValues[paramValue.Key].value * rank;
}
}
finalValues.Add(paramValue.Key, new ParameterModiferValue(paramMod.modType, value));
}
return(finalValues);
}
private void createActive_Click(object sender, EventArgs e)
{
int amount;
if (int.TryParse(activeAmount.Text, out amount))
{
String resource = activeResource.SelectedValue.ToString();
String result = String.Format("{0}:{1}:{2}", ActiveEffect.TAG, resource, amount);
if (ActiveEffect.IsValidActiveEffect(result))
{
activeEffectsList.Add(result);
}
}
string toWrite = "ACTIVEEFFECTS";
foreach (String ie in activeEffectsList)
{
toWrite += "^" + ie;
}
WriteFile("activeEffects.txt", toWrite);
}
public static int TicksSoFar(this ActiveEffect activeEffect)
{
return((int)(activeEffect.ActiveTime / activeEffect.Effect.Frequency));
}
private void UpdateEffectIcon(GameObject effectIcon, ActiveEffect ae)
{
UIHelper.UpdateSpriteComponent(effectIcon, "Image", gameDataObject.assetLibrary.getSprite(ae.effectName, ae.effectIndex));
UIHelper.AddClickToGameObject(effectIcon, AddHoverInfoPanel, EventTriggerType.PointerEnter, ae);
UIHelper.AddClickToGameObject(effectIcon, RemoveHoverInfoPanel, EventTriggerType.PointerExit);
}
private void ChangeFillingOutline(ActiveEffect ActiveStatusEffect, float filling)
{
statusEffectObjects[ActiveStatusEffect].GetStatusEffectImage().ChangeFillingOutline(filling);
}
public void SetEffect(EffectPlayType pType, EffectType etype, int value, int turn = 0, Target target = null, int cost = 0, TriggerType trigger = TriggerType.None, GameObject animEffect = null)
{
if (etype == EffectType.AttackPower || etype == EffectType.SkillPower)
{
SetPower(etype, value);
return;
}
CardEffect effect;
switch (pType)
{
case EffectPlayType.triggerEffect:
effect = new TriggerEffect()
{
TriggerType = trigger
};
break;
case EffectPlayType.staticEffect:
effect = new StaticEffect();
break;
case EffectPlayType.playEffect:
effect = new PlayEffect();
break;
case EffectPlayType.activeEffect:
effect = new ActiveEffect(cost);
break;
case EffectPlayType.none:
default:
effect = new CardEffect();
break;
}
//カード効果に応じてアニメーション設定
if (animEffect == null)
{
switch (etype)
{
case EffectType.CostAdd:
case EffectType.UnitCostAdd:
case EffectType.SkillDamageAdd:
case EffectType.AttackAdd:
case EffectType.AttackTime:
animEffect = null;
break;
case EffectType.CardDest:
case EffectType.RandCardDest: break;
case EffectType.CardDraft:
case EffectType.CardDraw:
case EffectType.GetDisZoneCard:
case EffectType.CardUnDraft:
case EffectType.GetDispCard: break;
case EffectType.Counter: break;
case EffectType.Damage:
animEffect = Resources.Load <GameObject>(Constants.CARD_EFFECT_MAGICK_FIRE);
break;
case EffectType.Heal:
animEffect = Resources.Load <GameObject>(Constants.CARD_EFFECT_HEAL);
break;
}
}
effect.effectState.Add(new EffectState(etype, value, turn, target, animEffect));
Effect.Add(effect);
}
