// 添加状态aa
public void AddActionState(sdBaseState state)
{
if (state != null)
{
states[state.id] = state;
switch (state.id)
{
case 100: {
die = state;
} break;
case 101: {
idle = state;
} break;
case 102: {} break;
case 103: {
run = state;
run.bMoveState = true;
} break;
case 104: {
stun = state;
} break;
}
}
}
// 添加状态aa
public sdBaseState AddActionState(string str)
{
sdBaseState state = (sdBaseState)null; //CreateObject(str);
AddActionState(state);
return(state);
}
// 释放技能aa
public bool OnCastSkill(sdSkill s)
{
if (statePointer == die)
{
return(false);
}
if (statePointer == null)
{
return(false);
}
if (!sdGameLevel.instance.AutoMode && _gameActor == sdGameLevel.instance.mainChar)
{
JoyStickCastSkill(s);
}
if (statePointer.bPassive)
{
SwitchSkill(_gameActor, s);
sdBaseState state = s.GetFirstValidAction();
SwitchToState(_gameActor, state);
return(state != null);
}
else
{
return(statePointer.OnCastSkill(_gameActor, s));
}
}
public sdBaseState AddAction(sdGameActor actor, string str)
{
sdBaseState state = actor.logicTSM.AddActionState(str);
state.belongToSkill = this;
actionStateList.Add(state);
state.actionID = actionStateList.Count - 1;
return(state);
}
public sdTransitNode AddNode(string str, sdBaseState src, sdBaseState dest)
{
sdTransitNode node = AddNode(str);
node.fromState = src;
node.destState = dest;
src.transitPath.Add(node);
return(node);
}
// 摇杆模式下施放技能时辅助调整方向aa
protected void JoyStickCastSkill(sdSkill s)
{
// 翻滚技能不使用辅助施放aaa
if (s.id == 1002)
{
return;
}
// 自动选取朝向上的怪物aaaa
HeaderProto.ESkillObjType objType = 0;
if (statePointer.bPassive)
{
sdBaseState state = s.GetFirstValidAction();
objType = (HeaderProto.ESkillObjType)state.stateData["byTargetType"];
}
else
{
objType = (HeaderProto.ESkillObjType)statePointer.stateData["byTargetType"];
}
float xbias = 0.0f;
float ybias = 0.0f;
sdGameLevel.instance.mainCharMoveControl(out xbias, out ybias);
sdActorInterface actor = null;
bool bTurnDir = false;
// 释放技能前，检查下方向键方向范围内是否有目标，如果有就转向释放技能，没有就不转向aaa
if (Mathf.Abs(xbias) > 0.1f || Mathf.Abs(ybias) > 0.1f)
{
Vector3 worldDir = Vector3.right * xbias + Vector3.forward * ybias;
worldDir.y = 0.0f;
worldDir.Normalize();
actor = sdGameLevel.instance.actorMgr.FindNearestAngle(_gameActor, objType, worldDir, 5.0f, 80.0f);
if (actor != null)
{
//_gameActor._moveVector = worldDir;
_gameActor.TargetFaceDirection = worldDir;
bTurnDir = true;
}
}
// 在角色当前方向上寻找最小夹角的目标aaa
if (!bTurnDir)
{
actor = sdGameLevel.instance.actorMgr.FindNearestAngle(_gameActor, objType, _gameActor.GetDirection(), 5.0f, 180.0f);
if (actor != null)
{
Vector3 dir = actor.transform.position - _gameActor.transform.position;
dir.y = 0;
dir.Normalize();
_gameActor.TargetFaceDirection = dir;
}
}
}
// 强制终止当前状态aa
public void ForceStop()
{
sdBaseState next = GetCurrentPassiveState();
nextState = null;
if (statePointer != next)
{
SwitchSkill(_gameActor, next.belongToSkill);
SwitchToState(_gameActor, next);
}
}
public void end(sdGameActor _gameActor)
{
_enabled = false;
t = 0.0f;
if (targetSkill != null)
{
targetSkill.leave(_gameActor);
}
state = null;
targetSkill = null;
}
public sdBaseState AddAction(int id, Hashtable actionInfo)
{
string classname = actionInfo["ClassName"] as string;
sdBaseState state = (sdBaseState)sdTransitGraph.CreateObject(classname);
state.id = id;
state.belongToSkill = this;
state.bEnable = (int)actionInfo["Enable"] != 0;
actionStateList.Add(state);
state.actionID = actionStateList.Count - 1;
return(state);
}
public bool OnContinueSkill(sdGameActor _gameActor)
{
sdBaseState next = GetNextSkillAction();
if (next != null)
{
_gameActor.logicTSM.nextState = next;
return(true);
}
return(false);
}
// 技能动画表aa
protected void CreateSkill_Action(int job)
{
// 被动Action表aa
Hashtable passive = sdConfDataMgr.Instance().GetTable("passiveaction");
foreach (DictionaryEntry de1 in passive)
{
int id = int.Parse(de1.Key as string);
Hashtable animation = de1.Value as Hashtable;
sdBaseState passiveState = new sdBaseState();
passiveState.id = id;
passiveState.info = animation[job.ToString()] as string;
passiveState.name = animation["strName"] as string;
passiveState.bPassive = true;
logicTSM.AddActionState(passiveState);
}
// 主动Action表aa
skillTree = sdSkillTree.createSkillTree(this, job); //< 技能表aa
Hashtable lstAction = sdConfDataMgr.Instance().m_vecJobSkillAction[job];
if (lstAction != null)
{
skillIDRange range = sdConfDataMgr.Instance().m_JobSkillRange[job];
for (int index = range.min; index <= range.max; ++index)
{
foreach (DictionaryEntry de in lstAction)
{
int id = (int)de.Key;
if (id == index)
{
Hashtable action = (Hashtable)de.Value;
int pid = (int)action["ParentID"];
int skillid = pid / 100;
sdSkill s = skillTree.getSkill(skillid);
if (s == null)
{
continue;
}
sdBaseState state = s.AddAction(id, action);
logicTSM.AddActionState(state);
break;
}
}
}
}
sdTransitGraph.loadAndLinkActionState(this, job);
}
public void begin(sdGameActor _gameActor, sdBaseState action, float interval_, float triggerTime_)
{
if (_enabled)
{
if (targetSkill != action.belongToSkill)
{
end(_gameActor);
}
}
state = action;
targetSkill = state.belongToSkill;
_interval = interval_;
_triggerTime = triggerTime_;
begin();
}
public void StartTimer(sdGameActor _gameActor)
{
sdActionStateTimer timer = _gameActor.actionStateTimer;
if (stateData != null)
{
if (stateData.ContainsKey("SkillTimerInterval") &&
stateData.ContainsKey("SkillTimerTrigger"))
{
int _interval = (int)stateData["SkillTimerInterval"];
int _trigger = 0; //(int)stateData["SkillTimerTrigger"];
if (_interval == 0)
{
if (timer.targetSkill == belongToSkill)
{
timer.targetSkill = null;
timer.end(_gameActor);
}
return;
}
if (belongToSkill != null)
{
sdBaseState next = GetNextSkillAction();
if (next == null)
{
timer.end(_gameActor);
return;
}
}
float length = 0.0f;
if (aniState != null)
{
length = aniState.length;
}
timer.begin(_gameActor, this, length + _interval * 0.001f, _trigger * 0.001f);
return;
}
}
timer.end(_gameActor);
}
// 直接切换状态aa
protected void SwitchToState(sdGameActor _gameActor, sdBaseState destState)
{
//if(CheckMP(destState))
{
if (statePointer != null)
{
statePointer.Leave(_gameActor);
}
statePointer = destState;
if (statePointer != null)
{
statePointer.Enter(_gameActor);
}
}
}
public sdBaseState GetNextSkillAction()
{
if (belongToSkill == null)
{
return(null);
}
int index = -1;
for (int i = 0; i < belongToSkill.actionStateList.Count; i++)
{
if (belongToSkill.actionStateList[i] == this)
{
index = i + 1;
break;
}
}
if (index == -1)
{
return(null);
}
for (int i = index; i < belongToSkill.actionStateList.Count; i++)
{
sdBaseState nextContinueState = belongToSkill.actionStateList[i];
//当前这个连招是否有效---
if (nextContinueState.bEnable)
{
return(nextContinueState);
}
}
if (belongToSkill.bUnLimitedAction)
{
for (int i = 0; i < belongToSkill.actionStateList.Count; i++)
{
sdBaseState nextContinueState = belongToSkill.actionStateList[i];
//当前这个连招是否有效---
if (nextContinueState.bEnable)
{
return(nextContinueState);
}
}
}
return(null);
}
public virtual float getActionInterval(sdGameActor _gameActor, int index)
{
float ft = 0.0f;
if (_gameActor != null && index < actionStateList.Count)
{
sdBaseState baseState = actionStateList[index] as sdBaseState;
//<
if (baseState != null && _gameActor.AnimController != null)
{
AnimationClip clip = _gameActor.AnimController.GetClip(baseState.info);
if (clip != null)
{
ft = clip.length;
}
}
}
return(ft);
}
// 初始化aa
public new bool init(sdGameActorCreateInfo kInfo)
{
base.init(kInfo);
// 设置角色初始朝向aa
mFaceDirection = transform.rotation * Vector3.forward;
// 初始化技能树aas
CreateSkill_Action(kInfo.mJob);
// 初始化基本属性表aa
mBaseProperty = sdConfDataMgr.CloneHashTable(sdPVPManager.Instance.PVPBaseProperty);
Property = sdConfDataMgr.CloneHashTable(sdPVPManager.Instance.PVPBaseProperty);
// 每次进图满血满蓝aa
if (Property.ContainsKey("HP") && Property.ContainsKey("MaxHP"))
{
Property["HP"] = Property["MaxHP"];
}
if (Property.ContainsKey("SP") && Property.ContainsKey("MaxSP"))
{
Property["SP"] = Property["MaxSP"];
}
// 初始化角色装备表aa
SetItemInfo(sdPVPManager.Instance.PVPItemProperty);
// 初始化角色技能表aa
SetSkillInfo(sdPVPManager.Instance.PVPSkillProperty);
// 宠物战队Buffaa
List <int> kBuffList = sdPVPManager.Instance.GetPetGroupBuff(this);
if (kBuffList != null)
{
foreach (int iBuffId in kBuffList)
{
AddBuff(iBuffId, 0, this);
}
}
// 加载角色动画aa
LoadAnimationFile(kInfo.mJob);
// 自动战斗系统aa
{
PVPAutoFight kPVPAutoFight = new PVPAutoFight();
sdSkill kSkill = skillTree.getSkill(1001);
if (kSkill != null)
{
sdBaseState kState = kSkill.actionStateList[0];
int iCastDistance = (int)kState.stateData["CastDistance"];
kPVPAutoFight.BattleDistance = (iCastDistance) * 0.001f;
}
mAutoFight = kPVPAutoFight;
mAutoFight.SetActor(this);
}
return(true);
}
public virtual void OnAttack(sdGameActor _gameActor, sdBaseState state)
{
}
public virtual void OnHitBegin(sdGameActor _gameActor, sdActorInterface monster, sdBaseState state, int index, object userdata)
{
}
public virtual void OnHitEnd(sdActorInterface _gameActor, sdActorInterface monster, sdBaseState state, int damage, int index, object userdata)
{
}
public virtual void OnActionStateLeave(sdGameActor _gameActor, sdBaseState state)
{
}
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);
}
// 鍔犺浇鎶鑳藉姩鐢昏〃aa
// 1.琚?姩Action琛╝a
// 2.鎶鑳戒俊鎭?〃aa
// 3.鎶鑳紸ction琛╝a
protected void CreateSkill_Action(ulong ulTemplateID)
{
{
sdBaseState kPassiveDeathState = new sdBaseState();
kPassiveDeathState.id = 100;
kPassiveDeathState.info = "death01";
kPassiveDeathState.name = "death01";
kPassiveDeathState.bPassive = true;
sdBaseState kPassiveIdleState = new sdBaseState();
kPassiveIdleState.id = 101;
kPassiveIdleState.info = "idle01";
kPassiveIdleState.name = "idle01";
kPassiveIdleState.bPassive = true;
sdBaseState kPassiveKnockState = new sdBaseState();
kPassiveKnockState.id = 102;
kPassiveKnockState.info = "death01";
kPassiveKnockState.name = "death01";
kPassiveKnockState.bPassive = true;
sdBaseState kPassiveWalkState = new sdBaseState();
kPassiveWalkState.id = 103;
kPassiveWalkState.info = "walk01";
kPassiveWalkState.name = "walk01";
kPassiveWalkState.bPassive = true;
sdBaseState kPassiveStunState = new sdBaseState();
kPassiveStunState.id = 104;
kPassiveStunState.info = "stun01";
kPassiveStunState.name = "stun01";
kPassiveStunState.bPassive = true;
logicTSM.AddActionState(kPassiveDeathState);
logicTSM.AddActionState(kPassiveIdleState);
logicTSM.AddActionState(kPassiveKnockState);
logicTSM.AddActionState(kPassiveWalkState);
logicTSM.AddActionState(kPassiveStunState);
}
skillTree = new sdSkillTree();
// 鏅?氭敾鍑绘妧鑳絘a
{
int iDfSkillId = (int)Property["DfSkill"];
Hashtable kSkillInfo = sdConfDataMgr.Instance().m_MonsterSkillInfo[iDfSkillId] as Hashtable;
Hashtable kSkillAction = sdConfDataMgr.Instance().m_MonsterSkillAction[iDfSkillId] as Hashtable;
if (kSkillInfo != null)
{
int iTemplateId = (int)kSkillInfo["dwTemplateID"];
int iPassive = (int)kSkillInfo["byIsPassive"];
string name = kSkillInfo["strName"] as string;
sdSkill kSkill = new sdSkill(name, iPassive == 1, iTemplateId);
skillTree.Add(kSkill);
kSkill.skillProperty = kSkillInfo;
if (kSkillAction != null)
{
sdBaseState kState = kSkill.AddAction(iDfSkillId, kSkillAction);
logicTSM.AddActionState(kState);
kState.SetInfo(kSkillAction, this);
}
}
}
// 瀹犵墿澶ф嫑aa
if (GetActorType() == ActorType.AT_Pet)
{
int iSpSkillId = (int)Property["SpSkill"];
Hashtable kSkillInfo = sdConfDataMgr.Instance().m_MonsterSkillInfo[iSpSkillId] as Hashtable;
Hashtable kSkillAction = sdConfDataMgr.Instance().m_MonsterSkillAction[iSpSkillId] as Hashtable;
if (kSkillInfo != null)
{
int iTemplateId = (int)kSkillInfo["dwTemplateID"];
int iPassive = (int)kSkillInfo["byIsPassive"];
string name = kSkillInfo["strName"] as string;
sdSkill kSkill = new sdSkill(name, iPassive == 1, iSpSkillId);
skillTree.Add(kSkill);
kSkill.skillProperty = kSkillInfo;
if (kSkillAction != null)
{
sdBaseState kState = kSkill.AddAction(iSpSkillId, kSkillAction);
logicTSM.AddActionState(kState);
kState.SetInfo(kSkillAction, this);
}
}
}
// 瀹犵墿鍜屾?墿瑙﹀彂鎶鑳絘a
{
int iSkillNum = 10;
if (GetActorType() == ActorType.AT_Pet)
{
iSkillNum = 4;
}
for (int iIndex = 1; iIndex <= iSkillNum; ++iIndex)
{
string kSkillKey = "Skill" + iIndex.ToString();
int iSkillId = (int)Property[kSkillKey];
if (iSkillId > 0)
{
Hashtable kSkillInfo = sdConfDataMgr.Instance().m_MonsterSkillInfo[iSkillId] as Hashtable;
Hashtable kSkillAction = sdConfDataMgr.Instance().m_MonsterSkillAction[iSkillId] as Hashtable;
if (kSkillInfo != null)
{
int iTemplateId = (int)kSkillInfo["dwTemplateID"];
int iPassive = (int)kSkillInfo["byIsPassive"];
string name = kSkillInfo["strName"] as string;
sdSkill kSkill = new sdSkill(name, iPassive == 1, iSkillId);
skillTree.Add(kSkill);
kSkill.skillProperty = kSkillInfo;
if (kSkillAction != null)
{
sdBaseState kState = kSkill.AddAction(iSkillId, kSkillAction);
logicTSM.AddActionState(kState);
kState.SetInfo(kSkillAction, this);
}
}
}
}
}
}
// 更新触发状态(继承自sdBehaviourState)aa
public override void UpdateState()
{
if (mIsInState != true)
{
return;
}
if (mCurrentCount == 0)
{
return;
}
mCurrentDelayTime -= Time.deltaTime;
if (mCurrentDelayTime <= 0.0f)
{
// 当前技能不存在则随机一个技能aa
if (mCurrentSkillID == -1)
{
mCurrentSkillID = RandomSkill();
}
// 检查技能范围,尝试释放技能aa
bool bCastSkill = false;
if (mCurrentSkillID > 0)
{
MonsterAutoFight kMonsterAutoFight = mBehaviourAdvancedState.MonsterAutoFightComponent;
sdGameMonster kMonster = kMonsterAutoFight.Monster;
if (mDetectDistance)
{
sdSkill kSkill = kMonster.skillTree.getSkill(mCurrentSkillID);
if (kSkill != null)
{
sdBaseState kState = kSkill.actionStateList[0];
float fDistance = (int)kState.stateData["CastDistance"] * 0.001f;
HeaderProto.ESkillObjType eTergetType = (HeaderProto.ESkillObjType)kState.stateData["byTargetType"];
float fCurrentDistance = 0.0f;
sdBehaviourStateBlock kBehaviourStateBlock = mBehaviourAdvancedState.BehaviourStateBlock;
if (eTergetType == HeaderProto.ESkillObjType.SKILL_OBJ_ENEMY)
{
fCurrentDistance = kBehaviourStateBlock.UpdateDistanceOfNearestEnemy(mBehaviourAdvancedState);
}
else
{
fCurrentDistance = kBehaviourStateBlock.UpdateDistanceOfNearestFriend(mBehaviourAdvancedState);
}
if (fCurrentDistance < fDistance)
{
kMonster.CastSkill(mCurrentSkillID);
bCastSkill = true;
}
}
}
else
{
kMonster.CastSkill(mCurrentSkillID);
bCastSkill = true;
}
}
// 释放技能成功则延迟一个mIntervalTime,否则仅仅延迟2s检查一次直到释放成功aa
if (bCastSkill)
{
mCurrentSkillID = -1;
mCurrentDelayTime = mIntervalTime;
--mCurrentCount;
}
else
{
mCurrentDelayTime = 2.0f;
}
}
}
// 初始化aa
public new bool init(sdGameActorCreateInfo kInfo)
{
base.init(kInfo);
// 设置角色初始朝向aa
mFaceDirection = transform.rotation * Vector3.forward;
// 初始化技能树aa
CreateSkill_Action(kInfo.mJob);
// 初始化角色属性aa
if (sdGlobalDatabase.Instance.globalData != null)
{
// 属性表
if (Property == null)
{
Property = sdConfDataMgr.CloneHashTable(sdGlobalDatabase.Instance.globalData["MainCharBaseProp"] as Hashtable);
}
// 每次进图就满血满蓝aa
if (Property.ContainsKey("HP") && Property.ContainsKey("MaxHP"))
{
Property["HP"] = Property["MaxHP"];
}
if (Property.ContainsKey("SP") && Property.ContainsKey("MaxSP"))
{
Property["SP"] = Property["MaxSP"];
}
//
AddSuitBuff();
// 设置到UIaa
RefreshProp();
//
if (sdConfDataMgr.Instance().skilliconAtlas == null)
{
int job = int.Parse(Property["BaseJob"].ToString());
sdConfDataMgr.Instance().LoadSkillIcon(job);
}
// 换装aa
if (sdGlobalDatabase.Instance.globalData.Contains("MainCharItemInfo"))
{
SetItemInfo(sdGlobalDatabase.Instance.globalData["MainCharItemInfo"] as Hashtable);
}
// 技能aa
if (sdGlobalDatabase.Instance.globalData.Contains("MainCharSkillInfo"))
{
SetSkillInfo(sdGlobalDatabase.Instance.globalData["MainCharSkillInfo"] as Hashtable);
}
// 初始Buffaa
if (sdGlobalDatabase.Instance.globalData.Contains("InitBuff"))
{
int[] buffArray = (int[])sdGlobalDatabase.Instance.globalData["InitBuff"];
if (buffArray != null)
{
foreach (int id in buffArray)
{
AddBuff(id, 0, this);
}
}
sdGlobalDatabase.Instance.globalData["InitBuff"] = null;
}
// 宠物战队Buffaa
List <int> kBuffList = sdNewPetMgr.Instance.GetPetGroupBuff(this);
if (kBuffList != null)
{
foreach (int iBuffId in kBuffList)
{
AddBuff(iBuffId, 0, this);
}
}
}
// 加载角色动画aa
LoadAnimationFile(kInfo.mJob);
// 初始化个体AI参数(自动战斗系统)aa
FingerControl kFingerControl = sdGameLevel.instance.GetFingerControl();
if (kFingerControl != null)
{
mAutoFight = kFingerControl;
mAutoFight.NotifyChangeTarget += NotifyBattleSystemChangeTarget;
sdSkill kSkill = skillTree.getSkill(1001);
if (kSkill != null)
{
sdBaseState kState = kSkill.actionStateList[0];
int iCastDistance = (int)kState.stateData["CastDistance"];
mAutoFight.BattleDistance = (iCastDistance) * 0.001f;
}
}
sdGuideMgr.Instance.Init(Property["Name"].ToString().Trim('\0'));
// 初始化群体AI参数aa
sdBehaviourNode kBehaviourNode = sdBehaviourManager.GetSingleton().GetBehaviourNode(1);
if (kBehaviourNode != null)
{
kBehaviourNode.AddActor(this);
}
return(true);
}
// 更新aa
public void UpdateSelf()
{
if (statePointer != null)
{
statePointer.Update(_gameActor);
if (_gameActor.GetCurrentHP() <= 0)
{
nextState = null;
if (statePointer != die)
{
SwitchSkill(_gameActor, null);
SwitchToState(_gameActor, die);
}
return;
}
else if (_gameActor.CheckDebuffState(HeaderProto.ECreatureActionState.CREATURE_ACTION_STATE_STUN) ||
_gameActor.CheckDebuffState(HeaderProto.ECreatureActionState.CREATURE_ACTION_STATE_HOLD))
{
nextState = null;
sdBaseState switchState = stun;
if (stun == null)
{
switchState = idle;
}
if (statePointer != switchState)
{
SwitchSkill(_gameActor, null);
SwitchToState(_gameActor, switchState);
}
return;
}
else if (_gameActor.CheckDebuffState(HeaderProto.ECreatureActionState.CREATURE_ACTION_STATE_IDLE))
{
nextState = null;
sdBaseState switchState = idle;
if (idle == null)
{
switchState = idle;
}
if (statePointer != switchState)
{
SwitchSkill(_gameActor, null);
SwitchToState(_gameActor, switchState);
}
return;
}
if (!statePointer.bPassive)
{
if (IsAnimLoop())
{
//判断是否死亡..
if (GetCurrentPassiveState() == die)
{
nextState = null;
SwitchToState(_gameActor, die);
return;
}
sdBaseState next = nextState;
nextState = null;
if (next != null && next != statePointer)
{
SwitchSkill(_gameActor, next.belongToSkill);
SwitchToState(_gameActor, next);
}
}
else if (IsAnimPlayOver())
{
sdBaseState next = nextState;
if (next == null)
{
next = GetCurrentPassiveState();
}
nextState = null;
SwitchSkill(_gameActor, next.belongToSkill);
SwitchToState(_gameActor, next);
}
else
{
if (nextState != null)
{
if (nextState.belongToSkill.id == 1002 && statePointer.bAllHitPointDone)
{
sdBaseState next = nextState;
nextState = null;
SwitchSkill(_gameActor, next.belongToSkill);
SwitchToState(_gameActor, next);
}
}
}
}
else
{
sdBaseState next = nextState;
if (next == null)
{
next = GetCurrentPassiveState();
}
nextState = null;
if (statePointer != next)
{
SwitchSkill(_gameActor, next.belongToSkill);
SwitchToState(_gameActor, next);
}
}
}
else
{
if (_gameActor.AnimController == null)
{
return;
}
sdBaseState next = nextState;
if (next == null)
{
next = GetCurrentPassiveState();
}
if (!next.IsAnimValid(_gameActor))
{
return;
}
nextState = null;
SwitchToState(_gameActor, next);
}
}
//
protected override void Start()
{
base.Start();
// 鑾峰彇妯″瀷鍙婃帶鍒跺櫒淇℃伅aa
GameObject rootRenderNode = transform.FindChild("@RenderNode").gameObject;
gatherRenderNodesInfo(rootRenderNode);
gatherMeshes(rootRenderNode);
GatherMeshShaders();
renderNode = rootRenderNode;
renderNode.SetActive(false);
for (int k = 0; k < renderNode.transform.childCount; ++k)
{
Transform kChildNode = renderNode.transform.GetChild(k);
if (kChildNode.name.Equals("Bip01"))
{
boneRoot = kChildNode.gameObject;
break;
}
}
mAnimController = renderNode.GetComponent <Animation>();
// mAnimController.enabled = false;
mMotionController = this.gameObject.GetComponent <CharacterController>();
mMotionController.enabled = false;
mNavAgent = this.gameObject.GetComponent <NavMeshAgent>();
mNavAgent.enabled = false;
mSelfAudioSource = this.gameObject.GetComponent <AudioSource>();
// mSelfAudioSource.enabled = false;
// 鍦烘櫙淇℃伅aa
mMainCamera = sdGameLevel.instance.mainCamera.GetComponent <Camera>();
mTuituLogic = sdGameLevel.instance.tuiTuLogic;
// 鍔犺浇鎬?墿灞炴ц〃(鍩虹?灞炴﹁aa
if (ActorType.AT_Pet == GetActorType())
{
Hashtable kTable = sdNewPetMgr.Instance.GetPetPropertyFromDBID(mDBID);
Property = sdConfDataMgr.CloneHashTable(kTable);
}
else
{
Hashtable kMonsterProperty = sdConfDataMgr.Instance().GetTable("MonsterProperty");
if (Application.platform == RuntimePlatform.WindowsEditor)
{
if (!kMonsterProperty.ContainsKey(templateId))
{
Debug.LogError("monster templateID error=" + templateId);
}
}
Hashtable kTable = kMonsterProperty[templateId] as Hashtable;
Property = sdConfDataMgr.CloneHashTable(kTable);
//娣辨笂BOSS闇瑕佺壒娈婂?鐞嗚?閲庬.
if (isLapBoss && !sdGameLevel.instance.testMode)
{
if (sdActGameMgr.Instance.m_uuLapBossLastBlood > 0)
{
Property["HP"] = (int)sdActGameMgr.Instance.m_uuLapBossLastBlood;
}
else
{
Property["HP"] = (int)sdActGameMgr.Instance.m_uuWorldBossLastBlood;
}
}
else
{
Property["HP"] = Property["MaxHP"]; //< 淇??琛閲庣鍙?湁鎬?墿闇瑕佷慨姝㈣aa
}
}
Property["MaxSP"] = 100; //< 淇??鏈楂樻硶鍔涘糰a
Property["SP"] = Property["MaxSP"]; //< 淇??娉曞姏鍊糰a
// 鍒濆?鍖栬?鑹叉秷澶辨椂闂碼a
mDisappeared = false;
mDisapearTime = (int)Property["DisappearTime"] / 1000.0f;
//
m_summonInfo = sdConfDataMgr.CloneHashTable(sdConfDataMgr.Instance().m_BaseSummon);
m_SkillEffect = sdConfDataMgr.CloneHashTable(sdConfDataMgr.Instance().m_BaseSkillEffect);
// 鍒濆?鍖栬?鏉?a
LoadHPUI();
// 鍒濆?鍖栭変腑鐩?爣鐗规晥aa
//if (GetActorType() == ActorType.AT_Pet)
// LoadTargetEffect();
// 鍒涘缓鎶鑳絘a
CreateSkill_Action((ulong)templateId);
// 鍒濆?鍖栦釜浣揂I鍙傛暟aa
if (ActorType.AT_Pet == GetActorType())
{
if (mAnimController != null)
{
mAnimController.cullingType = AnimationCullingType.AlwaysAnimate;
}
PetAutoFight kPetAutoFight = new PetAutoFight();
kPetAutoFight.FollowDistance = ((int)Property["FollowDistance"]) / 1000.0f;
kPetAutoFight.BattleFollowDistance = ((int)Property["BattleFollowDistance"]) / 1000.0f;
kPetAutoFight.EyeDistance = ((int)Property["EyeSize"]) / 1000.0f;
kPetAutoFight.Enable = useAI;
kPetAutoFight.AutoRetreat = (int)(Property["Retreat"]) != 0;
kPetAutoFight.RetreatDetectInterval = ((int)Property["RetreatDetectInterval"]) / 1000.0f;
kPetAutoFight.RetreatDetectMinDistance = ((int)Property["RetreatDetectMinDistance"]) / 1000.0f;
kPetAutoFight.RetreatElapseTime = ((int)Property["RetreatElapseTime"]) / 1000.0f;
kPetAutoFight.NotifyChangeTarget += NotifyBattleSystemChangeTarget;
sdSkill kSkill = skillTree.getSkill(1001);
if (kSkill != null)
{
sdBaseState kState = kSkill.actionStateList[0];
int iCastDistance = (int)kState.stateData["CastDistance"];
kPetAutoFight.BattleDistance = (iCastDistance) * 0.001f;
}
mAutoFight = kPetAutoFight;
mAutoFight.SetActor(this);
}
else
{
MonsterAutoFight kMonsterAutoFight = new MonsterAutoFight();
kMonsterAutoFight.EyeDistance = ((int)Property["EyeSize"]) / 1000.0f;
kMonsterAutoFight.ChaseDistance = ((int)Property["ChaseSize"]) / 1000.0f;
kMonsterAutoFight.Enable = useAI;
kMonsterAutoFight.NotifyChangeTarget += NotifyBattleSystemChangeTarget;
sdSkill kSkill = skillTree.getSkill(1001);
if (kSkill != null)
{
sdBaseState kState = kSkill.actionStateList[0];
int iCastDistance = (int)kState.stateData["CastDistance"];
kMonsterAutoFight.BattleDistance = (iCastDistance) * 0.001f;
}
mAutoFight = kMonsterAutoFight;
mAutoFight.SetActor(this);
}
// 鍒濆?鍖栫兢浣揂I鍙傛暟aa
if (ActorType.AT_Pet == GetActorType())
{
sdBehaviourNode kBehaviourNode = sdBehaviourManager.GetSingleton().GetBehaviourNode(1);
if (kBehaviourNode != null)
{
kBehaviourNode.AddActor(this);
}
}
//
LoadShadow();
}
