Python超人-宇宙模拟器

sim_lab/the_lost_planet.py

@@ -14,6 +14,8 @@ from sim_scenes.func import mayavi_run, ursina_run, create_sphere_sky
 from sim_scenes.universe_sim_scenes import UniverseSimScenes
 from simulators.func import ext_fun_for_method
 from simulators.ursina.ursina_event import UrsinaEvent
+from ursina import camera, Vec3, distance
+import math
 
 
 class TheLostPlanetSim(UniverseSimScenes):
@@ -26,7 +28,7 @@ class TheLostPlanetSim(UniverseSimScenes):
         # inner_radius:内圆半径 outer_radius:外圆半径，subdivisions:细分数，控制圆环的细节和精度
         # self.asteroids.torus_zone = 4.7, 5.5, 64
 
-        self.moon = Moon(size_scale=3e3, init_position=[0, 0, (0.4 + 2.4) * AU], distance_scale=1.76)
+        self.moon = Moon(size_scale=3.5e3, init_position=[0, 0, (0.4 + 2.4) * AU], distance_scale=1.76)
         # ceres = Ceres(size_scale=3e3, distance_scale=1.7)
         self.earth = Earth(size_scale=3e3, distance_scale=3.8)
         self.mars = Mars(size_scale=3e3, distance_scale=2.9)
@@ -86,7 +88,10 @@ class TheLostPlanetSim(UniverseSimScenes):
                 an = 0.4
             else:
                 an = 0.4 + 0.3 * pow(2, planet_no - 2)
-            print(body.name, an, body.position[2] / AU)
+            # print(body.name, an, body.position[2] / AU)
+
+        self.step_index = 0
+        self.init_steps()
 
     def on_ready(self):
         """
@@ -103,6 +108,13 @@ class TheLostPlanetSim(UniverseSimScenes):
         camera.look_at(self.jupiter.planet)
         # camera.look_at(sun.planet)
         camera.rotation_z -= 90
+        #
+        # self.moon.planet.update = lambda :None
+        # def moon_update():
+        #     self.moon.planet.scale = 80
+        #     # self.moon.planet.rotation_y += 10
+        #
+        # ext_fun_for_method(self.moon.planet, after_run_fun=moon_update)
 
         # for i in range(10):
         #     time.sleep(0.1)
@@ -113,6 +125,7 @@ class TheLostPlanetSim(UniverseSimScenes):
         # self.asteroids.planet.enabled = False
         self.moon.planet.enabled = False
         # ceres.planet.enabled = False
+        # self.moon.planet.look_at(self.mars.planet)
 
     def set_alpha_animation(self, body, begin_alpha, end_alpha, interval, is_destroy=False):
         from ursina import destroy
@@ -142,26 +155,111 @@ class TheLostPlanetSim(UniverseSimScenes):
             if is_destroy and not planet.enabled:
                 destroy(planet)
             # planet.color = Vec4(planet.color[0], planet.color[1], planet.color[2], alpha)
-            # print(planet.alpha)
+            # print(body, planet.alpha, planet.rotation_x, planet.rotation_y, planet.rotation_z)
 
         planet.update = alpha_animation
         # ext_fun_for_method(planet, after_run_fun=alpha_animation)
 
-    def create_asteroid(self, init_angle=89.5):
+    # def set_alpha_animation(self, body, begin_alpha, end_alpha, interval, is_destroy=False):
+    #     from ursina import destroy
+    #     if hasattr(body, "planet"):
+    #         planet = body.planet
+    #     else:
+    #         planet = body
+    #     planet.alpha = 0
+    #
+    #     def alpha_animation():
+    #         alpha = planet.alpha
+    #         alpha += interval
+    #         if alpha > 1:
+    #             alpha = 1
+    #         planet.enabled = (alpha > 0)
+    #         planet.alpha = alpha
+    #         # planet.color = Vec4(planet.color[0], planet.color[1], planet.color[2], alpha)
+    #         # print(body, planet.alpha, planet.rotation_x, planet.rotation_y, planet.rotation_z)
+    #
+    #     planet.update = alpha_animation
+    #     # ext_fun_for_method(planet, after_run_fun=alpha_animation)
+    # def moon_fade_in(self):
+    #     """
+    #     月球渐渐显示
+    #     @return:
+    #     """
+    #     # self.moon.planet.look_at(self.mars.planet)
+    #     self.moon.planet.alpha = 0
+    #     def alpha_animation():
+    #         from ursina import Vec2,Vec4
+    #         planet = self.moon.planet.main_entity
+    #         alpha = planet.alpha
+    #         alpha += 0.01
+    #         planet.color = Vec4(planet.color[0], planet.color[1], planet.color[2], alpha)
+    #         planet.alpha = alpha
+    #         planet.texture_offset = Vec2(0, 0)
+    #         planet.texture_scale = Vec2(1, 1)
+    #
+    #     self.moon.planet.update = alpha_animation #  lambda: None
+    #     self.set_alpha_animation(self.moon, 0.0, 1.0, 0.005)
+    #
+    # def moon_fade_in(self):
+    #     from ursina import Vec4
+    #     planet = self.moon.planet
+    #     planet.alpha = 0
+    #     def update_moon():
+    #         alpha = planet.alpha
+    #         alpha += 0.01
+    #         if alpha > 1.0:
+    #             alpha = 1.0
+    #             planet.update = lambda: None
+    #         planet.color = Vec4(planet.color[0], planet.color[1], planet.color[2], alpha)
+    #         planet.alpha = alpha
+    #
+    #     planet.update = update_moon
+
+    # def earth_fade_in(self):
+    #     """
+    #     月球渐渐显示
+    #     @return:
+    #     """
+    #     self.earth.planet.look_at(self.mars.planet)
+    #     # self.moon.planet.update = lambda: None
+    #     self.set_alpha_animation(self.earth, 0.0, 1.0, 0.005)
+
+    # def moon_fade_out(self):
+    #     """
+    #     月球渐渐显示
+    #     @return:
+    #     """
+    #     self.moon.planet.look_at(self.mars.planet)
+    #     # self.moon.planet.update = lambda: None
+    #     self.set_alpha_animation(self.moon, 1.0, 0.0, 0.005)
+    def create_asteroid(self, init_angle=110, smooth=False):
         from ursina import Entity, color, Vec3
         import math
         import random
         pos = self.moon.planet.position  # + Vec3()
