part 3 core

Author: SkyNeon22

core/additions/__init__.py

@@ -0,0 +1,39 @@
+
+
+'''
+    ADDITIONS
+    ---------
+
+    - Functions
+    ----------
+        - dist_2d(a: int, b: int) 
+        - get_direction(a: list, b: list)
+        - is_negative(num: int)
+    
+    - Interpolations
+    ----------
+        - linear
+
+        ------
+        - in_sine
+        - out_sine
+        - in_out_sine
+        
+        ------
+        - in_quad
+        - out_quad
+        - in_out_quad
+
+        -----
+        - in_cubic
+        - out_cubic
+        - in_out_cubic
+
+        -------
+        AND MORE
+        -------
+'''
+
+
+from core.additions.interpolations import *
+from core.additions.utils import *

core/additions/interpolations.py

@@ -0,0 +1,321 @@
+'''Copied from ursina engine so please check it out
+
+
+   Translated from https://github.com/AndrewRayCode/easing-utils/blob/master/src/easing.js'''
+
+from math import cos, pi, sqrt, sin, asin, floor
+
+
+def linear(t):
+    return t
+
+
+def in_sine(t):
+    return -1 * cos(t * (pi / 2)) + 1
+
+
+def out_sine(t):
+    return sin(t * (pi / 2))
+
+
+def in_out_sine(t):
+    return -.5 * (cos(pi * t) - 1)
+
+
+def in_quad(t):
+    return t * t
+
+
+def out_quad(t):
+    return t * (2 - t)
+
+
+def in_out_quad(t):
+    if t < .5:
+        return 2 * t * t
+    else:
+        return - 1 + (4 - 2 * t) * t
+
+
+def in_cubic(t):
+    return t * t * t
+
+
+def out_cubic(t):
+    t1 = t - 1
+    return t1 * t1 * t1 + 1
+
+
+def in_out_cubic(t):
+    if t < .5:
+        return 4 * t * t * t
+    else:
+        return (t - 1) * (2 * t - 2) * (2 * t - 2) + 1
+
+
+def in_quart(t):
+    return t * t * t * t
+
+
+def out_quart(t):
+    t1 = t - 1
+    return 1 - t1 * t1 * t1 * t1
+
+
+def in_out_quart(t):
+    t1 = t - 1
+    if t < .5:
+        return 8 * t * t * t * t
+    else:
+        1 - 8 * t1 * t1 * t1 * t1
+
+
+def in_quint(t):
+    return t * t * t * t * t
+
+
+def out_quint(t):
+    t1 = t - 1
+    return 1 + t1 * t1 * t1 * t1 * t1
+
+
+def in_out_quint(t):
+    t1 = t - 1
+    if t < .5:
+        return 16 * t * t * t * t * t
+    else:
+        return 1 + 16 * t1 * t1 * t1 * t1 * t1
+
+
+def in_expo(t):
+    return pow(2, 10 * (t - 1))
+
+
+def out_expo(t):
+    return -pow(2, -10 * t) + 1
+
+
+def in_out_expo(t):
+    scaledTime = t * 2
+    scaledTime1 = scaledTime - 1
+
+    if scaledTime < 1:
+        return .5 * pow(2, 10 * scaledTime1)
+
+    return .5 * (-pow(2, -10 * scaledTime1) + 2)
+
+
+def in_circ(t):
+    scaledTime = t / 1
+    return -1 * (sqrt(1 - scaledTime * t) - 1)
+
+
+def out_circ(t):
+    t1 = t - 1
+    return sqrt(1 - t1 * t1)
+
+
+def in_out_circ(t):
+    scaledTime = t * 2
+    scaledTime1 = scaledTime - 2
+
+    if scaledTime < 1:
+        return -.5 * (sqrt(1 - scaledTime * scaledTime) - 1)
+
+    return .5 * (sqrt(1 - scaledTime1 * scaledTime1) + 1)
+
+
+def in_back(t, magnitude=1.70158):
+    return t * t * ((magnitude + 1) * t - magnitude)
+
+
+def out_back(t, magnitude=1.70158):
+    scaledTime = (t / 1) - 1
+    return (
+                   scaledTime * scaledTime * ((magnitude + 1) * scaledTime + magnitude)
+           ) + 1
+
+
+def in_out_back(t, magnitude=1.70158):
+    scaledTime = t * 2
+    scaledTime2 = scaledTime - 2
+    s = magnitude * 1.525
+
+    if scaledTime < 1:
+        return .5 * scaledTime * scaledTime * (
+                ((s + 1) * scaledTime) - s
+        )
+    return .5 * (
+            scaledTime2 * scaledTime2 * ((s + 1) * scaledTime2 + s) + 2
+    )
+
+
+def in_elastic(t, magnitude=.7):
+    if t == 0 or t == 1:
+        return t
+    scaledTime = t / 1
+    scaledTime1 = scaledTime - 1
+    p = 1 - magnitude
+    s = p / (2 * pi) * asin(1)
+
+    return -(
+            pow(2, 10 * scaledTime1) *
+            sin((scaledTime1 - s) * (2 * pi) / p)
+    )
+
+
+def out_elastic(t, magnitude=.7):
+    p = 1 - magnitude
+    scaledTime = t * 2
+
+    if t == 0 or t == 1:
+        return t
+
+    s = p / (2 * pi) * asin(1)
+    return (
+                   pow(2, -10 * scaledTime) *
+                   sin((scaledTime - s) * (2 * pi) / p)
+           ) + 1
+
+
+def in_out_elastic(t, magnitude=0.65):
+    p = 1 - magnitude
+    if t == 0 or t == 1:
+        return t
+
+    scaledTime = t * 2
+    scaledTime1 = scaledTime - 1
+    s = p / (2 * pi) * asin(1)
+
+    if scaledTime < 1:
+        return -.5 * (
+                pow(2, 10 * scaledTime1) *
+                sin((scaledTime1 - s) * (2 * pi) / p)
+        )
+
+    return (
+                   pow(2, -10 * scaledTime1) *
+                   sin((scaledTime1 - s) * (2 * pi) / p) * .5
+           ) + 1
+
+
+def out_bounce(t):
+    scaledTime = t / 1
+
+    if scaledTime < 1 / 2.75:
+        return 7.5625 * scaledTime * scaledTime
+
+    elif scaledTime < 2 / 2.75:
+        scaledTime2 = scaledTime - (1.5 / 2.75)
+        return (7.5625 * scaledTime2 * scaledTime2) + .75
+
+    elif scaledTime < 2.5 / 2.75:
+        scaledTime2 = scaledTime - (2.25 / 2.75)
+        return (7.5625 * scaledTime2 * scaledTime2) + 0.9375
+
+    else:
+        scaledTime2 = scaledTime - (2.625 / 2.75)
+        return (7.5625 * scaledTime2 * scaledTime2) + 0.984375
+
+
+def in_bounce(t):
+    return 1 - out_bounce(1 - t)
+
+
+def in_out_bounce(t):
+    if t < .5:
+        return in_bounce(t * 2) * .5
+
+    return (out_bounce((t * 2) - 1) * .5) + .5
+
+
+# generate boomeranged versions of all the functions
+import sys
+from textwrap import dedent
+
+for e in dir(sys.modules[__name__]):
+    item = getattr(sys.modules[__name__], e)
+    if callable(item):
+        exec(dedent(f'''
+            def {e}_boomerang(t):
+                if t < .5:
+                    return {e}(t*2)
+                else:
+                    return {e}(1-((t-.5)*2))
+        '''))
+
+
+# bezier code is translated  from WebKit implementation
+class CubicBezier:
+    __slots__ = ['a', 'b', 'c', 'd', 'cx', 'bx', 'ax', 'cy', 'by', 'ay']
+
+    def __init__(self, a, b, c, d):
+        self.a = a
+        self.b = b
+        self.c = c
+        self.d = d
+        # pre-calculate the polynomial coefficients
+        # irst and last control points are implied to be (0,0) and (1.0, 1.0)
+        self.cx = 3.0 * a
+        self.bx = 3.0 * (c - a) - self.cx
+        self.ax = 1.0 - self.cx - self.bx
+
+        self.cy = 3.0 * b
+        self.by = 3.0 * (d - b) - self.cy
+        self.ay = 1.0 - self.cy - self.by
+
+    def sample_curve_x(self, t):
+        return ((self.ax * t + self.bx) * t + self.cx) * t
+
+    def sample_curve_y(self, t):
+        return ((self.ay * t + self.by) * t + self.cy) * t
+
+    def sample_curve_derivative_x(self, t):
+        return (3.0 * self.ax * t + 2.0 * self.bx) * t + self.cx
+
+    def calculate(self, x, epsilon=.0001):
+        return self.sample_curve_y(self.solve_curve_x(x, epsilon))
+
+    def solve_curve_x(self, t, epsilon=.0001):
+        # First try a few iterations of Newton's method -- normally very fast.
+        t0 = 0
+        t1 = 0
+        t2 = 0
+        x2 = 0
+        # d2 = 0
+        # i = 0
+
+        # t2 = t
+        # for i in range(8):
+        #     x2 = self.sample_curve_x(t2) - t
+        #     if abs(x2) < epsilon:
+        #         return t2
+        #     d2 = self.sample_curve_derivative_x(t2)
+        #     if abs(d2) < epsilon:
+        #         break
+        #
+        #     t2 = t2 - x2 / d2
+
+        # No solution found - use bi-section
+        t0 = 0.0
+        t1 = 1.0
+        t2 = t
+
+        if t2 < t0:
+            return t0
+        if t2 > t1:
+            return t1
+
+        while t0 < t1:
+            x2 = self.sample_curve_x(t2)
+            if abs(x2 - t) < epsilon:
+                return t2
+            if t > x2:
+                t0 = t2
+            else:
+                t1 = t2
+
+            t2 = (t1 - t0) * .5 + t0
+
+        # Give up
+        return t2

core/additions/utils.py

@@ -0,0 +1,25 @@
+import math
+import pygame as pg
+
+# distance 2d
+def dist_2d(a, b):
+    return math.dist(a, b)
+
+# direction and speed compensation
+def get_direction(a: list, b: list):
+    return [(a[0] - b[0]) / 384, (a[1] - b[1]) / 448]
+
+def is_negative(num: int):
+    return True if num % -1 else False
+
+def get_angle(target_pos, object_pos):
+    pos1 = pg.math.Vector2(target_pos)
+    pos2 = pg.math.Vector2(object_pos)
+    return math.degrees(math.atan2(target_pos.y - object_pos.y, target_pos.x - object_pos.x))
+
+# don't even try to understand this func (it's useless)
+def speed_compensation(direction: list, speed: float): 
+    return speed / (1 - (direction[0] % 1 + direction[1] % 1))
+# don't care for now
+def direction_to_angle(direction=[0, 0]):
+    return direction[0] * 180 + direction[1] * 180