Re: Standing in the middle of a game

On Sun, 3 Jul 2005, Jason McIntosh wrote:

> I don't think we ever talked about what happens when a player tries to
> stand up while a game is active.

I mentioned it in a post at one point, I think.

> I see three ways to handle this:
> (1) The ref simply shoots down the idea. The player remains seated.
> And likes it.
> (2) The ref allows the player to stand. If this causes the player's
> seat to become unoccupied, the ref begins its user-departure
> countdown, exactly as if the player had abruptly left the table
> altogether.
> (3) As above, except that the ref _immediately_ suspends the game,
> resuming it when all seated players voice readiness, exactly as per
> the "suspend" timeout reaction defined on [[user departure]]. It will
> suspend the game even its its timeout reaction is set to "bot" or
> "throw", since overturning the table the instant a player stands seems
> obnoxious, and having a bot immediately leap into the seat only
> slightly less so.
>
> I think I like option (3) the best, since it involves stuff that the
> ref sometimes has to do anyway (in the case of a user-departure
> timeout), and doing a countdown while the player is (literally)
> standing right there seems weird. Standing is a very deliberate action
> (compared to a connection drop) and doesn't seem to fit the automated
> response of a wait-for-return timer. Letting the players resolve the
> situation seems more natural, to me.

What player decision are we trying to model by this action?

At config time, standing up indicates the decision "I have changed my mind 
about being a player in this game; I want to be an observer."

And disconnecting (while seated) indicates "I have changed my mind
about being a player in this game; I don't want to pay any attention to it 
at all."

(This has the nice property that, at config time, the disconnection of a 
seated player can be handled exactly as "stand up" followed by "log off". 
That's certainly how I've written my ref code.)

During game time, standing up indicates... what? It isn't the same 
decision as above, because you're already a player -- that fact has 
already been recorded in the game state, and will be recorded in the final 
game outcome. (Which represents everyone else's willingness to play 
the game with you, and everyone's agreement that your input contributed 
to the final score.)

If you're just interested in *observing*, i.e. *not making moves*, you can 
indicate that by not making any darn moves. If you're interested in 
shutting off your computer, you're going to quit the client, thus making a 
"disconnect" event rather than a "stand up" event; see user departure as 
already defined.

Perhaps you want to participate *only* as an observer -- i.e., stop 
reading seat chatter, and stop seeing the seat's hidden information (down 
cards, etc). That strikes me as slightly pathological, and I don't have 
any great desire to support it.

> I guess what I'm basically suggesting is that the only kind of
> seat-change permissible when a game is active are players stand()-ing
> themselves (though this act can lead to game suspension, where almost
> anything goes, seat-wise).

Given what I say above, I will counter-suggest your option (1), where *no* 
seat-change is permitted after the game starts. (Except perhaps for the
addition of a bot, in the "bot" path of user departure handling.) This 
simplifies referee handling, by making the (human) membership of each seat 
absolutely immutable over the course of the game. A player can 
disconnect, but he's still a member of that seat (for purposes of the 
final game record, and in case he reconnects).

BTW, I thought of a quirk we should add to the departure rules. There are 
many games where a player (seat) is eliminated from the game before it's 
over. (E.g., Monopoly when you run out of money. Although it may not 
represent losing the game -- imagine a race game where the first player 
across the line wins, but the game continues to determine second place 
etc.)

The defining condition here is that the eliminated seat has no more game 
decisions to make. We should allow referees to make this determination -- 
mark a seat "eliminated" -- and then allow players in those seats to 
disconnect *without* triggering the departure protocol. In other words: 
once you're out of Monopoly money, you can turn off your computer and go 
get a beer. You're still marked as a disconnected member of the seat,
but it's a nondisruptive departure, whether the seat is empty or not.

--Z

"And Aholibamah bare Jeush, and Jaalam, and Korah: these were the borogoves..."
*
I'm still thinking about what to put in this space.

-------------------------------------------------------
SF.Net email is sponsored by: Discover Easy Linux Migration Strategies
from IBM. Find simple to follow Roadmaps, straightforward articles,
informative Webcasts and more! Get everything you need to get up to
speed, fast. http://ads.osdn.com/?ad_id=7477&alloc_id=16492&op=click