可移动的 Unity C# 中的网格

huangapple
go评论204阅读模式
英文:

Moveable grid in Unity C#

问题

I am working on a moveable grid system for my voxel game, I implemented most of it, but I keep getting stuck at making the actual Move function. This is the code without the Move function implemented:

我正在为我的体素游戏开发一个可移动的网格系统，我已经实现了大部分功能，但是在编写实际的Move函数时遇到了困难。以下是没有实现Move函数的代码：

  1. using UnityEngine;
  2. using System;
  4. public class Grid<T>
  5. {
  6.     // ... (其他代码部分未翻译)
  7. }
  9. // ... (其他代码部分未翻译)

This is the code Im using to test it:

这是我用来测试的代码：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  5. public class Tester : MonoBehaviour
  6. {
  7.     // ... (其他代码部分未翻译)
  8. }

The example shifts the grid in the left.

这个示例将网格向左移动。

First time it logs the matrix correctly:

第一次记录矩阵时正确的输出：

1 5 9 13

2 6 10 14

3 7 11 15

4 8 12 16

However the second time its incorrect.

但是第二次输出是不正确的。

What it prints with the current move function:

使用当前的移动函数时输出的内容：

What it's supposed to print:

它应该输出的内容：

0 1 5 9

0 2 6 10

0 3 7 11

0 4 8 12

What it prints:

实际输出的内容：

2 6 10 14

3 7 11 15

4 8 12 16

0 9 13 0

I've tried this Move function, but its not working, I could not figure out how to get good startPosition and endPosition.

我尝试了这个Move函数，但它不起作用，我无法弄清楚如何获得正确的startPosition和endPosition。

  1.     public void Move(Vector3Int position)
  2.     {
  3.         // ... (其他代码部分未翻译)
  4.     }

How it should look like

应该是什么样子

The first grid with position 0, 0, 0 shows how a 2x2 part of it would look like, and the second grid with position -1, 0, 0 shows how a 2x2 part of it should look shifted, and under them are the small 2x2 grids shown. THe one which is 0 6 0 7 is how it should look in code, 0 because the code cannot guess that its supposed to be 2 and 3.

第一个位置为0, 0, 0的网格显示了它的一部分是什么样子，而第二个位置为-1, 0, 0的网格显示了它的一部分应该如何移动，下面是显示的小型2x2网格。0 6 0 7 的网格是代码中应该的样子，0 是因为代码无法猜测它应该是2和3。

英文:

