Beispiel #1
0
    //유닛 위치 -> Client
    public IEnumerator UnitPositionSend(GameObject unit)
    {
        Debug.Log("몬스터 위치 보내기 시작");
        Monster monster = unit.GetComponent <Monster>();

        while (true)
        {
            yield return(new WaitForSeconds(0.016f));

            bool  dir  = monster.Direction;
            float xPos = monster.transform.position.x;
            float yPos = monster.transform.position.y;
            float zPos = monster.transform.position.z;

            UnitPositionData   unitPositionData   = new UnitPositionData((byte)UnitType.Monster, dir, xPos, yPos, zPos, (byte)monster.MonsterIndex);
            UnitPositionPacket unitPositionPacket = new UnitPositionPacket(unitPositionData);
            unitPositionPacket.SetPacketId((int)P2PPacketId.UnitPosition);

            byte[] msg = CreatePacket(unitPositionPacket);

            for (int index = 0; index < NetworkManager.Instance.UserIndex.Count; index++)
            {
                Debug.Log(index + ", " + NetworkManager.Instance.MyIndex);
                if (NetworkManager.Instance.MyIndex != index)
                {
                    Debug.Log("몬스터 위치 보냄");
                    DataPacket packet = new DataPacket(msg, NetworkManager.Instance.UserIndex[index].EndPoint);
                    sendMsgs.Enqueue(packet);
                }
            }
        }
    }
Beispiel #2
0
    //캐릭터 위치 -> Client
    public IEnumerator CharacterPositionSend(GameObject unit)
    {
        CharacterManager characterManager = unit.GetComponent <CharacterManager>();

        Debug.Log("캐릭터 위치 보내기 시작");

        while (true)
        {
            yield return(new WaitForSeconds(0.016f));

            bool  dir  = characterManager.charDir;
            float xPos = characterManager.transform.position.x;
            float yPos = characterManager.transform.position.y;
            float zPos = characterManager.transform.position.z;

            UnitPositionData   unitPositionData   = new UnitPositionData((byte)UnitType.Hero, dir, xPos, yPos, zPos, (byte)characterManager.UserNum);
            UnitPositionPacket unitPositionPacket = new UnitPositionPacket(unitPositionData);
            unitPositionPacket.SetPacketId((int)P2PPacketId.UnitPosition);

            byte[] msg = CreatePacket(unitPositionPacket);

            for (int index = 0; index < networkManager.UserIndex.Count; index++)
            {
                int userIndex = networkManager.UserIndex[index].UserNum;

                if (networkManager.MyIndex != userIndex)
                {
                    DataPacket packet = new DataPacket(CreateUdpPacket(unitPositionPacket, udpId[userIndex]), networkManager.UserIndex[index].EndPoint);
                    sendMsgs.Enqueue(packet);
                }
            }
        }
    }
Beispiel #3
0
    //캐릭터 위치 -> Client
    public IEnumerator CharacterPositionSend()
    {
        Debug.Log("캐릭터 위치 보내기 시작");
        CharacterManager characterManager = GameObject.FindWithTag("Player").GetComponent <CharacterManager>();

        while (true)
        {
            bool  dir  = characterManager.charDir;
            float xPos = characterManager.transform.position.x;
            float yPos = characterManager.transform.position.y;
            float zPos = characterManager.transform.position.z;

            UnitPositionData   unitPositionData   = new UnitPositionData((byte)UnitType.Hero, dir, xPos, yPos, zPos, (byte)NetworkManager.Instance.MyIndex);
            UnitPositionPacket unitPositionPacket = new UnitPositionPacket(unitPositionData);
            unitPositionPacket.SetPacketId((int)P2PPacketId.UnitPosition);

            for (int index = 0; index < NetworkManager.Instance.UserIndex.Count; index++)
            {
                if (NetworkManager.Instance.MyIndex != index)
                {
                    DataPacket packet = new DataPacket(CreateUdpPacket(unitPositionPacket, udpId[index]), NetworkManager.Instance.UserIndex[index].EndPoint);
                    sendMsgs.Enqueue(packet);
                }
            }

            yield return(new WaitForSeconds(0.016f));
        }
    }
        public bool Deserialize(ref UnitPositionData element)
        {
            if (GetDataSize() == 0)
            {
                // 데이터가 설정되지 않았다.
                return(false);
            }

            bool  ret       = true;
            byte  unitType  = 0;
            bool  dir       = true;
            byte  unitIndex = 0;
            float posX      = 0;
            float posY      = 0;
            float posZ      = 0;

            ret &= Deserialize(ref unitType);
            ret &= Deserialize(ref dir);
            ret &= Deserialize(ref unitIndex);
            ret &= Deserialize(ref posX);
            ret &= Deserialize(ref posY);
            ret &= Deserialize(ref posZ);

            element = new UnitPositionData(unitType, dir, posX, posY, posZ, unitIndex);

            return(ret);
        }
