예제 #1
0
    protected override JobHandle OnUpdate(JobHandle inputDependencies)
    {
        if (m_DamageWallMessages.CalculateEntityCount() == 0)
        {
            return(inputDependencies);
        }

        SINGLETON_GridDefinitions t_GridDef = GetSingleton <SINGLETON_GridDefinitions>();

        NativeArray <Entity>       na_BreakWallMessageEntities = m_DamageWallMessages.ToEntityArray(Allocator.TempJob);
        NativeArray <MC_BreakWall> na_BreakWallMessages        = m_DamageWallMessages.ToComponentDataArray <MC_BreakWall>(Allocator.TempJob);

        NativeArray <Entity>        na_PlayerEntities  = m_Players.ToEntityArray(Allocator.TempJob);
        NativeArray <C_PlayerIndex> na_PlayerIndexes   = m_Players.ToComponentDataArray <C_PlayerIndex>(Allocator.TempJob);
        NativeArray <C_PlayerPos>   na_PlayerPositions = m_Players.ToComponentDataArray <C_PlayerPos>(Allocator.TempJob);

        NativeArray <Entity>    na_GridEntities = m_Grid.ToEntityArray(Allocator.TempJob);
        NativeArray <C_GridPos> na_Grid         = m_Grid.ToComponentDataArray <C_GridPos>(Allocator.TempJob);


        EntityCommandBuffer ecb_Cleanup = CleanupMessageBarrier.CreateCommandBuffer();
        MC_BreakWall        mc_CurrentMessage;

        Entity      t_CurrentPlayerEntity = default;
        C_PlayerPos c_CurrentPlayerPos    = default;
        C_PlayerPos c_CurrentEnemyPos     = default;

        Entity    t_CurrentGridEntity = default;
        C_GridPos c_CurrentGridPos    = default;

        for (int i = 0; i < na_BreakWallMessages.Length; i++)
        {
            mc_CurrentMessage = na_BreakWallMessages[i];

            for (int j = 0; j < na_PlayerIndexes.Length; j++)
            {
                if (mc_CurrentMessage.PlayerId != na_PlayerIndexes[j].PlayerId)
                {
                    c_CurrentEnemyPos = na_PlayerPositions[j];
                }
                else
                {
                    t_CurrentPlayerEntity = na_PlayerEntities[j];
                    c_CurrentPlayerPos    = na_PlayerPositions[j];
                }
            }

            for (int j = 0; j < na_Grid.Length; j++)
            {
                if (c_CurrentPlayerPos.Pos != na_Grid[j].Pos)
                {
                    continue;
                }
                c_CurrentGridPos    = na_Grid[j];
                t_CurrentGridEntity = na_GridEntities[j];
            }

            unsafe
            {
                if (c_CurrentGridPos.WallStates[(int)mc_CurrentMessage.WallDirection] == (byte)WallStates.Damaged)
                {
                    Debug.Log($"Already Damaged: {c_CurrentGridPos}");
                    U_ServerUtils.NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 12);
                }
                else
                {
                    c_CurrentGridPos.WallStates[(int)mc_CurrentMessage.WallDirection] = (byte)WallStates.Damaged;
                    ecb_Cleanup.SetComponent(t_CurrentGridEntity, c_CurrentGridPos);

                    Vector2Int t_DuplicateWall = default;
                    switch (mc_CurrentMessage.WallDirection)
                    {
                    case WallIndexes.Up:
                        t_DuplicateWall = c_CurrentGridPos.Pos + new Vector2Int(0, -1);
                        break;

                    case WallIndexes.Down:
                        t_DuplicateWall = c_CurrentGridPos.Pos + new Vector2Int(0, 1);
                        break;

                    case WallIndexes.Left:
                        t_DuplicateWall = c_CurrentGridPos.Pos + new Vector2Int(-1, 0);
                        break;

                    case WallIndexes.Right:
                        t_DuplicateWall = c_CurrentGridPos.Pos + new Vector2Int(1, 0);
                        break;

                    default:
                        break;
                    }
                    Debug.Log($"Broken Wall: {c_CurrentGridPos}");

                    for (int j = 0; j < na_Grid.Length; j++)
                    {
                        if (t_DuplicateWall != na_Grid[j].Pos)
                        {
                            continue;
                        }

                        C_GridPos c_UpdatedDuplicateWall = na_Grid[j];

                        switch (mc_CurrentMessage.WallDirection)
                        {
                        case WallIndexes.Up:
                            c_UpdatedDuplicateWall.WallStates[(int)WallIndexes.Down] = (byte)WallStates.Damaged;
                            break;

                        case WallIndexes.Down:
                            c_UpdatedDuplicateWall.WallStates[(int)WallIndexes.Up] = (byte)WallStates.Damaged;
                            break;

                        case WallIndexes.Left:
                            c_UpdatedDuplicateWall.WallStates[(int)WallIndexes.Right] = (byte)WallStates.Damaged;
                            break;

                        case WallIndexes.Right:
                            c_UpdatedDuplicateWall.WallStates[(int)WallIndexes.Left] = (byte)WallStates.Damaged;
                            break;

                        default:
                            break;
                        }
                        ecb_Cleanup.SetComponent(na_GridEntities[j], c_UpdatedDuplicateWall);
                        Debug.Log($"Broken Wall: {c_UpdatedDuplicateWall}");
                    }

                    U_ServerUtils.NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 13);

                    // Notifies the enemy visor
                    int i_TileHandle;
                    U_ServerUtils.
                    NotifyEnemyVisor(
                        ref ecb_Cleanup,
                        in na_PlayerEntities,
                        in na_PlayerIndexes,
                        in na_PlayerPositions,
                        mc_CurrentMessage.PlayerId,
                        0, out i_TileHandle);

                    WallIndexes e_RelativeToEnemyDirection = U_ServerUtils.MapTilePositionToIndex(i_TileHandle);
                    int         i_EnemySoundMessage        = 0;
                    switch (e_RelativeToEnemyDirection)
                    {
                    case WallIndexes.Up:
                        i_EnemySoundMessage = 15;
                        break;

                    case WallIndexes.Down:
                        i_EnemySoundMessage = 18;
                        break;

                    case WallIndexes.Left:
                        i_EnemySoundMessage = 16;
                        break;

                    case WallIndexes.Right:
                        i_EnemySoundMessage = 17;
                        break;

                    case WallIndexes.Diagonal:
                        i_EnemySoundMessage = 14;
                        break;

                    case WallIndexes.Center:
                        i_EnemySoundMessage = 1;
                        break;

                    default:
                        break;
                    }

                    U_ServerUtils.NotifyEnemyText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, i_EnemySoundMessage);
                }
            }
            ecb_Cleanup.DestroyEntity(na_BreakWallMessageEntities[i]);
        }

        na_BreakWallMessageEntities.Dispose();
        na_BreakWallMessages.Dispose();

        na_PlayerEntities.Dispose();
        na_PlayerIndexes.Dispose();
        na_PlayerPositions.Dispose();

        na_GridEntities.Dispose();
        na_Grid.Dispose();
        return(inputDependencies);
    }
