I can create a 1-dimensional array as follows:

``````var list = []
``````

How would I create a 2-dimensional array? I can't seem to find an obvious example in the docs or project examples. In Python I think it would be:

``````var matrix = [[0 for x in range(width)] for y in range(height)]
``````

but this returns an error in Godot.

in Engine

godotscript is not python and doesn't follow the pythonic way. Simply do it the old fashion way:

``````var matrix=[]
for x in range(width):
matrix[x]=[]
for y in range(height):
matrix[x][y]=0
``````
by (698 points)
selected

This approach is returning an error " Invalid set index '0' (on base: 'Array'). " at the first step

``````matrix[x] = []
``````

Strange. I did try it yesterday. Anyway, maybe using

``````matrix.append([])
``````

does the trick. The theory for the n dimensional matrix doesn't change.

Thank you , that seems to fix the problem:

``````var matrix = []
for x in range(width):
matrix.append([])
matrix[x]=[]
for y in range(height):
matrix[x].append([])
matrix[x][y]=0
``````

Almost, I fixed it for you. Your method had some redundancies that slowed it down.

``````var matrix = []
for x in range(width):
matrix.append([])
for y in range(height):
matrix[x].append(0)
``````

## matrix[x]=[]

this sets the [] you just appended into a []

## matrix[x][y]=0

these append a [] and then set the [] to a 0, which is weird and inefficient

the cleaned up method simply starts with a [], then adds [] as rows, ex: [ [],[],[] ]
then adds 0's into the rows, ex: [ [0,0,0],[0,0,0],[0,0,0] ]

one last side note: if you are making a very large 2D array (300x300 or higher), it seems to be faster to use a while loop instead of the for each loop with the `range` method, because the `range` method does something along the lines of building an array, ex: range(3) makes an array = [0,1,2]. This is slower than simply having an increment counter, ex: int x = 0, while(x<3), x += 1

Or such:

``````func create_map(w, h):
var map = []

for x in range(w):
var col = []
col.resize(h)
map.append(col)

return map
``````

Return Null-filled array.

by (40 points)

This is the way I create 2d arrays in godot:

``````var array_a = [1,2,3,4]
var array_b = [5,6,7,8]

var array_2d = [array_a, array_b]
``````

``````array_2d[0,1] -> 2
array_2d[1,2] -> 7
``````
by (18 points)

I believe the correct way to read/write is (now):

``````array_2d[0][1] -> 2
``````

etc...

At least that's what i experienced in Godot 3.0

Seeing these awful answers; this is the most performance-friendly way of creating it:

``````func create_2d_array(width, height, value):
var a = []

for y in range(height):
a.append([])
a[y].resize(width)

for x in range(width):
a[y][x] = value

return a
``````

To be used as `array[y][x]`.

by (1,091 points)

This comment is ancient now, but why did you put y before x? That seems pretty programmer-unfriendly, considering that every other time coordinates are used, they go in alphabetical order (x,y)

@Davi-Danger, that isn't always true. It comes down to row-major vs. column major, which very much depends on the application of the 2D array. If I'm modeling something like a matrix, it isn't uncommon at all to have y first; and in some APIs it's the standard to do it that way.

After all, it doesn't just affect how the programmer sees it, it affects how it's arranged in memory.

``````#creating 2D Arrays in GDscript
var my_array = [[]]

var width = 5
var height = 5

#setting 2D Array size
for x in width:
my_array.resize(width)

for y in height:
my_array[x].resize(y)

#setting a value
my_array[0][0] = 1
``````
by (14 points)

The simplest way is probably:

``````var r = [0,0,0,0,0,0,0,0,0,0,0,0,0]#r for row
var matrix = [r,r,r,r,r,r,r,r,r,r,r,r,r,r,r]
``````
by (14 points)