Esempio n. 1
0
        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;
                            }
                        }
                    }
                }
            }
        }
Esempio n. 2
0
        public static void doWalls(GameMap map, Tile tile)
        {
            int x = tile.Position.X;
            int y = tile.Position.Y;
            int z = tile.Position.Z;

            List <Item> items_to_add   = new List <Item>();
            List <Item> items_to_erase = new List <Item>();

            foreach (Item wall in tile.Items)
            {
                if (!wall.Type.IsWall)
                {
                    continue;
                }
                WallBrush wall_brush = wall.getWallBrush();
                if (wall_brush == null)
                {
                    continue;
                }


                if (wall_brush as WallDecorationBrush != null)
                {
                    items_to_add.Add(wall);
                    continue;
                }


                bool[] neighbours = new bool[4];
                if (x == 0)
                {
                    if (y == 0)
                    {
                        neighbours[0] = false;
                        neighbours[1] = false;
                        neighbours[2] = hasMatchingWallBrushAtTile(map, wall_brush, x + 1, y, z);
                        neighbours[3] = hasMatchingWallBrushAtTile(map, wall_brush, x, y + 1, z);
                    }
                    else
                    {
                        neighbours[0] = hasMatchingWallBrushAtTile(map, wall_brush, x, y - 1, z);
                        neighbours[1] = false;
                        neighbours[2] = hasMatchingWallBrushAtTile(map, wall_brush, x + 1, y, z);
                        neighbours[3] = hasMatchingWallBrushAtTile(map, wall_brush, x, y + 1, z);
                    }
                }
                else if (y == 0)
                {
                    neighbours[0] = false;
                    neighbours[1] = hasMatchingWallBrushAtTile(map, wall_brush, x - 1, y, z);
                    neighbours[2] = hasMatchingWallBrushAtTile(map, wall_brush, x + 1, y, z);
                    neighbours[3] = hasMatchingWallBrushAtTile(map, wall_brush, x, y + 1, z);
                }
                else
                {
                    neighbours[0] = hasMatchingWallBrushAtTile(map, wall_brush, x, y - 1, z);
                    neighbours[1] = hasMatchingWallBrushAtTile(map, wall_brush, x - 1, y, z);
                    neighbours[2] = hasMatchingWallBrushAtTile(map, wall_brush, x + 1, y, z);
                    neighbours[3] = hasMatchingWallBrushAtTile(map, wall_brush, x, y + 1, z);
                }
                UInt32 tiledata = 0;
                for (int i = 0; i < 4; i++)
                {
                    if (neighbours[i])
                    {
                        tiledata |= (UInt32)1 << i;
                    }
                }
                bool exit = false;
                for (int i = 0; i < 2; ++i)
                {
                    if (exit)
                    {
                        break;
                    }

                    int bt;
                    if (i == 0)
                    {
                        bt = Border_Types.full_border_types[tiledata];
                    }
                    else
                    {
                        bt = Border_Types.half_border_types[tiledata];
                    }
                    if (wall.getWallAlignment() == BorderType.WALL_UNTOUCHABLE)
                    {
                        items_to_add.Add(wall);
                        // items_to_remove.Add(wall);
                        exit = true;
                    }
                    else if (wall.getWallAlignment() == bt)
                    {
                        items_to_add.Add(wall);
                        //it = tile->items.erase(it);
                        exit = true;
                        //while(it != tile->items.end()) {
                        //  todo
                        // }
                    }
                    else
                    {
                        UInt16    id        = 0;
                        WallBrush try_brush = wall_brush;

                        while (true)
                        {
                            if (try_brush == null)
                            {
                                break;
                            }
                            if (id != 0)
                            {
                                break;
                            }

                            WallNode wn = try_brush.wall_items[(int)bt];
                            if (wn.total_chance <= 0)
                            {
                                if (wn.items.Count() == 0)
                                {
                                    try_brush = try_brush.redirect_to;
                                    if (try_brush == wall_brush)
                                    {
                                        break;                                                     // To prevent infinite loop
                                    }
                                    continue;
                                }
                                else
                                {
                                    id = wn.items[0].id;
                                }
                            }
                            else
                            {
                                int chance = random.Next(1, wn.total_chance + 1);
                                foreach (WallType node_iter in wn.items)
                                {
                                    if (chance <= node_iter.chance)
                                    {
                                        id = node_iter.id;
                                        break;
                                    }
                                }
                            }
                            // Propagate down the chain
                            try_brush = try_brush.redirect_to;
                            if (try_brush == wall_brush)
                            {
                                break;                                             // To prevent infinite loop
                            }
                        }
                        if (try_brush == null && id == 0)
                        {
                            if (i == 1)
                            {
                                //++it;
                            }
                            continue;
                        }
                        else
                        {
                            // If there is such an item, add it to the tile
                            Item new_wall = Item.Create(id);
                            if (wall.isSelected())
                            {
//						        new_wall.isSelected = true;
                            }
                            items_to_add.Add(new_wall);
                            exit = true;
                            //++it;
                        }
                    }
                }
            }
            tile.cleanWalls(null);
            foreach (Item item in items_to_add)
            {
                tile.addWallItem(item);
            }
        }
