pygame.cursors
pygame module for cursor resources
create binary cursor data from simple strings
load cursor data from an XBM file
pygame object representing a cursor

Pygame ofrece control sobre el cursor del hardware del sistema. Pygame admite cursores en blanco y negro (cursores de mapa de bits), así como cursores variantes del sistema y cursores de color. Podés controlar el cursor utilizando funciones dentro del módulo pygame.mouse.

Este módulo de cursores contiene funciones para cargar y decodificar varios formatos de cursores. Estas te permiten almacenar fácilmente tus cursores en archivos externos o directamente como cadenas de caracteres codificadas en Python.

El módulo incluye varios cursores estándar. La función pygame.mouse.set_cursor() toma varios argumentos. Todos estos argumentos se han almacenado en una única tupla que puedes llamar de la siguiente manera:

>>> pygame.mouse.set_cursor(*pygame.cursors.arrow)

Las siguientes variables pueden ser pasadas a pygame.mouse.set_cursor function:

  • pygame.cursors.arrow

  • pygame.cursors.diamond

  • pygame.cursors.broken_x

  • pygame.cursors.tri_left

  • pygame.cursors.tri_right

Este módulo también contiene algunos cursores como cadenas de caracters formateadas. Será necesario pasarlos a la función pygame.cursors.compile() antes de poder utilizarlos. El ejemplo de llamada se vería así:

>>> cursor = pygame.cursors.compile(pygame.cursors.textmarker_strings)
>>> pygame.mouse.set_cursor((8, 16), (0, 0), *cursor)

Las siguientes cadenas de caracteres se pueden convertir en mapas de bits de cursor con pygame.cursors.compile() :

  • pygame.cursors.thickarrow_strings

  • pygame.cursors.sizer_x_strings

  • pygame.cursors.sizer_y_strings

  • pygame.cursors.sizer_xy_strings

  • pygame.cursor.textmarker_strings

pygame.cursors.compile()
create binary cursor data from simple strings
compile(strings, black='X', white='.', xor='o') -> data, mask

Se puede utilizar una secuencia de cadenas para crear datos binarios de cursor para el cursor del sistema. Esto devuelve los datos binarios en forma de dos tuplas. Estas se pueden pasar como tercer y cuarto argumento, respectivamente, de la función pygame.mouse.set_cursor().

Si estás creando tus propias cadenas de caracteres, podés usar cualquier valor para representar los píxeles blanco y negro. Algunos sistemas permiten establecer un color especial de alternancia para el color del sistema, también llamado color xor. Si el sistema no admite cursores xor, ese color será simplemente negro.

La altura debe ser divisible por 8. el ancho de las cadenas debe ser igual y divisible por 8. Si estas dos condiciones no se cumplen, se generará un ValueError. Un ejemplo de conjunto de cadenas de caracteres de cursor se ve así:

thickarrow_strings = (               #sized 24x24
  "XX                      ",
  "XXX                     ",
  "XXXX                    ",
  "XX.XX                   ",
  "XX..XX                  ",
  "XX...XX                 ",
  "XX....XX                ",
  "XX.....XX               ",
  "XX......XX              ",
  "XX.......XX             ",
  "XX........XX            ",
  "XX........XXX           ",
  "XX......XXXXX           ",
  "XX.XXX..XX              ",
  "XXXX XX..XX             ",
  "XX   XX..XX             ",
  "     XX..XX             ",
  "      XX..XX            ",
  "      XX..XX            ",
  "       XXXX             ",
  "       XX               ",
  "                        ",
  "                        ",
  "                        ")
pygame.cursors.load_xbm()
load cursor data from an XBM file
load_xbm(cursorfile) -> cursor_args
load_xbm(cursorfile, maskfile) -> cursor_args

Esto carga cursores para un subconjunto simple de archivos XBM . Los archivos XBM son tradicionalmente utilizados para almacenar cursores en sistemas UNIX, son un formato ASCII utilizado para representar imágenes simples.

A veces, los valores de color blanco y negro se dividen en dos archivos XBM separados. Podés pasar un segundo argumento de archivo de máscara (maskfile) para cargar las dos imágenes en un solo cursor.

Los argumentos 'cursorfile' y 'maskfile' pueden ser nombres de archivos u objetos similares a archivos con el método 'readlines'

El valor de retorno 'cursor_args' puede ser pasado directamente a la función pygame.mouse.set_cursor().

pygame.cursors.Cursor
pygame object representing a cursor
Cursor(size, hotspot, xormasks, andmasks) -> Cursor
Cursor(hotspot, surface) -> Cursor
Cursor(constant) -> Cursor
Cursor(Cursor) -> Cursor
Cursor() -> Cursor
copy the current cursor
Gets the cursor type
Gets the cursor data

En pygame 2, hay 3 tipos de cursores que podés crear para darle un poco de brillo adicional a tu juego. Existen cursores de tipo bitmap, que ya existían en Pygame 1.x, y se compilan a partir de una cadena de caracteres o se cargan desde un archivo xbm. Luego, están los cursores de tipo system, donde eliges un conjunto predefinido que transmitirá el mismo significado pero se verá nativo en diferentes sistemas operativos. Por último puedes crear un cursor de tipo color, que muestra una superficie de Pygame como el cursor.

Creando un cursor del sistema

