public void loadMaterials(XElement doc, String dataPath)
{
try
{
foreach (var xml_node in doc.Elements("include"))
{
loadMaterials(XElement.Load(dataPath + "\\" + xml_node.Attribute("file").GetString()), dataPath);
}
foreach (var metaitem_node in doc.Elements("metaitem"))
{
//TODO
}
foreach (var border_node in doc.Elements("border"))
{
Brushes.getInstance().unserializeBorder(border_node);
}
foreach (var brush_node in doc.Elements("brush"))
{
Brushes.getInstance().unserializeBrush(brush_node);
}
foreach (var tileset_node in doc.Elements("tileset"))
{
unserializeTileset(tileset_node);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n" + dataPath + "\n" + ex.StackTrace);
}
}
public void createOtherTileset()
{
TileSet others = null;
TileSet npc_tileset = null;
if (tilesets.ContainsKey("Others"))
{
others = tilesets["Others"];
}
else
{
others = new TileSet(Brushes.getInstance(), "Others");
tilesets["Others"] = others;
}
if (tilesets.ContainsKey("NPCs"))
{
npc_tileset = tilesets["NPCs"];
npc_tileset.clear();
}
else
{
npc_tileset = new TileSet(Brushes.getInstance(), "NPCs");
tilesets["NPCs"] = npc_tileset;
}
foreach (CreatureType type in CreatureDatabase.creatureDatabase)
{
if (type.in_other_tileset)
{
if (type.isNpc)
{
npc_tileset.getCategory(TilesetCategoryType.TILESET_CREATURE).brushlist.Add(type.brush);
}
else
{
others.getCategory(TilesetCategoryType.TILESET_CREATURE).brushlist.Add(type.brush);
}
}
else if (type.brush == null)
{
type.brush = new CreatureBrush(type);
Brushes.getInstance().addBrush(type.brush);
type.brush.flagAsVisible();
type.in_other_tileset = true;
if (type.isNpc)
{
npc_tileset.getCategory(TilesetCategoryType.TILESET_CREATURE).brushlist.Add(type.brush);
}
else
{
others.getCategory(TilesetCategoryType.TILESET_CREATURE).brushlist.Add(type.brush);
}
}
}
}
private void unserializeTileset(XElement tileset_node)
{
String tileSetName = tileset_node.Attribute("name").GetString();
if (!"".Equals(tileSetName))
{
TileSet ts = getTileSet(tileSetName);
if (ts == null)
{
ts = new TileSet(Brushes.getInstance(), tileSetName);
tilesets.Add(tileSetName, ts);
}
foreach (XElement element_tileset_node in tileset_node.Elements())
{
ts.LoadCategory(element_tileset_node);
}
}
//
}
public override void load(XElement brush)
{
look_id = brush.Attribute("lookid").GetUInt16();
if (brush.Attribute("server_lookid").GetUInt16() != 0)
{
look_id = brush.Attribute("server_lookid").GetUInt16();
}
foreach (XElement wall_brush in brush.Elements("wall"))
{
int alignment = 0;
String type = wall_brush.Attribute("type").GetString();
if (!"".Equals(type))
{
if (type == "vertical")
{
alignment = BorderType.WALL_VERTICAL;
}
else if (type == "horizontal")
{
alignment = BorderType.WALL_HORIZONTAL;
}
else if (type == "corner")
{
alignment = BorderType.WALL_NORTHWEST_DIAGONAL;
}
else if (type == "pole")
{
alignment = BorderType.WALL_POLE;
}
else if (type == "south end")
{
alignment = BorderType.WALL_SOUTH_END;
}
else if (type == "east end")
{
alignment = BorderType.WALL_EAST_END;
}
else if (type == "north end")
{
alignment = BorderType.WALL_NORTH_END;
}
else if (type == "west end")
{
alignment = BorderType.WALL_WEST_END;
}
else if (type == "south T")
{
alignment = BorderType.WALL_SOUTH_T;
}
else if (type == "east T")
{
alignment = BorderType.WALL_EAST_T;
}
else if (type == "west T")
{
alignment = BorderType.WALL_WEST_T;
}
else if (type == "north T")
{
alignment = BorderType.WALL_NORTH_T;
}
else if (type == "northwest diagonal")
{
alignment = BorderType.WALL_NORTHWEST_DIAGONAL;
}
else if (type == "northeast diagonal")
{
alignment = BorderType.WALL_NORTHEAST_DIAGONAL;
}
else if (type == "southwest diagonal")
{
alignment = BorderType.WALL_SOUTHWEST_DIAGONAL;
}
else if (type == "southeast diagonal")
{
alignment = BorderType.WALL_SOUTHEAST_DIAGONAL;
}
else if (type == "intersection")
{
alignment = BorderType.WALL_INTERSECTION;
}
else if (type == "untouchable")
{
alignment = BorderType.WALL_UNTOUCHABLE;
}
else
{
Messages.AddWarning("Unknown wall alignment '" + type + "'");
continue;
}
}
else
{
Messages.AddWarning("Could not read type tag of wall node");
continue;
}
foreach (XElement item_wall_brush in wall_brush.Elements("item"))
{
int id = 0;
int chance = 0;
id = item_wall_brush.Attribute("id").GetInt32();
if (id == 0)
{
Messages.AddWarning("Could not read id tag of item node");
break;
}
chance = item_wall_brush.Attribute("chance").GetInt32();
ItemType it = Global.items.items[id];
if (it == null)
{
Messages.AddWarning("There is no itemtype with id " + id);
continue;
}
if ((it.brush != null) && (it.brush != this))
{
Messages.AddWarning("Itemtype id " + id + " already has a brush");
continue;
}
it.IsWall = true;
it.brush = this;
it.BorderAlignment = alignment;
WallType wt = new WallType();
//issi é la do tipo
wall_items[alignment].total_chance += chance;
wt.chance = wall_items[alignment].total_chance;
wt.id = (UInt16)id;
wall_items[alignment].items.Add(wt);
}
foreach (XElement door_wall_brush in wall_brush.Elements("door"))
{
String type_door = "";
int chance = 0;
bool isOpen;
bool hate = false;
int id = door_wall_brush.Attribute("id").GetInt32();
if (id == 0)
{
Messages.AddWarning("Could not read id tag of item node");
break;
}
chance = door_wall_brush.Attribute("chance").GetInt32();
type_door = door_wall_brush.Attribute("type").GetString();
if (!"".Equals(type_door))
{
String strVal = door_wall_brush.Attribute("open").GetString();
if (!"".Equals(strVal))
{
isOpen = Generic.isTrueString(strVal);
}
else
{
isOpen = true;
if ((!type_door.Equals("window")) && (!type_door.Equals("any window")) && (!type_door.Equals("hatch window")))
{
Messages.AddWarning("Could not read open tag of item node");
break;
}
}
}
else
{
Messages.AddWarning("Could not read type tag of item node");
break;
}
if (!"".Equals(door_wall_brush.Attribute("type").GetString()))
{
hate = Generic.isTrueString(door_wall_brush.Attribute("type").GetString());
}
ItemType it = Global.items.items[id];
if (it == null)
{
Messages.AddWarning("There is no itemtype with id " + id);
continue;
}
it.IsWall = true;
it.brush = this;
it.IsBrushDoor = true;
it.WallHateMe = hate;
it.IsOpen = isOpen;
it.BorderAlignment = alignment;
DoorType dt = new DoorType();
bool all_windows = false;
bool all_doors = false;
if (type_door == "normal")
{
dt.type = EDoorType.WALL_DOOR_NORMAL;
}
else if (type_door == "locked")
{
dt.type = EDoorType.WALL_DOOR_LOCKED;
}
else if (type_door == "quest")
{
dt.type = EDoorType.WALL_DOOR_QUEST;
}
else if (type_door == "magic")
{
dt.type = EDoorType.WALL_DOOR_MAGIC;
}
else if (type_door == "archway")
{
dt.type = EDoorType.WALL_ARCHWAY;
}
else if (type_door == "window")
{
dt.type = EDoorType.WALL_WINDOW;
}
else if (type_door == "hatch_window" || type_door == "hatch window")
{
dt.type = EDoorType.WALL_HATCH_WINDOW;
}
else if (type_door == "any door")
{
all_doors = true;
}
else if (type_door == "any window")
{
all_windows = true;
}
else if (type_door == "any")
{
all_windows = true;
all_doors = true;
}
else
{
Messages.AddWarning("Unknown door type '" + type_door + "'");
break;
}
dt.id = (UInt16)id;
if (all_windows)
{
dt.type = EDoorType.WALL_WINDOW; door_items[alignment].Add(dt);
dt.type = EDoorType.WALL_HATCH_WINDOW; door_items[alignment].Add(dt);
}
if (all_doors)
{
dt.type = EDoorType.WALL_ARCHWAY; door_items[alignment].Add(dt);
dt.type = EDoorType.WALL_DOOR_NORMAL; door_items[alignment].Add(dt);
dt.type = EDoorType.WALL_DOOR_LOCKED; door_items[alignment].Add(dt);
dt.type = EDoorType.WALL_DOOR_QUEST; door_items[alignment].Add(dt);
dt.type = EDoorType.WALL_DOOR_MAGIC; door_items[alignment].Add(dt);
}
if (!all_doors && !all_windows)
{
door_items[alignment].Add(dt);
}
}
}
foreach (XElement efriend_brush in brush.Elements("friend"))
{
String friendName = efriend_brush.Attribute("name").GetString();
if (friendName != "")
{
if ("all".Equals(friendName))
{
//nada
}
else
{
Brush friend_brush = Brushes.getInstance().getBrush(friendName);
if (friend_brush != null)
{
friends.Add(friend_brush.getID());
}
else
{
Messages.AddWarning("Brush '" + friendName + "' is not defined.");
}
String redirect = efriend_brush.Attribute("redirect").GetString();
if ((!"".Equals(redirect)) && Generic.isTrueString(redirect))
{
WallBrush rd = null;
try
{
rd = (WallBrush)friend_brush;
}
catch// (Exception ex)
{
Messages.AddWarning("Wall brush redirect link: '" + redirect + "' is not a wall brush.");
}
if (redirect_to == null)
{
redirect_to = rd;
}
}
}
}
}
}
public override void load(XElement node)
{
UInt16 intVal = 0;
String strVal = "";
look_id = node.Attribute("lookid").GetUInt16();
if (node.Attribute("server_lookid").GetUInt16() != 0)
{
look_id = node.Attribute("server_lookid").GetUInt16();
}
z_order = node.Attribute("z-order").GetUInt16();
use_only_optional = Generic.isTrueString(node.Attribute("solo_optional").GetString());
randomize = Generic.isTrueString(node.Attribute("randomize").GetString());
foreach (var item_node in node.Elements("item"))
{
UInt16 itemid = item_node.Attribute("id").GetUInt16();
int chance = item_node.Attribute("chance").GetInt32();
ItemType it = Global.items.items[itemid];
if (it == null)
{
throw new Exception("Invalid item id brushId: " + this.id);
}
if (!it.isGroundTile())
{
throw new Exception("is not ground item: " + itemid + " this is a " + it.Group.ToString());
}
if (it.brush != null && !it.brush.Equals(this))
{
throw new Exception("can not be member of two brushes id:" + itemid);
}
it.brush = this;
ItemChanceBlock ci;
ci.id = itemid;
ci.chance = total_chance + chance;
border_items.Add(ci);
total_chance += chance;
}
foreach (var optional_node in node.Elements("optional"))
{
if (optional_border != null)
{
throw new Exception("Duplicate optional borders");
// continue;
}
intVal = optional_node.Attribute("ground_equivalent").GetUInt16();
if (intVal != 0)
{
ItemType it = Global.items.items[intVal];
if (it == null)
{
throw new Exception("Invalid id of ground dependency equivalent item");
}
if (!it.isGroundTile())
{
throw new Exception("Ground dependency equivalent is not a ground item");
}
if (!this.Equals(it.brush))
{
throw new Exception("Ground dependency equivalent does not use the same brush as ground border");
}
AutoBorder ab = new AutoBorder();
ab.Load(optional_node, this, intVal);
optional_border = ab;
}
else
{
Int32 id = optional_node.Attribute("id").GetInt32();
if (id == 0)
{
throw new Exception("Missing tag id for border node");
//continue;
}
AutoBorder border_secound = null;
for (int x = 0; x <= Brushes.getInstance().maxBorderId; x++)
{
AutoBorder border = Brushes.getInstance().borders[x];
if ((border != null) &&
(border.Id == id))
{
border_secound = border;
}
}
if (border_secound == null)
{
throw new Exception("Could not find border id. Brush: " + name);
}
optional_border = border_secound;
}
}
foreach (var border_node in node.Elements("border"))
{
AutoBorder ab;
int id = border_node.Attribute("id").GetInt32();
if (id == 0)
{
intVal = border_node.Attribute("ground_equivalent").GetUInt16();
ItemType it = Global.items.items[intVal];
if (it == null)
{
throw new Exception("Invalid id of ground dependency equivalent item");
}
if (!it.isGroundTile())
{
throw new Exception("Ground dependency equivalent is not a ground item");
}
if (!this.Equals(it.brush))
{
throw new Exception("Ground dependency equivalent does not use the same brush as ground border");
}
ab = new AutoBorder();
ab.Load(border_node, this, intVal);
}
else
{
AutoBorder border_secound = null;
for (int x = 0; x <= Brushes.getInstance().maxBorderId; x++)
{
AutoBorder border = Brushes.getInstance().borders[x];
if ((border != null) &&
(border.Id == id))
{
border_secound = border;
}
}
if (border_secound == null)
{
throw new Exception("Could not find border id. Brush:" + name);
}
ab = border_secound;
}
BorderBlock bb = new BorderBlock();
bb.super = false;
bb.autoborder = ab;
strVal = border_node.Attribute("to").GetString();
if (!"".Equals(strVal))
{
if ("all".Equals(strVal))
{
bb.to = 0xFFFFFFFF;
}
else if ("none".Equals(strVal))
{
bb.to = 0;
}
else
{
Brush toBrush = Brushes.getInstance().getBrush(strVal);
if (toBrush != null)
{
bb.to = toBrush.getID();
}
else
{
throw new Exception("To brush " + strVal + " doesn't exist.");
}
}
}
else
{
bb.to = 0xFFFFFFFF;
}
strVal = border_node.Attribute("super").GetString();
if (!"".Equals(strVal))
{
if (Generic.isTrueString(strVal))
{
bb.super = true;
}
}
strVal = border_node.Attribute("align").GetString();
if (!"".Equals(strVal))
{
if ("outer".Equals(strVal))
{
bb.outer = true;
}
else if ("inner".Equals(strVal))
{
bb.outer = false;
}
else
{
bb.outer = true;
}
}
if (bb.outer)
{
if (bb.to == 0)
{
has_zilch_outer_border = true;
}
else
{
has_outer_border = true;
}
}
else
{
if (bb.to == 0)
{
has_zilch_inner_border = true;
}
else
{
has_inner_border = true;
}
}
if (border_node.HasElements)
{
foreach (var specific_border_node in border_node.Elements("specific"))
{
SpecificCaseBlock scb = null;
foreach (var conditions_specific in specific_border_node.Elements("conditions"))
{
foreach (var match_border_conditions in conditions_specific.Elements("match_border"))
{
int border_id = 0;
string edge = "";
border_id = match_border_conditions.Attribute("id").GetInt32();
edge = match_border_conditions.Attribute("edge").GetString();
if ((border_id == 0) || "".Equals(edge))
{
continue;
}
int edge_id = AutoBorder.EdgeNameToEdge(edge);
AutoBorder bit_border = Brushes.getInstance().findBorder(edge_id);
if (bit_border == null)
{
throw new Exception("Unknown border id in specific case match block");
}
AutoBorder ab2 = bit_border;
if (ab2 == null)
{
throw new Exception("error ab2 ==null");
}
UInt16 match_itemid = ab.tiles[edge_id];
if (scb == null)
{
scb = new SpecificCaseBlock();
}
scb.items_to_match.Add(match_itemid);
}
foreach (var match_group_conditions in conditions_specific.Elements("match_group"))
{
uint group = 0;
String edge = "";
group = match_group_conditions.Attribute("group").GetUInt32();
edge = match_group_conditions.Attribute("edge").GetString();
if ((group == 0) || "".Equals(edge))
{
continue;
}
int edge_id = AutoBorder.EdgeNameToEdge(edge);
if (scb == null)
{
scb = new SpecificCaseBlock();
}
scb.match_group = group;
scb.group_match_alignment = edge_id;
scb.items_to_match.Add((UInt16)group);
}
foreach (var match_item_conditions in conditions_specific.Elements("match_item"))
{
ushort match_itemid = 0;
match_itemid = match_item_conditions.Attribute("id").GetUInt16();
if (match_itemid == 0)
{
continue;
}
if (scb == null)
{
scb = new SpecificCaseBlock();
}
scb.match_group = 0;
scb.items_to_match.Add(match_itemid);
}
}
// aqui conditions_specific
foreach (var actions_specific in specific_border_node.Elements("actions"))
{
foreach (var actions_replace_border in actions_specific.Elements("replace_border"))
{
int border_id = 0;
String edge = "";
ushort with_id = 0;
border_id = actions_replace_border.Attribute("id").GetInt32();
edge = actions_replace_border.Attribute("edge").GetString();
with_id = actions_replace_border.Attribute("with").GetUInt16();
if ((border_id == 0) || ("".Equals(edge)) || (with_id == 0))
{
continue;
}
int edge_id = AutoBorder.EdgeNameToEdge(edge);
AutoBorder bit_border = Brushes.getInstance().findBorder(border_id);
if (bit_border == null)
{
throw new Exception("Unknown border id in specific case match block");
}
AutoBorder ab2 = bit_border;
if (ab2 == null)
{
throw new Exception("error ab2 ==null");
}
ItemType it = Global.items.items[with_id];
if (it == null)
{
throw new Exception("Unknown with_id in replace border");
}
it.IsBorder = true;
if (scb == null)
{
scb = new SpecificCaseBlock();
}
scb.to_replace_id = ab2.tiles[edge_id];
scb.with_id = with_id;
}
foreach (var actions_replace_item in actions_specific.Elements("replace_item"))
{
ushort to_replace_id = actions_replace_item.Attribute("to_replace_id").GetUInt16();
ushort with_id = actions_replace_item.Attribute("with").GetUInt16();;
if ((to_replace_id == 0) || (with_id == 0))
{
continue;
}
ItemType it = Global.items.items[with_id];
if (it == null)
{
throw new Exception("Unknown with_id in replace item");
}
it.IsBorder = true;
if (scb == null)
{
scb = new SpecificCaseBlock();
}
scb.to_replace_id = to_replace_id;
scb.with_id = with_id;
}
foreach (var actions_delete_borders in actions_specific.Elements("delete_borders"))
{
if (scb == null)
{
scb = new SpecificCaseBlock();
}
scb.delete_all = true;
}
}
if (scb != null)
{
bb.specific_cases.Add(scb);
}
}
}
borders.Add(bb);
}
foreach (var friend_node in node.Elements("friend"))
{
String friendName = friend_node.Attribute("name").GetString();
if ("all".Equals(friendName))
{
friends.Add(0xFFFFFFFF);
}
else
{
Brush brush = Brushes.getInstance().getBrush(friendName);
if (brush != null)
{
friends.Add(brush.getID());
}
else
{
throw new Exception("Brush" + friendName + " is not defined.");
}
}
hateFriends = false;
}
foreach (var friend_node in node.Elements("enemy"))
{
String enemyName = friend_node.Attribute("name").GetString();
if ("all".Equals(enemyName))
{
friends.Add(0xFFFFFFFF);
}
else
{
Brush brush = Brushes.getInstance().getBrush(enemyName);
if (brush != null)
{
friends.Add(brush.getID());
}
else
{
throw new Exception("Brush" + enemyName + " is not defined.");
}
}
hateFriends = true;
}
foreach (var friend_node in node.Elements("clear_borders"))
{
borders.Clear();
}
foreach (var friend_node in node.Elements("clear_friends"))
{
friends.Clear();
hateFriends = false;
}
if (total_chance == 0)
{
randomize = false;
}
}