I am working on a moveable grid system for my voxel game, I implemented most of it, but I keep getting stuck at making the actual Move function. This is the code without the Move function implemented:

  1. using UnityEngine;
  2. using System;
  4. public class Grid<T>
  5. {
  6.     private T[] data;
  7.     public Vector3Int position;
  8.     public Vector3Int size;
  9.     public int iSize;
  11.     public Grid(Vector3Int size)
  12.     {
  13.         this.position = new Vector3Int(0, 0, 0);
  14.         this.size = size;
  15.         this.iSize = size.x * size.y * size.z;
  16.         this.data = new T[size.x * size.y * size.z];
  17.     }
  19.     public T this[int x, int y, int z]
  20.     {
  21.         get
  22.         {
  23.             Vector3Int position = new Vector3Int(x, y, z);
  24.             if (!IsValidIndex(position - this.position))
  25.             {
  26.                 throw new IndexOutOfRangeException("Invalid position");
  27.             }
  29.             Vector3Int positionRelative = PositionToRelative(position);
  30.             return this.data[VectorToIndex(positionRelative)];
  31.         }
  32.         set
  33.         {
  34.             Vector3Int position = new Vector3Int(x, y, z);
  35.             if (!IsValidIndex(position - this.position))
  36.             {
  37.                 throw new IndexOutOfRangeException("Invalid position");
  38.             }
  40.             Vector3Int positionRelative = PositionToRelative(position);
  41.             this.data[VectorToIndex(positionRelative)] = value;
  42.         }
  43.     }
  45.     public void Move(Vector3Int newPosition)
  46.     {
  47.         Vector3Int offset = PositionToRelative(newPosition);
  48.         T[] newData = new T[data.Length];
  50.         this.data = newData;
  51.         this.position = newPosition;
  52.     }
  54.     private bool IsPositionInRange(Vector3Int position, Vector3Int start, Vector3Int end)
  55.     {
  56.         int minX = Mathf.Min(start.x, end.x);
  57.         int maxX = Mathf.Max(start.x, end.x);
  58.         int minY = Mathf.Min(start.y, end.y);
  59.         int maxY = Mathf.Max(start.y, end.y);
  60.         int minZ = Mathf.Min(start.z, end.z);
  61.         int maxZ = Mathf.Max(start.z, end.z);
  62.         return position.x >= minX
  63.             && position.x <= maxX
  64.             && position.y >= minY
  65.             && position.y <= maxY
  66.             && position.z >= minZ
  67.             && position.z <= maxZ;
  68.     }
  70.     private Vector3Int PositionToRelative(Vector3Int position)
  71.     {
  72.         return position - this.position;
  73.     }
  75.     private bool IsValidIndex(Vector3Int position)
  76.     {
  77.         int index = VectorToIndex(position);
  79.         return index >= 0 && index < this.iSize;
  80.     }
  82.     private bool IsValidIndex(int index)
  83.     {
  84.         return index >= 0 && index < this.iSize;
  85.     }
  87.     private int VectorToIndex(Vector3Int position)
  88.     {
  89.         return position.x + this.size.x * (position.y + this.size.y * position.z);
  90.     }
  91. }

This is the code Im using to test it:

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  5. public class Tester : MonoBehaviour
  6. {
  7.     void PrintMatrix<T>(Grid<T> grid)
  8.     {
  9.         for (int x = 0; x < grid.size.x; x++)
  10.         {
  11.             string output = "\n";
  13.             for (int y = 0; y < grid.size.y; y++)
  14.             {
  15.                 Vector3Int position = new Vector3Int(x, y, 0) + grid.position;
  16.                 output += grid[position.x, position.y, position.z];
  18.                 if (y < grid.size.y - 1)
  19.                 {
  20.                     output += " ";
  21.                 }
  22.             }
  24.             Debug.Log(output);
  25.         }
  26.     }
  28.     void Start()
  29.     {
  30.         Vector3Int size = new Vector3Int(4, 4, 1);
  31.         Grid<int> grid = new Grid<int>(size);
  33.         for (int x = 0; x < size.x; x++)
  34.         {
  35.             for (int y = 0; y < size.y; y++)
  36.             {
  37.                 grid[x, y, 0] = x + size.y * y + 1;
  38.             }
  39.         }
  41.         PrintMatrix<int>(grid);
  43.         Debug.Log("-------- Amogus ------------");
  45.         grid.Move(new Vector3Int(-1, 0, 0));
  47.         PrintMatrix<int>(grid);
  48.     }
  50.     void Update() { }
  51. }

The example shifts the grid in the left.

First time it logs the matrix correctly:

1 5 9 13

2 6 10 14

3 7 11 15

4 8 12 16

However the second time its incorrect.
What it prints with the current move function:

What it's supposed to print:

0 1 5 9

0 2 6 10

0 3 7 11

0 4 8 12

What it prints:

2 6 10 14

3 7 11 15

4 8 12 16

0 9 13 0

