/// <summary>
/// Test supplementary scales (via LevelParser). Alternative for TestSupplementaryScales method above.
/// </summary>
/// <param name="headerformat">Report header format.</param>
/// <param name="input">Input level to parse.</param>
/// <remarks>
/// LevelParser is used here to get levels directly (and not via intermediate quantity as in
/// TestSupplementaryScales above). On the other hand, if you also need to input quantities
/// (e.g. temperature increase) then you will have to apply QuantityParser in addition (meaning
/// two methods instead of one).
/// </remarks>
static void TestSupplementaryScalesWithLevelParser(string headerformat, string input)
{
Console.WriteLine();
Console.WriteLine(headerformat, input);
var parser = new LevelParser <double>(Kelvin.Family);
ILevel <double> temperature;
if (!parser.TryParse(input, out temperature))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("{0}: invalid number or unit other than any of the following: {1}.", input, string.Join(", ", parser.Scales.Select(s => s.Unit.Symbol.ToString())));
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
int i = 0;
foreach (var scale in parser.Scales)
{
string scaleinfo = string.Format("{0,2}. {1}", ++i, scale);
ILevel <double> output = scale.From(temperature);
Console.WriteLine("{0,-40} {1} -> {2}", scaleinfo, input, output);
}
}
Console.ResetColor();
}
public void TestParseCustomLevelPlatformEnemy()
{
List <string> columns = new List <string>()
{
"--------------------------------------A-----------------"
};
List <string> result = LevelParser.BreakColumnsIntoSimplifiedTokens(columns, Games.Custom);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[0]);
columns.Add("------------------------------------Bbb-----------------");
result = LevelParser.BreakColumnsIntoSimplifiedTokens(columns, Games.Custom);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[0]);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[1]);
columns.Add("-------------------------------------bbb---------------C");
result = LevelParser.BreakColumnsIntoSimplifiedTokens(columns, Games.Custom);
Assert.AreEqual(3, result.Count);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[0]);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[1]);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[2]);
columns.Add("---------------------------------------------Ab---------");
result = LevelParser.BreakColumnsIntoSimplifiedTokens(columns, Games.Custom);
Assert.AreEqual(4, result.Count);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[0]);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[1]);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[2]);
Assert.AreEqual(SimplifiedColumns.PlatformForcedEnemy, result[3]);
}
public void UpdateChallengePreview()
{
Vector2 indexes = LevelParser.GetLevelPackLevelIndexes(LevelLoader.GetLevelName());
ChallengeLog challengeLog = ChallengeManager.GetCurrentChallengeLog((int)indexes.x, (int)indexes.y);
challengePreview.SetLevelChallengePreview(challengeLog, LevelLoader.GetLevelName());
}
public ClearReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var key = new CharaLevelPair(chara, level);
if (parent.allScoreData.Rankings.ContainsKey(key))
{
var stageProgress =
parent.allScoreData.Rankings[key].Max(rank => rank.StageProgress);
if (stageProgress == StageProgress.Extra)
{
return("Not Clear");
}
else
{
return(stageProgress.ToShortName());
}
}
else
{
return(StageProgress.None.ToShortName());
}
});
}
public PracticeReplacer(Th10Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = (CharaWithTotal)CharaParser.Parse(match.Groups[2].Value);
var stage = StageParser.Parse(match.Groups[3].Value);
if (level == Level.Extra)
{
return(match.ToString());
}
if (stage == Stage.Extra)
{
return(match.ToString());
}
if (parent.allScoreData.ClearData.ContainsKey(chara))
{
var key = new LevelStagePair(level, stage);
var practices = parent.allScoreData.ClearData[chara].Practices;
return(practices.ContainsKey(key)
? Utils.ToNumberString(practices[key].Score * 10) : "0");
}
else
{
return("0");
}
});
}
public void LoadLevel()
{
Dictionary <string, GameObject> mapping = new Dictionary <string, GameObject>();
foreach (GameObject m in typeMappings)
{
mapping[m.name] = m;
}
LevelParser l = new LevelParser();
string objectsFile = "Assets/Levels/" + levels[currentLevel].levelName + "_Objects.csv";
string platformFile = "Assets/Levels/" + levels[currentLevel].levelName + "_Platform.csv";
string floorFile = "Assets/Levels/" + levels[currentLevel].levelName + "_Floor.csv";
Level level = l.ParseLevelFile(objectsFile, floorFile, platformFile, tilesetFile);
Bounds allBounds = SpawnSet(level.floor, floorContainer.transform, mapping);
SpawnSet(level.objects, objectsContainer, mapping);
SpawnSet(level.platform, platformContainer, mapping);
platformContainer.transform.position = -allBounds.center + Vector3.up * platformContainer.transform.position.y;
objectsContainer.transform.position = -allBounds.center + Vector3.up * objectsContainer.transform.position.y;
floorContainer.transform.position = -allBounds.center + Vector3.up * floorContainer.transform.position.y;
Physics.SyncTransforms();
floorContainer.UpdateBounds();
historianManager.LoadHistorians();
historianManager.Record();
}
public PracticeReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var stage = StageParser.Parse(match.Groups[3].Value);
if (level == Level.Extra)
{
return(match.ToString());
}
if (stage == Stage.Extra)
{
return(match.ToString());
}
var key = new CharaLevelPair(chara, level);
if (parent.allScoreData.PracticeScores.ContainsKey(key))
{
var scores = parent.allScoreData.PracticeScores[key];
return(scores.ContainsKey(stage)
? Utils.ToNumberString(scores[stage].HighScore) : "0");
}
else
{
return("0");
}
});
}
private Tuple <List <string>, List <string> > GetColumnsSemiGuaranteed(ICompiledGram compiled, ICompiledGram simpleCompiled)
{
List <string> columns;
List <string> simplified;
if (simplifiedGram == null)
{
columns = NGramGenerator.Generate(compiled, startInput, size, includeStart: false);
simplified = LevelParser.BreakColumnsIntoSimplifiedTokens(
columns,
game);
}
else
{
simplified = NGramGenerator.GenerateBestAttempt(
simpleCompiled,
LevelParser.BreakColumnsIntoSimplifiedTokens(startInput, game),
size,
maxAttempts);
Games localGame = game;
columns = NGramGenerator.GenerateRestricted(
compiled,
startInput,
simplified,
(inColumn) =>
{
return(LevelParser.ClassifyColumn(inColumn, localGame));
},
includeStart: false);
}
return(new Tuple <List <string>, List <string> >(columns, simplified));
}
public ScoreReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var rank = Utils.ToZeroBased(
int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
var type = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture);
var key = new CharaLevelPair(chara, level);
var score = parent.allScoreData.Rankings.ContainsKey(key)
? parent.allScoreData.Rankings[key][rank] : InitialRanking[rank];
switch (type)
{
case 1: // name
return(Encoding.Default.GetString(score.Name).Split('\0')[0]);
case 2: // score
return(Utils.ToNumberString(score.Score));
case 3: // stage
return(score.StageProgress.ToShortName());
default: // unreachable
return(match.ToString());
}
});
}
private void Start()
{
//Camera.main.transparencySortMode = TransparencySortMode.Orthographic;
levelParser = GetComponent <LevelParser>();
levelData = levelParser.LoadLevelFromFile();
currBlock = 0;
currScrollSpeed = normalScrollSpeed;
bottomBlock = GenLoadedLevelBlock(currBlock, new Vector2(0f, 0f), currScrollSpeed, 0.5f, 20f);
topBlock = GenLoadedLevelBlock(currBlock + 1, new Vector2(0f, 10f), currScrollSpeed, 0f, 20f);
currBlock++;
//bottomBlock = CreateLevelBlock(new Vector2(0f, 0f), currScrollSpeed, 0.5f, 20f,
// new List<Vector2>() { new Vector2(3.5f, 0) },
// new List<Vector2>() { new Vector2(-9f, 3) },
// new List<Vector2>() { new Vector2(3.5f, -2f), new Vector2(-3.5f, -2f) },
// backgroundTex[0]);
//topBlock = CreateLevelBlock(new Vector2(0f, 10f), currScrollSpeed, 0f, 20f,
// new List<Vector2>() { new Vector2(3.5f, 0) },
// new List<Vector2>() { new Vector2(-9f, 3) },
// new List<Vector2>() { new Vector2(3.5f, -2f), new Vector2(-3.5f, -2f) },
// backgroundTex[0]);
character.boundary = screenBoundary;
character.PeakTouched += OnCenteringBegin;
character.CenteringEnd += OnCenteringEnd;
//OnPhaseChange
centering = false;
StartCoroutine(CheckLevelEndCoroutine());
}
public CardReplacer(Th095Converter parent, bool hideUntriedCards)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var scene = int.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
var type = int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture);
var key = new LevelScenePair(level, scene);
if (!SpellCards.ContainsKey(key))
{
return(match.ToString());
}
if (hideUntriedCards)
{
var score = parent.allScoreData.Scores.Find(
elem => (elem != null) && elem.LevelScene.Equals(key));
if (score == null)
{
return("??????????");
}
}
return((type == 1) ? SpellCards[key].Enemy.ToLongName() : SpellCards[key].Card);
});
}
public void InitializeGameState()
{
backGroundImage = new Entity(
new StationaryShape(new Vec2F(0.0f, 0.0f), new Vec2F(1.0f, 1.0f)),
new Image(Path.Combine("Assets", "Images", "SpaceBackground.png")));
titel = new Text("Select Level", new Vec2F(0f, 0.4f), new Vec2F(1f, 0.4f));
titel.SetColor(new Vec3F(1f, 1f, 0f));
titel.SetFontSize(65);
maxMenuButtons = LevelParser.GetInstance().LevelNames.Length + 1;
menuButtons = new Text[maxMenuButtons];
activeMenuButton = 2;
for (int i = 0; i < maxMenuButtons - 1; i++)
{
var levelName = LevelParser.GetInstance().LevelNames[i];
var text = new Text(levelName,
new Vec2F(0.3f, i * 0.1f + 0.2f), new Vec2F(0.8f, 0.4f));
text.SetColor(new Vec3F(1.0f, 1.0f, 1.0f));
text.SetFontSize(20);
menuButtons[maxMenuButtons - i - 2] = text;
}
menuButtons[maxMenuButtons - 1] =
new Text("Return", new Vec2F(0.3f, -0.2f), new Vec2F(0.8f, 0.4f));
menuButtons[activeMenuButton].SetColor(new Vec3F(0.0f, 1.0f, 0.0f));
}
private void UpdateDifficultyNGram()
{
Vector3 playerPosition = blackBoard.LevelInfo.Player.transform.position;
int toRight = blackBoard.ConfigUI.Config.DifficultyNGramRightColumns;
int toLeft = blackBoard.ConfigUI.Config.DifficultyNGramLeftColumns;
Tilemap tilemap = blackBoard.Tilemap;
Vector3Int tilePosition = tilemap.WorldToCell(playerPosition);
int x = Math.Max(tilePosition.x - toLeft, tilemap.cellBounds.xMin);
int xMax = Math.Min(tilePosition.x + toRight, tilemap.cellBounds.xMax - 1);
blackBoard.DifficultyNGram.UpdateMemory(blackBoard.ConfigUI.Config.DifficultyNGramMemoryUpdate);
List <string> difficultPart = blackBoard.LevelColumns.GetRange(x, xMax - x + 1);
NGramTrainer.Train(blackBoard.DifficultyNGram, difficultPart);
if (blackBoard.ConfigUI.Config.UsingSimplifiedNGram)
{
blackBoard.SimpleDifficultyNGram.UpdateMemory(blackBoard.ConfigUI.Config.DifficultyNGramMemoryUpdate);
NGramTrainer.Train(
blackBoard.SimpleDifficultyNGram,
LevelParser.BreakColumnsIntoSimplifiedTokens(
difficultPart,
blackBoard.ConfigUI.Config.Game));
}
}
public ClearReplacer(Th09Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var type = int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture);
var count = parent.allScoreData.PlayStatus.ClearCounts[chara].Counts[level];
if (type == 1)
{
return(Utils.ToNumberString(count));
}
else
{
if (count > 0)
{
return("Cleared");
}
else
{
var score = parent.allScoreData.Rankings[new CharaLevelPair(chara, level)][0];
var date = Encoding.Default.GetString(score.Date).TrimEnd('\0');
return((date != "--/--") ? "Not Cleared" : "-------");
}
}
});
}
public ScoreReplacer(Th09Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var rank = Utils.ToZeroBased(
int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
var type = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture);
var score = parent.allScoreData.Rankings[new CharaLevelPair(chara, level)][rank];
var date = string.Empty;
switch (type)
{
case 1: // name
return(Encoding.Default.GetString(score.Name).Split('\0')[0]);
case 2: // score
return(Utils.ToNumberString((score.Score * 10) + score.ContinueCount));
case 3: // date
date = Encoding.Default.GetString(score.Date).Split('\0')[0];
return((date != "--/--") ? date : "--/--/--");
default: // unreachable
return(match.ToString());
}
});
}
public void SetLevelChallengePreview(ChallengeLog challengeLog, string levelName)
{
int challengeCount = challengeLog?.GetChallengeCount() ?? 0;
if (challengeCount <= 0)
{
noChallengeText.gameObject.SetActive(true);
challengeParent.SetActive(false);
}
else
{
noChallengeText.gameObject.SetActive(false);
challengeParent.SetActive(true);
if (packIndex == -1 || levelIndex == -1)
{
Vector2 indexes = LevelParser.GetLevelPackLevelIndexes(levelName);
packIndex = (int)indexes.x;
levelIndex = (int)indexes.y;
}
for (int i = 0; i < challengeEntries.Count; i++)
{
if (i <= challengeCount - 1)
{
challengeEntries[i].gameObject.SetActive(true);
challengeEntries[i].UpdateChallengeEntry(challengeLog.GetChallengeData(i), packIndex, levelIndex);
}
else
{
challengeEntries[i].gameObject.SetActive(false);
}
}
}
}
public void LevelParser_ExtractHighscores_checkReturnsList()
{
ctrl.SaveFile();
ctrl.LoadFile();
List <int> actual = new LevelParser().ExtractHighscores();
Assert.IsInstanceOfType(actual, List <int>);
}
public void LevelParser_ExtractLevelHeight_checkReturnsInt()
{
ctrl.SaveFile();
ctrl.LoadFile();
Int32 actual = new LevelParser().ExtractLevelHeight();
Assert.IsInstanceOfType(actual, Int32);
}
public void LevelParser_ExtractLevelDifficulty_checkReturnsString()
{
ctrl.SaveFile();
ctrl.LoadFile();
string actual = new LevelParser().ExtractLevelDifficulty();
Assert.IsInstanceOfType(actual, String);
}
public void LevelParser_ExtractLevelDateTime_checkReturnsDate()
{
ctrl.SaveFile();
ctrl.LoadFile();
DateTime actual = new LevelParser().ExtractLevelDateTime();
Assert.IsInstanceOfType(actual, DateTime);
}
public void TestParse6()
{
var parser = new LevelParser();
int length;
parser.Parse("FATAL", 0, out length).Should().Be(LevelFlags.Fatal);
length.Should().Be(5);
}
public void Initialize()
{
var levelNo = _contexts.game.level.LevelNo;
var selectedLevel = LevelParser.ParseLevel(levelNo);
SpawnLevel(selectedLevel);
}
public void TestParse4()
{
var parser = new LevelParser();
int length;
parser.Parse("WARNING", 0, out length).Should().Be(LevelFlags.Warning);
length.Should().Be(7);
}
public void TestParse2()
{
var parser = new LevelParser();
int length;
parser.Parse("DEBUG", 0, out length).Should().Be(LevelFlags.Debug);
length.Should().Be(5);
}
public void TestParse5()
{
var parser = new LevelParser();
int length;
parser.Parse("ERROR", 0, out length).Should().Be(LevelFlags.Error);
length.Should().Be(5);
}
public void TestParse1()
{
var parser = new LevelParser();
int length;
parser.Parse("TRACE", 0, out length).Should().Be(LevelFlags.Trace);
length.Should().Be(5);
}
public void TestParse3()
{
var parser = new LevelParser();
int length;
parser.Parse("DEBUG INFO", 6, out length).Should().Be(LevelFlags.Info);
length.Should().Be(4);
}
public static void Initialize()
{
tileMaps = LoadTileMaps();
tileSets = TileSetParser.LoadTileSets(tileMaps);
levelList = LevelParser.LoadLevelList();
cachedLevelsInfo = new Dictionary <int, LevelInfo>();
currentLevelId = -1;
}
private void GenerateNGram()
{
if (blackBoard.ConfigUI.Config.HeiarchalEnabled)
{
grammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.HeiarchalMemory);
simpleGrammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.HeiarchalMemory);
}
else if (blackBoard.ConfigUI.Config.BackOffEnabled)
{
grammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.BackOffMemory);
simpleGrammar = NGramFactory.InitHierarchicalNGram(
blackBoard.ConfigUI.Config.N,
blackBoard.ConfigUI.Config.BackOffMemory);
}
else
{
grammar = NGramFactory.InitGrammar(blackBoard.ConfigUI.Config.N);
simpleGrammar = NGramFactory.InitGrammar(blackBoard.ConfigUI.Config.N);
}
for (int i = 0; i <= blackBoard.ProgressIndex; ++i)
{
if (blackBoard.ConfigUI.Config.UsingTieredGeneration || blackBoard.ProgressIndex == i)
{
JsonObject tierInfo = blackBoard.GameFlow[i].AsJsonObject;
JsonArray tierLevels = tierInfo[FlowKeys.LevelNames].AsJsonArray;
foreach (string levelName in tierLevels)
{
List <string> columns = LevelParser.BreakMapIntoColumns(levelName);
columns.RemoveAt(columns.Count - 1); // remove flag at the end
List <string> simpleColumns = LevelParser.BreakColumnsIntoSimplifiedTokens(
columns,
blackBoard.ConfigUI.Config.Game);
levelColumns.Add(columns);
simplifiedLevelColumns.Add(simpleColumns);
NGramTrainer.Train(grammar, columns, skipFirst: true);
NGramTrainer.Train(simpleGrammar, simpleColumns, skipFirst: true);
if (blackBoard.ProgressIndex != i)
{
grammar.UpdateMemory(blackBoard.ConfigUI.Config.TieredGenerationMemoryUpdate);
levelColumns.Clear();
simplifiedLevelColumns.Clear();
}
}
}
}
}
/// <summary>
/// Manages all things
/// </summary>
/// <param name="graphicsDevice">Used to draw</param>
/// <param name="content">Used to load content</param>
public GameStateManager(GraphicsDevice graphicsDevice, ContentManager content)
{
this.LayerManager = new LayerManager(graphicsDevice, content);
this.Camera = new CameraManager(graphicsDevice, 300, 1);
this.Content = content;
this.LayerManager = LevelParser.LoadLevel("test", graphicsDevice, content);
//Centers the camera around the player
Camera.MoveTo(new Point(-LayerManager.Player.Position.X, -LayerManager.Player.Position.Y));
}
void Start()
{
//todo: put this in MenuManager ?//
Time.timeScale = 1;
var stageComplete = StageCompleteCanvas.GetComponent<CanvasGroup>();
stageComplete.alpha = 0x00;
stageComplete.blocksRaycasts = false;
var gameMenu = GameMenu.GetComponent<CanvasGroup>();
gameMenu.alpha = 0x00;
gameMenu.blocksRaycasts = false;
//end todo//
Player.HitSomething += Player_HitSomethingWithGun;
_levelTexture = LevelTextures[_levelIndex];
_levelParser = new LevelParser
{
GrassTile = FloorTiles[0],
GrayTile = FloorTiles[1],
GrayTileWithGrass = FloorTiles[2],
GrayTileWithGrassRight = FloorTiles[3],
GrayTileWithGrassTop = FloorTiles[4],
GrayTileWithGrassLeft = FloorTiles[5],
WallTile = WallTiles[0],
//BreakableWallTile = WallTiles[3],
FountainTile = WallTiles[1],
KnightStatueTile = WallTiles[2],
BadGuy1 = BadGuy1,
BadGuy2 = BadGuy2,
AmmoPickup = AmmoPickup,
HealthPickup = HealthPickup,
Switch = Switch,
};
_currentLevelTiles = _levelParser.GetLevelData(_levelTexture).ToList();
LoadLevel(_currentLevelTiles, _currentLevelXOffset);
}
private void InitGame()
{
// Get and parse level
Level level = new Level("Default");
LevelParser levelParser = new LevelParser(level.GetLevelXml());
Fields = levelParser.AllFields;
// Get all colors
List<Color> colors = new List<Color>();
foreach (Color color in Enum.GetValues(typeof(Color)))
{
colors.Add(color);
}
// Set player settings
for (int i = 0; i < Players.Count(); i++)
{
// Set color
Players.ElementAt(i).Color = colors.ElementAt(i);
// Set start fields
switch (i)
{
case 0:
Players.ElementAt(i).StartFields = levelParser.StartFieldsPlayerOne;
break;
case 1:
Players.ElementAt(i).StartFields = levelParser.StartFieldsPlayerTwo;
break;
case 2:
Players.ElementAt(i).StartFields = levelParser.StartFieldsPlayerThree;
break;
case 3:
Players.ElementAt(i).StartFields = levelParser.StartFieldsPlayerFour;
break;
default:
Players.ElementAt(i).StartFields = levelParser.StartFieldsPlayerOne;
break;
}
// Add pawns
List<Pawn> pawns = new List<Pawn>();
for (int j = 0; j < 4; j++)
{
Pawn newPawn = new Pawn { Color = colors.ElementAt(i) };
int coordx = Players.ElementAt(i).StartFields.ElementAt(j).CoordX;
int y = Players.ElementAt(i).StartFields.ElementAt(j).CoordY;
IField startField = levelParser.AllFields.Where(x => x.CoordX == Players.ElementAt(i).StartFields.ElementAt(j).CoordX && x.CoordY == Players.ElementAt(i).StartFields.ElementAt(j).CoordY).First();
newPawn.Position = startField;
startField.Moveables.Add(newPawn);
pawns.Add(newPawn);
}
Players.ElementAt(i).Pawns = pawns;
}
// Selected starting player
Random r = new Random();
activePlayer = Players.ElementAt(r.Next(0, Players.Count()));
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Awake()
{
instance = this;
}
public override void Initialize()
{
levelParser = new LevelParser();
level = levelParser.generateLevel(@"Content\Level1.csv", 1);
camera = new Camera(1, Vector2.Zero, 0, false, Game.GraphicsDevice);
//pacman = new PacMan(level.getCell(1, 1), level,
// new PlayerController(Direction.Down, "Player 1", PlayerIndex.One, ), Direction.None, 2f,
// new Point(50, 50));
//pacman.Scale = 1;
base.Initialize();
}
