搜索：

清除此提示信息

TableOfContents

pygame.mouse

pygame中处理鼠标的模块

鼠标函数可以用来获取鼠标设备的当前状态。这些函数也可以用来改变系统鼠标指针。

当显示模式设置后，事件队列就会开始收到鼠标事件。当按下和释放鼠标的按键时，会产生pygame.MOUSEBUTTONDOWN和pygame.MOUSEBUTTONUP事件。这些事件包含一个button属性表示哪些键被按下。滚动鼠标滚轮会产生pygame.MOUSEBUTTONDOWN事件。当向上滚动滚轮时button的值是4，向下滚动时button的值是5。当移动鼠标时，会产生pygame.MOUSEMOTION事件。鼠标移动事件会被分解成一组较小的精确的移动事件。当鼠标移动时，会有很多事件被放在队列中。鼠标移动事件没有被正确的清除，常常是事件队列被填满的主要原因。

如果鼠标指针被隐藏，输入被当前的display捕获，鼠标会进入虚拟输入模式，这种模式下鼠标的相对位移不会收到屏幕边界的影响。参看pygame.mouse.set_visible和pygame.event.set_grab函数来实现这样的模式。

1. pygame.mouse.get_pressed

获取鼠标按键的状态

pygame.moouse.get_pressed(): return (button1, button2, button3)

返回一个布尔值的列表，包含所有鼠标按键的状态。True表示在函数调用时鼠标按键被按下了。

注意，要获取所有鼠标事件，最好使用pygame.event.wait()或者pygame.event.get()函数并检查所有的MOUSEBUTTONDOWN、MOUSEBUTTONUP、MOUSEMOTION事件。

注意，在X11上某些XServer使用中键模拟功能，当你同时按下按键1和按键3时，会发生一个按键2事件。

注意，记得在调用这个函数前调用pygame.event.get。否则他不会工作。

2. pygame.mouse.get_pos

获取鼠标指针的位置

pygame.mouse.get_pos(): return (x, y)

返回x和y表示鼠标指针的位置。这个位置是相对于display的左上角的位置。指针位置可以在display窗口的外面，但是总是在屏幕内部。

3. pygame.mouse.get_rel

获得鼠标指针的位移

pygame.mouse.get_rel(): return (x, y)

返回前一次调用这次函数到这次调用鼠标移动的x和y值。鼠标指针的相对位移被限制在屏幕边缘的内部，但是虚拟输入鼠标模式可以突破这个限制。

4. pygame.mouse.set_pos

设置鼠标指针的位置

pygame.mouse.set_pos([x, y]): return None

设置当前鼠标位置为给定的值。如果鼠标指针是可见的，它会跳到新的坐标位置。移动鼠标会产生新的pygame.MOUSEMOTION事件。

5. pygame.mouse.set_visible

隐藏或者显示鼠标指针

pygame.mouse.set_visible(bool): return bool

如果参数是True，则鼠标指针会显示出来。这个函数会返回以前的鼠标指针可见状态。

6. pygame.mouse.get_focused

检查display是否取得了鼠标输入焦点

pygame.mouse.get_focused(): return bool

如果pygame在接受鼠标输入（或者用窗口系统的说法，是激活的或者是获得焦点的）时则返回True。

这个函数对于在窗口中工作非常有用。相比之下，在全屏模式下，这个函数总是返回True。

注意，在MS Windows中，具有鼠标输入焦点的窗口同样有键盘输入焦点。但在X-Window中，可以一个窗口接受鼠标输入事件而同时另一个窗口接受键盘事件。pygame.mouse.get_focused判断pygame的窗口是否接受鼠标输入事件。

7. pygame.mouse.set_cursor

设置系统鼠标指针的图像

pygame.mouse.set_cursor(size, hotspot, xormasks, andmasks): return None

当鼠标指针可见时，它会显示为给定的位域数组指定的黑白色的位图。size是包含指针高度和宽度的列表。hotspot是表示指针的热点位置的列表。xormasks是序列包含指针异或数据位域的序列，andmask是一组包含指针位域数据的序列。

宽度必须是8的倍数，位域数组必须是size给定的正确的大小。否则会抛出一个异常。

参看pygame.cursor模块查看更多创建默认和自定义系统指针的信息。

8. pygame.mouse.get_cursor

获取系统鼠标指针的图像

pygame.mouse.get_cursor(): return (size, hotspot, xormasks, andmasks)

获得有关鼠标系统指针的信息。返回值和传给pygame.mouse.set_cursor的参数一样。

pygame.cursors

