// Use this for initialization
void Awake()
{
// ensure there is only one audio manager
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
return;
}
DontDestroyOnLoad(gameObject);
// load the saved browser data
GameDetailContainer.LoadedGameDetails = DataAccess.Load();
// if there is browser data, store it in gd
// otherwise, create new browser data and store it in gd
if (GameDetailContainer.LoadedGameDetails != null)
{
gd = GameDetailContainer.LoadedGameDetails;
}
else
{
gd = new GameDetails();
}
createSounds(gd);
muteVolume(gd);
}
//Slide mid game information into place
IEnumerator slideInFormation()
{
Vector3 startInfoPos = infoPanel.transform.localPosition;
Vector3 endInfoPos = startInfoPos - new Vector3(0, Screen.height * 2, 0);
Vector3 startButtonPos = buttons.transform.localPosition;
Vector3 endButtonPos = startButtonPos + new Vector3(0, Screen.height, 0);
float slideTime = 0;
while (slideTime < 1)
{
slideTime += Time.deltaTime;
infoPanel.transform.localPosition = Vector3.Lerp(startInfoPos, endInfoPos, slideTime);
buttons.transform.localPosition = Vector3.Lerp(startButtonPos, endButtonPos, slideTime);
yield return(new WaitForEndOfFrame());
}
if (KeyDirectory.Timer.isTimerSpeedingUp())
{
StartCoroutine(displaySpeedUp());
}
else
{
GameDetails.setPaused();
}
}
public static GameDetails load()
{
if (!usePlayerPrefs)
{
if (File.Exists(dataPath))
{
BinaryFormatter binaryFormater = new BinaryFormatter();
FileStream fileStream = File.Open(dataPath, FileMode.Open);
gameDetails = null;
gameDetails = (GameDetails)binaryFormater.Deserialize(fileStream);
fileStream.Close();
gameDetails.load();
loadPrefs();
readyToSave = true;
}
else
{
loadPrefs();
readyToSave = true;
save(false);
}
return(gameDetails);
}
else
{
loadPrefs();
return(null);
}
}
// Use this for initialization
void Start()
{
// set mouse to invisible
Cursor.visible = false;
// load the saved browser data
GameDetailContainer.LoadedGameDetails = DataAccess.Load();
// if there is browser data, store it in gd
// otherwise, create new browser data and store it in gd
if (GameDetailContainer.LoadedGameDetails != null)
{
gd = GameDetailContainer.LoadedGameDetails;
}
else
{
gd = new GameDetails();
}
// reset powerup timers everytime game is reloaded
minimizeTime = -1f;
multiplierTime = -1f;
addScoreTime = -1f;
// set highscore text in bottom corner to current saved high score
highscoreText.text = "Highscore: " + gd.highscore.ToString();
}
// responds to the mute button, takes the current GameDetails state, which is modified when mute is pressed
public void muteVolume(GameDetails gd)
{
foreach (Sound s in sounds)
{
s.source.mute = !gd.volumeOn; //
}
}
public static GameDetails Load()
{
GameDetails gameDetails = null;
string dataPath = string.Format("{0}/GameDetails.dat", Application.persistentDataPath);
try
{
//File.Delete(dataPath);
if (File.Exists(dataPath))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = File.Open(dataPath, FileMode.Open);
gameDetails = (GameDetails)binaryFormatter.Deserialize(fileStream);
fileStream.Close();
}
}
catch (Exception e)
{
PlatformSafeMessage("Failed to Load: " + e.Message);
}
return(gameDetails);
}
public async Task <IActionResult> GameDetails(string gameId)
{
var rapidApiKey = _config["RapidApiKey"];
GameDetails gamesInfo = new GameDetails();
string Baseurl = "https://localhost:44326/";
var gamesResponse = "";
using (var client = new HttpClient())
{
//Passing service base url
client.BaseAddress = new Uri(Baseurl);
client.DefaultRequestHeaders.Clear();
//Define request data format
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("x-rapidapi-key", rapidApiKey);
client.DefaultRequestHeaders.Add("x-rapidapi-host", "cheapshark-game-deals.p.rapidapi.com");
//Sending request to find web api REST service resource using HttpClient
HttpResponseMessage Res = await client.GetAsync("https://cheapshark-game-deals.p.rapidapi.com/games?id=" + gameId);
//Checking the response is successful or not which is sent using HttpClient
if (Res.IsSuccessStatusCode)
{
//Storing the response details recieved from web api
gamesResponse = Res.Content.ReadAsStringAsync().Result;
//Deserializing the response recieved from web api and storing into the Model
gamesInfo = JsonConvert.DeserializeObject <GameDetails>(gamesResponse);
}
}
return(View(gamesInfo));
}
public ActionResult Details(string title, string console, string version)
{
Game game = new Game();
if (Session["toegevoegd"] != null)
{
game = (Game)Session["toegevoegd"];
var gc = service.GetGameCollection((User)Session["user"]);
version = gc.Version;
}
else
{
game = service.GetGameDetails(title, console);
}
GameDetails details = MaakGameDetails(game);
details.Version = version;
//details.Title = game.Title;
//ConsoleSoort console =service.GetConsole(game.ConsoleSoort_Id);
//details.ConsoleNaam = console.ConsoleName;
//details.Conditie = game.Condition;
//Session.Remove("toegevoegd");
return(View(details));
}
// GET: Games/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
SetUserData();
var game = await _context.Games.SingleOrDefaultAsync(m => m.GameID == id);
var reviews = _context.Reviews.Where(r => r.Game.GameID == id).ToList <Review>();
var publisher = await _context.Publishers.SingleOrDefaultAsync(p => p.PublisherID == game.PublisherID);
//See this to try and track down why it's failing? https://github.com/WeberCS/WebUniversity/blob/master/WebUniversity/Controllers/InstructorsController.cs#L129
// (The "PopulateAssignedCourseData" method)
if (game == null || reviews == null || publisher == null)
{
return(NotFound());
}
GameDetails returnModel = new GameDetails()
{
Game = game,
Reviews = reviews,
Publisher = publisher
};
return(View(returnModel));
}
private static GameRoot CreateGameRoot(
string key = "Key",
GameDetails details = null,
string publisherId = null)
{
var root = new GameRoot
{
Key = key,
Details = details,
PublisherEntityId = publisherId,
Localizations = new[]
{
new GameLocalization
{
Id = Id,
CultureName = Culture.En
},
new GameLocalization
{
CultureName = Culture.Ru
}
}
};
return(root);
}
public bool ActionSaveRestore()
{
if (_restoring)
{
return(false);
}
_restoring = true;
try
{
GameDetails gameDetails = GetSelectedGameDetails();
if (gameDetails != null)
{
if (_backupManager.SaveRestore(gameDetails))
{
Message("The restoration has been successful", "Restoration Complete", MessageType.Information,
MessageMode.User);
return(true);
}
}
else
{
Message("Nothing to restore", "Nop!", MessageType.Warning, MessageMode.User);
return(false);
}
}
finally
{
_restoring = false;
}
Message("The restoration failed :(", "Hmm :(", MessageType.Error, MessageMode.User);
return(false);
}
static void Main(string[] args)
{
GameDetails Bingo = new GameDetails();
Bingo.Accept_game_details();
Bingo.Display_game_details();
}
public GameDetails StartNewGame()
{
var newGame = new GameDetails {
ManagerName = "", TeamId = 0, CurrentSeasonId = 0, CurrentWeek = 0
};
var gameId = Insert(newGame);
if (gameId > 0)
{
newGame.Id = gameId;
var seasonId = _seasonService.AddNew(newGame.Id);
newGame.CurrentSeasonId = seasonId;
Update(newGame);
GameCache.GameDetailsId = gameId;
GameCache.CurrentWeek = 0;
_teamService.CreateAllTeamsForGame(gameId);
var teamList = _teamService.GetTeamsForGame();
_teamSeasonService.CreateForNewGame(teamList, seasonId, gameId);
_playerCreatorService.CreateAllPlayersForGame(teamList);
return(newGame);
}
return(null);
}
public EnGameDetails(GameDetails gd)
{
GameId = gd.GameId;
Label = gd.Label;
State = gd.State.ToString();
Players = gd.Players.Select(p => new EnPlayerInfo(p)).ToList();
}
private BoardGameGeekGameDefinition GetExistingBGGGameById(GameDetails gameToAdd)
{
var existingGame = _dataContext.GetQueryable <BoardGameGeekGameDefinition>()
.FirstOrDefault(bgg => bgg.Id == gameToAdd.GameId);
return(existingGame);
}
protected void Page_Load(object sender, EventArgs e)
{
using (SBEntities db = new SBEntities())
{
UserSession user = Helper.GetUserSession();
_gameKey = int.Parse(Page.RouteData.Values["id"].ToString());
_userKey = user.userKey;
GameDetails gd = db.GetGame(_gameKey);
LiteralGameName.Text = gd.Game.GameName;
LiteralGameDetails.Text = Helper.FormatTextToHtml(gd.Game.OverView);
try
{
LiteralReleaseDate.Text = ((DateTime)gd.Game.ReleaseDate).ToShortDateString();
}
catch
{
LiteralReleaseDate.Text = "Not Set";
}
LiteralGameSystemName.Text = gd.GameSystemName;
_gameImage = gd.Game.CoverImage;
GameFollowerDetails gfd = db.GetGameFollowerDetails(user.userKey, _gameKey);
_followCount = gfd.FollowerCount;
_following = gfd.UserFollowing;
RepeaterUpcomingBattles.DataSource = db.GetGameUpcomingBattles(_gameKey, _userKey).ToList();
RepeaterUpcomingBattles.DataBind();
RepeaterUpcomingBattles.Visible = RepeaterUpcomingBattles.Items.Count > 0;
LabelNoBattles.Visible = RepeaterUpcomingBattles.Items.Count == 0;
}
}
public HostedGameViewModel(GameDetails data)
{
var game = GameManager.Get().GetById(data.GameId);
this.Id = data.Id;
this.GameId = data.GameId;
this.GameVersion = data.GameVersion;
this.Name = data.Name;
this.User = data.Host;
this.Status = data.InProgress ? EHostedGame.GameInProgress : EHostedGame.StartedHosting;
this.StartTime = data.DateCreated;
this.GameName = data.GameName;
this.HasPassword = data.PasswordProtected;
this.Visible = true;
this.Spectator = data.AllowsSpectators;
UpdateVisibility();
GameSource = "Online";
if (game == null)
{
return;
}
this.CanPlay = true;
this.GameName = game.Name;
this.IPAddress = IPAddress.Parse(data.IpAddress);
this.Port = data.Port;
}
public override void DecideOnGame(List <UserVoter> batchofplayers)
{
List <int> tmpWeight =
Program.gameDetailsList.Select(
possibGameDetails =>
batchofplayers.Sum(player => Convert.ToInt32(!player.HasPlayed(possibGameDetails.configFile))))
.ToList();
int totalWeight = tmpWeight.Sum();
Random _rnd = new Random();
int randomNumber = _rnd.Next(1, totalWeight + 1);
int x = 0;
GameDetails selecteDetails = Program.gameDetails;
foreach (int i in tmpWeight)
{
if (randomNumber <= i)
{
selecteDetails = Program.gameDetailsList[x];
break;
}
randomNumber -= i;
x++;
}
AssignToGame(selecteDetails, batchofplayers);
}
public void ItCreatesANewRecordIfOneDoesNotExist()
{
autoMocker.Get <IDataContext>().Expect(mock => mock.FindById <BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId))
.Throw(new EntityDoesNotExistException(typeof(BoardGameGeekGameDefinition), boardGameGeekGameDefinitionId));
var expectedGameDetails = new GameDetails
{
Thumbnail = "some thumbnail",
Name = "some name",
Categories = new List <GameCategory>()
};
autoMocker.Get <IBoardGameGeekApiClient>().Expect(mock => mock.GetGameDetails(boardGameGeekGameDefinitionId))
.Return(expectedGameDetails);
autoMocker.ClassUnderTest.CreateBoardGameGeekGameDefinition(boardGameGeekGameDefinitionId, currentUser);
var args = autoMocker.Get <IDataContext>().GetArgumentsForCallsMadeOn(mock => mock.Save(
Arg <BoardGameGeekGameDefinition> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
Assert.That(args.Count, Is.GreaterThan(0));
var actualBoardGameGeekGameDefinition = args[0][0] as BoardGameGeekGameDefinition;
Assert.That(actualBoardGameGeekGameDefinition, Is.Not.Null);
Assert.That(actualBoardGameGeekGameDefinition.Id, Is.EqualTo(boardGameGeekGameDefinitionId));
Assert.That(actualBoardGameGeekGameDefinition.Thumbnail, Is.EqualTo(expectedGameDetails.Thumbnail));
Assert.That(actualBoardGameGeekGameDefinition.Name, Is.EqualTo(expectedGameDetails.Name));
}
// advance injuries and suspensions. Recalculate team selections.
// TODO - training, recalculate ratings, values
public int AdvanceWeek(GameDetails gameDetails)
{
var teamsChangedList = new List <int>();
var injuredPlayerList = GetAllPlayersInGame(gameDetails.Id).Where(p => p.InjuredWeeks > 0);
foreach (var player in injuredPlayerList)
{
player.InjuredWeeks--;
Update(player);
if (!teamsChangedList.Contains(player.TeamId.Value))
{
teamsChangedList.Add(player.TeamId.Value);
}
}
var suspendedPlayerList = GetAllPlayersInGame(gameDetails.Id).Where(p => p.SuspendedWeeks > 0);
foreach (var player in suspendedPlayerList)
{
player.SuspendedWeeks--;
Update(player);
if (!teamsChangedList.Contains(player.TeamId.Value))
{
teamsChangedList.Add(player.TeamId.Value);
}
}
foreach (var team in teamsChangedList)
{
if (team != gameDetails.TeamId)
{
SetTeamSelection(_teamService.Get(team));
}
}
return(1);
}
public List <GameDetails> GetGamesPerConsole(int?id, int?collectionId)
{
List <GameDetails> games = new List <GameDetails>();
using (var db = new GameCollectionDBContainer())
{
var query = (from game in db.GameSet.Include("ConsoleSoort")
where game.ConsoleSoort_Id == id
orderby game.Title
select game).ToList();
foreach (var game in query)
{
foreach (var gamecollection in game.GameCollectionUIs)
{
if (gamecollection.Collection_id == collectionId)
{
var gameD = new GameDetails();
gameD.Title = game.Title;
gameD.ConsoleNaam = game.ConsoleSoort.ConsoleName;
gameD.Conditie = gamecollection.Condition;
gameD.Version = gamecollection.Version;
games.Add(gameD);
}
}
}
return(games);
}
}
public ActionResult Create([Bind(Include = "GameID,Name,Genre,Description")] GameDetails gameDetails, HttpPostedFileBase UploadGame, HttpPostedFileBase UploadImage)
{
if (ModelState.IsValid)
{
if (UploadGame != null)
{
UploadGame.SaveAs(Server.MapPath("/") + "/Content/" + UploadGame.FileName);
gameDetails.GameLocation = UploadGame.FileName;
}
else
{
return(View());
}
if (UploadImage != null)
{
UploadImage.SaveAs(Server.MapPath("/") + "/Content/" + UploadImage.FileName);
gameDetails.ImageLocation = UploadImage.FileName;
}
else
{
return(View());
}
db.GameDetails.Add(gameDetails);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(gameDetails));
}
public void startNewGame()
{
//GameCore.profitsMulti += (Lab.getEnergy (0) > 100 ? (Lab.getEnergy (0) / 4800) : 0) + (Lab.getEnergy (0) > 300 ? (Lab.getEnergy (0) / 1600) : 0);
//GameCore.setProfitsMulti(GameCore.getProfitsMulti() + (Lab.getEnergy (0) > 100 ? (Mathf.Exp((Lab.getEnergy (0) / 70.1139f))/100) : 0));
float minEnergy = 100;
if (((GameCore.getProfitsMulti() * 4) + Lab.getEnergy(0)) > 100)
{
minEnergy = (GameCore.getProfitsMulti() * 4) + minEnergy;
}
float tempToRemove = GameCore.getProfitsMulti();
if (Lab.getEnergy(0) - (tempToRemove * 4) < 100)
{
tempToRemove = (Lab.getEnergy(0) - 101) / 4;
}
else
{
tempToRemove = GameCore.getProfitsMulti();
}
GameCore.setProfitsMulti(GameCore.getProfitsMulti() + (Lab.getEnergy(0) > minEnergy ? (Mathf.Pow(((Lab.getEnergy(0) - (tempToRemove * 4)) / 100f), 2F) / 5.3333f) : 0));
GameDetails gd = new GameDetails();
gd.reset();
setActivePanel(false);
lab.load();
StartCoroutine(gameCore.startGame());
Research.lockButtons();
}
public static void Save(GameDetails gameDetails)
{
string dataPath = string.Format("{0}/GameDetails.dat", Application.persistentDataPath);
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream;
try
{
if (File.Exists(dataPath))
{
File.WriteAllText(dataPath, string.Empty);
fileStream = File.Open(dataPath, FileMode.Open);
}
else
{
fileStream = File.Create(dataPath);
}
binaryFormatter.Serialize(fileStream, gameDetails);
fileStream.Close();
if (Application.platform == RuntimePlatform.WebGLPlayer)
{
SyncFiles();
}
}
catch (Exception e)
{
PlatformSafeMessage("Failed to Save: " + e.Message);
}
}
// ReSharper disable once UnusedParameter.Local
private static void Main(string[] args)
{
ApplicationSetup();
bool keepPlaying;
do
{
Console.Clear();
CreateNewGame();
GetPlayerNames();
AddShips();
do
{
PerformAttack();
_currentGame = _read.Get <GameDetails>(_currentGame.Id).Result;
WriteLabel("Showing opponents board for demonstration of progress in game.");
var targetPlayerIndex = _currentGame.Turn % 2;
DrawPlayersBoard(_currentGame.Players[targetPlayerIndex].Board.Representation);
WriteLabel(_currentGame.Players[targetPlayerIndex].Board.LastAttackMessage);
WriteLine();
} while (_currentGame.HasWinner == null);
keepPlaying = WouldYouLikeToKeepPlaying();
} while (keepPlaying);
Console.Clear();
WriteDefault("Events generated by the most recent game.");
ShowGameEvents();
WriteLine();
Console.Write("Press <enter> to end.");
Console.ReadLine();
}
public GameBase(long genreId, long developerStudioId, long publisherId, GameDetails details)
{
GameDetails = details;
DeveloperStudioId = developerStudioId;
PublisherId = publisherId;
GenreId = genreId;
}
private async Task <DialogTurnResult> ActStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
// Call LUIS and gather any potential booking details. (Note the TurnContext has the response to the prompt.)
var luisResult = await _luisRecognizer.RecognizeAsync <Game>(stepContext.Context, cancellationToken);
switch (luisResult.TopIntent().intent)
{
case Game.Intent.PlayGame:
// Initialize BookingDetails with any entities we may have found in the response.
var gameDetails = new GameDetails()
{
MinimumNumber = luisResult.NumberRangeEntities.minimumNumber,
MaximumNumber = luisResult.NumberRangeEntities.maximumNumber,
};
// Run the PlayGameDialog giving it whatever details we have from the LUIS call, it will fill out the remainder.
return(await stepContext.BeginDialogAsync(nameof(PlayGameDialog), gameDetails, cancellationToken));
default:
// Catch all for unhandled intents
var didntUnderstandMessageText = $"Sorry, I didn't get that. Please try asking in a different way (intent was {luisResult.TopIntent().intent})";
var didntUnderstandMessage = MessageFactory.Text(didntUnderstandMessageText, didntUnderstandMessageText, InputHints.IgnoringInput);
await stepContext.Context.SendActivityAsync(didntUnderstandMessage, cancellationToken);
break;
}
return(await stepContext.NextAsync(null, cancellationToken));
}
public int Insert(GameDetails gameDetails)
{
return(Add(INSERT, new Dictionary <string, object>
{
{ "managerName", gameDetails.ManagerName }
}));
}
public List <GameDetails> GetAllGamesFromSearch(string gameNaam, int userId)
{
using (var db = new GameCollectionDBContainer())
{
List <GameDetails> gevondenGamesVanUser = new List <GameDetails>();
var query = (from game in db.GameSet.Include("ConsoleSoort")
where game.Title.Contains(gameNaam)
orderby game.Title
select game).ToList();
foreach (var game in query)
{
foreach (var collection in game.GameCollectionUIs)
{
if (collection.Collection_id == userId)
{
var gameD = new GameDetails();
gameD.Title = game.Title;
gameD.ConsoleNaam = game.ConsoleSoort.ConsoleName;
gameD.Conditie = collection.Condition;
gevondenGamesVanUser.Add(gameD);
}
}
}
return(gevondenGamesVanUser);
}
}
private void AssertBoardGameGeekGameDefinitionSaved(GameDetails expectedGameDetails)
{
var argumentsForCallsMadeOn = _autoMocker.Get <IDataContext>().GetArgumentsForCallsMadeOn(
mock => mock.Save(Arg <BoardGameGeekGameDefinition> .Is.Anything,
Arg <ApplicationUser> .Is.Anything));
Assert.That(argumentsForCallsMadeOn, Is.Not.Null);
BoardGameGeekGameDefinition actualBoardGameGeekGameDefinition = null;
foreach (var call in argumentsForCallsMadeOn)
{
actualBoardGameGeekGameDefinition = call[0] as BoardGameGeekGameDefinition;
Assert.That(actualBoardGameGeekGameDefinition, Is.Not.Null);
if (actualBoardGameGeekGameDefinition.Id == expectedGameDetails.GameId)
{
break;
}
}
Assert.That(actualBoardGameGeekGameDefinition, Is.Not.Null);
Assert.That(actualBoardGameGeekGameDefinition.AverageWeight, Is.EqualTo(expectedGameDetails.AverageWeight));
Assert.That(actualBoardGameGeekGameDefinition.Description, Is.EqualTo(expectedGameDetails.Description));
Assert.That(actualBoardGameGeekGameDefinition.MaxPlayTime, Is.EqualTo(expectedGameDetails.MaxPlayTime));
Assert.That(actualBoardGameGeekGameDefinition.MinPlayTime, Is.EqualTo(expectedGameDetails.MinPlayTime));
Assert.That(actualBoardGameGeekGameDefinition.MaxPlayers, Is.EqualTo(expectedGameDetails.MaxPlayers));
Assert.That(actualBoardGameGeekGameDefinition.MinPlayers, Is.EqualTo(expectedGameDetails.MinPlayers));
Assert.That(actualBoardGameGeekGameDefinition.Name, Is.EqualTo(expectedGameDetails.Name));
Assert.That(actualBoardGameGeekGameDefinition.Thumbnail, Is.EqualTo(expectedGameDetails.Thumbnail));
}
public HostedGameViewModel(GameDetails data)
{
var game = GameManager.Get().GetById(data.GameId);
this.Id = data.Id;
this.GameId = data.GameId;
this.GameVersion = data.GameVersion;
this.Name = data.Name;
this.User = data.Host;
this.Status = data.InProgress ? EHostedGame.GameInProgress : EHostedGame.StartedHosting;
this.StartTime = data.DateCreated;
this.GameName = data.GameName;
this.HasPassword = data.PasswordProtected;
this.Visible = true;
this.Spectator = data.AllowsSpectators;
UpdateVisibility();
GameSource = "Online";
if (game == null) return;
this.CanPlay = true;
this.GameName = game.Name;
this.IPAddress = IPAddress.Parse(data.IpAddress);
this.Port = data.Port;
}
private void GetIter(GameDetails details,
out TreeIter iter,
out bool needs_expansion)
{
int x = details.Examined ? 2 : details.
Rated ? 0 : 1;
int y;
switch (details.GameCategory)
{
case GameCategory.Blitz:
y = 0;
needs_expansion = true;
break;
case GameCategory.Standard:
y = 1;
needs_expansion = true;
break;
case GameCategory.Lightning:
y = 2;
needs_expansion = false;
break;
default:
y = 3;
needs_expansion = false;
break;
}
iter = iters[x, y];
}
public void OnObservableGameEvent(object o,
GameDetails
details)
{
if (details.PrivateGame)
{
return;
}
ngames++;
string filter_string =
String.Format ("{0} {1}",
details.white,
details.black);
filter_string = filter_string.ToLower ();
UpdateInfoLabel ();
TreeIter iter;
bool needs_expansion;
GetIter (details, out iter,
out needs_expansion);
TreeIter child = store.PrependNode (iter);
int i = 0;
store.SetValue (child, i++, filter_string);
store.SetValue (child, i++, details.gameId);
store.SetValue (child, i++,
details.ToPango ());
store.SetValue (child, i++,
details.
TimeDetailsAsMarkup ());
store.SetValue (child, i++,
details.CategoryStr);
if (needs_expansion)
gamesView.ExpandRow (store.
GetPath (iter),
false);
}
static void Main(string[] args)
{
GameDetails Bingo= new GameDetails();
Bingo.Accept_game_details();
Bingo.Display_game_details();
}
private void UpdateWebsiteTimerOnElapsed(object sender, ElapsedEventArgs elapsedEventArgs)
{
lock (UpdateWebsiteTimer)
{
if (ticking)
return;
ticking = true;
}
try
{
var client = new ApiClient();
var list = new List<GameDetails>();
var games = Games.ToArray();
foreach (var g in games)
{
var gd = new GameDetails()
{
AllowsSpectators = g.Spectator,
Id = g.Id,
GameId = g.GameGuid,
GameName = g.GameName,
Host = g.Username,
Name = g.Name,
InProgress = g.GameStatus == EHostedGame.GameInProgress,
PasswordProtected = g.HasPassword,
DateCreated = g.TimeStarted,
GameVersion = g.GameVersion,
GameIconUrl = g.GameIconUrl,
HostIconUrl = g.UserIconUrl,
IpAddress = g.IpAddress.ToString(),
Port = g.Port
};
list.Add(gd);
}
if (client.SetGameList(AppConfig.Instance.ApiKey, list) == false)
{
Log.Warn("UpdateWebsiteTimerOnElapsed: Couldn't set the game list, some kinda error.");
}
}
catch (Exception e)
{
Log.Error("UpdateWebsiteTimerOnElapsedError", e);
throw;
}
finally
{
ticking = false;
}
}
// 34 (Exam. 2144 litmus 1898 callaghan ) [ sr 15 5] B: 27
// 19 ++++ GuestFFDY ++++ GuestGLHK [ bu 5 10] 1:24 - 5:56 (32-36) W: 14
public static GameDetails FromBuffer(byte[]buffer,
int start,
int end)
{
string token;
GameDetails details = new GameDetails ();
details.gameId =
Int32.Parse (ParserUtils.
GetNextToken (buffer,
ref start,
end));
token = ParserUtils.GetNextToken (buffer,
ref start,
end);
if (token[0] == '(')
{
details.exam = true;
token = ParserUtils.
GetNextToken (buffer,
ref start,
end);
}
else
details.exam = false;
if (token[0] == '+' || token[0] == '-')
details.whiteRating = -1;
else
details.whiteRating =
Int32.Parse (token);
details.white =
ParserUtils.GetNextToken (buffer,
ref start,
end);
token = ParserUtils.GetNextToken (buffer,
ref start,
end);
if (token[0] == '+' || token[0] == '-')
details.blackRating = -1;
else
details.blackRating =
Int32.Parse (token);
if (!details.exam)
details.black =
ParserUtils.
GetNextToken (buffer,
ref start, end);
else
{
details.black =
ParserUtils.
GetNextToken (buffer, ')',
ref start,
end);
start++;
}
token = ParserUtils.GetNextToken (buffer, '[', ref start, end); // go to [
start++;
/*
details.gameType =
ParserUtils.GetNextToken (buffer,
ref start,
end);
*/
details.privateGame = buffer[start++] == 'p';
details.gameCategory =
(GameCategory) buffer[start++];
details.rated = buffer[start++] == 'r';
details.initial_time =
Int32.Parse (ParserUtils.
GetNextToken (buffer,
ref start,
end));
token = ParserUtils.GetNextToken (buffer, ']',
ref start,
end);
start++;
token = token.Trim ();
details.increment = Int32.Parse (token);
if (!details.exam)
{
token = ParserUtils.
GetNextToken (buffer,
ref start,
end);
details.whites_remaining_time =
ParserUtils.
ParseMoveTime (token,
out details.
inMilliseconds);
details.whites_remaining_time_str =
token;
ParserUtils.GotoThisChar (buffer,
'-',
ref start,
end);
start++;
token = ParserUtils.
GetNextToken (buffer,
ref start,
end);
details.blacks_remaining_time =
ParserUtils.
ParseMoveTime (token,
out details.
inMilliseconds);
details.blacks_remaining_time_str =
token;
ParserUtils.ReadWord (buffer, '(',
ref start,
end,
out token);
start++;
ParserUtils.ReadWord (buffer, '-',
ref start,
end,
out token);
start++;
token = token.Trim ();
details.whites_material_strength =
Int32.Parse (token);
ParserUtils.ReadWord (buffer, ')',
ref start,
end,
out token);
start++;
token = token.Trim ();
details.blacks_material_strength =
Int32.Parse (token);
}
token = ParserUtils.GetNextToken (buffer,
ref start,
end);
details.whiteToMove = token[0] == 'W';
details.moveNumber =
Int32.Parse (ParserUtils.
GetNextToken (buffer,
ref start,
end));
return details;
}
