helpy4/vh-bombsquad-modded-server-files
1
0
Fork 0
mirror of https://github.com/hypervortex/VH-Bombsquad-Modded-Server-Files synced 2025-11-07 17:36:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update floater.py

Browse source
This commit is contained in:
Sarasayed0118 2024-04-07 05:16:24 +05:30 • committed by GitHub
parent bf6cb27b88
commit aaed2af42b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 76 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

169
dist/ba_root/mods/chatHandle/ChatCommands/floater.py vendored
View file

@ -1,102 +1,82 @@
# ba_meta require api 6 # ba_meta require api 6
from __future__ import annotations from __future__ import annotations
from typing import TYPE_CHECKING from typing import TYPE_CHECKING
import _ba,ba,random,math import ba, _ba
import random
import math
from bastd.gameutils import SharedObjects from bastd.gameutils import SharedObjects
from bastd.actor.bomb import Bomb from bastd.actor.bomb import Bomb
from ba._generated.enums import InputType from ba._generated.enums import InputType
if TYPE_CHECKING: if TYPE_CHECKING:
from typing import Optional from typing import Optional
class Floater(ba.Actor): class Floater(ba.Actor):
def __init__(self, bounds): def __init__(self, bounds: tuple):
super().__init__() super().__init__()
shared = SharedObjects.get() shared = SharedObjects.get()
self.controlled = False self.controlled = False
self.source_player = None self.source_player = None
self.floaterMaterial = ba.Material() self.floater_material = ba.Material()
self.floaterMaterial.add_actions( self.floater_material.add_actions(
conditions=('they_have_material', conditions=('they_have_material',
shared.player_material), shared.player_material),
actions=(('modify_node_collision', 'collide', True), actions=(('modify_node_collision', 'collide', True),
('modify_part_collision', 'physical', True))) ('modify_part_collision', 'physical', True)))
self.floaterMaterial.add_actions( self.floater_material.add_actions(
conditions=(('they_have_material', conditions=(('they_have_material',
shared.object_material), 'or', shared.object_material), 'or',
('they_have_material', ('they_have_material',
shared.footing_material), 'or', shared.footing_material), 'or',
('they_have_material', ('they_have_material',
self.floaterMaterial)), self.floater_material)),
actions=('modify_part_collision', 'physical', False)) actions=('modify_part_collision', 'physical', False))
self.pos = bounds self.pos = bounds
self.px = "random.uniform(self.pos[0],self.pos[3])" self.px = random.uniform(self.pos[0], self.pos[3])
self.py = "random.uniform(self.pos[1],self.pos[4])" self.py = random.uniform(self.pos[1], self.pos[4])
self.pz = "random.uniform(self.pos[2],self.pos[5])" self.pz = random.uniform(self.pos[2], self.pos[5])
self.node = ba.newnode( self.node = ba.newnode(
'prop', 'prop',
delegate=self, delegate=self,
owner=None, owner=None,
attrs={ attrs={
'position': (eval(self.px), eval(self.py), eval(self.pz)), 'position': (self.px, self.py, self.pz),
'model': 'model': ba.getmodel('landMine'),
ba.getmodel('landMine'), 'light_model': ba.getmodel('landMine'),
'light_model': 'body': 'landMine',
ba.getmodel('landMine'), 'body_scale': 3,
'body': 'model_scale': 3.1,
'landMine', 'shadow_size': 0.25,
'body_scale': 'density': 999999,
3, 'gravity_scale': 0.0,
'model_scale': 'color_texture': ba.gettexture('achievementFlawlessVictory'),
3.1, 'reflection': 'soft',
'shadow_size':
0.25,
'density':
999999,
'gravity_scale':
0.0,
'color_texture':
ba.gettexture('achievementFlawlessVictory'),
'reflection':
'soft',
'reflection_scale': [0.25], 'reflection_scale': [0.25],
'materials': 'materials': [shared.footing_material, self.floater_material]
[shared.footing_material, self.floaterMaterial]
}) })
self.node2 = ba.newnode( self.node2 = ba.newnode(
'prop', 'prop',
owner=self.node, owner=self.node,
attrs={ attrs={
'position': (0, 0, 0), 'position': (0, 0, 0),
'body': 'body': 'sphere',
'sphere', 'model': None,
'model': 'color_texture': None,
None, 'body_scale': 1.0,
'color_texture': 'reflection': 'powerup',
None, 'density': 999999,
'body_scale':
1.0,
'reflection':
'powerup',
'density':
999999,
'reflection_scale': [1.0], 'reflection_scale': [1.0],
'model_scale': 'model_scale': 1.0,
1.0, 'gravity_scale': 0,
'gravity_scale': 'shadow_size': 0.1,
0, 'is_area_of_interest': True,
'shadow_size': 'materials': [shared.object_material, self.floater_material]
0.1,
'is_area_of_interest':
True,
'materials':
[shared.object_material, self.floaterMaterial]
}) })
self.node.connectattr('position', self.node2, 'position') self.node.connectattr('position', self.node2, 'position')
def checkCanControl(self): def check_can_control(self) -> bool:
if not self.node.exists(): if not self.node.exists():
return False return False
if not self.source_player.is_alive(): if not self.source_player.is_alive():
@ -104,80 +84,81 @@ class Floater(ba.Actor):
return False return False
return True return True
def con(self): def con(self) -> None:
self.controlled = True self.controlled = True
self.checkPlayerDie() self.check_player_die()
def up(self): def up(self) -> None:
if not self.checkCanControl(): if not self.check_can_control():
return return
v = self.node.velocity v = self.node.velocity
self.node.velocity = (v[0], 5, v[2]) self.node.velocity = (v[0], 5, v[2])
def upR(self): def upR(self) -> None:
if not self.checkCanControl(): if not self.check_can_control():
return return
v = self.node.velocity v = self.node.velocity
self.node.velocity = (v[0], 0, v[2]) self.node.velocity = (v[0], 0, v[2])
def down(self): def down(self) -> None:
if not self.checkCanControl(): if not self.check_can_control():
return return
v = self.node.velocity v = self.node.velocity
self.node.velocity = (v[0], -5, v[2]) self.node.velocity = (v[0], -5, v[2])
def downR(self): def downR(self) -> None:
if not self.checkCanControl(): if not self.check_can_control():
return return
v = self.node.velocity v = self.node.velocity
self.node.velocity = (v[0], 0, v[2]) self.node.velocity = (v[0], 0, v[2])
def leftright(self, value): def leftright(self, value: float) -> None:
if not self.checkCanControl(): if not self.check_can_control():
return return
v = self.node.velocity v = self.node.velocity
self.node.velocity = (5 * value, v[1], v[2]) self.node.velocity = (5 * value, v[1], v[2])
def updown(self, value): def updown(self, value: float) -> None:
if not self.checkCanControl(): if not self.check_can_control():
return return
v = self.node.velocity v = self.node.velocity
self.node.velocity = (v[0], v[1], -5 * value) self.node.velocity = (v[0], v[1], -5 * value)
def dis(self): def dis(self) -> None:
if self.node.exists(): if self.node.exists():
self.controlled = False self.controlled = False
self.node.velocity = (0, 0, 0) self.node.velocity = (0, 0, 0)
self.move() self.move()
def checkPlayerDie(self): def check_player_die(self) -> None:
if not self.controlled: if not self.controlled:
return return
if self.source_player is None: if self.source_player is None:
return return
if self.source_player.is_alive(): if self.source_player.is_alive():
ba.timer(1, self.checkPlayerDie) ba.timer(1, self.check_player_die)
return return
else: else:
self.dis() self.dis()
def distance(self, x1, y1, z1, x2, y2, z2): def distance(self, x1: float, y1: float, z1: float, x2: float, y2: float, z2: float) -> float:
d = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) + math.pow(z2 - z1, 2)) d = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) + math.pow(z2 - z1, 2))
return d return d
def drop(self): def drop(self) -> None:
try: try:
np = self.node.position np = self.node.position
except: except:
np = (0, 0, 0) np = (0, 0, 0)
self.b = Bomb(bomb_type=random.choice(['normal', 'ice', 'sticky', 'impact', 'land_mine', 'tnt']), source_player=self.source_player, position=(np[0], np[1] - 1, np[2]), velocity=(0, -1, 0)).autoretain() self.b = Bomb(bomb_type=random.choice(['normal', 'ice', 'sticky', 'impact', 'land_mine', 'tnt']),
source_player=self.source_player, position=(np[0], np[1] - 1, np[2]), velocity=(0, -1, 0)).autoretain()
if self.b.bomb_type in ['impact', 'land_mine']: if self.b.bomb_type in ['impact', 'land_mine']:
self.b.arm() self.b.arm()
def move(self): def move(self) -> None:
px = eval(self.px) px = self.px
py = eval(self.py) py = self.py
pz = eval(self.pz) pz = self.pz
if self.node.exists() and not self.controlled: if self.node.exists() and not self.controlled:
pn = self.node.position pn = self.node.position
dist = self.distance(pn[0], pn[1], pn[2], px, py, pz) dist = self.distance(pn[0], pn[1], pn[2], px, py, pz)
@ -185,7 +166,7 @@ class Floater(ba.Actor):
t = dist - 1 if dist - 1 >= 0 else 0.1 t = dist - 1 if dist - 1 >= 0 else 0.1
ba.timer(t, ba.WeakCall(self.move), suppress_format_warning=True) ba.timer(t, ba.WeakCall(self.move), suppress_format_warning=True)
def handlemessage(self, msg): def handlemessage(self, msg) -> None:
if isinstance(msg, ba.DieMessage): if isinstance(msg, ba.DieMessage):
self.node.delete() self.node.delete()
self.node2.delete() self.node2.delete()
@ -195,25 +176,27 @@ class Floater(ba.Actor):
else: else:
super().handlemessage(msg) super().handlemessage(msg)
def assign_flo_inputs(client_id: int) -> None:
def assignFloInputs(clientID: int):
with ba.Context(_ba.get_foreground_host_activity()): with ba.Context(_ba.get_foreground_host_activity()):
activity = ba.getactivity() activity = ba.getactivity()
# Check if the activity is a type that has a 'map' attribute
if not hasattr(activity, 'flo') or not activity.flo.node.exists(): if not hasattr(activity, 'flo') or not activity.flo.node.exists():
try: activity.flo = Floater(activity.map.get_def_bound_box('map_bounds')) try:
except: return #Perhaps using in main-menu/score-screen activity.flo = Floater(activity.map.get_def_bound_box('map_bounds'))
except Exception as e:
print(f"An error occurred while creating Floater: {e}")
return # Perhaps using in main-menu/score-screen
else:
# Reset the controlled flag to allow control again
activity.flo.controlled = False
floater = activity.flo floater = activity.flo
if floater.controlled: if floater.controlled:
ba.screenmessage('Floater is already being controlled', color=(1, 0, 0), transient=True, clients=[clientID]) ba.screenmessage('Floater is already being controlled', color=(1, 0, 0), transient=True, clients=[client_id])
return return
ba.screenmessage('You Gained Control Over The Floater!\n Press Bomb to Throw Bombs and Punch to leave!', clients=[clientID], transient=True, color=(0, 1, 1)) ba.screenmessage('You Gained Control Over The Floater!\n Press Bomb to Throw Bombs and Punch to leave!', clients=[client_id], transient=True, color=(0, 1, 1))
for i in _ba.get_foreground_host_activity().players: for i in _ba.get_foreground_host_activity().players:
if i.sessionplayer.inputdevice.client_id == clientID: if i.sessionplayer.inputdevice.client_id == client_id:
def dis(i, floater): def dis(i, floater):
i.actor.node.invincible = False i.actor.node.invincible = False
i.resetinput() i.resetinput()