that sounds really similar to how I maintain what moves are legal in our game. If the player makes a move on one blink, it broadcasts that move to all the blinks and each blink maintains a state of player index to move. With that state locally, they can know what moves are legal if one is made directly on them later. I’m also broadcasting state changes when players tap a blink so that all of the blinks are in the same game state
I’m not sure how you implemented broadcasting but I had to have a unique key to the message (in my case usually the last byte of the time) so that blinks could avoid re-broadcasting the same message or needing to maintain a more complex state (like here with the task). The main issue I hit then was that I needed to be sure two different messages would never be broadcast at once since that could cause things to go a bit nuts.
I mention that because I think it was the main reason I couldn’t solve my score problem with my simple broadcast solution and used this task solution instead. Since, at times, all blinks in my game update their score at simultaneously, it would have been very slow or expensive for me to sync up the shared player score in real time via broadcast.
Side note: you mentioned your using the blink serial to identify each unique blink. I started down that route at one point early on but had to backtrack since the full serial is a whopping 8 bytes. Ended up chewing up a ton of space everywhere I was indexing things specific to a blink. It ended up being the reason I initially wrote the first form of this task solution. Each blink could enumerate its self and self assign a unique index so they only had to broadcast a single byte to identify themselves / store info about one another.