blob: 1324d430f7cef6fef2d788d70590d389cd02da82 [file] [log] [blame]
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
part of game_component;
class HeartsGameComponent extends GameComponent {
HeartsGameComponent(Croupier croupier, SoundAssets sounds, VoidCallback cb,
{Key key, double width, double height})
: super(croupier, sounds, cb, key: key, width: width, height: height);
HeartsGame get game => super.game;
HeartsGameComponentState createState() => new HeartsGameComponentState();
}
class HeartsGameComponentState extends GameComponentState<HeartsGameComponent> {
List<logic_card.Card> passingCards1 = new List<logic_card.Card>();
List<logic_card.Card> passingCards2 = new List<logic_card.Card>();
List<logic_card.Card> passingCards3 = new List<logic_card.Card>();
List<logic_card.Card> bufferedPlay = new List<logic_card.Card>();
bool bufferedPlaying = false;
HeartsType _lastViewType;
bool _showSplitView = false;
@override
void initState() {
super.initState();
// If someone sat at the table, they would have the value 4.
// If nobody sat at the table, then we should show the split view.
if (!_isBoardPresent) {
_showSplitView = true;
}
_reset();
}
bool get _isBoardPresent => config.croupier.players_found.values.contains(4);
@override
void _reset() {
super._reset();
_lastViewType = config.game.viewType;
}
bool get _canBuffer {
HeartsGame game = config.game;
List<logic_card.Card> playCards =
game.cardCollections[HeartsGame.offsetPlay + game.playerNumber];
return game.isPlayer && game.numPlayed >= 1 && playCards.length == 0;
}
bool get _shouldUnbuffer {
HeartsGame game = config.game;
bool hasPermission = true;
// TODO(alexfandrianto): https://github.com/vanadium/issues/issues/1098
// bool hasPermission = game.asking || !_isBoardPresent;
return game.whoseTurn == game.playerNumber &&
bufferedPlay.length > 0 &&
!bufferedPlaying &&
hasPermission;
}
@override
Widget build(BuildContext context) {
HeartsGame game = config.game;
// Reset the game's stored ZCards if the view type changes.
if (_lastViewType != game.viewType) {
_reset();
}
// If it's our turn and buffered play is not empty, let's play it!
// Set a flag to ensure that we only play it once.
if (_shouldUnbuffer) {
_makeGameMoveCallback(bufferedPlay[0],
game.cardCollections[HeartsGame.offsetPlay + game.playerNumber]);
bufferedPlaying = true;
}
// If all cards were played, we can safely clear bufferedPlay.
if (game.allPlayed) {
_clearBufferedPlay();
}
// Hearts Widget
Widget heartsWidget = new Container(
decoration: new BoxDecoration(backgroundColor: Colors.grey[300]),
child: buildHearts());
List<Widget> children = new List<Widget>();
children.add(new Container(
decoration: new BoxDecoration(backgroundColor: Colors.grey[300]),
width: config.width,
height: config.height,
child: heartsWidget));
List<int> visibleCardCollectionIndexes = new List<int>();
if (game.phase != HeartsPhase.deal && game.phase != HeartsPhase.score) {
int playerNum = game.playerNumber;
if (game.viewType == HeartsType.player) {
switch (game.phase) {
case HeartsPhase.pass:
visibleCardCollectionIndexes.add(HeartsGame.offsetPass + playerNum);
visibleCardCollectionIndexes.add(HeartsGame.offsetHand + playerNum);
break;
case HeartsPhase.take:
visibleCardCollectionIndexes
.add(HeartsGame.offsetPass + game.takeTarget);
visibleCardCollectionIndexes.add(HeartsGame.offsetHand + playerNum);
break;
case HeartsPhase.play:
if (_showSplitView) {
for (int i = 0; i < 4; i++) {
visibleCardCollectionIndexes.add(HeartsGame.offsetHand + i);
visibleCardCollectionIndexes.add(HeartsGame.offsetTrick + i);
visibleCardCollectionIndexes.add(HeartsGame.offsetPlay + i);
}
} else {
visibleCardCollectionIndexes
.add(HeartsGame.offsetPlay + playerNum);
visibleCardCollectionIndexes
.add(HeartsGame.offsetHand + playerNum);
}
break;
default:
break;
}
} else {
// A board will need to see these things.
for (int i = 0; i < 4; i++) {
visibleCardCollectionIndexes.add(HeartsGame.offsetPlay + i);
visibleCardCollectionIndexes.add(HeartsGame.offsetPass + i);
visibleCardCollectionIndexes.add(HeartsGame.offsetHand + i);
visibleCardCollectionIndexes.add(HeartsGame.offsetTrick + i);
}
}
}
children.add(this.buildCardAnimationLayer(visibleCardCollectionIndexes));
return new Container(
width: config.width,
height: config.height,
child: new Stack(children: children));
}
void _switchViewCallback() {
HeartsGame game = config.game;
setState(() {
if (game.viewType == HeartsType.player) {
game.viewType = HeartsType.board;
} else {
game.viewType = HeartsType.player;
if (!game.isPlayer) {
game.playerNumber = 0; // avoid accidental red screen
}
}
});
}
// Passing between the temporary pass list and the player's hand.
// Does not actually move anything in game logic terms.
void _uiPassCardCallback(logic_card.Card card, List<logic_card.Card> dest) {
setState(() {
if (passingCards1.contains(card)) {
passingCards1.remove(card);
}
if (passingCards2.contains(card)) {
passingCards2.remove(card);
}
if (passingCards3.contains(card)) {
passingCards3.remove(card);
}
if (dest == passingCards1) {
passingCards1.clear();
passingCards1.add(card);
} else if (dest == passingCards2) {
passingCards2.clear();
passingCards2.add(card);
} else if (dest == passingCards3) {
passingCards3.clear();
passingCards3.add(card);
}
});
}
int _compareCards(logic_card.Card a, logic_card.Card b) {
if (a == b) return 0;
assert(a.deck == "classic" && b.deck == "classic");
HeartsGame game = config.game;
int r = game.getCardSuit(a).compareTo(game.getCardSuit(b));
if (r != 0) return r;
return game.getCardValue(a) < game.getCardValue(b) ? -1 : 1;
}
void _clearPassing() {
passingCards1.clear();
passingCards2.clear();
passingCards3.clear();
}
List<logic_card.Card> _combinePassing() {
List<logic_card.Card> ls = new List<logic_card.Card>();
ls.addAll(passingCards1);
ls.addAll(passingCards2);
ls.addAll(passingCards3);
return ls;
}
void _clearBufferedPlay() {
bufferedPlay.clear();
bufferedPlaying = false;
}
// This shouldn't always be here, but for now, we have little choice.
void _switchPlayersCallback() {
setState(() {
config.game.playerNumber = (config.game.playerNumber + 1) % 4;
_clearPassing(); // Just for sanity.
_clearBufferedPlay();
});
}
void _makeGamePassCallback() {
setState(() {
try {
config.game.passCards(_combinePassing());
config.game.debugString = null;
config.sounds.play("whooshOut");
} catch (e) {
print("You can't do that! ${e.toString()}");
config.game.debugString = "You must pass 3 cards";
}
});
}
void _makeGameTakeCallback() {
setState(() {
try {
// TODO(alexfandrianto): Another way to clear these passing cards is to
// do so upon the transition from the pass phase to the take phase.
// However, since they are never seen outside of the Pass phase, it is
// also valid to clear them upon taking any cards.
_clearPassing();
config.game.takeCards();
config.game.debugString = null;
config.sounds.play("whooshIn");
} catch (e) {
print("You can't do that! ${e.toString()}");
config.game.debugString = e.toString();
}
});
}
void _makeGameMoveCallback(logic_card.Card card, List<logic_card.Card> dest) {
setState(() {
HeartsGame game = config.game;
bool isBufferAttempt = dest == bufferedPlay;
String reason =
game.canPlay(game.playerNumber, card, lenient: isBufferAttempt);
if (reason == null) {
if (isBufferAttempt) {
print("Buffering ${card}...");
_clearBufferedPlay();
bufferedPlay.add(card);
} else {
// TODO(alexfandrianto): Clean up soon.
// https://github.com/vanadium/issues/issues/1098
// Automatically ask (for when there is no board).
/*if (!game.asking && !_isBoardPresent) {
game.askUI();
}*/
game.askUI();
game.move(card, dest);
config.sounds.play("whooshOut");
}
game.debugString = null;
} else {
print("You can't do that! ${reason}");
game.debugString = reason;
}
});
}
void _makeTakeTrickCallback() {
HeartsGame game = config.game;
setState(() {
game.takeTrickUI();
game.debugString = null;
config.sounds.play("whooshIn");
});
}
void _endRoundDebugCallback() {
setState(() {
config.game.jumpToScorePhaseDebug();
config.game.debugString = null;
});
}
Widget _makeDebugButtons() {
if (config.game.debugMode == false) {
return new Row(children: [
new Flexible(flex: 4, child: _makeButton('Quit', _quitGameCallback))
]);
}
return new Row(children: [
new Flexible(flex: 1, child: new Text('P${config.game.playerNumber}')),
new Flexible(
flex: 5, child: _makeButton('Switch Player', _switchPlayersCallback)),
new Flexible(
flex: 5, child: _makeButton('Switch View', _switchViewCallback)),
new Flexible(
flex: 5, child: _makeButton('End Round', _endRoundDebugCallback)),
new Flexible(flex: 4, child: _makeButton('Quit', _quitGameCallback))
]);
}
@override
Widget _makeButton(String text, VoidCallback callback,
{bool inactive: false}) {
var borderColor = inactive ? Colors.grey[500] : Colors.white;
var backgroundColor = inactive ? Colors.grey[500] : null;
return new FlatButton(
child: new Container(
decoration: new BoxDecoration(
border: new Border.all(width: 1.0, color: borderColor),
backgroundColor: backgroundColor),
padding: new EdgeDims.all(10.0),
child: new Text(text)),
onPressed: inactive ? null : callback);
}
Widget buildHearts() {
if (config.game.viewType == HeartsType.board) {
return buildHeartsBoard();
}
switch (config.game.phase) {
case HeartsPhase.deal:
return showDeal();
case HeartsPhase.pass:
return showPass();
case HeartsPhase.take:
return showTake();
case HeartsPhase.play:
return showPlay();
case HeartsPhase.score:
return showScore();
default:
assert(false);
return null;
}
}
Widget buildHeartsBoard() {
List<Widget> kids = new List<Widget>();
switch (config.game.phase) {
case HeartsPhase.deal:
case HeartsPhase.pass:
case HeartsPhase.take:
case HeartsPhase.play:
kids.add(showBoard());
break;
case HeartsPhase.score:
return showScore();
default:
assert(false);
return null;
}
kids.add(_makeDebugButtons());
return new Column(
children: kids, justifyContent: FlexJustifyContent.spaceBetween);
}
Widget showBoard() {
return new HeartsBoard(config.croupier, config.sounds,
width: config.width,
height: 0.825 * config.height, setGameStateCallback: () {
setState(() {});
});
}
String _getName(int playerNumber) {
return config.croupier.settingsFromPlayerNumber(playerNumber)?.name;
}
HeartsStatus _getStatus() {
HeartsGame game = config.game;
String status;
bool isPlayer = false;
bool isError = false;
switch (game.phase) {
case HeartsPhase.play:
// Who's turn is it?
String name = _getName(game.whoseTurn) ?? "Player ${game.whoseTurn}";
isPlayer = game.whoseTurn == game.playerNumber;
status = isPlayer ? "Your turn" : "${name}'s turn";
// Override if someone is taking a trick.
if (game.allPlayed) {
int winner = game.determineTrickWinner();
String trickTaker = _getName(winner) ?? "Player ${winner}";
isPlayer = winner == game.playerNumber;
status = isPlayer ? "Your trick" : "${trickTaker}'s trick";
}
break;
case HeartsPhase.pass:
if (game.hasPassed(game.playerNumber)) {
status = "Waiting for cards...";
} else {
String name =
_getName(game.passTarget) ?? "Player ${game.passTarget}";
status = "Pass to ${name}";
isPlayer = true;
}
break;
case HeartsPhase.take:
if (game.hasTaken(game.playerNumber)) {
status = "Waiting for other players...";
} else {
String name =
_getName(game.takeTarget) ?? "Player ${game.takeTarget}";
status = "Take from ${name}";
isPlayer = true;
}
break;
default:
break;
}
// Override if there is a debug string.
if (game.debugString != null) {
status = game.debugString;
isError = true;
}
return new HeartsStatus(status, isPlayer, isError);
}
Widget _buildNumTrickIcon() {
HeartsGame game = config.game;
int numTrickCards =
game.cardCollections[HeartsGame.offsetTrick + game.playerNumber].length;
int numTricks = numTrickCards ~/ 4;
String iconName = "image/filter_9_plus";
if (numTricks == 0) {
iconName = "image/filter_none";
} else if (numTricks <= 9) {
iconName = "image/filter_${numTricks}";
}
return new Icon(icon: iconName);
}
Widget _buildStatusBar() {
HeartsGame game = config.game;
List<Widget> statusBarWidgets = new List<Widget>();
HeartsStatus status = _getStatus();
statusBarWidgets.add(new Flexible(
flex: 1, child: new Text(status.text, style: style.Text.largeStyle)));
switch (game.phase) {
case HeartsPhase.play:
if (game.allPlayed &&
game.determineTrickWinner() == game.playerNumber &&
_showSplitView) {
statusBarWidgets.add(new Flexible(
flex: 0,
child: new GestureDetector(
onTap: _makeTakeTrickCallback,
child: new Container(
decoration: style.Box.brightBackground,
margin: style.Spacing.smallPaddingSide,
padding: style.Spacing.smallPadding,
child: new Text("Take Cards",
style: style.Text.largeStyle)))));
}
statusBarWidgets.add(_buildNumTrickIcon());
statusBarWidgets
.add(new IconButton(icon: "action/swap_vert", onPressed: () {
setState(() {
_showSplitView = !_showSplitView;
});
}));
break;
case HeartsPhase.pass:
case HeartsPhase.take:
// TODO(alexfandrianto): Icons for arrow_upward and arrow_downward were
// just added to the material icon list. However, they are not available
// through Flutter yet.
double rotationAngle = 0.0; // right
switch (game.roundNumber % 4) {
case 1:
rotationAngle = math.PI; // left
break;
case 2:
rotationAngle = -math.PI / 2; // up
break;
}
if (game.phase == HeartsPhase.take) {
rotationAngle = rotationAngle + math.PI; // opposite
}
statusBarWidgets.add(new Transform(
transform:
new vector_math.Matrix4.identity().rotateZ(rotationAngle),
alignment: new FractionalOffset(0.5, 0.5),
child: new Icon(icon: "navigation/arrow_forward")));
break;
default:
break;
}
BoxDecoration decoration = style.Box.background;
if (status.isPlayer) {
decoration = style.Box.liveBackground;
}
if (status.isError) {
decoration = style.Box.errorBackground;
}
return new Container(
padding: new EdgeDims.all(10.0),
decoration: decoration,
child: new Row(
children: statusBarWidgets,
justifyContent: FlexJustifyContent.spaceBetween));
}
Widget _buildFullMiniBoard() {
return new Container(
width: config.width * 0.5,
height: config.height * 0.25,
child: new HeartsBoard(config.croupier, config.sounds,
width: config.width * 0.5,
height: config.height * 0.25,
cardWidth: config.height * 0.1,
cardHeight: config.height * 0.1,
isMini: true,
gameAcceptCallback: _makeGameMoveCallback,
bufferedPlay: _canBuffer ? bufferedPlay : null));
}
Widget showPlay() {
HeartsGame game = config.game;
int p = game.playerNumber;
List<Widget> cardCollections = new List<Widget>();
List<logic_card.Card> playOrBuffer =
game.cardCollections[p + HeartsGame.offsetPlay];
if (playOrBuffer.length == 0) {
playOrBuffer = bufferedPlay;
}
if (_showSplitView) {
cardCollections.add(new Container(
decoration: style.Box.background,
child: new Column(
children: [_buildFullMiniBoard(), _buildStatusBar()])));
} else {
Widget playArea = new Container(
decoration: new BoxDecoration(backgroundColor: Colors.teal[500]),
width: config.width,
child: new Center(
child: new CardCollectionComponent(
playOrBuffer, true, CardCollectionOrientation.show1,
useKeys: true,
acceptCallback: _makeGameMoveCallback,
acceptType: p == game.whoseTurn || this._canBuffer
? DropType.card
: DropType.none,
backgroundColor:
p == game.whoseTurn ? Colors.white : Colors.grey[500],
altColor: p == game.whoseTurn
? Colors.grey[200]
: Colors.grey[600])));
cardCollections.add(new Container(
decoration: style.Box.background,
child: new BlockBody(children: [_buildStatusBar(), playArea])));
}
List<logic_card.Card> cards = game.cardCollections[p];
// A buffered card won't show up in the normal hand area.
List<logic_card.Card> remainingCards = new List<logic_card.Card>();
cards.forEach((logic_card.Card c) {
if (!bufferedPlay.contains(c)) {
remainingCards.add(c);
}
});
// You can start playing/buffering if it's your turn or you can buffer.
bool canTap = game.whoseTurn == game.playerNumber || this._canBuffer;
CardCollectionComponent c = new CardCollectionComponent(
remainingCards, game.playerNumber == p, CardCollectionOrientation.suit,
dragChildren: true, // Can drag, but may not have anywhere to drop
cardTapCallback: canTap
? (logic_card.Card card) =>
(_makeGameMoveCallback(card, playOrBuffer))
: null,
comparator: _compareCards,
width: config.width,
useKeys: true);
cardCollections.add(new BlockBody(children: [c, _makeDebugButtons()]));
return new Column(
children: cardCollections,
justifyContent: FlexJustifyContent.spaceBetween);
}
Widget showScore() {
HeartsGame game = config.game;
Widget w;
if (game.hasGameEnded) {
w = new Text("Game Over!");
} else if (!game.isPlayer || game.ready[game.playerNumber]) {
w = new Text("Waiting for other players...");
} else {
w = _makeButton('New Round', game.setReadyUI);
}
bool isTall = MediaQuery.of(context).orientation == Orientation.portrait;
FlexDirection crossDirection =
isTall ? FlexDirection.horizontal : FlexDirection.vertical;
FlexDirection mainDirection =
isTall ? FlexDirection.vertical : FlexDirection.horizontal;
TextStyle bigStyle = isTall ? style.Text.hugeStyle : style.Text.largeStyle;
TextStyle bigRedStyle =
isTall ? style.Text.hugeRedStyle : style.Text.largeRedStyle;
List<Widget> scores = new List<Widget>();
scores.add(new Flexible(
child: new Flex(children: [
new Flexible(
child: new Center(child: new Text("Score:", style: bigStyle)),
flex: 1),
new Flexible(
child: new Center(child: new Text("Round", style: bigStyle)),
flex: 1),
new Flexible(
child: new Center(child: new Text("Total", style: bigStyle)),
flex: 1)
], direction: crossDirection),
flex: 1));
for (int i = 0; i < 4; i++) {
bool isMaxForRound =
game.deltaScores.reduce(math.max) == game.deltaScores[i];
bool isMaxOverall = game.scores.reduce(math.max) == game.scores[i];
TextStyle deltaStyle = isMaxForRound ? bigRedStyle : bigStyle;
TextStyle scoreStyle = isMaxOverall ? bigRedStyle : bigStyle;
scores.add(new Flexible(
child: new Flex(children: [
new Flexible(
child: new CroupierProfileComponent(
settings: config.croupier.settingsFromPlayerNumber(i)),
flex: 1),
new Flexible(
child: new Center(
child:
new Text("${game.deltaScores[i]}", style: deltaStyle)),
flex: 1),
new Flexible(
child: new Center(
child: new Text("${game.scores[i]}", style: scoreStyle)),
flex: 1)
], direction: crossDirection, alignItems: FlexAlignItems.stretch),
flex: 2));
}
return new Column(children: [
new Flexible(
child: new Flex(children: scores, direction: mainDirection), flex: 7),
new Flexible(child: w, flex: 1),
new Flexible(child: _makeDebugButtons(), flex: 1)
]);
}
Widget showDeal() {
return new Container(
decoration: new BoxDecoration(backgroundColor: Colors.pink[500]),
child: new Column(children: [
new Text('Player ${config.game.playerNumber}'),
new Text('Waiting for Deal...'),
_makeDebugButtons()
], justifyContent: FlexJustifyContent.spaceBetween));
}
Widget _helpPassTake(
String name,
List<logic_card.Card> c1,
List<logic_card.Card> c2,
List<logic_card.Card> c3,
List<logic_card.Card> hand,
AcceptCb cb,
VoidCallback buttoncb) {
bool completed = (buttoncb == null);
bool draggable = (cb != null) && !completed;
List<Widget> topCardWidgets = new List<Widget>();
AcceptCb topCb = completed ? null : cb;
topCardWidgets.add(_topCardWidget(c1, topCb));
topCardWidgets.add(_topCardWidget(c2, topCb));
topCardWidgets.add(_topCardWidget(c3, topCb));
topCardWidgets.add(_makeButton(name, buttoncb, inactive: completed));
Color bgColor = completed ? Colors.teal[600] : Colors.teal[500];
Widget statusBar = _buildStatusBar();
Widget topArea = new Container(
decoration: new BoxDecoration(backgroundColor: bgColor),
padding: new EdgeDims.all(10.0),
width: config.width,
child: new Row(
children: topCardWidgets,
justifyContent: FlexJustifyContent.spaceBetween));
Widget combinedTopArea = new BlockBody(children: [statusBar, topArea]);
List<logic_card.Card> emptyC;
if (c1.length == 0) {
emptyC = c1;
} else if (c2.length == 0) {
emptyC = c2;
} else {
emptyC = c3; // even if c3 is already filled, it will be replaced.
}
Widget handArea = new CardCollectionComponent(
hand, true, CardCollectionOrientation.suit,
dragChildren: draggable,
comparator: _compareCards,
width: config.width,
acceptCallback: cb,
acceptType: draggable ? DropType.card : null,
cardTapCallback:
draggable ? (logic_card.Card c) => cb(c, emptyC) : null,
backgroundColor: Colors.grey[500],
altColor: Colors.grey[700],
useKeys: true);
Widget combinedBottomArea =
new BlockBody(children: [handArea, _makeDebugButtons()]);
return new Column(
children: <Widget>[combinedTopArea, combinedBottomArea],
justifyContent: FlexJustifyContent.spaceBetween);
}
Widget _topCardWidget(List<logic_card.Card> cards, AcceptCb cb) {
HeartsGame game = config.game;
List<logic_card.Card> passCards =
game.cardCollections[game.playerNumber + HeartsGame.offsetPass];
Widget ccc = new CardCollectionComponent(
cards, true, CardCollectionOrientation.show1,
dragChildren: cb != null,
acceptCallback: cb,
acceptType: cb != null ? DropType.card : null,
cardTapCallback:
cb != null ? (logic_card.Card c) => cb(c, passCards) : null,
backgroundColor: Colors.white,
altColor: Colors.grey[200],
useKeys: true);
if (cb == null) {
ccc = new Container(child: ccc);
}
return ccc;
}
// Pass Phase Screen: Show the cards being passed and the player's remaining cards.
Widget showPass() {
HeartsGame game = config.game;
List<logic_card.Card> passCards =
game.cardCollections[game.playerNumber + HeartsGame.offsetPass];
List<logic_card.Card> playerCards = game.cardCollections[game.playerNumber];
List<logic_card.Card> remainingCards = new List<logic_card.Card>();
playerCards.forEach((logic_card.Card c) {
if (!passingCards1.contains(c) &&
!passingCards2.contains(c) &&
!passingCards3.contains(c)) {
remainingCards.add(c);
}
});
bool hasPassed = passCards.length != 0;
return _helpPassTake(
"Pass",
passingCards1,
passingCards2,
passingCards3,
remainingCards,
_uiPassCardCallback,
hasPassed ? null : _makeGamePassCallback);
}
// Take Phase Screen: Show the cards the player has received and the player's hand.
Widget showTake() {
HeartsGame game = config.game;
List<logic_card.Card> playerCards = game.cardCollections[game.playerNumber];
List<logic_card.Card> takeCards =
game.cardCollections[game.takeTarget + HeartsGame.offsetPass];
bool hasTaken = takeCards.length == 0;
List<logic_card.Card> take1 =
takeCards.length != 0 ? takeCards.sublist(0, 1) : [];
List<logic_card.Card> take2 =
takeCards.length != 0 ? takeCards.sublist(1, 2) : [];
List<logic_card.Card> take3 =
takeCards.length != 0 ? takeCards.sublist(2, 3) : [];
return _helpPassTake("Take", take1, take2, take3, playerCards, null,
hasTaken ? null : _makeGameTakeCallback);
}
}
class HeartsArrangeComponent extends GameArrangeComponent {
HeartsArrangeComponent(Croupier croupier,
{double width, double height, Key key})
: super(croupier, width: width, height: height, key: key);
HeartsArrangeComponentState createState() =>
new HeartsArrangeComponentState();
}
class HeartsArrangeComponentState extends State<HeartsArrangeComponent> {
bool isTable = null; // Must first ask what kind of device this is.
bool fallback = false; // Set to true to switch to the old arrange players.
static final String personIcon = "social/person_outline";
static final String tableIcon = "hardware/tablet";
Widget build(BuildContext context) {
if (isTable == null) {
return _buildAskDeviceType();
}
if (isTable) {
return _buildTableArrangePlayers();
}
if (fallback) {
return _buildFallbackArrangePlayers();
}
return _buildPlayerArrangePlayers();
}
Widget _buildAskDeviceType() {
return new Container(
decoration: style.Box.liveNow,
height: config.height,
width: config.width,
child: new Column(children: [
new Text("Play Hearts as a...", style: style.Text.hugeStyle),
new FlatButton(
child: new Row(children: [
new Icon(size: IconSize.s48, icon: personIcon),
new Text("Player", style: style.Text.largeStyle)
], justifyContent: FlexJustifyContent.collapse),
color: style.secondaryTextColor, onPressed: () {
setState(() {
isTable = false;
});
}),
new FlatButton(
child: new Row(children: [
new Icon(size: IconSize.s48, icon: tableIcon),
new Text("Table", style: style.Text.largeStyle)
], justifyContent: FlexJustifyContent.collapse),
color: style.secondaryTextColor, onPressed: () {
setState(() {
isTable = true;
});
// Also sit at the table.
config.croupier.settings_manager.setPlayerNumber(
config.croupier.game.gameID,
config.croupier.settings.userID,
4);
})
], alignItems: FlexAlignItems.center));
}
int get numSitting => config.croupier.players_found.values.where((int index) {
return index != null && index >= 0 && index < 4;
}).length;
Widget _buildTableArrangePlayers() {
int arrangeID = null;
String status = "";
bool canStart = false;
if (numSitting < 4) {
// We still need people to sit.
// Only include non-table and non-sitting devices in this search.
// Note that this means it's possible arrangeID is null.
arrangeID = config.croupier.players_found.keys.firstWhere((int playerID) {
int index = config.croupier.players_found[playerID];
return index == null || index < 0;
}, orElse: () => null);
status = arrangeID != null ? "Tap to place" : "Waiting for players...";
} else {
status = "Play Hearts!";
canStart = true;
}
List<Widget> children = [new Text(status, style: style.Text.hugeStyle)];
// Also add the player's name (using a placeholder if that's not possible).
if (arrangeID != null) {
children.add(new CroupierProfileComponent.textOnly(
settings: config.croupier.settings_everyone[arrangeID]));
}
// You will need to show a Start Game button if the table isn't the creator.
// Replace the status text with a status button instead.
if (canStart && !config.croupier.game.isCreator) {
children = [
new FlatButton(
child: new Text(status, style: style.Text.hugeStyle),
color: style.theme.accentColor, onPressed: () {
config.croupier.settings_manager
.setGameStatus(config.croupier.game.gameID, "RUNNING");
})
];
}
Widget firstChild = new Row(
children: children, justifyContent: FlexJustifyContent.collapse);
return new Container(
decoration: style.Box.liveNow,
height: config.height,
width: config.width,
child: new Column(children: [
firstChild,
new Flexible(child: _buildArrangeTable(activeID: arrangeID))
], alignItems: FlexAlignItems.center));
}
Widget _buildPlayerArrangePlayers() {
List<Widget> children = <Widget>[
new Text("Waiting for game setup...", style: style.Text.hugeStyle)
];
if (config.croupier.game.isCreator) {
children.add(new FlatButton(
child: new Text("Manual Setup", style: style.Text.largeStyle),
color: style.theme.accentColor, onPressed: () {
setState(() {
fallback = true;
});
}));
}
return new Container(
decoration: style.Box.liveNow,
height: config.height,
width: config.width,
child:
new Column(children: children, alignItems: FlexAlignItems.center));
}
Widget _buildFallbackArrangePlayers() {
return new Container(
decoration: style.Box.liveNow,
height: config.height,
width: config.width,
child: _buildArrangeTable(canDragTo: true));
}
Widget _buildArrangeTable({int activeID: null, bool canDragTo: false}) {
int numAtTable = config.croupier.players_found.values
.where((int playerNumber) => playerNumber == 4)
.length;
return new Column(
children: [
new Flexible(
flex: 1,
child: new Row(
children: [
_buildEmptySlot(),
_buildSlot(personIcon, 2, activeID, canDragTo),
_buildEmptySlot()
],
justifyContent: FlexJustifyContent.spaceAround,
alignItems: FlexAlignItems.stretch)),
new Flexible(
flex: 1,
child: new Row(
children: [
_buildSlot(personIcon, 1, activeID, canDragTo),
_buildSlot(tableIcon, 4, activeID, canDragTo,
extra: "x${numAtTable}"),
_buildSlot(personIcon, 3, activeID, canDragTo)
],
justifyContent: FlexJustifyContent.spaceAround,
alignItems: FlexAlignItems.stretch)),
new Flexible(
flex: 1,
child: new Row(
children: [
_buildEmptySlot(),
_buildSlot(personIcon, 0, activeID, canDragTo),
_buildEmptySlot()
],
justifyContent: FlexJustifyContent.spaceAround,
alignItems: FlexAlignItems.stretch))
],
justifyContent: FlexJustifyContent.spaceAround,
alignItems: FlexAlignItems.stretch);
}
Widget _buildEmptySlot() {
return new Flexible(flex: 1, child: new Text(""));
}
Widget _buildSlot(String name, int index, int activeID, bool canDragTo,
{String extra: ""}) {
Widget slotWidget = new Row(
children: [
new Icon(size: IconSize.s48, icon: name),
new Text(extra, style: style.Text.largeStyle)
],
alignItems: FlexAlignItems.center,
justifyContent: FlexJustifyContent.center);
bool isMe = config.croupier.game.playerNumber == index;
bool isPlayerIndex = index >= 0 && index < 4;
bool isTableIndex = index == 4;
bool seatTaken = (isPlayerIndex || (isTableIndex && isMe)) &&
config.croupier.players_found.containsValue(index);
if (seatTaken) {
// Note: If more than 1 person is in the seat, it may no longer show you.
CroupierSettings cs = config.croupier.settingsFromPlayerNumber(index);
CroupierProfileComponent cpc =
new CroupierProfileComponent.horizontal(settings: cs);
slotWidget =
new Draggable<CroupierSettings>(child: cpc, feedback: cpc, data: cs);
}
Widget dragTarget = new DragTarget<CroupierSettings>(
builder: (BuildContext context, List<CroupierSettings> data, _) {
return new GestureDetector(onTap: () {
if (activeID != null) {
config.croupier.settings_manager
.setPlayerNumber(config.croupier.game.gameID, activeID, index);
}
},
child: new Container(
constraints: const BoxConstraints.expand(),
decoration: isMe ? style.Box.liveBackground : style.Box.border,
child: new Center(child: slotWidget)));
}, onAccept: (CroupierSettings cs) {
config.croupier.settings_manager
.setPlayerNumber(config.croupier.game.gameID, cs.userID, index);
}, onWillAccept: (_) => canDragTo);
return new Flexible(flex: 1, child: dragTarget);
}
}
class HeartsStatus {
final String text;
final bool isPlayer;
final bool isError;
const HeartsStatus(this.text, this.isPlayer, this.isError);
}