nx package

Subpackages

• nx.utils package
  • Submodules
  • nx.utils.cached_properties module
  • Module contents

Submodules

nx.audio module

Yet to be implemented.

nx.controllers module

class nx.controllers.Button(player, *key_bits)

Bases: object

Represents a button or button-like object.

static from_buttons(*buttons)

Creates a virtual button using multiple buttons.

is_pressed

Indicates whether the Button is pressed.

class nx.controllers.ButtonGroup(*buttons)

Bases: nx.controllers.Button

Represents a group of Button objects.

pressed

class nx.controllers.Controller(player)

Bases: object

Represents an abstract controller.

Attribute:player Type:Player

The player to whom the Controller belongs to.

Attribute:a_button Type:Button

The A button of the controller.

Attribute:b_button Type:Button

The B button of the controller.

Attribute:x_button Type:Button

The X button of the controller.

Attribute:y_button Type:Button

The Y button of the controller.

static from_player(player)

<todo>

Parameters:player – <todo> Returns:<todo> Controller class Return type:Controller

class nx.controllers.DualJoyconController(player)

Bases: nx.controllers.StandardController

Represents two Joy-Cons in combination, attached to rails

is_attached = True

class nx.controllers.FreeDualJoyconController(player)

Bases: nx.controllers.DualJoyconController

Represents two Joy-Cons in combination, detached from rails

is_attached = False

class nx.controllers.JoyconController(player, is_left, parent=None)

Bases: nx.controllers.Controller

Represents a single Joycon controller.

Attribute:is_left Type:bool

Whether the JoyconController is the left or right Joy-Con.

Attribute:parent Type:<todo>

The parent Controller of the Joy-Con.

Attribute:stick_button Type:Button

The button located in the analogue stick, when it is pressed.

Attribute:l_or_r_button Type:Button

Either the L or R button on the controller, dependent on which Joy-Con.

Attribute:zl_or_zr_button Type:Button

Either the ZL or ZR button on the controller, dependent on which Joy-Con.

Attribute:plus_or_minus_button Type:Button

Either the + or - button on the controller, dependent on which Joy-Con.

Attribute:stick Type:Stick

The analogue stick of the controller.

Attribute:left Type:Button

The analogue stick in the left position.

Attribute:right Type:Button

The analogue stick in the right position.

Attribute:up Type:Button

The analogue stick in the up position.

Attribute:down Type:Button

The analogue stick in the down position.

sl_button

sr_button

class nx.controllers.StandardController(player)

Bases: nx.controllers.Controller

class nx.controllers.Stick(player, is_left)

Bases: object

Represents the analogue stick on the controller.

down

Returns:A value indicating whether or not the stick is in the down position Return type:bool

left

Returns:A value indicating whether or not the stick is in the left position Return type:bool

right

Returns:A value indicating whether or not the stick is in the right position Return type:bool

up

Returns:A value indicating whether or not the stick is in the up position Return type:bool

x

The current x value of the analogue stick

Returns:The float value of the stick’s x location. Return type:float

y

The current y value of the analogue stick

Returns:The float value of the stick’s y location. Return type:float

class nx.controllers.SwitchProController(player)

Bases: nx.controllers.StandardController

Represents a Switch Pro Controller. Can also be a similar controller with the same buttons.

nx.controllers.any_pressed(player, *buttons, refresh_input=False)

Checks if any of the given buttons are pressed, or if any buttons are pressed at all in case no buttons are given.

player: Player

The player to check with.

buttons: Optional[one or more Button objects OR Tuple[Button]]

Buttons to check for. Checks if no Button is pressed if none given.

refresh_input: Optional[bool]

Whether or not to check for new inputs. Checks with inputs from last refresh if False. Defaults to False.

nx.controllers.is_pressed(player, button: nx.controllers.Button, refresh_input=False)

Checks if any of the given buttons are pressed, or if any buttons are pressed at all in case no buttons are given.

player: Player

The player to check with.

button: Button

Button to check for.

refresh_input: Optional[bool]

Whether or not to check for new inputs. Checks with inputs from last refresh if False. Defaults to False.

nx.controllers.refresh_inputs()

Refreshes inputs. Should normally be called at least once within every iteration of your main loop.

nx.controllers.which_pressed(player, *buttons, refresh_input=False)

