public Tileset(string Resourcepath)
{
BaseDir = ResourceManager.Instance.GetDirectoryName(Resourcepath);
List TilesL = Util.Load(Resourcepath, "supertux-tiles");
Properties TilesP = new Properties(TilesL);
foreach(List list in TilesP.GetList("tile")) {
try {
Tile Tile = new Tile();
ParseTile(Tile, list);
while(Tiles.Count <= Tile.Id)
Tiles.Add(null);
Tiles[Tile.Id] = Tile;
} catch(Exception e) {
Console.WriteLine("Couldn't parse a Tile: " + e.Message);
Console.WriteLine(e.StackTrace);
}
}
foreach(List list in TilesP.GetList("tiles")) {
try {
ParseTiles(list);
} catch(Exception e) {
Console.WriteLine("Couldn't parse a tiles: " + e.Message);
Console.WriteLine(e.StackTrace);
}
}
}
/// <summary>Loads the tiles from <paramref name="Resourcepath"/>.</summary>
/// <param name="Resourcepath">A path relative to the data folder of SuperTux.</param>
public Tileset(string Resourcepath)
{
baseDir = ResourceManager.Instance.GetDirectoryName(Resourcepath);
List TilesL = Util.Load(Resourcepath, "supertux-tiles");
Properties TilesP = new Properties(TilesL);
foreach(List list in TilesP.GetList("tile")) {
try {
Tile tile = new Tile();
ParseTile(tile, list);
while(tiles.Count <= tile.Id)
tiles.Add(null);
tiles[tile.Id] = tile;
} catch(Exception e) {
Console.WriteLine("Couldn't parse a Tile: " + e.Message);
Console.WriteLine(e.StackTrace);
}
}
foreach(List list in TilesP.GetList("tiles")) {
try {
ParseTiles(list);
} catch(Exception e) {
Console.WriteLine("Couldn't parse a tiles: " + e.Message);
Console.WriteLine(e.StackTrace);
}
}
// construct a tilegroup with all tiles
Tilegroup allGroup = new Tilegroup();
allGroup.Name = "All";
foreach(Tile tile in tiles) {
if(tile != null)
allGroup.Tiles.Add(tile.Id);
}
tilegroups.Add(allGroup.Name, allGroup);
LispSerializer serializer = new LispSerializer(typeof(Tilegroup));
foreach(List list in TilesP.GetList("tilegroup")) {
try {
Tilegroup group = (Tilegroup) serializer.Read(list);
for(int i = 0; i < group.Tiles.Count; ) {
if(!IsValid(group.Tiles[i])) {
Console.WriteLine("Tilegroup " + group.Name + " contains invalid TileID " + group.Tiles[i]);
group.Tiles.RemoveAt(i);
continue;
}
++i;
}
tilegroups.Add(group.Name, group);
} catch(Exception e) {
Console.WriteLine("Couldn't parse tilegroup: " + e.Message);
Console.WriteLine(e.StackTrace);
}
}
}
public void CustomLispRead(Properties props)
{
foreach(Type type in this.GetType().Assembly.GetTypes()) {
SupertuxObjectAttribute objectAttribute
= (SupertuxObjectAttribute) Attribute.GetCustomAttribute(type, typeof(SupertuxObjectAttribute));
if(objectAttribute == null)
continue;
LispSerializer serializer = new LispSerializer(type);
foreach(List list in props.GetList(objectAttribute.Name)) {
IGameObject Object = (IGameObject) serializer.Read(list);
GameObjects.Add(Object);
}
}
}
public object Read(List list)
{
object result = CreateObject(type);
Properties props = new Properties(list);
// iterate over all fields and properties
foreach(FieldOrProperty field in FieldOrProperty.GetFieldsAndProperties(type)) {
LispChildAttribute ChildAttrib = (LispChildAttribute)
field.GetCustomAttribute(typeof(LispChildAttribute));
if(ChildAttrib != null) {
string Name = ChildAttrib.Name;
if(field.Type == typeof(int)) {
int val = 0;
if(!props.Get(Name, ref val)) {
if(!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
field.SetValue(result, val);
}
} else if(field.Type == typeof(string)) {
string val = null;
if(!props.Get(Name, ref val)) {
if(!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
field.SetValue(result, val);
}
} else if(field.Type == typeof(float)) {
float val = 0;
if(!props.Get(Name, ref val)) {
if(!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
field.SetValue(result, val);
}
} else if (field.Type.IsEnum) {
Enum val = null;
if (!props.Get(Name, ref val, field.Type)) {
if (!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
field.SetValue(result, val);
}
} else if(field.Type == typeof(bool)) {
bool val = false;
if(!props.Get(Name, ref val)) {
if(!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
field.SetValue(result, val);
}
} else if(field.Type == typeof(List<int>)) {
List<int> val = new List<int>();
if(!props.GetIntList(Name, val)) {
if(!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
field.SetValue(result, val);
}
} else {
ILispSerializer serializer = LispSerializer.GetSerializer(field.Type);
if(serializer == null)
throw new LispException("Type " + field.Type + " not supported for serialization");
List val = null;
if(!props.Get(Name, ref val)) {
if(!ChildAttrib.Optional)
Console.WriteLine("Field '" + Name + "' not in lisp");
} else {
object oval = serializer.Read(val);
field.SetValue(result, oval);
}
}
}
foreach(LispChildsAttribute childsAttrib in
field.GetCustomAttributes(typeof(LispChildsAttribute))) {
object objectList = field.GetValue(result);
Type ListType = field.Type;
MethodInfo AddMethod = ListType.GetMethod(
"Add", new Type[] { childsAttrib.ListType }, null);
if(AddMethod == null)
throw new LispException("No Add method found for field " + field.Name);
ILispSerializer serializer = LispSerializer.GetSerializer(childsAttrib.Type);
if(serializer == null)
serializer = LispSerializer.CreateRootSerializer(childsAttrib.Type);
foreach(List childList in props.GetList(childsAttrib.Name)) {
object child = serializer.Read(childList);
AddMethod.Invoke(objectList, new object[] { child } );
}
}
}
if(result is ICustomLispSerializer) {
ICustomLispSerializer custom = (ICustomLispSerializer) result;
custom.CustomLispRead(props);
custom.FinishRead();
}
return result;
}
