lucia.utils
lucia.utils.instance_checker
InstanceChecker
InstanceChecker(self, f)
An instance checker
This is similar to bgt's instance object, to make sure a game can be running only once.
args: f (str): The name to be registered as a mutex.
is_running
InstanceChecker.is_running(self)
check if another instance is already running
returns: True if this instance is already registered, false otherwise.
lucia.utils.network
number_to_words
number_to_words(number, include_and=False)
returns a string representation for the given number
lucia.utils.rotation
Rotation class
This is modeled on the bgt rotation class from Sam Tupy. Input and output are in degrees.
Vector
Vector(self, x=0.0, y=0.0, z=0.0)
an object representing what bgt calls a vector
This represents a point in 3-space, where positive x is right, positive y is forward, and positive z is up. The property coords can be used to get and set a tuple of the coordinates represented by this vector with no rounding applied.
args: x (float, optional): The starting x coordinate of this vector y (float, optional): The starting y coordinate of this vector z (float, optional): The starting z coordinate of this vector.
move
move(coords, deg, pitch=0.0, factor=1.0)
moves a vector in a given direction by a scale factor of factor
Takes a vector as input, applies the translation, and returns a vector as output. Probably best done as player.coords=move(player.coords,player.facing) or something similar. The scale factor is used if you wish to move more than 1 coordinate, otherwise you simply apply the unit circle.
args: coords (tuple or list): The current point in 3-space you wish to move. deg (float): The current facing of an object pitch (float, optional): The vertical degrees you wish to move. Defaults to 0, no vertical movement. factor (float, optional): The scale factor you wish to move by. Passing 1 is equivalent to one unit move in any direction, but for warping in a particular direction you can pass a higher factor. Defaults to 1.
returns: a transformed vector
calculate_angle
calculate_angle(x1, y1, x2, y2, deg)
given two points, returns the angle of the second one relative to the first.
This function is useful for reporting a direction of an object to a player, for example. In this example the 'origin' point would be the player and the 'distant' point would be the object the player is tracking.
args: x1 (float): The x coordinate of the origin point. y1 (float): The y coordinate of the origin point. x2 (float): The x coordinate of the distant point y2 (float): The y coordinate of the distant point deg (float): The absolute direction the origin point is facing, for offsets.
returns: an angle (in degrees) of the distant point relative to the origin point, shifted by the orientation of the origin.
get_1d_distance
get_1d_distance(x1, x2)
returns the distance on a 1-dimensional plane from x1 to x2
get_2d_distance
get_2d_distance(x1, y1, x2, y2)
returns the pythagorean distance between two points on an x-y plane.
get_3d_distance
get_3d_distance(x1, y1, z1, x2, y2, z2)
returns the pythagorean distance between two points in 3-space.
lucia.utils.timer
Timer
Timer(self)
A timer class, to track time mesured in millis
elapsed
Returns the exact elapsed time since this timer was created or last restarted.
restart
Timer.restart(self)
Restarts the timer, and set it's elapsed time to 0.
pause
Timer.pause(self)
Pauses the timer at a certain position.
resume
Timer.resume(self)
Resumes the timer after being paused.