/// <summary>
/// Constructor fills in the menu contents.
/// </summary>
public GameOverScreen( GameResult gameResult )
: base() {
this.gameResult = gameResult;
// start the title screen music
AudioManager.PlayMusic( "Music_Win" );
}
private void Game_ResultChanged(ChessGame game, GameResult result)
{
string s = String.Empty;
switch (result)
{
case GameResult.BlackCheckMate:
s = "Black check mate";
break;
case GameResult.WhiteCheckMate:
s = "White check mate";
break;
case GameResult.BlackKingTaken:
s = "Black lost";
break;
case GameResult.WhiteKingTaken:
s = "White lost";
break;
case GameResult.StaleMate:
s = "Stale mate";
break;
case GameResult.BlackResigned:
s = "Black resigned";
break;
case GameResult.WhiteResigned:
s = "White resigned";
break;
case GameResult.Draw:
s = "Draw";
break;
}
if (s != String.Empty)
{
this.BoardForm.ShowResult(s);
}
}
protected string GetKnockedOutPlayerString(GameResult gameResult)
{
if (gameResult.KnockedOutBy == null)
return string.Empty;
return string.Format("knocked out by {0}", gameResult.KnockedOutBy.NickName);
}
/// <summary>
/// Generic elo algorithm
/// </summary>
public static void UpdateScores(ref int user1Rating, ref int user2Rating, GameResult result, int diff = 400, int kFactor = 10)
{
double est1 = 1 / Convert.ToDouble(1 + 10 ^ (user2Rating - user1Rating) / diff);
double est2 = 1 / Convert.ToDouble(1 + 10 ^ (user1Rating - user2Rating) / diff);
float sc1 = 0;
float sc2 = 0;
if (result == GameResult.Tie)
{
sc1 = 0.5f;
sc2 = 0.5f;
}
else if (result == GameResult.WhiteWin)
{
sc1 = 1;
}
else if (result == GameResult.BlackWin)
{
sc2 = 1;
}
user1Rating = Convert.ToInt32(Math.Round(user1Rating + kFactor * (sc1 - est1)));
user2Rating = Convert.ToInt32(Math.Round(user2Rating + kFactor * (sc2 - est2)));
}
// Use this for initialization
void Start ()
{
// Create a game result to send to the service
GameResult result = new GameResult
{
GameId = GameClock.Instance.CurrentGameId,
UserId = UserManager.Instance.Id,
UserName = UserManager.Instance.Name,
Score = ScoreManager.Instance.Score
};
// Serialize the game result into JSON
string serializedResult = result.ToJson();
// Setup HTTP request headers
Dictionary<string, string> headers = new Dictionary<string, string>();
headers.Add("Content-Type", "application/json");
headers.Add("Content-Length", serializedResult.Length.ToString());
headers.Add("X-ZUMO-APPLICATION", "tEtsHvgLHoRZKUATnELAkzCLWXARVl99");
// Convert the serialized game result into a byte array
byte[] body = Encoding.UTF8.GetBytes(serializedResult);
WWW httpRequest = new WWW("http://blockparty.azure-mobile.net/tables/GameResult", body, headers);
//WWW httpRequest = new WWW("http://localhost:49753/tables/GameResult", body, headers);
StartCoroutine(OnHttpRequest(httpRequest));
}
public void ProcessRequest(HttpContext context) {
GameResult result = new GameResult();
string m = context.Request.QueryString["method"];
if (!string.IsNullOrEmpty(m)) {
switch (m.ToLower()) {
case "getranking"://获取排名
result = getRanking(context);
break;
case "setscore":
result = setScore(context);
break;
case "getscore":
result = getScore(context);
break;
default:
result.errorCode = -1;
result.result = "不支持的方法调用!";
break;
}
} else {
result.errorCode = -1;
result.result = "不支持的方法调用!";
}
context.Response.ContentType = "application/json;charset=utf-8";
context.Response.Write(jsonHelper.Serialize(result));
context.Response.End();
}
public async Task AddGame(GameResultModel gameModel)
{
using (var context = this.dbContext())
{
var game = new GameResult() { };
game.InjectFrom(gameModel);
if (gameModel.Hero != null)
{
game.Hero = context.Heroes.Find(gameModel.Hero.Id);
}
if (gameModel.OpponentHero != null)
{
game.OpponentHero = context.Heroes.Find(gameModel.OpponentHero.Id);
}
ArenaSessionModel arenaModel = null;
ArenaSession arena = null;
if (gameModel.ArenaSession != null)
{
gameModel.Deck = null;
game.DeckKey = null;
game.Deck = null;
arenaModel = gameModel.ArenaSession;
arena = context.ArenaSessions.Query().FirstOrDefault(x => x.Id == arenaModel.Id);
if (arena == null)
{
throw new InvalidOperationException("Add arena using gameManager first!");
}
// context.Entry(arena).CurrentValues.SetValues(arenaModel);
AddGameToArena(game, arena);
SetEndDateIfNeeded(arena);
arena.Modified = DateTime.Now;
}
if (gameModel.Deck != null)
{
game.Deck = context.Decks.Find(gameModel.Deck.Id);
}
context.Games.Add(game);
await context.SaveChangesAsync();
gameModel.InjectFrom(game);
this.events.PublishOnBackgroundThread(new GameResultAdded(this, gameModel));
if (arenaModel != null)
{
arenaModel.InjectFrom(arena);
gameModel.ArenaSession = arenaModel;
arenaModel.Games.Add(gameModel);
var latestId = context.ArenaSessions.OrderByDescending(x => x.StartDate).Select(x => x.Id).FirstOrDefault();
this.events.PublishOnBackgroundThread(new ArenaSessionUpdated(arenaModel.Id, latestId == arenaModel.Id));
}
}
}
/*
* This method is called at the end of the game.
*
* Parameters:
* result - an instance of the GameResult class, which contains two boolean properties, Won and Invalid.
* The Invalid property is true if you lost because you sent an invalid command.
*/
public void EndOfGame(GameResult result)
{
Console.WriteLine("End of game - " + (result.Won ? "Won!" : "Lost..."));
if (result.Invalid)
{
Console.WriteLine("[WARNING] Invalid command");
}
}
public GameStats(GameResult result, string opponentHero)
{
Coin = false;
Result = result;
GameMode = Game.GameMode.None;
OpponentHero = opponentHero;
StartTime = DateTime.Now;
Logger.WriteLine("Started new game", "Gamestats");
GameId = Guid.NewGuid();
}
public GameStats(GameResult result, string opponentHero, string playerHero)
{
Coin = false;
Result = result;
GameMode = GameMode.None;
OpponentHero = opponentHero;
PlayerHero = playerHero;
StartTime = DateTime.Now;
GameId = Guid.NewGuid();
}
public static double ToValue(GameResult result)
{
switch (result)
{
case GameResult.Loss: return 0;
case GameResult.Draw: return 0.5;
case GameResult.Win: return 1;
default: throw new Exception();
}
}
/// <summary>
/// Gets the game result representation and writes it using the writer.
/// </summary>
/// <param name="result">The result.</param>
/// <returns>The game result representation.</returns>
private string GetResultString(GameResult result)
{
switch (result)
{
case GameResult.White: return "1-0";
case GameResult.Black: return "0-1";
case GameResult.Draw: return "½-½";
}
return "*";
}
private GameResult setScore(HttpContext context) {
GameResult result = new GameResult();
string data = context.Request.Params["data"];
if (!string.IsNullOrEmpty(data)) {
GameScore gs = null;
try {
gs= Newtonsoft.Json.JsonConvert.DeserializeObject<GameScore>(data);
} catch {
}
if (gs != null && !string.IsNullOrEmpty(gs.username)) {
lock (lockObj) {
List<GameScore> scoreList = ScoreList;
bool isupdate = false;
for (int i = scoreList.Count-1; i>=0 ; i--) {
if (gs.username == scoreList[i].username ) {
if (gs.score > scoreList[i].score) {
scoreList.RemoveAt(i);
break;
} else {
return result;
}
}
}
for (int i = 0; i < scoreList.Count; i++) {
if (gs.score > scoreList[i].score) {
scoreList.Insert(i, gs);
dbGameHelper.Update(gs);
gs = null;
break;
}
}
if (gs != null) {
scoreList.Add(gs);
dbGameHelper.Update(gs);
}
}
} else {
result.errorCode = -3;
result.result = "成绩提交格式非法!";
}
} else {
result.errorCode = -3;
result.result = "成绩提交格式非法!";
}
return result;
}
public override GameResult GetResults()
{
GameResult r = new GameResult();
r.IsSingleplayer = true;
r.Time = time;
r.Player1Score = playerOneField.GetScore;
r.Difficulty = settings.Difficulty;
return r;
}
private void EndGame(GameResult finalResult)
{
this.gameTimer.Stop();
this.GameStatistics[Statistic.GameEndTime] = DateTime.Now;
this.GameStatistics[Statistic.GameState] = finalResult;
this.GameStatistics[Statistic.MinesRemaining] = this.Minesweeper.MinesRemaining;
this.GameStatistics[Statistic.TimeElapsed] = this.Minesweeper.TimeElapsed;
this.Settings.Statistics.Add(this.GameStatistics);
this.Settings.Save();
}
protected void CalculateScore(GameResult result)
{
switch (result)
{
case GameResult.Lose:
PlayerTwo.Score++;
break;
case GameResult.Win:
PlayerOne.Score++;
break;
}
}
private void addButton_Click(object sender, EventArgs e)
{
GameResult newResult = new GameResult()
{
Difficulty = GameManager.Difficulty,
Moves = GameManager.MovesCount,
Time = GameManager.GameDuration
};
DatabaseManager.addResult(newResult, nameTextBox.Text);
DialogResult = DialogResult.OK;
}
public EndGameWindow(GameResult gameStage)
{
InitializeComponent();
switch (gameStage)
{
case GameResult.Won:
this.Result.Text = " YOU WIN !!! \n WE ARE PROUD \n OF YOUR BEER BELLY!!! :)";
break;
case GameResult.Lost:
this.Result.Text = " YOU LOOSE :( \n Next time try harder...";
break;
}
}
public override GameResult GetResults()
{
GameResult r = new GameResult();
r.IsSingleplayer = false;
r.Player1Won = p1Won;
r.Time = timePlayed;
r.Player1Score = localPlayerField.GetScore;
r.Player2Score = remotePlayerField.GetScore;
r.Difficulty = settings.Difficulty;
return r;
}
public ResultsScreen(GameResult results, bool isNetwork)
{
this.results = results;
this.isNetwork = isNetwork;
backGroundImage = new Image();
gameoverText = new Text();
infoText = new Text();
results = new GameResult();
time = new Text();
p1Score = new Text();
p2Score = new Text();
cursor = new Cursor();
}
private void PrintResult(GameResult result)
{
switch(result)
{
case GameResult.Quit:
this.CellData.Print(8, 1, "You've ended the game!", Color.White);
break;
case GameResult.Failed:
this.CellData.Print(5, 1, "Your're have failed to Escape!", Color.White);
break;
case GameResult.Win:
this.CellData.Print(5, 1, "You've Escaped the Castle!", Color.White);
break;
}
}
public ActionResult CreatePrediction(int id, GameResult gameResult)
{
string currentUserName = User.Identity.Name;
ApplicationUser currentUser = db.Users.FirstOrDefault(x => x.UserName == currentUserName);
this.db.Predictions.Add(new Prediction
{
GameId = id,
PredictedResult = gameResult,
User = currentUser,
});
this.db.SaveChanges();
return Content(string.Format("<li>{0}: {1}</li>", currentUser.UserName, gameResult.ToPredictionString()));
}
private static void DisplayWinner(Weapon computerChoice, GameResult result)
{
Console.Write("I chose " + computerChoice.ToString() + ". ");
switch (result)
{
case (GameResult.ComputerWins):
Console.Write("I win!");
break;
case (GameResult.UserWins):
Console.Write("You win!");
break;
case (GameResult.Tie):
Console.Write("I guess we're both winners!");
break;
}
Console.WriteLine();
}
private GameResult getScore(HttpContext context) {
GameResult result = new GameResult();
string username = context.Request.Params["username"];
if (!string.IsNullOrEmpty(username)) {
GameScore gs = new GameScore() { username = username };
lock (lockObj) {
foreach (GameScore score in ScoreList) {
if (score.username == username) {
gs.score = score.score;
break;
}
}
}
result.data = jsonHelper.Serialize(gs);
}
return result;
}
public void ShowGameSatgeView(GameResult gameStage)
{
var endGameWindow = new EndGameWindow(gameStage)
{
Height = AppSettings.WindowHeight,
Width = AppSettings.WindowWidth,
ResizeMode = ResizeMode.NoResize,
WindowStartupLocation = WindowStartupLocation.CenterScreen,
Background = new ImageBrush(new BitmapImage(new Uri(AppSettings.WindowBackgraund))),
Icon = new BitmapImage(new Uri(AppSettings.WindowIcon))
};
endGameWindow.Show();
foreach (Window window in Application.Current.Windows.Cast<Window>().Where(window => window.Title == "The Beer Belly Game"))
{
window.Close();
}
}
public void ShowBalloon()
{
var gameResult = new GameResult
{
Hero = new Hero("mage")
{
Name = "Mage"
},
OpponentHero = new Hero("mage")
{
Name = "Mage"
}
};
gameResult.Victory = true;
var title = "New game tracked.";
var vm = IoC.Get<GameResultBalloonViewModel>();
vm.SetGameResult(gameResult.ToModel());
events.PublishOnBackgroundThread(new TrayNotification(title, vm, 10000));
throw new ArgumentNullException();
}
public GameFinishedEventArgs(IMinigame game, GameResult result)
{
Game = game;
Result = result;
}
public override void OnServerDisconnect(NetworkConnection conn)
{
if (conn.identity == null)
{
return;
}
var dcPlayer = conn.identity.GetComponent <PlayerNetworkControl>();
if (dcPlayer == null)
{
return;
}
Debug.Log("Player: " + dcPlayer.slot + " quit the game");
// remove player
usedSlot[dcPlayer.slot] = false;
players.Remove(dcPlayer.slot);
// check for game state
switch (state)
{
case GameState.PREPARE:
// if game is not started yet then we do not need to do anything
break;
case GameState.STARTING:
// if game is starting then mean there is already 2 players
// we need reset game state back to Prepare
CancelInvoke(nameof(OnUpdateCountDown));
state = GameState.PREPARE;
sharedData.state = state;
break;
case GameState.STARTED:
// if game is already started mean we need to cancel SpawnCandy and destroy all candy
CancelInvoke(nameof(SpawnCandy));
// destroy all canndies
foreach (GameObject go in candies.Values)
{
NetworkServer.Destroy(go);
}
candies.Clear();
// we show result screen with one winner and player quit reason
var result = new GameResult();
result.playerAPoint = dcPlayer.slot == "A" ? -1 : players["A"].points;
result.playerBPoint = dcPlayer.slot == "B" ? -1 : players["B"].points;
state = GameState.FINISHED;
sharedData.state = state;
sharedData.gameTime = 0;
sharedData.gameResult = result;
break;
case GameState.FINISHED:
// if game is finished mean all cancel callback and thing is done. we just need to check
// if number player is zero then game reset back to Prepare
if (numPlayers == 0)
{
state = GameState.PREPARE;
sharedData.state = state;
}
break;
}
base.OnServerDisconnect(conn);
}
// Run once only
// Run on 17/12/2018
/*public async Task AddDivisionsAsync()
* {
*
* var dataSources = new List<Division>()
* {
* new Division()
* {
*
* DivisionName = "NL First Division 18/19",
* DivisionCode = "DIV1",
* },
* new Division()
* {
* DivisionName = "NL Second Division 18/19",
* DivisionCode = "DIV2"
* },
* new Division()
* {
* DivisionName = "NL Third Division 18/19",
* DivisionCode = "DIV3",
* }
* };
*
* foreach (var item in dataSources)
* {
* await _wpbService.CreateDivisionAsync(item);
* }
* }
*
* /// <summary>
* /// Only need to run this function once
* /// RUN COMPLETE
* /// </summary>
* /// <returns></returns>
* public async Task GetFixturesDataAsync()
* {
* // Get all the fixtures dataSources
* var fixturesDataSource = await _wpbService.GetFixtureDataSources();
*
* foreach (var src in fixturesDataSource)
* {
* var fixturesResults =
* ParseDataSource.ParseFixturesDataSource(src, src.ClassNameNode);
*
* foreach (var ftr in fixturesResults)
* {
* try
* {
* // get Home team details
* var teamHome = await _wpbService.GetTeamByTeamName(ftr.FixtureHomeTeamName);
* var teamAway = await _wpbService.GetTeamByTeamName(ftr.FixtureAwayTeamName);
*
* if (teamHome != null && teamAway != null)
* {
* var newFixture = new Fixture()
* {
* FixtureDate = ftr.FixtureDate,
* HomeTeamId = teamHome.Id,
* HomeTeamName = teamHome.TeamName,
* HomeTeamCode = teamHome.TeamCode,
* AwayTeamId = teamAway.Id,
* AwayTeamName = teamAway.TeamName,
* AwayTeamCode = teamAway.TeamCode,
* // already have the subdivision in both Home or Away team
* SubDivisionId = teamHome.SubDivisionId
* };
*
* // Check for null values!!
* await _wpbService.CreateFixtureAsync(newFixture);
* }
* else
* {
* throw new System.ArgumentException(
* "Detected null values in either teamHome, teamAway or subDivision variable!");
* }
* }
* catch (Exception err)
* {
* var msg = err.ToString();
* }
* }
* }
*
* }
*/
public async Task GetMatchResultsAsync()
{
// Get all the data sources for results
var resultsDataSource = await _wpbService.GetAllResultDataSourceAsync();
foreach (var result in resultsDataSource)
{
var matchResults =
ParseDataSource.ParseResultDataSource(result, result.ClassNameNode);
foreach (var game in matchResults)
{
try
{
var teamHome = await _wpbService.GetTeamByTeamName(game.HomeTeamName);
var teamAway = await _wpbService.GetTeamByTeamName(game.AwayTeamName);
if (teamHome != null && teamAway != null)
{
var winningTeam = (game.WinningTeamName == teamHome.TeamName) ? teamHome : teamAway;
var encodedResult = EncodeGameResult(teamHome.TeamName, teamAway.TeamName, result.TimeStamp);
var newResult = new GameResult()
{
TimeStamp = game.TimeStamp,
HomeTeamId = teamHome.Id,
HomeTeamName = teamHome.TeamName,
HomeTeamCode = teamHome.TeamCode,
AwayTeamId = teamAway.Id,
AwayTeamName = teamAway.TeamName,
AwayTeamCode = teamAway.TeamCode,
Score = game.Score,
WinningTeamName = winningTeam.TeamName,
WinningTeamCode = winningTeam.TeamCode,
// already have the subdivision in both Home or Away team
SubDivisionId = teamHome.SubDivisionId,
EncodedResult = encodedResult
};
var resultExist = await _wpbService.GameResultExistAsync(newResult.EncodedResult);
// only add if not in db
if (resultExist == false)
{
await _wpbService.CreateGameResultAsync(newResult);
}
}
else
{
throw new System.ArgumentException(
"Detected null values in either teamHome, teamAway or subDivision variable!");
}
}
catch (Exception err)
{
var msg = err.ToString();
}
}
}
// add new report tracker object
var newReportRun = new ReportTracker()
{
ReportTypeCode = ModelHelpers.REPORT_RSLT
};
await _wpbService.CreateReportHistory(newReportRun);
}
static bool TestWon(GameResult result, bool testPlayingWhite)
{
return((testPlayingWhite && result == GameResult.WhiteWin) ||
(!testPlayingWhite && result == GameResult.BlackWin));
}
public override void ApplyEffect(GameResult gameResult, float dt)
{
}
public static int[] EncodeGameResultAsArray(GameResult en)
{
var vals = Utilities.GetValues <GameResult>().Cast <int>();
return(vals.Select(v => v == (int)en ? 1 : 0).ToArray());
}
public virtual void OnCollision(GameResult gameResult, IControlable collider)
{
weaponInfo.OnCollision(gameResult, collider);
}
private string GetReferenceToPlayer1(GameResult finalResultOfTheGame)
{
return((finalResultOfTheGame.Player1.PlayerType == GamePlayer.TypeOfPlayer.Human)
? "You "
: "The player 1 ");
}
public virtual void OnCreation(GameResult gameResult, IControlable host)
{
this.host = host;
this.lifeTime = new LifeSpan(host.LifeTime);
}
public void OnAction(GameResult gameResult, float dt)
{
ShipStateChange cost;
ActionResult actionResult = new ActionResult(gameResult);
if (activated && source.ShipState.MeetsCost(cost = (-costs.RunningCost * dt)) && AcquireTarget())
{
if (OnRunning(actionResult, dt))
{
if (actionResult.ApplyCosts)
{
source.ShipState.Change(cost);
}
if (actionResult.PlaySound)
{
actionSounds.Running.Play(dt);
}
}
else
{
activated = false;
}
return;
}
else if (Ready && source.ShipState.MeetsCost(cost = (-costs.ActivationCost)) && AcquireTarget())
{
if (OnActivated(actionResult, dt))
{
if (actionResult.ResetDelay)
{
delay.Empty();
}
if (actionResult.ApplyCosts)
{
source.ShipState.Change(cost);
}
if (actionResult.PlaySound)
{
actionSounds.Activated.Play();
}
if (costs.RunningCost != null)
{
activated = true;
}
}
return;
}
else if (activated && costs.DeActivationCost != null && source.ShipState.MeetsCost(cost = (-costs.DeActivationCost)) && AcquireTarget())
{
if (OnDeActivated(actionResult, dt))
{
if (actionResult.ApplyCosts)
{
actionSounds.DeActivated.Play();
}
if (actionResult.PlaySound)
{
source.ShipState.Change(cost);
}
}
activated = false;
return;
}
activated = false;
}
public static void MapFrom(this GameResultModel target, GameResult source)
{
target.InjectFrom(source);
target.ArenaSession = source.ArenaSession.ToModel();
}
public void SetSplitResult(int playerNumber, GameResult result)
{
_splitResults[playerNumber - 1] = result;
}
public DeclareGameResultAction(PlayerModel localPlayer, PlayerModel dealer, GameResult result)
{
LocalPlayer = localPlayer;
Dealer = dealer;
Result = result;
}
/// <summary>
/// Initializes a <see cref="GameEndEntry"/>.
/// </summary>
/// <param name="result">The result.</param>
public GameEndEntry(GameResult result)
: base(MoveTextEntryType.GameEnd)
{
Result = result;
}
/*
* This method is called at the end of the game.
*
* Parameters:
* result - an instance of the GameResult enum, which can be GameResult.WON, GameResult.TIED or GameResult.LOST.
*/
public void EndOfGame(GameResult result)
{
Console.WriteLine("End of game - " + result.ToString());
}
public void OnCreation(GameResult gameResult, IShip source, IAction actionSource)
{
this.weaponInfo.OnCreation(gameResult, this, source, actionSource);
}
private void ProceedRound(int column, int row)
{
try
{
string s;
/// Validation.
if (column < 0 || column > 2 || row < 0 || row > 2)
{
s = "Out of range. Please select again.";
MessageBox.Show(s, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
AppendLogToUI(s);
return;
}
int index = GetArrayIndexByPosition(column, row);
if (MarkList.Contains(index))
{
s = "This position is already filled. Please select the other.";
MessageBox.Show(s, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
/// Mark the position.
MarkList.Add(index);
MarkPosition(column, row);
//char targetChar;
//Color targetColor;
//if (CurrentPlayer == Player.Player1)
//{
// targetChar = Mark.Cross;
// targetColor = Color.Red;
//}
//else
//{
// targetChar = Mark.Nough;
// targetColor = Color.Blue;
//}
//TlpGrid.Controls.Remove(TlpGrid.GetControlFromPosition(column, row));
//TlpGrid.Controls.Add(new Label()
//{
// ForeColor = targetColor,
// Font = new Font("Arial", 60, FontStyle.Bold),
// Dock = DockStyle.None,
// Anchor = AnchorStyles.None,
// TextAlign = ContentAlignment.MiddleCenter,
// AutoSize = true,
// Text = targetChar.ToString()
//}, column, row);
/// Analyze.
GameResult gameResult = AnalyzeResult(MarkList);
if (gameResult != GameResult.GameContinue)
{
s = "";
switch (gameResult)
{
case GameResult.Player1Win:
s = "Player One Win !!!";
break;
case GameResult.Player2Win:
s = (GameMode)CbxMode.SelectedValue == GameMode.TwoPlayers ? "Player Two Win !!!" : "Computer Win !!!";
break;
case GameResult.Draw:
s = "Draw";
break;
}
AppendLogToUI(s);
MessageBox.Show(s, "Result", MessageBoxButtons.OK, MessageBoxIcon.Information);
InitializeGame();
return;
}
/// Round Result.
s = "";
if (CurrentPlayer == Player.Player1)
{
CurrentPlayer = Player.Player2;
s = (GameMode)CbxMode.SelectedValue == GameMode.TwoPlayers ? Helpers.EnumExtensionMethods.GetEnumDescription(CurrentPlayer) : "Computer turn.";
}
else
{
CurrentPlayer = Player.Player1;
s = Helpers.EnumExtensionMethods.GetEnumDescription(CurrentPlayer);
}
AppendLogToUI("{0} turn. Please mark a postion.", s);
/// Computer decision.
if (CurrentPlayer == Player.Player2 && (GameMode)CbxMode.SelectedValue == GameMode.VsComputer)
{
int nextIndex = DecideByComputer(MarkList);
if (nextIndex < 1 && nextIndex > 9)
{
AppendLogToUI("Computer cannot decide.");
return;
}
int nextIndexm1 = nextIndex - 1;
ProceedRound(nextIndexm1 % 3, nextIndexm1 / 3);
}
}
catch (Exception ex) { Logger?.Error(ex); }
}
protected void End(GameResult result)
{
var msg = result.IsWin ? $"Winner: '{result.Winner}'" : "Draw";
Console.WriteLine(msg);
}
/// <summary>
/// Called when a player wins a round. There can be more than one winner per round.
/// </summary>
/// <param name="player">The winning player</param>
/// <param name="result">The winning player hand</param>
protected override void OnDeclareWinner(Player player, GameResult result)
{
base.OnDeclareWinner(player, result);
helper.OnDeclareWinner(player, result);
}
private void ScoreKeeper_GameCompleted(string chapter, int level, int star, int score, GameResult result, bool dailyChallenge)
{
if (result == GameResult.ReachedTarget)
{
InvokeRepeating(nameof(ShootStar), 0f, GameSettings.StarShooterFreq);
}
}
public void OnCreation(GameResult gameResult, IWeaponsLogic weaponInfo)
{
this.weaponInfo.OnCreation(gameResult, this, weaponInfo);
}
public override void OnCreation(GameResult gameResult, IControlable host)
{
this.lifeTime = new LifeSpan();
this.host = host;
this.shipHost = host as IShip;
}
public UpdateGameResultCommand(string matchId, GameResult result)
{
MatchId = matchId;
Result = result;
}
public void LogNewRound(int roundNumber, Gesture?anotherPlayerChoise, Gesture?thisPlayerChoise, GameResult state)
{
var logInstance = Instantiate(roundIreItemViewPrefab).GetComponent <RoundItemView>();
logInstance.UpdateItem(roundNumber, anotherPlayerChoise, thisPlayerChoise, state);
logInstance.transform.SetParent(transform, false);
var thisPlayerStep = Instantiate(stepPrefab);
thisPlayerStep.SetStep(roundNumber, thisPlayerChoise);
thisPlayerStep.transform.SetParent(thisPlayerStepsContainer, false);
thisPlayerStep.transform.SetAsFirstSibling();
var anotherPlayerStep = Instantiate(opponentStepPrefab);
anotherPlayerStep.SetStep(roundNumber, anotherPlayerChoise);
anotherPlayerStep.transform.SetParent(anotherPlayerStepsContainer, false);
anotherPlayerStep.transform.SetAsFirstSibling();
steps.Add(thisPlayerStep);
steps.Add(anotherPlayerStep);
var height = 75f * steps.Count / 2 + 7f;
scrollContent.sizeDelta = new Vector2(scrollContent.sizeDelta.x, height);
roundItemViews.Add(logInstance);
}
public void AddGameResult(GameResult result, string opponentHero)
{
Games.Add(new GameStats(result, opponentHero));
}
//returns a list of userIds and the amount of points they received/lost for the win/loss, and if the user lost/gained a rank
//UserId, Points added/removed, rank before, rank modify state, rank after
/// <summary>
/// Retrieves and updates player scores/wins
/// </summary>
/// <returns>
/// A list containing a value tuple with the
/// Player object
/// Amount of points received/lost
/// The player's current rank
/// The player's rank change state (rank up, derank, none)
/// The players new rank (if changed)
/// </returns>
public List <(Player, int, Rank, RankChangeState, Rank)> UpdateTeamScoresAsync(Competition competition, Lobby lobby, GameResult game, Rank[] ranks, bool win, HashSet <ulong> userIds, Database db)
{
var updates = new List <(Player, int, Rank, RankChangeState, Rank)>();
foreach (var userId in userIds)
{
var player = db.Players.Find(competition.GuildId, userId);
if (player == null)
{
continue;
}
//This represents the current user's rank
var maxRank = ranks.Where(x => x.Points < player.Points).OrderByDescending(x => x.Points).FirstOrDefault();
int updateVal;
RankChangeState state = RankChangeState.None;
Rank newRank = null;
if (win)
{
updateVal = (int)((maxRank?.WinModifier ?? competition.DefaultWinModifier) * lobby.LobbyMultiplier);
if (lobby.HighLimit != null)
{
if (player.Points > lobby.HighLimit)
{
updateVal = (int)(updateVal * lobby.ReductionPercent);
}
}
player.Points += updateVal;
player.Wins++;
newRank = ranks.Where(x => x.Points <= player.Points).OrderByDescending(x => x.Points).FirstOrDefault();
if (newRank != null)
{
if (maxRank == null)
{
state = RankChangeState.RankUp;
}
else if (newRank.RoleId != maxRank.RoleId)
{
state = RankChangeState.RankUp;
}
}
}
else
{
//Loss modifiers are always positive values that are to be subtracted
updateVal = maxRank?.LossModifier ?? competition.DefaultLossModifier;
if (lobby.MultiplyLossValue)
{
updateVal = (int)(updateVal * lobby.LobbyMultiplier);
}
player.Points -= updateVal;
if (!competition.AllowNegativeScore && player.Points < 0)
{
player.Points = 0;
}
player.Losses++;
//Set the update value to a negative value for returning purposes.
updateVal = -Math.Abs(updateVal);
if (maxRank != null)
{
if (player.Points < maxRank.Points)
{
state = RankChangeState.DeRank;
newRank = ranks.Where(x => x.Points <= player.Points).OrderByDescending(x => x.Points).FirstOrDefault();
}
}
}
updates.Add((player, updateVal, maxRank, state, newRank));
var oldUpdate = db.ScoreUpdates.FirstOrDefault(x => x.ChannelId == lobby.ChannelId && x.GameNumber == game.GameId && x.UserId == userId);
if (oldUpdate == null)
{
var update = new ScoreUpdate
{
GuildId = competition.GuildId,
ChannelId = game.LobbyId,
UserId = userId,
GameNumber = game.GameId,
ModifyAmount = updateVal
};
db.ScoreUpdates.Add(update);
}
else
{
oldUpdate.ModifyAmount = updateVal;
db.ScoreUpdates.Update(oldUpdate);
}
db.Update(player);
}
db.SaveChanges();
return(updates);
}
protected void AddGameToArena(GameResult game, ArenaSession arena)
{
game.ArenaSessionId = arena.Id;
game.ArenaSession = arena;
arena.Games.Add(game);
if (game.Victory)
{
arena.Wins++;
}
else
{
arena.Losses++;
}
}
public ServiceResult <GameResult> PerformAction(int playerId)
{
//Check Cooldown
var player = _playerService.Get(playerId);
var elapsedSeconds = DateTime.UtcNow.Subtract(player.LastActionExecutedDateTime).TotalSeconds;
var cooldownSeconds = _appSettings.DefaultCooldown;
if (player.CurrentFuelPlayerItem != null)
{
cooldownSeconds = player.CurrentFuelPlayerItem.Item.ActionCooldownSeconds;
}
if (elapsedSeconds < cooldownSeconds)
{
var waitSeconds = Math.Ceiling(cooldownSeconds - elapsedSeconds);
var waitText = $"You are still a bit tired. You have to wait another {waitSeconds} seconds.";
return(new ServiceResult <GameResult>
{
Data = new GameResult {
Player = player
},
Messages = new List <ServiceMessage> {
new ServiceMessage {
Code = "Cooldown", Message = waitText
}
}
});
}
var hasAttackItem = player.CurrentAttackPlayerItem != null;
var positiveGameEvent = _positiveGameEventService.GetRandomPositiveGameEvent(hasAttackItem);
if (positiveGameEvent == null)
{
return(new ServiceResult <GameResult> {
Messages =
new List <ServiceMessage>
{
new ServiceMessage
{
Code = "Error",
Message = "Something went wrong getting the Positive Game Event.",
MessagePriority = MessagePriority.Error
}
}
});
}
var negativeGameEvent = _negativeGameEventService.GetRandomNegativeGameEvent();
var oldLevel = player.GetLevel();
player.Money += positiveGameEvent.Money;
player.Experience += positiveGameEvent.Experience;
var newLevel = player.GetLevel();
var levelMessages = new List <ServiceMessage>();
//Check if we leveled up
if (oldLevel < newLevel)
{
levelMessages = new List <ServiceMessage> {
new ServiceMessage {
Code = "LevelUp", Message = $"Congratulations, you arrived at level {newLevel}"
}
};
}
//Consume fuel
var fuelMessages = ConsumeFuel(player);
var attackMessages = new List <ServiceMessage>();
//Consume attack when we got some loot
if (positiveGameEvent.Money > 0)
{
attackMessages.AddRange(ConsumeAttack(player));
}
var defenseMessages = new List <ServiceMessage>();
var negativeGameEventMessages = new List <ServiceMessage>();
if (negativeGameEvent != null)
{
//Check defense consumption
if (player.CurrentDefensePlayerItem != null)
{
negativeGameEventMessages.Add(new ServiceMessage {
Code = "DefenseWithGear", Message = negativeGameEvent.DefenseWithGearDescription
});
defenseMessages.AddRange(ConsumeDefense(player, negativeGameEvent.DefenseLoss));
}
else
{
negativeGameEventMessages.Add(new ServiceMessage {
Code = "DefenseWithoutGear", Message = negativeGameEvent.DefenseWithoutGearDescription
});
//If we have no defense item, consume the defense loss from Fuel and Attack
defenseMessages.AddRange(ConsumeFuel(player, negativeGameEvent.DefenseLoss));
defenseMessages.AddRange(ConsumeAttack(player, negativeGameEvent.DefenseLoss));
}
}
var warningMessages = GetWarningMessages(player);
player.LastActionExecutedDateTime = DateTime.UtcNow;
//Save Player
_database.SaveChanges();
var gameResult = new GameResult
{
Player = player,
PositiveGameEvent = positiveGameEvent,
NegativeGameEvent = negativeGameEvent,
NegativeGameEventMessages = negativeGameEventMessages
};
var serviceResult = new ServiceResult <GameResult>
{
Data = gameResult
};
//Add all the messages to the player
serviceResult.WithMessages(levelMessages);
serviceResult.WithMessages(warningMessages);
serviceResult.WithMessages(fuelMessages);
serviceResult.WithMessages(attackMessages);
serviceResult.WithMessages(defenseMessages);
return(serviceResult);
}
public override void OnTargetDeath(GameResult gameResult)
{
}
public void SetPlayerResult(int playerNumber, GameResult result)
{
_playerResults[playerNumber - 1] = result;
}
public override void ShowGameOver(GameResult info)
{
throw new NotImplementedException( );
}
public void LoadExistingData()
{
Rounds.Clear();
PlayerPairings.Clear();
var files = _storage.GetHatRoundPaths();
foreach (var file in files)
{
try
{
var doc = new XmlDocument();
using (var stream = new FileStream(file, FileMode.Open))
{
doc.Load(stream);
}
var teams = doc.SelectNodes("/HatRound/Teams/Team");
// Basic validation
if (teams.Count == 0 || teams.Count % 2 != 0)
{
throw new Exception();
}
var teamList = new List <Team>();
var i = 1;
foreach (XmlNode team in teams)
{
//var teamName = team.SelectSingleNode("Name").InnerText;
Team t = new Team(i);
var players = team.SelectNodes("Players/Player");
// Basic validation
if (players.Count == 0)
{
throw new Exception();
}
foreach (XmlNode player in players)
{
var name = player.SelectSingleNode("Name").InnerText;
Player p = PlayerProvider.GetPlayer(name);
// Player list may have changed throughout the day, so accept this difference
if (p != null)
{
t.AddPlayer(p);
}
}
GameResult gameResult = (GameResult)Enum.Parse(typeof(GameResult), team.SelectSingleNode("GameResult").InnerText);
if (gameResult != GameResult.NoneYet)
{
t.GameDone(gameResult);
}
teamList.Add(t);
i++;
}
var round = new HatRound(teamList, file);
AddRound(round);
}
catch (Exception)
{
throw new InvalidRoundException(string.Format("Round file {0} is an invalid file", file));
}
}
}
public void OnGameEnd(GameResult result)
{
timer.TimerStop();
if (result == GameResult.won) AddToScore(Mathf.CeilToInt(timer.TimeLeft * 10), Vector3.zero, ScoreType.time, false);
AddToScore(Mathf.CeilToInt(-doubt * 5), Vector3.zero, ScoreType.doubt, false);
StartCoroutine(OnGameEndCoroutine());
}
public override void OnCreation(GameResult gameResult, IControlable host)
{
this.target = host.Target;
base.OnCreation(gameResult, host);
CheckTarget();
}