• pygame module for cursor resources
  • pygame.cursors.compile - create binary cursor data from simple strings create binary cursor data from simple strings pygame.cursors.load_xbm - load cursor data from an xbm file load cursor data from an xbm file
  Pygame offers control over the system hardware cursor. Pygame only supports black and white cursors for the system. You control the cursor with functions inside pygame.mouse. This cursors module contains functions for loading and unencoding various cursor formats. These allow you to easily store your cursors in external files or directly as encoded python strings. The module includes several standard cursors. The pygame.mouse.set_cursor - set the image for the system mouse cursor function takes several arguments. All those arguments have been stored in a single tuple you can call like this:

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

  This module also contains a few cursors as formatted strings. You'll need to pass these to pygame.cursors.compile - create binary cursor data from simple strings function before you can use them. The example call would look like this:

  • >>> cursor = pygame.cursors.compile(pygame.cursors.textmarker_strings) >>> pygame.mouse.set_cursor(*cursor)

  The following variables are cursor bitmaps that can be used as cursor:
  • o pygame.cursors.arrow o pygame.cursors.diamond o pygame.cursors.broken_x o pygame.cursors.tri_left o pygame.cursors.tri_right
  The following strings can be converted into cursor bitmaps with pygame.cursors.compile - create binary cursor data from simple strings :
  • o pygame.cursors.thickarrow_strings o pygame.cursors.sizer_x_strings o pygame.cursors.sizer_y_strings o pygame.cursors.sizer_xy_strings

1. pygame.cursors.compile

• create binary cursor data from simple strings pygame.cursor.compile(strings, black='X', white='.', xor='o'): return data, mask A sequence of strings can be used to create binary cursor data for the system cursor. The return values are the same format needed by pygame.mouse.set_cursor - set the image for the system mouse cursor. If you are creating your own cursor strings, you can use any value represent the black and white pixels. Some system allow you to set a special toggle color for the system color, this is also called the xor color. If the system does not support xor cursors, that color will simply be black. The width of the strings must all be equal and be divisible by 8. An example set of cursor strings looks like this
  • 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 ", " ", " ", " ")
  August 27, 2006 4:58am - Anonymous

  \ZnbNzgytswsc %%%%%%%%%%%%%% _

2. pygame.cursors.load_xbm

• load cursor data from an xbm file pygame.cursors.load_xbm(cursorfile, maskfile=None): return cursor_args This loads cursors for a simple subset of XBM files. XBM files are traditionally used to store cursors on unix systems, they are an ascii format used to represent simple images. Sometimes the black and white color values will be split into two separate XBM files. You can pass a second maskfile argument to load the two images into a single cursor. The cursorfile and maskfile arguments can either be filenames or filelike object with the readlines method. The return value cursor_args can be passed directly to the pygame.mouse.set_cursor - set the image for the system mouse cursor function.

pygame.joystick

• pygame module for interacting with joystick devices The joystick module manages the joystick devices on a computer (there can be more than one). Joystick devices include trackballs and video-game-style gamepads, and the module allows the use of multiple buttons and "hats".

1. pygame.joystick.init

• initialize the joystick module pygame.joystick.init(): return None This function is called automatically by pygame.init - initialize all imported pygame modules. It initializes the joystick module. This will scan the system for all joystick devices. The module must be initialized before any other functions will work. It is safe to call this function more than once.

2. pygame.joystick.quit

• uninitialize the joystick module pygame.joystick.quit(): return None Uninitialize the joystick module. After you call this any existing joystick objects will no longer work. It is safe to call this function more than once.

3. pygame.joystick.get_init

• true if the joystick module is initialized pygame.joystick.get_init(): return bool Test if the pygame.joystick.init - initialize the joystick module function has been called.

4. pygame.joystick.get_count

• number of joysticks on the system pygame.joystick.get_count(): return count Return the number of joystick devices on the system. The count will be 0 if there are no joysticks on the system. When you create Joystick objects using Joystick(id), you pass an integer that must be lower than this count.

5. pygame.joystick.Joystick

• create a new Joystick object

            pygame.joystick.Joystick(id): return Joystick
                  Joystick.init - initialize the Joystick       initialize the Joystick
                  Joystick.quit - uninitialize the Joystick     uninitialize the Joystick
                  Joystick.get_init - check if the Joystick is initialized      check if the Joystick is initialized
                  Joystick.get_id - get the Joystick ID get the Joystick ID
                  Joystick.get_name - get the Joystick system name      get the Joystick system name
                  Joystick.get_numaxes - get the number of axes on a Joystick   get the number of axes on a Joystick
                  Joystick.get_axis - get the current position of an axis       get the current position of an axis
                  Joystick.get_numballs - get the number of trackballs on a Joystick    get the number of trackballs on a Joystick
                  Joystick.get_ball - get the relative position of a trackball  get the relative position of a trackball
                  Joystick.get_numbuttons - get the number of buttons on a Joystick     get the number of buttons on a Joystick
                  Joystick.get_button - get the current button state    get the current button state
                  Joystick.get_numhats - get the number of hat controls on a Joystick   get the number of hat controls on a Joystick
                  Joystick.get_hat - get the position of a joystick hat get the position of a joystick hat