Esempio n. 3
0
        public override void draw(GameMap map, Tile tile, object param = null)
        {
            List <Pair <Item, Item> > replaceItems = new List <Pair <Item, Item> >();

            foreach (Item item in tile.Items)
            {
                if (item.Type.IsWall == false)
                {
                    continue;
                }
                WallBrush wb = item.getWallBrush();
                if (wb == null)
                {
                    continue;
                }

                int wall_alignment = item.getWallAlignment();

                ushort discarded_id  = 0;        // The id of a discarded match
                bool   close_match   = false;
                bool   perfect_match = false;

                bool open = false;
                if (param != null)
                {
                    open = (Boolean)param;
                }

                if (item.Type.IsBrushDoor)
                {
                    open = item.Type.IsOpen;
                }

                WallBrush test_brush = wb;
                do
                {
                    foreach (WallBrush.DoorType dt in test_brush.door_items[wall_alignment])
                    {
                        if (dt.type == doortype)
                        {
                            ItemType it = Global.items.items[dt.id];

                            if (it.IsOpen == open)
                            {
                                //      item = Item.transformItem(item, dt.id, tile);
                                //replaceItems.Add(new Pair<Item,Item>(item,Item.transformItem(item, dt.id, tile)));
                                item.setID(dt.id);
                                perfect_match = true;
                                break;
                            }
                            else if (close_match == false)
                            {
                                discarded_id = dt.id;
                                close_match  = true;
                            }
                            if (!close_match && discarded_id == 0)
                            {
                                discarded_id = dt.id;
                            }
                        }
                    }
                    test_brush = test_brush.redirect_to;
                    if (perfect_match)
                    {
                        break;
                    }
                } while (test_brush != wb && test_brush != null);

                // If we've found no perfect match, use a close-to perfect
                if (perfect_match == false && discarded_id != 0)
                {
                    //   item = Item.transformItem(item, discarded_id, tile);
                    // replaceItems.Add(new Pair<Item, Item>(item, Item.transformItem(item, discarded_id, tile)));
                    item.setID(discarded_id);
                }

                /* HOUSE
                 *      if (Settings.getInteger(Config.AUTO_ASSIGN_DOORID) && tile.isHouseTile())
                 *      {
                 *              Map mmap = map as Map;
                 *              Door door = item as Door;
                 *              if (mmap != null && door != null)
                 *              {
                 *                      House house = mmap.houses.getHouse(tile.getHouseID());
                 *                      Debug.Assert(house);
                 *                      Map real_map = map as Map;
                 *                      if (real_map != null)
                 *                      {
                 *                              door.setDoorID(house.getEmptyDoorID());
                 *                      }
                 *              }
                 *      }*/
                /*
                 *          // We need to consider decorations!
                 *      while (true)
                 *      {
                 *              // Vector has been modified, before we can use the iterator again we need to find the wall item again
                 *              item_iter = tile.items.begin();
                 *              while (true)
                 *              {
                 *                      if (item_iter == tile.items.end())
                 *                      {
                 *                              return;
                 *                      }
                 *                      if (*item_iter == item)
                 *                      {
                 ++item_iter;
                 *                              if (item_iter == tile.items.end())
                 *                              {
                 *                                      return;
                 *                              }
                 *                              break;
                 *                      }
                 ++item_iter;
                 *              }
                 *              // Now it points to the correct item!
                 *
                 *              item = *item_iter;
                 *              if (item.isWall())
                 *              {
                 *                      if (WallDecorationBrush * wdb = item.getWallBrush() as WallDecorationBrush)
                 *                      {
                 *                              // We got a decoration!
                 *                              for (List<WallBrush.DoorType>.Enumerator iter = wdb.door_items[wall_alignment].begin(); iter.MoveNext();)
                 *                              {
                 *                                      WallBrush.DoorType dt = iter.Current;
                 *                                      if (dt.type == doortype)
                 *                                      {
                 *                                              Debug.Assert(dt.id);
                 *                                              ItemType it = item_db[dt.id];
                 *                                              Debug.Assert(it.id != 0);
                 *
                 *                                              if (it.isOpen == open)
                 *                                              {
                 *                                                      item = transformItem(item, dt.id, tile);
                 *                                                      perfect_match = true;
                 *                                                      break;
                 *                                              }
                 *                                              else if (close_match == false)
                 *                                              {
                 *                                                      discarded_id = dt.id;
                 *                                                      close_match = true;
                 *                                              }
                 *                                              if (!close_match && discarded_id == 0)
                 *                                              {
                 *                                                      discarded_id = dt.id;
                 *                                              }
                 *                                      }
                 *                              }
                 *                              // If we've found no perfect match, use a close-to perfect
                 *                              if (perfect_match == false && discarded_id != 0)
                 *                              {
                 *                                      item = transformItem(item, discarded_id, tile);
                 *                              }
                 *                              continue;
                 *                      }
                 *              }
                 *              break;
                 *      } */
                // If we get this far in the loop we should return
            }

            foreach (Pair <Item, Item> replace in replaceItems)
            {
                int index = tile.Items.IndexOf(replace.first);
                if (index > -1)
                {
                    tile.Items.RemoveAt(index);
                    tile.Items.Insert(index, replace.second);
                }
            }
        }
