Behold Vilya, Ring of Air and repository for our game and virtual worldly

extensions to the distributed environment provided by Narya. git-svn-id: svn+ssh://src.earth.threerings.net/vilya/trunk@1 c613c5cb-e716-0410-b11b-feb51c14d237
2006-06-23 17:58:11 +00:00
commit a4df87e52f
317 changed files with 45818 additions and 0 deletions
@@ -0,0 +1,92 @@
+//
+// $Id: TurnGameManager.java 3390 2005-03-10 00:13:25Z tedv $
+//
+// Narya library - tools for developing networked games
+// Copyright (C) 2002-2004 Three Rings Design, Inc., All Rights Reserved
+// http://www.threerings.net/code/narya/
+//
+// This library is free software; you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation; either version 2.1 of the License, or
+// (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+package com.threerings.parlor.turn.server;
+
+import com.threerings.util.Name;
+
+import com.threerings.parlor.game.server.GameManager;
+
+/**
+ * A game manager that wishes to make use of the turn game services should
+ * implement this interface and create a {@link TurnGameManagerDelegate}
+ * which will perform the basic turn game processing and call back to the
+ * main manager via this interface.
+ *
+ * <p> The basic flow of a turn-based game is as follows:
+ * <pre>
+ * GameManager.gameWillStart()
+ * GameManager.gameDidStart()
+ *   TurnGameManagerDelegate.setFirstTurnHolder()
+ *   TurnGameManagerDelegate.startTurn()
+ *     TurnGameManager.turnWillStart()
+ *   TurnGameManagerDelegate.endTurn()
+ *     TurnGameManager.turnDidEnd()
+ *   TurnGameManagerDelegate.setNextTurnHolder()
+ *   TurnGameManagerDelegate.startTurn()
+ *     ...
+ * GameManager.endGame()
+ * </pre>
+ */
+public interface TurnGameManager
+{
+    /**
+     * Extending {@link GameManager} should automatically handle
+     * implementing this method.
+     */
+    public Name getPlayerName (int index);
+
+    /**
+     * Extending {@link GameManager} should automatically handle
+     * implementing this method.
+     */
+    public int getPlayerIndex (Name username);
+
+    /**
+     * Extending {@link GameManager} should automatically handle
+     * implementing this method.
+     */
+    public int getPlayerCount ();
+
+    /**
+     * Extending {@link GameManager} should automatically handle
+     * implementing this method.
+     */
+    public boolean isActivePlayer (int pidx);
+
+    /**
+     * Called when we are about to start the next turn. Implementations
+     * can do whatever pre-start turn activities need to be done.
+     */
+    public void turnWillStart ();
+
+    /**
+     * Called when we have started the next turn. Implementations can do
+     * whatever post-start turn activities need to be done.
+     */
+    public void turnDidStart ();
+
+    /**
+     * Called when the turn was ended. Implementations can perform any
+     * post-turn processing (like updating scores, etc.).
+     */
+    public void turnDidEnd ();
+}
@@ -0,0 +1,246 @@
+//
+// $Id: TurnGameManagerDelegate.java 4188 2006-06-13 18:03:48Z mdb $
+//
+// Narya library - tools for developing networked games
+// Copyright (C) 2002-2004 Three Rings Design, Inc., All Rights Reserved
+// http://www.threerings.net/code/narya/
+//
+// This library is free software; you can redistribute it and/or modify it
+// under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation; either version 2.1 of the License, or
+// (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+package com.threerings.parlor.turn.server;
+
+import com.samskivert.util.RandomUtil;
+import com.threerings.util.Name;
+
+import com.threerings.crowd.data.PlaceObject;
+
+import com.threerings.parlor.Log;
+import com.threerings.parlor.game.server.GameManager;
+import com.threerings.parlor.game.server.GameManagerDelegate;
+
+import com.threerings.parlor.turn.data.TurnGameObject;
+
+/**
+ * Performs the server-side turn-based game processing for a turn based
+ * game. Game managers which wish to make use of the turn services must
+ * implement {@link TurnGameManager} and either create an instance of this
+ * class, or an instance of a derivation which customizes the behavior,
+ * either of which would be passed to {@link GameManager#addDelegate} to
+ * be activated.
+ */
+public class TurnGameManagerDelegate extends GameManagerDelegate
+{
+    /**
+     * Constructs a delegate that will manage the turn game state and call
+     * back to the supplied {@link TurnGameManager} implementation to let
+     * it in on the progression of the game.
+     */
+    public TurnGameManagerDelegate (TurnGameManager tgmgr)
+    {
+        super((GameManager)tgmgr);
+        _tgmgr = tgmgr;
+    }
+
+    /**
+     * Returns the index of the current turn holder as configured in the
+     * game object.
+     *
+     * @return the index into the players array of the current turn holder
+     * or <code>-1</code> if there is no current turn holder.
+     */
+    public int getTurnHolderIndex ()
+    {
+        return _tgmgr.getPlayerIndex(_turnGame.getTurnHolder());
+    }
+
+    /** Test if it's the inputted player's turn. */
+    public boolean isPlayersTurn (int playerIndex)
+    {
+        // Don't accidently match a visitor's id of -1 with the "no one's
+        // turn" state of turn -1.
+        int turnHolder = getTurnHolderIndex();
+        if (turnHolder < 0) {
+            return false;
+        }
+
+        // It's this player's turn if the ids match
+        return (turnHolder == playerIndex);
+    }
+
+    /**
+     * Called to start the next turn. It calls {@link
+     * TurnGameManager#turnWillStart} to allow our owning manager to
+     * perform any pre-start turn processing, sets the turn holder that
+     * was configured either when the game started or when finishing up
+     * the last turn, and then calls {@link TurnGameManager#turnDidStart}
+     * to allow the manager to perform any post-start turn
+     * processing. This assumes that a valid turn holder has been
+     * assigned. If some pre-game preparation needs to take place in a
+     * non-turn-based manner, this function should not be called until it
+     * is time to start the first turn.
+     */
+    public void startTurn ()
+    {
+        // sanity check
+        if (_turnIdx < 0 || _turnIdx >= _turnGame.getPlayers().length) {
+            Log.warning("startTurn() called with invalid turn index " +
+                        "[game=" + where() + ", turnIdx=" + _turnIdx + "].");
+            // abort, abort
+            return;
+        }
+
+        // get the player name and sanity-check again
+        Name name = _tgmgr.getPlayerName(_turnIdx);
+        if (name == null) {
+            Log.warning("startTurn() called with invalid player " +
+                        "[game=" + where() + ", turnIdx=" + _turnIdx + "].");
+            return;
+        }
+
+        // do pre-start processing
+        _tgmgr.turnWillStart();
+
+        // and set the turn indicator accordingly
+        _turnGame.setTurnHolder(name);
+
+        // do post-start processing
+        _tgmgr.turnDidStart();
+    }
+
+    /**
+     * Called to end the turn. Whatever indication a game manager has that
+     * the turn has ended (probably the submission of a valid move of some
+     * sort by the turn holding player), it should call this function to
+     * cause this turn to end and the next to begin.
+     *
+     * <p> If the next turn should not be started immediately after this
+     * turn, the game manager should arrange for {@link
+     * #setNextTurnHolder} to set the {@link #_turnIdx} field to
+     * <code>-1</code> which will cause us not to start the next turn. It
+     * can then call {@link GameManager#endGame} if the game is over or do
+     * whatever else it needs to do outside the context of the turn flow.
+     * To start things back up again it would set {@link #_turnIdx} to the
+     * next turn holder and call {@link #startTurn} itself.
+     */
+    public void endTurn ()
+    {
+        // let the manager know that the turn is over
+        _tgmgr.turnDidEnd();
+
+        // figure out who's up next
+        setNextTurnHolder();
+
+        // and start the next turn if desired
+        if (_turnIdx != -1) {
+            startTurn();
+
+        } else {
+            // otherwise, clear out the turn holder
+            _turnGame.setTurnHolder(null);
+        }
+    }
+
+    // documentation inherited
+    public void didStartup (PlaceObject plobj)
+    {
+        _turnGame = (TurnGameObject)plobj;
+    }
+
+    // documentation inherited
+    public void playerWasReplaced (int pidx, Name oplayer, Name nplayer)
+    {
+        // we need to update the turn holder if the current turn holder
+        // was the player that was replaced and we need to do so in a way
+        // that doesn't make everyone think that the turn just changed
+        if (oplayer != null && oplayer.equals(_turnGame.getTurnHolder())) {
+            // small hackery: this will indicate to the client that we are
+            // replacing the turn holder rather than changing the turn
+            _turnGame.setTurnHolder(TurnGameObject.TURN_HOLDER_REPLACED);
+            _turnGame.setTurnHolder(nplayer);
+        }
+    }
+
+    /**
+     * This should be called from {@link GameManager#gameDidStart} to let
+     * the turn delegate perform start of game processing.
+     */
+    public void gameDidStart ()
+    {
+        // figure out who will be first
+        setFirstTurnHolder();
+
+        // and start the first turn if we should apparently do so
+        if (_turnIdx != -1) {
+            startTurn();
+        }
+    }
+
+    /**
+     * This is called to determine which player will take the first
+     * turn. The default implementation chooses a player at random.
+     */
+    protected void setFirstTurnHolder ()
+    {
+        int size = _turnGame.getPlayers().length;
+        int firstPick = _turnIdx = RandomUtil.getInt(size);
+        while (!_tgmgr.isActivePlayer(_turnIdx)) {
+            _turnIdx = (_turnIdx + 1) % size;
+            if (_turnIdx == firstPick) {
+                Log.warning("No players eligible for first turn. Choking. " +
+                            "[game=" + where() + "].");
+                return;
+            }
+        }
+    }
+
+    /**
+     * This is called to determine which player will next hold the turn.
+     * The default implementation simply rotates through the players in
+     * order, but some games may need to mess with the turn from time to
+     * time. This should update the <code>_turnIdx</code> field, not set
+     * the turn holder field in the game object directly.
+     */
+    protected void setNextTurnHolder ()
+    {
+        // stick with the current player if they're the only participant
+        if (_tgmgr.getPlayerCount() == 1) {
+            return;
+        }
+
+        // find the next occupied active player slot
+        int size = _turnGame.getPlayers().length;
+        int oturnIdx = _turnIdx;
+        do {
+            _turnIdx = (_turnIdx + 1) % size;
+            if (_turnIdx == oturnIdx) {
+                // if we've wrapped all the way around, stop where we are
+                // even if the current player is not active.
+                Log.warning("1 or less active players. Unable to properly " +
+                            "change turn. [game=" + where() + "].");
+                break;
+            }
+        } while (!_tgmgr.isActivePlayer(_turnIdx));
+    }
+
+    /** The game manager for which we are delegating. */
+    protected TurnGameManager _tgmgr;
+
+    /** A reference to our game object. */
+    protected TurnGameObject _turnGame;
+
+    /** The player index of the current turn holder or <code>-1</code> if
+     * it's no one's turn. */
+    protected int _turnIdx = -1;
+}