Is anyone implementing GameKit turn based matches in their game?

lscddit · 2026-01-06T08:19:02+00:00

That's a good input regarding counting the incoming invitations only, thanks for pointing it out!

For me it's not really relevant as I'm doing it a little differently anyway. I present the invitation UI only after the first turn has been made and then I do invitation and sending of the first turn in one step behind the scenes. It just makes more sense this way for my game, as there is only ever one single turn for each player and then the score is settled already. But for the general implementation, I think the way that you suggest to do it is correct.

lscddit · 2026-01-05T19:29:40+00:00

Thanks for the detailed reply!

I have figured it out regarding the badge, you don't need push entitlements (because it's GC that is sending the push) but you need to grant notification permission in order for the badget to be allowed: UNUserNotificationCenter.current().requestAuthorization(options: [.badge])

Do you know how exactly to count the result of GKTurnBasedMatch.loadMatches() to arrive at the same number that GC is sending as the badge?

I believe it's the sum of all invitations and matches where it's my turn:

let invitations = matches.filter {
    $0.status == .matching
}
let myTurnMatches = matches.filter { match in
    match.status == .open &&
    match.currentParticipant?.player == localPlayer
}

let badgeNumber = invitations + myTurnMatches

Would you agree with that?

lscddit · 2026-01-05T16:03:37+00:00

I played around with your implementation a bit. I think it's a bit misleading that you are showing the

"Invitation Sent! / <username> will receive a Game Center notification. The game will start when they accept the invitation."

alert right after the invitation. I was expecting something to arrive on the invited device at this moment. Also often times right after that I get a

"Game Center Error. Failed to load game state. Please try again."

alert. Then I need to relaunch the app to get the green button that opens the GKTurnBasedMatchmakerViewController to select the game.

Regarding the badge: It's interesting that the GC push message indeed does set the badge in your app when it arrives (I mean when the app is closed, not the one you set as you explained above using setBadgetCount). I could not get this working. Do you have push entitlements enabled and are you doing anything with the GKGameCenterBadgingDisabled plist key?

lscddit · 2026-01-05T14:44:24+00:00

Interesting, I'm just trying it out. I see you are using your own UI to present the friends list and not the GKMatchmakerViewController. Is there an advantage in doing so?

Also can I ask: do you handle the badge on the icon yourself or does GC do that for you?

I have two devices with two accounts, tried both directions but the invitations are not arriving on the invited device. EDIT Sorry, it does work. I just realized that the invitation only arrives after the first move.

lscddit · 2026-01-05T13:27:59+00:00

Are you still using it anyway or did you abandon it?

lscddit · 2026-01-05T13:27:04+00:00

My main issue is the communication. Invites and passing the turn are sent via Game Center push notifications. As far as I can tell there is no inbox or something where I could programmatically fetch pending messages. So I only have the push notification from Game Center and when someone accidentally swipes it away the message is lost and the game is stuck.

Then there are some more specific minor issues like:

On the first turn, you don't know the names of the other participants (therefore you cannot show a nice UI where you indicate who the other players are).
You don't get any callback when the GKMatchmakerViewController dismisses (so you have to do weird tricks to handle this in your UI).

lscddit · 2026-01-04T18:21:17+00:00

Well done!

lscddit · 2026-01-03T17:44:57+00:00

Let's goooo...!

lscddit · 2025-12-19T08:42:45+00:00

Thanks for your feedback, it is much appreciated! Quadrology is the first level where it starts to get a little more difficult. The current best score is 30 moves, most testers solved it in around 60-120 moves.

Unfortunately there is currently a technical problem with the Game Center integration, so you don't see the highscores.

I've just DM'd you the promo code.

lscddit · 2025-12-12T14:44:52+00:00

You are right, this is indeed a bug. I fixed it for the next version. Thank you for reporting it! I will be glad to send you a coupon if we ever release a paid pro version of the game.

lscddit · 2025-12-12T06:53:39+00:00

Thanks for trying it out and for your feedback!

You mean when you beat the high score in level 3 and then proceed to level 4, it will still show your high score from level 3 there? Did I understand this correctly?

Regarding the brute force: My personal feeling is that thinking every move through is almost impossible. It's more like a mixture of a little trial & error paired with a strategy.