• Create a new joystick to access a physical device. The id argument must be a value from 0 to pygame.joystick.get_count()-1. To access most of the Joystick methods, you'll need to init() the Joystick. This is separate from making sure the joystick module is initialized. When multiple Joysticks objects are created for the same physical joystick device (i.e., they have the same ID number), the state and values for those Joystick objects will be shared. The Joystick object allows you to get information about the types of controls on a joystick device. Once the device is initialized the Pygame event queue will start receiving events about its input. You can call the Joystick.get_name - get the Joystick system name and Joystick.get_id - get the Joystick ID functions without initializing the Joystick object. January 14, 2006 10:59pm - Anonymous I have both a four button and two button joystick. (Two for older games). What they have in common is that when I pull the joystick in any direction it goes FULL BLAST. I need a joystick which will move SLOWLY with a minimal turn rather than a MAXIMUM turn upon any movement of the joy stick. Is there any way to make the joystick move a little bit with small movements of the stick? If I want maximum movement I would pull the stick FULL in that direction! Please advise

  garymac@hotpop.com

5.1. Joystick.init

• initialize the Joystick Joystick.init(): return None The Joystick must be initialized to get most of the information about the controls. While the Joystick is initialized the Pygame event queue will receive events from the Joystick input. It is safe to call this more than once.

5.2. Joystick.quit

• uninitialize the Joystick Joystick.quit(): return None This will unitialize a Joystick. After this the Pygame event queue will no longer receive events from the device. It is safe to call this more than once.

5.3. Joystick.get_init

• check if the Joystick is initialized Joystick.get_init(): return bool Returns True if the init() method has already been called on this Joystick object.

5.4. Joystick.get_id

• get the Joystick ID Joystick.get_id(): return int Returns the integer ID that represents this device. This is the same value that was passed to the Joystick() constructor. This method can safely be called while the Joystick is not initialized.

5.5. Joystick.get_name

• get the Joystick system name Joystick.get_name(): return string Returns the system name for this joystick device. It is unknown what name the system will give to the Joystick, but it should be a unique name that identifies the device. This method can safely be called while the Joystick is not initialized.

5.6. Joystick.get_numaxes

• get the number of axes on a Joystick Joystick.get_numaxes(): return int Returns the number of input axes are on a Joystick. There will usually be two for the position. Controls like rudders and throttles are treated as additional axes. The pygame.JOYAXISMOTION events will be in the range from -1.0 to 1.0. A value of 0.0 means the axis is centered. Gamepad devices will usually be -1, 0, or 1 with no values in between. Older analog joystick axes will not always use the full -1 to 1 range, and the centered value will be some area around 0. Analog joysticks usually have a bit of noise in their axis, which will generate a lot of rapid small motion events.

5.7. Joystick.get_axis

• get the current position of an axis Joystick.get_axis(axis_number): return float Returns the current position of a joystick axis. The value will range from -1 to 1 with a value of 0 being centered. You may want to take into account some tolerance to handle jitter, and joystick drift may keep the joystick from centering at 0 or using the full range of position values. The axis number must be an integer from zero to get_numaxes()-1.

5.8. Joystick.get_numballs

• get the number of trackballs on a Joystick Joystick.get_numballs(): return int Returns the number of trackball devices on a Joystick. These devices work similar to a mouse but they have no absolute position; they only have relative amounts of movement. The pygame.JOYBALLMOTION event will be sent when the trackball is rolled. It will report the amount of movement on the trackball.

5.9. Joystick.get_ball

• get the relative position of a trackball Joystick.get_ball(ball_number): return x, y Returns the relative movement of a joystick button. The value is a x, y pair holding the relative movement since the last call to get_ball. The ball number must be an integer from zero to get_numballs()-1.

5.10. Joystick.get_numbuttons

• get the number of buttons on a Joystick Joystick.get_numbuttons(): return int Returns the number of pushable buttons on the joystick. These buttons have a boolean (on or off) state. Buttons generate a pygame.JOYBUTTONDOWN and pygame.JOYBUTTONUP event when they are pressed and released. December 8, 2005 9:12pm - Anonymous There is a way to know the state of a button! Joystick.get_button(n)

5.11. Joystick.get_button

• get the current button state Joystick.get_button(button): return bool Returns the current state of a joystick button.

