Python超人-宇宙模拟器

sim_scenes/wormhole_sim.py

@@ -18,6 +18,7 @@ from ursina import camera, application, lerp, Vec3
 from bodies import Body
 from simulators.ursina.ursina_event import UrsinaEvent
 from dataclasses import dataclass, field
+import inspect
 
 
 @dataclass(order=True)
@@ -37,6 +38,11 @@ class WormholeInfo:
     rotation_x: float = None
     rotation_y: float = None
     rotation_z: float = None
+    around_max_count: int = 300
+    around_max_speed: int = -200
+    around_min_speed: int = 100
+    around_direction: str = "right"
+    around_acc_speed: int = -2
 
 
 # class WormholeInfoParams:
@@ -59,6 +65,7 @@ class WormholeSim:
                                             init_position=[D, 0, -D],
                                             init_velocity=[0, 0, 0],
                                             size_scale=self.SIZE_SCALE * 1e3).set_ignore_gravity(True)
+        self.wormholeinfo_default_vals = None
         self.camera_target.go_target = None
         self.camera_target.go_target_stage = None
         self.last_universe = None
@@ -66,6 +73,7 @@ class WormholeSim:
         self.target_universe = None
         self.universes = []
         self.wormhole_infos = {}
+
         self.create_universes()
         self.bodies = [self.camera_target] + self.universes
 
@@ -93,9 +101,14 @@ class WormholeSim:
         #     rotation_x: float = None
         #     rotation_y: float = None
         #     rotation_z: float = None
