marek/pirate-dice
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
team3
2026-09-16 15:04:02 +02:00
parent 3be22351a3
commit b9d6b115c0
23 changed files with 795 additions and 425 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
scripts/game.gd
View File

@@ -13,6 +13,11 @@ const WURF_ZEIT := 1.1 ## wie lange die geworfene Münze zu sehen ist,
var table: GameTable
var hud: CanvasLayer
## Alle Wartezeiten des Ablaufs (Bot-Pausen, Aufdecken, Münzwurf) laufen
## durch `_sleep` und lassen sich hiermit stauchen. Im Spiel 1.0; die Tests
## setzen 0, sonst dauert eine Bot-Partie Minuten statt Sekunden. Kein
## class_name dafür: den Klassencache baut nur der Editor, headless fehlt er.
var tempo := 1.0
var rng := RandomNumberGenerator.new()
var seats: Array = [] ## [{peer, name, ai, count, alive}]
@@ -64,13 +69,14 @@ func setup(cfg: Dictionary) -> void:
seats.append({"peer": int(s.peer), "name": String(s.name), "ai": bool(s.ai),
"count": int(s.count), "alive": bool(s.alive), "verwaist": false})
else:
var dice := int(cfg.get("dice", START_DICE)) # Tests spielen mit weniger
var peers: Array = cfg.peers
for p in peers:
seats.append({"peer": int(p), "name": String(cfg.names[p]), "ai": false,
"count": START_DICE, "alive": true, "verwaist": false})
"count": dice, "alive": true, "verwaist": false})
for i in int(cfg.ai):
seats.append({"peer": 0, "name": "Bot %d" % (i + 1), "ai": true,
"count": START_DICE, "alive": true, "verwaist": false})
"count": dice, "alive": true, "verwaist": false})
# Der Spielserver spielt nicht mit und bekommt deshalb keinen Platz.
var me := multiplayer.get_unique_id()
@@ -299,6 +305,10 @@ func _await_settled(list: Array, timeout := 7.0) -> void:
continue
var ok := true
for s in list:
# Verirrte Würfel zurückholen, sonst wartet man hier vergebens.
if table.fange_verirrte(s):
ok = false
continue
for d in table.dice_of(s):
if d.freeze:
continue
@@ -311,136 +321,45 @@ func _await_settled(list: Array, timeout := 7.0) -> void:
return
# ---------------------------------------------------------------- Münzen
# ---------------------------------------------------------------- Münzen und Aufdecken
# Ausgelagert nach muenzen.gd und aufdecken.gd. Die Hüllen hier bleiben, weil
# Tests und Aufrufer den Weg über das Spiel kennen.
var muenzen := preload("res://scripts/muenzen.gd").new(self)
var aufdecken := preload("res://scripts/aufdecken.gd").new(self)
## Wer einen Würfel abgibt, bekommt eine Münze. Das ist der einzige Nachschub.
func _zieh_muenze(seat: int) -> void:
var muenzen: Array = hand.get(seat, [])
if muenzen.size() >= BoosterDB.HANDLIMIT:
_log("%s hat schon drei Münzen und bekommt keine." % seats[seat].name)
return
var id := BoosterDB.zieh(rng)
muenzen.append(id)
hand[seat] = muenzen
_log("%s bekommt %s." % [seats[seat].name, BoosterDB.get_booster(id).name])
muenzen._zieh_muenze(seat)
## Ausspielen heißt: Münze in den Topf werfen. Geht nur am eigenen Zug, bevor
## man ansagt - so ist der Zug eine Entscheidung und nichts kommt sich in die
## Quere. Wappen verstärkt, Zahl lässt es bei der Grundwirkung.
func _do_play(seat: int, id: String, target: int) -> void:
if seat < 0 or phase != "bid" or seat != turn or _answered.has(seat):
return
if _muenze_laeuft:
return
if BoosterDB.needs_bid(id) and bid.is_empty():
return
var muenzen: Array = hand.get(seat, [])
if not muenzen.has(id):
return
muenzen.erase(id)
hand[seat] = muenzen
_muenze_laeuft = true
var stark := rng.randf() < BoosterDB.WAPPEN_CHANCE
_wurf_nr += 1
topf.append({"seat": seat, "id": id, "stark": stark, "nr": _wurf_nr})
while topf.size() > BoosterDB.TOPF_MAX:
var weg: Dictionary = topf.pop_front()
_log("%s fällt vom Tisch - der Topf ist voll." % BoosterDB.get_booster(String(weg.id)).name)
_log("%s wirft %s - %s." % [seats[seat].name,
BoosterDB.get_booster(id).name, "Wappen" if stark else "Zahl"])
# Erst die Münze zeigen, dann wirken lassen. Andersherum sähe man die
# Folge vor der Ursache.
_push_state()
await _sleep(WURF_ZEIT)
if _alive():
await _wirkung(seat, id, target, stark)
_muenze_laeuft = false
if not _alive():
return
_snapshot_all()
_push_state()
await muenzen._do_play(seat, id, target)
func _wirkung(seat: int, id: String, target: int, stark: bool) -> void:
var vals: Array = host_values[seat]
var ziel: int = clampi(target, 0, maxi(0, vals.size() - 1))
match id:
"peek":
var info := {}
for o in _alive_seats():
if o != seat:
info[o] = _zufalls_paare(o, 2 if stark else 1)
peeked[seat] = info
"count":
# Zahl: ein Fenster von drei, in dem die Wahrheit irgendwo liegt.
# Genau wüsste man sonst, ob die Ansage hält - kein Bluff mehr.
var n := _count_face(int(bid.face))
var von: int = n if stark else maxi(0, n - rng.randi_range(0, 2))
gezaehlt[seat] = {int(bid.face): [von, von if stark else von + 2]}
"set_face":
for k: int in _ziel_und_zufall(seat, ziel, stark):
_set_die(seat, k, int(bid.face))
"gain_die":
seats[seat].count += 1
table.set_dice_count(seat, seats[seat].count)
host_values[seat].append(1)
var neu: int = host_values[seat].size() - 1
await _neu_werfen(seat, [neu])
if stark:
_set_die(seat, neu, 6)
"bid_up":
bid.count = int(bid.count) + (2 if stark else 1)
last_bids[int(bid.seat)] = {"count": bid.count, "face": bid.face}
verlauf.append({"seat": int(bid.seat), "count": bid.count, "face": bid.face, "erhoeht": true})
"gag":
if stark:
for o in _alive_seats():
if o != seat:
must_bid[o] = true
else:
must_bid[_next_alive(seat)] = true
await muenzen._wirkung(seat, id, target, stark)
func _count_face(face: int) -> int:
var n := 0
for i in _alive_seats():
for v in host_values[i]:
if v == face:
n += 1
return n
return muenzen._count_face(face)
## Bis zu `n` verschiedene Würfelplätze eines Sitzes, zufällig gezogen.
func _zufalls_idx(seat: int, n: int) -> Array:
var frei: Array = range(host_values[seat].size())
var out: Array = []
while out.size() < n and not frei.is_empty():
out.append(frei.pop_at(rng.randi_range(0, frei.size() - 1)))
return out
func _bot_muenze(seat: int, a: Dictionary) -> bool:
return await muenzen._bot_muenze(seat, a)
func _zufalls_paare(seat: int, n: int) -> Array:
var out: Array = []
for k: int in _zufalls_idx(seat, n):
out.append([k, host_values[seat][k]])
return out
func _topf_an(winner: int) -> void:
muenzen._topf_an(winner)
## Der selbst gewählte Würfel, bei Wappen zusätzlich ein anderer zufälliger.
func _ziel_und_zufall(seat: int, ziel: int, stark: bool) -> Array:
var out: Array = [ziel]
if not stark:
return out
var frei: Array = []
for k in host_values[seat].size():
if k != ziel:
frei.append(k)
if not frei.is_empty():
out.append(frei[rng.randi_range(0, frei.size() - 1)])
return out
func _phase_reveal(result: Dictionary) -> void:
await aufdecken._phase_reveal(result)
func _all_values() -> Array:
return aufdecken._all_values()
## Würfel neu werfen und die Augenzahl danach übernehmen.
@@ -518,61 +437,6 @@ func _phase_bid() -> Dictionary:
return {}
## Ein Bot wirft eine Münze, wenn sie zu seinem Vorhaben passt. `a` ist die
## geplante Handlung. Gibt zurück, ob geworfen wurde.
func _bot_muenze(seat: int, a: Dictionary) -> bool:
var muenzen: Array = hand.get(seat, [])
if muenzen.is_empty():
return false
var vals: Array = host_values[seat]
var unknown: int = _total_dice() - vals.size()
var will_bieten: bool = a.type == "bid"
# Wie glaubwürdig ist das, was der Bot vorhat bzw. was auf dem Tisch liegt?
var eigenes: float = DiceAI.chance(vals, unknown, int(a.count), int(a.face)) if will_bieten else 0.0
var liegt: float = DiceAI.chance(vals, unknown, int(bid.count), int(bid.face)) if not bid.is_empty() else 0.0
var wahl := ""
var ziel := 0
# Hinten liegen: Nachschub ist der einzige Weg zurück.
if muenzen.has("gain_die") and vals.size() <= _kleinste_hand():
wahl = "gain_die"
# Vor dem Anfechten lieber noch nachsehen, wenn es knapp ist.
elif not will_bieten and liegt > 0.2 and liegt < 0.55 and muenzen.has("count"):
wahl = "count"
elif not will_bieten and liegt > 0.2 and liegt < 0.55 and muenzen.has("peek"):
wahl = "peek"
# Zudrücken: die Ansage des Gegners höher schrauben, dann anfechten.
elif not will_bieten and muenzen.has("bid_up"):
wahl = "bid_up"
# Ein Bluff steht an: dem Nächsten den Mund verbieten.
elif will_bieten and eigenes < 0.35 and muenzen.has("gag"):
wahl = "gag"
# Auf derselben Augenzahl erhöhen: einen Würfel dazu drehen.
elif will_bieten and not bid.is_empty() and int(a.face) == int(bid.face) \
and muenzen.has("set_face") and vals.count(int(bid.face)) < vals.size():
wahl = "set_face"
ziel = DiceAI.target_for(vals, int(bid.face))
# Voller Vorrat: irgendwas Spielbares raus, sonst wird nie geworfen.
elif muenzen.size() >= BoosterDB.HANDLIMIT:
for id: String in muenzen:
if not BoosterDB.needs_bid(id) or not bid.is_empty():
wahl = id
break
if wahl == "":
return false
await _do_play(seat, wahl, ziel)
await _sleep(0.6)
return true
## Die kleinste Würfelzahl am Tisch - wer da liegt, ist hinten.
func _kleinste_hand() -> int:
var k := 99
for i in _alive_seats():
k = mini(k, seats[i].count)
return k
## Gibt {} zurück wenn das Spiel weitergeht, sonst das Anfechtungs-Ergebnis.
func _apply_action(seat: int, a: Dictionary) -> Dictionary:
if a.type == "exact":
@@ -616,124 +480,11 @@ func _valid_bid(seat: int, count: int, face: int) -> bool:
return count == bid.count and face > bid.face
func _phase_reveal(result: Dictionary) -> void:
phase = "reveal"
deadline = 0.0
var b: Dictionary = result.bid
var rufer: int = result.challenger
var genau: bool = result.get("exact", false)
var total := _count_face(int(b.face))
# 1. Becher hoch. Noch kein Urteil - erst schauen.
reveal_total = -1
banner = "Genau?" if genau else "Aufdecken"
for i in _alive_seats():
table.arrange_and_show(i, host_values[i], rng)
table.set_cup_down(i, false)
# Gezielt an die Mitspieler am Tisch: ein Peer, der nur in der Lobby sitzt,
# hat keinen Spielknoten und würde das Paket ins Leere laufen lassen.
var values := _all_values()
for i in seats.size():
var peer: int = seats[i].peer
if _peer_live(peer):
_reveal.rpc_id(peer, values, banner)
_push_state()
await _sleep(ZEIT_BECHER)
if not _alive():
return
# 2. Zählen. Die Ansage in der Mitte färbt sich jetzt ein.
reveal_total = total
banner = "%d gefunden, %d angesagt" % [total, b.count]
_push_state()
await _sleep(ZEIT_ZAEHLEN)
if not _alive():
return
# 3. Urteil. Bei "Genau" trifft es alle anderen - oder nur den Rufer.
var verlierer: Array = []
var winner: int
var bonus := -1
if genau and total == int(b.count):
# Fester Schwung von zwei, egal wie viele am Tisch sitzen: der Ansager
# verliert einen, der Rufer bekommt einen. Mehr als eine Anfechtung
# bringt, weniger als "alle anderen" - das kippte bei vielen Spielern.
verlierer = [int(b.seat)]
winner = rufer
bonus = rufer
banner = "Genau! %s verliert, %s bekommt einen Würfel" % [
seats[int(b.seat)].name, seats[rufer].name]
elif genau:
verlierer = [rufer]
winner = int(b.seat)
banner = "Daneben - %s verliert" % seats[rufer].name
else:
var loser := rufer if total >= int(b.count) else int(b.seat)
verlierer = [loser]
winner = int(b.seat) if loser == rufer else rufer
banner = "%s verliert" % seats[loser].name
_log("%d x %d angesagt - tatsächlich %d. %s" % [b.count, b.face, total, banner])
_topf_an(winner)
_push_state()
await _sleep(ZEIT_URTEIL)
if not _alive():
return
for l: int in verlierer:
seats[l].count -= 1
if seats[l].count <= 0:
seats[l].alive = false
seats[l].count = 0
host_values[l] = []
table.set_dice_count(l, 0)
_log("%s scheidet aus." % seats[l].name)
else:
_zieh_muenze(l)
if bonus >= 0 and seats[bonus].alive:
seats[bonus].count += 1
host_values[bonus].append(rng.randi_range(1, 6))
table.set_dice_count(bonus, seats[bonus].count)
# Nach einem Treffer beginnt der Rufer, sonst der Verlierer.
var naechster: int = winner if genau and total == int(b.count) else verlierer[0]
starter = naechster if seats[naechster].alive else _next_alive(naechster)
# Nur wer noch spielt, bekommt den Becher wieder. Auf einer leeren Zone
# sähe er aus, als lägen dort noch Würfel.
for i in seats.size():
table.set_dice_visible(i, false)
table.set_cup_down(i, seats[i].alive)
banner = ""
_push_state()
## Wer das Aufdecken gewinnt, nimmt aus dem Topf, so viel in den Vorrat
## passt. Der Rest bleibt liegen und wächst in die nächste Runde - so ist
## ein voller Vorrat kein Grund, den Topf zu verschenken.
func _topf_an(winner: int) -> void:
if topf.is_empty():
return
var h: Array = hand.get(winner, [])
var genommen := 0
_topf_ziel = winner
while not topf.is_empty() and h.size() < BoosterDB.HANDLIMIT:
h.append(String(topf.pop_front().id))
genommen += 1
hand[winner] = h
_log("%s nimmt %d Münze(n) aus dem Topf, %d bleiben." % [
seats[winner].name, genommen, topf.size()])
func _all_values() -> Array:
var out: Array = []
for i in seats.size():
out.append(host_values[i] if seats[i].alive else [])
return out
## process_always = false: eine offene Pause hält den Timer wirklich an.
func _sleep(sec: float) -> void:
if not _alive():
return
await get_tree().create_timer(sec, false).timeout
await get_tree().create_timer(sec * tempo, false).timeout
func _wait_until(cond: Callable, timeout: float) -> bool:
@@ -983,11 +734,15 @@ func _on_pause_changed(on: bool) -> void:
_push_state()
## Noch eine Solopartie mit denselben Bots. Der Wunsch wandert über Net ins
## neu geladene Menü, das dann sofort startet.
## Noch eine Partie mit denselben Bots. Solo wandert der Wunsch über Net ins
## neu geladene Menü, das dann sofort startet. Im Netz bittet der Raumbesitzer
## den Server, den Raum neu aufzusetzen.
func _on_rematch() -> void:
if _quitting:
return
if Net.room_code != Net.SOLO:
Net.request_rematch()
return
var bots := 0
for s in seats:
if s.ai: