void ApplyDirection(ref PlayerState state, Vector2 movement, CharacterStateData data)
{
switch (data.DirectionMode)
{
case DirectionMode.PlayerControlled:
if (movement.x > DirectionalInput.DeadZone)
{
state.Direction = true;
}
else if (movement.x < -DirectionalInput.DeadZone)
{
state.Direction = false;
}
break;
case DirectionMode.AlwaysLeft:
state.Direction = false;
break;
case DirectionMode.AlwaysRight:
state.Direction = true;
break;
default:
break;
}
}
void ApplyMovement(ref PlayerState state, Vector2 movement, CharacterStateData data)
{
float dir = state.Direction ? 1f : -1f;
float speed = 0f;
switch (data.MovementType)
{
case MovementType.Normal:
speed = data.GetScaledMoveSpeed(movement);
break;
case MovementType.DirectionalInfluenceOnly:
dir = movement.x > 0 ? 1f : -1f;
speed = data.GetScaledMoveSpeed(movement);
break;
case MovementType.Locked:
speed = 0;
break;
case MovementType.Forced:
speed = data.MaxMoveSpeed;
break;
}
state.VelocityX = dir * speed;
}
//캐릭터의 애니메이션, 방향, 위치를 보내주는 메소드
public IEnumerator CharacterDataSend()
{
yield return(new WaitForSeconds(1.0f));
while (true)
{
yield return(new WaitForEndOfFrame());
byte state = (byte)characterManager.State;
float vertical = characterManager.Animator.GetFloat("Ver");
float horizontal = characterManager.Animator.GetFloat("Hor");
bool direction = characterManager.Animator.GetBool("Direction");
float xPos = characterManager.transform.position.x;
float yPos = characterManager.transform.position.y;
float zPos = characterManager.transform.position.z;
CharacterStateData characterStateData = new CharacterStateData(state, direction, horizontal, vertical, xPos, yPos, zPos);
CharacterStateDataPacket characterStateDataPacket = new CharacterStateDataPacket(characterStateData);
//현재는 client로 고정되있지만
//차후 수정으로 매개변수 newIPEndPoint를 설정하여 여러명의 클라이언트에 동시에 보내도록 수정할 예정
DataPacket packet = CreatePacket(characterStateDataPacket.GetPacketData(), P2PPacketId.CharacterState);
packet.endPoint = NetworkManager.client1;
sendMsgs.Enqueue(packet);
}
}
public bool Deserialize(ref CharacterStateData element)
{
if (GetDataSize() == 0)
{
// 데이터가 설정되지 않았다.
return(false);
}
bool ret = true;
byte state = 0;
bool direction = true;
float ver = 0;
float hor = 0;
float posX = 0;
float posY = 0;
float posZ = 0;
ret &= Deserialize(ref state);
ret &= Deserialize(ref direction);
ret &= Deserialize(ref ver);
ret &= Deserialize(ref hor);
ret &= Deserialize(ref posX);
ret &= Deserialize(ref posY);
ret &= Deserialize(ref posZ);
element.state = state;
element.direction = direction;
element.ver = ver;
element.hor = hor;
element.posX = posX;
element.posY = posY;
element.posZ = posZ;
return(ret);
}
internal void Initalize(string name, uint id, CharacterStateData data)
{
Name = name;
Id = id;
Data = Argument.NotNull(data);
AnimatorName = Name.Replace(".", "-");
AnimatorHash = Animator.StringToHash(AnimatorName);
}
public void ReplaceCharacterState(CharacterStateData newValue)
{
var index = GameComponentsLookup.CharacterState;
var component = (CharacterStateComponent)CreateComponent(index, typeof(CharacterStateComponent));
component.value = newValue;
ReplaceComponent(index, component);
}
public override void OnEnter(Controller controller, CharacterStateData data)
{
//get our state data casted
CharacterMultiStateData myData = data as CharacterMultiStateData;
myData.currentState = Random.Range(0, myData.states.Count);
myData.states[myData.currentState].OnEnter(controller);
base.OnEnter(controller, data);
}
public override void OnTick(Controller controller, CharacterStateData data)
{
(data as AttackStateData).timer.Tick();
if ((data as AttackStateData).timer.status == Timer.Status.finished)
{
PerformAttack(controller, data);
//reset the attack timer.
(data as AttackStateData).timer.ResetTimer();
}
}
//-----------------------------------------------------------------------------------------------------------------
//public API Methods
//-----------------------------------------------------------------------------------------------------------------
//Called when a character with this state enters this state
public override void OnTick(Controller character, CharacterStateData data)
{
base.OnTick(character, data);
//check which direction we want to turn
//if it's left then rotate on forward axis, if its right then rotate on -Forward axis.
int directionSwap = (data as IdleStateData).direction == IdleStateData.RotationDirections.left ? 1 : -1;
//asks the state data for the rotation speed, and apply that rotation to our character's transform rotation
character.transform.Rotate(directionSwap * Vector3.forward, (data as IdleStateData).rotationSpeed * Time.deltaTime);
}
public void SetState(CharacterStateData newStateData)
{
Debug.Log("상태 설정");
animator.SetBool("Direction", newStateData.direction);
animator.SetFloat("Ver", newStateData.ver);
animator.SetFloat("Hor", newStateData.hor);
transform.position = new Vector3(newStateData.posX, newStateData.posY, newStateData.posZ);
//animator.SetBool(GetCharacterState(newStateData.state).ToString(), true);
}
public override void OnEnter(Controller controller, CharacterStateData data)
{
base.OnEnter(controller, data);
AttackStateData stateData = (data as AttackStateData);
stateData.timer = new Timer(stateData.cooldownTime);
if (!stateData.target)
{
stateData.target = (stateData.findTransform.state as FindTargetState).FindTarget();
}
(data as AttackStateData).timer.ResetTimer();
}
CharacterStateData GetStateData(string key)
{
_dataMap = _dataMap ?? new Dictionary <string, CharacterStateData>();
CharacterStateData data;
if (!_dataMap.TryGetValue(key, out data))
{
data = new CharacterStateData();
_dataMap.Add(key, data);
}
return(data);
}
//원래는 보낸 IP를 체크해서 몇번째 플레이어인지 확인 후 그 플레이어의 캐릭터를 조정해야한다.
//현재는 고정적으로 1번 플레이어를 설정
public P2PPacketId CharacterState(byte[] data)
{
Debug.Log("캐릭터 상태 수신");
CharacterStateDataPacket characterStateDataPacket = new CharacterStateDataPacket(data);
CharacterStateData characterStateData = characterStateDataPacket.GetData();
CharacterManager characterManager = dungeonManager.Players[1].GetComponent <CharacterManager>();
characterManager.SetState(characterStateData);
return(P2PPacketId.None);
}
public bool Serialize(CharacterStateData data)
{
bool ret = true;
ret &= Serialize(data.state);
ret &= Serialize(data.direction);
ret &= Serialize(data.hor);
ret &= Serialize(data.ver);
ret &= Serialize(data.posX);
ret &= Serialize(data.posY);
ret &= Serialize(data.posZ);
return(ret);
}
/*[Tedo]:
* How about changing the 'data' type to 'AttackStateData'? */
public virtual void PerformAttack(Controller controller, CharacterStateData data)
{
for (int i = 0; i < (data as AttackStateData).projectiles; ++i)
{
if ((data as AttackStateData).projectiles % 2 != 0)
{
Attack(controller, data, (data as AttackStateData).angle * (i - Mathf.Floor((data as AttackStateData).projectiles / 2)));
}
else
{
Attack(controller, data, (data as AttackStateData).angle * ((i - ((float)(data as AttackStateData).projectiles / 2.0f)) + 0.5f));
}
}
}
public override void OnEnter(Controller controller, CharacterStateData data)
{
//get our state data casted
CharacterMultiStateData myData = data as CharacterMultiStateData;
//enter the state.
if (myData.states.Count > 0)
{
for (int i = 0; i < myData.states.Count; ++i)
{
myData.states[i].OnEnter(controller);
}
}
base.OnEnter(controller, data);
}
//enters a new state and exists the current state.
private void SetState(CharacterStateData state)
{
//check if our current state is vald
if (m_currState)
{
//exit the state
m_currState.OnExit(this); //[TODO]
}
//Check the new state is valid
if (state)
{
//enter the state
state.OnEnter(this); //[TODO]
}
//set our current state to the new state
m_currState = state;
}
//checks if we need to transition to a new state, ticks the current state
private void HandleStates()
{
//check if we have a current state
if (m_currState)
{
//Try getting a new state
CharacterStateData newState = m_currState.GetStateOnTransition(this); //[TODO]
//if we have a new state from transition then set it.
if (newState)
{
SetState(newState);
}
}
//if we have a current state then tick it.
if (m_currState)
{
m_currState.OnTick(this); //[TODO]
}
}
public override void OnTick(Controller controller, CharacterStateData data)
{
//get our state data casted
CharacterMultiStateData myData = data as CharacterMultiStateData;
//tick our state
if (myData.states.Count > 0)
{
for (int i = 0; i < myData.states.Count; ++i)
{
CharacterStateData newState = myData.states[i].GetStateOnTransition(controller);
if (newState)
{
myData.states[i].OnExit(controller);
myData.states[i] = newState;
newState.OnEnter(controller);
}
myData.states[i].OnTick(controller);
}
}
base.OnTick(controller, data);
}
public void OnCharacterShouldSpawn(CharacterStateData characterStateData)
{
if (players.ContainsKey(characterStateData.playerId))
{
GameObject gameObject;
Debug.Log(characterStateData.type);
switch (characterStateData.type)
{
case ECharacterType.MARINE:
gameObject = Instantiate(marinePrefab, new Vector2(characterStateData.position.X, characterStateData.position.Y), UnityEngine.Quaternion.Euler(UnityEngine.Vector3.forward));
break;
case ECharacterType.ROACH:
gameObject = Instantiate(roachPrefab, new Vector2(characterStateData.position.X, characterStateData.position.Y), UnityEngine.Quaternion.Euler(UnityEngine.Vector3.forward));
break;
default: return;
}
Player owner = players[characterStateData.playerId];
CharacterObject character = gameObject.GetComponent <CharacterObject>();
character.direction = characterStateData.direction;
character.type = characterStateData.type;
character.hp = characterStateData.hp;
character.speed = characterStateData.speed;
character.id = characterStateData.id;
character.teamId = characterStateData.teamId;
owner.character = character;
if (owner.id == Client.instance.myId)
{
character.SetAsLocalPlayer();
}
characters.Add(character.id, character);
}
}
public virtual void Attack(Controller controller, CharacterStateData data, float angle)
{
AttackStateData attackData = data as AttackStateData;
//direction of attack from us towards the target.
if (!attackData.target)
{
return;
}
Vector3 delta = attackData.target.position - controller.transform.position;
//normalize the direction of attack.
delta.Normalize();
//rotate the attack by the specified angle
delta = (new Vector2(delta.x, delta.y)).Rotate(angle);
//offset the spawn location by the distance specified
delta *= attackData.spawnDistance;
//rotation of the spawned projectile is the direction of the attack.
Quaternion rotation = Quaternion.LookRotation(Vector3.forward, delta);
//spawn the projectile.
GameObject projectile = Instantiate(attackData.projectile, controller.transform.position + delta, rotation, controller.transform.parent);
ProjectileScript projectileScript = projectile.GetComponent <ProjectileScript>();
//set the projectile layer to enemy bullet
projectile.layer = LayerMask.NameToLayer("EnemyBullet");
//assign velocity to the projectile.
projectileScript.direction = delta.normalized;
//Set the projectile damage and status effect
projectileScript.damage = attackData.damage;
projectileScript.statusEffect = attackData.statusEffectOnHit;
projectileScript.speed = attackData.projectileSpeed;
}
public override void Attack(Controller controller, CharacterStateData data, float angle)
{
AttackStateData attackData = data as AttackStateData;
//direction of attack from us towards the target.
if (!attackData.target)
{
return;
}
Vector3 delta = attackData.target.position - controller.transform.position;
//normalize the direction of attack.
delta.Normalize();
//rotate the attack by the specified angle
delta = (new Vector2(delta.x, delta.y)).Rotate(angle);
//offset the spawn location by the distance specified
delta *= attackData.spawnDistance;
//rotation of the spawned projectile is the direction of the attack.
Quaternion rotation = Quaternion.LookRotation(Vector3.forward, delta);
//spawn the projectile.
GameObject projectile = Instantiate(attackData.projectile, controller.transform.position + delta, rotation, controller.transform.parent);
}
public override void OnTick(Controller controller, CharacterStateData data)
{
//get our state data casted
CharacterMultiStateData myData = data as CharacterMultiStateData;
myData.states[myData.currentState].OnTick(controller);
//tick our state
//if (myData.states.Count > 0)
//{
// for (int i = 0; i < myData.states.Count; ++i)
// {
// CharacterStateData newState = myData.states[i].GetStateOnTransition(controller);
// if (newState)
// {
// myData.states[i].OnExit(controller);
// myData.states[i] = newState;
// newState.OnEnter(controller);
// }
// myData.states[i].OnTick(controller);
// }
//}
base.OnTick(controller, data);
}
public void OnCharacterState(GameEntity entity, CharacterStateData value)
{
Debug.Log(string.Format("Character State Change from {0} to {1}", value.prevState, value.currentState));
}
//-----------------------------------------------------------------------------------------------------------------
//public API Methods
//-----------------------------------------------------------------------------------------------------------------
//Called when a character with this state enters this state
public override void OnEnter(Controller controller, CharacterStateData data)
{
base.OnEnter(controller, data);
}
//called when a character with this state gets ticked
//TODO: Make the character check if the target has moved, if so then retarget our MovementComponent.
public override void OnTick(Controller controller, CharacterStateData data)
{
base.OnTick(controller, data);
//tell movement component of our character to go to our current target position.
(controller as AiController).movement.GoToLocation((data as GoToLocationStateData).GetCurrentTarget());
}
//called on tick of the character that owns that state
public virtual void OnTick(Controller controller, CharacterStateData data)
{
//
}
