130 lines
3.5 KiB
GDScript
130 lines
3.5 KiB
GDScript
extends Node
|
|
|
|
# warning-ignore:unused_signal
|
|
signal ping_handled(ping)
|
|
|
|
const AUTO_PING_ENABLED = true
|
|
const MAX_PINGS_ALLOWED = 6
|
|
|
|
onready var ping_sound = get_node("PingSound")
|
|
|
|
var unhandled_ping_list = []
|
|
var total_ping_count = 0
|
|
var current_ping_id = 0
|
|
|
|
var scheduled_pings = []
|
|
|
|
|
|
func _ready():
|
|
if AUTO_PING_ENABLED:
|
|
var autoping_timer = Timer.new()
|
|
autoping_timer.wait_time = 1.0 # Every second.
|
|
autoping_timer.autostart = true
|
|
autoping_timer.connect("timeout", self, "reevaluate_unreceived_pings")
|
|
add_child(autoping_timer)
|
|
|
|
|
|
func _input(event):
|
|
if event is InputEventKey:
|
|
if event.scancode == KEY_P and event.control and event.alt:
|
|
if event.pressed and !event.is_echo():
|
|
send_ping(Time.get_current_time())
|
|
|
|
|
|
func send_ping(time_stamp: int):
|
|
if unhandled_ping_list.size() < MAX_PINGS_ALLOWED:
|
|
Data.messages.add_message("", time_stamp, Users.get_helper())
|
|
ping_sound.play()
|
|
OS.request_attention()
|
|
|
|
|
|
func reschedule_pings():
|
|
scheduled_pings.clear()
|
|
|
|
var big_interaction = Data.miscellaneous.big_interaction
|
|
|
|
var small_interaction = Data.miscellaneous.small_interaction # last_key_press_time_stamp
|
|
|
|
var last_t_s_of_interaction = max(big_interaction, small_interaction)
|
|
|
|
seed(last_t_s_of_interaction)
|
|
|
|
var minimum_t_s_for_next_ping
|
|
minimum_t_s_for_next_ping = max(
|
|
big_interaction + _get_time_until_next_ping(),
|
|
small_interaction + 30
|
|
)
|
|
|
|
var previous_time_stamp = minimum_t_s_for_next_ping
|
|
for i in range(8):
|
|
if not _is_time_stamp_during_active_phase(previous_time_stamp):
|
|
previous_time_stamp = Time.get_current_phase_skipped(
|
|
previous_time_stamp
|
|
) + _random_addition([-300, 600])
|
|
var keep_pinging = true
|
|
while keep_pinging:
|
|
scheduled_pings.append(previous_time_stamp)
|
|
keep_pinging = randi() % 100 < 30 # 30% chance.
|
|
if keep_pinging:
|
|
previous_time_stamp += randi() % 6
|
|
previous_time_stamp += _get_time_until_next_ping() + i * 2400
|
|
|
|
|
|
func _is_time_stamp_during_active_phase(time_stamp: int) -> bool:
|
|
var big_interaction = Data.miscellaneous.big_interaction
|
|
if Time.is_during_night_time(time_stamp):
|
|
return false
|
|
elif Time.is_during_inactive_time(time_stamp):
|
|
return Time.is_during_inactive_time(big_interaction)
|
|
elif Time.is_during_active_time(time_stamp):
|
|
return true
|
|
else:
|
|
return Time.is_during_calm_down_time(big_interaction)
|
|
|
|
|
|
func _get_time_until_next_ping() -> int:
|
|
var time_addition_for_next_ping = 30
|
|
var average_in_seconds = Settings.average_minutes_until_ping * 60
|
|
|
|
var rare_time_addition = [
|
|
int(average_in_seconds * 0.05), # Minimum.
|
|
int(average_in_seconds * 0.35) # Span.
|
|
]
|
|
|
|
var average_time_addition = [
|
|
int(average_in_seconds * 0.9), # Minimum.
|
|
int(average_in_seconds * 0.2) # Span.
|
|
]
|
|
|
|
var uncommon_time_addition = [
|
|
int(average_in_seconds * 0.4), # Minimum.
|
|
int(average_in_seconds * 1.2) # Span.
|
|
]
|
|
|
|
var random_number = randi() % 1000
|
|
|
|
if random_number < 35:
|
|
time_addition_for_next_ping += _random_addition(rare_time_addition)
|
|
elif random_number < 665:
|
|
time_addition_for_next_ping += _random_addition(average_time_addition)
|
|
else:
|
|
time_addition_for_next_ping += _random_addition(uncommon_time_addition)
|
|
|
|
return time_addition_for_next_ping
|
|
|
|
|
|
func _random_addition(span: Array) -> int:
|
|
return span[0] + int(span[1] * randf())
|
|
|
|
|
|
func reevaluate_unreceived_pings():
|
|
for scheduled_ping_t_s in scheduled_pings:
|
|
if scheduled_ping_t_s < Time.get_current_time():
|
|
if not scheduled_ping_t_s in unhandled_ping_list:
|
|
send_ping(scheduled_ping_t_s)
|
|
|
|
|
|
func _on_ping_handled(ping: Message):
|
|
unhandled_ping_list.erase(ping.time_stamp)
|
|
current_ping_id += 1
|