I've tried this Move function, but its not working, I could not figure out how to get good startPosition and endPosition.

  1.     public void Move(Vector3Int position)
  2.     {
  3.         T[] newData = new T[data.Length];
  4.         Vector3Int positionRelative = PositionToRelative(position);
  6.         Vector3Int startPosition = new Vector3Int(
  7.             positionRelative.x >= 0 ? positionRelative.x : this.size.x + positionRelative.x,
  8.             positionRelative.y >= 0 ? positionRelative.y : this.size.y + positionRelative.y,
  9.             positionRelative.z >= 0 ? positionRelative.z : this.size.z + positionRelative.z
  10.         );
  11.         Vector3Int endPosition = new Vector3Int(
  12.             positionRelative.x < 0 ? this.size.x : positionRelative.x,
  13.             positionRelative.y < 0 ? this.size.y : positionRelative.y,
  14.             positionRelative.z < 0 ? this.size.z : positionRelative.z
  15.         );
  17.         Debug.Log(positionRelative + " " + startPosition + " " + endPosition);
  19.         for (int x = 0; x < size.x; x++)
  20.         {
  21.             for (int y = 0; y < size.y; y++)
  22.             {
  23.                 for (int z = 0; z < size.z; z++)
  24.                 {
  25.                     Vector3Int currentPosition = new Vector3Int(x, y, z);
  26.                     int index = VectorToIndex(currentPosition);
  27.                     int translationIndex = VectorToIndex(currentPosition - positionRelative);
  29.                     if (
  30.                         IsPositionInRange(currentPosition, startPosition, endPosition)
  31.                         || !IsValidIndex(translationIndex)
  32.                     )
  33.                     {
  34.                         newData[index] = default(T);
  35.                         continue;
  36.                     }
  38.                     newData[index] = data[translationIndex];
  39.                 }
  40.             }
  41.         }
  43.         this.position = position;
  44.         data = newData;
  45.     }

How it should look like

The first grid with position 0, 0, 0 shows how a 2x2 part of it would look like, and the second grid with position -1, 0, 0 shows how a 2x2 part of it should look shifted, and under them are the small 2x2 grids shown. THe one which is 0 6 0 7 is how it should look in code, 0 because the code cannot guess that its supposed to be 2 and 3.

答案1

得分: 0

最大的问题似乎出在你的PrintMatrix函数上。

它以以下方式打印值：

  • 对于每个X，打印一行

    => X 从上到下

  • 在每行中打印4个连续的Y值

    => Y 从左到右

基本上你的打印内容更接近我所期望的，因为它正确地将所有内容向上移动了一步（负X方向）。

可能更好的方式应该是：

  1. public void PrintMatrix(Grid<T> grid)
  2. {
  3.     var output = new StringBuilder();
  5.     for (var y = 0; y < grid.size.y; y++)
  6.     {
  7.         for (var x = 0; x < grid.size.x; x++)
  8.         {
  9.             var value = grid[x, y, 0];
  10.             if (value < 10) output.Append(' ');
  11.             output.Append(value);
  13.             output.Append(' ');
  14.         }
  16.         output.Append('\n');
  17.     }
  19.     Debug.Log(output.ToString());
  20. }

这将为每个Y打印一行（=> 从上到下），然后在每行内为X打印（=> 从左到右）。

实际上，我可能会选择对索引进行环绕处理，例如：

  1. private int VectorToIndex(Vector3Int index) => VectorToIndex(index.x, index.y, index.z);
  3. private int VectorToIndex(int x, int y, int z)
  4. {
  5.     x = x.WrapAround(size.x);
  6.     y = y.WrapAround(size.y);
  7.     z = z.WrapAround(size.z);
  9.     return x + size.x * (y + size.y * z);
  10. }

使用扩展方法：

  1. public static class IntExtensions
  2. {
  3.     public static int WrapAround(this int value, int maxValue)
  4.     {
  5.         return ((value % maxValue) + maxValue) % maxValue;
  6.     }
  7. }

以处理索引在边界处的情况。

首先打印：

  1. 1  2  3  4 
  2. 5  6  7  8 
  3. 9  10 11 12 
  4. 13 14 15 16