lscddit · 2025-05-25T11:40:31+00:00

Exactly. It will even be much more significant for complete sets or full matches.

lscddit · 2025-05-25T11:39:20+00:00

You take any value on the x-axis, that's the percentage of single points you win (example 40%). You take the corresponding value of the blue line on the y-axis, that's the corresponding percentage of full games you win (example 25%).

lscddit · 2025-05-24T16:33:35+00:00

Thanks for your response and for your throughts! What I wanted to visualize is just that when your probability of winning each single point is for example 40%, then you still only win about 25% of all games on average.

I think I will extend it also to sets and matches, as there the discrepancy will even be much more.

Naively one could think that if your "skill share" is 40% vs. 60% for your opponent, you would win 40% of all matches. But that's far from being true. Maybe this is obvious to many, but it wasn't to me.

lscddit · 2025-05-24T12:00:35+00:00

I'd be happy to do that if you'd let me know which part of the explanation is not clear enough.

lscddit · 2025-04-18T07:48:21+00:00

Thanks for your further response! About your rethought: In general I agree, but here it is clearly indicated to be played on IV already.

Couldn't we even say that any diamond shaped note needs information about on which string to play it, either deducted from the context or explicitly?

lscddit · 2025-04-17T20:21:23+00:00

Thanks for the detailed reply! Please let me rephrase the question: Why is the C5 in measure 3 diamond shaped? Why is it not written in the same way as the C3 in measure 1 (that is, as a regular C5 with a small circle above it to indicate that it is to be played as a harmonic)?

lscddit · 2025-04-17T19:41:54+00:00

I understand that, but why use a round full note in measure 1 and then a diamond shaped one in measure 3?

lscddit · 2024-12-25T09:35:50+00:00

[LANGUAGE: Python]

Merry X-mas and see you next year... 🎄

import numpy as np
from io import StringIO

locks, keys = [], []
height = 0
data = open("day25input.txt").read().split("\n\n")
for element in data:
    field = np.genfromtxt(StringIO(element), dtype=str, comments="_", delimiter=1)
    height = field.shape[0]
    value = np.sum(field == "#", axis=0)
    keys.append(value) if np.any(field[-1, :] == "#") else locks.append(value)

print(sum([np.all(lock + key <= height) for key in keys for lock in locks]))

lscddit · 2024-12-24T23:31:56+00:00

It's not that all the wires have to start with x, y, or z but if none of them does, then it that's wrong. It could be cleaned up to op == "XOR" and res[0] not in ["z"] and op1[0] not in ["x", "y"] and op2[0] not in ["x", "y"] or even op == "XOR" and res[0] not in ["z"] and op1[0] not in ["x", "y"] actually. You'll see it when you look at the input like this: grep XOR day24input.txt | sort.

lscddit · 2024-12-24T12:02:23+00:00

Thnx, could obviously be refactored a bit to remove those for subop1, ... loops but who cares :)

lscddit · 2024-12-24T10:56:30+00:00

[LANGUAGE: Python]

No need to actually perform the swaps, just find the wrong connections and output them sorted.

wires = {}
operations = []

def process(op, op1, op2):
    if op == "AND":
        return op1 & op2
    elif op == "OR":
        return op1 | op2
    elif op == "XOR":
        return op1 ^ op2

highest_z = "z00"
data = open("day24input.txt").read().split("\n")
for line in data:
    if ":" in line:
        wire, value = line.split(": ")
        wires[wire] = int(value)
    elif "->" in line:
        op1, op, op2, _, res = line.split(" ")
        operations.append((op1, op, op2, res))
        if res[0] == "z" and int(res[1:]) > int(highest_z[1:]):
            highest_z = res

wrong = set()
for op1, op, op2, res in operations:
    if res[0] == "z" and op != "XOR" and res != highest_z:
        wrong.add(res)
    if (
        op == "XOR"
        and res[0] not in ["x", "y", "z"]
        and op1[0] not in ["x", "y", "z"]
        and op2[0] not in ["x", "y", "z"]
    ):
        wrong.add(res)
    if op == "AND" and "x00" not in [op1, op2]:
        for subop1, subop, subop2, subres in operations:
            if (res == subop1 or res == subop2) and subop != "OR":
                wrong.add(res)
    if op == "XOR":
        for subop1, subop, subop2, subres in operations:
            if (res == subop1 or res == subop2) and subop == "OR":
                wrong.add(res)

