public void InitializeSportEntities()
{
var watch = Stopwatch.StartNew();
if (SportEntityFactory == null)
{
Init();
}
var time = watch.Elapsed.TotalMilliseconds;
Debug.WriteLine($"Init time: {time}");
Competition = SportEntityFactory.BuildSportEvent <ICompetition>(TestData.EventId, URN.Parse("sr:sport:3"), TestData.Cultures3, TestData.ThrowingStrategy);
Debug.WriteLine($"Competition time: {watch.Elapsed.TotalMilliseconds - time}");
time = watch.Elapsed.TotalMilliseconds;
Sport = SportEntityFactory.BuildSportAsync(TestData.SportId, TestData.Cultures3, TestData.ThrowingStrategy).Result;
Debug.WriteLine($"Sport time: {watch.Elapsed.TotalMilliseconds - time}");
time = watch.Elapsed.TotalMilliseconds;
Sports = SportEntityFactory.BuildSportsAsync(TestData.Cultures3, TestData.ThrowingStrategy).Result?.ToList();
Debug.WriteLine($"Sports time: {watch.Elapsed.TotalMilliseconds - time}");
time = watch.Elapsed.TotalMilliseconds;
Tournament = SportEntityFactory.BuildSportEvent <ITournament>(TestData.TournamentId, TestData.SportId, TestData.Cultures3, TestData.ThrowingStrategy);
Debug.WriteLine($"Tournament time: {watch.Elapsed.TotalMilliseconds - time}");
time = watch.Elapsed.TotalMilliseconds;
Season = SportEntityFactory.BuildSportEvent <ISeason>(TestData.SeasonId, TestData.SportId, TestData.Cultures3, TestData.ThrowingStrategy);
Debug.WriteLine($"Season time: {watch.Elapsed.TotalMilliseconds - time}");
}
public async Task <int> UpdateAsync(ISport entity)
{
DbContext.Sports.Remove(await DbContext.Sports.FindAsync(entity.SportItemId));
await DbContext.SaveChangesAsync();
return(await _repository.UpdateAsync(AutoMapper.Mapper.Map <Sport>(entity)));
}
public static PlayerBuilder InitializeBuilder(ISport sport)
{
var sportName = sport.GetType().Name;
return((PlayerBuilder)Activator.CreateInstance(
Type.GetType($"GameSimulate.Implementations.{sportName}.{sportName}PlayerBuilder"), true));
}
public static Player Create(ISport sport, string name, int power)
{
var sportName = sport.GetType().Name;
var builder = (PlayerBuilder)Activator.CreateInstance(
Type.GetType($"GameSimulate.Implementations.{sportName}.{sportName}PlayerBuilder"), true);
return(builder.Build(name, power));
}
public Team(ISport sport, string name)
{
this.SportPlayed = sport;
this.Name = name;
this.ID = 404;
this.StatList = new List <Stat>();
this.PlayerList = new List <IPlayer>();
InitializeStats();
}
public Match(ITeam teamOne, ITeam teamTwo, string date, string time, ISport sportPlayed)
{
this.TeamOne = teamOne;
this.TeamTwo = teamTwo;
this.Date = date;
this.Time = time;
this.SportPlayed = sportPlayed;
if (this.SportPlayed == null)
{
this.SportPlayed = new Sport();
}
this.About = $"Lovely day to play some {this.SportPlayed.Name}. We have {TeamOne.Name} versus {TeamTwo.Name} on ";
}
private static bool ValidateSport(ISport item, URN sportId, int categoryCount)
{
Assert.IsNotNull(item);
Assert.AreEqual(sportId.ToString(), item.Id.ToString());
Assert.IsNotNull(item.Names);
Assert.AreEqual(TestData.Cultures.Count, item.Names.Count);
if (categoryCount > 0)
{
if (item.Categories == null)
{
Assert.Fail($"Number of categories must be {categoryCount} but item.Categories is a null reference");
}
Assert.AreEqual(categoryCount, item.Categories.Count());
}
if (item.Categories != null)
{
var duffs = item.Categories.Where(c => c.Names[TestData.Culture] != c.Names[new CultureInfo("hu")]);
return(duffs.Any());
}
return(true);
}
public void RemoveObject(ISport sportObject)
{
ApplicationObjects.Remove(sportObject);
sportObject.Remove(ref sportObject);
}
public void AddObject(ISport sportObject)
{
ApplicationObjects.Add(sportObject);
FormMain.AddObjectToListBox(sportObject);
}
public async Task <int> UpdateAsync(ISport entity)
{
return(await Repository.UpdateAsync(entity));
}
public async Task <int> RemoveAsync(ISport entity)
{
return(await Repository.RemoveAsync(entity));
}
public async Task <int> AddAsync(ISport entity)
{
return(await Repository.AddAsync(entity));
}
public void SpawnSport()
{
int temp;
temp = teamDrpDwn.GetComponent <Dropdown>().value;
if (temp == 0)
{
isTeam = true;
}
else
{
isTeam = false;
}
ballSize = ballSizeDrpDwn.GetComponent <Dropdown>().value;
temp = inWaterDrpDwn.GetComponent <Dropdown>().value;
if (temp == 0)
{
inWater = true;
}
else
{
inWater = false;
}
SportRequirements requirements = new SportRequirements();
requirements.isTeam = isTeam;
requirements.ballSize = ballSize;
requirements.inWater = inWater;
ISport s = GetSport(requirements);
sportTxt.text = s.ToString();
if (s.ToString() == "Golf")
{
spawner.SpawnBall(golf);
}
else if (s.ToString() == "WaterPolo")
{
spawner.SpawnBall(waterPolo);
}
else if (s.ToString() == "WaterFootBall")
{
spawner.SpawnBall(waterFootBall);
}
else if (s.ToString() == "BeachBall")
{
spawner.SpawnBall(beachBall);
}
else if (s.ToString() == "SpikeBall")
{
spawner.SpawnBall(spikeBall);
}
else if (s.ToString() == "VolleyBall")
{
spawner.SpawnBall(volleyBall);
}
else if (s.ToString() == "KinBall")
{
spawner.SpawnBall(kinBall);
}
else if (s.ToString() == "DivingBall")
{
spawner.SpawnBall(divingBall);
}
else if (s.ToString() == "WaterBasketBall")
{
spawner.SpawnBall(waterBasketBall);
}
else if (s.ToString() == "WaterBall")
{
spawner.SpawnBall(waterBall);
}
else if (s.ToString() == "Bowling")
{
spawner.SpawnBall(bowlingBall);
}
else
{
spawner.SpawnBall(yardPong);
}
}
public async Task <int> RemoveAsync(ISport entity)
{
DbContext.Sports.Remove(await DbContext.Sports.FindAsync(entity.SportItemId));
return(await DbContext.SaveChangesAsync());
}
public async Task <int> AddAsync(ISport entity)
{
return(await _repository.AddAsync(AutoMapper.Mapper.Map <Sport>(entity)));
}
public CatalogController(ISport sports)
{
_sport = sports;
}