在移动后（-1, 0, 0）的打印结果：

  1. 2  3  4  1 
  2. 6  7  8  5 
  3. 10 11 12  9 
  4. 14 15 16 13

=> 所有值向左移动了一个位置（负X方向）

还有一个小提示，你知道你也可以直接使用矢量作为索引器，并进行如下操作：

  1. public T this[Vector3Int index]
  2. {
  3.     get
  4.     {
  5.         var positionRelative = PositionToRelative(position);
  6.         return data[VectorToIndex(positionRelative)];
  7.     }
  8.     set
  9.     {
  10.         var positionRelative = PositionToRelative(position);
  11.         data[VectorToIndex(positionRelative)] = value;
  12.     }
  13. }

和/或者甚至为方便起见保留两者：

  1. public T this[int x, int y, int z]
  2. {
  3.     get => this[new Vector3Int(x, y, z)];
  4.     set => this[new Vector3Int(x, y, z)] = value;
  5. }
英文:

The biggest issue seems to be your PrintMatrix.

It prints the values the following way

  • For each X prints a line

    => X goes top to bottom

  • In each line prints 4 consecutive Y values

    => Y goes left to right

Basically your What it prints is closer to what I would expect as it correctl shifts everything one step upwards (negative X direction)

It should probably rather be e.g.

  1. public void PrintMatrix(Grid&lt;T&gt; grid)
  2. {
  3. var output = new StringBuilder();
  4. for (var y = 0; y &lt; grid.size.y; y++)
  5. {
  6. for (var x = 0; x &lt; grid.size.x; x++)
  7. {
  8. var value = grid[x, y, 0];
  9. if(value &lt; 10) output.Append(&#39; &#39;)
  10. output.Append(value);
  11. output.Append(&#39; &#39;);
  12. }
  13. output.Append(&#39;\n&#39;);
  14. }
  15. Debug.Log(output.ToString());
  16. }

which would print out a line for each Y (=> top to bottom) and then within the line X (=> left to right).

Actually I would probably go for a wrap-around of the indices and have something like e.g.

  1. private int VectorToIndex(Vector3Int index) =&gt; VectorToIndex(index.x, index.y, index.z);
  2. private int VectorToIndex(int x, int y, int z)
  3. {
  4. x = x.WrapAround(size.x);
  5. y = y.WrapAround(size.y);
  6. z = z.WrapAround(size.z);
  7. return x + size.x * (y + size.y * z);
  8. }

with extension method

  1. public static class IntExtensions
  2. {
  3. public static int WrapAround(this int value, int maxValue)
  4. {
  5. return ((value % maxValue) + maxValue) % maxValue;
  6. }
  7. }

for wrapping the index at the borders

=>

first print

  1. 1  2   3  4 
  2. 5  6   7  8 
  3. 9  10 11 12 
  4. 13 14 15 16

print after moving (-1 ,0 ,0)

  1.  2  3  4  1 
  2. 6  7  8  5 
  3. 10 11 12  9 
  4. 14 15 16 13

=> all values shifted one to the left (= negative X direction)

And just a sidenote you know you can also directly use the vector as indexer and do

  1. public T this[Vector3Int index]
  2. {
  3. get
  4. {
  5. var positionRelative = PositionToRelative(position);
  6. return data[VectorToIndex(positionRelative)];
  7. }
  8. set
  9. {
  10. var positionRelative = PositionToRelative(position);
  11. data[VectorToIndex(positionRelative)] = value;
  12. }
  13. }

and/or even keep both for convenience

  1. public T this[int x, int y, int z]
  2. {
  3. get =&gt; this[new Vector3Int(x, y, z)];
  4. set =&gt; this[new Vector3Int(x, y, z)] = value;
  5. }

huangapple
  • 本文由 发表于 2023年7月3日 16:20:57
  • 转载请务必保留本文链接：https://go.coder-hub.com/76603008.html
  • c#
  • dynamic
  • grid
  • unity-game-engine
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定