AfflictionNetworks/vilya
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

No longer pass the manager in the constructor. As many of these delegates are

Browse Source 
in the wild, we'll deprecate the old constructors rather than remove them.  Yay
cruft!


git-svn-id: svn+ssh://src.earth.threerings.net/vilya/trunk@487 c613c5cb-e716-0410-b11b-feb51c14d237
This commit is contained in:
Michael Bayne
2007-11-10 04:41:44 +00:00
parent 265cf43941
commit eb80403bbe
8 changed files with 312 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/java/com/threerings/ezgame/server/EZGameManager.java
+1 -1
View File
@@ -73,7 +73,7 @@ public class EZGameManager extends GameManager
{
public EZGameManager ()
{
addDelegate(_turnDelegate = new EZGameTurnDelegate(this));
addDelegate(_turnDelegate = new EZGameTurnDelegate());
}
/**
src/java/com/threerings/ezgame/server/EZGameTurnDelegate.java
-5
View File
@@ -33,11 +33,6 @@ import com.threerings.parlor.turn.server.TurnGameManagerDelegate;
*/
public class EZGameTurnDelegate extends TurnGameManagerDelegate
{
public EZGameTurnDelegate (EZGameManager mgr)
{
super(mgr);
}
/**
* A form of endTurn where you can specify the next turn holder oid.
*/
src/java/com/threerings/parlor/card/trick/server/TrickCardGameManagerDelegate.java
+99 -98
View File
@@ -37,7 +37,8 @@ import com.threerings.presents.server.PresentsServer;
import com.threerings.crowd.data.BodyObject;
import com.threerings.crowd.data.PlaceObject;
import com.threerings.parlor.game.server.GameManager;
import com.threerings.crowd.server.PlaceManager;
import com.threerings.parlor.turn.server.TurnGameManagerDelegate;
import com.threerings.parlor.card.Log;
@@ -56,34 +57,38 @@ import com.threerings.parlor.card.trick.data.TrickCardGameObject;
public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
implements TrickCardGameProvider
{
/**
* Constructor.
*
* @param manager the game manager
*/
public TrickCardGameManagerDelegate (CardGameManager manager)
public TrickCardGameManagerDelegate ()
{
super(manager);
_cgmgr = manager;
_deck = new Deck();
}
// Documentation inherited.
/**
* @deprecated use the zero-argument constructor.
*/
@Deprecated public TrickCardGameManagerDelegate (CardGameManager manager)
{
}
@Override // from PlaceManagerDelegate
public void setPlaceManager (PlaceManager plmgr)
{
super.setPlaceManager(plmgr);
_cgmgr = (CardGameManager)plmgr;
}
@Override // from PlaceManagerDelegate
public void didStartup (PlaceObject plobj)
{
super.didStartup(plobj);
_deck = new Deck();
_trickCardGame = (TrickCardGameObject)plobj;
_cardGame = (CardGameObject)plobj;
_trickCardGame.setTrickCardGameService(
(TrickCardGameMarshaller)PresentsServer.invmgr.registerDispatcher(
new TrickCardGameDispatcher(this)));
}
// Documentation inherited.
@Override // from PlaceManagerDelegate
public void didShutdown ()
{
super.didShutdown();
@@ -91,7 +96,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
PresentsServer.invmgr.clearDispatcher(_trickCardGame.getTrickCardGameService());
}
// Documentation inherited.
@Override // from GameManagerDelegate
public void gameWillStart ()
{
super.gameWillStart();
@@ -116,7 +121,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
startHand();
}
// Documentation inherited.
@Override // from GameManagerDelegate
public void gameDidEnd ()
{
super.gameDidEnd();
@@ -134,7 +139,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setRematchRequests(new int[_cardGame.getPlayerCount()]);
}
// Documentation inherited.
@Override // from TurnGameManagerDelegate
public void startTurn ()
{
super.startTurn();
@@ -144,7 +149,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_turnTimeoutInterval.schedule(_trickCardGame.getTurnDuration());
}
// Documentation inherited.
@Override // from TurnGameManagerDelegate
public void endTurn ()
{
// cancel the timeout interval
@@ -205,11 +210,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
trickDidEnd();
}
/**
* Processes a request to transfer a group of cards between players.
* Default implementation verifies that the user's hand contains the
* specified cards, then calls {@link #sendCardsToPlayer(int, int, Card[])}.
*/
// from interface TrickCardGameProvider
public void sendCardsToPlayer (ClientObject client, int toidx, Card[] cards)
{
// make sure they're actually a player
@@ -231,25 +232,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
sendCardsToPlayer(fromidx, toidx, cards);
}
/**
* Sends cards between players without error checking. Default
* implementation transfers the cards between hands and notifies
* everyone of the transfer using {@link
* CardGameManager#transferCardsBetweenPlayers(int, int, Card[])}.
*/
protected void sendCardsToPlayer (int fromidx, int toidx, Card[] cards)
{
// remove from sending player's hand
_hands[fromidx].removeAll(cards);
// add to receiving player's hand
_hands[toidx].addAll(cards);
// notify everyone of the transfer
_cgmgr.transferCardsBetweenPlayers(fromidx, toidx, cards);
}
// Documentation inherited.
// from interface TrickCardGameProvider
public void playCard (ClientObject client, Card card, int handSize)
{
// make sure we're playing a trick
@@ -286,39 +269,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
// play the card
playCard(pidx, card);
}
/**
* Plays a card for a player without error checking.
*/
protected void playCard (int pidx, Card card)
{
((DObject) _trickCardGame).startTransaction();
try {
// play the card by removing it from the hand and adding it
// to the end of the cards played array
_hands[pidx].remove(card);
PlayerCard[] cards = (PlayerCard[])ArrayUtil.append(
_trickCardGame.getCardsPlayed(), new PlayerCard(pidx, card));
_trickCardGame.setCardsPlayed(cards);
// end the user's turn
endTurn();
// end the trick if everyone has played a card
if (_turnIdx == -1) {
if (_endTrickDelay == 0) {
endTrick();
} else {
_endTrickInterval.schedule(_endTrickDelay);
}
}
} finally {
((DObject) _trickCardGame).commitTransaction();
}
}
// Documentation inherited.
// from interface TrickCardGameProvider
public void requestRematch (ClientObject client)
{
// make sure the game is over
@@ -354,6 +305,56 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
}
}
/**
* Sends cards between players without error checking. Default
* implementation transfers the cards between hands and notifies
* everyone of the transfer using {@link
* CardGameManager#transferCardsBetweenPlayers(int, int, Card[])}.
*/
protected void sendCardsToPlayer (int fromidx, int toidx, Card[] cards)
{
// remove from sending player's hand
_hands[fromidx].removeAll(cards);
// add to receiving player's hand
_hands[toidx].addAll(cards);
// notify everyone of the transfer
_cgmgr.transferCardsBetweenPlayers(fromidx, toidx, cards);
}
/**
* Plays a card for a player without error checking.
*/
protected void playCard (int pidx, Card card)
{
((DObject) _trickCardGame).startTransaction();
try {
// play the card by removing it from the hand and adding it
// to the end of the cards played array
_hands[pidx].remove(card);
PlayerCard[] cards = (PlayerCard[])ArrayUtil.append(
_trickCardGame.getCardsPlayed(), new PlayerCard(pidx, card));
_trickCardGame.setCardsPlayed(cards);
// end the user's turn
endTurn();
// end the trick if everyone has played a card
if (_turnIdx == -1) {
if (_endTrickDelay == 0) {
endTrick();
} else {
_endTrickInterval.schedule(_endTrickDelay);
}
}
} finally {
((DObject) _trickCardGame).commitTransaction();
}
}
/**
* Returns the number of players currently requesting or accepting a rematch.
*/
@@ -377,7 +378,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
return _trickCardGame.getCardsPlayed().length == _cardGame.getPlayerCount();
}
// Documentation inherited.
@Override // from TurnGameManagerDelegate
protected void setFirstTurnHolder ()
{
if (_trickCardGame.getTrickState() == TrickCardGameObject.PLAYING_TRICK) {
@@ -388,7 +389,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
}
}
// Documentation inherited.
@Override // from TurnGameManagerDelegate
protected void setNextTurnHolder ()
{
if (_trickCardGame.getTrickState() == TrickCardGameObject.PLAYING_TRICK &&
@@ -455,7 +456,8 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
* Notifies the object that a new hand is about to start.
*/
protected void handWillStart ()
{}
{
}
/**
* Notifies the object that a new hand has just started. Default
@@ -530,7 +532,8 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
* Notifies the object that the trick is about to end.
*/
protected void trickWillEnd ()
{}
{
}
/**
* Notifies the object that the trick has ended. Default implementation
@@ -568,6 +571,21 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
return false;
}
/** The all-purpose turn timeout interval. */
protected Interval _turnTimeoutInterval = new Interval(PresentsServer.omgr) {
public void expired () {
_turnTimedOut = true;
turnTimedOut();
}
};
/** Calls {@link #endTrick} upon expiration. */
protected Interval _endTrickInterval = new Interval(PresentsServer.omgr) {
public void expired () {
endTrick();
}
};
/** The card game manager. */
protected CardGameManager _cgmgr;
@@ -589,27 +607,10 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
/** Whether or not the turn timed out. */
protected boolean _turnTimedOut;
/** The all-purpose turn timeout interval. */
protected Interval _turnTimeoutInterval = new Interval(PresentsServer.omgr) {
public void expired () {
_turnTimedOut = true;
turnTimedOut();
}
};
/** Calls {@link #endTrick} upon expiration. */
protected Interval _endTrickInterval = new Interval(PresentsServer.omgr) {
public void expired () {
endTrick();
}
};
/** Reduce turn duration scales by this amount each time the player times out. */
protected static final float TURN_DURATION_SCALE_REDUCTION = 0.25f;
/**
* Increase turn duration scales by this amount each time the player
* manages not to time out. */
/** Turn duration scales increase by this amount each time the player doesn't time out. */
protected static final float TURN_DURATION_SCALE_INCREASE = 0.5f;
/** Don't let turn duration scales get below this level. */
src/java/com/threerings/parlor/game/server/GameManagerDelegate.java
+16 -17
View File
@@ -28,18 +28,19 @@ import com.threerings.crowd.server.PlaceManagerDelegate;
import com.threerings.parlor.game.data.GameAI;
/**
* Extends the {@link PlaceManagerDelegate} mechanism with game manager
* specific methods.
* Extends the {@link PlaceManagerDelegate} mechanism with game manager specific methods.
*/
public class GameManagerDelegate extends PlaceManagerDelegate
{
/**
* Provides the delegate with a reference to the game manager for
* which it is delegating.
*/
public GameManagerDelegate (GameManager gmgr)
public GameManagerDelegate ()
{
}
/**
* @deprecated use the zero-argument constructor.
*/
@Deprecated public GameManagerDelegate (GameManager gmgr)
{
super(gmgr);
}
/**
@@ -57,16 +58,15 @@ public class GameManagerDelegate extends PlaceManagerDelegate
}
/**
* Called when a player in the game has been replaced by a call to
* {@link GameManager#replacePlayer}.
* Called when a player in the game has been replaced by a call to {@link
* GameManager#replacePlayer}.
*/
public void playerWasReplaced (int pidx, Name oldPlayer, Name newPlayer)
{
}
/**
* Called by the manager when we should do some AI. Only called while
* the game is IN_PLAY.
* Called by the manager when we should do some AI. Only called while the game is IN_PLAY.
*
* @param pidx the player index to fake some gameplay for.
* @param ai a record indicating the AI's configuration.
@@ -90,17 +90,16 @@ public class GameManagerDelegate extends PlaceManagerDelegate
}
/**
* Called when the game is about to reset, but before any other
* clearing out of game data has taken place. Derived classes should
* override this if they need to perform some pre-reset activities.
* Called when the game is about to reset, but before any other clearing out of game data has
* taken place. Derived classes should override this if they need to perform some pre-reset
* activities.
*/
public void gameWillReset ()
{
}
/**
* Called when the specified player has been set as an AI with the
* supplied AI configuration.
* Called when the specified player has been set as an AI with the supplied AI configuration.
*/
public void setAI (int pidx, GameAI ai)
{
src/java/com/threerings/parlor/rating/server/RatingManagerDelegate.java
+12 -6
View File
@@ -42,8 +42,10 @@ import com.threerings.util.Name;
import com.threerings.media.util.MathUtil;
import com.threerings.crowd.data.BodyObject;
import com.threerings.crowd.data.PlaceConfig;
import com.threerings.crowd.data.PlaceObject;
import com.threerings.crowd.server.CrowdServer;
import com.threerings.crowd.server.PlaceManager;
import com.threerings.parlor.game.data.GameConfig;
import com.threerings.parlor.game.data.GameObject;
@@ -60,13 +62,17 @@ import com.threerings.parlor.rating.server.persist.RatingRepository;
public abstract class RatingManagerDelegate extends GameManagerDelegate
implements RatingCodes
{
/**
* Constructs a rating manager delegate.
*/
public RatingManagerDelegate (GameManager gmgr)
@Override // from PlaceManagerDelegate
public void setPlaceManager (PlaceManager plmgr)
{
super(gmgr);
_gmgr = gmgr;
super.setPlaceManager(plmgr);
_gmgr = (GameManager)plmgr;
}
@Override // from PlaceManagerDelegate
public void didInit (PlaceConfig config)
{
super.didInit(config);
_repo = getRatingRepository();
}
src/java/com/threerings/parlor/turn/server/TurnGameManagerDelegate.java
+62 -64
View File
@@ -25,6 +25,7 @@ import com.samskivert.util.RandomUtil;
import com.threerings.util.Name;
import com.threerings.crowd.data.PlaceObject;
import com.threerings.crowd.server.PlaceManager;
import com.threerings.parlor.Log;
import com.threerings.parlor.game.server.GameManager;
@@ -33,31 +34,36 @@ 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.
* 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)
public TurnGameManagerDelegate ()
{
super((GameManager)tgmgr);
_tgmgr = tgmgr;
}
/**
* Returns the index of the current turn holder as configured in the game
* object.
* @deprecated use the zero-argument constructor.
*/
@Deprecated public TurnGameManagerDelegate (TurnGameManager tgmgr)
{
}
@Override // from PlaceManagerDelegate
public void setPlaceManager (PlaceManager plmgr)
{
super.setPlaceManager(plmgr);
_tgmgr = (TurnGameManager)plmgr;
}
/**
* 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.
* @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 ()
{
@@ -67,8 +73,7 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
/** 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.
// 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;
@@ -79,22 +84,20 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
}
/**
* 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.
* 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 + "].");
Log.warning("startTurn() called with invalid turn index [game=" + where() +
", turnIdx=" + _turnIdx + "].");
// abort, abort
return;
}
@@ -102,8 +105,8 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
// 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 + "].");
Log.warning("startTurn() called with invalid player [game=" + where() +
", turnIdx=" + _turnIdx + "].");
return;
}
@@ -118,21 +121,18 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
}
/**
* 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.
* 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 game is no longer in play (see {@link TurnGame#isInPlay})
* after having called {@link TurnGameManager#turnDidEnd} and {@link
* #setNextTurnHolder}, then the next turn will not automatically be
* started.
* <p> If the game is no longer in play (see {@link TurnGame#isInPlay}) after having called
* {@link TurnGameManager#turnDidEnd} and {@link #setNextTurnHolder}, then the next turn will
* not automatically be started.
*
* <p> If the game is in play, but the next turn should not be started
* immediately, the game manager should have {@link #setNextTurnHolder} set
* the {@link #_turnIdx} field to <code>-1</code> which will cause us to
* not start the next turn. To start things back up again it would set
* {@link #_turnIdx} to the next turn holder and call {@link #startTurn}
* <p> If the game is in play, but the next turn should not be started immediately, the game
* manager should have {@link #setNextTurnHolder} set the {@link #_turnIdx} field to
* <code>-1</code> which will cause us to not start the next turn. To start things back up
* again it would set {@link #_turnIdx} to the next turn holder and call {@link #startTurn}
* itself.
*/
public void endTurn ()
@@ -162,20 +162,20 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
// 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
// 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
// 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.
* This should be called from {@link GameManager#gameDidStart} to let the turn delegate perform
* start of game processing.
*/
public void gameDidStart ()
{
@@ -189,8 +189,8 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
}
/**
* This is called to determine which player will take the first
* turn. The default implementation chooses a player at random.
* This is called to determine which player will take the first turn. The default
* implementation chooses a player at random.
*/
protected void setFirstTurnHolder ()
{
@@ -198,10 +198,9 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
}
/**
* 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
* 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 ()
@@ -217,10 +216,10 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
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() + "].");
// 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));
@@ -251,7 +250,6 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
/** 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. */
/** The player index of the current turn holder or <code>-1</code> if it's no one's turn. */
protected int _turnIdx = -1;
}
src/java/com/threerings/puzzle/drop/server/DropManagerDelegate.java
+10 -5
View File
@@ -64,14 +64,19 @@ public abstract class DropManagerDelegate extends PuzzleManagerDelegate
implements PuzzleCodes, DropCodes
{
/**
* Provides the delegate with a reference to the manager for which it
* is delegating as well as the logic object that it uses to determine
* how to manage the drop puzzle.
* @deprecated use {@link #DropManagerDelegate(DropLogic)}.
*/
public DropManagerDelegate (PuzzleManager puzmgr, DropLogic logic)
@Deprecated public DropManagerDelegate (PuzzleManager puzmgr, DropLogic logic)
{
super(puzmgr);
this(logic);
}
/**
* Creates a drop manager delegate with a logic that it uses to determine how to manage the
* drop puzzle.
*/
public DropManagerDelegate (DropLogic logic)
{
// configure the game-specific settings
_usedrop = logic.useBlockDropping();
_userise = logic.useBoardRising();
src/java/com/threerings/puzzle/server/PuzzleManagerDelegate.java
+18 -8
View File
@@ -21,21 +21,31 @@
package com.threerings.puzzle.server;
import com.threerings.crowd.server.PlaceManager;
import com.threerings.parlor.game.server.GameManagerDelegate;
/**
* Extends the {@link GameManagerDelegate} mechanism with puzzle manager
* specific methods (of which there are currently none).
* Extends the {@link GameManagerDelegate} mechanism with puzzle manager specific methods (of which
* there are currently none).
*/
public class PuzzleManagerDelegate extends GameManagerDelegate
{
/**
* Constructs a puzzle manager delegate.
*/
public PuzzleManagerDelegate (PuzzleManager puzmgr)
public PuzzleManagerDelegate ()
{
super(puzmgr);
_puzmgr = puzmgr;
}
/**
* @deprecated use the zero-argument constructor.
*/
@Deprecated public PuzzleManagerDelegate (PuzzleManager puzmgr)
{
}
@Override // from PlaceManagerDelegate
public void setPlaceManager (PlaceManager plmgr)
{
super.setPlaceManager(plmgr);
_puzmgr = (PuzzleManager)plmgr;
}
protected PuzzleManager _puzmgr;