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 () 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 class EZGameTurnDelegate extends TurnGameManagerDelegate
{ {
public EZGameTurnDelegate (EZGameManager mgr)
{
super(mgr);
}
/** /**
* A form of endTurn where you can specify the next turn holder oid. * A form of endTurn where you can specify the next turn holder oid.
*/ */
src/java/com/threerings/parlor/card/trick/server/TrickCardGameManagerDelegate.java
+193 -192
View File
@@ -37,7 +37,8 @@ import com.threerings.presents.server.PresentsServer;
import com.threerings.crowd.data.BodyObject; import com.threerings.crowd.data.BodyObject;
import com.threerings.crowd.data.PlaceObject; 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.turn.server.TurnGameManagerDelegate;
import com.threerings.parlor.card.Log; import com.threerings.parlor.card.Log;
@@ -55,112 +56,116 @@ import com.threerings.parlor.card.trick.data.TrickCardGameObject;
*/ */
public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
implements TrickCardGameProvider implements TrickCardGameProvider
{ {
/** public TrickCardGameManagerDelegate ()
* Constructor.
*
* @param manager the game manager
*/
public TrickCardGameManagerDelegate (CardGameManager manager)
{ {
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) public void didStartup (PlaceObject plobj)
{ {
super.didStartup(plobj); super.didStartup(plobj);
_deck = new Deck();
_trickCardGame = (TrickCardGameObject)plobj; _trickCardGame = (TrickCardGameObject)plobj;
_cardGame = (CardGameObject)plobj; _cardGame = (CardGameObject)plobj;
_trickCardGame.setTrickCardGameService( _trickCardGame.setTrickCardGameService(
(TrickCardGameMarshaller)PresentsServer.invmgr.registerDispatcher( (TrickCardGameMarshaller)PresentsServer.invmgr.registerDispatcher(
new TrickCardGameDispatcher(this))); new TrickCardGameDispatcher(this)));
} }
// Documentation inherited. @Override // from PlaceManagerDelegate
public void didShutdown () public void didShutdown ()
{ {
super.didShutdown(); super.didShutdown();
PresentsServer.invmgr.clearDispatcher(_trickCardGame.getTrickCardGameService()); PresentsServer.invmgr.clearDispatcher(_trickCardGame.getTrickCardGameService());
} }
// Documentation inherited. @Override // from GameManagerDelegate
public void gameWillStart () public void gameWillStart ()
{ {
super.gameWillStart(); super.gameWillStart();
// clear out the last cards played // clear out the last cards played
_trickCardGame.setLastCardsPlayed(null); _trickCardGame.setLastCardsPlayed(null);
// initialize the turn duration scales // initialize the turn duration scales
float[] scales = new float[_cardGame.getPlayerCount()]; float[] scales = new float[_cardGame.getPlayerCount()];
Arrays.fill(scales, 1.0f); Arrays.fill(scales, 1.0f);
_trickCardGame.setTurnDurationScales(scales); _trickCardGame.setTurnDurationScales(scales);
} }
/** /**
* Called when the game has started. Default implementation starts the first hand. * Called when the game has started. Default implementation starts the first hand.
*/ */
public void gameDidStart () public void gameDidStart ()
{ {
super.gameDidStart(); super.gameDidStart();
// start the first hand // start the first hand
startHand(); startHand();
} }
// Documentation inherited. @Override // from GameManagerDelegate
public void gameDidEnd () public void gameDidEnd ()
{ {
super.gameDidEnd(); super.gameDidEnd();
// make sure all intervals are cancelled // make sure all intervals are cancelled
_turnTimeoutInterval.cancel(); _turnTimeoutInterval.cancel();
_endTrickInterval.cancel(); _endTrickInterval.cancel();
// make sure trick state is back to between hands // make sure trick state is back to between hands
if (_trickCardGame.getTrickState() != TrickCardGameObject.BETWEEN_HANDS) { if (_trickCardGame.getTrickState() != TrickCardGameObject.BETWEEN_HANDS) {
_trickCardGame.setTrickState(TrickCardGameObject.BETWEEN_HANDS); _trickCardGame.setTrickState(TrickCardGameObject.BETWEEN_HANDS);
} }
// initialize the array of rematch requests // initialize the array of rematch requests
_trickCardGame.setRematchRequests(new int[_cardGame.getPlayerCount()]); _trickCardGame.setRematchRequests(new int[_cardGame.getPlayerCount()]);
} }
// Documentation inherited. @Override // from TurnGameManagerDelegate
public void startTurn () public void startTurn ()
{ {
super.startTurn(); super.startTurn();
// initialize the timeout flag and schedule the timeout interval // initialize the timeout flag and schedule the timeout interval
_turnTimedOut = false; _turnTimedOut = false;
_turnTimeoutInterval.schedule(_trickCardGame.getTurnDuration()); _turnTimeoutInterval.schedule(_trickCardGame.getTurnDuration());
} }
// Documentation inherited. @Override // from TurnGameManagerDelegate
public void endTurn () public void endTurn ()
{ {
// cancel the timeout interval // cancel the timeout interval
_turnTimeoutInterval.cancel(); _turnTimeoutInterval.cancel();
// reduce or increase the turn duration scale // reduce or increase the turn duration scale
if (_turnTimedOut) { if (_turnTimedOut) {
reduceTurnDurationScale(_turnIdx); reduceTurnDurationScale(_turnIdx);
} else { } else {
increaseTurnDurationScale(_turnIdx); increaseTurnDurationScale(_turnIdx);
} }
super.endTurn(); super.endTurn();
} }
/** /**
* Starts a hand of cards. Calls {@link #handWillStart}, sets the trick * Starts a hand of cards. Calls {@link #handWillStart}, sets the trick
* state to PLAYING_HAND, and calls {@link #handDidStart}. * state to PLAYING_HAND, and calls {@link #handDidStart}.
@@ -171,7 +176,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setTrickState(TrickCardGameObject.PLAYING_HAND); _trickCardGame.setTrickState(TrickCardGameObject.PLAYING_HAND);
handDidStart(); handDidStart();
} }
/** /**
* Ends the hand of cards. Calls {@link #handWillEnd}, sets the trick * Ends the hand of cards. Calls {@link #handWillEnd}, sets the trick
* state to BETWEEN_HANDS, and calls {@link #handDidEnd}. * state to BETWEEN_HANDS, and calls {@link #handDidEnd}.
@@ -182,7 +187,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setTrickState(TrickCardGameObject.BETWEEN_HANDS); _trickCardGame.setTrickState(TrickCardGameObject.BETWEEN_HANDS);
handDidEnd(); handDidEnd();
} }
/** /**
* Starts a trick. Calls {@link #trickWillStart}, sets the trick * Starts a trick. Calls {@link #trickWillStart}, sets the trick
* state to PLAYING_TRICK, and calls {@link #trickDidStart}. * state to PLAYING_TRICK, and calls {@link #trickDidStart}.
@@ -193,7 +198,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setTrickState(TrickCardGameObject.PLAYING_TRICK); _trickCardGame.setTrickState(TrickCardGameObject.PLAYING_TRICK);
trickDidStart(); trickDidStart();
} }
/** /**
* Ends the trick. Calls {@link #trickWillEnd}, sets the trick * Ends the trick. Calls {@link #trickWillEnd}, sets the trick
* state to PLAYING_HAND, and calls {@link #trickDidEnd}. * state to PLAYING_HAND, and calls {@link #trickDidEnd}.
@@ -204,12 +209,8 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setTrickState(TrickCardGameObject.PLAYING_HAND); _trickCardGame.setTrickState(TrickCardGameObject.PLAYING_HAND);
trickDidEnd(); trickDidEnd();
} }
/** // from interface TrickCardGameProvider
* 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[])}.
*/
public void sendCardsToPlayer (ClientObject client, int toidx, Card[] cards) public void sendCardsToPlayer (ClientObject client, int toidx, Card[] cards)
{ {
// make sure they're actually a player // make sure they're actually a player
@@ -219,18 +220,91 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
((BodyObject)client).who() + ", cards=" + StringUtil.toString(cards) + "]."); ((BodyObject)client).who() + ", cards=" + StringUtil.toString(cards) + "].");
return; return;
} }
// make sure they have the cards // make sure they have the cards
if (!_hands[fromidx].containsAll(cards)) { if (!_hands[fromidx].containsAll(cards)) {
Log.warning("Tried to send cards not held [username=" + Log.warning("Tried to send cards not held [username=" +
((BodyObject)client).who() + ", cards=" + StringUtil.toString(cards) + "]."); ((BodyObject)client).who() + ", cards=" + StringUtil.toString(cards) + "].");
return; return;
} }
// send the cards // send the cards
sendCardsToPlayer(fromidx, toidx, cards); sendCardsToPlayer(fromidx, toidx, cards);
} }
// from interface TrickCardGameProvider
public void playCard (ClientObject client, Card card, int handSize)
{
// make sure we're playing a trick
if (_trickCardGame.getTrickState() != TrickCardGameObject.PLAYING_TRICK) {
return; // silently ignore play attempts after timeouts
}
// make sure it's their turn
Name username = ((BodyObject)client).getVisibleName();
if (!username.equals(_trickCardGame.getTurnHolder())) {
return;
}
// make sure they're on the right trick
int pidx = _cardGame.getPlayerIndex(username);
if (_hands[pidx].size() != handSize) {
return;
}
// make sure their hand contains the specified card
if (!_hands[pidx].contains(card)) {
Log.warning("Tried to play card not held [username=" + username +
", card=" + card + "].");
return;
}
// make sure the card is legal to play
if (!_trickCardGame.isCardPlayable(_hands[pidx], card)) {
Log.warning("Tried to play illegal card [username=" + username +
", card=" + card + "].");
return;
}
// play the card
playCard(pidx, card);
}
// from interface TrickCardGameProvider
public void requestRematch (ClientObject client)
{
// make sure the game is over
if (_cardGame.state != CardGameObject.GAME_OVER) {
Log.warning("Tried to request rematch when game wasn't over " +
"[username=" + ((BodyObject)client).who() + "].");
return;
}
// make sure the requester is one of the players
int pidx = _cgmgr.getPlayerIndex(client);
if (pidx == -1) {
Log.warning("Rematch request from non-player [username=" +
((BodyObject)client).who() + "].");
return;
}
// make sure the player hasn't already requested
if (_trickCardGame.getRematchRequests()[pidx] != TrickCardGameObject.NO_REQUEST) {
Log.warning("Repeated rematch request [username=" + ((BodyObject)client).who() + "].");
return;
}
// if player is first requesting, set to request; else set to accept
int req = (getRematchRequestCount() == 0 ?
TrickCardGameObject.REQUESTS_REMATCH :
TrickCardGameObject.ACCEPTS_REMATCH);
_trickCardGame.setRematchRequestsAt(req, pidx);
// if all players accept the rematch, restart the game
if (getRematchRequestCount() == _cardGame.getPlayerCount()) {
_cgmgr.rematchGame();
}
}
/** /**
* Sends cards between players without error checking. Default * Sends cards between players without error checking. Default
* implementation transfers the cards between hands and notifies * implementation transfers the cards between hands and notifies
@@ -241,52 +315,14 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
// remove from sending player's hand // remove from sending player's hand
_hands[fromidx].removeAll(cards); _hands[fromidx].removeAll(cards);
// add to receiving player's hand // add to receiving player's hand
_hands[toidx].addAll(cards); _hands[toidx].addAll(cards);
// notify everyone of the transfer // notify everyone of the transfer
_cgmgr.transferCardsBetweenPlayers(fromidx, toidx, cards); _cgmgr.transferCardsBetweenPlayers(fromidx, toidx, cards);
} }
// Documentation inherited.
public void playCard (ClientObject client, Card card, int handSize)
{
// make sure we're playing a trick
if (_trickCardGame.getTrickState() != TrickCardGameObject.PLAYING_TRICK) {
return; // silently ignore play attempts after timeouts
}
// make sure it's their turn
Name username = ((BodyObject)client).getVisibleName();
if (!username.equals(_trickCardGame.getTurnHolder())) {
return;
}
// make sure they're on the right trick
int pidx = _cardGame.getPlayerIndex(username);
if (_hands[pidx].size() != handSize) {
return;
}
// make sure their hand contains the specified card
if (!_hands[pidx].contains(card)) {
Log.warning("Tried to play card not held [username=" + username +
", card=" + card + "].");
return;
}
// make sure the card is legal to play
if (!_trickCardGame.isCardPlayable(_hands[pidx], card)) {
Log.warning("Tried to play illegal card [username=" + username +
", card=" + card + "].");
return;
}
// play the card
playCard(pidx, card);
}
/** /**
* Plays a card for a player without error checking. * Plays a card for a player without error checking.
*/ */
@@ -300,15 +336,15 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
PlayerCard[] cards = (PlayerCard[])ArrayUtil.append( PlayerCard[] cards = (PlayerCard[])ArrayUtil.append(
_trickCardGame.getCardsPlayed(), new PlayerCard(pidx, card)); _trickCardGame.getCardsPlayed(), new PlayerCard(pidx, card));
_trickCardGame.setCardsPlayed(cards); _trickCardGame.setCardsPlayed(cards);
// end the user's turn // end the user's turn
endTurn(); endTurn();
// end the trick if everyone has played a card // end the trick if everyone has played a card
if (_turnIdx == -1) { if (_turnIdx == -1) {
if (_endTrickDelay == 0) { if (_endTrickDelay == 0) {
endTrick(); endTrick();
} else { } else {
_endTrickInterval.schedule(_endTrickDelay); _endTrickInterval.schedule(_endTrickDelay);
} }
@@ -317,43 +353,8 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
((DObject) _trickCardGame).commitTransaction(); ((DObject) _trickCardGame).commitTransaction();
} }
} }
// Documentation inherited.
public void requestRematch (ClientObject client)
{
// make sure the game is over
if (_cardGame.state != CardGameObject.GAME_OVER) {
Log.warning("Tried to request rematch when game wasn't over " +
"[username=" + ((BodyObject)client).who() + "].");
return;
}
// make sure the requester is one of the players
int pidx = _cgmgr.getPlayerIndex(client);
if (pidx == -1) {
Log.warning("Rematch request from non-player [username=" +
((BodyObject)client).who() + "].");
return;
}
// make sure the player hasn't already requested
if (_trickCardGame.getRematchRequests()[pidx] != TrickCardGameObject.NO_REQUEST) {
Log.warning("Repeated rematch request [username=" + ((BodyObject)client).who() + "].");
return;
}
// if player is first requesting, set to request; else set to accept
int req = (getRematchRequestCount() == 0 ?
TrickCardGameObject.REQUESTS_REMATCH :
TrickCardGameObject.ACCEPTS_REMATCH);
_trickCardGame.setRematchRequestsAt(req, pidx);
// if all players accept the rematch, restart the game
if (getRematchRequestCount() == _cardGame.getPlayerCount()) {
_cgmgr.rematchGame();
}
}
/** /**
* Returns the number of players currently requesting or accepting a rematch. * Returns the number of players currently requesting or accepting a rematch.
*/ */
@@ -368,7 +369,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
} }
return count; return count;
} }
/** /**
* Checks whether the trick is complete--that is, whether each player has played a card. * Checks whether the trick is complete--that is, whether each player has played a card.
*/ */
@@ -376,30 +377,30 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
return _trickCardGame.getCardsPlayed().length == _cardGame.getPlayerCount(); return _trickCardGame.getCardsPlayed().length == _cardGame.getPlayerCount();
} }
// Documentation inherited. @Override // from TurnGameManagerDelegate
protected void setFirstTurnHolder () protected void setFirstTurnHolder ()
{ {
if (_trickCardGame.getTrickState() == TrickCardGameObject.PLAYING_TRICK) { if (_trickCardGame.getTrickState() == TrickCardGameObject.PLAYING_TRICK) {
super.setFirstTurnHolder(); super.setFirstTurnHolder();
} else { } else {
_turnIdx = -1; _turnIdx = -1;
} }
} }
// Documentation inherited. @Override // from TurnGameManagerDelegate
protected void setNextTurnHolder () protected void setNextTurnHolder ()
{ {
if (_trickCardGame.getTrickState() == TrickCardGameObject.PLAYING_TRICK && if (_trickCardGame.getTrickState() == TrickCardGameObject.PLAYING_TRICK &&
!isTrickComplete()) { !isTrickComplete()) {
super.setNextTurnHolder(); super.setNextTurnHolder();
} else { } else {
_turnIdx = -1; _turnIdx = -1;
} }
} }
/** /**
* Called when the current turn times out. Default implementation * Called when the current turn times out. Default implementation
* plays a random playable card if in the trick-playing state. * plays a random playable card if in the trick-playing state.
@@ -410,7 +411,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
playCard(_turnIdx, pickRandomPlayableCard(_hands[_turnIdx])); playCard(_turnIdx, pickRandomPlayableCard(_hands[_turnIdx]));
} }
} }
/** /**
* Reduces the specified player's turn duration due to a time-out. * Reduces the specified player's turn duration due to a time-out.
*/ */
@@ -423,7 +424,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setTurnDurationScalesAt(newScale, pidx); _trickCardGame.setTurnDurationScalesAt(newScale, pidx);
} }
} }
/** /**
* Increases the specified player's turn duration due to avoiding a time-out. * Increases the specified player's turn duration due to avoiding a time-out.
*/ */
@@ -435,7 +436,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_trickCardGame.setTurnDurationScalesAt(newScale, pidx); _trickCardGame.setTurnDurationScalesAt(newScale, pidx);
} }
} }
/** /**
* Returns a random playable card from the specified hand. * Returns a random playable card from the specified hand.
*/ */
@@ -450,13 +451,14 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
} }
return (Card)RandomUtil.pickRandom(playableCards); return (Card)RandomUtil.pickRandom(playableCards);
} }
/** /**
* Notifies the object that a new hand is about to start. * Notifies the object that a new hand is about to start.
*/ */
protected void handWillStart () protected void handWillStart ()
{} {
}
/** /**
* Notifies the object that a new hand has just started. Default * Notifies the object that a new hand has just started. Default
* implementation prepares the deck, deals the hands, and starts the first trick. * implementation prepares the deck, deals the hands, and starts the first trick.
@@ -465,14 +467,14 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
// prepare the deck // prepare the deck
prepareDeck(); prepareDeck();
// deal cards to players // deal cards to players
dealHands(); dealHands();
// start the first trick // start the first trick
startTrick(); startTrick();
} }
/** /**
* Prepares the deck for a new hand of cards. Default implementation * Prepares the deck for a new hand of cards. Default implementation
* resets to a full deck without jokers and shuffles. * resets to a full deck without jokers and shuffles.
@@ -482,7 +484,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
_deck.reset(false); _deck.reset(false);
_deck.shuffle(); _deck.shuffle();
} }
/** /**
* Deals hands to the players. Default implementation deals the entire * Deals hands to the players. Default implementation deals the entire
* deck to the players in equal-sized hands. * deck to the players in equal-sized hands.
@@ -491,13 +493,13 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
_hands = _cgmgr.dealHands(_deck, _deck.size() / _cardGame.getPlayerCount()); _hands = _cgmgr.dealHands(_deck, _deck.size() / _cardGame.getPlayerCount());
} }
/** /**
* Notifies the object that the hand is about to end. * Notifies the object that the hand is about to end.
*/ */
protected void handWillEnd () protected void handWillEnd ()
{} {}
/** /**
* Notifies the object that the hand has ended. Default implementation * Notifies the object that the hand has ended. Default implementation
* starts the next hand. * starts the next hand.
@@ -506,7 +508,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
startHand(); startHand();
} }
/** /**
* Notifies the object that a new trick is about to start. Default * Notifies the object that a new trick is about to start. Default
* implementation resets the array of cards played. * implementation resets the array of cards played.
@@ -515,7 +517,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
_trickCardGame.setCardsPlayed(new PlayerCard[0]); _trickCardGame.setCardsPlayed(new PlayerCard[0]);
} }
/** /**
* Notifies the object that a new trick has started. Default * Notifies the object that a new trick has started. Default
* implementation sets the first turn holder and starts the turn. * implementation sets the first turn holder and starts the turn.
@@ -525,13 +527,14 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
setFirstTurnHolder(); setFirstTurnHolder();
startTurn(); startTurn();
} }
/** /**
* Notifies the object that the trick is about to end. * Notifies the object that the trick is about to end.
*/ */
protected void trickWillEnd () protected void trickWillEnd ()
{} {
}
/** /**
* Notifies the object that the trick has ended. Default implementation * Notifies the object that the trick has ended. Default implementation
* records the last cards played and starts the next trick, unless a * records the last cards played and starts the next trick, unless a
@@ -541,20 +544,20 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
{ {
// store the trick results for late-joiners // store the trick results for late-joiners
_trickCardGame.setLastCardsPlayed(_trickCardGame.getCardsPlayed()); _trickCardGame.setLastCardsPlayed(_trickCardGame.getCardsPlayed());
// clear out the cards played in the trick // clear out the cards played in the trick
_trickCardGame.setCardsPlayed(null); _trickCardGame.setCardsPlayed(null);
// verify that each player has at least one card // verify that each player has at least one card
if (anyHandsEmpty()) { if (anyHandsEmpty()) {
endHand(); endHand();
return; return;
} }
// everyone has cards; let's play another trick // everyone has cards; let's play another trick
startTrick(); startTrick();
} }
/** /**
* Checks whether any hands are empty. * Checks whether any hands are empty.
*/ */
@@ -567,28 +570,7 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
} }
return false; return false;
} }
/** The card game manager. */
protected CardGameManager _cgmgr;
/** The game object as trick card game. */
protected TrickCardGameObject _trickCardGame;
/** The game object as card game. */
protected CardGameObject _cardGame;
/** The amount of time to wait before ending the trick. */
protected long _endTrickDelay;
/** The deck from which cards are dealt. */
protected Deck _deck;
/** The hands of each player. */
protected Hand[] _hands;
/** Whether or not the turn timed out. */
protected boolean _turnTimedOut;
/** The all-purpose turn timeout interval. */ /** The all-purpose turn timeout interval. */
protected Interval _turnTimeoutInterval = new Interval(PresentsServer.omgr) { protected Interval _turnTimeoutInterval = new Interval(PresentsServer.omgr) {
public void expired () { public void expired () {
@@ -596,22 +578,41 @@ public class TrickCardGameManagerDelegate extends TurnGameManagerDelegate
turnTimedOut(); turnTimedOut();
} }
}; };
/** Calls {@link #endTrick} upon expiration. */ /** Calls {@link #endTrick} upon expiration. */
protected Interval _endTrickInterval = new Interval(PresentsServer.omgr) { protected Interval _endTrickInterval = new Interval(PresentsServer.omgr) {
public void expired () { public void expired () {
endTrick(); endTrick();
} }
}; };
/** The card game manager. */
protected CardGameManager _cgmgr;
/** The game object as trick card game. */
protected TrickCardGameObject _trickCardGame;
/** The game object as card game. */
protected CardGameObject _cardGame;
/** The amount of time to wait before ending the trick. */
protected long _endTrickDelay;
/** The deck from which cards are dealt. */
protected Deck _deck;
/** The hands of each player. */
protected Hand[] _hands;
/** Whether or not the turn timed out. */
protected boolean _turnTimedOut;
/** Reduce turn duration scales by this amount each time the player times out. */ /** Reduce turn duration scales by this amount each time the player times out. */
protected static final float TURN_DURATION_SCALE_REDUCTION = 0.25f; protected static final float TURN_DURATION_SCALE_REDUCTION = 0.25f;
/** /** Turn duration scales increase by this amount each time the player doesn't time out. */
* Increase turn duration scales by this amount each time the player
* manages not to time out. */
protected static final float TURN_DURATION_SCALE_INCREASE = 0.5f; protected static final float TURN_DURATION_SCALE_INCREASE = 0.5f;
/** Don't let turn duration scales get below this level. */ /** Don't let turn duration scales get below this level. */
protected static final float MINIMUM_TURN_DURATION_SCALE = 0.1f; protected static final float MINIMUM_TURN_DURATION_SCALE = 0.1f;
} }
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; import com.threerings.parlor.game.data.GameAI;
/** /**
* Extends the {@link PlaceManagerDelegate} mechanism with game manager * Extends the {@link PlaceManagerDelegate} mechanism with game manager specific methods.
* specific methods.
*/ */
public class GameManagerDelegate extends PlaceManagerDelegate public class GameManagerDelegate extends PlaceManagerDelegate
{ {
/** public GameManagerDelegate ()
* Provides the delegate with a reference to the game manager for {
* which it is delegating. }
*/
public GameManagerDelegate (GameManager gmgr) /**
* @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 * Called when a player in the game has been replaced by a call to {@link
* {@link GameManager#replacePlayer}. * GameManager#replacePlayer}.
*/ */
public void playerWasReplaced (int pidx, Name oldPlayer, Name newPlayer) public void playerWasReplaced (int pidx, Name oldPlayer, Name newPlayer)
{ {
} }
/** /**
* Called by the manager when we should do some AI. Only called while * Called by the manager when we should do some AI. Only called while the game is IN_PLAY.
* the game is IN_PLAY.
* *
* @param pidx the player index to fake some gameplay for. * @param pidx the player index to fake some gameplay for.
* @param ai a record indicating the AI's configuration. * @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 * Called when the game is about to reset, but before any other clearing out of game data has
* clearing out of game data has taken place. Derived classes should * taken place. Derived classes should override this if they need to perform some pre-reset
* override this if they need to perform some pre-reset activities. * activities.
*/ */
public void gameWillReset () public void gameWillReset ()
{ {
} }
/** /**
* Called when the specified player has been set as an AI with the * Called when the specified player has been set as an AI with the supplied AI configuration.
* supplied AI configuration.
*/ */
public void setAI (int pidx, GameAI ai) 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.media.util.MathUtil;
import com.threerings.crowd.data.BodyObject; import com.threerings.crowd.data.BodyObject;
import com.threerings.crowd.data.PlaceConfig;
import com.threerings.crowd.data.PlaceObject; import com.threerings.crowd.data.PlaceObject;
import com.threerings.crowd.server.CrowdServer; 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.GameConfig;
import com.threerings.parlor.game.data.GameObject; 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 public abstract class RatingManagerDelegate extends GameManagerDelegate
implements RatingCodes implements RatingCodes
{ {
/** @Override // from PlaceManagerDelegate
* Constructs a rating manager delegate. public void setPlaceManager (PlaceManager plmgr)
*/
public RatingManagerDelegate (GameManager gmgr)
{ {
super(gmgr); super.setPlaceManager(plmgr);
_gmgr = gmgr; _gmgr = (GameManager)plmgr;
}
@Override // from PlaceManagerDelegate
public void didInit (PlaceConfig config)
{
super.didInit(config);
_repo = getRatingRepository(); _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.util.Name;
import com.threerings.crowd.data.PlaceObject; import com.threerings.crowd.data.PlaceObject;
import com.threerings.crowd.server.PlaceManager;
import com.threerings.parlor.Log; import com.threerings.parlor.Log;
import com.threerings.parlor.game.server.GameManager; 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; import com.threerings.parlor.turn.data.TurnGameObject;
/** /**
* Performs the server-side turn-based game processing for a turn based game. * Performs the server-side turn-based game processing for a turn based game. Game managers which
* Game managers which wish to make use of the turn services must implement * wish to make use of the turn services must implement {@link TurnGameManager} and either create
* {@link TurnGameManager} and either create an instance of this class, or an * an instance of this class, or an instance of a derivation which customizes the behavior, either
* instance of a derivation which customizes the behavior, either of which * of which would be passed to {@link GameManager#addDelegate} to be activated.
* would be passed to {@link GameManager#addDelegate} to be activated.
*/ */
public class TurnGameManagerDelegate extends GameManagerDelegate public class TurnGameManagerDelegate extends GameManagerDelegate
{ {
/** public TurnGameManagerDelegate ()
* 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 * @deprecated use the zero-argument constructor.
* object. */
@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 * @return the index into the players array of the current turn holder or <code>-1</code> if
* <code>-1</code> if there is no current turn holder. * there is no current turn holder.
*/ */
public int getTurnHolderIndex () public int getTurnHolderIndex ()
{ {
@@ -67,8 +73,7 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
/** Test if it's the inputted player's turn. */ /** Test if it's the inputted player's turn. */
public boolean isPlayersTurn (int playerIndex) public boolean isPlayersTurn (int playerIndex)
{ {
// Don't accidently match a visitor's id of -1 with the "no one's // Don't accidently match a visitor's id of -1 with the "no one's turn" state of turn -1.
// turn" state of turn -1.
int turnHolder = getTurnHolderIndex(); int turnHolder = getTurnHolderIndex();
if (turnHolder < 0) { if (turnHolder < 0) {
return false; return false;
@@ -79,22 +84,20 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
} }
/** /**
* Called to start the next turn. It calls {@link * Called to start the next turn. It calls {@link TurnGameManager#turnWillStart} to allow our
* TurnGameManager#turnWillStart} to allow our owning manager to perform * owning manager to perform any pre-start turn processing, sets the turn holder that was
* any pre-start turn processing, sets the turn holder that was configured * configured either when the game started or when finishing up the last turn, and then calls
* either when the game started or when finishing up the last turn, and * {@link TurnGameManager#turnDidStart} to allow the manager to perform any post-start turn
* then calls {@link TurnGameManager#turnDidStart} to allow the manager to * processing. This assumes that a valid turn holder has been assigned. If some pre-game
* perform any post-start turn processing. This assumes that a valid turn * preparation needs to take place in a non-turn-based manner, this function should not be
* holder has been assigned. If some pre-game preparation needs to take * called until it is time to start the first turn.
* 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 () public void startTurn ()
{ {
// sanity check // sanity check
if (_turnIdx < 0 || _turnIdx >= _turnGame.getPlayers().length) { if (_turnIdx < 0 || _turnIdx >= _turnGame.getPlayers().length) {
Log.warning("startTurn() called with invalid turn index " + Log.warning("startTurn() called with invalid turn index [game=" + where() +
"[game=" + where() + ", turnIdx=" + _turnIdx + "]."); ", turnIdx=" + _turnIdx + "].");
// abort, abort // abort, abort
return; return;
} }
@@ -102,8 +105,8 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
// get the player name and sanity-check again // get the player name and sanity-check again
Name name = _tgmgr.getPlayerName(_turnIdx); Name name = _tgmgr.getPlayerName(_turnIdx);
if (name == null) { if (name == null) {
Log.warning("startTurn() called with invalid player " + Log.warning("startTurn() called with invalid player [game=" + where() +
"[game=" + where() + ", turnIdx=" + _turnIdx + "]."); ", turnIdx=" + _turnIdx + "].");
return; return;
} }
@@ -118,21 +121,18 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
} }
/** /**
* Called to end the turn. Whatever indication a game manager has that the * Called to end the turn. Whatever indication a game manager has that the turn has ended
* turn has ended (probably the submission of a valid move of some sort by * (probably the submission of a valid move of some sort by the turn holding player), it should
* the turn holding player), it should call this function to cause this * call this function to cause this turn to end and the next to begin.
* turn to end and the next to begin.
* *
* <p> If the game is no longer in play (see {@link TurnGame#isInPlay}) * <p> If the game is no longer in play (see {@link TurnGame#isInPlay}) after having called
* after having called {@link TurnGameManager#turnDidEnd} and {@link * {@link TurnGameManager#turnDidEnd} and {@link #setNextTurnHolder}, then the next turn will
* #setNextTurnHolder}, then the next turn will not automatically be * not automatically be started.
* started.
* *
* <p> If the game is in play, but the next turn should not be started * <p> If the game is in play, but the next turn should not be started immediately, the game
* immediately, the game manager should have {@link #setNextTurnHolder} set * manager should have {@link #setNextTurnHolder} set the {@link #_turnIdx} field to
* the {@link #_turnIdx} field to <code>-1</code> which will cause us to * <code>-1</code> which will cause us to not start the next turn. To start things back up
* not start the next turn. To start things back up again it would set * again it would set {@link #_turnIdx} to the next turn holder and call {@link #startTurn}
* {@link #_turnIdx} to the next turn holder and call {@link #startTurn}
* itself. * itself.
*/ */
public void endTurn () public void endTurn ()
@@ -162,20 +162,20 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
// documentation inherited // documentation inherited
public void playerWasReplaced (int pidx, Name oplayer, Name nplayer) public void playerWasReplaced (int pidx, Name oplayer, Name nplayer)
{ {
// we need to update the turn holder if the current turn holder // we need to update the turn holder if the current turn holder was the player that was
// was the player that was replaced and we need to do so in a way // replaced and we need to do so in a way that doesn't make everyone think that the turn
// that doesn't make everyone think that the turn just changed // just changed
if (oplayer != null && oplayer.equals(_turnGame.getTurnHolder())) { if (oplayer != null && oplayer.equals(_turnGame.getTurnHolder())) {
// small hackery: this will indicate to the client that we are // small hackery: this will indicate to the client that we are replacing the turn
// replacing the turn holder rather than changing the turn // holder rather than changing the turn
_turnGame.setTurnHolder(TurnGameObject.TURN_HOLDER_REPLACED); _turnGame.setTurnHolder(TurnGameObject.TURN_HOLDER_REPLACED);
_turnGame.setTurnHolder(nplayer); _turnGame.setTurnHolder(nplayer);
} }
} }
/** /**
* This should be called from {@link GameManager#gameDidStart} to let * This should be called from {@link GameManager#gameDidStart} to let the turn delegate perform
* the turn delegate perform start of game processing. * start of game processing.
*/ */
public void gameDidStart () public void gameDidStart ()
{ {
@@ -189,8 +189,8 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
} }
/** /**
* This is called to determine which player will take the first * This is called to determine which player will take the first turn. The default
* turn. The default implementation chooses a player at random. * implementation chooses a player at random.
*/ */
protected void setFirstTurnHolder () protected void setFirstTurnHolder ()
{ {
@@ -198,10 +198,9 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
} }
/** /**
* This is called to determine which player will next hold the turn. * This is called to determine which player will next hold the turn. The default
* The default implementation simply rotates through the players in * implementation simply rotates through the players in order, but some games may need to mess
* order, but some games may need to mess with the turn from time to * with the turn from time to time. This should update the <code>_turnIdx</code> field, not set
* time. This should update the <code>_turnIdx</code> field, not set
* the turn holder field in the game object directly. * the turn holder field in the game object directly.
*/ */
protected void setNextTurnHolder () protected void setNextTurnHolder ()
@@ -217,10 +216,10 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
do { do {
_turnIdx = (_turnIdx + 1) % size; _turnIdx = (_turnIdx + 1) % size;
if (_turnIdx == oturnIdx) { if (_turnIdx == oturnIdx) {
// if we've wrapped all the way around, stop where we are // if we've wrapped all the way around, stop where we are even if the current
// even if the current player is not active. // player is not active.
Log.warning("1 or less active players. Unable to properly " + Log.warning("1 or less active players. Unable to properly change turn. " +
"change turn. [game=" + where() + "]."); "[game=" + where() + "].");
break; break;
} }
} while (!_tgmgr.isActivePlayer(_turnIdx)); } while (!_tgmgr.isActivePlayer(_turnIdx));
@@ -251,7 +250,6 @@ public class TurnGameManagerDelegate extends GameManagerDelegate
/** A reference to our game object. */ /** A reference to our game object. */
protected TurnGameObject _turnGame; protected TurnGameObject _turnGame;
/** The player index of the current turn holder or <code>-1</code> if /** The player index of the current turn holder or <code>-1</code> if it's no one's turn. */
* it's no one's turn. */
protected int _turnIdx = -1; 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 implements PuzzleCodes, DropCodes
{ {
/** /**
* Provides the delegate with a reference to the manager for which it * @deprecated use {@link #DropManagerDelegate(DropLogic)}.
* is delegating as well as the logic object that it uses to determine
* how to manage the drop puzzle.
*/ */
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 // configure the game-specific settings
_usedrop = logic.useBlockDropping(); _usedrop = logic.useBlockDropping();
_userise = logic.useBoardRising(); _userise = logic.useBoardRising();
src/java/com/threerings/puzzle/server/PuzzleManagerDelegate.java
+18 -8
View File
@@ -21,21 +21,31 @@
package com.threerings.puzzle.server; package com.threerings.puzzle.server;
import com.threerings.crowd.server.PlaceManager;
import com.threerings.parlor.game.server.GameManagerDelegate; import com.threerings.parlor.game.server.GameManagerDelegate;
/** /**
* Extends the {@link GameManagerDelegate} mechanism with puzzle manager * Extends the {@link GameManagerDelegate} mechanism with puzzle manager specific methods (of which
* specific methods (of which there are currently none). * there are currently none).
*/ */
public class PuzzleManagerDelegate extends GameManagerDelegate public class PuzzleManagerDelegate extends GameManagerDelegate
{ {
/** public PuzzleManagerDelegate ()
* Constructs a puzzle manager delegate.
*/
public PuzzleManagerDelegate (PuzzleManager puzmgr)
{ {
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; protected PuzzleManager _puzmgr;