5.12. Joystick.get_numhats

• get the number of hat controls on a Joystick Joystick.get_numhats(): return int Returns the number of joystick hats on a Joystick. Hat devices are like miniature digital joysticks on a joystick. Each hat has two axes of input. The pygame.JOYHATMOTION event is generated when the hat changes position. The position attribute for the event contains a pair of values that are either -1, 0, or 1. A position of (0, 0) means the hat is centered.

5.13. Joystick.get_hat

• get the position of a joystick hat Joystick.get_hat(hat_number): return x, y Returns the current position of a position hat. The position is given as two values representing the X and Y position for the hat. (0, 0) means centered. A value of -1 means left/down and a value of 1 means right/up: so (-1, 0) means left; (1, 0) means right; (0, 1) means up; (1, 1) means upper-right; etc. This value is digital, i.e., each coordinate can be -1, 0 or 1 but never in-between. The hat number must be between 0 and get_numhats()-1.

pygame.time

• pygame module for monitoring time Times in pygame are represented in milliseconds (1/1000 seconds). Most platforms have a limited time resolution of around 10 milliseconds.

1. pygame.time.get_ticks

• get the time in milliseconds pygame.time.get_ticks(): return milliseconds Return the number of millisconds since pygame.init - initialize all imported pygame modules was called. Before pygame is initialized this will always be 0.

2. pygame.time.wait

• pause the program for an amount of time pygame.time.wait(milliseconds): return time Will pause for a given number of milliseconds. This function sleeps the process to share the processor with other programs. A program that waits for even a few milliseconds will consume very little processor time. It is slightly less accurate than the pygame.time.delay - pause the program for an amount of time function. This returns the actual number of milliseconds used.

3. pygame.time.delay

• pause the program for an amount of time pygame.time.delay(milliseconds): return time Will pause for a given number of milliseconds. This function will use the processor (rather than sleeping) in order to make the delay more accurate than pygame.time.wait - pause the program for an amount of time. This returns the actual number of milliseconds used.

4. pygame.time.set_timer

• repeatedly create an event on the event queue pygame.time.set_timer(eventid, milliseconds): return None Set an event type to appear on the event queue every given number of milliseconds. The first event will not appear until the amount of time has passed. Every event type can have a separate timer attached to it. It is best to use the value between pygame.USEREVENT and pygame.NUMEVENTS. To disable the timer for an event, set the milliseconds argument to 0.

5. pygame.time.Clock

• create an object to help track time pygame.time.Clock(): return Clock
  • Clock.tick - update the clock update the clock Clock.tick_busy_loop - update the clock update the clock Clock.get_time - time used in the previous tick time used in the previous tick Clock.get_rawtime - actual time used in the previous tick actual time used in the previous tick Clock.get_fps - compute the clock framerate compute the clock framerate
  Creates a new Clock object that can be used to track an amount of time. The clock also provides several functions to help control a game's framerate.

5.1. Clock.tick

• update the clock Clock.tick(framerate=0): return milliseconds control timer events This method should be called once per frame. It will compute how many milliseconds have passed since the previous call. If you pass the optional framerate argument the function will delay to keep the game running slower than the given ticks per second. This can be used to help limit the runtime speed of a game. By calling Clock.tick(40) once per frame, the program will never run at more than 40 frames per second. Note that this function uses SDL_Delay function which is not accurate on every platform, but does not use much cpu. Use tick_busy_loop if you want an accurate timer, and don't mind chewing cpu.

5.2. Clock.tick_busy_loop

• update the clock Clock.tick_busy_loop(framerate=0): return milliseconds control timer events This method should be called once per frame. It will compute how many milliseconds have passed since the previous call. If you pass the optional framerate argument the function will delay to keep the game running slower than the given ticks per second. This can be used to help limit the runtime speed of a game. By calling Clock.tick(40) once per frame, the program will never run at more than 40 frames per second. Note that this function uses pygame.time.delay, which uses lots of cpu in a busy loop to make sure that timing is more acurate.

5.3. Clock.get_time

• time used in the previous tick Clock.get_time(): return milliseconds Returns the parameter passed to the last call to Clock.tick - update the clock. It is the number of milliseconds passed between the previous two calls to Pygame.tick().

5.4. Clock.get_rawtime

• actual time used in the previous tick Clock.get_rawtime(): return milliseconds Similar to Clock.get_time - time used in the previous tick, but this does not include any time used while Clock.tick - update the clock was delaying to limit the framerate.

5.5. Clock.get_fps

• compute the clock framerate Clock.get_fps(): return float Compute your game's framerate (in frames per second). It is computed by averaging the last few calls to Clock.tick - update the clock.

The End