Elegí una constante de esta lista, pasala a pygame.cursors.Cursor(constant), ¡y listo! Tené en cuenta que no todos los sistemas admiten todos los cursores del sistema y es posible que obtengas una sustitución en su lugar. Por ejemplo, en MacOS, WAIT/WAITARROW debería mostrarse como una flecha y SIZENWSE/SIZENESW/SIZEALL debería mostrarse como una mano cerrada. Y en Wayland, cada cursor SIZE debería aparecer como una mano. debería mostrarse como una mano cerrada.

Pygame Cursor Constant           Description
--------------------------------------------
pygame.SYSTEM_CURSOR_ARROW       arrow (flecha)
pygame.SYSTEM_CURSOR_IBEAM       i-beam (viga en i, o viga de doble t)
pygame.SYSTEM_CURSOR_WAIT        wait (espera)
pygame.SYSTEM_CURSOR_CROSSHAIR   crosshair (cruz de mira)
pygame.SYSTEM_CURSOR_WAITARROW   small wait cursor (pequeño cursor de espera)
                                 (or wait if not available) (o si no está disponible, espera)
pygame.SYSTEM_CURSOR_SIZENWSE    double arrow pointing (doble flecha apuntando al noroeste y sudeste)
                                 northwest and southeast
pygame.SYSTEM_CURSOR_SIZENESW    double arrow pointing (doble flecha apuntando al noreste y sudoeste)
                                 northeast and southwest
pygame.SYSTEM_CURSOR_SIZEWE      double arrow pointing (doble flecha apuntando al oeste y al este)
                                 west and east
pygame.SYSTEM_CURSOR_SIZENS      double arrow pointing (doble flecha apuntando al norte y sur)
                                 north and south
pygame.SYSTEM_CURSOR_SIZEALL     four pointed arrow pointing (flecha de cuatro puntas apuntando al norte, sur, este y oeste)
                                 north, south, east, and west
pygame.SYSTEM_CURSOR_NO          slashed circle or crossbones (círculo tachado o calaveras cruzadas)
pygame.SYSTEM_CURSOR_HAND        hand (mano)

Creando un cursor sin pasar argumentos

Además de las constantes del cursor disponibles y descritas anteriormente, también podés llamar a pygame.cursors.Cursor(), y tu cursor está listo (hacer esto es lo mismo que llamar a pygame.cursors.Cursor(pygame.SYSTEM_CURSOR_ARROW)) Haciendo una de estas llamadas lo que en realidad se crea es un cursor del sistema utilizando la imagen nativa predeterminada.

Creando un curosr de color

Para crear un cursor de color, hay que crear un objeto Cursor a partir de un hotspot y una surface. Un hotspot es una coordenada (x,y) que determina donde en el cursor está el punto exacto. La posición debe estar dentro de los límites de la surface.

Creando un cursor de mapa de bits (bitmap)

Cuando el cursor del mouse está visible, se mostrará como un mapa de bits en blanco y negro utilizando los arrays de máscaras (bitmask) dadas. El size (tamaño) es una secuencia que contiene el ancho y alto del cursor. El ``hotspot``es una secuencia que contiene la posición del hotspot del cursor.

Un cursor tiene un ancho y alto, pero la posición del mouse está representada mediante un conjunto de coordenadas de punto. Por lo tanto, el valor pasado al hotspot del cursor ayuda a pygame a determinar exactamente en qué punto se encuentra el cursor.

xormasks``es una secuencia de bytes que contiene las máscaras de datos del cursor. Por último, ``andmasks es una secuencia de bytes que contiene los datos de máscara de bits del cursor. Para crear estas variable podemos utilizar la función pygame.cursors.compile()create binary cursor data from simple strings.

Ancho y alto deben ser múltiplos de 8, y las arrays de máscara (mask arrays) deben tener el tamaño correcto para el ancho y el alto dados. De lo contrario, se generará una excepción.

copy()
copy the current cursor
copy() -> Cursor

Devuelve un nuevo objeto Cursor con los mismos datos y hotspots que el original.

type
Gets the cursor type
type -> string

El tipo será "system", "bitmap", o "color".

data
Gets the cursor data
data -> tuple

Devuelve los datos que se utilizaron para crear este objeto de cursor, envuelto en una tupla.

New in pygame 2.0.1.

Código de ejemplo para crear y establecer cursores. (Click en el mouse para cambiar el cursor)

# pygame setup
import pygame as pg

pg.init()
screen = pg.display.set_mode([600, 400])
pg.display.set_caption("Example code for the cursors module")

# create a system cursor
system = pg.cursors.Cursor(pg.SYSTEM_CURSOR_NO)

# create bitmap cursors
bitmap_1 = pg.cursors.Cursor(*pg.cursors.arrow)
bitmap_2 = pg.cursors.Cursor(
    (24, 24), (0, 0), *pg.cursors.compile(pg.cursors.thickarrow_strings)
)

# create a color cursor
surf = pg.Surface((40, 40)) # you could also load an image 
surf.fill((120, 50, 50))        # and use that as your surface
color = pg.cursors.Cursor((20, 20), surf)

cursors = [system, bitmap_1, bitmap_2, color]
cursor_index = 0

pg.mouse.set_cursor(cursors[cursor_index])

clock = pg.time.Clock()
going = True
while going:
    clock.tick(60)
    screen.fill((0, 75, 30))
    pg.display.flip()

    for event in pg.event.get():
        if event.type == pg.QUIT or (event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE):
            going = False

        # if the mouse is clicked it will switch to a new cursor
        if event.type == pg.MOUSEBUTTONDOWN:
            cursor_index += 1
            cursor_index %= len(cursors)
            pg.mouse.set_cursor(cursors[cursor_index])

pg.quit()



Edit on GitHub