public AllNoneGuy(string name, string job, int maxHealth, ETargetType targetType) : base(name, job, maxHealth, targetType)
{
for (int x = 0; x < 6; x++)
{
Abilities[x] = new Regular(new Bare());
}
}
public STarget(ETargetType type, Objects.InteractableObject interactable
, EnemyController enemy)
{
this.type = type;
interactableTarget = interactable;
enemyTarget = enemy;
}
public TargetItem(ETargetType type, string name, string ipAddress, int port)
{
Type = type;
Name = name;
IpAddress = ipAddress;
Port = port;
}
public override void OnEnter()
{
catcher.SetActive(true);
List <EntityPanel> panels = new List <EntityPanel>();
panels.AddRange(MenuManager.Instance.PartyPanel);
panels.AddRange(MenuManager.Instance.EnemyPanel);
ETargetType abiltiesTargetType = CombatManager.Instance.Attacker.UpSide.Ability.TargetType;
foreach (var panel in panels)
{
if (panel.model.TargetType == abiltiesTargetType && !panel.model.IsDead)
{
panel.button.onClick.RemoveAllListeners();
var panel1 = panel;
panel.button.onClick.AddListener(() => MenuManager.Instance.MakeSelection(panel1.model));
// If model is not a target type of ally, disable them
// If they are, change the onClick of the panel to link to the CombatManager and set the model as the defender
}
else
{
panel.GetComponent <Image>().color = new Color(.2f, .2f, .2f);
panel.button.interactable = false;
}
}
}
public TargetStatistic(TargetStatistic oldTargetStatistic)
{
Id = oldTargetStatistic.Id;
InitialTimeInFov = oldTargetStatistic.InitialTimeInFov;
InitialTimeTargetInFocus = oldTargetStatistic.InitialTimeTargetInFocus;
EndTimeOfTargetInFocus = oldTargetStatistic.EndTimeOfTargetInFocus;
TypeOfTarget = oldTargetStatistic.TypeOfTarget;
}
public override void OnEditorUI()
{
base.OnEditorUI();
targetType = (ETargetType)EditorGUILayout.EnumPopup("目标类型", targetType);
targetState = (ETargetState)EditorGUILayout.EnumPopup("目标状态", targetState);
targetDistance = EditorGUILayout.FloatField("目标距离", targetDistance, GUILayout.ExpandWidth(false));
}
public override void OnEditorUI()
{
base.OnEditorUI();
targetType = (ETargetType)EditorGUILayout.EnumPopup("目标类型", targetType);
targetState = (ETargetState)EditorGUILayout.EnumPopup("目标状态", targetState);
targetDistance = EditorGUILayout.FloatField("目标距离", targetDistance, GUILayout.ExpandWidth(false));
}
protected BAbility(string name, string description, int power, float baseModifier, float critModifier, ETargetType targetType)
{
Name = name;
Description = description;
Power = power;
CritModifier = critModifier;
BaseModifier = baseModifier;
TargetType = targetType;
}
public GoblinSorcerer(string name, string job, int maxHealth, ETargetType targetType) : base(name, job, maxHealth, targetType)
{
Abilities[0] = new Vulnerable(new Bare("Head", "Your bare head"));
Abilities[1] = new Regular(new IceBeam());
Abilities[2] = new Regular(new LightningBolt());
Abilities[3] = new Evade(new Spring(), 0.25f);
Abilities[4] = new Vulnerable(new Bare("Chest", "Your bare chest"));
Abilities[5] = new Vulnerable(new Bare("Back", "Your bare back"));
}
public Warrior(string name, int maxHealth, ETargetType targetType)
: base(name, "Warrior", maxHealth, targetType)
{
Abilities[0] = new Regular(new Headbutt());
Abilities[1] = new Armored(new Shieldslam(), 3);
Abilities[2] = new Regular(new Slash());
Abilities[3] = new Regular(new Kick());
Abilities[4] = new Regular(new Tackle());
Abilities[5] = new Vulnerable(new Bare("Back", "Your bare back"));
}
public BDice(string name, string job, int maxHealth, ETargetType targetType)
{
Name = name;
Job = job;
MaxHealth = maxHealth;
TargetType = targetType;
Abilities = new BSide[6];
CurrentHealth = maxHealth;
IsDead = false;
}
public Cleric(string name, int maxHealth, ETargetType targetType)
: base(name, "Cleric", maxHealth, targetType)
{
Abilities[0] = new Regular(new Prayer());
Abilities[1] = new Armored(new Shieldslam(), 3);
Abilities[2] = new Regular(new Heal());
Abilities[3] = new Evade(new Dodge(), 0.25f);
Abilities[4] = new Armored(new Bare("Chest", "Bare Chest"), 3);
Abilities[5] = new Vulnerable(new Bare("Back", "Your bare back"));
}
public Sorcerer(string name, int maxHealth, ETargetType targetType)
: base(name, "Sorcerer", maxHealth, targetType)
{
Abilities[0] = new Regular(new DragonsBreath());
Abilities[1] = new Regular(new IceBeam());
Abilities[2] = new Regular(new LightningBolt());
Abilities[3] = new Evade(new Spring(), 0.25f);
Abilities[4] = new Vulnerable(new Bare("Chest", "Your bare chest"));
Abilities[5] = new Vulnerable(new Bare("Back", "Your bare back"));
}
public AbstractCard(int id, int number, ECardColorTypes color, String name,
int type, ETargetType targetType, bool needRange)
{
// super();
this.id = id;
this.number = number;
this.color = color;
this.name = name;
this.type = type;
this.targetType = targetType;
this.needRange = needRange;
}
public MonsterAbilityStaticData()
{
m_nameKey = String.Empty;
m_icon = String.Empty;
m_values1 = new Single[0];
m_values2 = new Single[0];
m_values3 = new Single[0];
m_isPercentValue = false;
m_Gfx = String.Empty;
m_Animation = ",";
m_ActiveAbility = false;
m_TargetType = ETargetType.NONE;
}
void OnClick()
{
if (type == ETargetType.NONE)
{
type = ETargetType.CHOOSSED;
PlayManager.Instance.resetBuilding();
//// reset range tower
PlayManager.Instance.resetRangeTower();
PlayManager.Instance.selectedTowerBuild.SetActive(false);
PlayManager.Instance.objectBuild.Target = rootTower;
PlayManager.Instance.resetUpgrade();
PlayManager.Instance.chooseTarget.transform.parent = transform;
PlayManager.Instance.chooseTarget.transform.localScale = Vector3.one;
PlayManager.Instance.chooseTarget.transform.localPosition = new Vector3(3.5f, -30, 0);
PlayManager.Instance.chooseTarget.transform.GetChild(0).renderer.material.renderQueue = transform.GetChild(0).renderer.material.renderQueue - 1;
PlayManager.Instance.chooseTarget.SetActive(true);
if (SceneState.Instance.State == ESceneState.ADVENTURE)
{
if (PlayTouchManager.Instance.skillTarget != null)
{
if (PlayTouchManager.Instance.skillTarget != this.gameObject)
{
PlayDragonInfoSkillController temp = PlayTouchManager.Instance.skillTarget.GetComponent <PlayDragonInfoSkillController>();
temp.selected.GetComponent <TweenScale>().PlayReverse();
temp.selected.GetComponent <TweenAlpha>().PlayReverse();
temp.typeSprite.GetComponent <TweenPosition>().PlayReverse();
temp.typeSprite.GetComponent <TweenAlpha>().PlayReverse();
temp.isTap = false;
PlayTouchManager.Instance.skillTarget = null;
PlayTouchManager.Instance.setCurrentOffenseType(ESkillOffense.AOE);
}
}
}
// set tutorial cho lan dau tien
if (PlayerInfo.Instance.tutorialInfo.tutorial_build == 0 && WaveController.Instance.currentMap == 1 &&
SceneState.Instance.State == ESceneState.ADVENTURE)
{
PlayerInfo.Instance.tutorialInfo.tutorial_build = 1;
PlayerInfo.Instance.tutorialInfo.Save();
PlayManager.Instance.tutorial.SetActive(true);
UIButtonTutorialPlay.Instance.StartTutorialBuildTower();
}
}
}
void OnClick()
{
if (type == ETargetType.NONE)
{
type = ETargetType.CHOOSSED;
PlayManager.Instance.resetBuilding();
//// reset range tower
PlayManager.Instance.resetRangeTower();
PlayManager.Instance.selectedTowerBuild.SetActive(false);
PlayManager.Instance.objectBuild.Target = rootTower;
PlayManager.Instance.resetUpgrade();
PlayManager.Instance.chooseTarget.transform.parent = transform;
PlayManager.Instance.chooseTarget.transform.localScale = Vector3.one;
PlayManager.Instance.chooseTarget.transform.localPosition = new Vector3(3.5f, -30, 0);
PlayManager.Instance.chooseTarget.transform.GetChild(0).renderer.material.renderQueue = transform.GetChild(0).renderer.material.renderQueue - 1;
PlayManager.Instance.chooseTarget.SetActive(true);
if (SceneState.Instance.State == ESceneState.ADVENTURE)
{
if (PlayTouchManager.Instance.skillTarget != null)
{
if (PlayTouchManager.Instance.skillTarget != this.gameObject)
{
PlayDragonInfoSkillController temp = PlayTouchManager.Instance.skillTarget.GetComponent<PlayDragonInfoSkillController>();
temp.selected.GetComponent<TweenScale>().PlayReverse();
temp.selected.GetComponent<TweenAlpha>().PlayReverse();
temp.typeSprite.GetComponent<TweenPosition>().PlayReverse();
temp.typeSprite.GetComponent<TweenAlpha>().PlayReverse();
temp.isTap = false;
PlayTouchManager.Instance.skillTarget = null;
PlayTouchManager.Instance.setCurrentOffenseType(ESkillOffense.AOE);
}
}
}
// set tutorial cho lan dau tien
if (PlayerInfo.Instance.tutorialInfo.tutorial_build == 0 && WaveController.Instance.currentMap == 1
&& SceneState.Instance.State == ESceneState.ADVENTURE)
{
PlayerInfo.Instance.tutorialInfo.tutorial_build = 1;
PlayerInfo.Instance.tutorialInfo.Save();
PlayManager.Instance.tutorial.SetActive(true);
UIButtonTutorialPlay.Instance.StartTutorialBuildTower();
}
}
}
private void OnFXQueueFinish(Object p_sender, EventArgs p_args)
{
if (MyController != null)
{
((Character)p_sender).FightHandler.FlushDelayedActionLog();
}
DelayedEventManager.InvokeEvent(EDelayType.ON_FX_HIT, EEventType.CHARACTER_CAST_SPELL, p_sender, p_args);
ETargetType targetType = ((SpellEventArgs)p_args).Spell.TargetType;
if ((targetType & ETargetType.PARTY) == ETargetType.PARTY)
{
DelayedEventManager.InvokeEvent(EDelayType.ON_FX_FINISH, EEventType.CHARACTER_CAST_SPELL, p_sender, p_args);
}
}
public static List <Vessel> GetTargets(this Vessel vessel, ETargetType targetTypes, bool considerAircrafts)
{
bool findSurf = (targetTypes & ETargetType.SURF) > 0;
bool findSub = (targetTypes & ETargetType.SUB) > 0;
bool findAir = (targetTypes & ETargetType.AIR) > 0;
List <Vessel> result = new List <Vessel>();
if (findSurf || findSub)
{
foreach (Vessel v in BattleManager.instance.sides[1 - vessel.side])
{
if (v.isAlive == false)
{
continue;
}
if (v.vesselType == EVesselType.SS && findSub)
{
if (vessel.CheckWeapon(v, considerAircrafts) == true)
{
result.Add(v);
}
}
else if (v.vesselType != EVesselType.SS && findSurf)
{
if (vessel.CheckWeapon(v, considerAircrafts) == true)
{
result.Add(v);
}
}
}
}
if (findAir && BattleManager.instance.sidesAC.Count > (1 - vessel.side))
{
foreach (Aircraft a in BattleManager.instance.sidesAC[1 - vessel.side])
{
if (a.isAlive == false)
{
continue;
}
if (vessel.CheckWeapon(a, considerAircrafts) == true)
{
result.Add(a);
}
}
}
return(result);
}
public static AIUnit FindTarget(AIUnit srcUnit, ETargetType targetType)
{
if (targetType == ETargetType.MainPlayer)
{
return(AIMgr.instance.GetMainPlayer() as AIUnit);
}
else if (targetType == ETargetType.Enemy)
{
return(AIMgr.instance.FindFirstEnemy(srcUnit));
}
else
{
Debug.LogError("未实现的查找类型" + targetType);
return(null);
}
}
public void initWeapon(TowerListRow aRow) {
this.damage = aRow._BulletDamage;
this.splashDamage = aRow._BulletSplash;
this.splashRange = aRow._BulletSplashRange;
this.damageInfantryMultiplier = aRow._BulletInfantryModifier;
this.damageMechanicMultiplier = aRow._BulletArmorModifier;
this.slowTime = aRow._BulletSlowTime;
this.slowPercent = aRow._BulletSlowPercent;
switch(aRow._SlowTarget) {
default:this.slowType = ETargetType.None;break;
case("Infantry"):this.slowType = ETargetType.Infantry;break;
case("Mechanical"):this.slowType = ETargetType.Mechanical;break;
case("FlyingMechanical"):this.slowType = ETargetType.FlyingMechanical;break;
case("AnyMechanical"):this.slowType = ETargetType.AnyMechanical;break;
}
}
public virtual Boolean CastSpell(MonsterSpell p_spell)
{
ETargetType targetType = p_spell.TargetType;
if (targetType != ETargetType.SINGLE_MONSTER)
{
if (targetType != ETargetType.SINGLE_PARTY_MEMBER)
{
if (targetType != ETargetType.ALL_MONSTERS_ON_TARGET_SLOT)
{
if (targetType != ETargetType.PARTY)
{
return(false);
}
if (LegacyLogic.Instance.MapLoader.Grid.LineOfSight(m_owner.Position, LegacyLogic.Instance.WorldManager.Party.Position, Position.Distance(m_owner.Position, LegacyLogic.Instance.WorldManager.Party.Position) <= m_owner.StaticData.SpellRanges))
{
m_owner.SpellHandler.LastCastedSpell = p_spell;
return(true);
}
return(false);
}
}
else
{
if (LegacyLogic.Instance.MapLoader.Grid.LineOfSight(m_owner.Position, LegacyLogic.Instance.WorldManager.Party.Position, Position.Distance(m_owner.Position, LegacyLogic.Instance.WorldManager.Party.Position) <= m_owner.StaticData.SpellRanges))
{
m_owner.SpellHandler.LastCastedSpell = p_spell;
return(true);
}
return(false);
}
}
GridSlot slot = LegacyLogic.Instance.MapLoader.Grid.GetSlot(m_owner.Position);
if (slot.Entities.Count > 0)
{
m_owner.SpellHandler.LastCastedSpell = p_spell;
return(true);
}
return(false);
}
private Boolean CastSpellErebos(MonsterSpell p_spell)
{
m_owner.m_stateMachine.ChangeState(Monster.EState.MOVING);
ETargetType targetType = p_spell.TargetType;
if (targetType != ETargetType.SINGLE_MONSTER)
{
if (targetType != ETargetType.SINGLE_PARTY_MEMBER)
{
if (targetType != ETargetType.ALL_MONSTERS_ON_TARGET_SLOT)
{
if (targetType != ETargetType.PARTY)
{
return(false);
}
if (LegacyLogic.Instance.MapLoader.Grid.LineOfSight(m_owner.Position, LegacyLogic.Instance.WorldManager.Party.Position, true))
{
return(true);
}
return(false);
}
}
else
{
if (LegacyLogic.Instance.MapLoader.Grid.LineOfSight(m_owner.Position, LegacyLogic.Instance.WorldManager.Party.Position, true))
{
return(true);
}
return(false);
}
}
GridSlot slot = LegacyLogic.Instance.MapLoader.Grid.GetSlot(m_owner.Position);
if (slot.Entities.Count > 0)
{
return(true);
}
return(false);
}
protected static string GetOutputFile(string sourceFile, string outDir, ETargetType type, bool createDir)
{
FileInfo inFile = new FileInfo(sourceFile);
if (!inFile.Exists)
{
throw new FileNotFoundException("Input Excel file not found.", sourceFile);
}
if (createDir)
{
if (!FileUtils.CheckDirectory(outDir))
{
throw new DirectoryNotFoundException(String.Format("Output directory not found/be created. [path={0}]", outDir));
}
}
string fname = Path.GetFileNameWithoutExtension(inFile.FullName);
string outpath = String.Format("{0}/{1}.{2}", outDir, fname, type.ToString());
LogUtils.Debug(String.Format("Generating {1} output. [path={0}]", outpath, type.ToString()));
return(outpath);
}
public Slash(string name, string description, int power, float baseModifier, float critModifier, ETargetType targetType) : base(name, description, power, baseModifier, critModifier, targetType)
{
}
protected void GetAttackTargets(List <Object> targets)
{
Int32 range = Brain.Data.Range;
Grid grid = LegacyLogic.Instance.MapLoader.Grid;
Position position = Controller.Position;
EDirection direction = Controller.Direction;
ETargetType targetType = Brain.Data.TargetType;
if ((targetType & ETargetType.PARTY) == ETargetType.PARTY && LegacyLogic.Instance.WorldManager.Party.Position == position)
{
targets.AddRange(LegacyLogic.Instance.WorldManager.Party.Members);
}
if ((targetType & ETargetType.SINGLE_MONSTER) == ETargetType.SINGLE_MONSTER)
{
Monster randomMonsterInDirection = grid.GetRandomMonsterInDirection(position, direction, range);
if (randomMonsterInDirection != null && randomMonsterInDirection.CurrentHealth > 0)
{
targets.Add(randomMonsterInDirection);
}
}
if ((targetType & ETargetType.ALL_MONSTERS_ON_TARGET_SLOT) == ETargetType.ALL_MONSTERS_ON_TARGET_SLOT)
{
Int32 count = targets.Count;
grid.GetMonstersOnFirstSlot(position, direction, 0, targets);
for (Int32 i = targets.Count - 1; i >= count; i--)
{
if (!((Monster)targets[i]).IsAttackable || ((Monster)targets[i]).CurrentHealth <= 0)
{
targets.RemoveAt(i);
}
}
}
if ((targetType & ETargetType.ALL_MONSTERS_IN_LINE_OF_SIGHT) == ETargetType.ALL_MONSTERS_IN_LINE_OF_SIGHT)
{
Int32 count2 = targets.Count;
grid.GetMonstersInDirection(position, direction, range, targets);
for (Int32 j = targets.Count - 1; j >= count2; j--)
{
if (!((Monster)targets[j]).IsAttackable || ((Monster)targets[j]).CurrentHealth <= 0)
{
targets.RemoveAt(j);
}
}
}
if ((targetType & ETargetType.ALL_ADJACENT_MONSTERS) == ETargetType.ALL_ADJACENT_MONSTERS)
{
Int32 count3 = targets.Count;
grid.GetMonstersInDirection(position, EDirection.NORTH, 1, targets);
grid.GetMonstersInDirection(position, EDirection.EAST, 1, targets);
grid.GetMonstersInDirection(position, EDirection.SOUTH, 1, targets);
grid.GetMonstersInDirection(position, EDirection.WEST, 1, targets);
for (Int32 k = targets.Count - 1; k >= count3; k--)
{
if (!((Monster)targets[k]).IsAttackable || ((Monster)targets[k]).CurrentHealth <= 0)
{
targets.RemoveAt(k);
}
}
}
if ((targetType & ETargetType.ALL_MONSTERS) == ETargetType.ALL_MONSTERS)
{
foreach (Monster monster in LegacyLogic.Instance.WorldManager.GetObjectsByTypeIterator <Monster>())
{
if (monster.IsAggro && monster.IsAttackable && monster.CurrentHealth > 0)
{
targets.Add(monster);
}
}
}
if (targets.Count > 1)
{
HashSet <Object> collection = new HashSet <Object>(targets);
targets.Clear();
targets.AddRange(collection);
}
}
protected void DefendThis(Actor target)
{
DefendTarget = Target.FromActor(target);
TargetType = ETargetType.Actor;
}
protected void DefendThis(int2 target)
{
DefendTarget = Target.FromPos(target);
TargetType = ETargetType.Location;
}
private void WaitForIdle()
{
// could be an attack or move order ... => 'disable' the stance for now (invalidate the target)
DefendTarget = Target.None;
TargetType = ETargetType.None;
WaitingForIdle = true;
}
public void hitUnit(float aDamage,float aDamageInfantryMultiplier,float aDamageMachineMultiplier,float aSlowPercent,int aSlowTime,ETargetType aSlowTarget) {
if(this.health>0f) {
if(this.unitType==ETargetType.Infantry) {
aDamage = aDamage*aDamageInfantryMultiplier;
}
if(this.unitType==ETargetType.Mechanical||this.unitType==ETargetType.FlyingMechanical) {
aDamage = aDamage*aDamageMachineMultiplier;
}
this.health -= aDamage;
if(energyBar==null&&!GameManager.REF.demo) {
GameObject eb = this.gameObject;
eb = healthBarPool.FastInstantiate(GameObject.Find ("Canvas").transform);
energyBar = eb.GetComponent<EnergyBar>();
// energyBar.transform.SetParent(canvas.transform);
EnergyBarFollowObject guiBar = energyBar.GetComponent<EnergyBarFollowObject>();
if(this.gameObject.transform.FindChild("BarPoint")==null) {
Debug.Log (this.name+" has no BarPoint");
} else
guiBar.followObject = this.gameObject.transform.FindChild("BarPoint").gameObject;
energyBar.SetValueMax(Convert.ToInt32(health+aDamage));
}
if(energyBar!=null)
this.energyBar.SetValueCurrent((int) this.health);
}
if(this.health>=0f) {
// If we still have health, do we want to slow this unit?
if(aSlowTime>0) {
Debug.Log(unitType+" - "+aSlowTarget);
ETargetType thisT = (this.unitType&aSlowTarget);
Debug.Log (thisT);
if(thisT==this.unitType) {
slowTimeRemaining += aSlowTime;
this.unitSpeed = this.originalSpeed * aSlowPercent;
updateSpeeds();
}
}
}
}
public void initTower(TowerListRow aTower) {
shotSpeed = aTower._ShotSpeed;
this.shotsPerRound = aTower._ShotsPerRound;
this.burstAmount = aTower._BurstAmount;
this.burstResetTime = aTower._BurstResetTime;
this.cycleTime = aTower._CycleTime;
this.maxRange = aTower._MaxRange;
this.reloadTime = aTower._ReloadTime;
this.slowPercent = aTower._BulletSlowPercent;
this.slowTime = aTower._BulletSlowTime;
switch(aTower._SlowTarget) {
default:this.slowType = ETargetType.None;break;
case("Infantry"):this.slowType = ETargetType.Infantry;break;
case("Mechanical"):this.slowType = ETargetType.Mechanical;break;
case("FlyingMechanical"):this.slowType = ETargetType.FlyingMechanical;break;
case("AnyMechanical"):this.slowType = ETargetType.AnyMechanical;break;
}
}
// --------------------------------------------------------------------------------------------
public static float GetDamage(ETargetType targetType, EDamageType damageType)
{
return(_instance._targetToDamageToType[(int)targetType][(int)damageType]);
}
public void reset()
{
type = ETargetType.NONE;
}
public void MonsterCastSpell(ETarget target, TestSpell spell)
{
m_LastSpellIsMonster = false;
m_LastSpell = spell;
m_TargetOrWizard = target;
FXDescription fxdescription = Helper.ResourcesLoad <FXDescription>(spell.EffectPath, false);
if (fxdescription == null)
{
Debug.LogError("FXDescription not found! at " + spell.EffectPath, this);
return;
}
if (target == ETarget.Party)
{
target = (ETarget)UnityEngine.Random.Range(1, 4);
}
GameObject gameObject;
switch (target)
{
case ETarget.Member1:
gameObject = m_Member1;
break;
case ETarget.Member2:
gameObject = m_Member2;
break;
case ETarget.Member3:
gameObject = m_Member3;
break;
case ETarget.Member4:
gameObject = m_Member4;
break;
default:
return;
}
Vector3 forward = m_ActiveMonster.transform.forward;
Vector3 p_slotLeft = -m_ActiveMonster.transform.right;
m_ActiveMonsterAnimationHandler.AttackMagic(spell.AnimationNum);
AnimatorEventHandler component = m_ActiveMonsterAnimationHandler.GetComponent <AnimatorEventHandler>();
GameObject activeMonster = m_ActiveMonster;
ETargetType targetType = spell.TargetType;
FXArgs p_args;
if ((targetType & ETargetType.MULTY) == ETargetType.MULTY)
{
p_args = new FXArgs(activeMonster, m_PartySlot, activeMonster, m_PartySlot, activeMonster.transform.position, forward, p_slotLeft, m_PartySlot.transform.position, new List <GameObject>
{
m_Member1,
m_Member2,
m_Member3,
m_Member4
});
}
else if ((targetType & ETargetType.SINGLE) == ETargetType.SINGLE)
{
p_args = new FXArgs(activeMonster, gameObject, activeMonster, gameObject, activeMonster.transform.position, forward, p_slotLeft, m_PartySlot.transform.position, new List <GameObject>
{
gameObject
});
}
else if ((targetType & ETargetType.ADJACENT) == ETargetType.ADJACENT)
{
p_args = new FXArgs(activeMonster, activeMonster, activeMonster, activeMonster, activeMonster.transform.position, forward, p_slotLeft, m_PartySlot.transform.position, new List <GameObject>
{
gameObject
});
}
else
{
p_args = new FXArgs(activeMonster, activeMonster, activeMonster, activeMonster, activeMonster.transform.position, forward, p_slotLeft, m_PartySlot.transform.position, new List <GameObject>
{
gameObject
});
}
fxdescription = Helper.Instantiate <FXDescription>(fxdescription);
fxdescription.Configurate(component, p_args);
}
public void PartyCastSpell(ETarget wizard, TestSpell spell)
{
m_LastSpellIsMonster = false;
m_LastSpell = spell;
m_TargetOrWizard = wizard;
if (!String.IsNullOrEmpty(spell.EffectPath))
{
FXQueue fxqueue = Helper.ResourcesLoad <FXQueue>(spell.EffectPath, false);
if (fxqueue != null && m_ActiveMonster != null)
{
if (wizard == ETarget.Party)
{
wizard = (ETarget)UnityEngine.Random.Range(1, 4);
}
GameObject gameObject;
switch (wizard)
{
case ETarget.Member1:
gameObject = m_Member1;
break;
case ETarget.Member2:
gameObject = m_Member2;
break;
case ETarget.Member3:
gameObject = m_Member3;
break;
case ETarget.Member4:
gameObject = m_Member4;
break;
default:
return;
}
Vector3 forward = m_Party.transform.forward;
Vector3 p_slotLeft = -m_Party.transform.right;
ETargetType targetType = spell.TargetType;
FXArgs args;
if ((targetType & ETargetType.PARTY) == ETargetType.PARTY)
{
args = new FXArgs(m_PartySlot, m_PartySlot, m_PartySlot, m_PartySlot, m_PartySlot.transform.position, forward, p_slotLeft, m_PartySlot.transform.position, new List <GameObject>
{
m_PartySlot
});
}
else if ((targetType & ETargetType.LINE_OF_SIGHT) == ETargetType.LINE_OF_SIGHT)
{
args = new FXArgs(m_PartySlot, m_MonsterSlot, m_PartySlot, m_MonsterSlot, m_PartySlot.transform.position, forward, p_slotLeft, m_MonsterSlot.transform.position, new List <GameObject>
{
m_ActiveMonster
});
}
else if ((targetType & ETargetType.MULTY) == ETargetType.MULTY)
{
args = new FXArgs(gameObject, m_MonsterSlot, gameObject, m_MonsterSlot, m_PartySlot.transform.position, forward, p_slotLeft, m_MonsterSlot.transform.position, new List <GameObject>
{
m_ActiveMonster
});
}
else if ((targetType & ETargetType.SINGLE) == ETargetType.SINGLE)
{
FXTags component = m_ActiveMonster.GetComponent <FXTags>();
GameObject p_endPoint = m_ActiveMonster;
if (component != null)
{
p_endPoint = component.FindOne("HitSpot");
}
else
{
Debug.LogError("FXTags not found!!\nTarget=" + m_ActiveMonster, m_ActiveMonster);
}
args = new FXArgs(gameObject, m_MonsterSlot, gameObject, p_endPoint, m_PartySlot.transform.position, forward, p_slotLeft, m_MonsterSlot.transform.position, new List <GameObject>
{
m_ActiveMonster
});
}
else if ((targetType & ETargetType.ADJACENT) == ETargetType.ADJACENT)
{
args = new FXArgs(gameObject, m_PartySlot, gameObject, m_PartySlot, m_PartySlot.transform.position, forward, p_slotLeft, m_MonsterSlot.transform.position, new List <GameObject>
{
m_ActiveMonster
});
}
else
{
Debug.LogError("error !! spellType: " + targetType);
args = new FXArgs(gameObject, m_ActiveMonster, gameObject, m_ActiveMonster, m_PartySlot.transform.position, forward, p_slotLeft, m_MonsterSlot.transform.position, new List <GameObject>
{
m_ActiveMonster
});
}
FXQueue fxqueue2 = Helper.Instantiate <FXQueue>(fxqueue);
fxqueue2.Finished += delegate(Object sender, EventArgs e)
{
m_ActiveMonsterAnimationHandler.Hit();
};
fxqueue2.Execute(args);
}
else
{
Debug.LogError("SpellEffect not found! " + spell.EffectPath);
}
}
PartyCastBuff(spell);
MonsterCastBuff(spell);
}
public override string Convert(string sourceFile, string ourDir, bool createDir = true, ETargetType targetFormat = ETargetType.PDF)
{
throw new NotImplementedException();
}
public void initWeapon(TowerListRow aData) {
if(shot==null) {
ParticleCollision pc = this.GetComponentInChildren<ParticleCollision>();
shot = pc.GetComponent<ParticleSystem>();
}
ParticleCollision p = shot.GetComponent<ParticleCollision>();
p.damageToInflict = aData._BulletDamage;
p.infantryDamageMultiplier = aData._BulletInfantryModifier;
p.tankInfantryMultiplier = aData._BulletArmorModifier;
switch(aData._SlowTarget) {
default:this.slowType = ETargetType.None;break;
case("Infantry"):this.slowType = ETargetType.Infantry;break;
case("Mechanical"):this.slowType = ETargetType.Mechanical;break;
case("FlyingMechanical"):this.slowType = ETargetType.FlyingMechanical;break;
case("AnyMechanical"):this.slowType = ETargetType.AnyMechanical;break;
}
p.slowPercent = aData._BulletSlowPercent;
p.slowTime = aData._BulletSlowTime;
p.slowType = this.slowType;
}
void AddTarget(ETargetType type, string name, string ipAddress, int port)
{
AddTarget(new TargetItem(type, name, ipAddress, port));
}
protected BaDamaging(string name, string description, int power, float baseModifier, float critModifier, ETargetType targetType) : base(name, description, power, baseModifier, critModifier, targetType)
{
}
public virtual Dictionary <string, string> Convert(List <string> sourceFiles, string ourDir, bool createDir = true, ETargetType targetFormat = ETargetType.PDF)
{
Dictionary <string, string> docSet = new Dictionary <string, string>();
foreach (string sourceFile in sourceFiles)
{
string output = Convert(sourceFile, ourDir, createDir, targetFormat);
if (!string.IsNullOrEmpty(output))
{
docSet.Add(sourceFile, output);
}
}
return(docSet);
}
