public UiMap(SinglePlayerGame game)
{
this.game = game;
var decisionProvider = game.UserPortal;
Prompt = decisionProvider.GetCurrent().Prompt;
var cachedOptions = decisionProvider.GetCurrent().Options; // cache in case calculated on the fly
int pad = 0;
foreach (var o in cachedOptions)
{
if (o is IActionFactory factory)
{
pad = Math.Max(pad, factory.Name.Length);
}
}
dict = new Dictionary <string, IOption>();
var tempList = new List <string[]>();
int labelIndex = 0;
foreach (var option in cachedOptions)
{
string key;
string description;
if (TextOption.Done.Matches(option))
{
key = option.Text[..1].ToLower();
public async Task PlaySimultaneousGamesCallbackCalled()
{
var board = new BoardContent(SquareContent.Water);
board["A1"] = board["C1"] = board["E1"] = SquareContent.Ship;
var shootingBoard = new BoardContent(SquareContent.Unknown);
var game = new SinglePlayerGame(Guid.Empty, 0, board, shootingBoard);
var games = new[] { game };
var playerClientMock = new Mock <IPlayerClient>();
playerClientMock.Setup(m => m.GetShots(It.IsAny <string>(),
It.IsAny <IEnumerable <ISinglePlayerGame> >(), It.IsAny <string?>()))
.ReturnsAsync(new[] { new BoardIndex() });
var callbackCalls = 0;
var client = new GameClient(playerClientMock.Object, Mock.Of <ISinglePlayerGameFactory>());
Task Callback()
{
callbackCalls++;
return(Task.CompletedTask);
}
await client.PlaySimultaneousGames("https://someserver.com/api/", games, 2, Callback, "key", new[] { 1, 1, 1 });
Assert.Equal(2, callbackCalls);
}
public IActionResult PlayPost(SinglePlayerGameFilledBlank obj)
{
if (ModelState.IsValid)
{
//Save Answer
_db.SinglePlayerGameFilledBlank.Update(obj);
_db.SaveChanges();
//Update Game
SinglePlayerGame game = _db.SinglePlayerGame.Where(g => g.Id == obj.SinglePlayerGameId).FirstOrDefault();
game.ActiveMadlibBlankIndex++;
//If it's the last one, show the results
if (game.ActiveMadlibBlankIndex > _db.MadlibBlank.Where(b => b.MadlibId == game.MadlibId).Select(b => b.Index).Max())
{
return(RedirectToAction("DisplayResults", game));
}
//Otherwise move to the next one
SinglePlayerGameFilledBlank nextBlank = AddNextBlankToAnswers(game);
_db.SinglePlayerGame.Update(obj.SinglePlayerGame);
_db.SaveChanges();
return(RedirectToAction("Play", nextBlank));
}
else
{
return(View(obj));
}
}
public GiftOfStrength_Tests()
{
spirit = new VitalStrength();
User = new VirtualEarthUser(spirit);
var gs = new GameState(spirit, Board.BuildBoardA());
game = new SinglePlayerGame(gs);
}
public SinglePlayerGameTests()
{
_mockCoordinates = Enumerable.Range(0, 5).Select(x => new Coordinate(0, x)).ToList();
_mockCoordinateGenerator = new Mock <ICoordinateGenerator>();
_mockCoordinateGenerator
.Setup(x => x.GenerateCoordinates(BOARD_SIZE, It.IsAny <int>(), It.IsAny <Orientation>()))
.Returns(_mockCoordinates);
_game = new SinglePlayerGame(_mockCoordinateGenerator.Object, new Mock <ILogger <Game> >().Object);
}
static void Main(string[] _)
{
var gs = new GameState(new RiverSurges())
{
Island = new Island(Board.BuildBoardA())
};
var game = new SinglePlayerGame(gs);
new CmdLinePlayer(game).Play();
}
//GET - DISPLAYRESULTS
public IActionResult DisplayResults(SinglePlayerGame game)
{
if (game == null)
{
return(NotFound());
}
Madlib.Models.Madlib madLib = _db.Madlib.Find(game.MadlibId);
string[] Answers = _db.SinglePlayerGameFilledBlank.Where(b => b.SinglePlayerGameId == game.Id).OrderBy(b => b.MadlibBlankIndex).Select(b => b.Answer).ToArray();
game.Madlib = madLib;
game.CompletedStory = string.Format(madLib.Text, Answers);
return(View(game));
}
public MassiveFlooding_Tests() : base()
{
// Given: River
spirit.UsePowerProgression();
gs = new GameState(spirit, Board.BuildBoardA())
{
InvaderDeck = InvaderDeck.Unshuffled(),
Phase = Phase.Slow
};
game = new SinglePlayerGame(gs);
}
public CmdLinePlayer(SinglePlayerGame game)
{
this.game = game;
// Init UI
commandMap = new Dictionary <string, Action> {
["spirit"] = ShowSpirit,
["island"] = ShowIsland,
["invaders"] = ShowInvaders,
["cards"] = ShowCards,
["?"] = ShowCommands,
["q"] = Quit,
};
}
private SinglePlayerGameFilledBlank AddNextBlankToAnswers(SinglePlayerGame game)
{
MadlibBlank currentBlank = _db.MadlibBlank.Where(b => b.MadlibId == game.MadlibId && b.Index == game.ActiveMadlibBlankIndex).FirstOrDefault();
SinglePlayerGameFilledBlank nextBlank = new SinglePlayerGameFilledBlank()
{
MadlibBlankIndex = currentBlank.Index,
CategoryId = currentBlank.CategoryId,
SinglePlayerGameId = game.Id
};
_db.SinglePlayerGameFilledBlank.Add(nextBlank);
_db.SaveChanges();
return(nextBlank);
}
private void StartGameButtonClick(object sender, RoutedEventArgs e)
{
Player player = new Player(this.PlayerName.Text);
if (this.PlayerName.Text == "")
{
MessageBox.Show("You must set your player name!", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
Category gameCategory = GetCategory();
Word gameWord = gameCategory.GetRandomWord();
WordChecker checker = new WordChecker(gameWord);
SinglePlayerGame game = new SinglePlayerGame(player, gameCategory, gameWord, checker);
SingleGameUI gameUI = new SingleGameUI(game);
this.NavigationService.Navigate(gameUI);
}
public async Task PlaySimultaneousGamesMaximumShots()
{
var board = new BoardContent(SquareContent.Water);
board["A1"] = board["C1"] = board["E1"] = SquareContent.Ship;
var shootingBoard = new BoardContent(SquareContent.Unknown);
var game = new SinglePlayerGame(Guid.Empty, 0, board, shootingBoard);
var games = new[] { game };
var playerClientMock = new Mock <IPlayerClient>();
playerClientMock.Setup(m => m.GetShots("https://someserver.com/api/",
It.Is <IEnumerable <ISinglePlayerGame> >(g => g.Count() == 1), "key"))
.ReturnsAsync(new[] { new BoardIndex() });
var client = new GameClient(playerClientMock.Object, Mock.Of <ISinglePlayerGameFactory>());
await client.PlaySimultaneousGames("https://someserver.com/api/", games, 2, null, "key", new[] { 1, 1, 1 });
playerClientMock.Verify(m => m.GetShots("https://someserver.com/api/",
It.Is <IEnumerable <ISinglePlayerGame> >(g => g.Count() == 1), "key"), Times.Exactly(2));
}
public SingleGameUI(SinglePlayerGame game)
{
InitializeComponent();
this.game = game;
this.PlayerName.Content = this.game.Player.PlayerName;
this.Category.Content = this.game.Category.CategoryName;
if (this.game.Word.GameWord.Contains(' '))
{
this.WordLength.Content = this.game.Word.GameWord.Length - 1;
}
else
{
this.WordLength.Content = this.game.Word.GameWord.Length;
}
this.wordBuilder = new WordBuilder(this.WordPanel, this.game.Word);
this.hangman = new Hangman(this.HangmanDrawing);
this.letterCount = 0;
wordBuilder.BuildWord(this.game.Word);
}
public IActionResult Start(Madlib.Models.Madlib obj)
{
if (obj == null)
{
return(NotFound());
}
SinglePlayerGame NewGame = new SinglePlayerGame()
{
MadlibId = obj.Id,
ActiveMadlibBlankIndex = 0
};
if (ModelState.IsValid)
{
_db.SinglePlayerGame.Add(NewGame);
_db.SaveChanges();
SinglePlayerGameFilledBlank nextBlank = AddNextBlankToAnswers(NewGame);
return(RedirectToAction("Play", nextBlank));
}
else
{
return(View(obj));
}
}
/// <summary>
/// Executes the command of Single Player games
/// </summary>
/// <param name="commandLine">The command line.</param>
/// <param name="client">The client.</param>
public void ExecuteCommand(string commandLine, TcpClient client)
{
var parser = new CommandParser(commandLine);
SinglePlayerGame sp;
if (!commands.ContainsKey(parser.CommandKey))
{
sp = new SinglePlayerGame(client, "The command " + parser.CommandKey + " isn't known");
sp.SendMassage();
}
else
{
var command = commands[parser.CommandKey];
var packet = command.Execute(parser.Args, client);
var result = packet.StringStream;
if (!packet.MultiPlayer)
{
//create new Single Player game to play with on client
sp = new SinglePlayerGame(client, result);
sp.SendMassage();
}
}
}
