Merge db76175c1c into f6812ba886

plugins/utilities.json

@@ -2310,4 +2310,22 @@
       }
     }
   }
+},
+"snowfallModz": {
+      "description": "add snowfall in local match",
+      "external_url": "",
+      "authors": [
+        {
+          "name": "KritarthaT",
+          "email": "ktgamer768@gmail.com",
+          "discord": "kritarthat"
         }
+      ],
+      "versions": {
+        "1.0.0": {
+          "api_version": 9,
+          "released_on": "15-07-2025"
+      }
+    },
+    
+  

plugins/utilities/aura_overload_fx.py

@@ -0,0 +1,83 @@
+# ba_meta require api 9
+# ba_meta name Aura Overload FX
+# ba_meta description Gives the host player a glowing, smoothly transitioning aura.
+# ba_meta author KritarthaT
+
+import bascenev1 as bs
+import babase
+import random
+
+
+class AuraEffect:
+    def __init__(self, player: bs.Player):
+        self._player = player
+        self._light = None
+        self._colors = [
+            (1, 0, 0), (0, 1, 0), (0, 0, 1),
+            (1, 1, 0), (0, 1, 1), (1, 0, 1)
+        ]
+        self._color_index = 0
+        self._next_index = 1
+        self._t = 0.0
+
+        self._timer = bs.Timer(0.05, self._update, repeat=True)
+
+    def _lerp_color(self, c1, c2, t):
+        return tuple(c1[i] + (c2[i] - c1[i]) * t for i in range(3))
+
+    def _update(self):
+        if not self._player or not self._player.actor or not self._player.actor.node:
+            return
+
+        pos = self._player.actor.node.position
+        if not self._light:
+            self._light = bs.newnode('light', attrs={
+                'position': pos,
+                'color': self._colors[self._color_index],
+                'radius': 0.3,
+                'intensity': 0.8,
+                'volume_intensity_scale': 1.0
+            })
+
+        # Interpolate color
+        self._t += 0.05 / 1.0  # 1 sec per color transition
+        if self._t >= 1.0:
+            self._t = 0.0
+            self._color_index = self._next_index
+            self._next_index = (self._next_index + 1) % len(self._colors)
+
+        smooth_color = self._lerp_color(
+            self._colors[self._color_index],
+            self._colors[self._next_index],
+            self._t
+        )
+
+        self._light.color = smooth_color
+        self._light.position = (pos[0], pos[1] + 0.8, pos[2])  # Follow player
+
+        # Optional visual sparks
+        bs.emitfx(
+            position=pos,
+            velocity=(0, 2, 0),
+            count=10,
+            scale=0.6,
+            spread=0.2,
+            chunk_type='spark'
+        )
+
+
+# ba_meta export plugin
+class AuraOverloadFX(babase.Plugin):
+    def __init__(self):
+        bs.Activity.__init__ = self._wrap_activity_init(bs.Activity.__init__)
+
+    def _wrap_activity_init(self, original):
+        def new_init(activity_self, settings):
+            original(activity_self, settings)
+            bs.timer(1.0, lambda: self._start_glow(activity_self))
+        return new_init
+
+    def _start_glow(self, activity: bs.Activity):
+        if activity.players:
+            player = activity.players[0]  # Host player
+            AuraEffect(player)

plugins/utilities/snowfallModz.py

@@ -0,0 +1,52 @@
+# ba_meta require api 9
+# ba_meta name Snowfall FX
+# ba_meta description Adds snowfall particle effects in all maps.
+# ba_meta author KritarthaT
+
+import random
+import bascenev1 as bs
+import babase
+
+
+def start_snowfall(activity: bs.Activity) -> None:
+    if not hasattr(activity, 'map'):
+        return
+
+    try:
+        bounds = activity.map.get_def_bound_box('map_bounds')
+    except Exception:
+        return
+
+    def emit_snow() -> None:
+        for i in range(int(bounds[3] * bounds[5])):
+
+            def _emit() -> None:
+                bs.emitfx(
+                    position=(
+                        random.uniform(bounds[0], bounds[3]),
+                        random.uniform(bounds[4] * 1.2, bounds[4] * 1.45),
+                        random.uniform(bounds[2], bounds[5])
+                    ),
+                    velocity=(0, 0, 0),
+                    scale=random.uniform(1.0, 1.6),
+                    count=random.randint(6, 12),
+                    spread=random.uniform(0.03, 0.08),
+                    chunk_type='ice'  # ❄️ Snowflake particle
+                )
+
+            bs.timer(random.uniform(0.01, 0.05) * (i + 1), _emit)
+
+    bs.timer(0.5, emit_snow, repeat=True)
+
+# ba_meta export plugin
+
+
+class SnowfallFX(babase.Plugin):
+    def __init__(self):
+        bs.Activity.__init__ = self._wrap_activity_init(bs.Activity.__init__)
+
+    def _wrap_activity_init(self, original_init):
+        def new_init(activity_self, settings):
+            original_init(activity_self, settings)
+            bs.timer(1.0, lambda: start_snowfall(activity_self))
+        return new_init