-        radius = self.moon.planet.position[2] + 40 * random.random() - 20  # * moon.distance_scale
+        radius = self.moon.planet.position[2] + 50 * random.random() - 15  # * moon.distance_scale
         asteroid = Entity(model='sphere', position=pos, color=color.white, scale=1.5)
         asteroid.s_angle = init_angle
+        asteroid.init_pos = pos
         y = 10 * random.random() - 5
+        speed = random.random() / 7 + 0.2
 
         def rotation():
-            x = self.sun.planet.x + radius * math.cos(asteroid.s_angle)
-            z = self.sun.planet.z + radius * math.sin(asteroid.s_angle)
-            asteroid.position = (x, y, z)
-            speed = random.random() / 50
+            angle = math.pi * asteroid.s_angle / 180
+            x = self.sun.planet.x + radius * math.cos(angle)
+            z = self.sun.planet.z + radius * math.sin(angle)
+            target_pos = Vec3(x, y, z)
+            if asteroid.init_pos is None or not smooth:
+                # angle = math.pi * asteroid.s_angle / 180
+                # x = self.sun.planet.x + radius * math.cos(angle)
+                # z = self.sun.planet.z + radius * math.sin(angle)
+                asteroid.position = target_pos
+            else:
+                asteroid.look_at(target_pos)
+                asteroid.position += asteroid.forward * 1.5
+                d = distance(asteroid.position, target_pos)
+                if d < 3:
+                    asteroid.init_pos = None
             asteroid.s_angle += speed
 
         asteroid.update = rotation
@@ -169,7 +267,7 @@ class TheLostPlanetSim(UniverseSimScenes):
 
     def create_asteroids(self):
         self.asteroids = []
-        for i in range(500):
+        for i in range(400):
             self.asteroids.append(self.create_asteroid(i))
 
     # def clear_asteroids(self):
@@ -202,6 +300,15 @@ class TheLostPlanetSim(UniverseSimScenes):
         self.moon.planet.update = lambda: None
         self.set_alpha_animation(self.moon, 0.0, 1.0, 0.005)
 
