private void UpdateArenas(SkinContent skinContent, dynamic navigationPlanElement)
{
var arenasElement = navigationPlanElement.arenas;
var existingArenasElements = ((System.Collections.IEnumerable)arenasElement).Cast <dynamic>().ToArray();
var newAreansElements = new JArray();
foreach (var arena in skinContent.Arenas)
{
foreach (var arenaLayout in arena.Layouts)
{
newAreansElements.Add(CreateArenaElement(existingArenasElements, arena, arenaLayout));
}
}
foreach (var lobby in skinContent.Lobbies)
{
newAreansElements.Add(CreateLobbyArenaElement(lobby, skinContent.Arenas));
}
navigationPlanElement.arenas = newAreansElements;
}
/// <summary>
/// The refresh model
/// </summary>
private void RefreshModel()
{
if (this.ModelMesh.InternalModel == null)
{
return;
}
this.meshContent = this.ModelMesh.MeshContent;
this.meshes = this.ModelMesh.MeshContent?.MeshParts?.Select(mp => (mp as SkinnedMesh)?.Clone()).ToArray();
this.rootInverseBindPose = Matrix.Identity;
if (this.meshContent.Skin >= 0)
{
this.skin = this.ModelMesh.InternalModel?.Skins[this.meshContent.Skin];
for (int i = 0; i < this.skin.Joints.Length; i++)
{
if (this.skin.RootJoint == this.skin.Joints[i].NodeId)
{
this.rootInverseBindPose = this.skin.Joints[i].InverseBindPose;
break;
}
}
Array.Resize(ref this.skinMatrices, this.skin.Joints.Length);
for (int i = 0; i < this.skinMatrices.Length; i++)
{
this.skinMatrices[i] = Matrix.Identity;
}
}
this.shouldSkinMeshes = true;
this.rootJointChanged = true;
}
private void UpdateArenas(SkinContent layout)
{
var existingArenasXmlElements = lobby_data_ndl.Element(XmlNames.arenas).Elements(XmlNames.arena).ToArray();
var newAreansXmlElements = new List <XNode>();
foreach (var arena in layout.Arenas)
{
foreach (var arenaLayout in arena.Layouts)
{
newAreansXmlElements.Add(new XComment(arena.Name));
newAreansXmlElements.Add(CreateArenaXmlElement(existingArenasXmlElements, arena, arenaLayout));
}
}
foreach (var lobby in layout.Lobbies)
{
newAreansXmlElements.Add(CreateLobbyArenaXmlElement(existingArenasXmlElements, lobby, layout.Arenas));
}
var arenasXmlElement = lobby_data_ndl.Element(XmlNames.arenas);
var arenasXmlElementAttributes = arenasXmlElement.Attributes().ToArray();
arenasXmlElement.ReplaceAll(newAreansXmlElements.ToArray());
arenasXmlElement.Add(arenasXmlElementAttributes);
}
private SkinContent ReadSkinContent(SkinDefinitionContext skinDefinitionContext)
{
SkinContent layout = new SkinContent();
FillSkinContent(layout, skinDefinitionContext);
return(layout);
}
private void LoadAvailableGames(int brandId, SkinContent layout, IEnumerable <Game> availableGames)
{
var gamesInfo = _serviceLocator.GetInstance <IGamesInformationProvider>()
.GetGamesInfo(brandId)
.ToDictionary(g => g.GameType);
LoadExistingClientGames(layout, availableGames, gamesInfo);
LoadAllOtherGames(gamesInfo);
}
private void FillSkinContent(SkinContent skinContent, SkinDefinitionContext skinDefinitionContext)
{
FillArenasCollection(skinContent.Arenas, skinDefinitionContext);
FillLobbyCollection(skinContent.Lobbies, skinDefinitionContext);
FillGamesGroupCollection(skinContent.TopGames, skinDefinitionContext, XmlNames.topGames, XmlNames.topGame);
FillGamesGroupCollection(skinContent.VipTopGames, skinDefinitionContext, XmlNames.vipGames, XmlNames.vipGame);
FillMyAccountCollection(skinContent.MyAccountLobby, XmlValues.lobby);
FillMyAccountCollection(skinContent.MyAccountHistory, XmlValues.history);
FillTriggers(skinContent.Triggers);
}
private void FillSkinContent(SkinContent skinContent, SkinDefinitionContext skinDefinitionContext)
{
FillArenasCollection(skinContent.Arenas, skinDefinitionContext);
FillLobbyCollection(skinContent.Lobbies, skinDefinitionContext);
FillGamesGroupCollection(skinContent.TopGames, skinDefinitionContext, _navigationPlanJson.navigationPlan.topGames);
FillGamesGroupCollection(skinContent.VipTopGames, skinDefinitionContext, _navigationPlanJson.navigationPlan.vipGames);
FillMyAccountCollection(skinContent.MyAccountLobby, _navigationPlanJson.navigationPlan.menus.lobby);
FillMyAccountCollection(skinContent.MyAccountHistory, _navigationPlanJson.navigationPlan.menus.history);
FillTriggers(skinContent.Triggers);
}
private SkinContent ReadSkinContent(SkinDefinitionContext skinDefinitionContext)
{
if (_navigationPlanXml == null)
{
return(null);
}
SkinContent layout = new SkinContent();
FillSkinContent(layout, skinDefinitionContext);
return(layout);
}
private void LoadMyAccount(SkinContent skin)
{
var myAccountViewModel = new MyAccountViewModel();
LoadMyAccountCollection(skin.MyAccountLobby, myAccountViewModel.Lobby);
LoadMyAccountCollection(skin.MyAccountHistory, myAccountViewModel.History);
foreach (var item in myAccountViewModel.Lobby.Union(myAccountViewModel.History).Distinct().OrderBy(item => item.Name))
{
myAccountViewModel.AllMyAccountItems.Add(item);
}
_skinDefinition.MyAccount = myAccountViewModel;
}
/// <summary>
/// Loads this class with data from a stream.
/// </summary>
/// <param name="graphicsDevice">The graphicsDevice device.</param>
/// <param name="stream">The stream that contains the model data.</param>
public void Load(GraphicsDevice graphicsDevice, Stream stream)
{
this.graphics = graphicsDevice;
using (var reader = new BinaryReader(stream))
{
// Model Bounding Box
this.BoundingBox.Min = reader.ReadVector3();
this.BoundingBox.Max = reader.ReadVector3();
// Materials
int materialCount = reader.ReadInt32();
this.Materials = new List <string>();
for (int i = 0; i < materialCount; i++)
{
string materialName = reader.ReadString();
this.Materials.Add(materialName);
}
// Meshes
int meshCount = reader.ReadInt32();
this.Meshes = new MeshContent[meshCount];
for (int i = 0; i < meshCount; i++)
{
this.Meshes[i] = MeshContent.Read(reader);
}
// Skins
int skinCount = reader.ReadInt32();
this.Skins = new SkinContent[skinCount];
for (int i = 0; i < skinCount; i++)
{
this.Skins[i] = SkinContent.Read(reader);
}
this.ReadNodes(reader);
// Animations
int animationsCount = reader.ReadInt32();
this.Animations = new Dictionary <string, AnimationClip>();
for (int i = 0; i < animationsCount; i++)
{
var animation = AnimationClip.Read(reader);
this.Animations[animation.Name] = animation;
}
}
}
private void LoadExistingClientGames(SkinContent layout, IEnumerable <Game> availableGames, Dictionary <int, GameInfo> gamesInfo)
{
var uniqueAvailableGames = layout.Arenas.SelectMany(a => a.Layouts.SelectMany(l => l.Games))
.GroupBy(g => g.GameType)
.ToDictionary(g => g.Key, g => new AvailableGameViewModel(g.Key,
g.First().Name,
ExtractGameProperty(gamesInfo, g.Key, item => item.GameGroup),
g.Select(item => item.NewGame).Where(item => item == true).FirstOrDefault(),
g.Max(item => item.UserMode),
ExtractGameProperty(gamesInfo, g.Key, item => item.IsApproved),
ExtractGameProperty(gamesInfo, g.Key, item => item.VendorName),
ExtractGameProperty(gamesInfo, g.Key, item => item.JackpotIds),
_serviceLocator));
_existingClientGames = new List <AvailableGameViewModel>();
foreach (var game in availableGames.OrderBy(g => g.Name))
{
if (uniqueAvailableGames.ContainsKey(game.Id))
{
_existingClientGames.Add(uniqueAvailableGames[game.Id]);
}
else
{
_existingClientGames.Add(new AvailableGameViewModel(game.Id,
game.Name,
ExtractGameProperty(gamesInfo, game.Id, item => item.GameGroup),
false,
UserModes.Both,
ExtractGameProperty(gamesInfo, game.Id, item => item.IsApproved),
ExtractGameProperty(gamesInfo, game.Id, item => item.VendorName),
ExtractGameProperty(gamesInfo, game.Id, item => item.JackpotIds),
_serviceLocator));
}
}
}
private void UpdateMyAccount(SkinContent skinContent, dynamic navigationPlanJson)
{
navigationPlanJson.navigationPlan.menus.lobby = GenerateMyAccountSection(skinContent.MyAccountLobby);
navigationPlanJson.navigationPlan.menus.history = GenerateMyAccountSection(skinContent.MyAccountHistory);
}
private void UpdateMyAccount(SkinContent skinContent)
{
UpdateMyAccountSection(XmlValues.lobby, skinContent.MyAccountLobby);
UpdateMyAccountSection(XmlValues.history, skinContent.MyAccountHistory);
}