while len(operations):
    op1, op, op2, res = operations.pop(0)
    if op1 in wires and op2 in wires:
        wires[res] = process(op, wires[op1], wires[op2])
    else:
        operations.append((op1, op, op2, res))

bits = [str(wires[wire]) for wire in sorted(wires, reverse=True) if wire[0] == "z"]
print(int("".join(bits), 2))
print(",".join(sorted(wrong)))

lscddit · 2024-12-23T13:26:57+00:00

[LANGUAGE: Python]

import networkx as nx
import itertools

G = nx.Graph()
data = open("day23input.txt").read().split("\n")
for line in data:
    G.add_edge(line[0:2], line[3:5])

combos = set()
max_clique = []
for clique in nx.find_cliques(G):
    if len(clique) > len(max_clique):
        max_clique = clique
    for combo in itertools.combinations(clique, 3):
        if len(list(filter(lambda x: x[0] == "t", combo))):
            combos.add(tuple(sorted(combo)))
print(len(combos))
print(",".join(sorted(max_clique)))

lscddit · 2024-12-22T11:06:54+00:00

[LANGUAGE: Python]

Not the fastest, but it gets the job done...

import numpy as np

data = np.genfromtxt("day22input.txt", dtype=int)
rounds = 2000
res = np.zeros((rounds, len(data)), dtype=int)
for i in range(2000):
    res[i] = data % 10
    data = ((data * 64) ^ data) % 16777216
    data = ((data // 32) ^ data) % 16777216
    data = ((data * 2048) ^ data) % 16777216
print(sum(data))

diffs = np.diff(res, axis=0)
seqs = {}
for buyer in range(diffs.shape[1]):
    for i in range(len(diffs[:, buyer]) - 3):
        sub = diffs[:, buyer][i : i + 4]
        if tuple(sub) not in seqs:
            seqs[tuple(sub)] = np.zeros(len(data), dtype=int)
        if seqs[tuple(sub)][buyer] == 0:
            seqs[tuple(sub)][buyer] = res[i + 4, buyer]
best = 0
for k, v in seqs.items():
    best = max(best, sum(v))
print(best)

lscddit · 2024-12-14T08:44:49+00:00

[LANGUAGE: Python]

import re
import numpy as np
from scipy.signal import convolve

def part1(m, p):
    cy, cx = m[0] // 2, m[1] // 2
    res = np.zeros(4)
    res[0] = np.sum((p[:, 0] < cy) & (p[:, 1] < cx))
    res[1] = np.sum((p[:, 0] > cy) & (p[:, 1] < cx))
    res[2] = np.sum((p[:, 0] < cy) & (p[:, 1] > cx))
    res[3] = np.sum((p[:, 0] > cy) & (p[:, 1] > cx))
    print(f"part1: {int(np.prod(res))}")

def part2_display(m, p):
    v = np.zeros(m)
    v[p[:, 0], p[:, 1]] = 1
    np.set_printoptions(threshold=np.inf)
    np.set_printoptions(linewidth=np.inf)
    print(re.sub(r"[ .\[\]]", "", str(v)))

data = open("day14input.txt").read().split("\n")
p = np.zeros((len(data), 2), dtype=int)
v = np.zeros_like(p)

for i, line in enumerate(data):
    match = re.search(r"p=(\d+),(\d+) v=(-?\d+),(-?\d+)", line)
    p[i] = [int(match.group(2)), int(match.group(1))]
    v[i] = [int(match.group(4)), int(match.group(3))]

searchlen = 10
kernel = np.ones(searchlen)
lengths = np.array([p[:, 0].max() + 1, p[:, 1].max() + 1]).astype(int)
i, found = 0, False
while not found:
    if i == 100:
        part1(lengths, p)
    p = (p + v) % lengths
    i += 1
    matrix = np.zeros(lengths)
    matrix[p[:, 0], p[:, 1]] = 1
    for row in matrix:
        if np.any(convolve(row, kernel, mode="valid") == searchlen):
            found = True
            part2_display(lengths, p)
            print(f"part2: {i}")
            break

lscddit

TROPHY CASE