+    # def moon_fade_out(self):
+    #     """
+    #     月球渐渐显示
+    #     @return:
+    #     """
+    #     self.moon.planet.look_at(self.mars.planet)
+    #     # self.moon.planet.update = lambda: None
+    #     self.set_alpha_animation(self.moon, 1.0, 0.0, 0.005)
+
     def moon_renovation(self):
         """
         月球改造中
@@ -209,44 +316,98 @@ class TheLostPlanetSim(UniverseSimScenes):
         """
         if not hasattr(self, "moon_redesign_last_time"):
             self.moon_redesign_last_time = time.time()
+            self.asteroid_num = 0
         c_time = time.time()
         # set_alpha_animation(asteroids, 0.0, 1.0, 0.01)
         if c_time - self.moon_redesign_last_time > 0.02:
             self.moon_redesign_last_time = c_time
-            self.create_asteroid()
+            self.create_asteroid(smooth=True)
+            self.asteroid_num += 1
 
     def moon_move_to_target_and_rotation(self, target, rotation_radius, end_angle, end_tag,
-                                         forward=0.1,
-                                         angle_val=0.08):
-        from ursina import camera, Vec3, distance
-        import math
+                                         forward,
+                                         angle_val):
+
         if hasattr(target, "planet"):
             target_planet = target.planet.main_entity
         else:
             target_planet = target.main_entity
 
-        self.moon.planet.look_at(target_planet)
+        if not hasattr(target_planet, "is_forward"):
+            target_planet.is_forward = True
 
-        d = distance(self.moon.planet, target_planet)
-        if d > rotation_radius:
+        if target_planet.is_forward:
+            target_pos = target_planet.position + Vec3(-rotation_radius, 0, 0)
+            self.moon.planet.look_at(target_pos)
+            d = distance(self.moon.planet, target_pos)
+            if d > 3:
                 self.moon.planet.position += self.moon.planet.forward * forward
+            else:
+                target_planet.is_forward = False
         else:
             if not hasattr(target_planet, "moon_angle"):
-                setattr(target_planet, "moon_angle", 90)
-
+                setattr(target_planet, "moon_angle", 180)
             moon_angle = getattr(target_planet, "moon_angle")
-            x = target_planet.x + rotation_radius * math.cos(moon_angle)
-            z = target_planet.z + rotation_radius * math.sin(moon_angle)
+
+            angle = math.pi * moon_angle / 180
+            x = target_planet.x + rotation_radius * math.cos(angle)
+            z = target_planet.z + rotation_radius * math.sin(angle)
             self.moon.planet.position = (x, 0, z)
 
             setattr(target_planet, "moon_angle", moon_angle + angle_val)
 
             if moon_angle >= end_angle:
                 setattr(self, end_tag, True)
+                self.step_index += 1
 
             # print("moon_angle", moon_angle)
 
+    def init_steps(self):
+
+        def step_05():
+            if not hasattr(self, "moon_around_mars"):
+                # setattr(self, "step_04", True)
+                self.moon_move_to_target_and_rotation(target=self.mars,
+                                                      rotation_radius=12,
+                                                      end_angle=180 + 360 * 3,
+                                                      end_tag="moon_around_mars",
+                                                      forward=0.02, angle_val=0.8)
+
+        def step_06():
+            if not hasattr(self, "moon_around_earth"):
+                self.moon_move_to_target_and_rotation(target=self.earth,
+                                                      rotation_radius=15,
+                                                      end_angle=7200,
+                                                      end_tag="moon_around_earth",
+                                                      forward=0.02, angle_val=1)
+
+        self.steps = [
+            (self.asteroid_fade_in, 3, 1),
+            (self.asteroid_fade_out, 3, 1),
+            (self.moon_fade_in, 3, 1),
+            (self.moon_renovation, 10, -1),
+            (step_05, -1, -1),
+            (step_06, -1, -1),
+        ]
+
     def on_timer_changed(self, time_data):
