public void TestSetUp()
{
autoMocker = new RhinoAutoMocker<PlayedGameSaver>();
autoMocker.PartialMockTheClassUnderTest();
currentUser = new ApplicationUser
{
Id = "user id",
CurrentGamingGroupId = GAMING_GROUP_ID,
AnonymousClientId = "anonymous client id"
};
gameDefinition = new GameDefinition
{
Name = "game definition name",
GamingGroupId = GAMING_GROUP_ID,
Id = 9598
};
autoMocker.Get<ISecuredEntityValidator>().Expect(mock => mock.RetrieveAndValidateAccess<GameDefinition>(Arg<int>.Is.Anything, Arg<ApplicationUser>.Is.Anything)).Return(gameDefinition);
existingPlayerWithMatchingGamingGroup = new Player
{
Id = 1,
GamingGroupId = GAMING_GROUP_ID
};
autoMocker.Get<IDataContext>().Expect(mock => mock.FindById<Player>(Arg<int>.Is.Anything)).Return(existingPlayerWithMatchingGamingGroup);
}
public void SetUp()
{
builder = new GameResultViewModelBuilder();
GameDefinition gameDefinition = new GameDefinition()
{
Id = 15131,
Name = "Yodle-masters 2014"
};
PlayedGame playedGame = new PlayedGame()
{
GameDefinition = gameDefinition,
DatePlayed = new DateTime(2014, 09, 15),
WinnerType = WinnerTypes.TeamWin
};
playerGameResult = new PlayerGameResult()
{
GameRank = 1,
NemeStatsPointsAwarded = 2,
Id = 151,
PlayerId = 15135,
Player = new Player()
{
Name = "Test Player",
Active = false
},
PlayedGameId = 1432,
PlayedGame = playedGame
};
playerGameResultDetails = builder.Build(playerGameResult);
}
public void SetUp()
{
expectedGameDefinition = new GameDefinition
{
Id = GAME_DEFINITION_ID,
Name = "some old game definition name",
BoardGameGeekGameDefinitionId = -1
};
autoMocker.Get<IDataContext>().Expect(mock => mock.FindById<GameDefinition>(Arg<int>.Is.Anything)).Return(expectedGameDefinition);
}
public void ItReturnsTheEntityForTheGivenId()
{
int entityId = 1;
GameDefinition expectedGameDefinition = new GameDefinition() { Id = entityId };
gameDefinitionDbSetMock.Expect(mock => mock.Find(entityId))
.Return(expectedGameDefinition);
GameDefinition actualGameDefinition = dataContext.FindById<GameDefinition>(entityId);
Assert.AreSame(expectedGameDefinition, actualGameDefinition);
}
public void ItValidatesThatTheEntityExists()
{
int entityId = 1;
GameDefinition gameDefinition = new GameDefinition() { Id = entityId };
gameDefinitionDbSetMock.Expect(mock => mock.Find(entityId))
.Return(gameDefinition);
dataContext.FindById<GameDefinition>(entityId);
dataContext.AssertWasCalled(mock => mock.ValidateEntityExists<GameDefinition>(entityId, gameDefinition));
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker<SecuredEntityValidator>();
_securedEntity = new GameDefinition
{
Id = _securedEntityId,
GamingGroupId = _securedEntityGamingGroupId
};
_currentUser = new ApplicationUser();
_autoMocker.Get<IDataContext>().Expect(mock => mock.FindById<GameDefinition>(_securedEntityId))
.Return(_securedEntity);
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker<ChampionRecalculator>();
_applicationUser = new ApplicationUser();
_gameDefinition = new GameDefinition
{
ChampionId = _previousChampionId
};
_autoMocker.Get<IDataContext>().Expect(mock => mock.FindById<GameDefinition>(_gameDefinitionId))
.Return(_gameDefinition);
_savedChampion = new Champion { Id = _newChampionId };
_autoMocker.Get<IDataContext>().Expect(mock => mock.Save(Arg<Champion>.Is.Anything, Arg<ApplicationUser>.Is.Anything))
.Return(_savedChampion);
}
public override void FixtureSetUp()
{
base.FixtureSetUp();
dataContext = new NemeStatsDataContext();
var playerRepository = new EntityFrameworkPlayerRepository(dataContext);
boardGameGeekGameDefinitionInfoRetriever = new BoardGameGeekGameDefinitionInfoRetriever(new DateUtilities(), new CacheService(), dataContext);
gameDefinitionRetriever = new GameDefinitionRetriever(dataContext, playerRepository, boardGameGeekGameDefinitionInfoRetriever);
gameDefinition = gameDefinitionRetriever.GetGameDefinitionDetails(testGameDefinitionWithOtherGamingGroupId.Id,
0);
championlessGameDefinition = gameDefinitionRetriever.GetGameDefinitionDetails(gameDefinitionWithNoChampion.Id, 0);
// Player ID 1 has a winning percentage high enough to be considered the champion
championPlayerIdForGameDefinition = testPlayer7WithOtherGamingGroupId.Id;
// Player ID 9 has a higher winning percentage than player 7, but is not active
otherChampionPlayerIdForGameDefinition = testPlayer9UndefeatedWith5Games.Id;
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker<UniversalGameRetriever>();
_currentUser = new ApplicationUser
{
Id = "some user id"
};
_expectedGameDefinition = new GameDefinition
{
Id = 20,
BoardGameGeekGameDefinitionId = _boardGameGeekGameDefinitionId,
};
var otherGameDefinition = new GameDefinition
{
Id = 21,
BoardGameGeekGameDefinitionId = _boardGameGeekGameDefinitionId,
};
var gameDefinitionQueryable = new List<GameDefinition>
{
_expectedGameDefinition,
otherGameDefinition
}.AsQueryable();
_autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(gameDefinitionQueryable);
_expectedBoardGameGeekInfo = new BoardGameGeekInfo();
_autoMocker.Get<IBoardGameGeekGameDefinitionInfoRetriever>().Expect(mock => mock.GetResults(Arg<int>.Is.Anything)).Return(_expectedBoardGameGeekInfo);
_expectedGameDefinitionSummary = new GameDefinitionSummary();
_expectedUniversalStats = new UniversalGameStats();
_autoMocker.Get<IUniversalStatsRetriever>().Expect(mock => mock.GetResults(Arg<int>.Is.Anything))
.Return(_expectedUniversalStats);
_expectedTopChampions = new List<ChampionData>();
_autoMocker.Get<IUniversalTopChampionsRetreiver>().Expect(mock => mock.GetFromSource(Arg<int>.Is.Anything))
.Return(_expectedTopChampions);
}
/// <summary>
/// Touch使用交換人物位置的方法
/// </summary>
/// <param name="mode">交換的位置</param>
public void ChangeRolePosition(GameDefinition.ChangeRoleMode mode)
{
if (!this.isChanging)
{
switch (mode)
{
case GameDefinition.ChangeRoleMode.OneAndTwo:
this.SetChange(ref this.Roles[0], ref this.Roles[1]);
break;
case GameDefinition.ChangeRoleMode.TwoAndThree:
this.SetChange(ref this.Roles[1], ref this.Roles[2]);
break;
case GameDefinition.ChangeRoleMode.ThreeAndFour:
this.SetChange(ref this.Roles[2], ref this.Roles[3]);
break;
default:
break;
}
}
}
public void SetUp()
{
_gameDefinitionDbSetMock = MockRepository.GenerateMock<DbSet<GameDefinition>>();
nemeStatsDbContext.Expect(mock => mock.Set<GameDefinition>())
.Repeat.Once()
.Return(_gameDefinitionDbSetMock);
_securedEntityValidator = MockRepository.GenerateMock<ISecuredEntityValidator>();
securedEntityValidatorFactory.Expect(mock => mock.MakeSecuredEntityValidator<GameDefinition>(dataContext))
.Repeat.Once()
.Return(_securedEntityValidator);
_gameDefinition = new GameDefinition
{
Id = _gameDefinitionId
};
_securedEntityValidator.Expect(mock => mock.RetrieveAndValidateAccess<GameDefinition>(_gameDefinitionId, currentUser))
.Return(_gameDefinition);
}
public GameDefinition CreateGameDefinition(CreateGameDefinitionRequest createGameDefinitionRequest, ApplicationUser currentUser)
{
ValidateNotNull(createGameDefinitionRequest);
ValidateGameDefinitionNameIsNotNullOrWhitespace(createGameDefinitionRequest.Name);
int gamingGroupId = createGameDefinitionRequest.GamingGroupId ?? currentUser.CurrentGamingGroupId;
var boardGameGeekGameDefinition = CreateBoardGameGeekGameDefinition(
createGameDefinitionRequest.BoardGameGeekGameDefinitionId,
currentUser);
var existingGameDefinition = dataContext.GetQueryable<GameDefinition>()
.FirstOrDefault(game => game.GamingGroupId == gamingGroupId
&& game.Name == createGameDefinitionRequest.Name);
if (existingGameDefinition == null)
{
var newGameDefinition = new GameDefinition
{
Name = createGameDefinitionRequest.Name,
BoardGameGeekGameDefinitionId = boardGameGeekGameDefinition?.Id,
Description = createGameDefinitionRequest.Description,
GamingGroupId = gamingGroupId
};
new Task(() => eventTracker.TrackGameDefinitionCreation(currentUser, createGameDefinitionRequest.Name)).Start();
return dataContext.Save(newGameDefinition, currentUser);
}
ValidateNotADuplicateGameDefinition(existingGameDefinition);
existingGameDefinition.Active = true;
existingGameDefinition.BoardGameGeekGameDefinitionId = boardGameGeekGameDefinition?.Id;
if (!string.IsNullOrWhiteSpace(createGameDefinitionRequest.Description))
{
existingGameDefinition.Description = createGameDefinitionRequest.Description;
}
return dataContext.Save(existingGameDefinition, currentUser);
}
public void ItThrowsADuplicateKeyExceptionIfThereIsAnExistingActiveGameDefinitionWithTheSameNameInTheCurrentUsersGamingGroupAndTheGamingGroupIsNotExplicitlySet()
{
var gameDefinition = new GameDefinition
{
Name = "existing game definition name",
Active = true,
GamingGroupId = currentUser.CurrentGamingGroupId
};
var createGameDefinitionRequest = new CreateGameDefinitionRequest
{
Name = gameDefinition.Name
};
var gameDefinitionQueryable = new List<GameDefinition>
{
gameDefinition
}.AsQueryable();
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(gameDefinitionQueryable);
Exception exception = Assert.Throws<DuplicateKeyException>(
() => autoMocker.ClassUnderTest.CreateGameDefinition(createGameDefinitionRequest, currentUser));
Assert.That(exception.Message, Is.EqualTo("An active Game Definition with name '" + gameDefinition.Name + "' already exists in this Gaming Group."));
}
public override bool Compile(GameAssetType gameAsset, Uri baseUri, BinaryAsset asset, XmlNode node, GameDefinition game,
string trace, ref int position, out string ErrorDescription)
{
List <TerrainTextureTileRuntime> tiles = new List <TerrainTextureTileRuntime>();
List <XmlNode> nodes = new List <XmlNode>();
foreach (XmlNode childNode in node.ChildNodes)
{
if (childNode.Name == "Tile")
{
nodes.Add(childNode);
}
}
FileHelper.SetInt(nodes.Count, 4, asset.Content);
BinaryAsset tileList = new BinaryAsset(12 * nodes.Count);
asset.SubAssets.Add(8, tileList);
DDSFile[,] textureList = new DDSFile[nodes.Count, 2];
BinaryAsset baseAsset = new BinaryAsset(0);
BinaryAsset normalAsset = new BinaryAsset(0);
uint positionX = 16;
uint positionY = 16;
uint nextY = 0;
for (int idx = 0; idx < nodes.Count; ++idx)
{
FileHelper.SetUInt(uint.Parse(nodes[idx].Attributes["TextureID"].Value), idx * 12, tileList.Content);
string baseTexture = nodes[idx].Attributes["BaseTexture"].Value;
baseTexture = baseTexture.Substring(baseTexture.LastIndexOf(Path.DirectorySeparatorChar) + 1);
baseTexture = baseTexture.Substring(baseTexture.LastIndexOf('/') + 1);
baseTexture = baseTexture.Substring(0, baseTexture.LastIndexOf('.'));
string baseTexturePath = Macro.Terrain + baseTexture + ".dds";
if (!IOFile.Exists(baseTexturePath))
{
ErrorDescription = string.Format("{0} doesn't exist.", baseTexturePath);
return(false);
}
using (FileStream textureStream = new FileStream(baseTexturePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (BinaryReader textureReader = new BinaryReader(textureStream))
{
textureList[idx, 0] = new DDSFile(textureReader.ReadBytes((int)(textureStream.Length)));
}
}
string normalTexture = nodes[idx].Attributes["NormalTexture"].Value;
normalTexture = normalTexture.Substring(normalTexture.LastIndexOf(Path.DirectorySeparatorChar) + 1);
normalTexture = normalTexture.Substring(normalTexture.LastIndexOf('/') + 1);
normalTexture = normalTexture.Substring(0, normalTexture.LastIndexOf('.'));
string normalTexturePath = Macro.Terrain + normalTexture + ".dds";
if (!IOFile.Exists(normalTexturePath))
{
ErrorDescription = string.Format("{0} doesn't exist.", normalTexturePath);
return(false);
}
using (FileStream textureStream = new FileStream(normalTexturePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (BinaryReader textureReader = new BinaryReader(textureStream))
{
textureList[idx, 1] = new DDSFile(textureReader.ReadBytes((int)(textureStream.Length)));
}
}
}
// fixed width, automatically calculated height
ushort atlasSize = 576;
ushort atlasHeight = 0;
/*
* foreach (XmlAttribute attribute in node.Attributes)
* {
* switch (attribute.Name)
* {
* case "AtlasSize":
* atlasSize = ushort.Parse(attribute.Value);
* break;
* }
* }
*/
byte[] baseContent = new byte[0];
byte[] normalContent = new byte[0];
uint rowHeight = 0;
for (int tileIdx = 0; tileIdx < textureList.Length >> 1; ++tileIdx)
{
uint size = textureList[tileIdx, 0].Header.Height;
rowHeight = Math.Max(size + 32, rowHeight);
if (positionX + size + 16 > atlasSize)
{
positionX = 16;
positionY += nextY;
rowHeight = size + 32;
}
if (positionY + size + 16 > atlasHeight)
{
atlasHeight += atlasSize;
Array.Resize(ref baseContent, atlasSize * 4 * atlasHeight);
Array.Resize(ref normalContent, atlasSize * 4 * atlasHeight);
}
byte[] color = textureList[tileIdx, 0].Content.GetColor(size, size);
byte[] normal = textureList[tileIdx, 1].Content.GetColor(size, size);
for (int idy = -16; idy < size + 16; ++idy)
{
for (int idx = -16; idx < size + 16; ++idx)
{
int tileY = idy;
if (tileY < 0)
{
tileY = (int)(size + tileY);
}
else if (tileY >= size)
{
tileY = (int)(tileY - size);
}
int tileX = idx;
if (tileX < 0)
{
tileX = (int)(size + tileX);
}
else if (tileX >= size)
{
tileX = (int)(tileX - size);
}
baseContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4] = color[tileY * size * 4 + tileX * 4];
baseContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4 + 1] = color[tileY * size * 4 + tileX * 4 + 1];
baseContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4 + 2] = color[tileY * size * 4 + tileX * 4 + 2];
baseContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4 + 3] = color[tileY * size * 4 + tileX * 4 + 3];
normalContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4] = normal[tileY * size * 4 + tileX * 4];
normalContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4 + 1] = normal[tileY * size * 4 + tileX * 4 + 1];
normalContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4 + 2] = normal[tileY * size * 4 + tileX * 4 + 2];
normalContent[(positionY + idy) * atlasSize * 4 + (positionX + idx) * 4 + 3] = normal[tileY * size * 4 + tileX * 4 + 3];
}
}
FileHelper.SetUShort((ushort)positionX, 12 * tileIdx + 4, tileList.Content);
FileHelper.SetUShort((ushort)positionY, 12 * tileIdx + 6, tileList.Content);
FileHelper.SetUShort((ushort)(positionX + size), 12 * tileIdx + 8, tileList.Content);
FileHelper.SetUShort((ushort)(positionY + size), 12 * tileIdx + 10, tileList.Content);
positionX += size + 32;
nextY = Math.Max(size + 32, nextY);
}
bool hasAlpha = false;
for (int idx = 0; idx < nodes.Count; ++idx)
{
if (textureList[idx, 0].HasAlpha())
{
hasAlpha = true;
break;
}
}
DDSFile baseAtlas = null;
if (hasAlpha)
{
baseAtlas = new DDSFile(atlasSize, atlasHeight, 5, DDSType.DXT5, baseContent);
}
else
{
baseAtlas = new DDSFile(atlasSize, atlasHeight, 5, DDSType.DXT1, baseContent);
}
hasAlpha = false;
for (int idx = 0; idx < nodes.Count; ++idx)
{
if (textureList[idx, 1].HasAlpha())
{
hasAlpha = true;
break;
}
}
DDSFile normalAtlas = null;
if (hasAlpha)
{
normalAtlas = new DDSFile(atlasSize, atlasHeight, 5, DDSType.A1R5G5B5, normalContent);
}
else
{
normalAtlas = new DDSFile(atlasSize, atlasHeight, 5, DDSType.R5G6B5, normalContent);
}
baseAsset.Content = baseAtlas.Binary;
asset.SubAssets.Add(0x0C, baseAsset);
FileHelper.SetInt(baseAsset.Content.Length, 0x10, asset.Content);
normalAsset.Content = normalAtlas.Binary;
asset.SubAssets.Add(0x14, normalAsset);
FileHelper.SetInt(normalAsset.Content.Length, 0x18, asset.Content);
ErrorDescription = string.Empty;
return(true);
}
private GameDefinition SaveGameDefinition(NemeStatsDbContext nemeStatsDbContext, int gamingGroupId, string gameDefinitionName, int? boardGameGeekGameDefinitionid = null)
{
GameDefinition gameDefinition = new GameDefinition
{
Name = gameDefinitionName,
Description = testGameDescription,
GamingGroupId = gamingGroupId,
BoardGameGeekGameDefinitionId = boardGameGeekGameDefinitionid
};
nemeStatsDbContext.GameDefinitions.Add(gameDefinition);
nemeStatsDbContext.SaveChanges();
return gameDefinition;
}
public override void OnSessionBegin(string sessionName, GameDefinition gameDef, Props sessionParameters)
{
base.OnSessionBegin(sessionName, gameDef, sessionParameters);
instance._gameDefinition = gameDef;
}
/// <summary>
/// 根據角色不同，使出不同絕技
/// </summary>
/// <param name="role">角色</param>
void CheckRoleUniqueSkill(GameDefinition.Role role)
{
GameObject obj = null;
switch (role)
{
case GameDefinition.Role.狂戰士: //公式：第一段普通攻擊2倍，第二段普通攻擊1.5倍
//第一段攻擊，自身攻擊距離範圍內所有怪物受到傷害
foreach (var hit in Physics.RaycastAll(this.transform.position, Vector3.right, this.AttackDistance, this.AttackLayer))
{
if (hit.transform.GetComponent<EnemyPropertyInfo>())
hit.transform.GetComponent<EnemyPropertyInfo>().DecreaseLife(Mathf.FloorToInt(this.roleInfo.damage * (2 + this.roleInfo.UltimateSkillLV * 1.5f))); //第一段傷害
else if (hit.transform.GetComponent<BossPropertyInfo>())
hit.transform.GetComponent<BossPropertyInfo>().DecreaseLife(Mathf.FloorToInt(this.roleInfo.damage * (2 + this.roleInfo.UltimateSkillLV * 1.5f))); //第一段傷害
}
//第二段攻擊，產生衝擊波物件
obj = (GameObject)Instantiate(this.SkillObject, this.transform.position - new Vector3(0, 0, 0.1f), this.SkillObject.transform.rotation);
//設定物件的parent 、 layer 、 Damage
obj.layer = LayerMask.NameToLayer("ShootObject");
obj.transform.parent = GameObject.Find("UselessObjectCollection").transform;
obj.GetComponent<ShootObjectInfo_Through>().Damage = Mathf.FloorToInt(this.roleInfo.damage * (1.5f + this.roleInfo.UltimateSkillLV * 0.75f)); //第二段傷害
break;
case GameDefinition.Role.獵人: //公式：普通攻擊1.2倍
//三支箭
for (int i = 0; i < 3; i++)
{
//產生光箭物件
obj = (GameObject)Instantiate(this.SkillObject, this.transform.position - new Vector3(0, 0, 0.1f), this.SkillObject.transform.rotation);
//設定物件的parent 、 layer 、 Damage
obj.layer = LayerMask.NameToLayer("ShootObject");
obj.transform.parent = GameObject.Find("UselessObjectCollection").transform;
obj.transform.Rotate(new Vector3(0, 0, -10 + i * 10)); //光箭角度不同
obj.GetComponent<ShootObjectInfo_Through>().Damage = Mathf.FloorToInt(this.roleInfo.damage * (1.2f + this.roleInfo.UltimateSkillLV * 0.4f));
}
break;
case GameDefinition.Role.盾騎士: //公式：普通攻擊3倍
//產生光波物件
obj = (GameObject)Instantiate(this.SkillObject, this.transform.position - new Vector3(0, 0, 0.1f), this.SkillObject.transform.rotation);
//設定物件的parent 、 layer 、 Damage
obj.layer = LayerMask.NameToLayer("ShootObject");
obj.transform.parent = GameObject.Find("UselessObjectCollection").transform;
obj.GetComponent<ShootObjectInfo_Through>().Damage = this.roleInfo.damage * (3 + this.roleInfo.UltimateSkillLV * 2);
break;
case GameDefinition.Role.魔法師: //公式：普通攻擊2.5倍
//產生魔法陣物件
obj = (GameObject)Instantiate(this.SkillObject, this.transform.position - new Vector3(0, 0, 0.1f), this.SkillObject.transform.rotation);
obj.transform.position = Camera.main.ScreenToWorldPoint(new Vector3(Camera.main.pixelWidth / 2, Camera.main.pixelHeight / 2, 1)); //魔法陣在螢幕正中央
foreach (EnemyPropertyInfo script in GameObject.FindObjectsOfType(typeof(EnemyPropertyInfo)))
script.DecreaseLife(Mathf.FloorToInt(this.roleInfo.damage * (2.5f + this.roleInfo.UltimateSkillLV * 1.75f)));
if (GameManager.script.CurrentBossObject != null)
{
BossPropertyInfo script = (BossPropertyInfo)GameObject.FindObjectOfType(typeof(BossPropertyInfo));
script.DecreaseLife(Mathf.FloorToInt(this.roleInfo.damage * (2.5f + this.roleInfo.UltimateSkillLV * 1.75f)));
}
break;
}
}
public void AnExistingInactiveGameDefinitionIsReactivatedIfSomeoneTriesToAddItAgain()
{
var existingGameDefinition = new GameDefinition
{
Id = 1,
Name = "existing game definition name",
GamingGroupId = currentUser.CurrentGamingGroupId,
Active = false
};
var gameDefinitionQueryable = new List<GameDefinition>
{
existingGameDefinition
}.AsQueryable();
var newGameDefinition = new CreateGameDefinitionRequest
{
Name = existingGameDefinition.Name
};
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(gameDefinitionQueryable);
autoMocker.ClassUnderTest.CreateGameDefinition(newGameDefinition, currentUser);
var gameDefinitionThatWasSaved =
(GameDefinition)autoMocker.Get<IDataContext>().GetArgumentsForCallsMadeOn(mock => mock.Save(Arg<GameDefinition>.Is.Anything, Arg<ApplicationUser>.Is.Anything))[0][0];
Assert.That(gameDefinitionThatWasSaved.Id, Is.EqualTo(existingGameDefinition.Id));
Assert.That(gameDefinitionThatWasSaved.BoardGameGeekGameDefinitionId, Is.EqualTo(existingGameDefinition.BoardGameGeekGameDefinitionId));
Assert.That(gameDefinitionThatWasSaved.Active, Is.EqualTo(true));
}
private void UpdateGameDefinition(GameDefinition game, int boardGameGeekGameDefinitionId,
LinkOrphanGamesJobResult jobResult)
{
game.BoardGameGeekGameDefinitionId = boardGameGeekGameDefinitionId;
jobResult.LinkedGames++;
}
public static void Run(Options opts)
{
logger.Info("Starting...");
var definition = GameDefinition.FromGame(opts.Game);
var installation = GameInstallation
.FindAll(new[] { definition })
.FirstOrDefault();
if (installation == null)
{
Console.WriteLine($"OpenSAGE was unable to find any installations of {definition.DisplayName}.\n");
Console.WriteLine("You can manually specify the installation path by setting the following environment variable:");
Console.WriteLine($"\t{definition.Identifier.ToUpper()}_PATH=<installation path>\n");
Console.WriteLine("OpenSAGE doesn't yet detect every released version of every game. Please report undetected versions to our GitHub page:");
Console.WriteLine("\thttps://github.com/OpenSAGE/OpenSAGE/issues");
Console.WriteLine("\n\n Press any key to exit.");
Console.ReadLine();
Environment.Exit(1);
}
logger.Debug($"Have installation of {definition.DisplayName}");
Platform.Start();
var traceEnabled = !string.IsNullOrEmpty(opts.TraceFile);
if (traceEnabled)
{
GameTrace.Start(opts.TraceFile);
}
// TODO: Read game version from assembly metadata or .git folder
// TODO: Set window icon.
var config = new Configuration()
{
UseFullscreen = opts.Fullscreen,
UseRenderDoc = opts.RenderDoc,
LoadShellMap = !opts.NoShellmap,
};
logger.Debug($"Have configuration");
using (var game = new Game(installation, opts.Renderer, config))
{
game.GraphicsDevice.SyncToVerticalBlank = !opts.DisableVsync;
game.DeveloperModeEnabled = opts.DeveloperMode;
if (opts.ReplayFile != null)
{
var replayFile = game.ContentManager.UserDataFileSystem?.GetFile(Path.Combine("Replays", opts.ReplayFile));
if (replayFile == null)
{
logger.Debug("Could not find entry for Replay " + opts.ReplayFile);
game.ShowMainMenu();
}
game.LoadReplayFile(replayFile);
}
else if (opts.Map != null)
{
var mapCache = game.AssetStore.MapCaches.GetByName(opts.Map);
if (mapCache == null)
{
logger.Debug("Could not find MapCache entry for map " + opts.Map);
game.ShowMainMenu();
}
else if (mapCache.IsMultiplayer)
{
var pSettings = new PlayerSetting?[]
{
new PlayerSetting(null, game.AssetStore.PlayerTemplates.GetByName("FactionAmerica"), new ColorRgb(255, 0, 0)),
new PlayerSetting(null, game.AssetStore.PlayerTemplates.GetByName("FactionGLA"), new ColorRgb(255, 255, 255)),
};
logger.Debug("Starting multiplayer game");
game.StartMultiPlayerGame(opts.Map,
new EchoConnection(),
pSettings,
0);
}
else
{
logger.Debug("Starting singleplayer game");
game.StartSinglePlayerGame(opts.Map);
}
}
else
{
logger.Debug("Showing main menu");
game.ShowMainMenu();
}
logger.Debug("Starting game");
game.Run();
}
if (traceEnabled)
{
GameTrace.Stop();
}
Platform.Stop();
}
public void SetUp()
{
_autoMocker = new RhinoAutoMocker<UniversalTopChampionsRetreiver>();
_expectedFirstChampionGameDefinition = new GameDefinition
{
Id = 20,
BoardGameGeekGameDefinitionId = _boardGameGeekGameDefinitionId,
ChampionId = _topChampionId
};
var otherGameDefinition = new GameDefinition
{
Id = 21,
BoardGameGeekGameDefinitionId = _boardGameGeekGameDefinitionId,
ChampionId = _champion2Id
};
_topChampion = new Champion
{
Id = _topChampionId,
GameDefinitionId = _expectedFirstChampionGameDefinition.Id,
WinPercentage = 100,
NumberOfWins = 2,
NumberOfGames = 2,
PlayerId = 200,
Player = new Player()
{
Name = "player name 1",
GamingGroupId = 200,
GamingGroup = new GamingGroup
{
Name = "gaming group 1"
}
},
GameDefinition = _expectedFirstChampionGameDefinition
};
_champion2 = new Champion
{
Id = _champion2Id,
GameDefinitionId = otherGameDefinition.Id,
WinPercentage = 50,
NumberOfWins = 1,
NumberOfGames = 2,
PlayerId = 201,
Player = new Player()
{
Name = "player name 2",
GamingGroupId = 201,
GamingGroup = new GamingGroup
{
Name = "gaming group 2"
}
},
GameDefinition = otherGameDefinition
};
_championThatIsNoLongerTheCurrentChampionForTheGameDefinition = new Champion
{
Id = -1,
GameDefinitionId = otherGameDefinition.Id,
WinPercentage = 50,
NumberOfWins = 1,
NumberOfGames = 2,
PlayerId = 202,
Player = new Player()
{
Name = "player name 2",
GamingGroupId = 201,
GamingGroup = new GamingGroup
{
Name = "gaming group 2"
}
},
GameDefinition = otherGameDefinition
};
var championQueryable = new List<Champion>
{
_topChampion,
_champion2,
_championThatIsNoLongerTheCurrentChampionForTheGameDefinition
}.AsQueryable();
_autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<Champion>()).Return(championQueryable);
}
public void SetUp()
{
autoMocker = new RhinoAutoMocker<PlayerRetriever>();
autoMocker.PartialMockTheClassUnderTest();
expectedChampion = new Champion()
{
Id = 100,
PlayerId = 101,
Player = new Player()
};
expectedNemesis = new Nemesis()
{
Id = 155,
NemesisPlayerId = 8888,
NemesisPlayer = new Player()
};
expectedPriorNemesis = new Nemesis()
{
Id = 22222,
NemesisPlayerId = 4444,
NemesisPlayer = new Player()
};
var nemesisForPlayerWithOnlyACurrentNemesis = new Nemesis
{
Id = 33333,
NemesisPlayer = new Player()
};
player = new Player()
{
Id = 1351,
Name = "the player",
PlayerGameResults = new List<PlayerGameResult>(),
GamingGroup = new GamingGroup{ Id = gamingGroupId },
GamingGroupId = gamingGroupId,
Active = true,
NemesisId = expectedNemesis.Id,
Nemesis = expectedNemesis,
PreviousNemesisId = expectedPriorNemesis.Id,
PreviousNemesis = expectedPriorNemesis
};
expectedFormerChampionGame = new GameDefinition
{
Id = 111,
PreviousChampionId = player.Id,
GamingGroupId = gamingGroupId
};
playerWithNoNemesisEver = new Player()
{
Id = 161266939,
GamingGroup = new GamingGroup { Id = gamingGroupId },
GamingGroupId = gamingGroupId
};
playerWithOnlyACurrentNemesis = new Player()
{
Id = 888484,
NemesisId = 7,
Nemesis = nemesisForPlayerWithOnlyACurrentNemesis,
GamingGroup = new GamingGroup { Id = gamingGroupId },
GamingGroupId = gamingGroupId
};
playerWithAChampionship = new Player()
{
Id = 101,
GamingGroup = new GamingGroup { Id = gamingGroupId }
};
var players = new List<Player>()
{
player,
playerWithNoNemesisEver,
playerWithOnlyACurrentNemesis,
playerWithAChampionship
};
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<Player>())
.Return(players.AsQueryable());
expectedPlayerStatistics = new PlayerStatistics
{
NemePointsSummary = new NemePointsSummary(1, 2, 4)
};
autoMocker.ClassUnderTest.Expect(repo => repo.GetPlayerStatistics(Arg<int>.Is.Anything))
.Repeat.Once()
.Return(expectedPlayerStatistics);
autoMocker.ClassUnderTest.Expect(mock => mock.GetPlayerGameResultsWithPlayedGameAndGameDefinition(
Arg<int>.Is.Anything,
Arg<int>.Is.Anything))
.Repeat.Once()
.Return(player.PlayerGameResults.ToList());
this.expectedMinions = new List<Player>();
autoMocker.ClassUnderTest.Expect(mock => mock.GetMinions(Arg<int>.Is.Anything))
.Return(this.expectedMinions);
expectedPlayerGameSummaries = new List<PlayerGameSummary>
{
new PlayerGameSummary()
};
autoMocker.Get<IPlayerRepository>().Expect(mock => mock.GetPlayerGameSummaries(Arg<int>.Is.Anything))
.Return(expectedPlayerGameSummaries);
expectedChampionedGames = new List<Champion> { expectedChampion };
autoMocker.ClassUnderTest.Expect(mock => mock.GetChampionedGames(Arg<int>.Is.Anything))
.Return(expectedChampionedGames);
expectedFormerChampionedGames = new List<GameDefinition> { expectedFormerChampionGame };
autoMocker.ClassUnderTest.Expect(mock => mock.GetFormerChampionedGames(Arg<int>.Is.Anything))
.Return(expectedFormerChampionedGames);
expectedPlayerVersusPlayerStatistics = new List<PlayerVersusPlayerStatistics>();
autoMocker.Get<IPlayerRepository>().Expect(mock => mock.GetPlayerVersusPlayersStatistics(Arg<int>.Is.Anything))
.Return(expectedPlayerVersusPlayerStatistics);
autoMocker.Get<IPlayerRepository>().Expect(mock => mock.GetLongestWinningStreak(player.Id)).Return(expectedLongestWinningStreak);
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<PlayerAchievement>()).Return(new List<PlayerAchievement>().AsQueryable());
}
private void ClearChampionId(ApplicationUser applicationUser, GameDefinition gameDefinition)
{
if (gameDefinition.ChampionId != null)
{
gameDefinition.PreviousChampionId = gameDefinition.ChampionId;
gameDefinition.ChampionId = null;
dataContext.Save(gameDefinition, applicationUser);
}
}
public void ItCanFindAnEntityUsingAnIntId()
{
GameDefinition gameDefinition = dataContext.FindById <GameDefinition>(testGameDefinition.Id);
Assert.NotNull(gameDefinition);
}
public void ItDoesNotRecordAGameDefinitionCreatedEventIfTheGameDefinitionIsNotNew()
{
var existingGameDefinition = new GameDefinition
{
Id = 1,
Name = "existing game definition name",
GamingGroupId = currentUser.CurrentGamingGroupId,
Active = false
};
var gameDefinitionQueryable = new List<GameDefinition>
{
existingGameDefinition
}.AsQueryable();
var newGameDefinition = new CreateGameDefinitionRequest
{
Name = existingGameDefinition.Name
};
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(gameDefinitionQueryable); ;
autoMocker.ClassUnderTest.CreateGameDefinition(newGameDefinition, currentUser);
autoMocker.Get<INemeStatsEventTracker>().AssertWasNotCalled(mock => mock.TrackGameDefinitionCreation(currentUser, newGameDefinition.Name));
}
public void ReactivatingAnExistingGameDefinitionTakesTheOldDescriptionIfTheNewOneIsBlank()
{
var existingGameDefinition = new GameDefinition
{
Id = 1,
Name = "existing game definition name",
Description = "existing game definition description",
Active = false,
GamingGroupId = currentUser.CurrentGamingGroupId
};
var gameDefinitionQueryable = new List<GameDefinition>
{
existingGameDefinition
}.AsQueryable();
var newGameDefinition = new CreateGameDefinitionRequest
{
Name = existingGameDefinition.Name
};
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>()).Return(gameDefinitionQueryable);
autoMocker.ClassUnderTest.CreateGameDefinition(newGameDefinition, currentUser);
var gameDefinitionThatWasSaved =
(GameDefinition)autoMocker.Get<IDataContext>().GetArgumentsForCallsMadeOn(mock => mock.Save(Arg<GameDefinition>.Is.Anything, Arg<ApplicationUser>.Is.Anything))[0][0];
Assert.That(gameDefinitionThatWasSaved.Description, Is.EqualTo(existingGameDefinition.Description));
}
public virtual void FixtureSetUp()
{
//create a stub for this only since we don't want the slowdown of all of the universal analytics event tracking
eventTrackerStub = MockRepository.GenerateStub<IEventTracker>();
eventTrackerStub.Expect(stub => stub.TrackEvent(Arg<IUniversalAnalyticsEvent>.Is.Anything))
.Repeat.Any();
playedGameTracker = new UniversalAnalyticsNemeStatsEventTracker(eventTrackerStub, eventFactory);
using (NemeStatsDbContext nemeStatsDbContext = new NemeStatsDbContext())
{
CleanUpTestData();
testUserWithDefaultGamingGroup = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithDefaultGamingGroup,
"*****@*****.**");
testUserWithDefaultGamingGroupAndNoInvites = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithDefaultGamingGroupAndNoInvites,
"*****@*****.**");
testUserWithOtherGamingGroup = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithOtherGamingGroup,
"*****@*****.**");
testUserWithThirdGamingGroup = SaveApplicationUser(
nemeStatsDbContext,
testApplicationUserNameForUserWithThirdGamingGroup,
"*****@*****.**");
using (NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
testGamingGroup = SaveGamingGroup(dataContext, testGamingGroup1Name, testUserWithDefaultGamingGroup);
testUserWithDefaultGamingGroup = UpdateDatefaultGamingGroupOnUser(testUserWithDefaultGamingGroup, testGamingGroup, dataContext);
testOtherGamingGroup = SaveGamingGroup(dataContext, testGamingGroup2Name, testUserWithOtherGamingGroup);
testUserWithOtherGamingGroup = UpdateDatefaultGamingGroupOnUser(testUserWithOtherGamingGroup, testOtherGamingGroup, dataContext);
testThirdGamingGroup = SaveGamingGroup(dataContext, testGamingGroup3Name, testUserWithThirdGamingGroup);
testUserWithThirdGamingGroup = UpdateDatefaultGamingGroupOnUser(testUserWithThirdGamingGroup,
testThirdGamingGroup, dataContext);
testBoardGameGeekGameDefinition = SaveBoardGameGeekGameDefinition(dataContext);
testGameDefinition = SaveGameDefinition(nemeStatsDbContext, testGamingGroup.Id, testGameName, testBoardGameGeekGameDefinition.Id);
testGameDefinition2 = SaveGameDefinition(nemeStatsDbContext, testGamingGroup.Id, testGameName2);
testGameDefinitionWithOtherGamingGroupId = SaveGameDefinition(nemeStatsDbContext, testOtherGamingGroup.Id, testGameNameForGameWithOtherGamingGroupId);
gameDefinitionWithNoChampion = SaveGameDefinition(nemeStatsDbContext, testThirdGamingGroup.Id,
gameDefinitionWithNoChampionName);
anotherTestGameDefinitionWithOtherGamingGroupId = SaveGameDefinition(nemeStatsDbContext,
testOtherGamingGroup.Id, testGameNameForAnotherGameWithOtherGamingGroupId);
SavePlayers(nemeStatsDbContext, testGamingGroup.Id, testOtherGamingGroup.Id);
}
using(NemeStatsDataContext dataContext = new NemeStatsDataContext())
{
CreatePlayedGames(dataContext);
}
}
}
/// <summary>
/// 提升角色能力等級
/// </summary>
/// <param name="role">角色名</param>
/// <param name="type">提升能力類型</param>
public void LevelUp(GameDefinition.Role role, LevelUpType type)
{
int currentLV = -1;
int cost = -1;
GameDefinition.RoleData getData;
switch (type)
{
case LevelUpType.生命:
currentLV = PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_HP_LV");
//如果該能力已經升至最大等級，則不進行升級
if (currentLV >= GameDefinition.AbilityCostLevel.Count)
return;
//將目前金幣數扣除升級能力所需的費用
if (0 > (cost = PlayerPrefsDictionary.script.GetValue("Money") - PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_HP_M")))
return;
PlayerPrefsDictionary.script.SetValue("Money", cost);
//將能力升一級
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_HP_LV", currentLV + 1);
//如果該能力在升級後，達最大等級，則升級所需金額設為0
if ((currentLV + 1) == GameDefinition.AbilityCostLevel.Count)
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_HP_M", 0);
else
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_HP_M", GameDefinition.AbilityCostLevel[currentLV + 1]);
//讀取系統儲存的角色屬性資料
getData = GameDefinition.RoleList.Find((GameDefinition.RoleData data) => { return data.RoleName == role; });
//儲存升級後的能力至系統
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_HP", getData.Life + getData.LifeAdd);
getData.UpdateAbilityValue(PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_HP"), getData.Damage, getData.Defence);
break;
case LevelUpType.攻擊:
currentLV = PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_ATK_LV");
//如果該能力已經升至最大等級，則不進行升級
if (currentLV >= GameDefinition.AbilityCostLevel.Count)
return;
//將目前金幣數扣除升級能力所需的費用
if (0 > (cost = PlayerPrefsDictionary.script.GetValue("Money") - PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_ATK_M")))
return;
PlayerPrefsDictionary.script.SetValue("Money", cost);
//將能力升一級
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ATK_LV", currentLV + 1);
//如果該能力在升級後，達最大等級，則升級所需金額設為0
if ((currentLV + 1) == GameDefinition.AbilityCostLevel.Count)
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ATK_M", 0);
else
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ATK_M", GameDefinition.AbilityCostLevel[currentLV + 1]);
//讀取系統儲存的角色屬性資料
getData = GameDefinition.RoleList.Find((GameDefinition.RoleData data) => { return data.RoleName == role; });
//儲存升級後的能力至系統
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ATK", getData.Damage + getData.DamageAdd);
getData.UpdateAbilityValue(getData.Life, PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_ATK"), getData.Defence);
break;
case LevelUpType.防禦:
currentLV = PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_DEF_LV");
//如果該能力已經升至最大等級，則不進行升級
if (currentLV >= GameDefinition.AbilityCostLevel.Count)
return;
//將目前金幣數扣除升級能力所需的費用
if (0 > (cost = PlayerPrefsDictionary.script.GetValue("Money") - PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_DEF_M")))
return;
PlayerPrefsDictionary.script.SetValue("Money", cost);
//將能力升一級
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_DEF_LV", currentLV + 1);
//如果該能力在升級後，達最大等級，則升級所需金額設為0
if ((currentLV + 1) == GameDefinition.AbilityCostLevel.Count)
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_DEF_M", 0);
else
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_DEF_M", GameDefinition.AbilityCostLevel[currentLV + 1]);
//讀取系統儲存的角色屬性資料
getData = GameDefinition.RoleList.Find((GameDefinition.RoleData data) => { return data.RoleName == role; });
//儲存升級後的能力至系統
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_DEF", getData.Defence + getData.DefenceAdd);
getData.UpdateAbilityValue(getData.Life, getData.Damage, PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_DEF"));
break;
case LevelUpType.普攻等級:
currentLV = PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_BASIC_LV");
//如果該能力已經升至最大等級，則不進行升級
if (currentLV >= GameDefinition.AttackLVCostLevel.Count)
return;
//將目前金幣數扣除升級能力所需的費用
if (0 > (cost = PlayerPrefsDictionary.script.GetValue("Money") - PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_BASIC_LV_M")))
return;
PlayerPrefsDictionary.script.SetValue("Money", cost);
//將能力升一級
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_BASIC_LV", currentLV + 1);
//如果該能力在升級後，達最大等級，則升級所需金額設為0
if ((currentLV + 1) == GameDefinition.AttackLVCostLevel.Count)
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_BASIC_LV_M", 0);
else
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_BASIC_LV_M", GameDefinition.AttackLVCostLevel[currentLV + 1]);
break;
case LevelUpType.絕技等級:
currentLV = PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_ULT_LV");
//如果該能力已經升至最大等級，則不進行升級
if (currentLV >= GameDefinition.UltimateSkillCostLevel.Count)
return;
//將目前金幣數扣除升級能力所需的費用
if (0 > (cost = PlayerPrefsDictionary.script.GetValue("Money") - PlayerPrefsDictionary.script.GetValue(this.RoleNameDictionary[role] + "_ULT_LV_M")))
return;
PlayerPrefsDictionary.script.SetValue("Money", cost);
//將能力升一級
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ULT_LV", currentLV + 1);
//如果該能力在升級後，達最大等級，則升級所需金額設為0
if ((currentLV + 1) == GameDefinition.UltimateSkillCostLevel.Count)
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ULT_LV_M", 0);
else
PlayerPrefsDictionary.script.SetValue(this.RoleNameDictionary[role] + "_ULT_LV_M", GameDefinition.UltimateSkillCostLevel[currentLV + 1]);
break;
}
}
public void TestFixtureSetUp()
{
AutomapperConfiguration.Configure();
minionViewModelBuilderMock = MockRepository.GenerateMock <IMinionViewModelBuilder>();
mapperFactory = MockRepository.GenerateStub <IMapperFactory>();
currentUser = new ApplicationUser()
{
CurrentGamingGroupId = gamingGroupId,
Id = "application user id"
};
var gameDefinition1 = new GameDefinition()
{
Name = "test game 1",
Id = gameDefinitionIdThatIsChampionedByCurrentPlayer,
};
gameDefinitionThatIsFormerlyChampionedByCurrentPlayer = new GameDefinition
{
Name = "formerly championed game",
Id = gameDefinitionIdThatIsFormerlyChampionedByCurrentPlayer
};
gameDefinitionThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer = new GameDefinition
{
Name = "currently and formerly championed game",
Id = gameDefinitionIdThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
};
var playedGame1 = new PlayedGame()
{
Id = 1,
GameDefinition = gameDefinition1
};
var playedGame2 = new PlayedGame()
{
Id = 2,
GameDefinitionId = gameDefinitionIdThatIsFormerlyChampionedByCurrentPlayer
};
var playerGameResults = new List <PlayerGameResult>()
{
new PlayerGameResult()
{
PlayedGameId = 12, PlayedGame = playedGame1
},
new PlayerGameResult()
{
PlayedGameId = 13, PlayedGame = playedGame2
}
};
normalPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "Jim",
OpposingPlayerId = 1,
OpposingPlayerActive = false,
NumberOfGamesWonVersusThisPlayer = 10,
NumberOfGamesLostVersusThisPlayer = 10
};
playerWithNoGamesPlayed = new PlayerVersusPlayerStatistics
{
OpposingPlayerId = 2
};
minionPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "Minion Player",
OpposingPlayerId = 5,
NumberOfGamesWonVersusThisPlayer = 20,
NumberOfGamesLostVersusThisPlayer = 0
};
nemesisPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "nemesis player",
OpposingPlayerId = 3,
NumberOfGamesWonVersusThisPlayer = 0,
NumberOfGamesLostVersusThisPlayer = 100
};
previousNemesisPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "Previous Nemesis Player",
OpposingPlayerId = 13,
NumberOfGamesWonVersusThisPlayer = 0,
NumberOfGamesLostVersusThisPlayer = 42
};
var nemesis = new Nemesis()
{
NemesisPlayerId = nemesisPlayer.OpposingPlayerId,
NumberOfGamesLost = 3,
LossPercentage = 75,
NemesisPlayer = new Player()
{
Name = "Ace Nemesis",
}
};
var previousNemesis = new Nemesis()
{
NemesisPlayerId = previousNemesisPlayer.OpposingPlayerId,
NumberOfGamesLost = 5,
LossPercentage = 66,
NemesisPlayer = new Player()
{
Name = "Bravo Nemesis",
}
};
playerDetails = new PlayerDetails()
{
Id = playerId,
ApplicationUserId = currentUser.Id,
Active = true,
Name = "Skipper",
LongestWinningStreak = 39,
PlayerGameResults = playerGameResults,
PlayerStats = new PlayerStatistics()
{
TotalGames = 5,
NemePointsSummary = new NemePointsSummary(1, 3, 5),
AveragePlayersPerGame = 3,
TotalGamesLost = 1,
TotalGamesWon = 4,
WinPercentage = 20
},
CurrentNemesis = nemesis,
PreviousNemesis = previousNemesis,
Minions = new List <Player>
{
new Player
{
Id = minionPlayer.OpposingPlayerId
}
},
GamingGroupId = gamingGroupId,
GamingGroupName = "gaming group name",
PlayerVersusPlayersStatistics = new List <PlayerVersusPlayerStatistics>
{
normalPlayer,
playerWithNoGamesPlayed,
nemesisPlayer,
previousNemesisPlayer,
minionPlayer
},
PlayerGameSummaries = new List <PlayerGameSummary>
{
new PlayerGameSummary
{
GameDefinitionId = gameDefinitionIdThatIsChampionedByCurrentPlayer
},
new PlayerGameSummary
{
GameDefinitionId = gameDefinitionIdThatIsFormerlyChampionedByCurrentPlayer
},
new PlayerGameSummary
{
GameDefinitionId = gameDefinitionIdThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
}
},
NemePointsSummary = new NemePointsSummary(1, 3, 5)
};
gameResultViewModelBuilder
= MockRepository.GenerateMock <IGameResultViewModelBuilder>();
gameResultViewModelBuilder.Expect(build => build.Build(playerGameResults[0]))
.Repeat
.Once()
.Return(new Models.PlayedGame.GameResultViewModel()
{
PlayedGameId = playerGameResults[0].PlayedGameId
});
gameResultViewModelBuilder.Expect(build => build.Build(playerGameResults[1]))
.Repeat
.Once()
.Return(new Models.PlayedGame.GameResultViewModel()
{
PlayedGameId = playerGameResults[1].PlayedGameId
});
foreach (var player in playerDetails.Minions)
{
minionViewModelBuilderMock.Expect(mock => mock.Build(player))
.Return(new MinionViewModel()
{
MinionPlayerId = player.Id
});
}
var championedGames = new List <Champion>
{
new Champion {
GameDefinition = gameDefinition1, GameDefinitionId = gameDefinitionIdThatIsChampionedByCurrentPlayer
},
new Champion {
GameDefinition = gameDefinitionThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer, GameDefinitionId = gameDefinitionIdThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
}
};
playerDetails.ChampionedGames = championedGames;
var formerChampionedGames = new List <GameDefinition>
{
gameDefinitionThatIsFormerlyChampionedByCurrentPlayer,
gameDefinitionThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
};
playerDetails.FormerChampionedGames = formerChampionedGames;
builder = new PlayerDetailsViewModelBuilder(gameResultViewModelBuilder, minionViewModelBuilderMock, mapperFactory);
playerDetailsViewModel = builder.Build(playerDetails, twitterMinionBraggingUrl, currentUser);
}
public void TestFixtureSetUp()
{
AutomapperConfiguration.Configure();
minionViewModelBuilderMock = MockRepository.GenerateMock<IMinionViewModelBuilder>();
mapperFactory = MockRepository.GenerateStub<IMapperFactory>();
currentUser = new ApplicationUser()
{
CurrentGamingGroupId = gamingGroupId,
Id = "application user id"
};
var gameDefinition1 = new GameDefinition()
{
Name = "test game 1",
Id = gameDefinitionIdThatIsChampionedByCurrentPlayer,
};
gameDefinitionThatIsFormerlyChampionedByCurrentPlayer = new GameDefinition
{
Name = "formerly championed game",
Id = gameDefinitionIdThatIsFormerlyChampionedByCurrentPlayer
};
gameDefinitionThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer = new GameDefinition
{
Name = "currently and formerly championed game",
Id = gameDefinitionIdThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
};
var playedGame1 = new PlayedGame()
{
Id = 1,
GameDefinition = gameDefinition1
};
var playedGame2 = new PlayedGame()
{
Id = 2,
GameDefinitionId = gameDefinitionIdThatIsFormerlyChampionedByCurrentPlayer
};
var playerGameResults = new List<PlayerGameResult>()
{
new PlayerGameResult(){ PlayedGameId = 12, PlayedGame = playedGame1 },
new PlayerGameResult(){ PlayedGameId = 13, PlayedGame = playedGame2 }
};
normalPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "Jim",
OpposingPlayerId = 1,
OpposingPlayerActive = false,
NumberOfGamesWonVersusThisPlayer = 10,
NumberOfGamesLostVersusThisPlayer = 10
};
playerWithNoGamesPlayed = new PlayerVersusPlayerStatistics
{
OpposingPlayerId = 2
};
minionPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "Minion Player",
OpposingPlayerId = 5,
NumberOfGamesWonVersusThisPlayer = 20,
NumberOfGamesLostVersusThisPlayer = 0
};
nemesisPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "nemesis player",
OpposingPlayerId = 3,
NumberOfGamesWonVersusThisPlayer = 0,
NumberOfGamesLostVersusThisPlayer = 100
};
previousNemesisPlayer = new PlayerVersusPlayerStatistics
{
OpposingPlayerName = "Previous Nemesis Player",
OpposingPlayerId = 13,
NumberOfGamesWonVersusThisPlayer = 0,
NumberOfGamesLostVersusThisPlayer = 42
};
var nemesis = new Nemesis()
{
NemesisPlayerId = nemesisPlayer.OpposingPlayerId,
NumberOfGamesLost = 3,
LossPercentage = 75,
NemesisPlayer = new Player()
{
Name = "Ace Nemesis",
}
};
var previousNemesis = new Nemesis()
{
NemesisPlayerId = previousNemesisPlayer.OpposingPlayerId,
NumberOfGamesLost = 5,
LossPercentage = 66,
NemesisPlayer = new Player()
{
Name = "Bravo Nemesis",
}
};
playerDetails = new PlayerDetails()
{
Id = playerId,
ApplicationUserId = currentUser.Id,
Active = true,
Name = "Skipper",
LongestWinningStreak = 39,
PlayerGameResults = playerGameResults,
PlayerStats = new PlayerStatistics()
{
TotalGames = 5,
NemePointsSummary = new NemePointsSummary(1, 3, 5),
AveragePlayersPerGame = 3,
TotalGamesLost = 1,
TotalGamesWon = 4,
WinPercentage = 20
},
CurrentNemesis = nemesis,
PreviousNemesis = previousNemesis,
Minions = new List<Player>
{
new Player
{
Id = minionPlayer.OpposingPlayerId
}
},
GamingGroupId = gamingGroupId,
GamingGroupName = "gaming group name",
PlayerVersusPlayersStatistics = new List<PlayerVersusPlayerStatistics>
{
normalPlayer,
playerWithNoGamesPlayed,
nemesisPlayer,
previousNemesisPlayer,
minionPlayer
},
PlayerGameSummaries = new List<PlayerGameSummary>
{
new PlayerGameSummary
{
GameDefinitionId = gameDefinitionIdThatIsChampionedByCurrentPlayer
},
new PlayerGameSummary
{
GameDefinitionId = gameDefinitionIdThatIsFormerlyChampionedByCurrentPlayer
},
new PlayerGameSummary
{
GameDefinitionId = gameDefinitionIdThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
}
},
NemePointsSummary = new NemePointsSummary(1, 3, 5)
};
gameResultViewModelBuilder
= MockRepository.GenerateMock<IGameResultViewModelBuilder>();
gameResultViewModelBuilder.Expect(build => build.Build(playerGameResults[0]))
.Repeat
.Once()
.Return(new Models.PlayedGame.GameResultViewModel() { PlayedGameId = playerGameResults[0].PlayedGameId });
gameResultViewModelBuilder.Expect(build => build.Build(playerGameResults[1]))
.Repeat
.Once()
.Return(new Models.PlayedGame.GameResultViewModel() { PlayedGameId = playerGameResults[1].PlayedGameId });
foreach (var player in playerDetails.Minions)
{
minionViewModelBuilderMock.Expect(mock => mock.Build(player))
.Return(new MinionViewModel() { MinionPlayerId = player.Id });
}
var championedGames = new List<Champion>
{
new Champion { GameDefinition = gameDefinition1, GameDefinitionId = gameDefinitionIdThatIsChampionedByCurrentPlayer },
new Champion { GameDefinition = gameDefinitionThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer, GameDefinitionId = gameDefinitionIdThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer }
};
playerDetails.ChampionedGames = championedGames;
var formerChampionedGames = new List<GameDefinition>
{
gameDefinitionThatIsFormerlyChampionedByCurrentPlayer,
gameDefinitionThatIsBothCurrentlyAndFormerlyChampionedByCurrentPlayer
};
playerDetails.FormerChampionedGames = formerChampionedGames;
builder = new PlayerDetailsViewModelBuilder(gameResultViewModelBuilder, minionViewModelBuilderMock, mapperFactory);
playerDetailsViewModel = builder.Build(playerDetails, twitterMinionBraggingUrl, currentUser);
}
private static void ValidateNotADuplicateGameDefinition(GameDefinition existingGameDefinition)
{
if (existingGameDefinition.Active)
{
string message = $"An active Game Definition with name '{existingGameDefinition.Name}' already exists in this Gaming Group.";
throw new DuplicateKeyException(message);
}
}
public virtual void BaseSetUp()
{
autoMocker = new RhinoAutoMocker<PlayerRetriever>();
autoMocker.PartialMockTheClassUnderTest();
const int CHAMPION_ID = 55;
gameDefinition = new GameDefinition
{
Name = "game name",
ChampionId = CHAMPION_ID
};
var playerId = 1;
var champion = new Champion
{
Id = CHAMPION_ID,
GameDefinition = gameDefinition,
PlayerId = playerId
};
playerGameResultsForFirstPlayer = new List<PlayerGameResult>()
{
new PlayerGameResult
{
GameRank = 2,
NemeStatsPointsAwarded = 10,
PlayedGame = new PlayedGame
{
DatePlayed = new BasicDateRangeFilter().FromDate
}
},
new PlayerGameResult
{
GameRank = 1,
NemeStatsPointsAwarded = 20,
PlayedGame = new PlayedGame
{
DatePlayed = new BasicDateRangeFilter().ToDate
}
}};
playerChampionshipsForFirstPlayer = new List<Champion>
{
champion
};
List<Player> players = new List<Player>()
{
new Player(){ GamingGroupId = gamingGroupId, Name = "2", PlayerGameResults = new List<PlayerGameResult>(), ChampionedGames = new List<Champion>()},
new Player(){ GamingGroupId = gamingGroupId, Name = "3", PlayerGameResults = new List<PlayerGameResult>(), ChampionedGames = new List<Champion>() },
new Player(){ GamingGroupId = -1, Name = "not in gaming group", PlayerGameResults = new List<PlayerGameResult>(), ChampionedGames = new List<Champion>() },
new Player()
{
Id = playerId,
GamingGroupId = gamingGroupId,
Name = "1",
PlayerGameResults = playerGameResultsForFirstPlayer,
ChampionedGames = new List<Champion>
{
champion
}
},
new Player()
{
//player that will be last because she's inactive
GamingGroupId = gamingGroupId, Name = "0", PlayerGameResults = new List<PlayerGameResult>(), ChampionedGames = new List<Champion>(), Active = false
}
};
players[3].NemesisId = 1;
players[3].Nemesis = new Nemesis()
{
NemesisPlayerId = 2,
NemesisPlayer = new Player() { Id = 93995 }
};
playerQueryable = players.AsQueryable<Player>();
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<Player>())
.Return(playerQueryable);
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<GameDefinition>())
.Return(
new List<GameDefinition>
{ gameDefinition }.AsQueryable());
var playerAchievement =
new PlayerAchievement
{
DateCreated = DateTime.UtcNow,
LastUpdatedDate = DateTime.UtcNow,
PlayerId = playerId,
AchievementLevel = AchievementLevel.Bronze,
AchievementId = AchievementId.BusyBee
};
autoMocker.Get<IDataContext>().Expect(mock => mock.GetQueryable<PlayerAchievement>())
.Return(new List<PlayerAchievement> { playerAchievement }.AsQueryable());
}
private void AttachToBoardGameGeekGameDefinition(int? boardGameGeekGameDefinitionId, ApplicationUser currentUser, GameDefinition gameDefinition)
{
if (!boardGameGeekGameDefinitionId.HasValue)
{
return;
}
var newlyCreatedBoardGameGeekGameDefinition = CreateBoardGameGeekGameDefinition(
boardGameGeekGameDefinitionId.Value,
currentUser);
if (newlyCreatedBoardGameGeekGameDefinition != null)
{
gameDefinition.BoardGameGeekGameDefinitionId = newlyCreatedBoardGameGeekGameDefinition.Id;
}
}
public void ItSetsTheGamingGroupIdIfItIsASecuredEntityThatIsntAlreadyInTheDatabaseAndTheGamingGroupIdIsntAlreadySet()
{
var gameDefinition = new GameDefinition();
var securedEntityValidator = MockRepository.GenerateMock<ISecuredEntityValidator>();
securedEntityValidatorFactory.Expect(mock => mock.MakeSecuredEntityValidator<GameDefinition>(dataContext))
.IgnoreArguments()
.Return(securedEntityValidator);
securedEntityValidator.Expect(mock => mock.ValidateAccess<GameDefinition>(null, null)).IgnoreArguments();
dataContext.Expect(mock => mock.AddOrInsertOverride(gameDefinition))
.Repeat.Once()
.Return(gameDefinition);
dataContext.Save(gameDefinition, currentUser);
dataContext.AssertWasCalled(mock => mock.AddOrInsertOverride(
Arg<GameDefinition>.Matches(entity => entity.GamingGroupId == currentUser.CurrentGamingGroupId)));
}
