def dealPoison(userid, attacker, dmg, time):
userid = int(userid)
if userid not in poison_dict:
poison_dict[userid] = []
poison_repeat = Repeat(_poison_repeat, (userid, attacker, dmg))
poison_dict[userid].append(poison_repeat)
poison_repeat.start(time, execute_on_start=True)
def repeat(
self, callback, args=(), kwargs=None,
cancel_on_level_end=False):
"""Create the repeat which will be stopped after removing the entity.
:param callback:
A callable object that should be called at the end of each loop.
:param tuple args:
Arguments that should be passed to the callback.
:param dict kwargs:
Keyword arguments that should be passed to the callback.
:param bool cancel_on_level_end:
Whether or not to cancel the delay at the end of the map.
:raise ValueError:
Raised if the given callback is not callable.
:return:
The repeat instance.
:rtype: Repeat
"""
# Get the repeat instance...
repeat = Repeat(callback, args, kwargs, cancel_on_level_end)
# Add the repeat to the dictionary...
_entity_repeats[self.index].add(repeat)
# Return the repeat instance...
return repeat
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.cooldowns = CooldownDict()
self._player = self.parent.parent
self._players_hit = set()
self._repeater = Repeat(self._repeat, args=(self._player, ))
self._wards = list()
self.outer_ring = TempEntity('BeamRingPoint',
model_index=self._model.index,
halo_index=self._model.index,
amplitude=10,
red=250,
green=200,
blue=100,
alpha=245,
fade_length=100,
start_width=10,
end_width=10,
speed=3)
self.beam = TempEntity('BeamPoints',
alpha=255,
red=0,
green=0,
blue=255,
model_index=self._model2.index,
start_width=7,
end_width=7,
frame_rate=255,
halo_index=self._model2.index)
def _on_player_pre_attack(self, attacker, victim, **kwargs):
if randint(1, 100) > 20 or self.cooldowns['blizzard'] > 0 or self.level == 0:
return
self._center = victim.origin
self._player = attacker
self._players_hit.clear()
self._repeater = Repeat(self._repeat)
self._repeater.start(0.1)
self._effect = TempEntity('BeamRingPoint', center=self._center, start_radius=self.range,
end_radius=self.range+1, model_index=self._model.index, halo_index=self._model.index,
life_time=7, amplitude=10, red=200, green=200, blue=255, alpha=245, flags=0,
start_width=10, end_width=10)
self._effect.create()
self._stack = Entity.create('env_smokestack')
self._stack.teleport(self._center, QAngle(0, 180, 0), None)
self._stack.base_spread = self.range / 2
self._stack.spread_speed = 10
self._stack.start_size = 2
self._stack.end_size = 1
self._stack.jet_length = 100
self._stack.angles = QAngle(0, 0, 0)
self._stack.rate = 600
self._stack.speed = 100
self._stack.twist = 180
self._stack.render_mode = RenderMode.TRANS_COLOR
self._stack.render_amt = 100
self._stack.render_color = Color(200, 200, 255)
self._stack.add_output('SmokeMaterial particle/rain.vmt')
self._stack.turn_on()
self._stack2 = Entity.create('env_smokestack')
self._stack2.teleport(self._center, None, QAngle(0, 180, 0))
self._stack2.base_spread = self.range / 4
self._stack2.spread_speed = self.range / 2
self._stack2.start_size = 2
self._stack2.end_size = 1
self._stack2.jet_length = 100
self._stack2.angles = QAngle(0, 180, 0)
self._stack2.rate = 600
self._stack2.speed = 100
self._stack2.twist = 120
self._stack2.render_mode = RenderMode.TRANS_COLOR
self._stack2.render_amt = 100
self._stack2.render_color = Color(200, 200, 255)
self._stack2.add_output('SmokeMaterial particle/rain.vmt')
self._stack2.turn_on()
send_wcs_saytext_by_index(self._msg_a.format(name=victim.name), attacker.index)
self._stack.delay(7, self._stack.turn_off)
self._stack2.delay(7, self._stack2.turn_off)
Delay(7, self._repeater.stop)
self.cooldowns['blizzard'] = 10
def __init__(self):
self.state_warmup = True
self.handle_flag = False
self.checking = Repeat(self.players_quantity)
self.players_to_start_sdm = settings.PAYERS_TO_START
self.player_weapon = "weapon_glock"
self.bot_weapon = "weapon_knife"
self.single_player_weapon_restrict = WeaponRestrictionHandler()
def _on_spawn_start_repeat(self, player, **kwargs):
self.can_crit = True
self.counter = 0
self.repeater = Repeat(self._on_game_tick,
kwargs={},
cancel_on_level_end=True)
self.repeater.start(0.1)
def wcs_regeneration_command(command_info, player:convert_userid_to_player, value:int, duration:float, maxhealth:int, maxheal:deprecated, radius:float):
if player is None:
return
repeat = Repeat(_regeneration_repeat, (player.userid, value, maxhealth, radius))
repeat.start(duration)
_repeats[player.userid].append(repeat)
def cluster_rockets():
player = Player.from_userid(int(es.ServerVar('wcs_userid')))
if player.team >= 2:
nade_repeat = Repeat(create_nade,
(player, int(es.ServerVar('wcs_dmg'))))
nade_repeat.start(0.2, int(es.ServerVar('wcs_rockets')), True)
es.tell(
player.userid, '#multi',
'#green[WCS] #lightgreenYou fired #green%s Cluster Rockets!' %
int(es.ServerVar('wcs_rockets')))
def request_input(self, callback, return_menu=None):
assert self.data.get('_internal_input_callback') is None
self.data['_internal_input_callback'] = callback
self.data['_internal_input_menu'] = return_menu
self.data['_internal_input_repeat'] = Repeat(self._request_update)
self.data['_internal_input_repeat'].start(0.25, 39)
self.data['_internal_input_delay'] = Delay(10, self._request_end)
return input_menu
def __init__(self):
super().__init__()
self._counter = 0
self._repeat = Repeat(self._tick)
self._refreshing = False
self._threads = []
self['races'] = {}
self['items'] = {}
def __init__(self):
super().__init__()
self._counter = 0
self._repeat = Repeat(self._tick)
self._checking_new_version = False
self._installing_new_version = False
self._refreshing_modules = False
self._refreshing_commits = False
self._threads = []
self['races'] = {}
self['items'] = {}
def _regeneration(command):
#<userid> <amount> <time> <maxhp> <maxheal> <radius>
userid = int(command[1])
amount = int(command[2])
time = float(command[3])
maxhp = int(command[4])
maxheal = int(command[5])
radius = float(command[6])
if exists(userid):
wcsgroup.setUser(userid, 'regeneration_active', 1)
player = Player.from_userid(userid)
repeat_dict[player.userid] = Repeat(
_regeneration_repeat, (player, amount, maxhp, maxheal, radius))
repeat_dict[player.userid].start(time)
db = pickle.getDict()
joined = set()
def exptick():
for player in PlayerIter():
steamid = player.steamid
if steamid == 'BOT':
steamid = 'BOT_' + player.name.upper()
if tickoxp.get_int():
db[steamid]["exp"] += int(tickoxp)
db[steamid]["left"] = time()
repeat = Repeat(exptick)
repeat.start(timer.get_int())
def player_menu_select(menu, index, choice):
userid = choice.value
player = Player.from_userid(userid)
steamid = player.steamid
if steamid == 'BOT':
steamid = 'BOT_' + player.name.upper()
check(steamid)
exp = int(db[steamid]["exp"])
if player.index == index:
wcs.wcs.tell(
Player(index).userid,
def __init__(self):
super().__init__()
self._repeat = Repeat(self._tick)
self._filter = PlayerReadyIter(is_filters='alive')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.longjump = False
self.repeater = Repeat(self.on_cycle, args=(self.parent.parent, ))
self.state = None
self.reduction = 0
def __init__(self):
self._repeat = Repeat(self.tick)
self._filter = PlayerReadyIter(['bot', 'alive'])
def on_purchase(self, player):
super().on_purchase(player)
player.cash -= self.cost
self.repeater = Repeat(self.on_cycle, args=(player, ))
self.repeater.start(1)
send_wcs_saytext_by_index(self._msg_purchase, player.index)
def dealTimed(userid, attacker, dmg, time):
if userid not in timed_dict:
timed_dict[userid] = []
timed_repeat = Repeat(_timed_repeat, (userid, attacker, dmg))
timed_dict[userid].append(timed_repeat)
timed_repeat.start(time, execute_on_start=True)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.repeater = Repeat(self.on_cycle, args=(self.parent.parent, ))
def load():
global log_players_loop
log_players_loop = Repeat(log_players)
log_players_loop.start(5, execute_on_start=True)
