旋转对象以放置在二维数组中

Question

I'm trying to create a basic RTS style grid. The grid works perfectly and I can place object by setting a number to anything other than 0.

That's the easy part. currently im trying to allow each object that is placed to be rotated. The objects that can be rotated can be any size eg 1x1, 2x1, 3x4 etc, and all object have an entry block which needs to be rotated with the object.

For example.

My grid is empty

0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

and I can place an object shown below:

1 2 1
1 1 1

which will place like

0 0 0 0 0 0 0
0 1 2 1 0 0 0       1 2 1
0 1 1 1 0 0 0       1 1 1
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

but when rotated it should place like

1 2 1 0 1 1 0     1 2 1   1 1  
1 1 1 0 1 2 0     1 1 1   1 2  
0 0 0 0 1 1 0             1 1  
0 1 1 0 0 0 0       1 1        
0 2 1 0 1 1 1       2 1   1 1 1
0 1 1 0 1 2 1       1 1   1 2 1

Im trying to figure out how this could be acheived in code considering that the object can be of different shapes? :(

1 1 2 1    1 1 1    1 1 1 1    1 1 1
1 1 1 1    1 1 1    1 1 1 1    2 1 1
1 1 1 1    1 1 2    1 2 1 1    1 1 1
           1 1 1               1 1 1

Answer 1

I figured out how to accomplish this from another board on here.

First thing I did was store the object in a 2 dimensional array eg

1 2 1 1
1 1 1 1

I then transposed the array leaving me with this array

1 1
2 1
1 1
1 1

And then I rotated each row leaving me with my final rotated object

1 1
1 2
1 1
1 1

And for 180+ rotations I just use this technique again to reach the desired rotation :)

My final Array Class in Unity3D C#

using UnityEngine;
using System.Collections;

namespace Arrays {

    public class Array {

        public static int[,] Rotate(int[,] array)
        {
            return Rotate90 (array);
        }

        public static int[,] Rotate90(int[,] array)
        {
            return RotateArrayRow( Transpose(array) );
        }

        public static int[,] Rotate180(int[,] array)
        {
            return Rotate90(Rotate90(array));;
        }

        public static int[,] Rotate270(int[,] array)
        {
            return Rotate90(Rotate180(array));;
        }

        private static int[,] RotateArrayRow(int[,] array){
            int x = array.GetLength(1);
            int y = array.GetLength(0);
            int[,] temp = new int[y,x];
            for(int i=0; i<y; i++)
            {
                for(int j=0; j<x; j++)
                {
                    temp[i,x-j-1] = array[i,j];
                }
            }
            return temp;
        }

        public static int[,] Transpose(int[,] array){
            int x = array.GetLength(1);
            int y = array.GetLength(0);
            int[,] temp = new int[x,y];

            for(int i=0; i<y;i++){
                for(int j=0; j<x; j++){
                    temp[j,i] = array[i,j];
                }
            }

            return temp;
        }

        public static void Log(int[,] array){
            for(int i=0; i<array.GetLength(0); i++)
            {
                string line = "";
                for(int j=0; j<array.GetLength(1); j++)
                {
                    line += array[i,j] + " ";
                }
                Debug.Log(line);
            }
        }
    }
}

Answer 2

One thing to think about first is that to rotate your objects you only need to implement one rotation function: 90 degrees in one direction. The other rotations just repeat this operation 2 or 3 times, simplifying your logic.

There are two mappings from original to rotated array you need to consider:

1. How do the dimensions map?
2. How do the indices map?

1 is easy: the dimensions are swapped. A rotated 1x4 becomes 4x1.

2 depends on your implementation, but if you're using 2d coordinates [x, y] => [y, -x] or [-y, x] depending on direction of rotation.