API tools faq
paste
Guest User

Untitled

a guest
Apr 20th, 2012
136
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 41.79 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Drawing;
  5. using System.IO;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Xml;
  9.  
  10. namespace CellChunkGenerator
  11. {
  12.     public enum WallStyle
  13.     {
  14.         None,
  15.         WestWall,
  16.         WestWallTrans,
  17.         WestWindow,
  18.         WestDoorFrame,
  19.         NorthWall,
  20.         NorthWallTrans,
  21.         NorthWindow,
  22.         NorthDoorFrame,
  23.         NorthWestCorner,
  24.         NorthWestCornerTrans,
  25.         SouthEastCorner,
  26.     }
  27.     public enum RoofStyle
  28.     {
  29.         None,
  30.         WestRoofB,
  31.         WestRoofM,
  32.         WestRoofT,
  33.     }
  34.     public enum TileBlockStyle
  35.     {
  36.         None,
  37.         Solid,
  38.         SolidTransparent,
  39.     }
  40.  
  41.     public enum Direction
  42.     {
  43.         None,
  44.         N,
  45.         NE,
  46.         E,
  47.         SE,
  48.         S,
  49.         SW,
  50.         W,
  51.         NW,
  52.     }
  53.  
  54.     public enum StairStyle
  55.     {
  56.         None,
  57.         BottomW,
  58.         MiddleW,
  59.         TopW,
  60.         BottomN,
  61.         MiddleN,
  62.         TopN,
  63.     }
  64.  
  65.     public enum DoorStyle
  66.     {
  67.         None,
  68.         North,
  69.         West,
  70.     }
  71.  
  72.     public enum LightPolyStyle
  73.     {
  74.         None,
  75.         WallW,
  76.         WallN,
  77.     }
  78.    
  79.     public class UIProperties
  80.     {
  81.  
  82.         [DescriptionAttribute("Light style"),
  83.             CategoryAttribute("Light Settings"),
  84.             DefaultValueAttribute(LightPolyStyle.None)]
  85.         public LightPolyStyle LightPolyStyle { get; set; }
  86.         [DescriptionAttribute("Climb Sheet North"),
  87.               CategoryAttribute("Sheet Settings"),
  88.               DefaultValueAttribute(false)]
  89.         public bool ClimbSheetN { get; set; }
  90.         [DescriptionAttribute("Climb Sheet West"),
  91.               CategoryAttribute("Sheet Settings"),
  92.               DefaultValueAttribute(false)]
  93.         public bool ClimbSheetW { get; set; }
  94.         [DescriptionAttribute("Is tile collidable from the north?"),
  95.             CategoryAttribute("Collision Settings"),
  96.             DefaultValueAttribute(false)]
  97.         public bool CollideNorth { get; set; }
  98.         [DescriptionAttribute("Is tile collidable from the west?"),
  99.             CategoryAttribute("Collision Settings"),
  100.             DefaultValueAttribute(false)]
  101.         public bool CollideWest { get; set; }
  102.         [DescriptionAttribute("Is tile pre-'seen' on the map (aka not starting out black)"),
  103.              CategoryAttribute("Visibility Functions"),
  104.              DefaultValueAttribute(false)]
  105.         public bool PreSeen { get; set; }
  106.         [DescriptionAttribute("Force square tile is on to ambient lighting (useful to get rid of uneven lighting on roofs, for e.g."),
  107.               CategoryAttribute("Lighting Functions"),
  108.               DefaultValueAttribute(false)]
  109.         public bool ForceAmbient { get; set; }
  110.         [DescriptionAttribute("If it is a door what direction is it facing?"),
  111.             CategoryAttribute("Door Functions"),
  112.             DefaultValueAttribute(DoorStyle.None)]
  113.         public DoorStyle Door { get; set; }
  114.         [DescriptionAttribute("If it is a window what direction is it facing?"),
  115.            CategoryAttribute("Window Functions"),
  116.            DefaultValueAttribute(DoorStyle.None)]
  117.         public DoorStyle Window { get; set; }
  118.         [DescriptionAttribute("Smashed Tile Offset (0 == this tile)"),
  119.            CategoryAttribute("Window Functions"),
  120.            DefaultValueAttribute(0)]
  121.         public int SmashedTileOffset { get; set; }
  122.         [DescriptionAttribute("Is window openable?"),
  123.           CategoryAttribute("Window Functions"),
  124.           DefaultValueAttribute(false)]
  125.         public bool WindowLocked { get; set; }
  126.       [DescriptionAttribute("Open Tile Offset (0 == this tile)"),
  127.            CategoryAttribute("Window Functions"),
  128.            DefaultValueAttribute(0)]
  129.         public int OpenTileOffset { get; set; }
  130.         [DescriptionAttribute("If it is a door frame what direction is it facing?"),
  131.             CategoryAttribute("Door Functions"),
  132.        DefaultValueAttribute(DoorStyle.None)]
  133.         public DoorStyle DoorFrame { get; set; }
  134.         [DescriptionAttribute("Is it a water source piped?"),
  135.        CategoryAttribute("Water Functions"),
  136.           DefaultValueAttribute(false)]
  137.         public bool WaterPiped { get; set; }
  138.         [DescriptionAttribute("How many units worth of water is in here? (10 = one bottle)"),
  139.             CategoryAttribute("Water Functions"),
  140.             DefaultValueAttribute(0)]
  141.         public int WaterAmount { get; set; }
  142.         [DescriptionAttribute("How many max units worth of water is in here when filled? (10 = one bottle)"),
  143.             CategoryAttribute("Water Functions"),
  144.             DefaultValueAttribute(0)]
  145.         public int WaterMaxAmount { get; set; }
  146.         [DescriptionAttribute("Can the player / NPCs sleep on the object?"),
  147.             CategoryAttribute("Extra Functions"),
  148.             DefaultValueAttribute(false)]
  149.         public bool IsBed { get; set; }
  150.         [DescriptionAttribute("Hoppable North"),
  151.              CategoryAttribute("Wall Settings"),
  152.              DefaultValueAttribute(false)]
  153.         public bool HoppableN { get; set; }
  154.         [DescriptionAttribute("Hoppable West"),
  155.               CategoryAttribute("Wall Settings"),
  156.               DefaultValueAttribute(false)]
  157.         public bool HoppableW { get; set; }
  158.         [DescriptionAttribute("If it is a wall piece, the type of wall."),
  159.               CategoryAttribute("Wall Settings"),
  160.               DefaultValueAttribute(WallStyle.None)]
  161.         public WallStyle WallStyle { get; set; }
  162.         [DescriptionAttribute("If it is a stair piece, the type of stair."),
  163.             CategoryAttribute("Stair Settings"),
  164.             DefaultValueAttribute(StairStyle.None)]
  165.         public StairStyle StairStyle { get; set; }
  166.         [DescriptionAttribute("If it is a roof piece, the type of roof piece."),
  167.             CategoryAttribute("Roof Settings"),
  168.             DefaultValueAttribute(RoofStyle.None)]
  169.         public RoofStyle RoofStyle { get; set; }
  170.         [DescriptionAttribute("Is there a floor on the tile characters can walk on?"),
  171.             CategoryAttribute("Floor Settings"),
  172.             DefaultValueAttribute(false)]
  173.         public bool IsFloor { get; set; }
  174.         [DescriptionAttribute("Is the tilepiece an indoor tile? (Cuts higher floors if stood on) Only indoor floor tiles need this."),
  175.             CategoryAttribute("Floor Settings"),
  176.             DefaultValueAttribute(true)]
  177.         public bool IsIndoor { get; set; }
  178.         [DescriptionAttribute("Is tile an overlay for a floor piece? (i.e. smooth lit decal)"),
  179.             CategoryAttribute("Floor Settings"),
  180.             DefaultValueAttribute(false)]
  181.         public bool FloorOverlay { get; set; }
  182.         [DescriptionAttribute("If it is an in-tile object, is it collidable / transparent?"),
  183.             CategoryAttribute("Global Settings"),
  184.             DefaultValueAttribute(TileBlockStyle.None)]
  185.         public TileBlockStyle TileBlockStyle { get; set; }
  186.  
  187.         [DescriptionAttribute("Is tile an overlay for a wall piece? (i.e. smooth lit decal)"),
  188.             CategoryAttribute("Wall Settings"),
  189.             DefaultValueAttribute(false)]
  190.         public bool WallOverlay { get; set; }
  191.         [DescriptionAttribute("Orientation of floor height item shelves (None = no shelves)"),
  192.             CategoryAttribute("Shelf Settings"),
  193.             DefaultValueAttribute(Direction.None)]
  194.         public Direction FloorItemShelf { get; set; }
  195.         [DescriptionAttribute("Orientation of floor height item shelves (None = no shelves)"),
  196.             CategoryAttribute("Shelf Settings"),
  197.             DefaultValueAttribute(Direction.None)]
  198.         public Direction TableItemShelf { get; set; }
  199.         [DescriptionAttribute("Orientation of head height item shelves (None = no shelves)"),
  200.             CategoryAttribute("Shelf Settings"),
  201.             DefaultValueAttribute(Direction.None)]
  202.         public Direction HighItemShelf { get; set; }
  203.         [DescriptionAttribute("Name, if any, of the container the tile can store items in."),
  204.             CategoryAttribute("Object Settings"),
  205.             DefaultValueAttribute("")]
  206.         public String ContainerType { get; set; }
  207.         [DescriptionAttribute("Is it a wheeliebin?"),
  208.               CategoryAttribute("Object Settings"),
  209.               DefaultValueAttribute(false)]
  210.         public bool WheelieBin { get; set; }
  211.         public void FromProperties(Dictionary<string, string> properties)
  212.         {
  213.  
  214.  
  215.             if (properties.ContainsKey("WheelieBin"))
  216.             {
  217.                 WheelieBin = true;
  218.             }
  219.  
  220.  
  221.             if (properties.ContainsKey("collideW"))
  222.             {
  223.                 CollideWest = true;
  224.             }
  225.             if (properties.ContainsKey("collideN"))
  226.             {
  227.                 CollideNorth = true;
  228.             }
  229.             if (properties.ContainsKey("climbSheetN"))
  230.             {
  231.                 ClimbSheetN = true;
  232.             }
  233.  
  234.             if (properties.ContainsKey("climbSheetW"))
  235.             {
  236.                 ClimbSheetW = true;
  237.             }
  238.  
  239.             if (properties.ContainsKey("HoppableN"))
  240.             {
  241.                 HoppableN = true;
  242.             }
  243.             if (properties.ContainsKey("HoppableW"))
  244.             {
  245.                 HoppableW = true;
  246.             }
  247.             if (properties.ContainsKey("ForceAmbient"))
  248.             {
  249.                 ForceAmbient = true;
  250.             }
  251.             if (properties.ContainsKey("bed"))
  252.             {
  253.                 IsBed = true;
  254.             }
  255.             if (properties.ContainsKey("PreSeen"))
  256.             {
  257.                 PreSeen = true;
  258.             }
  259.             if (properties.ContainsKey("WindowLocked"))
  260.             {
  261.                 WindowLocked = true;
  262.             }
  263.             if (properties.ContainsKey("SmashedTileOffset"))
  264.             {
  265.                 SmashedTileOffset = Convert.ToInt32(properties["SmashedTileOffset"]);
  266.             }
  267.             if (properties.ContainsKey("OpenTileOffset"))
  268.             {
  269.                 SmashedTileOffset = Convert.ToInt32(properties["OpenTileOffset"]);
  270.             }
  271.             if (properties.ContainsKey("LightPolyStyle"))
  272.             {
  273.                 LightPolyStyle = (LightPolyStyle)Enum.Parse(LightPolyStyle.GetType(), properties["LightPolyStyle"]);
  274.             }
  275.            
  276.             if (properties.ContainsKey("doorN"))
  277.             {
  278.                 Door = DoorStyle.North;
  279.             }
  280.             if (properties.ContainsKey("doorW"))
  281.             {
  282.                 Door = DoorStyle.West;
  283.             }
  284.             if (properties.ContainsKey("windowN"))
  285.             {
  286.                 Window = DoorStyle.North;
  287.             }
  288.             if (properties.ContainsKey("windowW"))
  289.             {
  290.                 Window = DoorStyle.West;
  291.             }
  292.             if (properties.ContainsKey("doorFrN"))
  293.             {
  294.                 DoorFrame = DoorStyle.North;
  295.             }
  296.             if (properties.ContainsKey("doorFrW"))
  297.             {
  298.                 DoorFrame = DoorStyle.West;
  299.             }
  300.            
  301.             if (properties.ContainsKey("waterAmount"))
  302.             {
  303.                 WaterAmount = Convert.ToInt32(properties["waterAmount"]);
  304.             }
  305.             if (properties.ContainsKey("waterMaxAmount"))
  306.             {
  307.                 WaterMaxAmount = Convert.ToInt32(properties["waterMaxAmount"]);
  308.             }
  309.             if (properties.ContainsKey("waterPiped"))
  310.             {
  311.                 WaterPiped = true;
  312.             }
  313.             if (properties.ContainsKey("WestRoofB"))
  314.             {
  315.                 RoofStyle = RoofStyle.WestRoofB;
  316.             }
  317.             else if (properties.ContainsKey("WestRoofM"))
  318.             {
  319.                 RoofStyle = RoofStyle.WestRoofM;
  320.             }
  321.             else if (properties.ContainsKey("WestRoofT"))
  322.             {
  323.                 RoofStyle = RoofStyle.WestRoofT;
  324.             }
  325.             if (properties.ContainsKey("WallOverlay"))
  326.             {
  327.                 WallOverlay = true;
  328.             }
  329.             if (properties.ContainsKey("FloorOverlay"))
  330.             {
  331.                 FloorOverlay = true;
  332.             }
  333.             if (properties.ContainsKey("stairsBW"))
  334.             {
  335.                 StairStyle = StairStyle.BottomW;
  336.             }
  337.             else if (properties.ContainsKey("stairsMW"))
  338.             {
  339.                 StairStyle = StairStyle.MiddleW;
  340.             }
  341.             else if (properties.ContainsKey("stairsTW"))
  342.             {
  343.                 StairStyle = StairStyle.TopW;
  344.             }
  345.             else if (properties.ContainsKey("stairsBN"))
  346.             {
  347.                 StairStyle = StairStyle.BottomN;
  348.             }
  349.             else if (properties.ContainsKey("stairsMN"))
  350.             {
  351.                 StairStyle = StairStyle.MiddleN;
  352.             }
  353.             else if (properties.ContainsKey("stairsTN"))
  354.             {
  355.                 StairStyle = StairStyle.TopN;
  356.             }
  357.             IsIndoor = true;
  358.             if (properties.ContainsKey("windowFW"))
  359.             {
  360.                 WallStyle = WallStyle.WestWindow;
  361.                 properties.Remove("collideW");
  362.             }
  363.             else if (properties.ContainsKey("windowFN"))
  364.             {
  365.                 WallStyle = WallStyle.NorthWindow;
  366.                 properties.Remove("collideN");
  367.             }
  368.             else if (properties.ContainsKey("collideW") && properties.ContainsKey("cutW") && !properties.ContainsKey("collideN") && !properties.ContainsKey("windowFW"))
  369.             {
  370.                 WallStyle = WallStyle.WestWall;
  371.  
  372.             }
  373.             else if (properties.ContainsKey("collideW") && properties.ContainsKey("cutW") && properties.ContainsKey("collideN"))
  374.             {
  375.                 WallStyle = WallStyle.NorthWestCorner;
  376.  
  377.             }
  378.             else if (properties.ContainsKey("cutN") && properties.ContainsKey("cutW") && !properties.ContainsKey("collideN") && !properties.ContainsKey("collideW"))
  379.             {
  380.                 WallStyle = WallStyle.SouthEastCorner;
  381.             }
  382.             else if (properties.ContainsKey("cutN"))
  383.             {
  384.                 WallStyle = WallStyle.NorthDoorFrame;    
  385.             }
  386.             else if (properties.ContainsKey("cutW"))
  387.             {
  388.                 WallStyle = WallStyle.WestDoorFrame;    
  389.             }
  390.  
  391.             if (properties.ContainsKey("WallW"))
  392.             {
  393.                 WallStyle = WallStyle.WestWall;
  394.             }
  395.             else if (properties.ContainsKey("WallN"))
  396.             {
  397.                 WallStyle = WallStyle.NorthWall;
  398.             }
  399.             else if (properties.ContainsKey("WallNW"))
  400.             {
  401.                 WallStyle = WallStyle.NorthWestCorner;
  402.             }
  403.             else if (properties.ContainsKey("WallWTrans"))
  404.             {
  405.                 WallStyle = WallStyle.WestWallTrans;
  406.             }
  407.             else if (properties.ContainsKey("WallNTrans"))
  408.             {
  409.                 WallStyle = WallStyle.NorthWallTrans;
  410.             }
  411.             else if (properties.ContainsKey("WallNWTrans"))
  412.             {
  413.                 WallStyle = WallStyle.NorthWestCornerTrans;
  414.             }
  415.             else if (properties.ContainsKey("WallSE"))
  416.             {
  417.                 WallStyle = WallStyle.SouthEastCorner;
  418.             }
  419.             else if (properties.ContainsKey("WindowW"))
  420.             {
  421.                 WallStyle = WallStyle.WestWindow;
  422.             }
  423.             else if (properties.ContainsKey("WindowN"))
  424.             {
  425.                 WallStyle = WallStyle.NorthWindow;
  426.             }
  427.             else if (properties.ContainsKey("DoorWallW"))
  428.             {
  429.                 WallStyle = WallStyle.WestDoorFrame;
  430.             }
  431.             else if (properties.ContainsKey("DoorWallN"))
  432.             {
  433.                 WallStyle = WallStyle.NorthDoorFrame;
  434.             }
  435.  
  436.  
  437.  
  438.             if (properties.ContainsKey("solid"))
  439.             {
  440.                 TileBlockStyle = TileBlockStyle.Solid;
  441.             }
  442.             if (properties.ContainsKey("solidtrans"))
  443.             {
  444.                 TileBlockStyle = TileBlockStyle.SolidTransparent;
  445.             }
  446.  
  447.             if(properties.ContainsKey("container"))
  448.             {
  449.                 ContainerType = properties["container"];
  450.             }
  451.  
  452.             if (properties.ContainsKey("solidfloor"))
  453.             {
  454.                 IsFloor = true;
  455.             }
  456.  
  457.             properties.Remove("interior");
  458.            
  459.             if (properties.ContainsKey("exterior"))
  460.             {
  461.                 IsIndoor = false;
  462.             }
  463.             if (properties.ContainsKey("floorS") && properties.ContainsKey("floorW"))
  464.             {
  465.                 FloorItemShelf = Direction.SW;
  466.             }
  467.             else if (properties.ContainsKey("floorN") && properties.ContainsKey("floorW"))
  468.             {
  469.                 FloorItemShelf = Direction.NW;
  470.             }
  471.             else if (properties.ContainsKey("floorS") && properties.ContainsKey("floorE"))
  472.             {
  473.                 FloorItemShelf = Direction.SE;
  474.             }
  475.             else if (properties.ContainsKey("floorN") && properties.ContainsKey("floorE"))
  476.             {
  477.                 FloorItemShelf = Direction.NE;
  478.             }
  479.             else if (properties.ContainsKey("floorE"))
  480.             {
  481.                 FloorItemShelf = Direction.E;
  482.  
  483.             }
  484.             else if (properties.ContainsKey("floorN"))
  485.             {
  486.                 FloorItemShelf = Direction.N;
  487.  
  488.             }
  489.             else if (properties.ContainsKey("floorS"))
  490.             {
  491.                 FloorItemShelf = Direction.S;
  492.  
  493.             }
  494.             else if (properties.ContainsKey("floorW"))
  495.             {
  496.                 FloorItemShelf = Direction.W;
  497.  
  498.             }
  499.             if (properties.ContainsKey("tableS") && properties.ContainsKey("tableW"))
  500.             {
  501.                 HighItemShelf = Direction.SW;
  502.             }
  503.             else if (properties.ContainsKey("tableN") && properties.ContainsKey("tableW"))
  504.             {
  505.                 HighItemShelf = Direction.NW;
  506.             }
  507.             else if (properties.ContainsKey("tableS") && properties.ContainsKey("tableE"))
  508.             {
  509.                 TableItemShelf = Direction.SE;
  510.             }
  511.             else if (properties.ContainsKey("tableN") && properties.ContainsKey("tableE"))
  512.             {
  513.                 TableItemShelf = Direction.NE;
  514.             }
  515.             else if (properties.ContainsKey("tableE"))
  516.             {
  517.                 TableItemShelf = Direction.E;
  518.  
  519.             }
  520.             else if (properties.ContainsKey("tableN"))
  521.             {
  522.                 TableItemShelf = Direction.N;
  523.  
  524.             }
  525.             else if (properties.ContainsKey("tableS"))
  526.             {
  527.                 TableItemShelf = Direction.S;
  528.  
  529.             }
  530.             else if (properties.ContainsKey("tableW"))
  531.             {
  532.                 TableItemShelf = Direction.W;
  533.  
  534.             }
  535.          
  536.  
  537.             if (properties.ContainsKey("shelfS") && properties.ContainsKey("shelfW"))
  538.             {
  539.                 HighItemShelf = Direction.SW;
  540.             }
  541.             else if (properties.ContainsKey("shelfN") && properties.ContainsKey("shelfW"))
  542.             {
  543.                 HighItemShelf = Direction.NW;
  544.             }
  545.             else if (properties.ContainsKey("shelfS") && properties.ContainsKey("shelfE"))
  546.             {
  547.                 HighItemShelf = Direction.SE;
  548.             }
  549.             else if (properties.ContainsKey("shelfN") && properties.ContainsKey("shelfE"))
  550.             {
  551.                 HighItemShelf = Direction.NE;
  552.             }
  553.             else if (properties.ContainsKey("shelfE"))
  554.             {
  555.                 HighItemShelf = Direction.E;
  556.  
  557.             }
  558.             else if (properties.ContainsKey("shelfN"))
  559.             {
  560.                 HighItemShelf = Direction.N;
  561.  
  562.             }
  563.             else if (properties.ContainsKey("shelfS"))
  564.             {
  565.                 HighItemShelf = Direction.S;
  566.  
  567.             }
  568.             else if (properties.ContainsKey("shelfW"))
  569.             {
  570.                 HighItemShelf = Direction.W;
  571.  
  572.             }
  573.      
  574.  
  575.         }
  576.  
  577.     }
  578.     public class Tile
  579.     {
  580.         public Dictionary<String, String> Properties = new Dictionary<string, string>();
  581.         public UIProperties propertyUI = new UIProperties();
  582.  
  583.         public void ChangeProperties(string label, object oldValue, object value)
  584.         {          
  585.             /*
  586.               if (properties.ContainsKey("WaterAmount"))
  587.             {
  588.                 WaterAmount = Convert.ToInt32(properties["WaterAmount"]);
  589.             }
  590.             if (properties.ContainsKey("WaterPiped"))
  591.             {
  592.                 WaterPiped = true;
  593.             }
  594.              */
  595.  
  596.             if (label == "LightPolyStyle")
  597.             {
  598.                 Properties.Remove("LightPolyStyle");
  599.                 if ((LightPolyStyle)value != LightPolyStyle.None)
  600.                 {
  601.                     Properties["LightPolyStyle"] = ((LightPolyStyle)value).ToString();
  602.                 }
  603.  
  604.             }
  605.             if (label == "ClimbSheetN")
  606.             {
  607.                 Properties.Remove("climbSheetN");
  608.                 if ((bool)value == true)
  609.                 {
  610.                     Properties["climbSheetN"] = "";
  611.                 }
  612.  
  613.             }
  614.             if (label == "ClimbSheetW")
  615.             {
  616.                 Properties.Remove("climbSheetW");
  617.                 if ((bool)value == true)
  618.                 {
  619.                     Properties["climbSheetW"] = "";
  620.                 }
  621.  
  622.             }
  623.             if (label == "WheelieBin")
  624.             {
  625.                 Properties.Remove("WheelieBin");
  626.                 if ((bool)value == true)
  627.                 {
  628.                     Properties["WheelieBin"] = "";
  629.                 }
  630.  
  631.             }
  632.             if (label == "CollideWest")
  633.             {
  634.                 Properties.Remove("collideW");
  635.                 if ((bool)value == true)
  636.                 {
  637.                     Properties["collideW"] = "";
  638.                 }
  639.  
  640.             }
  641.             if (label == "CollideNorth")
  642.             {
  643.                 Properties.Remove("collideN");
  644.                 if ((bool)value == true)
  645.                 {
  646.                     Properties["collideN"] = "";
  647.                 }
  648.  
  649.             }
  650.             if (label == "PreSeen")
  651.             {
  652.                 Properties.Remove("PreSeen");
  653.                 if ((bool)value == true)
  654.                 {
  655.                     Properties["PreSeen"] = "";
  656.                 }
  657.  
  658.             }
  659.             if (label == "HoppableW")
  660.             {
  661.                 Properties.Remove("HoppableW");
  662.                 if ((bool)value == true)
  663.                 {
  664.                     Properties["HoppableW"] = "";
  665.                 }
  666.  
  667.             }
  668.             if (label == "HoppableN")
  669.             {
  670.                 Properties.Remove("HoppableN");
  671.                 if ((bool)value == true)
  672.                 {
  673.                     Properties["HoppableN"] = "";
  674.                 }
  675.  
  676.             }
  677.             if (label == "IsBed")
  678.             {
  679.                 Properties.Remove("bed");
  680.                 if ((bool)value == true)
  681.                 {
  682.                     Properties["bed"] = "";
  683.                 }
  684.  
  685.             }
  686.             if (label == "ForceAmbient")
  687.             {
  688.                 Properties.Remove("ForceAmbient");
  689.                 if ((bool)value == true)
  690.                 {
  691.                     Properties["ForceAmbient"] = "";
  692.                 }
  693.  
  694.             }
  695.             if (label == "WindowLocked")
  696.             {
  697.                 Properties.Remove("WindowLocked");
  698.                 if ((bool)value == true)
  699.                 {
  700.                     Properties["WindowLocked"] = "";
  701.                 }
  702.  
  703.             }
  704.            
  705.             if (label == "SmashedTileOffset")
  706.             {
  707.                 Properties["SmashedTileOffset"] = ((int)value).ToString();
  708.  
  709.             }
  710.             if (label == "OpenTileOffset")
  711.             {
  712.                 Properties["OpenTileOffset"] = ((int)value).ToString();
  713.             }
  714.            
  715.  
  716.             if (label == "Door")
  717.             {
  718.                 Properties.Remove("doorN");
  719.                 Properties.Remove("doorW");
  720.  
  721.                 switch ((DoorStyle)value)
  722.                 {
  723.                     case DoorStyle.North:
  724.                         Properties["doorN"] = "";
  725.                         break;
  726.                     case DoorStyle.West:
  727.                         Properties["doorW"] = "";
  728.                         break;
  729.                 }
  730.             }
  731.             if (label == "Window")
  732.             {
  733.                 Properties.Remove("windowN");
  734.                 Properties.Remove("windowW");
  735.  
  736.                 switch ((DoorStyle)value)
  737.                 {
  738.                     case DoorStyle.North:
  739.                         Properties["windowN"] = "";
  740.                         break;
  741.                     case DoorStyle.West:
  742.                         Properties["windowW"] = "";
  743.                         break;
  744.                 }
  745.             }
  746.             if (label == "DoorFrame")
  747.             {
  748.                 Properties.Remove("doorFrN");
  749.                 Properties.Remove("doorFrW");
  750.  
  751.                 switch ((DoorStyle)value)
  752.                 {
  753.                     case DoorStyle.North:
  754.                         Properties["doorFrN"] = "";
  755.                         break;
  756.                     case DoorStyle.West:
  757.                         Properties["doorFrW"] = "";
  758.                         break;
  759.                 }
  760.             }
  761.          
  762.  
  763.             if (label == "WaterAmount")
  764.             {
  765.                 Properties.Remove("waterAmount");
  766.                 if ((int)value != 0)
  767.                 {
  768.                     Properties["waterAmount"] = ((int)value).ToString();
  769.                 }
  770.  
  771.             }
  772.             if (label == "WaterMaxAmount")
  773.             {
  774.                 Properties.Remove("waterMaxAmount");
  775.                 if ((int)value != 0)
  776.                 {
  777.                     Properties["waterMaxAmount"] = ((int)value).ToString();
  778.                 }
  779.  
  780.             }
  781.             else if (label == "WaterPiped")
  782.             {
  783.                 Properties.Remove("waterPiped");
  784.                 if((bool)value == true)
  785.                 {
  786.                     Properties["waterPiped"] = "";
  787.                 }
  788.             }
  789.  
  790.             if (label == "RoofStyle")
  791.             {
  792.                 Properties.Remove("WestRoofB");
  793.                 Properties.Remove("WestRoofM");
  794.                 Properties.Remove("WestRoofT");
  795.  
  796.                 switch ((RoofStyle)value)
  797.                 {
  798.                     case RoofStyle.WestRoofB:
  799.                         Properties["WestRoofB"] = "";
  800.                         break;
  801.                     case RoofStyle.WestRoofM:
  802.                         Properties["WestRoofM"] = "";
  803.                         break;
  804.                     case RoofStyle.WestRoofT:
  805.                         Properties["WestRoofT"] = "";
  806.                         break;
  807.                  
  808.                 }
  809.             }
  810.             if (label == "TileBlockStyle")
  811.             {
  812.                 Properties.Remove("solid");
  813.                 Properties.Remove("solidtrans");
  814.  
  815.                 switch ((TileBlockStyle)value)
  816.                 {
  817.                     case TileBlockStyle.Solid:
  818.                         Properties["solid"] = "";
  819.                         break;
  820.                     case TileBlockStyle.SolidTransparent:
  821.                         Properties["solidtrans"] = "";
  822.                         break;
  823.                 }
  824.             }
  825.             if (label == "IsIndoor")
  826.            {
  827.                Properties.Remove("interior");
  828.                Properties.Remove("exterior");
  829.                if (((bool)(value)) == false)
  830.                {
  831.                    Properties["exterior"] = "";
  832.                }
  833.            }
  834.            if (label == "FloorOverlay")
  835.            {
  836.                Properties.Remove("FloorOverlay");
  837.  
  838.                if (((bool)(value)) == true)
  839.                {
  840.                    Properties["FloorOverlay"] = "";
  841.                }
  842.            }
  843.            if (label == "WallOverlay")
  844.            {
  845.                Properties.Remove("WallOverlay");
  846.  
  847.                if (((bool)(value)) == true)
  848.                {
  849.                    Properties["WallOverlay"] = "";
  850.                }
  851.            }
  852.            if (label == "IsFloor")
  853.            {
  854.                Properties.Remove("solidfloor");
  855.                if(((bool)(value)) == true)
  856.                {
  857.                    Properties["solidfloor"] = "";                    
  858.                }
  859.            }
  860.                
  861.            else if(label=="WallStyle")
  862.            {
  863.                Properties.Remove("wall");
  864.                Properties.Remove("WallN");
  865.                Properties.Remove("WallW");
  866.                Properties.Remove("WallNTrans");
  867.                Properties.Remove("WallWTrans");
  868.                Properties.Remove("DoorWallN");
  869.                Properties.Remove("DoorWallW");
  870.                Properties.Remove("WallNW");
  871.                Properties.Remove("WallNWTrans");
  872.                Properties.Remove("doorFrW");
  873.                Properties.Remove("doorFrN");
  874.                Properties.Remove("WallSE");
  875.                Properties.Remove("WindowW");
  876.                Properties.Remove("WindowN");
  877.                Properties.Remove("collideW");
  878.                Properties.Remove("collideN");
  879.                Properties.Remove("cutW");
  880.                Properties.Remove("cutN");
  881.                Properties.Remove("transparentW");
  882.                Properties.Remove("transparentN");
  883.                Properties.Remove("windowFW");
  884.                Properties.Remove("windowFN");
  885.                Properties["wall"] = "";
  886.                switch ((WallStyle)value)
  887.                {
  888.                    case WallStyle.None:
  889.                        Properties.Remove("wall");
  890.                        break;
  891.                    case WallStyle.NorthWall:
  892.                        Properties["WallN"] = "";
  893.                        break;
  894.                    case WallStyle.WestWall:
  895.                        Properties["WallW"] = "";
  896.                        break;
  897.                    case WallStyle.NorthWallTrans:
  898.                        Properties["WallNTrans"] = "";
  899.                        break;
  900.                    case WallStyle.WestWallTrans:
  901.                        Properties["WallWTrans"] = "";
  902.                        break;
  903.                    case WallStyle.NorthDoorFrame:
  904.                        Properties["DoorWallN"] = "";
  905.                        break;
  906.                    case WallStyle.WestDoorFrame:
  907.                        Properties["DoorWallW"] = "";
  908.                        break;
  909.                    case WallStyle.NorthWestCorner:
  910.                        Properties["WallNW"] = "";
  911.                        break;
  912.                    case WallStyle.NorthWestCornerTrans:
  913.                        Properties["WallNWTrans"] = "";
  914.                        break;
  915.                    case WallStyle.SouthEastCorner:
  916.                        Properties["WallSE"] = "";
  917.                        break;
  918.                    case WallStyle.WestWindow:
  919.                        Properties["WindowW"] = "";
  920.                        break;
  921.                    case WallStyle.NorthWindow:
  922.                        Properties["WindowN"] = "";
  923.                        break;
  924.  
  925.                }
  926.  
  927.            }
  928.            else if (label == "ContainerType")
  929.            {
  930.                Properties.Remove("container");
  931.  
  932.                if (((string)value).Trim().Length > 0)
  933.                 Properties["container"] = ((string)value).Trim();
  934.  
  935.            }
  936.            else if (label == "StairStyle")
  937.            {
  938.                Properties.Remove("stairsBW");
  939.                Properties.Remove("stairsMW");
  940.                Properties.Remove("stairsTW");
  941.                Properties.Remove("stairsBN");
  942.                Properties.Remove("stairsMN");
  943.                Properties.Remove("stairsTN");
  944.                switch ((StairStyle)value)
  945.                {
  946.                    case StairStyle.BottomW:
  947.                        Properties["stairsBW"] = "";
  948.                        break;
  949.                    case StairStyle.MiddleW:
  950.                        Properties["stairsMW"] = "";
  951.                        break;
  952.                    case StairStyle.TopW:
  953.                        Properties["stairsTW"] = "";
  954.                        break;
  955.                    case StairStyle.BottomN:
  956.                        Properties["stairsBN"] = "";
  957.                        break;
  958.                    case StairStyle.MiddleN:
  959.                        Properties["stairsMN"] = "";
  960.                        break;
  961.                    case StairStyle.TopN:
  962.                        Properties["stairsTN"] = "";
  963.                        break;
  964.  
  965.                }
  966.            }
  967.         }
  968.     }
  969.     public class Tileset
  970.     {
  971.         public String name;
  972.         public int widthTiles;
  973.         public int heightTiles;
  974.         public List<Tile> Tiles = new List<Tile>();
  975.         public string source;
  976.  
  977.         public void ChangeProperties(List<int> selectionList, string label, object oldValue, object value)
  978.         {
  979.             int n = 0;
  980.             foreach (var tile in Tiles)
  981.             {
  982.                 if(selectionList.Contains(n))
  983.                 {
  984.                     tile.ChangeProperties(label, oldValue, value);
  985.                 }
  986.                 n++;
  987.             }
  988.         }
  989.     }
  990.     public class TileSetSystem
  991.     {
  992.         public static TileSetSystem instance = new TileSetSystem();
  993.         //public List<Tileset> Tilesets = new List<Tileset>();
  994.         public Dictionary<String, Tileset> Tilesets = new Dictionary<String, Tileset>();
  995.  
  996.         public void Add(String filename)
  997.         {
  998.             String ofilename = filename;
  999.             if (filename.Contains("/"))
  1000.             {
  1001.                 filename = filename.Substring(filename.LastIndexOf("/") + 1);
  1002.             }
  1003.             if (filename.Contains("\\"))
  1004.             {
  1005.                 filename = filename.Substring(filename.LastIndexOf("\\") + 1);
  1006.             }
  1007.             Tileset set = null;
  1008.             if (Tilesets.ContainsKey(filename.Replace(".png", "")))
  1009.                 set = Tilesets[filename.Replace(".png", "")];
  1010.             else
  1011.             {
  1012.                 set = new Tileset();
  1013.                 set.source = filename;
  1014.                 if (set.source.Contains("/"))
  1015.                 {
  1016.                     set.source = set.source.Substring(set.source.LastIndexOf("/") + 1);
  1017.                 }
  1018.                 if (set.source.Contains("\\"))
  1019.                 {
  1020.                     set.source = set.source.Substring(set.source.LastIndexOf("\\") + 1);
  1021.                 }
  1022.                 set.name = set.source.Replace(".png", "");
  1023.                 Image bmp = Image.FromFile(ofilename);
  1024.                 set.widthTiles = bmp.Width / 64;
  1025.                 set.heightTiles = bmp.Height / 128;
  1026.                 Tilesets[set.name] = set;
  1027.                 for (int m = 0; m < set.widthTiles * set.heightTiles; m++)
  1028.                 {
  1029.                     Tile t = new Tile();
  1030.                     set.Tiles.Add(t);
  1031.                 }
  1032.             }
  1033.         }
  1034.  
  1035.         public void Import(String filename)
  1036.         {
  1037.             XmlDocument doc = new XmlDocument();
  1038.             doc.Load(filename);
  1039.  
  1040.             XmlNode n = doc.FirstChild.NextSibling.FirstChild;
  1041.  
  1042.             while(n != null)
  1043.             {
  1044.                 if(n.Name == "tileset")
  1045.                 {
  1046.                     XmlNode image = n.FirstChild;
  1047.                     XmlNode tile = n.FirstChild.NextSibling;
  1048.  
  1049.                     Tileset set = null;
  1050.  
  1051.                     if (Tilesets.ContainsKey(image.Attributes["source"].Value.Replace(".png", "")))
  1052.                         set = Tilesets[image.Attributes["source"].Value.Replace(".png", "")];
  1053.                     else
  1054.                     {
  1055.                         set = new Tileset();
  1056.                         set.source = image.Attributes["source"].Value;
  1057.                         if (set.source.Contains("/"))
  1058.                         {
  1059.                             set.source = set.source.Substring(set.source.LastIndexOf("/") + 1);
  1060.                         }
  1061.                         set.name = set.source.Replace(".png", "");
  1062.                         Image bmp = Image.FromFile(set.source);
  1063.                         set.widthTiles = bmp.Width/64;
  1064.                         set.heightTiles = bmp.Height / 128;
  1065.                         Tilesets[set.name] = set;
  1066.                         for (int m = 0; m < set.widthTiles * set.heightTiles; m++)
  1067.                         {
  1068.                             Tile t = new Tile();
  1069.                             set.Tiles.Add(t);
  1070.                         }
  1071.                     }
  1072.                     while (tile != null)
  1073.                     {
  1074.                         XmlNode properties = tile.FirstChild;
  1075.                         int id = Convert.ToInt32(tile.Attributes["id"].Value);
  1076.                         Tile t = set.Tiles[id];
  1077.                         if (properties != null)
  1078.                         {
  1079.                             XmlNode property = properties.FirstChild;
  1080.                             while (property != null)
  1081.                             {
  1082.  
  1083.                                 if (property.Attributes["name"].Value == "interior")
  1084.                                 {
  1085.                                     t.Properties["exterior"] = "";
  1086.                                 }
  1087.                                 else
  1088.                                 {
  1089.                                     t.Properties[property.Attributes["name"].Value] = property.Attributes["value"].Value;    
  1090.                                 }
  1091.                                
  1092.  
  1093.                                 property = property.NextSibling;
  1094.                             }
  1095.                             t.propertyUI.FromProperties(t.Properties);
  1096.                         }
  1097.                         tile = tile.NextSibling;
  1098.                     }
  1099.                 }
  1100.                 n = n.NextSibling;
  1101.             }
  1102.         }
  1103.  
  1104.         public void SaveString(BinaryWriter binWriter, String str)
  1105.         {
  1106.             foreach (var c in str)
  1107.             {
  1108.                 binWriter.Write(c);
  1109.             }
  1110.             binWriter.Write('\n');
  1111.         }
  1112.  
  1113.         private string ReadString(BinaryReader binReader)
  1114.         {
  1115.             String str = "";
  1116.  
  1117.             char c = ' ';
  1118.             while(c!='\n')
  1119.             {
  1120.                 c = binReader.ReadChar();
  1121.                 if( c!='\n')
  1122.                     str += c;
  1123.             }
  1124.             return str;
  1125.         }
  1126.         public void Save(string fileName)
  1127.         {
  1128.             ASCIIEncoding utf8 = new ASCIIEncoding();
  1129.             using (BinaryWriter binWriter =
  1130.                 new BinaryWriter(File.Open(fileName, FileMode.Create), utf8))
  1131.             {
  1132.                 binWriter.Write(this.Tilesets.Count);
  1133.                 foreach (var tileset in Tilesets.Values)
  1134.                 {
  1135.                     SaveString(binWriter, tileset.name);
  1136.                     SaveString(binWriter, tileset.source);
  1137.                     binWriter.Write(tileset.widthTiles);
  1138.                     binWriter.Write(tileset.heightTiles);
  1139.                     binWriter.Write(tileset.Tiles.Count);
  1140.                     foreach (var tile in tileset.Tiles)
  1141.                     {
  1142.                         if (tile.propertyUI.WallStyle != WallStyle.None)
  1143.                             tile.Properties["wall"] = "";
  1144.  
  1145.                         binWriter.Write(tile.Properties.Count);
  1146.                         foreach (var property in tile.Properties)
  1147.                         {
  1148.                             SaveString(binWriter,property.Key);
  1149.                             SaveString(binWriter,property.Value);
  1150.                         }
  1151.                     }
  1152.                 }
  1153.  
  1154.                 binWriter.Close();
  1155.             }
  1156.  
  1157.         }
  1158.  
  1159.  
  1160.         public void Load(String filename)
  1161.         {
  1162.             ASCIIEncoding utf8 = new ASCIIEncoding();
  1163.             using (BinaryReader binReader =
  1164.                 new BinaryReader(File.Open(filename, FileMode.Open), utf8))
  1165.             {
  1166.                 filename = filename.Substring(0, filename.LastIndexOf("\\"));
  1167.                 int c = binReader.ReadInt32();
  1168.                 for(int n=0;n<c;n++)
  1169.                 {
  1170.                    Tileset t = new Tileset();
  1171.                     t.name = ReadString(binReader);
  1172.                     t.source = ReadString(binReader);
  1173.                     t.widthTiles = binReader.ReadInt32();
  1174.                     t.heightTiles = binReader.ReadInt32();
  1175.                     Image bmp = Image.FromFile(filename+"\\"+t.source);
  1176.                     t.widthTiles = bmp.Width / 64;
  1177.                     t.heightTiles = bmp.Height / 128;
  1178.                     int c2 = binReader.ReadInt32();
  1179.                    
  1180.                     for(int m=0;m<c2;m++)
  1181.                     {
  1182.                         Tile tile = new Tile();
  1183.                         t.Tiles.Add(tile);
  1184.                         int np = binReader.ReadInt32();
  1185.                        
  1186.                         for(int q=0;q<np;q++)
  1187.                         {
  1188.                             String p = ReadString(binReader);
  1189.                             String v = ReadString(binReader);
  1190.  
  1191.                             tile.Properties[p] = v;
  1192.  
  1193.                         }
  1194.                         tile.propertyUI.FromProperties(tile.Properties);
  1195.                     }
  1196.  
  1197.                     int c3 = t.widthTiles * t.heightTiles;
  1198.  
  1199.  
  1200.                     for (int m = c2; m < c3;m++ )
  1201.                     {
  1202.                          Tile tile = new Tile();
  1203.                         t.Tiles.Add(tile);
  1204.                     }
  1205.                        
  1206.                     Tilesets[t.name] = t;
  1207.                    
  1208.                    
  1209.                 }
  1210.             }
  1211.         }
  1212.  
  1213.     }
  1214. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!