forked from Nekojimi/JackIt
147 lines
3.8 KiB
GDScript
147 lines
3.8 KiB
GDScript
extends Player
|
|
class_name WolfPlayer
|
|
|
|
var role: Role:
|
|
set(val):
|
|
role = val.duplicate(true)
|
|
role_changed.emit(role)
|
|
if is_multiplayer_authority():
|
|
sync_role.rpc(role.name if role != null else "")
|
|
var team: Team:
|
|
set(val):
|
|
team = val
|
|
team_changed.emit(team)
|
|
if is_multiplayer_authority():
|
|
sync_team.rpc(team.name if team != null else "")
|
|
var alive: bool = true:
|
|
set(val):
|
|
alive = val
|
|
alive_changed.emit(alive)
|
|
|
|
var vote: String = ""
|
|
|
|
var night_action_chosen: NightAction = null
|
|
var night_action_answer: String = ""
|
|
|
|
var visit_callbacks: Array[Callable] = []
|
|
var leave_callbacks: Array[Callable] = []
|
|
var murder_callbacks: Array[Callable] = []
|
|
var execute_callbacks: Array[Callable] = []
|
|
|
|
signal murdered(killer: WolfPlayer)
|
|
signal executed(hammer: WolfPlayer)
|
|
signal died()
|
|
signal team_changed(team: Team)
|
|
signal role_changed(role: Role)
|
|
signal alive_changed(alive: bool)
|
|
|
|
enum CallbackFlags { KEEP_CALLBACK = 1, STOP_PROCESS = 2 }
|
|
|
|
@rpc("authority", "call_remote", "reliable")
|
|
func sync_team(team_name: String) -> void:
|
|
team = Team.teams.get(team_name)
|
|
|
|
@rpc("authority", "call_remote", "reliable")
|
|
func sync_role(role_name: String) -> void:
|
|
role = Role.roles.get(role_name)
|
|
|
|
@rpc("any_peer","call_remote", "reliable")
|
|
func use_night_action(night_action_name: String) -> void:
|
|
var night_action: NightAction = get_night_actions().get(night_action_name,null)
|
|
if night_action != null:
|
|
night_action.setup(self)
|
|
night_action_chosen = night_action
|
|
|
|
func get_night_actions() -> Dictionary: #[String, NightAction]:
|
|
var actions: Dictionary = {}
|
|
#var actions: Dictionary[String, NightAction] = {}
|
|
if team != null and team.night_action != null:
|
|
actions[team.name] = team.night_action
|
|
if role != null and role.night_action != null:
|
|
actions[role.name] = role.night_action
|
|
|
|
#for key in actions.keys():
|
|
#var night_action: NightAction = actions[key]
|
|
#if night_action.team_nightly_action and
|
|
return actions
|
|
|
|
func game_reset() -> void:
|
|
alive = true
|
|
visit_callbacks.clear()
|
|
murder_callbacks.clear()
|
|
execute_callbacks.clear()
|
|
leave_callbacks.clear()
|
|
day_reset()
|
|
night_reset()
|
|
#team = null
|
|
#role = null
|
|
|
|
func day_reset() -> void:
|
|
vote = ""
|
|
|
|
func night_reset() -> void:
|
|
visit_callbacks.clear()
|
|
murder_callbacks.clear()
|
|
execute_callbacks.clear()
|
|
leave_callbacks.clear()
|
|
night_action_chosen = null
|
|
night_action_answer = ""
|
|
|
|
func leave() -> bool:
|
|
return notify_callback_list(leave_callbacks, "")
|
|
|
|
func visit(visitor: WolfPlayer) -> bool:
|
|
return notify_callback_list(visit_callbacks, visitor)
|
|
|
|
func execute(hammer: WolfPlayer) -> bool:
|
|
if !alive:
|
|
return false
|
|
|
|
var unprotected: bool = notify_callback_list(execute_callbacks, hammer)
|
|
|
|
if unprotected:
|
|
alive = false
|
|
print("%s has been executed!" % [player_name])
|
|
executed.emit(hammer)
|
|
return !alive
|
|
|
|
func murder(killer: WolfPlayer) -> bool:
|
|
if !alive:
|
|
return false
|
|
|
|
var unprotected: bool = notify_callback_list(murder_callbacks, killer)
|
|
|
|
if unprotected:
|
|
alive = false
|
|
print("%s has been murdered by %s!" % [player_name, killer.player_name])
|
|
murdered.emit(killer)
|
|
return true # you succeeded in ATTEMPTING to kill them
|
|
|
|
func add_murder_callback(callback: Callable):
|
|
murder_callbacks.append(callback)
|
|
|
|
func add_visit_callback(callback: Callable):
|
|
if callback == null:
|
|
print("wtf?????")
|
|
visit_callbacks.append(callback)
|
|
|
|
func notify_callback_list(callbacks: Array[Callable], data: Variant) -> bool:
|
|
var finished: bool = true
|
|
var expired_callbacks: Array[Callable] = []
|
|
for callback in callbacks:
|
|
var flags: int = callback.call(self, data)
|
|
if !(flags & CallbackFlags.KEEP_CALLBACK):
|
|
expired_callbacks.append(callback)
|
|
if flags & CallbackFlags.STOP_PROCESS:
|
|
finished = false
|
|
break
|
|
for callback in expired_callbacks:
|
|
murder_callbacks.erase(callback)
|
|
return finished
|
|
|
|
#func save_from_death() -> bool:
|
|
#if !saved_from_death:
|
|
#saved_from_death = true
|
|
#return true
|
|
#return false
|