Checks which of the given buttons are pressed.

player: Player

The player to check with.

buttons: one or more Button objects OR Tuple[Button]

Buttons to check for.

refresh_input: Optional[bool]

Whether or not to check for new inputs. Checks with inputs from last refresh if False. Defaults to False.

A list of Button objects.

nx.filesystem module

class nx.filesystem.FileSystem(base_path: str)

Bases: object

Represents a filesystem.

base_path: pathlib.Path

The base path of the filesystem.

open(file_path: str, mode='r', buffering=-1, encoding=None, errors=None, newline=None)

Opens a file given a file path and returns a file-like object. Apart from the file_path: str parameter, this method works the same way as pathlib.Path.open, thus it works pretty much the same way as the open function.

class nx.filesystem.MountableFileSystem(base_path)

Bases: nx.filesystem.FileSystem

Represents a filesystem that is able to be mounted.

base_path: pathlib.Path

The base path of the filesystem.

commit()

Commits the filesystem.

is_mounted

Whether or not the filesystem is currently mounted.

mount()

Mounts the filesystem.

open(file_path: str, mode='r', buffering=-1, encoding=None, errors=None, newline=None)

Opens a file given a file path and returns a file-like object. Apart from the file_path: str parameter, this method works the same way as pathlib.Path.open, thus it works pretty much the same way as the open function.

unmount()

Unmounts the filesystem.

class nx.filesystem.RomFS(title)

Bases: nx.filesystem.MountableFileSystem

Represents the data filesystem of a title. Do not instantiate this. Rather, get a RomFS object via nx.titles[MY_TITLE_ID].romfs.

title: Title

The title this RomFS belongs to.

base_path: pathlib.Path

The base path of the RomFS.

is_mounted

Whether the RomFS is mounted.

mount()

Yet to be implemented. Mounts the RomFS.

unmount()

Unmounts the mounted RomFS.

class nx.filesystem.Savedata(title, user=None)

Bases: nx.filesystem.MountableFileSystem

Represents the savedata filesystem of a title. Do not instantiate this. Rather, get a Savedata object via nx.titles[MY_TITLE_ID].savedata.

title: Title

The title this Savedata belongs to.

base_path: pathlib.Path

The base path of the savedata filesystem.

commit()

Commits the savedata filesystem.

is_mounted

Whether the savedata filesystem has been mounted.

mount()

Mounts the savedata filesystem.

unmount()

Unmounts the savedata filesystem.

nx.players module

class nx.players.Player(number)

Bases: object

Represents a player. You shouldn’t instantiate this yourself. Rather, access Player objects via nx.p1, nx.p2, … nx.p8.

number: int

The player’s number, e.g. Player 1’s number is 1.

controller: Controller

The player’s controller.

In addition, a Player has several properties depending on the type of Controller they are using. To begin with, a Player will have a property that points to a Button for each of the Buttons their Controller has. These properties can return None if a Button is not available on the Controller used by the Player. Furthermore, a Player will always have the properties left, right, up, down and stick. These work similar to the ones found in the Controller classes. Finally, a Player can also have the properties left_stick, right_stick, left_joycon and right_joycon if their controller has these attributes.

any_pressed(*buttons, refresh_input=False)

nx.title module

class nx.title.Title(id: int)

Bases: object

Represents a title that is installed on or inserted into the Switch. Do not instantiate this. Rather, get a Title object via nx.titles[MY_TITLE_ID]

id: int

The title ID.

romfs: RomFS

The title’s ROM filesystem.

savedata: Savedata

The title’s savedata filesystem.

nx.touch module

class nx.touch.Touch(x, y, dx, dy, angle)

Bases: object

Represents a touch point.

x: float

The x coordinate of the touch.

y: float

The y coordinate of the touch.

dx: float

The width of the touch in pixels.

dy: float

The height of the touch in pixels.

angle: float

The angle of the touch.

class nx.touch.TouchScreen

Bases: nx.controllers.Button

Represents the Switch’s touchscreen.

touches

Returns a tuple of Touch objects that represent where and how the touchscreen is touched. Can return an empty tuple.

nx.users module

class nx.users.User(id)

Bases: object

Represents a user who is registered on the Switch.

id: int

The user ID.

is_active

Returns:Whether the specified user is the current active user Return type:bool

Module contents