I have the following manim code to make heart animations but each heart is in a different class [
from manim import *

class HeartCurve1(Scene):
    def construct(self):
        # Title
        title = Text("Heart Curve using Polar Coordinates")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Define polar heart curve: r = 2 - 2 sin θ
        heart_curve = ParametricFunction(
            lambda t: np.array([
                16 * np.sin(t) ** 3,
                13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t),
                0
            ]) * 0.05,
            t_range = [0, TAU],
            color = RED
        )
        
        self.play(Create(heart_curve), run_time=5)
        self.wait(2)

class HeartCurve2(Scene):
    def construct(self):
        # Title
        title = Text("Heart Curve using Implicit Equation")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Equation: (x^2 + y^2 - 1)^3 = x^2 y^3
        implicit_heart = ImplicitFunction(
            lambda x, y: (x**2 + y**2 - 1)**3 - x**2 * y**3,
            color = PINK,
            stroke_width = 2
        )
        
        self.play(Create(implicit_heart), run_time=5)
        self.wait(2)

class HeartCurve3(Scene):
    def construct(self):
        # Title
        title = Text("Cardioid as a Heart Shape")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Cardioid: r = 1 - sin θ
        cardioid = ParametricFunction(
            lambda t: np.array([
                2 * (1 - np.sin(t)) * np.cos(t),
                2 * (1 - np.sin(t)) * np.sin(t),
                0
            ]) * 2,
            t_range = [0, TAU],
            color = MAROON
        )
        
        self.play(Create(cardioid), run_time=5)
        self.wait(2)

class HeartCurve4(Scene):
    def construct(self):
        # Title
        title = Text("Heart Shape using Bézier Curves")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Define control points for Bézier curves
        left_curve = CubicBezier(
            LEFT + UP,
            LEFT + 3 * UP,
            3 * LEFT + UP,
            ORIGIN
        )
        right_curve = CubicBezier(
            ORIGIN,
            3 * RIGHT + UP,
            RIGHT + 3 * UP,
            RIGHT + UP
        )
        bottom_curve = ArcBetweenPoints(
            LEFT + UP,
            RIGHT + UP,
            angle = -PI
        )
        
        heart = VGroup(left_curve, right_curve, bottom_curve).set_color(RED)
        
        self.play(Create(heart), run_time=5)
        self.wait(2)

class HeartCurve5(Scene):
    def construct(self):
        # Title
        title = Text("Mandart's Theorem Heart")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Use circles tangent to the sides of a triangle to form a heart
        triangle = Polygon(
            2 * LEFT,
            2 * RIGHT,
            2 * UP,
            color = WHITE
        )
        
        circle1 = Circle(radius = 1, color = RED).move_to(LEFT + UP/2)
        circle2 = Circle(radius = 1, color = RED).move_to(RIGHT + UP/2)
        
        heart = VGroup(triangle, circle1, circle2)
        self.play(Create(triangle))
        self.wait(1)
        self.play(Create(circle1), Create(circle2))
        self.wait(2)

class HeartCurve6(Scene):
    def construct(self):
        # Title
        title = Text("Heart using Parametric Equations")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Parametric equations
        heart_curve = ParametricFunction(
            lambda t: np.array([
                16 * np.sin(t) ** 3,
                13 * np.cos(t) - 5 * np.cos(2 * t) - 2 * np.cos(3 * t) - np.cos(4 * t),
                0
            ]) * 0.05,
            t_range = [0, TAU],
            color = RED
        )
        
        self.play(Create(heart_curve), run_time=5)
        self.wait(2)

class HeartCurve7(Scene):
    def construct(self):
        # Title
        title = Text("Heart using the Folium of Descartes")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Folium of Descartes: x^3 + y^3 = 3axy
        a = 1
        folium = ImplicitFunction(
            lambda x, y: x**3 + y**3 - 3 * a * x * y,
            color = RED,
            stroke_width = 2,
            x_range = [-3, 3],
            y_range = [-3, 3],
        )
        
        self.play(Create(folium), run_time=5)
        self.wait(2)

class HeartCurve8(Scene):
    def construct(self):
        # Title
        title = Text("Heart Shape using Sine and Cosine")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Parametric equations
        heart_curve = ParametricFunction(
            lambda t: np.array([
                np.sin(t) * np.cos(t) * np.log(abs(t)),
                abs(t) ** 0.5 * np.cos(t),
                0
            ]),
            t_range = [-2 * PI, 2 * PI],
            color = RED
        )
        
        self.play(Create(heart_curve), run_time=5)
        self.wait(2)

class HeartCurve9(Scene):
    def construct(self):
        # Title
        title = Text("Heart using Lemniscate of Bernoulli")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Lemniscate: (x^2 + y^2)^2 = 2a^2 (x^2 - y^2)
        a = 1
        lemniscate = ImplicitFunction(
            lambda x, y: (x**2 + y**2)**2 - 2 * a**2 * (x**2 - y**2),
            color = RED,
            stroke_width = 2,
            x_range = [-2, 2],
            y_range = [-2, 2],
        )
        
        self.play(Create(lemniscate), run_time=5)
        self.wait(2)

class HeartCurve10(Scene):
    def construct(self):
        # Title
        title = Text("Heart Using the Astroid Curve")
        title.to_edge(UP)
        self.play(Write(title))
        self.wait(1)
        
        # Astroid: x^{2/3} + y^{2/3} = a^{2/3}
        a = 1
        heart_curve = ParametricFunction(
            lambda t: np.array([
                a * (np.cos(t))**3,
                a * (np.sin(t))**3,
                0
            ]),
            t_range = [0, TAU],
            color = RED
        )
        
        self.play(Create(heart_curve), run_time=5)
        self.wait(2)
] How should i modify it so that i can run all the scenes with a 1 second wait inbetween each scene/class