public void SelectLevel(LevelElement element)
{
if (element != _selectedLevelElement)
{
if (_selectedLevelElement != null)
{
DeselectLevel();
}
EventSystem.current.SetSelectedGameObject(element.gameObject);
_sfxSource.PlayOneShot(uiSounds.clickSounds[1]);
_selectedLevelElement = element;
_selectedLevelElement.songName.text = GetLevelLabel();
Song song = GetSongAsset();
LevelSelectPersistence.Instance.SelectedSong = song;
_selectedLevelElement.songName.enabled = true;
if (!startButton.interactable)
{
startButton.interactable = true;
}
PreviewSong(song);
}
}
private void ResetStars(LevelElement element)
{
for (int i = 0; i < element.ratingImages.Length; i++)
{
element.ratingImages[i].sprite = _blankStar;
}
}
public void Step()
{
LevelElement nextOpenEnd = RandomElement <LevelElement> (openEnds);
openEnds.Remove(nextOpenEnd);
Tile nextTile = RandomTile();
LevelElement nextElt = nextOpenEnd;
if (nextTile == Tile.GATE)
{
nextElt.tile = nextTile;
}
else
{
nextElt.tile = Tile.TUBE;
LevelElement nextRoom = new LevelElement();
nextRoom.pos = TubeExit(nextElt);
nextRoom.dir = nextElt.dir;
nextRoom.tile = nextTile;
if (Fits(nextElt) && Fits(nextRoom))
{
AddElement(nextRoom);
foreach (var exit in Exits(nextRoom))
{
openEnds.Add(exit);
}
}
else
{
nextElt.tile = Tile.GATE;
}
}
AddElement(nextElt);
}
/// <summary>
/// Copies index, name and filter from the element.
/// </summary>
/// <param name="element"></param>
public LevelElement(LevelElement/*!*/element)
: this(element.Index)
{
filter = element.filter;
levelName = element.levelName;
userData = element.userData;
}
public List <LevelElement> Exits(LevelElement elt)
{
Point ignoreStart = GoInDir(elt.pos, elt.dir, -1);
Point center = (elt.tile == Tile.CUBE) ? elt.pos : GoInDir(elt.pos, elt.dir, 1);
int steps = (elt.tile == Tile.CUBE) ? 1 : 2;
List <LevelElement> ret = new List <LevelElement> ();
Direction[] allDirs =
{
Direction.BACK,
Direction.DOWN,
Direction.FRONT,
Direction.LEFT,
Direction.RIGHT,
Direction.UP
};
foreach (var dir in allDirs)
{
LevelElement open = new LevelElement();
open.pos = GoInDir(center, dir, steps);
open.dir = dir;
if (!ignoreStart.Equals(open.pos))
{
ret.Add(open);
}
}
return(ret);
}
/// <summary>
/// Destroys the top level of buffering.
/// </summary>
/// <param name="flush">Whether to flush data on the current level. Data will be discarded if not set.</param>
/// <remarks>Returns the current level index after decreasing.</remarks>
public int DecreaseLevel(bool flush)
{
if (level == null)
{
throw new InvalidOperationException(CoreResources.GetString("output_buffering_disabled"));
}
if (flush)
{
InternalFlush();
}
int top = levels.Count - 1;
levels.RemoveAt(top);
if (top != 0)
{
level = (LevelElement)levels[top - 1];
return(top - 1);
}
else
{
level = null;
return(-1);
}
}
public List <Point> OccupiedBy(LevelElement elt)
{
List <Point> ret = new List <Point> ();
switch (elt.tile)
{
case Tile.GATE:
break;
case Tile.TUBE:
ret.Add(elt.pos);
ret.Add(GoInDir(elt.pos, elt.dir));
ret.Add(GoInDir(elt.pos, elt.dir, 2));
break;
case Tile.CUBE:
ret.Add(elt.pos);
break;
case Tile.ROOM:
var center = GoInDir(elt.pos, elt.dir);
for (int x = center.x - 1; x < center.x + 2; x++)
{
for (int y = center.y - 1; y < center.y + 2; y++)
{
for (int z = center.z - 1; z < center.z + 2; z++)
{
ret.Add(new Point(x, y, z));
}
}
}
break;
}
return(ret);
}
/// <summary>
/// Copies index, name and filter from the element.
/// </summary>
/// <param name="element"></param>
public LevelElement(LevelElement /*!*/ element)
: this(element.Index)
{
filter = element.filter;
levelName = element.levelName;
userData = element.userData;
}
public static GameObject InstantiateElement(LevelElement element)
{
GameObject a = null;
switch (element.type)
{
case "StarFragment":
a = MonoBehaviour.Instantiate(starFragmentPrefab, new Vector3(element.position_x, element.position_y, 0), Quaternion.identity);
a.transform.localScale = new Vector3(element.scale_x, element.scale_y, 1);
break;
case "moon":
case "Planet":
a = MonoBehaviour.Instantiate(moonPrefab, new Vector3(element.position_x, element.position_y, 0), Quaternion.identity);
a.transform.GetChild(0).transform.localScale = new Vector3(element.scale_x, element.scale_y, 1);
a.transform.GetChild(2).GetComponent <gravity>().gravityScale = element.gravity_scale;
a.transform.GetChild(2).GetComponent <CircleCollider2D>().radius = element.radius;
break;
case "finish_planet":
case "FinishPlanet":
a = MonoBehaviour.Instantiate(finishPlanetPrefab, new Vector3(element.position_x, element.position_y, 0), Quaternion.identity);
a.transform.localScale = new Vector3(element.scale_x, element.scale_y, 1);
a.GetComponent <CircleCollider2D>().radius = element.radius;
break;
case "BlackHole":
a = MonoBehaviour.Instantiate(blackholePrefab, new Vector3(element.position_x, element.position_y, 0), Quaternion.identity);
a.transform.localScale = new Vector3(element.scale_x, element.scale_y, 1);
a.GetComponent <CircleCollider2D>().radius = element.radius;
break;
}
return(a);
}
/// <summary>
/// Copies index, name and filter from the element.
/// </summary>
/// <param name="element"></param>
internal LevelElement(LevelElement/*!*/element)
:this(element.index)
{
filter = element.filter;
levelName = element.levelName;
userData = element.userData;
}
/// <summary>
/// Copies index, name and filter from the element.
/// </summary>
/// <param name="element"></param>
internal LevelElement(LevelElement /*!*/ element)
: this(element.index)
{
filter = element.filter;
levelName = element.levelName;
userData = element.userData;
}
public LevelElement GetHolder(EMapHolder type)
{
LevelElement holder = null;
mHolders.TryGetValue(type, out holder);
return(holder);
}
void Gen()
{
Clear();
LevelElement start = new LevelElement();
start.dir = Direction.FRONT;
openEnds.Add(start);
var p = GateProb;
GateProb = 0f;
for (int i = 0; i < 4; i++)
{
Step();
}
GateProb = p;
for (int i = 0; i < 30; i++)
{
Step();
}
GateProb = 1;
while (openEnds.Count > 0)
{
Step();
}
}
public Point TubeExit(LevelElement elt)
{
if (elt.tile != Tile.TUBE)
{
throw new UnityException("must be tube");
}
return(GoInDir(elt.pos, elt.dir, 3));
}
public static PropertyValues UpdateFloor(this LevelElement level, VaultAliases vaultAlias, int modelId)
{
var pvs = new PropertyValues();
AddProperties(level, pvs, vaultAlias, modelId);
return(pvs);
}
private void tsElement_Click(object sender, EventArgs e)
{
if (lstLevels.SelectedItems.Count > 0)
{
selectedElementIndex = (LevelElement)Int16.Parse((String)((ToolStripButton)sender).Tag);
tsTopMenu.Refresh();
}
}
// ------------------------------------------------------------------------
public void resetSelectedElement()
{
_selectedElement = new LevelElement();
_selectedElement.part = PrefabLevelEditor.PartList.End_Of_List;
_selectedMeshRenderers.Clear();
_selectedElementBounds = new Bounds();
}
/// <summary>
/// Discards data on the current level of buffering.
/// </summary>
public void Clean()
{
if (level == null)
{
return;
}
levels[level.index] = level = new LevelElement(level);
}
void Start()
{
Level lvl = new Level();
lvl.name = lvlName;
lvl.previewPath = previewPath;
lvl.elements = new List <LevelElement>();
for (int i = 0; i < transform.childCount; i++)
{
GameObject child = transform.GetChild(i).gameObject;
MeshCollider collider = child.GetComponent <MeshCollider>();
MeshFilter filter = child.GetComponent <MeshFilter>();
MeshRenderer renderer = child.GetComponent <MeshRenderer>();
TextureMarker texMarker = child.GetComponent <TextureMarker>();
LevelElementAnimator anim = child.GetComponent <LevelElementAnimator>();
LevelElement e = new LevelElement();
e.name = child.name;
e.position = child.transform.localPosition;
e.rotation = child.transform.localRotation;
e.scale = child.transform.localScale;
e.collider = collider == null ? ColliderType.None : ColliderType.Mesh;
if (filter != null)
{
e.mesh = filter.mesh;
e.materials = new List <LevelMat>();
for (int m = 0; m < renderer.materials.Length; m++)
{
LevelMat mat = new LevelMat();
mat.shader = renderer.materials[m].shader.name;
mat.color = renderer.materials[m].GetColor("_Color");
if (texMarker != null)
{
mat.texture = texMarker.textures[m];
}
e.materials.Add(mat);
}
}
if (anim != null)
{
e.animation = new LevelElementAnimation();
e.animation.animCurves = anim.animCurves;
}
lvl.elements.Add(e);
}
XElement xml = lvl.Serialize();
XDocument doc = new XDocument(xml);
string path = ConfigManager.basePath + "level" + System.IO.Path.DirectorySeparatorChar + lvlName + ".xml";
doc.Save(path);
Level reload = new Level();
reload.Deserialize(xml);
reload.LoadLevel();
gameObject.SetActive(false);
}
/// <summary>
/// Discards data on the current level of buffering.
/// </summary>
public void Clean()
{
if (_level == null)
{
return;
}
_levels[_level.Index] = _level = new LevelElement(_level);
}
public void AddReally(LevelElement elt)
{
GameObject obj = GetPrefab(elt.tile);
Vector3 pos = Center(elt);
Quaternion rot = Rotation(elt.dir);
GameObject o = (GameObject)(Instantiate(obj, pos, rot));
o.transform.parent = GameObject.Find("Level").transform;
}
/// <summary>
/// Flushes all data from all buffers to sinks. Discards all data and all levels of buffering.
/// Disables output buffering.
/// </summary>
public void FlushAll()
{
for (int i = levels.Count - 1; i >= 0; i--)
{
level = (LevelElement)levels[i];
InternalFlush();
}
levels.Clear();
level = null;
}
public static ObjVer CreateFloor(this LevelElement level, VaultAliases vaultAlias, int modelId, AccessControlList acl)
{
var objTypeId = vaultAlias.ObDict[OB.Level];
var classId = vaultAlias.CsDict[CS.Level];
var pvs = new PropertyValues();
AddProperties(level, pvs, vaultAlias, modelId);
return(BaseElementExtensions.CreateBasicObject(objTypeId, classId, pvs, vaultAlias.Vault, acl));
}
private void mnuLevelItem_Click(ToolStripMenuItem selectedItem, int index)
{
foreach (ToolStripMenuItem item in mnuLevelElements)
{
item.Checked = false;
}
selectedItem.Checked = true;
selectedElementIndex = (LevelElement)index;
}
public static void AddProperties(this LevelElement level, PropertyValues pvs, VaultAliases vaultAlias, int modelId)
{
level.AddBasicProperties(pvs, vaultAlias, modelId);
var elevPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Elevation]
};
elevPV.Value.SetValue(MFDataType.MFDatatypeText, level.Elevation);
pvs.Add(-1, elevPV);
}
public void AddElement(LevelElement elt)
{
print("Add: " + elt.tile + " " + elt.pos + " " + elt.dir);
this.elements.Add(elt);
foreach (var p in OccupiedBy(elt))
{
occupied.Add(p);
}
AddReally(elt);
}
// ------------------------------------------------------------------------
public void selectElement(string name)
{
_selectedElement = _levelElements [name];
setMeshCollider(_selectedElement.go, false);
setRigidBody(_selectedElement.go, false);
getSelectedMeshRenderers(_selectedElement.go, _iSelectedGroupIndex);
getSelectedMeshRendererBounds();
}
public void AddHolder <T>(EMapHolder type) where T : LevelElement
{
LevelElement holder = null;
mHolders.TryGetValue(type, out holder);
if (holder == null)
{
holder = new GameObject(typeof(T).Name).AddComponent <T>();
mHolders[type] = holder;
}
}
public static Chromosome OnePointCrossover(Chromosome first, Chromosome second)
{
var length = first.LevelElements.Length;
var rand = new Random();
var splitPoint = rand.Next(length);
var child = new LevelElement[length];
Array.Copy(first.LevelElements, child, splitPoint);
Array.Copy(first.LevelElements, splitPoint, child, splitPoint, length - splitPoint);
return(new Chromosome(child));
}
/// <summary>
/// Set the level name.
/// </summary>
/// <param name="levelIndex">Index of the level from 1.</param>
/// <param name="levelName">New name of the level.</param>
public void SetLevelName(int levelIndex, string levelName)
{
if (levelIndex < 0 || levelIndex >= Level)
{
throw new ArgumentOutOfRangeException("levelIndex");
}
LevelElement element = (LevelElement)levels[levelIndex];
element.levelName = levelName;
}
private string GetLevelName(LevelElement element)
{
if (element.levelName != null)
{
return(element.levelName);
}
else
{
return((element.filter != null) ? element.filter.ToPhpValue().ToString(_ctx) : "default output handler");
}
}
/// <summary>
/// Flushes all data from all buffers to sinks. Discards all data and all levels of buffering.
/// Disables output buffering.
/// </summary>
public void FlushAll()
{
for (int i = _levels.Count - 1; i >= 0; i--)
{
_level = _levels[i];
InternalFlush();
}
_levels.Clear();
_level = null;
}
void LoadLevel()
{
ArrayList lElementList = (ArrayList)Prime31.Json.jsonDecode(mLevelDescriptors[mCurrentScene].text);
foreach(IDictionary lDic in lElementList)
{
LevelElement lLevelElement = new LevelElement(lDic);
mLevelElements.Add(lLevelElement);
}
}
/// <summary>
/// Discards data on the current level of buffering.
/// </summary>
public void Clean()
{
if (_level == null)
return;
_levels[_level.Index] = _level = new LevelElement(_level);
}
/// <summary>
/// Flushes data on current level of buffering to the sinks or to the previous level.
/// The current level clean up MUST follow this method's call.
/// </summary>
internal void InternalFlush()
{
Debug.Assert(level != null);
if (level.filter != null)
{
ChunkPosition chunk_position = ChunkPosition.First | ChunkPosition.Middle | ChunkPosition.Last;
// writes data to the current level of buffering or to sinks depending on the level count:
if (level.index > 0)
{
// gets data from user's callback:
object data = level.filter.Invoke(GetContent(), chunk_position);
// store level to allow its restore:
LevelElement old_level = level;
// temporarily decreases the level of buffering toredirect writes to the lower level:
level = (LevelElement)levels[level.index - 1];
// checks whether the filtered data are binary at first; if not so, converts them to a string:
PhpBytes bin = data as PhpBytes;
if (bin != null)
stream.Write(bin.ReadonlyData, 0, bin.Length);
else
this.Write(PHP.Core.Convert.ObjectToString(data));
// restore the level of buffering:
level = old_level;
}
else
{
// gets data from user's callback:
object data = level.filter.Invoke(GetContent(), chunk_position);
// checks whether the filtered data are binary at first; if not so, converts them to a string:
PhpBytes bin = data as PhpBytes;
if (bin != null)
{
if (bin.Length > 0) byteSink.Write(bin.ReadonlyData, 0, bin.Length);
}
else
charSink.Write(PHP.Core.Convert.ObjectToString(data));
}
}
else
{
if (level.index > 0)
{
// joins levels (data are not copied => the current level MUST be cleaned up after the return from this method):
if (level.size > 0)
{
LevelElement lower_level = (LevelElement)levels[level.index - 1];
lower_level.buffers.AddRange(level.buffers);
lower_level.size += level.size;
lower_level.freeSpace = level.freeSpace; // free space in the last buffer of the level
lower_level.containsByteData |= level.containsByteData;
lower_level.containsCharData |= level.containsCharData;
}
}
else
{
// writes top-level data to sinks:
for (int i = 0; i < level.buffers.Count; i++)
{
BufferElement element = (BufferElement)level.buffers[i];
byte[] bytes = element.data as byte[];
if (bytes != null)
byteSink.Write(bytes, 0, element.size);
else
charSink.Write((char[])element.data, 0, element.size);
}
}
}
}
/// <summary>
/// Flushes all data from all buffers to sinks. Discards all data and all levels of buffering.
/// Disables output buffering.
/// </summary>
public void FlushAll()
{
for (int i = levels.Count - 1; i >= 0; i--)
{
level = (LevelElement)levels[i];
InternalFlush();
}
levels.Clear();
level = null;
}
public void addResource(LevelElement ele)
{
int i;
int j;
int type;
bool walkable;
if (ele.Type.Equals("Bush"))
{
type = ANode.SEED_SOURCE;
walkable = false;
}
else if (ele.Type.Equals("SoftGround"))
{
type = ANode.PLANT_AREA;
walkable = true;
}
else if (ele.Type.Equals("BabyPlant"))
{
type = ANode.NOT_SPECIAL;
walkable = true;
}
else
{
type = ANode.NOT_SPECIAL;
walkable = false;
}
i = (int)((ele.CollisionRect.Left + 2048) / 50);
if (i > 81)
{
i = 81;
}
if (i < 0)
{
i = 0;
}
j = (int)((ele.CollisionRect.Top + 2048) / 50);
if (j > 81)
{
j = 81;
}
if (j < 0)
{
j = 0;
}
// top left
mGrid[i, j].bWalkable = walkable;
mGrid[i, j].Type = type;
i = (int)((ele.CollisionRect.Right + 2028) / 50);
if (i > 81)
{
i = 81;
}
if (i < 0)
{
i = 0;
}
// top right
mGrid[i, j].bWalkable = walkable;
mGrid[i, j].Type = type;
j = (int)((ele.CollisionRect.Bottom + 2048) / 50);
if (j > 81)
{
j = 81;
}
if (j < 0)
{
j = 0;
}
// bottom right
mGrid[i, j].bWalkable = walkable;
mGrid[i, j].Type = type;
i = (int)(ele.CollisionRect.Left);
if (i > 81)
{
i = 81;
}
if (i < 0)
{
i = 0;
}
// bottom left
mGrid[i, j].bWalkable = walkable;
mGrid[i, j].Type = type;
}
// needed for HearMe, AbcRank
public LevelOption(string name, LevelElement element)
{
this.setName(name);
this.setLevelElement(element);
}
/// <summary>
/// Adds a new level of buffering on the top of the levels stack.
/// </summary>
/// <remarks>Returns the new level index.</remarks>
public int IncreaseLevel()
{
_levels.Add(_level = new LevelElement(_levels.Count));
return _level.Index;
}
/// <summary>
/// Flushes all data from all buffers to sinks. Discards all data and all levels of buffering.
/// Disables output buffering.
/// </summary>
public void FlushAll()
{
for (int i = _levels.Count - 1; i >= 0; i--)
{
_level = _levels[i];
InternalFlush();
}
_levels.Clear();
_level = null;
}
/// <summary>
/// Flushes data on current level of buffering to the sinks or to the previous level.
/// The current level clean up MUST follow this method's call.
/// </summary>
internal void InternalFlush()
{
Debug.Assert(_level != null);
if (_level.filter == null)
{
if (_level.Index == 0)
{
// TODO: PhpString buffers
// writes top-level data to sinks:
for (int i = 0; i < _level.buffers.Count; i++)
{
BufferElement element = _level.buffers[i];
byte[] bytes = element.data as byte[];
if (bytes != null)
_byteSink.Write(bytes, 0, element.size);
else
_charSink.Write((char[])element.data, 0, element.size);
}
}
else
{
// joins levels (data are not copied => the current level MUST be cleaned up after the return from this method):
if (_level.size > 0)
{
var lower_level = _levels[_level.Index - 1];
lower_level.buffers.AddRange(_level.buffers);
lower_level.size += _level.size;
lower_level.freeSpace = _level.freeSpace; // free space in the last buffer of the level
lower_level.containsByteData |= _level.containsByteData;
lower_level.containsCharData |= _level.containsCharData;
}
}
}
else
{
// gets data from user's callback:
var data = _level.filter.DynamicInvoke(GetContent(), ChunkPosition.First | ChunkPosition.Middle | ChunkPosition.Last);
if (data != null)
{
var bindata = data as byte[];
// writes data to the current level of buffering or to sinks depending on the level count:
if (_level.Index == 0)
{
// checks whether the filtered data are binary at first; if not so, converts them to a string:
if (bindata != null)
{
_byteSink.Write(bindata, 0, bindata.Length);
}
else
{
// TODO: PhpString containing both string and byte[]
_charSink.Write(data.ToString());
}
}
else
{
// temporarily decreases the level of buffering toredirect writes to the lower level:
var old_level = _level;
_level = _levels[_level.Index - 1];
// checks whether the filtered data are binary at first; if not so, converts them to a string:
if (bindata != null)
{
_stream.Write(bindata, 0, bindata.Length);
}
else
{
// TODO: PhpString containing both string and byte[]
this.Write(data.ToString());
}
// restore the level of buffering:
_level = old_level;
}
}
}
}
// needed for FourPictures
public LevelOption(LevelElement element, bool isCorrect)
{
this.setLevelElement(element);
this.setIsCorrect(isCorrect);
}
private void attackLevelElement(LevelElement ele, GameTime gameTime)
{
attackTimer += gameTime.ElapsedGameTime.Milliseconds;
if (attackTimer > 500)
{
attackCounter++;
}
if (attackCounter >= 3)
{
if (ele.Type.Equals("Tree") || ele.Type.Equals("Tree2"))
{
ele.Type = "Stump";
ele.Tex = ContentManager.GetTexture("Stump");
GameScreen.CurWorldHealth--;
SoundManager.PlaySound("Thump");
}
else if (ele.Type.Equals("Stump") || ele.Type.Equals("BabyPlant"))
{
if (ele.Type.Equals("BabyPlant"))
{
GameScreen.CurWorldHealth--;
}
ele.Type = "SoftGround";
ele.Tex = ContentManager.GetTexture("SoftGround");
AGrid.GetInstance().addResource(ele);
SoundManager.PlaySound("Thump");
}
attackCounter = 0;
attackTimer = 0;
}
}
/// <summary>
/// Destroys the top level of buffering.
/// </summary>
/// <param name="flush">Whether to flush data on the current level. Data will be discarded if not set.</param>
/// <remarks>Returns the current level index after decreasing.</remarks>
public int DecreaseLevel(bool flush)
{
ThrowIfDisabled();
if (flush) InternalFlush();
int top = _levels.Count - 1;
_levels.RemoveAt(top);
if (top != 0)
{
_level = (LevelElement)_levels[top - 1];
return top - 1;
}
else
{
_level = null;
return -1;
}
}
/// <summary>
/// Adds a new level of buffering on the top of the levels stack.
/// </summary>
/// <remarks>Returns the new level index.</remarks>
public int IncreaseLevel()
{
return levels.Add(level = new LevelElement(levels.Count));
}
/// <summary>
/// Destroys the top level of buffering.
/// </summary>
/// <param name="flush">Whether to flush data on the current level. Data will be discarded if not set.</param>
/// <remarks>Returns the current level index after decreasing.</remarks>
public int DecreaseLevel(bool flush)
{
if (level == null) throw new InvalidOperationException(CoreResources.GetString("output_buffering_disabled"));
if (flush) InternalFlush();
int top = levels.Count - 1;
levels.RemoveAt(top);
if (top != 0)
{
level = (LevelElement)levels[top - 1];
return top - 1;
}
else
{
level = null;
return -1;
}
}
// needed for Memory
public LevelOption(int id, string name, LevelElement element)
{
this.setId(id);
this.setName(name);
this.setLevelElement(element);
}
/// <summary>
/// Discards data on the current level of buffering.
/// </summary>
public void Clean()
{
if (level == null) return;
levels[level.index] = level = new LevelElement(level);
}
public void setLevelElement(LevelElement element)
{
this.Element = element;
}
public static void LoadLevel(string level)
{
if (!System.IO.File.Exists("Content/Levels/" + level + ".txt"))
{
return;
}
System.IO.StreamReader fileReader = new System.IO.StreamReader("Content/Levels/" + level + ".txt");
string fileLine = fileReader.ReadLine();
LevelElement ele;
int x;
int y;
string type;
Texture2D tex = null;
while (fileLine != null)
{
type = fileLine;
fileLine = fileReader.ReadLine();
x = Convert.ToInt32(fileLine);
fileLine = fileReader.ReadLine();
y = Convert.ToInt32(fileLine);
tex = ContentManager.GetTexture(type);
ele = new LevelElement(new Vector2(x, y), type, tex);
if (!ele.Type.Equals("Grass") && !ele.Type.Equals("GrassBig")
&& !ele.Type.Equals("Flowers"))
{
UpdateKeeper.getInstance().addLevelElement(ele);
}
DrawKeeper.getInstance().addLevelElement(ele);
fileLine = fileReader.ReadLine();
}
}