+        if time_data.years > 1:
+            if self.step_index > len(self.steps) - 1:
+                self.step_index = len(self.steps) - 1
+            fun, wait_years, run_times = self.steps[self.step_index]
+            if not hasattr(self, f"{fun.__name__}_wait_years"):
+                setattr(self, f"{fun.__name__}_wait_years", time_data.years)
+                setattr(self, f"{fun.__name__}_run_times", 0)
+            fun_run_times = getattr(self, f"{fun.__name__}_run_times")
+            if fun_run_times < run_times or run_times < 0:
+                fun()
+            setattr(self, f"{fun.__name__}_run_times", fun_run_times + 1)
+            fun_wait_years = getattr(self, f"{fun.__name__}_wait_years")
+            if wait_years + fun_wait_years < time_data.years and wait_years > 0:
+                self.step_index += 1
+            # print(self.step_index, fun.__name__)
+
+    def on_timer_changed2(self, time_data):
         from ursina import camera, Vec3, distance
         import math
 
@@ -270,66 +431,16 @@ class TheLostPlanetSim(UniverseSimScenes):
             setattr(self, "step_04", True)
             self.moon_move_to_target_and_rotation(target=self.mars,
                                                   rotation_radius=12,
-                                                  end_angle=110,
+                                                  end_angle=720,
                                                   end_tag="moon_around_mars",
-                                                  forward=0.03, angle_val=0.05)
-            # self.moon.planet.look_at(self.mars.planet)
-            # radius = 12
-            # d = distance(self.moon.planet, self.mars.planet.position)
-            # if d > 12:
-            #     self.moon.planet.position += self.moon.planet.forward * 0.1
-            # else:
-            #     if not hasattr(self.mars, "moon_angle"):
-            #         setattr(self.mars, "moon_angle", 90)
-            #
-            #     moon_angle = getattr(self.mars, "moon_angle")
-            #     x = self.mars.planet.x + radius * math.cos(moon_angle)
-            #     z = self.mars.planet.z + radius * math.sin(moon_angle)
-            #     self.moon.planet.position = (x, 0, z)
-            #
-            #     setattr(self.mars, "moon_angle", moon_angle + 0.08)
-            #
-            #     if moon_angle >= 110:
-            #         setattr(self.moon, "mars_rotation", True)
-
-            # print("moon_angle", moon_angle)
+                                                  forward=0.03, angle_val=3)
 
         elif hasattr(self, "moon_around_mars") and not hasattr(self, "moon_around_earth"):
             self.moon_move_to_target_and_rotation(target=self.earth,
                                                   rotation_radius=15,
-                                                  end_angle=360,
+                                                  end_angle=720,
                                                   end_tag="moon_around_earth",
-                                                  forward=0.03, angle_val=0.05)
-
-            # earth_target = self.earth.planet.main_entity
-            # self.moon.planet.look_at(earth_target)
-            # radius = 15
-            # d = distance(self.moon.planet.position, earth_target.position)
-            # if d > 15:
-            #     self.moon.planet.position += self.moon.planet.forward * 0.1
-            # else:
-            #     if not hasattr(self.earth, "moon_angle"):
-            #         setattr(self.earth, "moon_angle", 90)
-            #
-            #     moon_angle = getattr(self.earth, "moon_angle")
-            #     x = earth_target.x + radius * math.cos(moon_angle)
-            #     z = earth_target.z + radius * math.sin(moon_angle)
-            #     self.moon.planet.position = (x, 0, z)
-            #
-            #     setattr(self.earth, "moon_angle", moon_angle + 0.08)
-
-            # if moon_angle >= 360 * 2 + 90:
-            #     setattr(moon, "earth_rotation", True)
-
-            # print("moon_angle", moon_angle)
-            # moon.planet.world_rotation_z = 90
-            # moon.planet.position += moon.planet.right * 0.1
-
-            # setattr(moon, "years_8", True)
-
-        # elif time_data.years > 15 and not hasattr(moon, "years_15"):
-        #     set_alpha_animation(moon, 1.0, 0.0, 0.05)
-        #     setattr(moon, "years_15", True)
+                                                  forward=0.03, angle_val=3)
 
 
 if __name__ == '__main__':
@@ -355,4 +466,5 @@ if __name__ == '__main__':
                timer_enabled=True,
                show_timer=True,
                cosmic_bg='',
+               # show_trail=True,
                show_grid=False)