public ActionResult CreateGame(CreateGame createGame)
{
var cmd = new CreateGameCommand(repo);
var result = cmd.Execute(createGame);
return(Json(result));
}
void FireCreateEvent(object sender, LessThanOk.UI.Events.ButtonEventArgs e)
{
if (CreateGame != null)
{
CreateGame.Invoke(this, EventArgs.Empty);
}
}
// Update is called once per frame
void Update()
{
runas = GameObject.Find("Main Camera").GetComponent <CreateGame> ();
fire = runas.fuego;
water = runas.agua;
air = runas.aire;
earth = runas.tierra;
if (fire == 3)
{
health.CurrentVal -= 10;
runas.fuego -= 3;
fire -= 3;
}
if (water == 3)
{
health.CurrentVal -= 10;
runas.agua -= 3;
water -= 3;
}
if (air == 3)
{
health.CurrentVal -= 10;
runas.aire -= 3;
air -= 3;
}
if (earth == 3)
{
health.CurrentVal -= 10;
runas.tierra -= 3;
earth -= 3;
}
}
private void HandleGameState(Line line)
{
if (line.Text.Contains("CREATE_GAME"))
{
CreateGame?.Invoke();
}
}
public GamePresenter(MainComponent mainComponent, CreateGame createGame, Guess guess, ScoreService scoreService)
{
this.mainComponent = mainComponent;
this.createGame = createGame;
this.guess = guess;
this.scoreService = scoreService;
}
private async void PlayButton_Click(object sender, RoutedEventArgs e)
{
var request = new CreateGame
{
Gamemode = new GamemodeDto
{
Width = (int)WidthSlider.Value,
Height = (int)HeightSlider.Value,
Bombs = (int)BombsSlider.Value,
Name = ((GamemodeDto)LevelsList.SelectedItem).Name
}
};
var response = await _communication.SendAndRecieveAsync <GameDto>(request);
if (response == null)
{
_provider.GetRequiredService <ServerSettings>().Show();
Close();
return;
}
using (var scope = _provider.CreateScope())
{
var gameScreen = new GameScreen(this, _communication, ((GamemodeDto)LevelsList.SelectedItem).Name, response, _provider.GetRequiredService <IAssets>());
gameScreen.ShowDialog();
if (gameScreen.ConnectionLost)
{
_provider.GetRequiredService <ServerSettings>().Show();
Close();
}
}
}
public void CreateGame(string name)
{
CreateGame outmsg = new CreateGame();
outmsg.Name = name;
this.sendNetPacket(MsgType.CreateGame, outmsg);
}
public ActionResult Edit(CreateGame game)
{
if (ModelState.IsValid)
{
byte[] fileData = null;
if (game.Image != null)
{
var img = game.Image;
using (var binaryReader = new BinaryReader(img.InputStream))
{
fileData = binaryReader.ReadBytes(img.ContentLength);
}
}
var result = new ApiClient().PostData <CreateGameDto>("api/game/Post/Update", new CreateGameDto()
{
ID = game.ID,
Name = game.Name,
ReleaseDate = game.ReleaseDate,
ProductionID = game.ProductionID,
GamePlatformID = game.GamePlatformID,
AgeRatingID = game.AgeRatingID,
Price = game.Price,
Description = game.Description,
GameGenres = game.GameGenres,
Image = fileData
});
return(RedirectToAction("Index"));
}
return(View(game));
}
private async void RestartButton_Click(object sender, RoutedEventArgs e)
{
var request = new CreateGame
{
Gamemode = new GamemodeDto
{
Width = Game.Board.Width,
Height = Game.Board.Height,
Bombs = Game.Board.Bombs,
Name = GamemodeName
}
};
_timer.Stop();
TimeTextBlock.Text = 0.ToString();
var response = await _communication.SendAndRecieveAsync <GameDto>(request);
if (response == null)
{
ConnectionLost = true;
Close();
return;
}
UpdateWindow(response);
UpdateFields(response.Board.Fields);
}
public HttpResult Post(CreateGame request)
{
var game = new Game().PopulateWith(request.SanitizeDtoHtml());
int newId;
using (IDbTransaction trans = Db.OpenTransaction())
{
newId = (int) Db.Insert(game, selectIdentity: true);
// This is throwing because it maybe called without the Request with bombs creating hateoas urls
//var participant = ResolveService<ParticipantService>().Get(new FetchParticipantStatus { CrawlerId = game.CrawlerId, SeasonId = game.SeasonId }).ParticipantStatus;
// TODO Update particpant counts extension method.
//Db.Update<Participant>(participant);
game.Id = newId;
Db.SaveAllReferences(game);
trans.Commit();
}
return new HttpResult(new GameResponse {Game = Get(new FetchGame {Id = newId}).Game})
{
StatusCode = HttpStatusCode.Created,
Headers =
{
{HttpHeaders.Location, new FetchGame {Id = newId}.ToGetUrl()}
}
};
}
public void Test_BlackMove()
{
var serverActorRef = ActorOfAsTestActorRef <GameServerActor>();
Assert.IsNotNull(serverActorRef);
var player = new HumanPlayer("black", PlayerColor.Black);
var createGame = new CreateGame()
{
Size = 19,
White = new ComputerPlayer("white", PlayerColor.White),
Black = player
};
serverActorRef.Tell(createGame, TestActor);
var answer = ExpectMsg <CreateGameResponse>();
Assert.IsNotNull(answer.Guid);
Assert.IsNotNull(answer.GameActorRef);
var gameActor = answer.GameActorRef;
answer.GameActorRef.Tell(new StartGame(answer.Guid));
ExpectMsg <GameStarted>();
// black's turn
gameActor.Tell(new MoveMade(answer.Guid, player, 9, 9));
var answer2 = ExpectMsg <MoveResponse>();
Assert.IsNotNull(answer2.Guid);
Assert.IsTrue(answer2.MoveStatus == MoveStatus.Accepted);
Assert.IsTrue(answer2.GameStatus == GameStatus.Continue);
Assert.IsTrue(answer2.NextPlayer.Color == PlayerColor.White);
}
public void Test_WhiteMove_Rejected()
{
var serverActorRef = ActorOfAsTestActorRef <GameServerActor>();
Assert.IsNotNull(serverActorRef);
var player = new HumanPlayer("white", PlayerColor.White);
var createGame = new CreateGame(size: 19,
white: player,
black: new ComputerPlayer("black", PlayerColor.Black));
serverActorRef.Tell(createGame, TestActor);
var answer = ExpectMsg <CreateGameResponse>();
Assert.IsNotNull(answer.Guid);
Assert.IsNotNull(answer.GameActorRef);
var gameActor = answer.GameActorRef;
answer.GameActorRef.Tell(new StartGame(answer.Guid));
ExpectMsg <GameStarted>();
var answer2 = ExpectMsg <MoveMade>();
Assert.IsNotNull(answer.Guid);
Assert.IsTrue((answer2.Row == 9) && (answer2.Column == 9));
gameActor.Tell(new MoveMade(answer2.Guid, player, 9, 9));
var answer3 = ExpectMsg <MoveResponse>();
Assert.IsNotNull(answer3.Guid);
Assert.IsTrue(answer3.MoveStatus == MoveStatus.Rejected);
}
public void TestCreateGameConv()
{
IPEndPoint ip = new IPEndPoint(IPAddress.Any, 0);
CreateGameConv conv =
ConversationFactory
.Instance.CreateFromConversationType <CreateGameConv>
(ip, null, null, null);
conv._MinPlayers = 5;
conv._MaxPlayers = 6;
CreateGame msg = (CreateGame)conv.CreateFirstMessage();
Assert.AreEqual(msg.MaxPlayers, 6);
Assert.AreEqual(msg.MinPlayers, 5);
CommSubSystem.ConversationQueue queue = conv.MyQueue;
queue.Enqueue(msg.Encode());
conv.Receive();
Assert.AreEqual(conv.Error, null);
Assert.AreEqual(conv.incomingMsg, msg.Encode());
Assert.AreEqual(true, conv.ValidateEnvelope(msg));
}
public async Task <IActionResult> CreateGame()
{
var gameId = Guid.NewGuid();
var cmd = new CreateGame(gameId, 10);
await _bus.Send(cmd);
return(new RedirectToActionResult("Get", "Games", new { gameId }));
}
public IActionResult CreateGame(CreateGame input)
{
_gameManager.CreateGameAndUser(input.PlayerName);
_databaseContext.SaveChanges();
var gameModel = _modelBuilder.ToDetailModel(_currentContext.Game);
return(Ok(gameModel));
}
public async Task <IActionResult> JsonCreateAsync([FromBody] CreateGame command)
{
var gameId = Guid.NewGuid();
command.GameId = gameId;
await module.DispatchAsync(command);
logger.LogInformation("Game Created - {gameId}", gameId);
return(Created($"/games/{gameId}", gameId));
}
public object GetResponse(Request request)
{
return(request switch
{
CreateGame createGame => CreateGame(createGame),
GetRanking getRanking => GetRanking(getRanking),
Handshake handshake => Handshake(handshake),
PlayGame playGame => PlayGame(playGame),
_ => throw new ArgumentException()
});
static void Main()
{
while (true)
{
var readLine = Console.ReadLine();
var input = readLine.Split();
try
{
var command = input[0];
switch (command)
{
case "register":
var email = input[1];
var password = input[2];
var confirmPassword = input[3];
Register.User(email, password, confirmPassword);
break;
case "login":
var username = input[1];
var loginPass = input[2];
Login.User(username, loginPass);
break;
case "create-game":
CreateGame.Create();
break;
case "join-game":
var gameId = input[1];
JoinGame.Join(gameId);
break;
case "play":
var id = input[1];
var x = input[2];
var y = input[3];
Play.Now(id, x, y);
break;
default:
Console.WriteLine("Enter a valid command.");
break;
}
}
catch (IndexOutOfRangeException)
{
Console.WriteLine("The parametars are invalide. Enter valid parametars:");
}
}
}
//Add Factory method (GetProps)
private bool Handle(CreateGame message)
{
var id = new GameId($"Game_{Guid.NewGuid().ToString()}");
//Retrieve child GameActor and check if it already exists.
//If GameActor already exists:
// - Respond with GameAlreadyExists message
//If GameActor does not exist:
// - Create new GameActor as a child
// - Respond with GameCreated message
return(true);
}
public async Task CreateGame(CreateGame game)
{
var successful = gameProvider.CreateGame(game.GameName, game.StartingMoney, game.BigBlind);
if (successful)
{
await SendGameCreated(Context.ConnectionId);
}
else
{
await SendGameAlreadyExists(Context.ConnectionId);
}
}
public ActionResult Create(CreateGame cg)
{
if (this.ModelState.IsValid)
{
GameController gc = new GameController();
gc.Post(cg);
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(cg));
}
}
private bool Handle(CreateGame message)
{
var id = new GameId($"Game_{Guid.NewGuid().ToString()}");
//Retrieve child GameActor using Context and check if it already exists comparing with ActorRefs.Nobody
//If GameActor already exists:
// - Respond with GameAlreadyExists message to Sender
//If GameActor does not exist:
// - Create new GameActor as a child
// - Respond with GameCreated message to Sender
return(true);
}
public ObjectResult CreateGame([FromBody] CreateGame data)
{
Spel spel = new Spel
{
PlayerToken1 = data.PlayerToken1,
Description = data.Description,
Token = Guid.NewGuid().ToString()
};
iRepository.AddSpel(spel);
return(StatusCode(201, spel.Token));
}
/// <summary>
/// Creates a Game with specific information.
/// </summary>
public IHttpActionResult Post(CreateGame game)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreateGameService();
if (!service.CreateGame(game))
{
return(InternalServerError());
}
return(Ok());
}
private void Awake()
{
Creator = GameObject.Find("Creator").GetComponent <CreateGame>();
CurrentSet = new Movement();
CurrentSet.MovementSpeed = 10;
CurrentSet.DashSpeed = 30;
CurrentSet.DashDruation = 0.5f;
CurrentSet.JumpForce = 15;
CurrentSet.SlowDown = 60;
CurrentSet.Acceleration = 60;
CurrentSet.GravityScale = 30;
CurrentSet.Mask = LayerMask.NameToLayer("Ground");
CurrentSet.CharacterMask = LayerMask.NameToLayer("Character");
}
public async void GameCommandHandlerHandlesCreateGameCommand()
{
// Arrange
var mockAggregateRepo = new Mock <IAggregateRepository>();
var newGameGuid = Guid.NewGuid();
var fakeCommand = new CreateGame(newGameGuid, 8);
var sut = new GameCommandHandler(mockAggregateRepo.Object);
// Act
await sut.Handle(fakeCommand);
//Assert
mockAggregateRepo.Verify(m => m.Save(It.IsAny <Game>(), -1), Times.Once);
}
private async Task <GameModel> CreateGame(CreateGame request, string gameCode)
{
var game = await gamesRepository.CreateGame(new CreateGameModel
{
Code = gameCode,
LanguageId = request.LanguageId,
Name = request.Name,
OwnerId = request.UserId,
ShowAdultContent = request.ShowAdultContent,
PointsLimit = request.PointsLimit > 0 ? request.PointsLimit : GameConstants.DefaultPointsLimit
});
return(game);
}
public void Test_BlackMove_Rejected()
{
var serverActorRef = ActorOfAsTestActorRef <GameServerActor>();
Assert.IsNotNull(serverActorRef);
var player = new HumanPlayer("black", PlayerColor.Black);
var createGame = new CreateGame(size: 19,
white: new ComputerPlayer("white", PlayerColor.White),
black: player);
serverActorRef.Tell(createGame, TestActor);
var answer = ExpectMsg <CreateGameResponse>();
Assert.IsNotNull(answer.Guid);
Assert.IsNotNull(answer.GameActorRef);
var gameActor = answer.GameActorRef;
answer.GameActorRef.Tell(new StartGame(answer.Guid));
ExpectMsg <GameStarted>();
// black's turn
gameActor.Tell(new MoveMade(answer.Guid, player, 0, 0));
var answer3 = ExpectMsg <MoveResponse>();
Assert.IsNotNull(answer3.Guid);
Assert.IsTrue(answer3.MoveStatus == MoveStatus.Accepted);
Assert.IsTrue(answer3.NextPlayer.Color == PlayerColor.White);
// white's response
var answer4 = ExpectMsg <MoveMade>();
Assert.IsNotNull(answer4.Guid);
var row = answer4.Row;
var column = answer4.Column;
// black's turn
gameActor.Tell(new MoveMade(answer4.Guid, player, row, column));
var answer5 = ExpectMsg <MoveResponse>();
Assert.IsNotNull(answer5.Guid);
Assert.IsTrue(answer5.MoveStatus == MoveStatus.Rejected);
Assert.IsTrue(answer5.NextPlayer.Color == PlayerColor.Black);
}
public override Message CreateFirstMessage()
{
CreateGame msg = new CreateGame()
{
GameName = _GameName,
PlayerId = _Player,
MinPlayers = _MinPlayers,
MaxPlayers = _MaxPlayers,
ConvId = ConvId,
MsgId = ConvId,
MessageType = TypeOfMessage.CreateGame
};
return(msg);
}
public void TestCreateGame_BlackIsHuman()
{
var serverActorRef = ActorOfAsTestActorRef <GameServerActor>();
Assert.IsNotNull(serverActorRef);
var createGame = new CreateGame(size: 15,
white: new ComputerPlayer("white", PlayerColor.White),
black: new HumanPlayer("black", PlayerColor.Black));
serverActorRef.Tell(createGame, TestActor);
var answer = ExpectMsg <CreateGameResponse>().Guid;
Assert.IsNotNull(answer);
}
public bool createGame(string word, List <string> clues, int level, int mode, int option)
{
CreateGame game = new CreateGame(word, this.Traits, clues, (Level)level, (Mode)mode, option);
Feedback feedback = JsonConvert.DeserializeObject <Feedback>(this._socketHandler.TestPOSTWebRequest(game, "/game/create").ToString());
if (feedback.status)
{
_events.PublishOnUIThread(new appSuccessEvent(feedback.log_message));
return(true);
}
else
{
_events.PublishOnUIThread(new appWarningEvent(feedback.log_message));
return(false);
}
}
private void Run()
{
if (_running)
return;
try
{
var response = _services.AdminSvc.Get(new FetchProcessRequest());
foreach (SeasonProcessRequest seasonRequest in response.ProcessRequest.SeasonProcessRequests)
{
foreach (var roundRequest in seasonRequest.RoundProcessRequests)
{
var morgues = _runner.GetValidMorgues(roundRequest, new StandardMorgueValidator(seasonRequest.CrawlVersion));
foreach (MorgueFile morgue in morgues)
{
var game = new CreateGame
{
SeasonId = seasonRequest.SeasonId,
CrawlerId = morgue.CrawlerId,
CompletedDate = morgue.LastModified,
Morgue = morgue.Contents
};
game.ParseMorgueForStats();
_services.GameSvc.Post(game);
}
}
var season = _services.SeasonSvc.Get(new FetchSeason { Id = seasonRequest.SeasonId }).Season;
season.LastProcessed = DateTime.UtcNow;
_services.SeasonSvc.Put(season.ToUpdateRequest());
}
}
// TODO: catch (Exception ex) { }
finally
{
_running = false;
}
}
void confirmClicked(object sender, EventArgs e)
{
try
{
var newGame = new CreateGame { RoundId = Round.Id, MachineNumber = GameNumber.Value, PlayerId = Player.Id, Score = ScoreValue.Value, IsBonusGame = false };
if(Round.UseEntries)
newGame.EntryNumber = EntryNumber;
var game = AppDelegate.Self.ApiClient.Post(newGame);
}
catch (WebServiceException ex)
{
AppDelegate.Self.ShowModalAlertViewAsync (string.Format("An error occured. Please try again.{0}Error code: {1} - {2}",
Environment.NewLine, ex.StatusCode, ex.ErrorMessage), "Error");
return;
}
catch (Exception ex)
{
AppDelegate.Self.ShowModalAlertViewAsync (string.Format("An error occured. Please try again.{0}{1}",
Environment.NewLine, ex.Message), "Error");
return;
}
EntryDone();
}
/// <summary>
/// Listener for clicks on the start a new game menu item.
/// Opens the CreateGame window to start a new game.
/// </summary>
/// <param name="sender">The sender of the notification.</param>
/// <param name="e">The event.</param>
private void OnClickStartNewGame(object sender, RoutedEventArgs e)
{
MessageBoxResult result = MessageBox.Show("Do you want to save the game before starting a new game?", "Open a new game", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if(result == MessageBoxResult.Yes) {
this.SaveGame();
}
CreateGame createWindow = new CreateGame();
createWindow.Show();
this.Close();
}
protected void ScoreConfirmed (object sender, EventArgs e)
{
try
{
uipocConfirm.Dismiss(true);
var model = pickMachine.Model as PickerMachineModel;
var newGame = new CreateGame { RoundId = Round.Id, MachineNumber = model.SelectedItem.MachineNumber, PlayerId = Player.Id, Score = ScoreValue, IsBonusGame = cbxBonus.On };
if(Round.UseEntries)
newGame.EntryNumber = PlayerNumberValue;
var game = AppDelegate.Self.ApiClient.Post(newGame);
ShowMessage("Score was submitted successfully.", Round.Name).ContinueWith((t) =>
{
PlayerNumberChanged (txtPlayer);
//HideMachine(true);
}, TaskScheduler.FromCurrentSynchronizationContext());
}
catch (WebServiceException ex)
{
ShowMessage(string.Format("There was a problem registering the score. Please try again.{0}{1} {2}",
Environment.NewLine, ex.StatusCode, ex.ErrorCode));
}
catch (Exception ex)
{
ShowMessage(string.Format("There was a problem registering the score. Please try again.{0}{1}",
Environment.NewLine, ex.Message));
}
}
