521 lines
16 KiB
GDScript
521 lines
16 KiB
GDScript
class_name Player
|
|
extends Node2D
|
|
|
|
signal draft_completed
|
|
signal board_attached
|
|
|
|
enum FSMState {DRAFT, SETUP, MANAGEMENT, WORKER, H_WORKER, SHIFT, H_CLIENT}
|
|
enum DraftType {HIRE_WORKER}
|
|
|
|
@export var roster_positions : Array[Node2D] = []
|
|
@export var slot_buttons : Array[Node2D] = []
|
|
@export var seconds_to_hide_hand := 2.0
|
|
@export var seconds_to_show_hand := 2.0
|
|
var money := 0
|
|
var payout := 0
|
|
var cost := 0
|
|
var hire_costs := [40, 50, 60, 70, 80]
|
|
var shift_deck : Array[Client] = []
|
|
var workers : Array[Worker] = []
|
|
var hand : Array[Worker] = []
|
|
var active_workers : Array[Worker] = [null, null, null, null, null]
|
|
var active_clients : Array[Client] = [null, null, null, null, null]
|
|
var poor_discard : Array[Client] = []
|
|
var good_discard : Array[Client] = []
|
|
var great_discard : Array[Client] = []
|
|
var last_fsm_state := FSMState.SETUP
|
|
var current_fsm_state := FSMState.SETUP
|
|
var draft := DraftType.HIRE_WORKER
|
|
var hand_hiding := false
|
|
var hand_hidden := false
|
|
var hand_hiding_progress := 0.0
|
|
var hand_showing := false
|
|
var hand_showing_progress := 0.0
|
|
var shown_for_draft : Array[Worker] = []
|
|
var selected_for_draft : Array[Worker] = []
|
|
var draft_limit := 0
|
|
var current_client : Client
|
|
var selected_worker : Worker
|
|
var task_drawn := false
|
|
var client_assignment : int = -1
|
|
var board : Board = null
|
|
var turn_completed = false
|
|
var round_completed = false
|
|
|
|
|
|
func _ready() -> void:
|
|
#Bug in Godot 4.0.3.stable makes it nessesary to add these manually
|
|
roster_positions.append($RosterSection/Position1)
|
|
roster_positions.append($RosterSection/Position2)
|
|
roster_positions.append($RosterSection/Position3)
|
|
roster_positions.append($RosterSection/Position4)
|
|
roster_positions.append($RosterSection/Position5)
|
|
roster_positions.append($RosterSection/Position6)
|
|
roster_positions.append($RosterSection/Position7)
|
|
roster_positions.append($RosterSection/Position8)
|
|
roster_positions.append($RosterSection/Position9)
|
|
roster_positions.append($RosterSection/Position10)
|
|
roster_positions.append($RosterSection/Position11)
|
|
roster_positions.append($RosterSection/Position12)
|
|
roster_positions.append($RosterSection/Position13)
|
|
roster_positions.append($RosterSection/Position14)
|
|
roster_positions.append($RosterSection/Position15)
|
|
slot_buttons.append($WorkerPlaySlots/Slot1)
|
|
slot_buttons.append($WorkerPlaySlots/Slot2)
|
|
slot_buttons.append($WorkerPlaySlots/Slot3)
|
|
slot_buttons.append($WorkerPlaySlots/Slot4)
|
|
slot_buttons.append($WorkerPlaySlots/Slot5)
|
|
for button in slot_buttons:
|
|
button.button_pushed.connect(select_slot)
|
|
$PoorDiscardPile/Label.text = "No / Poor service"
|
|
$GoodDiscardPile/Label.text = "Good service"
|
|
$GreatDiscardPile/Label.text = "Great service"
|
|
$TaskDrawDeck/Label.text = "Click to draw task card"
|
|
$Camera2D.make_current()
|
|
await board_attached
|
|
enter_setup_state()
|
|
|
|
|
|
func _process(delta) -> void:
|
|
if (hand_hiding):
|
|
if hand_hiding_progress < seconds_to_hide_hand:
|
|
hand_hiding_progress += delta
|
|
var percent = clampf(hand_hiding_progress / seconds_to_hide_hand, 0.0, 1.0)
|
|
for card in hand:
|
|
card.hand_position.y = lerpf($Hand.position.y, $Hand.position.y + 300.0, percent)
|
|
else:
|
|
hand_hiding = false
|
|
hand_hidden = true
|
|
hand_hiding_progress = 0.0
|
|
if (hand_showing):
|
|
if hand_showing_progress < seconds_to_show_hand:
|
|
hand_showing_progress += delta
|
|
var percent = clampf(hand_showing_progress / seconds_to_show_hand, 0.0, 1.0)
|
|
for card in hand:
|
|
card.hand_position.y = lerpf($Hand.position.y + 300.0, $Hand.position.y, percent)
|
|
else:
|
|
hand_showing = false
|
|
hand_showing_progress = 0.0
|
|
|
|
|
|
func start_turn():
|
|
pass
|
|
|
|
|
|
func start_round():
|
|
pass
|
|
|
|
|
|
@rpc("call_local")
|
|
func attach_board(board_path : NodePath):
|
|
board = get_node(board_path) as Board
|
|
board_attached.emit()
|
|
|
|
|
|
func add_to_hand(card):
|
|
hand.append(card)
|
|
for x in hand.size():
|
|
var hand_ratio = 0.5
|
|
|
|
if hand.size() > 1:
|
|
hand_ratio = float(x) / float(hand.size() - 1)
|
|
hand[x].position = $Hand.position
|
|
hand[x].hand_ratio = hand_ratio
|
|
hand[x].in_hand = true
|
|
hand[x].hand_position = $Hand.position
|
|
hand[x].visible = true
|
|
hand[x].set_process(true)
|
|
|
|
|
|
func lift_hand():
|
|
for card in hand:
|
|
card.hovered = true
|
|
|
|
|
|
func drop_hand():
|
|
for card in hand:
|
|
card.hovered = false
|
|
|
|
|
|
func _on_hire_button_pressed():
|
|
if money >= hire_costs[workers.size()]:
|
|
money -= hire_costs[workers.size()]
|
|
$Camera2D/Money.text = "$" + str(money)
|
|
draft_workers(3, 1, true)
|
|
await draft_completed
|
|
$Button.text = "Hire Worker: $" + str(hire_costs[workers.size()])
|
|
|
|
|
|
func assign_task_to_worker():
|
|
client_assignment = active_workers.find(selected_worker)
|
|
if active_clients[client_assignment] != null:
|
|
return
|
|
current_client.slide_to_position(selected_worker.position.x - 100, selected_worker.position.y - 100, 0.0, 0.3)
|
|
current_client.show_time_selector()
|
|
await current_client.time_slots_selected
|
|
payout = 0
|
|
payout += current_client.turns_left * 2
|
|
for service in current_client.services:
|
|
if selected_worker.services.has(service):
|
|
payout += Data.service_prices[service]
|
|
$Camera2D/Payout.text = "$" + str(payout)
|
|
$"Camera2D/EndTurn".visible = true
|
|
|
|
|
|
func move_to_poor_discard(_button):
|
|
current_client.slide_to_position($PoorDiscardPile.position.x, $PoorDiscardPile.position.y, 0.0, 0.2)
|
|
client_assignment = -1
|
|
$Camera2D/EndTurn.visible = true
|
|
payout = 0
|
|
$Camera2D/Payout.text = ""
|
|
|
|
|
|
func select_card(card):
|
|
if current_fsm_state == FSMState.DRAFT:
|
|
if selected_for_draft.size() <= draft_limit:
|
|
if selected_for_draft.has(card):
|
|
selected_for_draft.remove_at(selected_for_draft.find(card))
|
|
card.slide_to_position(card.position.x, card.position.y + 40, 0.0, 0.1)
|
|
else:
|
|
if selected_for_draft.size() < draft_limit:
|
|
selected_for_draft.append(card)
|
|
card.slide_to_position(card.position.x, card.position.y - 40, 0.0, 0.1)
|
|
return
|
|
selected_worker = card
|
|
if current_client != null:
|
|
assign_task_to_worker()
|
|
|
|
|
|
func select_slot(slot):
|
|
if selected_worker == null:
|
|
return
|
|
if active_workers.has(selected_worker):
|
|
active_workers[active_workers.find(selected_worker)] = null
|
|
if hand.has(selected_worker):
|
|
hand.remove_at(hand.find(selected_worker))
|
|
active_workers[slot_buttons.find(slot)] = selected_worker
|
|
selected_worker.slide_to_position(slot.position.x, slot.position.y, 0.0, 0.3)
|
|
selected_worker = null
|
|
|
|
#Shift Phase
|
|
#1. Swap 1 time token on each worker over to the stress side
|
|
#2. Pick up the next client card in the deck, and either assign it to
|
|
# a worker or place it in the no service pile
|
|
#3. If a worker both has no client, and at least one stress token, remove
|
|
# a stress token
|
|
|
|
#Management Phase
|
|
#Market Research
|
|
#Look at the 10 clients, and place them back in the same order
|
|
#Targeted Advertising
|
|
#Search through the client discard deck, and add all clients
|
|
#with one extra type to your shift deck
|
|
#Roster Worker
|
|
#Add 1 worker from your hand into the next open slot on your board
|
|
|
|
|
|
func _on_area_2d_input_event(_viewport, event, _shape_idx):
|
|
if event is InputEventMouseButton and event.pressed:
|
|
enter_workers_view_state()
|
|
|
|
|
|
func _on_area_2d_2_input_event(_viewport, event, _shape_idx):
|
|
if event is InputEventMouseButton and event.pressed:
|
|
enter_management_overview_state()
|
|
|
|
|
|
func _on_task_draw_deck_button_pushed(_button):
|
|
enter_holding_task_state()
|
|
|
|
|
|
func evaluate_task_success(num):
|
|
var successfulness = 0
|
|
var worker = active_workers[num]
|
|
var client = active_clients[num]
|
|
match client.services.size():
|
|
2, 3:
|
|
successfulness = 2
|
|
4:
|
|
successfulness = 1
|
|
if worker.services.has(client.services[3]):
|
|
successfulness = 2
|
|
5:
|
|
successfulness = 1
|
|
if worker.services.has(client.services[4]):
|
|
successfulness = 2
|
|
6:
|
|
successfulness = 0
|
|
if worker.services.has(client.services[3]) or worker.services.has(client.services[4]):
|
|
successfulness = 1
|
|
if worker.services.has(client.services[5]):
|
|
successfulness = 2
|
|
7:
|
|
successfulness = 0
|
|
if worker.services.has(client.services[3]) or worker.services.has(client.services[4]):
|
|
successfulness = 1
|
|
if worker.services.has(client.services[5]) or worker.services.has(client.services[6]):
|
|
successfulness = 2
|
|
var slide_destination : Vector2
|
|
match successfulness:
|
|
0:
|
|
poor_discard.append(client)
|
|
slide_destination = $PoorDiscardPile.position
|
|
1:
|
|
good_discard.append(client)
|
|
slide_destination = $GoodDiscardPile.position
|
|
2:
|
|
great_discard.append(client)
|
|
slide_destination = $GreatDiscardPile.position
|
|
client.slide_to_position(slide_destination.x, slide_destination.y, 0.0, 0.2)
|
|
client.z_index = 0
|
|
active_clients[num] = null
|
|
|
|
|
|
func worker_exceeded_capacity(num):
|
|
active_workers[num].stress = 0
|
|
active_workers[num].set_process(false)
|
|
active_workers[num].visible = false
|
|
workers.remove_at(workers.find(active_workers[num]))
|
|
active_workers[num] = null
|
|
|
|
|
|
func draft_workers(_draw, pick, cancelable):
|
|
draft = DraftType.HIRE_WORKER
|
|
draft_limit = pick
|
|
shown_for_draft = []
|
|
selected_for_draft = []
|
|
var y = 0
|
|
var x = (250.0 * _draw) / 2.0
|
|
shown_for_draft.append_array(board.draw_worker(_draw))
|
|
for i in shown_for_draft.size():
|
|
var card = shown_for_draft[i]
|
|
card.visible = true
|
|
card.set_process(true)
|
|
card.card_clicked.connect(select_card)
|
|
var ratio = float(i) / float(_draw - 1)
|
|
var xx = lerpf(-1 * x, x, ratio)
|
|
card.slide_to_position(xx, y, 0.0, 0.3)
|
|
enter_draft_state(cancelable)
|
|
|
|
|
|
func pad_shift_deck():
|
|
var padding = (2 + (2 * board.round_num)) - shift_deck.size()
|
|
shift_deck.append_array(board.draw_client(padding))
|
|
|
|
|
|
func process_discard_decks():
|
|
poor_discard.shuffle()
|
|
good_discard.shuffle()
|
|
great_discard.shuffle()
|
|
for x in range(poor_discard.size() - 1, -1, -1):
|
|
if x == 0:
|
|
shift_deck.append(poor_discard[x])
|
|
else:
|
|
board.discard_client(poor_discard[x])
|
|
poor_discard[x].position = Vector2(9999, 9999)
|
|
poor_discard[x].visible = false
|
|
poor_discard.remove_at(x)
|
|
for x in range(good_discard.size() - 1, -1, -1):
|
|
if x <= int(good_discard.size() / 2.0):
|
|
shift_deck.append(good_discard[x])
|
|
else:
|
|
board.discard_client(good_discard[x])
|
|
good_discard[x].position = Vector2(9999, 9999)
|
|
good_discard[x].visible = false
|
|
good_discard.remove_at(x)
|
|
for x in range(great_discard.size() - 1, -1, -1):
|
|
if x < great_discard.size() - 1:
|
|
shift_deck.append(great_discard[x])
|
|
else:
|
|
board.discard_client(great_discard[x])
|
|
great_discard[x].position = Vector2(9999, 9999)
|
|
great_discard[x].visible = false
|
|
great_discard.remove_at(x)
|
|
|
|
|
|
func confirm_draft():
|
|
if selected_for_draft.size() != draft_limit:
|
|
return
|
|
$Camera2D/EndDraft.visible = false
|
|
$Camera2D/CancelDraft.visible = false
|
|
match(draft):
|
|
DraftType.HIRE_WORKER:
|
|
for card in selected_for_draft:
|
|
add_to_hand(card)
|
|
workers.append(card)
|
|
shown_for_draft.remove_at(shown_for_draft.find(card))
|
|
for card in shown_for_draft:
|
|
card.position = Vector2(9999, 9999)
|
|
board.discard_worker(card)
|
|
match(last_fsm_state):
|
|
FSMState.SETUP, FSMState.MANAGEMENT:
|
|
enter_management_overview_state()
|
|
draft_completed.emit()
|
|
|
|
|
|
func cancel_draft():
|
|
$Camera2D/EndDraft.visible = false
|
|
$Camera2D/CancelDraft.visible = false
|
|
match(draft):
|
|
DraftType.HIRE_WORKER:
|
|
for card in shown_for_draft:
|
|
card.visible = false
|
|
card.set_process(false)
|
|
board.discard_worker(board.search_and_draw_worker(card))
|
|
match(last_fsm_state):
|
|
FSMState.SETUP, FSMState.MANAGEMENT:
|
|
enter_management_overview_state()
|
|
draft_completed.emit()
|
|
|
|
|
|
func enter_draft_state(cancelable):
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.DRAFT
|
|
$Camera2D/PhaseLabel.text = "Choose " + str(draft_limit) + " cards"
|
|
$Camera2D/EndManagement.visible = false
|
|
$RosterButton/CollisionShape2D.disabled = true
|
|
$ReturnButton.visible = false
|
|
$ReturnButton/CollisionShape2D.disabled = true
|
|
$Camera2D/EndDraft.visible = true
|
|
if cancelable:
|
|
$Camera2D/CancelDraft.visible = true
|
|
|
|
|
|
func enter_setup_state():
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.SETUP
|
|
#money = 100
|
|
$Camera2D/Money.text = "$" + str(money)
|
|
draft_workers(4, 2, false)
|
|
|
|
|
|
func enter_management_overview_state():
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.MANAGEMENT
|
|
for worker in active_workers:
|
|
if worker != null:
|
|
worker.decrease_stress(worker.stress)
|
|
$Camera2D/RoundCounter.text = "Round: " + str(board.round_num)
|
|
$Camera2D/PhaseLabel.text = "Management Phase"
|
|
$Camera2D/EndManagement.visible = true
|
|
$Camera2D/Cost.visible = true
|
|
$Camera2D/EndShift.visible = false
|
|
$Camera2D/EndTurn.visible = false
|
|
$RosterButton/CollisionShape2D.disabled = false
|
|
$WorkerPlaySlots/Slot1.visible = true
|
|
$WorkerPlaySlots/Slot2.visible = true
|
|
$WorkerPlaySlots/Slot3.visible = true
|
|
$WorkerPlaySlots/Slot4.visible = true
|
|
$WorkerPlaySlots/Slot5.visible = true
|
|
$HireWorkerButton.visible = true
|
|
$Camera2D/TurnCounter.visible = false
|
|
hand_showing = true
|
|
selected_worker = null
|
|
$RosterButton/CollisionShape2D.disabled = false
|
|
$ReturnButton.visible = false
|
|
$ReturnButton/CollisionShape2D.disabled = true
|
|
$Camera2D.position.y = 0
|
|
for x in hand.size():
|
|
hand[x].in_hand = true
|
|
$TaskDrawDeck/Area2D/CollisionShape2D.disabled = true
|
|
$PoorDiscardPile/Area2D/CollisionShape2D.disabled = true
|
|
process_discard_decks()
|
|
pad_shift_deck()
|
|
$TaskDrawDeck/Count.text = str(shift_deck.size())
|
|
|
|
|
|
func enter_workers_view_state():
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.WORKER
|
|
selected_worker = null
|
|
$RosterButton/CollisionShape2D.disabled = true
|
|
$ReturnButton.visible = true
|
|
$ReturnButton/CollisionShape2D.disabled = false
|
|
$Camera2D.position.y = 640
|
|
for x in hand.size():
|
|
hand[x].in_hand = false
|
|
hand[x].slide_to_position(roster_positions[x].position.x, roster_positions[x].position.y, 0.0, 0.2)
|
|
|
|
|
|
func enter_holding_worker_state():
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.H_WORKER
|
|
|
|
|
|
func enter_shift_overview_state():
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.SHIFT
|
|
$Camera2D/TurnCounter.visible = true
|
|
$Camera2D/TurnCounter.text = "Turn: " + str(board.turn_num)
|
|
$Camera2D/PhaseLabel.text = "Shift Phase"
|
|
$Camera2D/EndManagement.visible = false
|
|
$RosterButton/CollisionShape2D.disabled = true
|
|
$WorkerPlaySlots/Slot1.visible = false
|
|
$WorkerPlaySlots/Slot2.visible = false
|
|
$WorkerPlaySlots/Slot3.visible = false
|
|
$WorkerPlaySlots/Slot4.visible = false
|
|
$WorkerPlaySlots/Slot5.visible = false
|
|
$ReturnButton.visible = false
|
|
$ReturnButton/CollisionShape2D.disabled = true
|
|
$Camera2D.position.y = 0
|
|
$Camera2D/Cost.visible = false
|
|
$HireWorkerButton.visible = false
|
|
for x in hand.size():
|
|
hand[x].in_hand = true
|
|
if hand_hidden == false:
|
|
hand_hiding = true
|
|
$TaskDrawDeck/Area2D/CollisionShape2D.disabled = false
|
|
task_drawn = false
|
|
money += payout
|
|
payout = 0
|
|
if client_assignment != null and current_client != null:
|
|
active_clients[client_assignment] = current_client
|
|
if active_workers[client_assignment].increase_stress(current_client.initial_stress):
|
|
worker_exceeded_capacity(client_assignment)
|
|
client_assignment = -1
|
|
current_client = null
|
|
elif client_assignment == -1 and current_client != null:
|
|
poor_discard.append(current_client)
|
|
current_client = null
|
|
$Camera2D/Payout.text = ""
|
|
$Camera2D/Money.text = "$" + str(money)
|
|
$Camera2D/EndTurn.visible = false
|
|
$PoorDiscardPile/Area2D/CollisionShape2D.disabled = true
|
|
#Pretty sure these are done in the right order even though it looks the wrong way around
|
|
for x in active_workers.size():
|
|
if active_workers[x] != null and active_clients[x] == null:
|
|
active_workers[x].decrease_stress(1)
|
|
if active_workers[x] != null and active_clients[x] != null:
|
|
if active_workers[x].increase_stress(1):
|
|
worker_exceeded_capacity(x)
|
|
active_clients[x].turns_left -= 1
|
|
active_clients[x].update_counter()
|
|
if active_clients[x].turns_left == 0:
|
|
evaluate_task_success(x)
|
|
var tasks_done = true
|
|
for client in active_clients:
|
|
if client != null:
|
|
tasks_done = false
|
|
if shift_deck.size() == 0:
|
|
if tasks_done:
|
|
round_completed = true
|
|
#enter_management_overview_state()
|
|
else:
|
|
$Camera2D/EndTurn.visible = true
|
|
$TaskDrawDeck/Area2D/CollisionShape2D.disabled = true
|
|
|
|
|
|
func enter_holding_task_state():
|
|
last_fsm_state = current_fsm_state
|
|
current_fsm_state = FSMState.H_CLIENT
|
|
current_client = shift_deck.pop_back()
|
|
current_client.position = Vector2(494, -414)
|
|
current_client.visible = true
|
|
current_client.z_index = 1
|
|
current_client.slide_to_position($PreviewTask.position.x, $PreviewTask.position.y, 0.0, 0.3)
|
|
task_drawn = true
|
|
$TaskDrawDeck/Area2D/CollisionShape2D.disabled = true
|
|
$PoorDiscardPile/Area2D/CollisionShape2D.disabled = false
|
|
$TaskDrawDeck/Count.text = str(shift_deck.size())
|
|
|