Beispiel #5
0
        public bool Serialize(UnitPositionData data)
        {
            bool ret = true;

            ret &= Serialize(data.Dir);
            ret &= Serialize(data.UnitIndex);
            ret &= Serialize(data.PosX);
            ret &= Serialize(data.PosY);
            ret &= Serialize(data.PosZ);
            return(ret);
        }
Beispiel #6
0
 public void SetPosition(UnitPositionData newPositionData)
 {
     if (newPositionData.Dir)
     {
         transform.rotation = Quaternion.Euler(new Vector3(0, 0.0f, 0));
         charDir            = true;
     }
     else
     {
         transform.rotation = Quaternion.Euler(new Vector3(0, 180.0f, 0));
         charDir            = false;
     }
     transform.position = new Vector3(newPositionData.PosX, newPositionData.PosY, newPositionData.PosZ);
 }
Beispiel #7
0
    //Client - 유닛 위치
    public void UnitPosition(DataPacket packet, int udpId)
    {
        UnitPositionPacket unitPositionPacket = new UnitPositionPacket(packet.msg);
        UnitPositionData   unitPositionData   = unitPositionPacket.GetData();

        if (unitPositionData.UnitType == (byte)UnitType.Hero)
        {
            dungeonManager.SetCharacterPosition(unitPositionData);
        }
        else if (unitPositionData.UnitType == (byte)UnitType.Monster)
        {
            dungeonManager.SetMonsterPosition(unitPositionData);
        }
    }
    public void SetPosition(UnitPositionData newPositionData)
    {
        Debug.Log("캐릭터 위치 설정 유저 번호 : " + userNum);

        if (newPositionData.Dir)
        {
            transform.rotation = Quaternion.Euler(new Vector3(0, 0.0f, 0));
            charDir            = true;
        }
        else
        {
            transform.rotation = Quaternion.Euler(new Vector3(0, 180.0f, 0));
            charDir            = false;
        }
        transform.position = new Vector3(newPositionData.PosX, newPositionData.PosY, newPositionData.PosZ);
    }
Beispiel #9
0
        public static void SetUnitPositionData(
            ref UnitPositionData unitPositionData,
            int resolution,
            float baseAngle = 0.0f,
            float direction = 1.0f
            )
        {
            bool needsUpdate = false;

            if (
                unitPositionData.UnitPositions == null ||
                unitPositionData.UnitPositions.Length != resolution)
            {
                unitPositionData.UnitPositions = new Vector3[resolution];

                for (int i = 0; i < unitPositionData.UnitPositions.Length; i++)
                {
                    unitPositionData.UnitPositions[i] = ZeroV3;
                }

                needsUpdate = true;
            }

            needsUpdate |=
                baseAngle != unitPositionData.LastBaseAngle ||
                direction != unitPositionData.LastDirection;

            if (needsUpdate)
            {
                float angleIncrement = TwoPI / (float)resolution;
                angleIncrement *= direction;
                float angle;

                for (int i = 0; i < resolution; i++)
                {
                    angle = baseAngle + (angleIncrement * i);

                    unitPositionData.UnitPositions[i].x = Mathf.Sin(angle);
                    unitPositionData.UnitPositions[i].y = Mathf.Cos(angle);
                }

                unitPositionData.LastBaseAngle = baseAngle;
                unitPositionData.LastDirection = direction;
            }
        }
 public void SetMonsterPosition(UnitPositionData unitPositionData)
 {
     monsterData[unitPositionData.UnitIndex].LookAtPattern(unitPositionData.Dir);
     monsters[unitPositionData.UnitIndex].transform.position = new Vector3(unitPositionData.PosX, unitPositionData.PosY, unitPositionData.PosZ);
 }
 public void SetCharacterPosition(UnitPositionData unitPositionData)
 {
     characterData[unitPositionData.UnitIndex].SetPosition(unitPositionData);
 }