Esempio n. 4
0
        public void unserializeBrush(XElement border_node)
        {
            Brush  brush = null;
            String name  = border_node.Attribute("name").GetString();

            if (name == "")
            {
                //
            }
            brush = getBrush(name);

            if (brush == null)
            {
                String type = border_node.Attribute("type").GetString();

                switch (type)
                {
                case "border":
                    brush = new GroundBrush();
                    break;

                case "ground":
                    brush = new GroundBrush();
                    break;

                case "wall":
                    brush = new WallBrush();
                    break;

                case "wall decoration":
                    brush = new WallDecorationBrush();
                    break;

                case "carpet":
                    brush = new CarpetBrush();
                    break;

                case "table":
                    brush = new TableBrush();
                    break;

                case "doodad":
                    brush = new DoodadBrush();
                    break;

                default:
                    Messages.AddWarning("Unknown brush type type:" + type);
                    break;
                }
                brush.setName(name);
            }

            if (!border_node.HasElements)
            {
                brushList.Add(name, brush);
            }
            else
            {
                brush.load(border_node);

                if (getBrush(name) != null)
                {
                    if (getBrush(name).getLookID() != brush.getLookID())
                    {
                        //erro
                    }
                    else
                    {
                        return;
                    }
                }
                brushList.Add(name, brush);
            }
        }
Esempio n. 5
0
        public override bool canDraw(GameMap map, Position pos)
        {
            Tile tile = map.getTile(pos);

            if (tile == null)
            {
                return(false);
            }
            Item item = tile.getWall();

            if (item == null)
            {
                return(false);
            }
            WallBrush wb = item.getWallBrush();

            if (wb == null)
            {
                return(false);
            }

            int wall_alignment = item.getWallAlignment();

            ushort discarded_id = 0; // The id of a discarded match
            bool   close_match  = false;

            bool open = false;

            if (item.Type.IsBrushDoor)
            {
                open = item.Type.IsOpen;
            }

            WallBrush test_brush = wb;

            do
            {
                foreach (WallBrush.DoorType dt in test_brush.door_items[wall_alignment])
                {
                    if (dt.type == doortype)
                    {
                        //Debug.Assert(dt.id);
                        ItemType it = Global.items.items[dt.id];
                        if (it.IsOpen == open)
                        {
                            return(true);
                        }
                        else if (close_match == false)
                        {
                            discarded_id = dt.id;
                            close_match  = true;
                        }
                        if (!close_match && discarded_id == 0)
                        {
                            discarded_id = dt.id;
                        }
                    }
                }
                test_brush = test_brush.redirect_to;
            } while (test_brush != wb && test_brush != null);
            // If we've found no perfect match, use a close-to perfect
            if (discarded_id != 0)
            {
                return(true);
            }

            return(false);
        }