public void RemoveBuffAttribute(ObjectData objData, Buff buff)
{
var attributeData = objData.GetData <ActorAttributeData>();
var actorData = objData.GetData <ActorData>();
var actorInfo = WorldManager.Instance.ActorConfig.Get(actorData.actorId);
var value = 0;
if (buff.currentCount < buff.value.Length)
{
value = buff.value[buff.currentCount];
}
else
{
value = buff.value[0];
}
switch (buff.buffType)
{
case BuffType.ChangeHpMax:
{
var extraHp = (float)value / (actorInfo.Value.attributeInfo.hp + attributeData.extraAttribute.hpMax) * attributeData.baseAttribute.hp;
baseAttribute.hp -= Mathf.FloorToInt(extraHp);
extraAttribute.hpMax -= value;
}
break;
}
}
void DoSkill(SkillInfo skill, ObjectData objData, Physics2DData physics2DData, ActorData actorData)
{
switch (skill.skillType)
{
case SkillType.Fly:
var flyData = objData.GetData <ActorFlyData>();
flyData.duration = skill.duration;
flyData.currentDuration = 0;
objData.SetDirty(flyData, physics2DData, actorData);
break;
case SkillType.Dash:
var dashData = objData.GetData <ActorDashData>();
dashData.duration = skill.duration;
dashData.currentDuration = 0;
objData.SetDirty(dashData, physics2DData, actorData);
break;
case SkillType.Stress:
var stressData = objData.GetData <ActorStressData>();
stressData.duration = skill.duration;
stressData.currentDuration = 0;
objData.SetDirty(stressData, physics2DData, actorData);
break;
}
}
public void AddBuffAttribute(ObjectData objData, Buff buff)
{
var worldMgr = WorldManager.Instance;
var attributeData = objData.GetData <ActorAttributeData>();
var actorData = objData.GetData <ActorData>();
var hurtData = objData.GetData <ResourceHurtData>();
var value = 0;
if (buff.currentCount < buff.value.Length)
{
value = buff.value[buff.currentCount];
}
else if (buff.value.Length > 0)
{
value = buff.value[0];
}
switch (buff.buffType)
{
case BuffType.NormalChangeHp:
{
var hurt = buff.valueType == BuffValueType.Normal ? value : Mathf.FloorToInt(attributeData.baseAttribute.hp * value * Constant.PERCENT);
if (hurt < 0)
{
hurt += attributeData.baseAttribute.def;
}
baseAttribute.hp += hurt;
}
break;
case BuffType.ChangeHpMax:
{
var actorInfo = worldMgr.ActorConfig.Get(actorData.actorId);
extraAttribute.hpMax += value;
var extraHp = (float)value / (actorInfo.Value.attributeInfo.hp + attributeData.extraAttribute.hpMax) * attributeData.baseAttribute.hp;
baseAttribute.hp += Mathf.FloorToInt(extraHp);
}
break;
case BuffType.AddForce:
{
var hurt = buff.forceValue;
if (hurtData.attackObjDataId != 0)
{
var attackObjData = worldMgr.GetObjectData(hurtData.attackObjDataId);
var directionData = attackObjData.GetData <DirectionData>();
hurt.x *= directionData.direction.x;
}
force += hurt;
}
break;
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var speedData = objData.GetData <SpeedData>();
if (speedData.speed == 0)
{
Stop(objData.ObjectId);
return;
}
var actorData = objData.GetData <ActorData>();
if (!ActorController.CanMove(actorData.currentState))
{
return;
}
if ((actorData.currentState & (int)ActorStateType.Move) == 0)
{
speedData.speed = 0;
return;
}
var physics2DData = objData.GetData <Physics2DData>();
var speed = speedData.speed;
speedData.speed = speed - physics2DData.friction;
if (speedData.speed <= 0)
{
speedData.speed = 0;
physics2DData.force.x = 0;
ActorAnimator.Stop(objData, ActorStateType.Move);
actorData.currentState &= ~(int)ActorStateType.Move;
objData.SetDirty(actorData);
}
else
{
physics2DData.force.x = speed;
objData.SetDirty(physics2DData);
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var controllerData = objData.GetData <ActorController2DData>();
var collider2D = Physics2D.OverlapBox(controllerData.groundCollider2D.transform.position,
controllerData.groundCollider2D.size, 0, LayerMask.GetMask(Constant.LAYER_GROUND_NAME));
if (collider2D != null)
{
controllerData.isGround = true;
}
else
{
controllerData.isGround = false;
}
var physics2DData = objData.GetData <Physics2DData>();
if (controllerData.isGround && physics2DData.force.x == 0 && physics2DData.force.y == 0)
{
Stop(objData.ObjectId);
return;
}
var actorData = objData.GetData <ActorData>();
var currentState = actorData.currentState;
var forceY = physics2DData.force.y;
if ((currentState & (int)ActorStateType.SkillDefault) == 0 && (currentState & (int)ActorStateType.SkillCustom) == 0)
{
forceY += -physics2DData.gravity;
}
var directionData = objData.GetData <DirectionData>();
var gameSystemData = WorldManager.Instance.GameCore.GetData <GameSystemData>();
var deltaX = directionData.direction.x * physics2DData.force.x * gameSystemData.unscaleDeltaTime;
var deltaY = forceY * gameSystemData.unscaleDeltaTime;
_movePosition.x = (float)deltaX / Constant.UNITY_UNIT_TO_GAME_UNIT;
_movePosition.y = (float)deltaY / Constant.UNITY_UNIT_TO_GAME_UNIT;
var rb2d = controllerData.rigidbody2D;
rb2d.MovePosition(rb2d.position + _movePosition);
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var resourceData = objData.GetData <ResourceData>();
var position = resourceData.gameObject.transform.position;
position.z = Camera.main.transform.position.z;
Camera.main.transform.position = position;
}
public override void Refresh(ObjectData objData)
{
var clientJoyStickData = objData.GetData <ClientJoyStickData>();
if (clientJoyStickData.actionList.Count == 0)
{
return;
}
var serverJoyStickData = objData.GetData <ServerJoyStickData>();
serverJoyStickData.actionList.AddRange(clientJoyStickData.actionList);
clientJoyStickData.actionList.Clear();
objData.SetDirty(serverJoyStickData);
}
public override void Refresh(ObjectData objData)
{
#if !UNITY_EDITOR
Stop(objData.ObjectId);
return;
#endif
var joyStickData = objData.GetData <ClientJoyStickData>();
var joyStickMapDataList = WorldManager.Instance.JoyStickConfig.joyStickMapDataList;
for (var j = 0; j < joyStickMapDataList.Length; j++)
{
var joystickMapData = joyStickMapDataList[j];
if (joystickMapData.keyStateType == KeyStateType.Down)
{
var keyCodeList = joystickMapData.keyCode;
for (var k = 0; k < keyCodeList.Length; k++)
{
if (Input.GetKeyDown(keyCodeList[k]))
{
AddJoyStickActionData(objData, joyStickData, joystickMapData.joyStickActionType, joystickMapData.joyStickActionFaceType);
}
}
}
else if (joystickMapData.keyStateType == KeyStateType.Up)
{
var keyCodeList = joystickMapData.keyCode;
for (var k = 0; k < keyCodeList.Length; k++)
{
if (Input.GetKeyUp(keyCodeList[k]))
{
AddJoyStickActionData(objData, joyStickData, joystickMapData.joyStickActionType, joystickMapData.joyStickActionFaceType);
}
}
}
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var resourceData = objData.GetData <ResourceData>();
var directionData = objData.GetData <DirectionData>();
Vector3 scale = resourceData.gameObject.transform.localScale;
scale.x = Mathf.Abs(scale.x) * directionData.direction.x;
resourceData.gameObject.transform.localScale = scale;
var actorData = objData.GetData <ActorData>();
if ((actorData.currentState & (int)ActorStateType.Hurt) != 0)
{
// play hurt animation;
}
else if ((actorData.currentState & (int)ActorStateType.SkillCustom) != 0)
{
// play custom skill animation;
}
else if ((actorData.currentState & (int)ActorStateType.SkillDefault) != 0)
{
// play default skill animation;
var attackData = objData.GetData <ActorAttackData>();
attackData.defaultAttack.SetActive(true);
}
else if ((actorData.currentState & (int)ActorStateType.Jump) != 0)
{
// play jump animation;
}
else if ((actorData.currentState & (int)ActorStateType.Move) != 0)
{
// play move animation;
}
else
{
// play idle animation;
}
}
void ReleaseResource(ObjectData objData)
{
var worldMgr = WorldManager.Instance;
var resourceData = objData.GetData <ResourceData>();
var resourceStateData = objData.GetData <ResourceStateData>();
resourceStateData.isInstantiated = false;
if (resourceData.gameObject != null)
{
worldMgr.PoolMgr.ReleaseGameObject(resourceData.resource, resourceData.gameObject);
}
var battleData = worldMgr.GameCore.GetData <BattleResourceData>();
var hurtData = objData.GetData <ResourceHurtData>();
if (hurtData != null)
{
battleData.hurtDictionary.Remove(hurtData.hurt);
}
var attackData = objData.GetData <ResourceAttackData>();
if (attackData != null)
{
battleData.attackDictionary.Remove(attackData.attack);
}
var actorAttackData = objData.GetData <ActorAttackData>();
if (actorAttackData != null)
{
battleData.attackDictionary.Remove(actorAttackData.defaultAttack);
}
_notificationData.mode = NotificationMode.Object;
_notificationData.type = (int)CreatureStateType.Release;
_notificationData.data1 = objData;
worldMgr.NotificationCenter.Notificate(_notificationData);
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var actorAttribute = objData.GetData <ActorAttributeData>();
var totalLeftHp = actorAttribute.baseAttribute.hp + actorAttribute.extraAttribute.hp;
LogUtil.I("{0} hp : {1}!", resourceStateData.name, totalLeftHp);
if (totalLeftHp <= 0)
{
ResourceCreator.ReleaseResource(objData);
}
}
public static void ReleaseResource(ObjectData objData)
{
var creatureStateData = objData.GetData <CreatureStateData>();
creatureStateData.stateType = CreatureStateType.Release;
objData.SetDirty(creatureStateData);
WorldManager.Instance.PoolMgr.ReleaseObjData(objData);
}
public void ResetAttributeInfo(ObjectData objData)
{
baseAttribute.hp = 0;
baseAttribute.mp = 0;
baseAttribute.atk = 0;
baseAttribute.def = 0;
var attributeData = objData.GetData <ActorAttributeData>();
extraAttribute.hp = attributeData.extraAttribute.hp;
extraAttribute.hpMax = attributeData.extraAttribute.hpMax;
extraAttribute.mp = attributeData.extraAttribute.mp;
extraAttribute.atk = attributeData.extraAttribute.atk;
extraAttribute.def = attributeData.extraAttribute.def;
var hurtData = objData.GetData <ResourceHurtData>();
force = hurtData.force;
}
public override void Refresh(ObjectData objData)
{
var creatureStateData = objData.GetData <CreatureStateData>();
if (creatureStateData.stateType == CreatureStateType.Load)
{
LoadResource(objData, creatureStateData);
}
else if (creatureStateData.stateType == CreatureStateType.Release)
{
ReleaseResource(objData);
}
}
public override void Refresh(ObjectData objData)
{
var gameSystemData = objData.GetData <GameSystemData>();
gameSystemData.clientFrame++;
var deltaTime = Mathf.RoundToInt(Time.unscaledDeltaTime * Constant.SECOND_TO_MILLISECOND);
gameSystemData.unscaleDeltaTime = deltaTime;
gameSystemData.unscaleTime += deltaTime;
WorldManager.Instance.TimerMgr.Update();
}
public void UpdateAttributeInfo(ObjectData objData)
{
var attributeData = objData.GetData <ActorAttributeData>();
attributeData.baseAttribute.hp += baseAttribute.hp;
attributeData.baseAttribute.mp += baseAttribute.mp;
attributeData.baseAttribute.atk += baseAttribute.atk;
attributeData.baseAttribute.def += baseAttribute.def;
attributeData.extraAttribute.hp = extraAttribute.hp;
attributeData.extraAttribute.hpMax = extraAttribute.hpMax;
attributeData.extraAttribute.mp = extraAttribute.mp;
attributeData.extraAttribute.atk = extraAttribute.atk;
attributeData.extraAttribute.def = extraAttribute.def;
var hurtData = objData.GetData <ResourceHurtData>();
hurtData.force += force;
var actorData = objData.GetData <ActorData>();
actorData.currentState |= (int)ActorStateType.Hurt;
objData.SetDirty(actorData, attributeData, hurtData);
}
public static void AddJoyStickActionData(ObjectData objData, ClientJoyStickData joyStickData, JoyStickActionType actionType, JoyStickActionFaceType faceType)
{
var gameSystemData = WorldManager.Instance.GameCore.GetData <GameSystemData>();
var actorData = objData.GetData <ActorData>();
var joyStickActionData = WorldManager.Instance.PoolMgr.Get <JoyStickActionData>();
joyStickActionData.actorId = actorData.actorId;
joyStickActionData.frame = gameSystemData.clientFrame + Constant.JOYSTICK_DELAY_FRAME_COUNT;
joyStickActionData.actionType = actionType;
joyStickActionData.actionParam = faceType;
joyStickData.actionList.Add(joyStickActionData);
objData.SetDirty(joyStickData);
}
private void sendAndClear()
{
if (_tilesToUpdateOrAdd.Count > 0 || _objectsToUpdateOrAdd.Count > 0)
{
Client.SendPacket(new Update()
{
AddOrUpdateTile = _tilesToUpdateOrAdd.Select(_ => TileData.GetData(_)).ToArray(),
AddOrUpdateObject = _objectsToUpdateOrAdd.Select(_ => ObjectData.GetData(_)).ToArray(),
RemovedObjects = _removedObjects.ToArray()
});
}
_tilesToUpdateOrAdd.Clear();
_objectsToUpdateOrAdd.Clear();
_removedObjects.Clear();
}
void UpdateActionInfo(KeyStateType keyStateType)
{
if (_player == null)
{
_player = GetPlayer();
}
var joyStickData = _player.GetData <Data.ClientJoyStickData>();
for (var i = 0; i < ActionInfo.Length; i++)
{
var actionInfo = ActionInfo[i];
if (actionInfo.keyStateType == keyStateType)
{
Module.ActorJoyStick.AddJoyStickActionData(_player, joyStickData, actionInfo.actionType, actionInfo.faceType);
}
}
}
public static void Stop(ObjectData objData, ActorStateType stateType)
{
if (stateType == ActorStateType.Hurt)
{
}
else if (stateType == ActorStateType.SkillCustom)
{
}
else if (stateType == ActorStateType.SkillDefault)
{
var attackData = objData.GetData <ActorAttackData>();
attackData.defaultAttack.SetActive(false);
}
else if (stateType == ActorStateType.Jump)
{
}
else if (stateType == ActorStateType.Move)
{
}
}
public override void Refresh(ObjectData objData)
{
var worldMgr = WorldManager.Instance;
if (worldMgr.ResourcePreloadConfig == null)
{
return;
}
var resourcePreloadData = objData.GetData <Data.ResourcePreloadData>();
var resourceNameList = worldMgr.ResourcePreloadConfig.GetResourceNameList(resourcePreloadData.preloadType);
for (var i = 0; i < resourceNameList.Length; i++)
{
var resourceName = resourceNameList[i];
worldMgr.ResourceMgr.LoadAsync(resourceName, delegate(Object obj)
{
var reourceInfo = worldMgr.ResourceMgr.Get(resourceName);
if (reourceInfo.Value.type == Data.ResourceType.UI)
{
worldMgr.UIMgr.LoadPanel(obj);
}
resourcePreloadData.preloadCount++;
if (resourcePreloadData.preloadCount == resourceNameList.Length)
{
_notificationData.mode = NotificationMode.ValueType;
_notificationData.type = (int)resourcePreloadData.preloadType;
_notificationData.data2 = resourcePreloadData.preloadCount;
worldMgr.NotificationCenter.Notificate(_notificationData);
}
});
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var hurtData = objData.GetData <ResourceHurtData>();
var force = hurtData.force;
if (force.y == 0 && force.x == 0)
{
Stop(objData.ObjectId);
return;
}
var actorData = objData.GetData <ActorData>();
if (!ActorController.CanHurt(actorData.currentState))
{
return;
}
if ((actorData.currentState & (int)ActorStateType.Hurt) == 0)
{
hurtData.force = Vector3Int.zero;
return;
}
var physics2DData = objData.GetData <Physics2DData>();
if (hurtData.force.y == 0)
{
hurtData.force.x = 0;
physics2DData.force.x = 0;
physics2DData.force.y = 0;
actorData.currentState &= ~(int)ActorStateType.Hurt;
objData.SetDirty(actorData);
}
else
{
hurtData.force.y = force.y - physics2DData.airFriction;
if (hurtData.force.y < 0)
{
hurtData.force.y = 0;
physics2DData.force.y += -physics2DData.airFriction;
}
else
{
physics2DData.force.y = force.y;
}
physics2DData.force.x = hurtData.force.x;
objData.SetDirty(physics2DData);
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var stressData = objData.GetData <ActorStressData>();
if (stressData.duration == 0)
{
Stop(objData.ObjectId);
return;
}
var actorData = objData.GetData <ActorData>();
if (!ActorController.CanSkillDefault(actorData.currentState))
{
return;
}
if ((actorData.currentState & (int)ActorStateType.SkillDefault) == 0 &&
(actorData.currentState & (int)ActorStateType.SkillCustom) == 0)
{
stressData.currentDuration = stressData.duration = 0;
return;
}
var worldMgr = WorldManager.Instance;
var physics2DData = objData.GetData <Physics2DData>();
if (stressData.currentDuration == stressData.duration)
{
stressData.currentDuration = stressData.duration = 0;
physics2DData.force.y = 0;
if ((actorData.currentState & (int)ActorStateType.SkillDefault) != 0)
{
ActorAnimator.Stop(objData, ActorStateType.SkillDefault);
}
else if ((actorData.currentState & (int)ActorStateType.SkillDefault) != 0)
{
ActorAnimator.Stop(objData, ActorStateType.SkillCustom);
}
actorData.currentState &= ~(int)ActorStateType.SkillDefault;
actorData.currentState &= ~(int)ActorStateType.SkillCustom;
objData.SetDirty(actorData);
}
else
{
var gameSystemData = worldMgr.GameCore.GetData <GameSystemData>();
stressData.currentDuration += gameSystemData.unscaleDeltaTime;
if (stressData.currentDuration >= stressData.duration)
{
stressData.currentDuration = stressData.duration;
physics2DData.force.y = 0;
}
else
{
physics2DData.force.y = -physics2DData.mass * Constant.ACTOR_STRESS_RATE_Y;
objData.SetDirty(physics2DData);
}
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var jumpData = objData.GetData <ActorJumpData>();
var currentJump = jumpData.currentJump;
if (currentJump.y == 0 && currentJump.x == 0)
{
Stop(objData.ObjectId);
return;
}
var actorData = objData.GetData <ActorData>();
if (!ActorController.CanJump(actorData.currentState))
{
return;
}
if ((actorData.currentState & (int)ActorStateType.Jump) == 0)
{
jumpData.currentJump = Vector3Int.zero;
return;
}
var physics2DData = objData.GetData <Physics2DData>();
var actorControllerData = objData.GetData <ActorController2DData>();
if (ActorPhysics2D.IsGround(actorControllerData) && jumpData.currentJump.y == 0)
{
jumpData.currentJump.x = 0;
physics2DData.force.x = 0;
physics2DData.force.y = 0;
ActorAnimator.JumpGround(objData);
ActorAnimator.Stop(objData, ActorStateType.Jump);
actorData.currentState &= ~(int)ActorStateType.Jump;
objData.SetDirty(actorData);
}
else
{
jumpData.currentJump.y = currentJump.y - physics2DData.airFriction;
if (jumpData.currentJump.y < 0)
{
jumpData.currentJump.y = 0;
physics2DData.force.y += -physics2DData.airFriction;
}
else
{
physics2DData.force.y = currentJump.y;
}
physics2DData.force.x = jumpData.currentJump.x;
objData.SetDirty(physics2DData);
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var buffData = objData.GetData <ActorBuffData>();
var buffList = buffData.buffList;
if (buffList.Count == 0 || !CheckIfHasNeedRefreshBuff(buffList))
{
Stop(objData.ObjectId);
return;
}
ResetAttributeInfo(objData);
var gameSystemData = WorldManager.Instance.GameCore.GetData <GameSystemData>();
var isDirty = false;
for (var i = 0; i < buffList.Count;)
{
var buff = buffList[i];
if (buff.buffState != BuffState.Finished)
{
if (buff.buffState == BuffState.Init)
{
if (buff.lastUpdateTime == 0)
{
buff.lastUpdateTime = gameSystemData.unscaleTime;
}
if (buff.lastUpdateTime + buff.delay <= gameSystemData.unscaleTime)
{
buff.buffState = BuffState.Start;
}
}
else if (buff.buffState == BuffState.Stop)
{
if (buff.lastUpdateTime + buff.interval <= gameSystemData.unscaleTime)
{
buff.buffState = BuffState.Start;
}
}
else if (buff.buffState == BuffState.Start)
{
if (buff.count > 0)
{
isDirty = true;
AddBuffAttribute(objData, buff);
buff.count--;
buff.currentCount++;
}
if (buff.time > 0)
{
buff.time = Mathf.Max(0, buff.time - gameSystemData.unscaleDeltaTime);
}
if (buff.time == 0 && buff.count == 0)
{
buff.buffState = BuffState.Finished;
}
else if (buff.time == 0)
{
buff.buffState = BuffState.Stop;
}
buff.lastUpdateTime = gameSystemData.unscaleTime;
}
buffList[i] = buff;
i++;
}
else
{
if ((buff.buffAttribute & (int)BuffAttribute.NeedRemove) != 0)
{
isDirty = true;
RemoveBuffAttribute(objData, buff);
}
buffList.RemoveAt(i);
}
}
if (isDirty)
{
UpdateAttributeInfo(objData);
}
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var joyStickData = objData.GetData <ServerJoyStickData>();
var serverActionList = joyStickData.actionList;
if (serverActionList.Count == 0)
{
Stop(objData.ObjectId);
return;
}
var worldMgr = WorldManager.Instance;
var gameSystemData = worldMgr.GameCore.GetData <GameSystemData>();
var actorData = objData.GetData <ActorData>();
var actorInfo = worldMgr.ActorConfig.Get(actorData.actorId);
var physics2DData = objData.GetData <Physics2DData>();
var speedData = objData.GetData <SpeedData>();
var directionData = objData.GetData <DirectionData>();
var jumpData = objData.GetData <ActorJumpData>();
var actorAttackData = objData.GetData <ActorAttackData>();
for (var i = 0; i < serverActionList.Count;)
{
var serverAction = serverActionList[i];
if (serverAction.frame < gameSystemData.clientFrame)
{
serverActionList.Remove(serverAction);
}
else if (serverAction.frame == gameSystemData.clientFrame && serverAction.actorId == actorData.actorId)
{
switch (serverAction.actionType)
{
case JoyStickActionType.Move:
physics2DData.friction = 0;
speedData.speed = actorInfo.Value.speed;
directionData.direction.x = serverAction.actionParam == JoyStickActionFaceType.Right ? 1 : -1;
actorData.currentState |= (int)ActorStateType.Move;
objData.SetDirty(speedData, directionData, physics2DData, actorData);
break;
case JoyStickActionType.CancelMove:
physics2DData.friction = actorInfo.Value.friction;
objData.SetDirty(speedData, physics2DData);
break;
case JoyStickActionType.Jump:
jumpData.currentJump = actorInfo.Value.jump;
actorData.currentState |= (int)ActorStateType.Jump;
objData.SetDirty(jumpData, physics2DData, actorData);
break;
case JoyStickActionType.SkillDefault:
actorData.currentState |= (int)ActorStateType.SkillDefault;
DoSkill(actorAttackData.defaultSkill, objData, physics2DData, actorData);
break;
}
serverActionList.Remove(serverAction);
worldMgr.PoolMgr.Release(serverAction);
}
else
{
i++;
}
}
}
void LoadResource(ObjectData objData, CreatureStateData creatureStateData)
{
var resourceData = objData.GetData <ResourceData>();
var worldMgr = WorldManager.Instance;
worldMgr.ResourceMgr.LoadAsync(resourceData.resource, delegate(Object obj)
{
var resourceStateData = objData.GetData <ResourceStateData>();
resourceStateData.isInstantiated = true;
var resource = worldMgr.PoolMgr.GetGameObject(resourceData.resource, obj);
var transform = resource.transform;
resourceData.gameObject = resource;
resource.name = resourceStateData.name;
resource.transform.position = resourceData.initialPosition;
var battleData = worldMgr.GameCore.GetData <BattleResourceData>();
if (creatureStateData.type == CreatureType.Actor)
{
var controller = objData.GetData <ActorController2DData>();
controller.rigidbody2D = resource.GetComponent <Rigidbody2D>();
var ground = transform.Find("Ground");
controller.groundCollider2D = ground.GetComponent <BoxCollider2D>();
var actorAttackData = objData.GetData <ActorAttackData>();
var attackTransform = transform.Find("DefaultAttack");
actorAttackData.defaultAttack = attackTransform.gameObject;
battleData.attackDictionary.Add(attackTransform.gameObject, objData.ObjectId);
var attackCollider2D = attackTransform.GetComponent <AttackCollider2D>();
var effect = worldMgr.BuffConfig.GetEffect(actorAttackData.defaultSkill.effectId);
attackCollider2D.Init(effect.Value);
}
var attackData = objData.GetData <ResourceAttackData>();
if (attackData != null)
{
attackData.attack = transform.Find("Attack").gameObject;
battleData.attackDictionary.Add(attackData.attack, objData.ObjectId);
var attackCollider2DList = transform.GetComponentsInChildren <AttackCollider2D>();
for (var i = 0; i < attackCollider2DList.Length; i++)
{
attackCollider2DList[i].Init(attackData.effect);
}
}
var hurtData = objData.GetData <ResourceHurtData>();
if (hurtData != null)
{
hurtData.hurt = transform.Find("Hurt").gameObject;
battleData.hurtDictionary.Add(hurtData.hurt, objData.ObjectId);
}
_notificationData.mode = NotificationMode.Object;
_notificationData.type = (int)CreatureStateType.Load;
_notificationData.data1 = objData;
worldMgr.NotificationCenter.Notificate(_notificationData);
});
}
public override void Refresh(ObjectData objData)
{
var resourceStateData = objData.GetData <ResourceStateData>();
if (!resourceStateData.isInstantiated)
{
return;
}
var flyData = objData.GetData <ActorFlyData>();
if (flyData.duration == 0)
{
Stop(objData.ObjectId);
return;
}
var actorData = objData.GetData <ActorData>();
if (!ActorController.CanSkillDefault(actorData.currentState))
{
return;
}
if ((actorData.currentState & (int)ActorStateType.SkillDefault) == 0 &&
(actorData.currentState & (int)ActorStateType.SkillCustom) == 0)
{
flyData.currentDuration = flyData.duration = 0;
return;
}
var worldMgr = WorldManager.Instance;
var physics2DData = objData.GetData <Physics2DData>();
if (flyData.currentDuration == flyData.duration)
{
flyData.currentDuration = flyData.duration = 0;
physics2DData.force.x = 0;
physics2DData.force.y = 0;
if ((actorData.currentState & (int)ActorStateType.SkillDefault) != 0)
{
ActorAnimator.Stop(objData, ActorStateType.SkillDefault);
}
else if ((actorData.currentState & (int)ActorStateType.SkillDefault) != 0)
{
ActorAnimator.Stop(objData, ActorStateType.SkillCustom);
}
actorData.currentState &= ~(int)ActorStateType.SkillDefault;
actorData.currentState &= ~(int)ActorStateType.SkillCustom;
objData.SetDirty(actorData);
}
else
{
var gameSystemData = worldMgr.GameCore.GetData <GameSystemData>();
flyData.currentDuration += gameSystemData.unscaleDeltaTime;
if (flyData.currentDuration >= flyData.duration)
{
flyData.currentDuration = flyData.duration;
physics2DData.force.y = 0;
}
else
{
var seconds = flyData.currentDuration * Constant.ACTOR_FLY_SHAKE_DURATION / Constant.SECOND_TO_MILLISECOND;
if (seconds % 2 == 0)
{
physics2DData.force.y = Constant.ACTOR_FLY_SHAKE_Y;
}
else
{
physics2DData.force.y = -Constant.ACTOR_FLY_SHAKE_Y;
}
}
physics2DData.force.x = Constant.ACTOR_FLY_SPEED_X;
objData.SetDirty(physics2DData);
}
}