+        #     around_max_count: int = 300
+        #     around_max_speed: int = -200
+        #     around_direction: str = "right"
+        #     around_acc_speed: int = -2
+
         wormhole_infos = [
             {"position": [D, 0, -D], "rotation_y": -150},
-            {"position": [D, 0, D], "rotation_z": 30},
+            {"position": [D, 0, D], "rotation_z": 30, "around_acc_speed": -10, "around_min_speed": 150},
             {"position": [- D, -D, D]},
             {"position": [- D, 0, -D]},
             {"position": [D, D, D]},
@@ -110,58 +123,34 @@ class WormholeSim:
 
         def build_wormhole_info_param(wormhole_info):
             # ps = WormholeInfoParams()
+            if self.wormholeinfo_default_vals is None:
+                self.wormholeinfo_default_vals = {}
+                init_wormholeinfo_default_vals = True
+            else:
+                init_wormholeinfo_default_vals = False
+
             ps = {}
-            import inspect
             attributes = inspect.getmembers(WormholeInfo)
             for attr in attributes:
                 if not attr[0].startswith('_'):
                     pn = attr[0]
+                    if init_wormholeinfo_default_vals:
+                        self.wormholeinfo_default_vals[pn] = attr[1]
                     if pn not in wormhole_info.keys():
                         continue
                     ps[pn] = wormhole_info[pn]  # attr[1].default
-            # return {
-            #     attr[0]: attr[1].default
-            #     for attr in attributes
-            #     if not attr[0].startswith('_')
-            # }
+
             return ps
 
         for idx, wormhole_info in enumerate(wormhole_infos):
             pos = wormhole_info.get("position", [0, 0, 0])
             name = wormhole_info.get("name", f"宇宙{idx}")
-            # camera_target_init_speed: int = wormhole_info.get("camera_target_init_speed", 100)
-            # camera_init_speed: int = wormhole_info.get("camera_init_speed", 100)
-            # camera_target_speed: int = wormhole_info.get("camera_target_speed", 2000)
-            # camera_target_max_speed: int = wormhole_info.get("camera_target_max_speed", 2000)
-            # camera_forward_speed: int = wormhole_info.get("camera_forward_speed", -0.1)
-            # camera_max_speed: int = wormhole_info.get("camera_max_speed", 5000)
-            # camera_acc_speed: int = wormhole_info.get("camera_acc_speed", 1.02)
-            # camera_forward_acc_speed: int = wormhole_info.get("camera_forward_acc_speed", 0.01)
-            # size_factor: float = wormhole_info.get("size_factor", 10)
-            # rotation_x: float = wormhole_info.get("rotation_x", None)
-            # rotation_y: float = wormhole_info.get("rotation_y", None)
-            # rotation_z: float = wormhole_info.get("rotation_z", None)
             ps1 = build_wormhole_info_param(wormhole_info)
             ps1["position"] = pos
             ps1["name"] = name
             universe = self.create_universe(name, idx, pos)
             self.universes.append(universe)
             self.wormhole_infos[universe] = WormholeInfo(**ps1)
-            # self.wormhole_infos[universe] = WormholeInfo(name=name, position=pos,
-            #                                              camera_target_init_speed=camera_target_init_speed,
-            #                                              camera_init_speed=camera_init_speed,
-            #                                              camera_target_speed=camera_target_speed,
-            #                                              camera_target_max_speed=camera_target_max_speed,
-            #                                              camera_forward_speed=camera_forward_speed,
-            #                                              camera_max_speed=camera_max_speed,
-            #                                              camera_acc_speed=camera_acc_speed,
-            #                                              camera_forward_acc_speed=camera_forward_acc_speed,
-            #                                              size_factor=size_factor,
-            #                                              rotation_x=rotation_x,
-            #                                              rotation_y=rotation_y,
-            #                                              rotation_z=rotation_z
-            #
-            #                                              )
 
     def init_setting(self):
         camera.clip_plane_near = 0.00005
@@ -180,18 +169,25 @@ class WormholeSim:
         camera.forward_speed = 0
 
     def get_wormhole_data(self, data_name, default_val=None, universe=None):
+        def ret_value():
+            if default_val is None:
+                if data_name in self.wormholeinfo_default_vals.keys():
+                    return self.wormholeinfo_default_vals[data_name]
+
+            return default_val
+
         if universe is None:
             universe = self.current_universe
         wormhole_info = self.wormhole_infos[universe]
         if wormhole_info is None:
-            return default_val
+            return ret_value()
 
         if not hasattr(wormhole_info, data_name):
-            return default_val
+            return ret_value()
 
         val = getattr(wormhole_info, data_name)
         if val is None:
-            return default_val
+            return ret_value()
 
         return val
 
@@ -223,8 +219,8 @@ class WormholeSim:
         if rotation_z is not None:
             self.current_universe.planet.rotation_z = rotation_z
 
-        self.camera_target.speed = self.get_wormhole_data("camera_target_init_speed", 100)
-        camera.speed = self.get_wormhole_data("camera_init_speed", 100)
+        self.camera_target.speed = self.get_wormhole_data("camera_target_init_speed")
+        camera.speed = self.get_wormhole_data("camera_init_speed")
 
         if self.last_universe is None:
             self.camera_target.go_target = self.target_universe
@@ -234,14 +230,14 @@ class WormholeSim:
             self.camera_target.go_target = self.last_universe
             self.last_universe.planet.enabled = True
 
-            size_factor = self.get_wormhole_data("size_factor", 10, self.last_universe)
+            size_factor = self.get_wormhole_data("size_factor", universe=self.last_universe)
 
             self.scale_down(self.last_universe, scale_size=self.SIZE_SCALE * size_factor)
             self.camera_target.go_target_stage = "last_universe"
             self.camera_target.go_target_hit = False
             self.scale_down(u)
-            self.camera_target.speed = self.get_wormhole_data("camera_target_speed", 2000)
-            camera.forward_speed = self.get_wormhole_data("camera_forward_speed", -0.1)
+            self.camera_target.speed = self.get_wormhole_data("camera_target_speed")
+            camera.forward_speed = self.get_wormhole_data("camera_forward_speed")
 
         self.scale_up(self.current_universe)
         # self.scale_down(self.target_universe)
@@ -270,13 +266,9 @@ class WormholeSim:
         self.body_update_reset()
         self.universe_reset()
 
-        # self.target_universe.planet.rotation_y = 100
-        # self.current_universe.planet.rotation_y = 200
-        # self.current_universe.planet.rotation_x = 30
-
         # camera_look_at(self.camera_target)
         self.camera_target.planet.collider = "sphere"
-        # self.camera_target.planet.enabled = False
+        self.camera_target.planet.enabled = False
         camera.collider = "sphere"
         camera.current_universe = self.current_universe
         camera_look_at(self.camera_target, rotation_z=0)
@@ -319,18 +311,19 @@ class WormholeSim:
         # self.camera_move(time_data)
         from ursina import time, distance
 
-        camera_max_speed = self.get_wormhole_data("camera_max_speed", 5000)
-        camera_acc_speed = self.get_wormhole_data("camera_acc_speed", 1.02)
-        camera_target_max_speed = self.get_wormhole_data("camera_target_max_speed", 2000)
+        camera_max_speed = self.get_wormhole_data("camera_max_speed")
+        camera_acc_speed = self.get_wormhole_data("camera_acc_speed")
+        camera_target_max_speed = self.get_wormhole_data("camera_target_max_speed", )
 
         if self.camera_target.go_target is not None:
             go_target = self.camera_target.go_target.planet
             if self.camera_target.go_target_stage == "around_universe":
-                around_max_count: int = 300
-                around_max_speed: int = -200
-                around_direction: str = "right"
-                around_acc_speed: int = -2
-                around_target = camera
+                around_max_count = self.get_wormhole_data("around_max_count")
+                around_max_speed = self.get_wormhole_data("around_max_speed")
+                around_min_speed = self.get_wormhole_data("around_min_speed")
+                around_direction = self.get_wormhole_data("around_direction")
+                around_acc_speed = self.get_wormhole_data("around_acc_speed")
+                # around_target = camera
                 around_target = go_target
 
                 self.camera_target.planet.look_at(around_target)
@@ -344,13 +337,14 @@ class WormholeSim:
                     self.camera_target.around_count = 0
 
                 if self.camera_target.around_count > around_max_count:
-                    if hasattr(self.camera_target, "around_speed") and abs(self.camera_target.around_speed) > 100:
-                        self.camera_target.around_speed -= around_acc_speed * 10
+                    if hasattr(self.camera_target, "around_speed") and \
+                            abs(self.camera_target.around_speed) > abs(around_min_speed):
+                        self.camera_target.around_speed -= around_acc_speed
                     else:
-                        delattr(self.camera_target, "around_speed")
+                        # delattr(self.camera_target, "around_speed")
                         delattr(self.camera_target, "around_count")
                         self.camera_target.go_target_stage = "last_universe"
-                        self.camera_target.speed = self.get_wormhole_data("camera_init_speed", 100)
+                        self.camera_target.speed = self.get_wormhole_data("camera_init_speed")
                 else:
                     self.camera_target.around_speed += around_acc_speed
 
@@ -360,14 +354,14 @@ class WormholeSim:
 
                     self.camera_target.planet.position += planet_direction * self.camera_target.around_speed
 
-                    print("around_speed",self.camera_target.around_speed)
+                    print("around_speed", self.camera_target.around_speed)
 
                 if hasattr(self.camera_target, "around_count"):
                     self.camera_target.around_count += 1
 
                 # camera.forward_speed = -0.05
                 if camera.forward_speed < 0:
-                    camera_forward_acc_speed = self.get_wormhole_data("camera_forward_acc_speed", 0.01)
+                    camera_forward_acc_speed = self.get_wormhole_data("camera_forward_acc_speed")
                     camera.forward_speed += camera_forward_acc_speed
                 else:
                     camera.forward_speed = 0
@@ -388,14 +382,25 @@ class WormholeSim:
                         self.camera_target.go_target_hit = True
                         self.camera_target.go_target_stage = "around_universe"
                         self.camera_target.go_target = self.target_universe
-                        self.camera_target.speed = self.get_wormhole_data("camera_init_speed", 100)
+                        self.camera_target.speed = self.get_wormhole_data("camera_init_speed")
                         camera.speed = 1  # 在看上一个宇宙时候，停留一会
                     # # camera.forward_speed = -0.05
                     # if camera.forward_speed < 0:
-                    #     camera_forward_acc_speed = self.get_wormhole_data("camera_forward_acc_speed", 0.01)
+                    #     camera_forward_acc_speed = self.get_wormhole_data("camera_forward_acc_speed")
                     #     camera.forward_speed += camera_forward_acc_speed
                     # else:
                     #     camera.forward_speed = 0
+                if hasattr(self.camera_target, "around_speed"):
+                    if abs(self.camera_target.around_speed) > abs(10):
+                        around_acc_speed = self.get_wormhole_data("around_acc_speed")
+                        around_direction = self.get_wormhole_data("around_direction")
+                        planet_direction = getattr(self.camera_target.planet, around_direction)
+
+                        self.camera_target.around_speed -= around_acc_speed
+                        self.camera_target.planet.position += planet_direction * self.camera_target.around_speed
+                    else:
+                        delattr(self.camera_target, "around_speed")
+
             elif self.camera_target.go_target_stage == "target_universe":
                 if self.camera_target.planet.intersects(go_target).hit and not self.camera_target.go_target_hit:
                     self.camera_target.go_target_hit = True