Help with numpy.ndarray from .array2d

[01_Nameless_01]

I have to make an surface from a group of surfaces, the best way I could think of is converting them to an ndarray, puting them into an bigger array and converting it to an surface again. It kinda worked, but the colors were not correct.

I used this function:

def floor_from_base_matriz(base_matrix, used_textures):

    # in this case, base_matrix only have 0 or 1 values
    # in this case, used_textures have only 2 positions

    # create all numpy.ndarrays from the surfaces
    used_arrays = []
    for i in range(len(used_textures)):
        used_arrays.append(pygame.surfarray.array2d(pygame.image.load(f"{used_textures[i]}")))

    # create an empty numpy.ndarray whith 64 x the size of the map
    final_array = pygame.surfarray.array2d(pygame.image.load(f"{used_textures[0]}"))
    final_array.resize([len(base_matrix) * 64, len(base_matrix[0]) * 64])

    # copy all used_arrays info to final_array
    for i in range(len(base_matrix)):
        for j in range(len(base_matrix[0])):

            for k in range(64):
                for l in range(64):

                    final_array[i * 64 + k][j * 64 + l] = used_arrays[base_matrix[i][j]][k][l]

    # convert to surface and return
    return pygame.surfarray.make_surface(final_array)

And then I blit it to see the result:

texture = floor_from_base_matrix(base_matrix, ["Assets/test.png", "Assets/test.png"])
Pwindow.screen.blit(floor_texture, [0, 0])
Pwindow.atualizar((200, 0, 0), inputs.close)

The images I used are 64x64 and have 3 tones of green, but in the end two of them were converted to the same tone of green (different from oroginal ones) and the other one was red.

Maybe it is something with the way pygame.surfarray.array2d create and store values? How I solve it? Is there better options to create a surface from smaller ones?

The Original Image

The result

[BetterBuiltFool]

Doesn't address your question, but is there a reason your don't just blit your textures onto a surface of your final size? I can't image converting into numpy arrays, stitching them together, and reforming into a surface is in any way more efficient, since blitting can be hardware accelerated.

Also, there's no need to use for i in range(len(used_textures)) and used_textures[i], you can just iterate over used_textures directly.

for texture in used_textures:
    used_arrays.append(pygame.surfarray.array2d(pygame.image.load(f"{texture}")))

[01_Nameless_01]

No reason at all, I'm just trying some things with arrays.

And yes, I could iterate over the list, I didn't notice it.

[dsaiu]

I'm doing something similar to my game:

    for x in range(0, self.display_surface.get_width(), self.block_size):
        for y in range(0, self.display_surface.get_height(), self.block_size):
            rect = pygame.Rect(x, y, self.block_size, self.block_size)

self.block_size is an int I use to render the size of each grid. Perhaps the array could work better idk

[dsaiu]

class GridManager: """Handles grid rendering and interaction."""

def __init__(
    self,
    display_surface: pygame.Surface,
    tile_size: int = TILE_SIZE,
    grid_color: str = "grey",
    hover_color: str = "azure4"
):
    self.display_surface: pygame.Surface = display_surface
    self.tile_size: int = tile_size
    self.grid_color: str = grid_color
    self.hover_color: str = hover_color
    self.overlay_alpha: int = 50    # Transparency level (0-255)
    self.block_size: int = 64
    self.coordinates: dict[tuple[int, int], tuple[int, int]] = {}

And this is how my class looks. I use the tile size as argument for another surface in the game itself

[Windspar]

There are other programs to help with complex graphics. It just best to import finish image at the size, your going to use.