PyTweening

1.2.0 · active · verified Fri Apr 10

PyTweening is a lightweight Python library providing a collection of tweening (also known as easing) functions. These functions allow for smooth, non-linear interpolation between values, commonly used to create natural-looking animations in graphical applications or games. The library is currently at version 1.2.0 and receives periodic updates to enhance functionality and maintain compatibility.

Warnings

gotcha Tweening functions generally expect an input 'n' between 0.0 and 1.0 representing the progress of the animation. While the library itself doesn't strictly enforce this range check internally anymore, providing values outside of this range might lead to unexpected results, especially for functions designed to stay within the 0.0-1.0 output range.
Fix: Ensure that the input parameter 'n' to tweening functions (e.g., `pytweening.linear(n)`) is always a float between 0.0 and 1.0 for predictable behavior. Custom functions like `easeInOutElastic` might naturally go outside this range for visual effects, but the input should still be 0.0-1.0.
gotcha When using iterator functions like `pytweening.iterLinear` to generate sequences of points, some floating-point rounding errors may naturally occur in the output coordinates. This is a common characteristic of floating-point arithmetic.
Fix: Be aware of potential minor inaccuracies when precise integer coordinates are required for iterated lines. If pixel-perfect integer coordinates are critical, consider explicit rounding or using integer-based line algorithms.
gotcha PyTweening provides client-side animation logic. When integrating into multi-client environments (e.g., online games) or systems involving physics, performing local client-side tweens on shared objects can lead to desynchronization. Different clients might observe inconsistent object positions due to network latency or varying execution times.
Fix: For shared game objects or physics-driven movements in networked applications, it is often better to manage the 'tween' state (start/end positions, duration, easing type) on the server and replicate the results, or use server-side interpolation to ensure consistency across all clients.

Install

pip install pytweening Install with pip

Imports

pytweening
```
import pytweening
```
All tweening functions and utilities are directly available as attributes of the imported 'pytweening' module.

Quickstart

This quickstart demonstrates how to import `pytweening` and use some of its core tweening functions. Tweening functions typically take a float `n` from 0.0 (start) to 1.0 (end) and return a new float, which can then be used to interpolate between two desired values.

import pytweening

# Get a linear tween value at 50% progress
linear_value = pytweening.linear(0.5)
print(f"Linear tween at 0.5: {linear_value}")

# Get an ease-in-quad tween value at 50% progress
ease_in_quad_value = pytweening.easeInQuad(0.5)
print(f"EaseInQuad tween at 0.5: {ease_in_quad_value}")

# Example of interpolating a value from start to end using a tweening function
start_val = 0
end_val = 100
progress = 0.75 # 75% of the animation progress
tweened_progress = pytweening.easeInOutSine(progress)

interpolated_value = start_val + (end_val - start_val) * tweened_progress
print(f"Interpolated value at {progress} progress (easeInOutSine): {interpolated_value}")

view raw JSON →