public static Vector3 GetShootPosition(ISkillTarget target)
{
SkillRunner runner = target as SkillRunner;
if (runner != null && runner.GetComponent <Collider>() != null)
{
AiObject aiObj = runner as AiObject;
if (aiObj != null)
{
if (aiObj.model != null)
{
Rigidbody[] rigids = aiObj.model.GetComponentsInChildren <Rigidbody>();
if (rigids != null && rigids.Length > 0)
{
return(rigids[Random.Range(0, rigids.Length)].worldCenterOfMass);
}
}
return(aiObj.center);
}
else
{
return(AiUtil.GetColliderCenter(runner.GetComponent <Collider>()));
}
}
else
{
//CreationSkillRunner creation = runner as CreationSkillRunner;
//if (creation != null)
// return creation.transform.TransformPoint(creation.LocalBounds.center);
//else
// return target.GetPosition();
}
return(Vector3.zero);
}
public static Vector3 GetTargetCenter(ISkillTarget target)
{
SkillRunner runner = target as SkillRunner;
if (runner != null && runner.GetComponent <Collider>() != null)
{
AiObject aiObj = runner as AiObject;
if (aiObj != null)
{
return(aiObj.center);
}
else
{
return(AiUtil.GetColliderCenter(runner.GetComponent <Collider>()));
}
}
else
{
//CreationSkillRunner creation = runner as CreationSkillRunner;
//if (creation != null)
//return creation.transform.TransformPoint(creation.LocalBounds.center);
// else
// return target.GetPosition();
}
return(Vector3.zero);
}
public static Vector3 GetPredictPosition(ISkillTarget target, Vector3 startPos, float speed)
{
SkillRunner runner = target as SkillRunner;
if (runner != null && runner.GetComponent <Rigidbody>() != null)
{
Vector3 reverseVec = startPos - GetShootPosition(target);
float sqrv22mv12 = Mathf.Sqrt(speed * speed - runner.GetComponent <Rigidbody>().velocity.sqrMagnitude);
float cos2 = Mathf.Cos(Vector3.Angle(reverseVec, runner.GetComponent <Rigidbody>().velocity) / 180f * Mathf.PI);
float temp1 = reverseVec.sqrMagnitude * runner.GetComponent <Rigidbody>().velocity.sqrMagnitude *cos2 *cos2;
float predictTime;
if (Vector3.Angle(reverseVec, runner.GetComponent <Rigidbody>().velocity) <= 90f)
{
predictTime = (Mathf.Sqrt(reverseVec.sqrMagnitude + temp1 / sqrv22mv12 / sqrv22mv12) - Mathf.Sqrt(temp1 / sqrv22mv12 / sqrv22mv12)) / sqrv22mv12;
}
else
{
predictTime = (Mathf.Sqrt(reverseVec.sqrMagnitude + temp1 / sqrv22mv12 / sqrv22mv12) + Mathf.Sqrt(temp1 / sqrv22mv12 / sqrv22mv12)) / sqrv22mv12;
}
Vector3 predictPos = GetShootPosition(target) + runner.GetComponent <Rigidbody>().velocity *predictTime;
return(predictPos);
}
else
{
return(GetShootPosition(target));
}
}
public void Init(byte index, SkillRunner emitRunner, ISkillTarget target, Transform emitTransform, float rand1)
{
//this.projectileIndex = index;
this.emitRunner = emitRunner;
this.emitTransform = emitTransform;
//this.random1 = rand1;
SetupTrajectory(emitRunner, emitTransform, target);
}
public SkillRunner GetOrCreateSkillRunner(SkillsEnum skill)
{
if (m_skillRunners[(int)skill] == null)
{
m_skillRunners[(int)skill] = new SkillRunner(skill);
}
return(m_skillRunners[(int)skill]);
}
public GoldFingerRunner()
{
SceneLoader instance = SceneLoader.Instance;
Skill = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.Goldfinger);
GoldFingerActive = (from active in Skill.Active
select(active)).TakeUntilDestroy(instance).ToReactiveProperty();
}
public virtual void InitEquipment(SkillRunner runner, ItemObject item)
{
mSkillRunner = runner;
mHuman = mSkillRunner as IHuman;
// InitNetworkLayer(runner.Netlayer);
mItemObj = item;
mSkillIndex = 0;
//mMainPlayerEquipment = mSkillRunner == PlayerFactory.mMainPlayer;
}
public TntRunner()
{
SceneLoader instance = SceneLoader.Instance;
Skill = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.TNT);
TntCurrentDamage = (from dmg in Singleton <HeroTeamRunner> .Instance.GetOrCreateHeroDamageRunner(0).Damage
select dmg *PersistentSingleton <GameSettings> .Instance.TntDamageMultiplier).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
}
public override void InitEquipment(SkillRunner runner, ItemObject item)
{
mCurrentIndex = 0;
//mLastIndex = 0;
mCoolDownTime = new List <float>();
for (int i = 0; i < mGunMuzzle.Count; i++)
{
//foreach (VCPGunMuzzle muzzle in mGunMuzzle)
mCoolDownTime.Add(Time.time);
}
base.InitEquipment(runner, item);
}
public override void InitEquipment(SkillRunner runner, ItemObject item)
{
base.InitEquipment(runner, item);
if (mBuffID != 0)
{
mBuff = EffSkillBuff.s_tblEffSkillBuffs.Find(iter0 => EffSkillBuff.MatchId(iter0, mBuffID));
if (null != mBuff)
{
mSkillRunner.m_effSkillBuffManager.AddBuff(mBuff);
}
}
}
public override void InitEquipment(SkillRunner runner, ItemAsset.ItemObject item)
{
base.InitEquipment(runner, item);
if (mMainPlayerEquipment)
{
mOpCube.Active = true;
mOpCube.Enable = true;
}
else
{
mOpCube.Active = false;
}
}
public TeamBoostRunner()
{
Singleton <PropertyManager> .Instance.AddRootContext(this);
SceneLoader instance = SceneLoader.Instance;
Skill = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.TeamBoost);
DamageMult = (from active in Skill.Active
select(!active) ? 1f : PersistentSingleton <GameSettings> .Instance.TeamBoostMultiplier).TakeUntilDestroy(instance).ToReactiveProperty();
Active = (from active in Skill.Active
select(active)).TakeUntilDestroy(instance).ToReactiveProperty();
}
public AutoMineRunner()
{
SceneLoader instance = SceneLoader.Instance;
Skill = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.AutoMine);
DamageTriggered = (from _ in (from elapsed in m_elapsedTime
where elapsed > (double)(1f / PersistentSingleton <GameSettings> .Instance.AutoMinePerSecond)
select elapsed).Do(delegate
{
m_elapsedTime.Value -= 1f / PersistentSingleton <GameSettings> .Instance.AutoMinePerSecond;
})
select true).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
}
protected virtual void RPC_S2C_SkillCastShoot(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int skillID = stream.Read <int>();
Vector3 pos = stream.Read <Vector3>();
DefaultPosTarget target = new DefaultPosTarget(pos);
SkillRunner caster = Runner as SkillRunner;
if (null != caster && !caster.IsController)
{
caster.RunEffOnProxy(skillID, target);
}
}
public override void InitEquipment(SkillRunner runner, ItemAsset.ItemObject item)
{
base.InitEquipment(runner, item);
Transform[] bones = runner.GetComponentsInChildren <Transform>();
foreach (Transform tran in bones)
{
if (tran.name == "Bow_box")
{
mArrowBag.transform.parent = tran;
mArrowBag.transform.localPosition = Vector3.zero;
mArrowBag.transform.localScale = Vector3.one;
mArrowBag.transform.localRotation = Quaternion.identity;
break;
}
}
}
void RPC_S2C_SkillCastShoot(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int skillID;
Vector3 pos;
stream.TryRead <int>(out skillID);
stream.TryRead <Vector3>(out pos);
DefaultPosTarget target = new DefaultPosTarget(pos);
SkillRunner caster = Runner as SkillRunner;
if (null != caster)
{
caster.RunEffOnProxy(skillID, target);
}
}
private bool IsApplicable(RewardEnum type)
{
SkillRunner orCreateSkillRunner = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.TNT);
switch (type)
{
case RewardEnum.AddToRelics:
case RewardEnum.MultiplyCoins:
case RewardEnum.AddToGems:
case RewardEnum.AddToKeys:
return(true);
case RewardEnum.Bottle:
return(PlayerData.Instance.LifetimeCreatures.Value > 1);
case RewardEnum.AddToSkillAutoMine:
orCreateSkillRunner = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.AutoMine);
return(orCreateSkillRunner.CooldownSeconds.Value > 15 && !orCreateSkillRunner.Active.Value);
case RewardEnum.AddToSkillGoldfinger:
orCreateSkillRunner = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.Goldfinger);
return(orCreateSkillRunner.CooldownSeconds.Value > 15 && !orCreateSkillRunner.Active.Value);
case RewardEnum.AddToSkillTNT:
orCreateSkillRunner = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.TNT);
return(orCreateSkillRunner.CooldownSeconds.Value > 15 && !orCreateSkillRunner.Active.Value);
case RewardEnum.AddToSkillTapBoost:
orCreateSkillRunner = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.TapBoost);
return(orCreateSkillRunner.CooldownSeconds.Value > 15 && !orCreateSkillRunner.Active.Value);
case RewardEnum.AddToSkillTeamBoost:
orCreateSkillRunner = Singleton <SkillCollectionRunner> .Instance.GetOrCreateSkillRunner(SkillsEnum.TeamBoost);
return(orCreateSkillRunner.CooldownSeconds.Value > 15 && !orCreateSkillRunner.Active.Value);
default:
return(true);
}
}
internal override void ApplyHpChange(SkillRunner caster, float hpChange, float damagePercent, int type)
{
if (OnBuff(Buff_Sp.INVENSIBLE))
{
return;
}
if (!GameConfig.IsMultiMode)
{
float _defence = (float)defence / (float)(defence + 0);
if (caster != null)
{
float attack = caster.GetAttribute(Pathea.AttribType.Atk) * damagePercent + hpChange;
float damage = attack * (1 - _defence) * Random.Range(0.9f, 1.1f);
int damageType = type == 0 ? AiDamageTypeData.GetDamageType(caster) : type;
damage *= AiDamageTypeData.GetDamageScale(damageType, defenceType);
//Debug.Log(caster + " attack " + this.gameObject + (int)damage + " hp");
if (caster.gameObject.Equals(this.gameObject))
{
ApplyDamage(Mathf.CeilToInt(damage));
}
else
{
ApplyDamage(caster.transform, Mathf.CeilToInt(damage));
}
}
else
{
float attack = hpChange;
float damage = attack * (1 - _defence) * Random.Range(0.9f, 1.1f);
ApplyDamage(Mathf.CeilToInt(damage));
}
}
}
void RPC_S2C_SkillCast(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int _skillID;
uLink.NetworkViewID _viewID;
stream.TryRead <int>(out _skillID);
stream.TryRead <uLink.NetworkViewID>(out _viewID);
SkillRunner caster = Runner as SkillRunner;
if (null != caster)
{
ISkillTarget target = null;
uLink.NetworkView view = uLink.NetworkView.Find(_viewID);
if (null != view)
{
NetworkInterface network = view.GetComponent <NetworkInterface>();
target = (null == network) ? null : network.Runner;
}
caster.RunEffOnProxy(_skillID, target);
}
}
//float FoodCheckInterval;
void Awake()
{
mActiveRules = new List <int>();
mRulesDecreaseStackCount = new Dictionary <int, float>();
mIndexList = new List <int>();
mPropertys = new Dictionary <int, float>();
mPropertyMaxs = new Dictionary <int, float>();
if (mRules == null)
{
mRules = new List <int>();
}
foreach (int id in mRules)
{
AddRule(id);
}
mSkillRunner = GetComponent <SkillRunner>();
//FoodCheckInterval = 1;
// enabled = false;
}
internal override void ApplyHpChange(SkillRunner caster, float hpChange, float damagePercent, int type)
{
}
protected virtual EffSkillInstance CostSkill(SkillRunner coster, int id, ISkillTarget target)
{
return(coster.RunEff(id, target));
}
private string GetPrefabPath()
{
SkillRunner skillRunner = (SkillRunner)Singleton <PropertyManager> .Instance.GetContext("SkillRunner", base.transform);
return("UI/SkillItemProfiles/SkillItem." + skillRunner.Skill);
}
public void CastDamageSkill(Collider other)
{
if (emitRunner == null || other == null)
{
return;
}
VFVoxelChunkGo chunk = other.GetComponent <VFVoxelChunkGo>();
B45ChunkGo buildChunk = other.GetComponent <B45ChunkGo>();
if (chunk != null || null != buildChunk)
{
EffSkill skillData = EffSkill.s_tblEffSkills.Find(iterSkill1 => EffSkill.MatchId(iterSkill1, damageSkillID));
if (skillData.m_scopeOfSkill != null)
{
RunEff(damageSkillID, null);
}
else
{
RunEff(damageSkillID, new DefaultPosTarget(transform.position));
}
}
else
{
if (other != null)
{
int emitHarm = AiUtil.GetHarm(emitRunner.gameObject);
if (GameConfig.IsMultiMode)
{
SkillRunner obj = VCUtils.GetComponentOrOnParent <SkillRunner>(other.gameObject);
if (null == obj)
{
return;
}
int targetHarm = AiUtil.GetHarm(obj.gameObject);
if (AiHarmData.GetHarmValue(emitHarm, targetHarm) == 0)
{
return;
}
}
else
{
int targetHarm = AiUtil.GetHarm(other.gameObject);
if (AiHarmData.GetHarmValue(emitHarm, targetHarm) == 0)
{
return;
}
}
}
EffSkill data = EffSkill.s_tblEffSkills.Find(iterSkill1 => EffSkill.MatchId(iterSkill1, damageSkillID));
if (data != null)
{
if (data.m_scopeOfSkill != null)
{
RunEff(damageSkillID, null);
}
else
{
SkillRunner runner = VCUtils.GetComponentOrOnParent <SkillRunner>(other.gameObject);
if (runner != null)
{
RunEff(damageSkillID, runner);
}
}
}
}
}
internal override List <ISkillTarget> GetTargetlistInScope(EffScope scope, int targetMask, ISkillTarget target)
{
List <ISkillTarget> targetList = new List <ISkillTarget>();
if (emitRunner == null)
{
return(targetList);
}
Collider[] cs = Physics.OverlapSphere(transform.position, scope.m_radius);
List <Transform> transforms = new List <Transform>();
foreach (Collider item in cs)
{
if (item.isTrigger)
{
continue;
}
if (!transforms.Contains(item.transform) &&
!item.gameObject.Equals(this.gameObject) &&
!item.gameObject.Equals(emitRunner.gameObject))
{
transforms.Add(item.transform);
}
Transform root = item.transform;
CreationSkillRunner creation = VCUtils.GetComponentOrOnParent <CreationSkillRunner>(root.gameObject);
if (creation != null)
{
if (!transforms.Contains(creation.transform))
{
transforms.Add(creation.transform);
}
}
}
foreach (Transform tr in transforms)
{
if (tr == null || emitTransform == null)
{
continue;
}
float cosAngle = AiMath.Dot(emitTransform, tr);
float angle = Mathf.Acos(cosAngle) * Mathf.Rad2Deg;
int emitHarm = AiUtil.GetHarm(emitRunner.gameObject);
if (GameConfig.IsMultiMode)
{
SkillRunner obj = tr.GetComponent <SkillRunner>();
if (null == obj)
{
continue;
}
int targetHarm = AiUtil.GetHarm(obj.gameObject);
if (AiHarmData.GetHarmValue(emitHarm, targetHarm) == 0)
{
continue;
}
}
else
{
int targetHarm = AiUtil.GetHarm(tr.gameObject);
if (AiHarmData.GetHarmValue(emitHarm, targetHarm) == 0)
{
continue;
}
}
Ray rayStart = new Ray(transform.position, tr.position - transform.position);
float distance = Vector3.Distance(transform.position, tr.position);
if (Physics.Raycast(rayStart, distance,
AiUtil.groundedLayer | AiUtil.obstructLayer))
{
continue;
}
if (angle > scope.m_degEnd || angle < scope.m_degStart)
{
continue;
}
SkillRunner runner = tr.GetComponent <SkillRunner>();
if (runner == null)
{
runner = VCUtils.GetComponentOrOnParent <SkillRunner>(tr.gameObject);
}
if (runner != null && !targetList.Contains(runner))
{
targetList.Add(runner);
}
}
return(targetList);
}
public void SetupTrajectory(SkillRunner caster, Transform emit, ISkillTarget target)
{
//mTrajectory = GetComponent<Trajectory>();
//if (mTrajectory == null)
// return;
//mTrajectory.emitter = caster != null ? caster.transform : null;
//if (mTrajectory is TRRay)
//{
// (mTrajectory as TRRay).Emit(emit.forward);
//}
//else if (mTrajectory is TRParabola)
//{
// (mTrajectory as TRParabola).Emit(GetShootPosition(target));
//}
//else if (mTrajectory is TRRaycast)
//{
// (mTrajectory as TRRaycast).Emit(emit);
//}
//else if (mTrajectory is TRTrack)
//{
// (mTrajectory as TRTrack).Emit(target);
//}
//else if (mTrajectory is TRMultiPara)
//{
// (mTrajectory as TRMultiPara).Emit(target);
//}
//else if (mTrajectory is TRStraight)
//{
// (mTrajectory as TRStraight).Emit(GetShootPosition(target));
//}
//else if (mTrajectory is TRMultiImpulse)
//{
// (mTrajectory as TRMultiImpulse).Emit(GetShootPosition(target), emit.forward, projectileIndex);
//}
//else if (mTrajectory is TRImpulse)
//{
// (mTrajectory as TRImpulse).Emit(GetShootPosition(target), emit.forward);
//}
//else if (mTrajectory is TRBind)
//{
// (mTrajectory as TRBind).Emit(emit);
//}
//else if (mTrajectory is TRSiloMissile)
//{
// (mTrajectory as TRSiloMissile).Emit(target, emit.forward, projectileIndex, random1);
//}
//else if (mTrajectory is TRGatling)
//{
// (mTrajectory as TRGatling).Emit(emit.forward);
//}
//else if (mTrajectory is TRVLS)
//{
// (mTrajectory as TRVLS).Emit(target);
//}
//else if (mTrajectory is TRTrackPhscs)
//{
// (mTrajectory as TRTrackPhscs).Emit(target, emit.forward);
//}
//else if (mTrajectory is TRMotorFlame)
//{
// (mTrajectory as TRMotorFlame).Emit();
//}
//else if (mTrajectory is TRMultiR04_l)
//{
// (mTrajectory as TRMultiR04_l).Emit(projectileIndex);
//}
//else if (mTrajectory is TRFlare)
//{
// (mTrajectory as TRFlare).Emit(GetShootPosition(target));
//}
}
internal override List <ISkillTarget> GetTargetlistInScope(EffScope scope, int targetMask, ISkillTarget target)
{
//if (target == null) return null;
List <ISkillTarget> targetList = new List <ISkillTarget>();
Vector3 scopeCenter = transform.position;
if (scope.m_centerType == -1)
{
scopeCenter = transform.position;
}
if (scope.m_centerType == -2)
{
scopeCenter = center;
}
Collider[] colliders = Physics.OverlapSphere(scopeCenter, scope.m_radius + radius, 0);
// Edit by zhouxun
// we need check the parent gameobject also.
foreach (Collider c in colliders)
{
if (c.isTrigger || c.gameObject == this.gameObject)
{
continue;
}
if (GameConfig.IsMultiMode)
{
SkillRunner obj = VCUtils.GetComponentOrOnParent <SkillRunner>(c.gameObject);
if (null == obj)
{
continue;
}
int targetHarm = AiUtil.GetHarm(obj.gameObject);
if (AiHarmData.GetHarmValue(harm, targetHarm) == 0)
{
continue;
}
}
else
{
int targetHarm = AiUtil.GetHarm(c.gameObject);
if (AiHarmData.GetHarmValue(harm, targetHarm) == 0)
{
continue;
}
}
float cosAngle = AiMath.Dot(transform, c.transform);
float angle = Mathf.Acos(cosAngle) * Mathf.Rad2Deg;
if (angle > scope.m_degEnd || angle < scope.m_degStart)
{
continue;
}
SkillRunner runner = VCUtils.GetComponentOrOnParent <SkillRunner>(c.gameObject);
if (runner != null && (runner != this) && !targetList.Contains(runner))
{
targetList.Add(runner);
}
}
return(targetList);
}
//internal abstract Get
// Apply changed of properties directly to
internal override void ApplyDistRepel(SkillRunner caster, float distRepel)
{
}
