public void Clear()
{
LastUpdated = DateTime.MinValue;
LastSlowUpdate = DateTime.MinValue;
LastVerySlowUpdate = DateTime.MinValue;
IsIncapacitated = false;
IsRooted = false;
IsInTown = false;
CurrentHealthPct = 0;
PrimaryResource = 0;
PrimaryResourcePct = 0;
SecondaryResource = 0;
SecondaryResourcePct = 0;
Position = Vector3.Zero;
MyDynamicID = -1;
Level = -1;
ActorClass = ActorClass.Invalid;
BattleTag = String.Empty;
SceneId = -1;
LevelAreaId = -1;
Scene = new SceneInfo()
{
SceneId = -1,
LastUpdate = DateTime.UtcNow
};
Summons = new SummonInfo();
}
private void OnTriggerEnter(Collider collision)
{
if (collision.gameObject.GetComponent <EnemyInformation>())
{
EnemyInformation enemy = collision.gameObject.GetComponent <EnemyInformation>();
enemy.PlayerHealth -= damage;
//Call PopupDamage Function.
//Debug.Log("Hit Enemy");
//text = GameObject.FindGameObjectWithTag("UiManager").GetComponent<FloatingText>();
//text.DamageText(gameObject.transform.position, damage, collision.gameObject);
GameObject temp = Instantiate(Resources.Load <GameObject>("FloatingText/TextPrefab"));
temp.GetComponent <TextMesh>().text = damage.ToString();
temp.transform.position = new Vector3(collision.transform.position.x, GameObject.FindGameObjectWithTag("Player").transform.position.y + 3.0f, collision.transform.position.z);
Destroy(temp, 0.6f);
Destroy(this.gameObject);
}
else if (collision.gameObject.tag == "Player")
{
Debug.Log(this.gameObject);
GameInformation.PlayerHealth -= damage;
Destroy(this.gameObject);
}
else if (collision.gameObject.tag == "Summon")
{
SummonInfo summon = collision.GetComponent <SummonsAi>().summon;
summon.SummonHealth -= damage;
Debug.Log(summon.SummonHealth);
Destroy(this.gameObject);
}
//Destroy(this.gameObject);
}
public string attackProjector = "RangedAttackProjector"; // going to be more then one projector later for certian abilites
// No heal projector in this one
public HealingAttackTurret()
{
info = new SummonInfo();
SummonAbilites abilites = new SummonAbilites(info);
info.HealingCalc(healingDone);
//Debug.Log(info.HealAmount);
}
void CalculateSummonStats(SummonInfo info)
{
info.SummonHealth = GameInformation.PlayerHealth / 2.5f;
info.SummonEnergy = GameInformation.PlayerEnergy;
info.CritChance = GameInformation.CritChance + 0.05f;
info.SummonShield = 0;
info.CritDamage = GameInformation.CritDamage;
}
private void OnTriggerEnter(Collider collision)
{
// <- gotta check for max hp
if (collision.gameObject.GetComponent <EnemyInformation>() && user.GetComponent <EnemyInformation>())
{
EnemyInformation enemy = collision.gameObject.GetComponent <EnemyInformation>();
if (enemy.PlayerHealth + heal > enemy.PlayerMaxHealth)
{
enemy.PlayerHealth = enemy.PlayerMaxHealth;
}
else
{
enemy.PlayerHealth += heal;
}
text = GameObject.FindGameObjectWithTag("UiManager").GetComponent <FloatingText>();
text.DamageText(gameObject.transform.position, heal, collision.gameObject, Color.green);
Destroy(this.gameObject);
}
else if (collision.gameObject.tag == "Player")
{
Debug.Log(this.gameObject);
if (GameInformation.PlayerHealth + heal > GameInformation.PlayerMaxHp)
{
GameInformation.PlayerHealth = GameInformation.PlayerMaxHp;
}
else
{
GameInformation.PlayerHealth += heal;
}
Debug.Log("Healed: " + heal);
Destroy(this.gameObject);
}
else if (collision.gameObject.tag == "Summon")
{
SummonInfo summon = collision.GetComponent <SummonsAi>().summon;
if (summon.SummonHealth + heal > summon.SummonMaxHealth)
{
summon.SummonHealth = summon.SummonMaxHealth;
}
else
{
summon.SummonHealth += heal;
}
if (summon.SummonHealth > summon.SummonMaxHealth)
{
summon.SummonHealth = summon.SummonMaxHealth;
}
text = GameObject.FindGameObjectWithTag("UiManager").GetComponent <FloatingText>();
text.DamageText(gameObject.transform.position, heal, collision.gameObject, Color.green);
Debug.Log(summon.SummonHealth);
Destroy(this.gameObject);
}
//Destroy(this.gameObject);
}
public static void SetMultiEnemyDeck(int number, int level)
{
if (4 <= Setting.EnemyDeck.Count)
{
Setting.EnemyDeck.Clear();
}
SummonInfo summonInfo = SummonInfoManager.summonInfo[number];
Setting.EnemyDeck.Add(GetUnitData(summonInfo, level));
UnityEngine.Debug.Log("EnemyDeck.Add");
}
private static UnitData GetUnitData(SummonInfo summonInfo, int level)
{
return(new UnitData(summonInfo.number,
level,
summonInfo.pattern,
summonInfo.fieldType,
summonInfo.attackType,
summonInfo.colliderCenter,
summonInfo.colliderSize,
summonInfo.attackSpeed,
summonInfo.airDamage * summonInfo.growthRateOfAirDam * level,
summonInfo.groundDamage * summonInfo.growthRateOfGroundDam * level,
summonInfo.health * summonInfo.growthRateOfHealth * level,
summonInfo.armor * summonInfo.growthRateOfArmor * level,
summonInfo.isBuff,
ConstructBuff(summonInfo.number),
SummonSpriteManager.sprite[summonInfo.number]
));
}
public bool AddSummon(SummonInfo info, int iUniqueID)
{
Hashtable table = m_summonInfo[info.summonID] as Hashtable;
string prefab = table["SummonEffect"] as string;
ResLoadParams param = new ResLoadParams();
param.pos = info.pos;
param.scale = info.scale;
param.rot = info.rotate;
param.userdata0 = info.summonID;
param.userdata1 = info.userdata;
param.userdata2 = info.skillID;
param.userdata3 = info.bParabola;
param.userdata4 = info.bFly;
param.userdata5 = info.targetPos;
param.petInt = iUniqueID;
sdResourceMgr.Instance.LoadResourceImmediately(prefab, OnLoadSummon, param);
return(true);
}
void SummonWindow(SummonInfo info)
{
Vector2 StartSize = ComputeSize(info.startSize);
Vector2 EndSize = ComputeSize(info.endSize);
float availableSpaceX = ScreenCanvas.sizeDelta.x - Margin.x * 2 - Mathf.Max(StartSize.x, EndSize.x);
Vector2 Pos = new Vector2(0, 0);
for (int i = 0; i < info.scaler.Length; ++i)
{
if (info.pos != 0)
{
Pos.x = availableSpaceX * (info.scaler[i] / ((float)info.pos + 1));
}
else
{
Pos.x = 0.0f;
}
CreatePopUp(Pos, StartSize).AnimateResize(info.resizeTime, EndSize);
}
}
// Use this for initialization
void Start()
{
foreach (var kv in scrollsSprite)
{
CurrencyTypes currency = kv.Key;
SummonInfo info = kv.Value;
SummonButtonContainer summonChoice = this.Clone <SummonButtonContainer>(BtnSummonTemplate);
summonChoice.btn.onClick.AddListener(() => BtnAction_Summon(summonChoice));
summonChoice.label.text = info.label + " SUMMON";
summonChoice.icon.sprite = info.sprite;
summonChoice.currency = currency;
summonChoice.summonType = CurrencyManager.ConvertCurrencyToSummonType(currency);
summonChoice.UpdateCounter();
_summonButtons.Add(summonChoice);
}
BtnSummonTemplate.SetActive(false);
PlayerManager.signals.OnChangedCurrency += OnChangedCurrency;
}
public void SetSummonInfo(SummonInfo sum)
{
summon = sum;
}
public static bool Do(sdActorInterface actor, OpParameter param)
{
Hashtable table = sdConfDataMgr.Instance().GetTable("operation");
Operation op = (Operation)table[param.id];
switch (op.byOperationType)
{
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_NONE: {
return(true);
}
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_FOREVER: {
if (param.doType == (int)HeaderProto.EDoOperationType.DO_OPERATION_TYPE_START ||
param.doType == (int)HeaderProto.EDoOperationType.DO_OPERATION_TYPE_ADD
)
{
if (actor == null)
{
return(false);
}
Hashtable dst = actor.GetProperty();
switch (op.dwOperationPara1)
{
case (int)HeaderProto.EOpreationFlag.OPREATION_FLAG_ADD: {
AddProperty(actor, dst, op, param);
} break;
case (int)HeaderProto.EOpreationFlag.OPREATION_FLAG_REDUCE: {
param.data = -param.data;
AddProperty(actor, dst, op, param);
} break;
case (int)HeaderProto.EOpreationFlag.OPREATION_FLAG_SET: {} break;
}
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_STATE: {
if (actor == null)
{
return(false);
}
if (param.doType == (int)HeaderProto.EDoOperationType.DO_OPERATION_TYPE_START)
{
HeaderProto.ECreatureActionState state = (HeaderProto.ECreatureActionState)param.data;
actor.AddDebuffState(state);
}
else if (param.doType == (int)HeaderProto.EDoOperationType.DO_OPERATION_TYPE_REMOVE)
{
HeaderProto.ECreatureActionState state = (HeaderProto.ECreatureActionState)param.data;
actor.RemoveDebuffState(state);
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_ADD_BUFF: {
if (actor == null)
{
return(false);
}
actor.AddBuff(param.data, param.data1, param.attackActor);
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_DISPEL: {
if (actor == null)
{
return(false);
}
if (op.dwOperationPara0 == 0)
{
actor.RemoveBuffbyClassType(op.dwOperationPara1);
}
else if (op.dwOperationPara0 == 1)
{
actor.RemoveBuff(op.dwOperationPara1, op.dwOperationPara2);
}
else if (op.dwOperationPara0 == 2)
{
actor.RemoveBuffbyID(param.data);
}
else if (op.dwOperationPara0 == 3)
{
actor.RemoveBuffbyProperty(op.dwOperationPara1);
}
else if (op.dwOperationPara0 == 4)
{
}
else if (op.dwOperationPara0 == 5)
{
actor.RemoveAllBuff();
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_DO_BUFF_DAMAGE:
{
if (param.targetActor == null)
{
return(false);
}
Hashtable action = sdConfDataMgr.Instance().m_BuffAction[param.data] as Hashtable;
int strikeType = (int)action["byAoeAreaType"];
int nCombo = 0;
if (strikeType == 0)
{
HeaderProto.ESkillEffect skilleffect = HeaderProto.ESkillEffect.SKILL_EFFECT_DAMAGE_HP;
if (action.ContainsKey("bySkillEffect"))
{
skilleffect = (HeaderProto.ESkillEffect)(action["bySkillEffect"]);
}
action["ParentID"] = 0;
DamageResult dr = sdGameLevel.instance.battleSystem.testHurt(param.attackActor,
action,
param.targetActor,
0,
skilleffect);
if (Bubble.IsHurtOther(dr.bubbleType))
{
nCombo++;
}
}
else
{
nCombo = sdGameLevel.instance.battleSystem.DoSDAttack(
param.attackActor,
action,
param.targetActor.transform.position,
0,
null);
}
if (param.attackActor == sdGameLevel.instance.mainChar && nCombo > 0)
{
sdUICharacter.Instance.ShowComboWnd(true, nCombo);
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_CLEAR_SKILL_COOLDOWN:
{
sdGameActor gameActor = (sdGameActor)actor;
if (op.dwOperationPara0 == 0) //某个技能aa
{
int skillID = param.data / 100;
sdSkill skill = gameActor.skillTree.getSkill(skillID);
if (skill != null)
{
if (op.dwOperationPara1 == 0)
{
skill.skillState = (int)sdSkill.State.eSS_OK;
}
else if (op.dwOperationPara1 == 1)
{
int time = CalculateSkillCoolDown(op.dwOperationPara2, op.dwOperationPara3, skill.GetCD(), param.data1);
sdUICharacter.Instance.SetShortCutCd(param.data, time, true);
skill.cooldown = time;
skill.Setct(0.0f);
}
}
}
else if (op.dwOperationPara0 == 1) //某种形态的技能aa
{
foreach (DictionaryEntry de in gameActor.skillTree.AllSkill)
{
sdSkill skill = de.Value as sdSkill;
if (skill.skillProperty.ContainsKey("byShape"))
{
int byShape = (int)skill.skillProperty["byShape"];
if (byShape == param.data)
{
if (op.dwOperationPara1 == 0)
{
skill.skillState = (int)sdSkill.State.eSS_OK;
}
else if (op.dwOperationPara1 == 1)
{
int time = CalculateSkillCoolDown(op.dwOperationPara2, op.dwOperationPara3, skill.cooldown, param.data1);
sdUICharacter.Instance.SetShortCutCd(skill.id, time, true);
skill.cooldown = time;
skill.Setct(0.0f);
}
}
}
}
}
else if (op.dwOperationPara0 == 2) //所有技能aa
{
foreach (DictionaryEntry de in gameActor.skillTree.AllSkill)
{
sdSkill skill = de.Value as sdSkill;
if (op.dwOperationPara1 == 0)
{
skill.skillState = (int)sdSkill.State.eSS_OK;
}
else if (op.dwOperationPara1 == 1)
{
int time = CalculateSkillCoolDown(op.dwOperationPara2, op.dwOperationPara3, skill.cooldown, param.data1);
sdUICharacter.Instance.SetShortCutCd(skill.id, time, true);
skill.cooldown = time;
skill.Setct(0.0f);
}
}
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_SUMMON_MONSTER: //operator.txt byOperationType
{
iSummonUniqueID++;
if (op.dwOperationPara0 == 1)
{
int iAngle = op.dwOperationPara2;
int iSummonID = param.data;
int iSommonCount = param.data1;
int skillID = param.data2;
Vector3 v = param.attackActor.GetDirection();
v.y = 0.0f;
v.Normalize();
Quaternion tempQ = Quaternion.FromToRotation(new Vector3(0, 0, 1), v);
if (v.z < -0.9999f)
{
tempQ = Quaternion.AngleAxis(180.0f, new Vector3(0, 1, 0));
}
List <sdActorInterface> lstActor = null;
if (op.dwOperationPara3 == 1 || op.dwOperationPara3 == 2) //1 方向并跟踪目标 2.方向不跟踪aaa
{
List <sdActorInterface> actorList = null;
if (iAngle == 360)
{
actorList = sdGameLevel.instance.actorMgr.FindActor(
param.attackActor,
HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY,
param.attackActor.transform.position,
Vector3.zero,
1,
0,
15.0f,
true);
}
else
{
actorList = sdGameLevel.instance.actorMgr.FindActor(
param.attackActor,
HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY,
param.attackActor.transform.position,
param.attackActor.GetDirection(),
5,
iAngle,
15.0f,
true);
}
lstActor = sdGameLevel.instance.actorMgr.SortActor(param.attackActor.transform.position, actorList);
}
int i = 0;
if (op.dwOperationPara3 == 1)
{
for (; i < iSommonCount && i < lstActor.Count; i++)
{
sdActorInterface target = lstActor[i];
SummonInfo sumInfo = new SummonInfo();
Vector3 vDir = target.transform.position - param.attackActor.transform.position;
vDir.y = 0.0f;
vDir.Normalize();
if (v.z < -0.99999f)
{
sumInfo.rotate = Quaternion.AngleAxis(180.0f, new Vector3(0, 1, 0));
}
else
{
sumInfo.rotate = Quaternion.FromToRotation(new Vector3(0, 0, 1), vDir);
}
sumInfo.pos = param.trans.position;
sumInfo.userdata = target;
sumInfo.summonID = iSummonID;
sumInfo.skillID = skillID;
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
}
}
else if (op.dwOperationPara3 == 2)
{
for (; i < iSommonCount && i < lstActor.Count; i++)
{
sdActorInterface target = lstActor[i];
Vector3 vDir = target.transform.position - param.attackActor.transform.position;
vDir.y = 0.0f;
vDir.Normalize();
SummonInfo sumInfo = new SummonInfo();
if (v.z < -0.99999f)
{
sumInfo.rotate = Quaternion.AngleAxis(180.0f, new Vector3(0, 1, 0));
}
else
{
sumInfo.rotate = Quaternion.FromToRotation(new Vector3(0, 0, 1), vDir);
}
sumInfo.pos = param.trans.position;
sumInfo.summonID = iSummonID;
sumInfo.skillID = skillID;
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
}
}
if (i < iSommonCount)
{
if (iAngle == 360)
{
float iPerAngle = (float)iAngle / (float)(iSommonCount - i);
for (int j = 0; j < iSommonCount - i; j++)
{
SummonInfo sumInfo = new SummonInfo();
sumInfo.rotate = Quaternion.AngleAxis(iPerAngle * j, new Vector3(0, 1, 0)) * tempQ;
sumInfo.pos = param.trans.position;
sumInfo.summonID = iSummonID;
sumInfo.skillID = skillID;
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
}
}
else
{
float iPerAngle = (float)iAngle / (float)(iSommonCount - i + 1);
float iAngleStart = -iAngle * 0.5f + iPerAngle;
for (int j = 0; j < iSommonCount - i; j++)
{
SummonInfo sumInfo = new SummonInfo();
sumInfo.rotate = Quaternion.AngleAxis(iAngleStart + iPerAngle * j, new Vector3(0, 1, 0)) * tempQ;
sumInfo.pos = param.trans.position;
sumInfo.summonID = iSummonID;
sumInfo.skillID = skillID;
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
}
}
}
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_TELEPORT:
{
TeleportInfo tpInfo = new TeleportInfo();
tpInfo.Type = op.dwOperationPara0;
tpInfo.PlayActionProbality = op.dwOperationPara1;
tpInfo.TeleportState = (op.dwOperationPara2 == 1);
tpInfo.MoveSpeed = (float)param.data * 0.001f;
tpInfo.MoveTime = (float)param.data1 * 0.001f;
tpInfo.castActor = param.attackActor;
tpInfo.castCenter = param.attackActor.transform.position;
if (actor != null)
{
actor.SetTeleportInfo(tpInfo);
}
else
{
float dis = tpInfo.MoveSpeed * tpInfo.MoveTime;
List <sdActorInterface> lstActor = sdGameLevel.instance.actorMgr.FindActor(param.attackActor, HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY, tpInfo.castCenter, Vector3.zero, 1, 0, dis, true);
if (lstActor != null)
{
foreach (sdActorInterface a in lstActor)
{
a.SetTeleportInfo(tpInfo);
}
}
}
} break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_DOACTION:
{
sdGameActor gameActor = (sdGameActor)(param.attackActor);
sdBaseState baseState = (sdBaseState)gameActor.logicTSM.states[param.data];
if (baseState != null)
{
int nCombo = sdGameLevel.instance.battleSystem.DoSDAttack(gameActor, baseState.stateData, gameActor.transform.position, 0, baseState);
baseState.playEffectNow(gameActor);
baseState.PlayAudioNow(gameActor);
if (gameActor == sdGameLevel.instance.mainChar && nCombo > 0)
{
sdUICharacter.Instance.ShowComboWnd(true, nCombo);
}
}
}
break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_COMBO:
{
if (param.attackActor.GetActorType() == ActorType.AT_Player)
{
sdGameActor gameActor = (sdGameActor)(param.attackActor);
sdBaseState baseState = (sdBaseState)gameActor.logicTSM.states[param.data];
if (baseState != null)
{
baseState.bEnable = (param.data1 == 1);
}
}
}
break;
case (int)HeaderProto.EOpreationType.OPREATION_TYPE_ATTACKGETHP:
{
AttackRestore data = new AttackRestore();
data.upperLimit = op.dwOperationPara1 * 0.0001f;
data.restoreHp = (op.dwOperationPara0 == 0);
data.monsterType = op.dwOperationPara2;
data.ratio = param.data * 0.0001f;
data.actionID = param.data1;
sdGameActor gameActor = (sdGameActor)(param.attackActor);
gameActor.AddAttackRestore(data);
}
break;
case (int)HeaderProto.EOpreationType.OPERATION_TYPE_SUMMON:
{
iSummonUniqueID++;
switch (op.dwOperationPara0)
{
case 0:
case 1:
PointSummon(actor, param, op);
break;
case 2:
case 3:
RandomSummon(actor, param, op);
break;
case 4:
case 5:
RoundSummon(actor, param, op);
break;
}
}
break;
case (int)HeaderProto.EOpreationType.OPERATION_TYPE_HIDESHOW:
{
HideShowInfo info = new HideShowInfo();
info.actor = param.attackActor;
info.fHideTime = param.data * 0.001f;
info.fDistance = param.data1 * 0.001f;
sdHideShowMgr.Instance.AddActor(info);
}
break;
case (int)HeaderProto.EOpreationType.OPERATION_TYPE_FLASH:
{
float fFront = 1.0f;
if ((op.dwOperationPara0 & 1) == 1)
{
fFront = -1.0f;
}
float fDistance = (float)op.dwOperationPara3 * 0.001f;
sdActorInterface castActor = param.attackActor;
int playerLayer = 1 << LayerMask.NameToLayer("Player");
int petLayer = 1 << LayerMask.NameToLayer("Pet");
int monsterLayer = 1 << LayerMask.NameToLayer("Monster");
int mask = ~(playerLayer | petLayer | monsterLayer);
switch (op.dwOperationPara0)
{
case 0:
case 1:
{
fDistance = (float)param.data1 * 0.001f;
Vector3 dir = castActor.GetDirection() * fFront;
Vector3 pos = castActor.transform.position;
int oldLayer = castActor.gameObject.layer;
int[] layer = new int[] {
LayerMask.NameToLayer("Monster"),
LayerMask.NameToLayer("Pet"),
LayerMask.NameToLayer("Player")
};
bool[] oldcollision = new bool[3];
for (int i = 0; i < 3; i++)
{
oldcollision[i] = Physics.GetIgnoreLayerCollision(oldLayer, layer[i]);
Physics.IgnoreLayerCollision(oldLayer, layer[i]);
}
((sdGameActor)castActor).moveInternal(dir * fDistance / Time.deltaTime);
for (int i = 0; i < 3; i++)
{
Physics.IgnoreLayerCollision(oldLayer, layer[i], oldcollision[i]);
}
castActor.gameObject.layer = oldLayer;
Vector3 newPos = castActor.transform.position;
sdGameLevel.instance.actorMgr.ManualCheckTrigger((sdGameActor)castActor, pos, newPos - pos);
if (param.data > 0)
{
HideShowInfo info = new HideShowInfo();
info.actor = castActor;
info.fHideTime = param.data * 0.001f;
info.fDistance = 0.0f;
sdHideShowMgr.Instance.AddActorNoRandomPosition(info);
}
}
break;
case 2:
case 3:
{
float fResearchDistance = param.data1 * 0.001f;
int iAngle = op.dwOperationPara1;
List <sdActorInterface> actorList = null;
if (iAngle == 360)
{
actorList = sdGameLevel.instance.actorMgr.FindActor(
param.attackActor,
HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY,
param.attackActor.transform.position,
Vector3.zero,
1,
0,
fResearchDistance,
true);
}
else
{
actorList = sdGameLevel.instance.actorMgr.FindActor(
param.attackActor,
HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY,
param.attackActor.transform.position,
param.attackActor.GetDirection(),
5,
iAngle,
fResearchDistance,
true);
}
sdActorInterface targetActor = null;
if (actorList != null)
{
if (actorList.Count > 0)
{
if (op.dwOperationPara2 == 0)
{
targetActor = actorList[0];
float min = (castActor.transform.position - targetActor.transform.position).sqrMagnitude;
for (int i = 1; i < actorList.Count; i++)
{
Vector3 v = castActor.transform.position - actorList[i].transform.position;
if (v.sqrMagnitude < min)
{
min = v.sqrMagnitude;
targetActor = actorList[i];
}
}
}
else
{
int index = Random.Range(0, actorList.Count);
if (index >= actorList.Count)
{
index = 0;
}
targetActor = actorList[index];
}
}
}
if (targetActor != null)
{
if (fDistance < targetActor.getRadius() + castActor.getRadius())
{
fDistance = targetActor.getRadius() + castActor.getRadius();
}
Vector3 dir = targetActor.GetDirection() * fFront;
Vector3 pos = targetActor.transform.position + new Vector3(0, 0.1f, 0);
RaycastHit hit;
if (Physics.Raycast(pos, dir, out hit, fDistance * 2, mask))
{
if (hit.distance < fDistance)
{
fDistance = hit.distance;
}
}
castActor.transform.position = targetActor.transform.position + dir * fDistance;
dir.y = 0.0f;
dir.Normalize();
((sdGameActor)castActor).spinToTargetDirection(-dir, true);
if (param.data > 0)
{
HideShowInfo info = new HideShowInfo();
info.actor = castActor;
info.fHideTime = param.data * 0.001f;
info.fDistance = 0.0f;
sdHideShowMgr.Instance.AddActorNoRandomPosition(info);
}
}
} break;
}
}
break;
}
return(true);
}
private SummonInfo GetPlayerSummonCounts()
{
var info = new SummonInfo();
// todo, create a units only collection in ActorsCache so we dont have to iterate all RActors.
foreach (var actor in Core.Actors.Actors)
{
if (!actor.IsSummonedByPlayer)
{
continue;
}
var actorSnoId = actor.ActorSnoId;
var distance = actor.Distance;
switch (ActorClass)
{
case ActorClass.Monk:
if (GameData.MysticAllyIds.Contains(actorSnoId))
{
info.MysticAllyCount++;
}
break;
case ActorClass.DemonHunter:
if (GameData.DemonHunterPetIds.Contains(actorSnoId))
{
info.DHPetsCount++;
}
if (GameData.DemonHunterSentryIds.Contains(actorSnoId) && distance < 60f)
{
info.DHSentryCount++;
}
break;
case ActorClass.Wizard:
if (GameData.WizardHydraIds.Contains(actorSnoId) && distance < 60f)
{
info.HydraCount++;
}
break;
case ActorClass.Witchdoctor:
if (GameData.SpiderPetIds.Contains(actorSnoId) && distance < 100f)
{
info.SpiderPetCount++;
}
if (GameData.GargantuanIds.Contains(actorSnoId))
{
info.GargantuanCount++;
}
if (GameData.ZombieDogIds.Contains(actorSnoId))
{
info.ZombieDogCount++;
}
if (GameData.FetishArmyIds.Contains(actorSnoId))
{
info.FetishArmyCount++;
}
break;
case ActorClass.Barbarian:
if (GameData.AncientIds.Contains(actorSnoId))
{
info.AncientCount++;
}
break;
}
}
return(info);
}
internal void UpdateFastChangingData()
{
var commonData = _me.CommonData;
if (_me.IsInCombat)
{
LastInCombatTime = DateTime.UtcNow;
}
IsInParty = ZetaDia.Service.Party.NumPartyMembers > 1;
AcdId = _me.ACDId;
RActorGuid = _me.RActorId;
LastUpdated = DateTime.UtcNow;
IsInTown = GameData.TownLevelAreaIds.Contains(LevelAreaId);
IsInRift = GameData.RiftWorldIds.Contains(WorldSnoId);
IsDead = _me.IsDead;
IsIncapacitated = _me.IsFeared || _me.IsStunned || _me.IsFrozen || _me.IsBlind || IsPowerUseDisabled;
IsRooted = _me.IsRooted;
CurrentHealthPct = _me.HitpointsCurrentPct;
PrimaryResource = GetCurrentPrimaryResource();
PrimaryResourcePct = PrimaryResource / PrimaryResourceMax;
PrimaryResourceMissing = PrimaryResourceMax - PrimaryResource;
SecondaryResource = _me.CurrentSecondaryResource;
SecondaryResourcePct = SecondaryResource / SecondaryResourceMax;
SecondaryResourceMissing = SecondaryResourceMax - SecondaryResource;
Position = _me.Position;
Rotation = _me.Movement.Rotation;
DirectionVector = _me.Movement.DirectionVector;
MovementSpeed = (float)Core.PlayerHistory.MoveSpeed;
IsMoving = _me.Movement.IsMoving;
IsInCombat = _me.IsInCombat;
MaxBloodShards = 500 + commonData.GetAttribute <int>(ActorAttributeType.HighestSoloRiftLevel) * 10;
IsMaxCriticalChance = _me.CritPercentBonusUncapped > 0 || Math.Abs(_me.CritDamagePercent - 100) < float.Epsilon;
CriticalChancePct = _me.CritDamagePercent;
IsJailed = _me.HasDebuff(SNOPower.MonsterAffix_JailerCast);
IsFrozen = _me.IsFrozen;
ParticipatingInTieredLootRun = _me.IsParticipatingInTieredLootRun;
TieredLootRunlevel = _me.InTieredLootRunLevel;
IsCasting = _me.LoopingAnimationEndTime > 0;
IsInteractingWithGizmo = commonData.GetAttribute <bool>(ActorAttributeType.PowerBuff0VisualEffectNone, (int)SNOPower.Axe_Operate_Gizmo);
CurrentAnimation = commonData.CurrentAnimation;
IsInventoryLockedForGreaterRift = ZetaDia.Storage.RiftStarted && ZetaDia.Storage.CurrentRiftType == RiftType.Greater && !ZetaDia.Storage.RiftCompleted;
ShieldHitpoints = commonData.GetAttribute <float>(ActorAttributeType.DamageShieldAmount);
Summons = GetPlayerSummonCounts();
//var direction = ZetaDia.Me.Movement.DirectionVector;
// var directionRadians = Math.Atan2(direction.X, direction.Y);
//var directionDegrees = directionRadians * 180/Math.PI;
//Core.Logger.Log("Player DirectionVector={0}{1} Radians={2} (DB: {3}) Degrees={4} (DB: {5})",
// DirectionVector.X,
// DirectionVector.Y,
// directionRadians,
// ZetaDia.Me.Movement.Rotation,
// directionDegrees,
// ZetaDia.Me.Movement.RotationDegrees
// );
var wasCastingPortal = IsCastingPortal;
IsCastingPortal = IsCasting && wasCastingPortal || IsCastingTownPortalOrTeleport();
CurrentHealth = _me.HitpointsCurrent;
IsInBossEncounter = _me.IsInBossEncounter;
HealthHistory.Add(CurrentHealth);
while (HealthHistory.Count > 5)
{
HealthHistory.RemoveAt(0);
}
var averageHealth = HealthHistory.Average();
IsTakingDamage = averageHealth > CurrentHealth;
// For WD Angry Chicken
IsHidden = _me.IsHidden;
}
public string attackProjector = "RangedAttackProjector"; // going to be more then one projector later for certian abilites
// No heal projector in this one
public HealingTurretAbility()
{
info = new SummonInfo();
SummonAbilites abilites = new SummonAbilites(info);
}
public void Init(int ID)
{
GameObject projector = null;
GameObject healProjector = null;
AbilityCreatorClass abilityCreator = new AbilityCreatorClass(); // This will create the summonInfo Dynically
var classInfo = abilityCreator.GetAbility(ID);
Type type = classInfo.GetType();
summonInfo = new SummonInfo();
int damage = 0;
int duration = 0;
foreach (var f in type.GetFields().Where(f => f.IsPublic))
{
if (f.Name == "baseDamage")
{
var temp = f.GetValue(classInfo).ToString();
damage = int.Parse(temp);
}
if (f.Name == "range")
{
var temp = f.GetValue(classInfo).ToString();
range = int.Parse(temp);
}
if (f.Name == "info")
{
var temp = f.GetValue(classInfo) as SummonInfo;
summonInfo = temp;
}
if (f.Name == "name")
{
name = f.GetValue(classInfo).ToString();
}
if (f.Name == "attackProjector")
{
var temp = f.GetValue(classInfo).ToString();
projector = Instantiate(Resources.Load <GameObject>("Projectors/" + temp));
projector.name = temp;
}
if (f.Name == "healProjector")
{
var temp = f.GetValue(classInfo) as GameObject;
healProjector = temp;
}
if (f.Name == "duration")
{
var temp = f.GetValue(classInfo).ToString();
duration = int.Parse(temp);
}
}
GameInformation.SummonsUp++;
summonInfo.SummonName = name;
summon = Instantiate(Resources.Load <GameObject>("Summons/" + name));
projector.transform.parent = summon.transform;
summon.transform.position = new Vector3(circleProjector.transform.position.x, transform.position.y, circleProjector.transform.position.z);
projector.transform.position = new Vector3(summon.transform.position.x, projector.transform.position.y + 20f, summon.transform.position.z);
//projector.transform.rotation = new Vector3(summon.transform.rotation.x, projector.transform.rotation.y);
var rotationVector = summon.transform.rotation.eulerAngles;
rotationVector.x = 90f;
rotationVector.z = 90f;
projector.transform.rotation = Quaternion.Euler(rotationVector);
if (projector != null)
{
summon.GetComponent <SummonsAi>().SetDamageProjector(projector);
}
if (healProjector != null)
{
summon.GetComponent <SummonsAi>().SetHealProjector(healProjector);
}
summon.GetComponent <SummonsAi>().baseDamage = summonInfo.BaseDamage;
summon.GetComponent <SummonsAi>().attackRange = range;
summon.GetComponent <SummonsAi>().duration = duration;
summonInfo.CalculateEnergy();
summonInfo.CalculateHealth();
summonInfo.CalculateCrit();
summonInfo.CalculateDamage(damage);
summon.GetComponent <SummonsAi>().SetSummonInfo(summonInfo);
Debug.Log(summonInfo.HealAmount);
}
//目标点等距离圆形或者扇形aaa
public static void RoundSummon(sdActorInterface actor, OpParameter param, Operation op)
{
//int summonID = param.data; //召唤物id
//int skillId = param.data2;
int summonCount = param.data1; //召唤数量aaa
float alarmTime = op.dwOperationPara4 * 0.001f; //预警特效时间aaa
alarmTime = 0.5f;
float alarmRadius = op.dwOperationPara2 * 0.001f; //预警半径aaa
int iAngle = op.dwOperationPara1; //召唤物在多少角度范围内召唤aaa
float radius = op.dwOperationPara3 * 0.001f;
Vector3 v = param.attackActor.GetDirection();
v.y = 0.0f;
v.Normalize();
Quaternion tempQ = Quaternion.FromToRotation(new Vector3(0, 0, 1), v);
if (v.z < -0.9999f)
{
tempQ = Quaternion.AngleAxis(180.0f, new Vector3(0, 1, 0));
}
float iPerAngle = 0.0f;
float iAngleStart = 0.0f;
if (iAngle == 360)
{
iPerAngle = (float)iAngle / (float)(summonCount);
}
else
{
iPerAngle = (float)iAngle / (float)(summonCount + 1);
iAngleStart = -iAngle * 0.5f + iPerAngle;
}
for (int j = 0; j < summonCount; j++)
{
SummonInfo sumInfo = new SummonInfo();
sumInfo.summonID = param.data;
sumInfo.skillID = param.data2;
ResLoadParams alarmParam = new ResLoadParams();
Quaternion rot = Quaternion.AngleAxis(iAngleStart + iPerAngle * j, new Vector3(0, 1, 0)) * tempQ;
if (op.dwOperationPara0 == 4) //指定点召唤东西aaa
{
sumInfo.pos = param.trans.position + rot * v * radius;
Vector3 hitpos = Vector3.zero;
if (sdTuiTuLogic.NavMesh_RayCast(sumInfo.pos, ref hitpos))
{
sumInfo.pos = hitpos + new Vector3(0.0f, 0.1f, 0.0f);
}
sumInfo.bFly = false;
alarmParam.pos = sumInfo.pos;
}
else //指定点丢东西aaa
{
sumInfo.pos = param.trans.position;
sumInfo.targetPos = param.trans.position + rot * Vector3.forward * radius;
Vector3 hitpos = Vector3.zero;
if (sdTuiTuLogic.NavMesh_RayCast(sumInfo.targetPos, ref hitpos))
{
sumInfo.targetPos = hitpos + new Vector3(0.0f, 0.1f, 0.0f);
}
sumInfo.bParabola = true;
sumInfo.bFly = true;
alarmParam.pos = sumInfo.targetPos;
}
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
alarmParam.userdata0 = alarmTime;
alarmParam.userdata1 = alarmRadius;
sdResourceMgr.Instance.LoadResourceImmediately("Effect/MainChar/$Tongyong/yujing/FX_yujing.prefab", OnLoadAlarmEffect, alarmParam);
}
}
//朝目标点召唤aaa
public static void PointSummon(sdActorInterface actor, OpParameter param, Operation op)
{
//int summonID = param.data; //召唤物id
//int skillId = param.data2;
int iSommonCount = param.data1; //召唤数量aaa
float alarmTime = op.dwOperationPara4 * 0.001f; //预警特效时间aaa
float alarmRadius = op.dwOperationPara2 * 0.001f; //预警半径aaa
int iAngle = op.dwOperationPara1; //召唤物在多少角度范围内召唤aaa
float radius = op.dwOperationPara3 * 0.001f;
Vector3 v = param.attackActor.GetDirection();
v.y = 0.0f;
v.Normalize();
Quaternion tempQ = Quaternion.FromToRotation(new Vector3(0, 0, 1), v);
if (v.z < -0.9999f)
{
tempQ = Quaternion.AngleAxis(180.0f, new Vector3(0, 1, 0));
}
List <sdActorInterface> actorList = null;
List <sdActorInterface> lstActor = null;
if (iAngle == 360)
{
actorList = sdGameLevel.instance.actorMgr.FindActor(
param.attackActor,
HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY,
param.attackActor.transform.position,
Vector3.zero,
1,
0,
radius,
true);
}
else
{
actorList = sdGameLevel.instance.actorMgr.FindActor(
param.attackActor,
HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY,
param.attackActor.transform.position,
param.attackActor.GetDirection(),
5,
iAngle,
radius,
true);
}
lstActor = sdGameLevel.instance.actorMgr.SortActor(param.attackActor.transform.position, actorList);
int i = 0;
for (; i < iSommonCount && i < lstActor.Count; i++)
{
sdActorInterface target = lstActor[i];
SummonInfo sumInfo = new SummonInfo();
ResLoadParams alarmParam = new ResLoadParams();
sumInfo.summonID = param.data;
sumInfo.skillID = param.data2;
if (op.dwOperationPara0 == 0) //朝目标所在直接召唤aaa
{
sumInfo.pos = target.gameObject.transform.position;
alarmParam.pos = sumInfo.pos;
sumInfo.bFly = false;
}
else //朝目标所在点丢东西aaa
{
sumInfo.pos = param.trans.position;
sumInfo.targetPos = target.gameObject.transform.position;
alarmParam.pos = sumInfo.targetPos;
sumInfo.bParabola = true;
sumInfo.bFly = true;
}
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
alarmParam.userdata0 = alarmTime;
alarmParam.userdata1 = alarmRadius;
sdResourceMgr.Instance.LoadResourceImmediately("Effect/MainChar/$Tongyong/yujing/FX_yujing.prefab", OnLoadAlarmEffect, alarmParam);
}
if (i < iSommonCount)
{
float iPerAngle = 0.0f;
float iAngleStart = 0.0f;
if (iAngle == 360)
{
iPerAngle = (float)iAngle / (float)(iSommonCount - i);
}
else
{
iPerAngle = (float)iAngle / (float)(iSommonCount - i + 1);
iAngleStart = -iAngle * 0.5f + iPerAngle;
}
for (int j = 0; j < iSommonCount - i; j++)
{
SummonInfo sumInfo = new SummonInfo();
sumInfo.summonID = param.data;
sumInfo.skillID = param.data2;
ResLoadParams alarmParam2 = new ResLoadParams();
sumInfo.pos = param.trans.position;
Quaternion rot = Quaternion.AngleAxis(iAngleStart + iPerAngle * j, new Vector3(0, 1, 0)) * tempQ;
if (op.dwOperationPara0 == 0) //朝目标所在直接召唤aaa
{
sumInfo.pos = param.trans.position + rot * Vector3.forward * radius;
Vector3 hitpos = Vector3.zero;
if (sdTuiTuLogic.NavMesh_RayCast(sumInfo.pos, ref hitpos))
{
sumInfo.pos = hitpos + new Vector3(0.0f, 0.1f, 0.0f);
}
alarmParam2.pos = sumInfo.pos;
sumInfo.bFly = false;
}
else //朝目标所在点丢东西aaa
{
sumInfo.pos = param.trans.position;
sumInfo.targetPos = param.trans.position + rot * Vector3.forward * radius;
Vector3 hitpos = Vector3.zero;
if (sdTuiTuLogic.NavMesh_RayCast(sumInfo.targetPos, ref hitpos))
{
sumInfo.targetPos = hitpos + new Vector3(0.0f, 0.1f, 0.0f);
}
sumInfo.bFly = true;
sumInfo.bParabola = true;
alarmParam2.pos = sumInfo.targetPos;
}
param.attackActor.AddSummon(sumInfo, iSummonUniqueID);
alarmParam2.userdata0 = alarmTime;
alarmParam2.userdata1 = alarmRadius;
sdResourceMgr.Instance.LoadResourceImmediately("Effect/MainChar/$Tongyong/yujing/FX_yujing.prefab", OnLoadAlarmEffect, alarmParam2);
}
}
}
/// <summary>
/// Dont forget to declear the name before this function
/// </summary>
/// <param name="info"></param>
public SummonAbilites(SummonInfo info)
{
CalculateSummonStats(info);
}