예제 #2
0
파일: S_MovePlayer.cs 프로젝트: rauiz/encs2
    protected override JobHandle OnUpdate(JobHandle inputDependencies)
    {
        if (m_MovePlayerMessages.CalculateEntityCount() == 0)
        {
            return(inputDependencies);
        }

        SINGLETON_GridDefinitions t_GridDef = GetSingleton <SINGLETON_GridDefinitions>();

        NativeArray <Entity>        na_MovePlayerMessageEntities = m_MovePlayerMessages.ToEntityArray(Allocator.TempJob);
        NativeArray <MC_MovePlayer> na_MovePlayerMessages        = m_MovePlayerMessages.ToComponentDataArray <MC_MovePlayer>(Allocator.TempJob);

        NativeArray <Entity>        na_PlayerEntities  = m_Players.ToEntityArray(Allocator.TempJob);
        NativeArray <C_PlayerIndex> na_PlayerIndexes   = m_Players.ToComponentDataArray <C_PlayerIndex>(Allocator.TempJob);
        NativeArray <C_PlayerPos>   na_PlayerPositions = m_Players.ToComponentDataArray <C_PlayerPos>(Allocator.TempJob);

        NativeArray <C_GridPos> na_Grid = m_Grid.ToComponentDataArray <C_GridPos>(Allocator.TempJob);


        EntityCommandBuffer ecb_Cleanup = CleanupMessageBarrier.CreateCommandBuffer();
        MC_MovePlayer       mc_CurrentMessage;

        Entity      t_CurrentPlayerEntity = default;
        C_PlayerPos c_CurrentPlayerPos    = default;
        C_PlayerPos c_EnemyPlayerPos      = default;

        C_GridPos c_CurrentGridPos;

        for (int i = 0; i < na_MovePlayerMessages.Length; i++)
        {
            mc_CurrentMessage = na_MovePlayerMessages[i];

            for (int j = 0; j < na_PlayerIndexes.Length; j++)
            {
                if (mc_CurrentMessage.PlayerId != na_PlayerIndexes[j].PlayerId)
                {
                    c_EnemyPlayerPos = na_PlayerPositions[j];
                }
                else
                {
                    t_CurrentPlayerEntity = na_PlayerEntities[j];
                    c_CurrentPlayerPos    = na_PlayerPositions[j];
                }
            }

            for (int j = 0; j < na_Grid.Length; j++)
            {
                if (c_CurrentPlayerPos.Pos != na_Grid[j].Pos)
                {
                    continue;
                }
                c_CurrentGridPos = na_Grid[j];
                break;
            }

            unsafe
            {
                if (c_CurrentGridPos.WallStates[(int)mc_CurrentMessage.WallDirection] == (byte)WallStates.Open)
                {
                    Vector2Int t_NewPos = default;
                    switch (mc_CurrentMessage.WallDirection)
                    {
                    case WallIndexes.Up:
                        t_NewPos = c_CurrentPlayerPos.Pos + new Vector2Int(0, -1);
                        break;

                    case WallIndexes.Down:
                        t_NewPos = c_CurrentPlayerPos.Pos + new Vector2Int(0, 1);
                        break;

                    case WallIndexes.Left:
                        t_NewPos = c_CurrentPlayerPos.Pos + new Vector2Int(-1, 0);
                        break;

                    case WallIndexes.Right:
                        t_NewPos = c_CurrentPlayerPos.Pos + new Vector2Int(1, 0);
                        break;

                    default:
                        break;
                    }

                    if ((t_NewPos.x >= 0 && t_NewPos.x < t_GridDef.RowCount) &&
                        (t_NewPos.y >= 0 && t_NewPos.y < t_GridDef.ColumnCount))
                    {
                        ecb_Cleanup.SetComponent(t_CurrentPlayerEntity, new C_PlayerPos
                        {
                            Pos = t_NewPos
                        });

                        // Notifies the player that he moved.
                        U_ServerUtils
                        .NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 6);

                        // Finds the new position in the grid.
                        for (int j = 0; j < na_Grid.Length; j++)
                        {
                            if (t_NewPos != na_Grid[j].Pos)
                            {
                                continue;
                            }
                            c_CurrentGridPos = na_Grid[j];
                            break;
                        }

                        // Writes to the player the status of the room.
                        if (c_CurrentGridPos.WallStates[(int)WallIndexes.Up] == (byte)WallStates.Damaged)
                        {
                            U_ServerUtils.NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 2);
                        }
                        if (c_CurrentGridPos.WallStates[(int)WallIndexes.Left] == (byte)WallStates.Damaged)
                        {
                            U_ServerUtils.NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 3);
                        }
                        if (c_CurrentGridPos.WallStates[(int)WallIndexes.Right] == (byte)WallStates.Damaged)
                        {
                            U_ServerUtils.NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 4);
                        }
                        if (c_CurrentGridPos.WallStates[(int)WallIndexes.Down] == (byte)WallStates.Damaged)
                        {
                            U_ServerUtils.NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 5);
                        }

                        // Notifies the enemy visor
                        int i_TileHandle;
                        U_ServerUtils.
                        NotifyEnemyVisor(
                            ref ecb_Cleanup,
                            in na_PlayerEntities,
                            in na_PlayerIndexes,
                            in na_PlayerPositions,
                            mc_CurrentMessage.PlayerId,
                            0, out i_TileHandle);

                        WallIndexes e_RelativeToEnemyDirection = U_ServerUtils.MapTilePositionToIndex(i_TileHandle);
                        int         i_EnemySoundMessage        = 0;
                        switch (e_RelativeToEnemyDirection)
                        {
                        case WallIndexes.Up:
                            i_EnemySoundMessage = 8;
                            break;

                        case WallIndexes.Down:
                            i_EnemySoundMessage = 11;
                            break;

                        case WallIndexes.Left:
                            i_EnemySoundMessage = 9;
                            break;

                        case WallIndexes.Right:
                            i_EnemySoundMessage = 10;
                            break;

                        case WallIndexes.Diagonal:
                            i_EnemySoundMessage = 7;
                            break;

                        case WallIndexes.Center:
                            i_EnemySoundMessage = 1;
                            break;

                        default:
                            break;
                        }

                        U_ServerUtils.NotifyEnemyText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, i_EnemySoundMessage);
                    }
                    else
                    {
                        // Notifies the player that he failed to move due to touching the edge of the Grid.
                        U_ServerUtils
                        .NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, 33);
                    }
                }
                else
                {
                    int i_MessageIndex = -1;
                    switch (mc_CurrentMessage.WallDirection)
                    {
                    case WallIndexes.Up:
                        i_MessageIndex = 2;
                        break;

                    case WallIndexes.Down:
                        i_MessageIndex = 5;
                        break;

                    case WallIndexes.Left:
                        i_MessageIndex = 3;
                        break;

                    case WallIndexes.Right:
                        i_MessageIndex = 4;
                        break;

                    default:
                        break;
                    }
                    // Notifies the player that he failed to move due to the wall being broken.
                    U_ServerUtils
                    .NotifyPlayerText(ref ecb_Cleanup, in na_PlayerEntities, in na_PlayerIndexes, mc_CurrentMessage.PlayerId, i_MessageIndex);
                }
            }
            ecb_Cleanup.DestroyEntity(na_MovePlayerMessageEntities[i]);
        }

        na_MovePlayerMessageEntities.Dispose();
        na_MovePlayerMessages.Dispose();

        na_PlayerEntities.Dispose();
        na_PlayerIndexes.Dispose();
        na_PlayerPositions.Dispose();

        na_Grid.Dispose();
        return(inputDependencies);
    }