public EventTileDataInstance CreateEventTile(EventTileData data, Point2I position)
{
EventTileDataInstance dataInstance = new EventTileDataInstance(data, position);
AddEventTile(dataInstance);
return(dataInstance);
}
private EventTileDataInstance ReadEventTileData(BinaryReader reader)
{
EventTileData tileData = ReadResource(reader, eventTileData);
Point2I position = new Point2I(
reader.ReadInt32(),
reader.ReadInt32());
EventTileDataInstance eventTile = new EventTileDataInstance(tileData, position);
ReadProperties(reader, eventTile.Properties);
eventTile.Properties.PropertyObject = eventTile;
eventTile.Properties.BaseProperties = eventTile.EventTileData.Properties;
return(eventTile);
}
public EventTileDataInstance CreateEventTile(EventTileData data, int x, int y)
{
return(CreateEventTile(data, new Point2I(x, y)));
}
public override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
Point2I mousePos = new Point2I(e.X, e.Y);
Room room = LevelDisplayControl.SampleRoom(mousePos);
Point2I tileCoord = LevelDisplayControl.SampleTileCoordinates(mousePos);
if (editorControl.EventMode)
{
if (EditorControl.EventMode && e.Button == MouseButtons.Left)
{
EventTileData eventTile = editorControl.SelectedTilesetTileData as EventTileData;
if (room != null && eventTile != null)
{
Point2I roomPos = LevelDisplayControl.GetRoomDrawPosition(room);
Point2I pos = (mousePos - roomPos) / 8;
pos *= 8;
//Point2I tileCoord = LevelDisplayControl.SampleTileCoordinates(mousePos);
room.CreateEventTile(eventTile, pos);
}
}
else if (EditorControl.EventMode && e.Button == MouseButtons.Right)
{
EventTileDataInstance eventTile = LevelDisplayControl.SampleEventTile(new Point2I(e.X, e.Y));
if (eventTile != null)
{
eventTile.Room.RemoveEventTile(eventTile);
editorControl.OnDeleteObject(eventTile);
}
}
else if (e.Button == MouseButtons.Middle)
{
// Select events.
EventTileDataInstance selectedEventTile = LevelDisplayControl.SampleEventTile(mousePos);
if (selectedEventTile != null)
{
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord);
EditorControl.PropertyGrid.OpenProperties(selectedEventTile.Properties, selectedEventTile);
}
else
{
EditorControl.PropertyGrid.CloseProperties();
}
}
}
else
{
if (e.Button == MouseButtons.Middle)
{
// Select tiles.
TileDataInstance selectedTile = room.GetTile(tileCoord, editorControl.CurrentLayer);
if (selectedTile != null)
{
Point2I levelTileCoord = LevelDisplayControl.ToLevelTileCoordinates(room, tileCoord);
EditorControl.PropertyGrid.OpenProperties(selectedTile.Properties, selectedTile);
}
else
{
EditorControl.PropertyGrid.CloseProperties();
}
}
}
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
public TilesetSR()
{
//this.loadingMode = LoadingModes.Tilesets;
this.resources = new TemporaryResources();
this.useTemporary = false;
this.spriteBuilder = new SpriteBuilder();
//=====================================================================================
// LOADING MODE
//=====================================================================================
AddCommand("Load", "string resourceType",
delegate(CommandParam parameters) {
/*string loadType = parameters.GetString(0).ToLower();
* if (loadType == "tilesets")
* loadingMode = LoadingModes.Tilesets;
* else if (loadType == "animations")
* loadingMode = LoadingModes.Animations;
* else if (loadType == "sprites")
* loadingMode = LoadingModes.Sprites;
* else
* ThrowParseError("Invalid Load type", true);*/
});
//=====================================================================================
// TILE/TILESET BEGIN/END
//=====================================================================================
AddCommand("Tileset", "string name, string sheetName, (int width, int height)",
delegate(CommandParam parameters) {
SpriteSheet sheet = Resources.GetSpriteSheet(parameters.GetString(1));
tileset = new Tileset(parameters.GetString(0), sheet,
parameters.GetPoint(2));
});
//=====================================================================================
AddCommand("EventTileset", "string name, (int width, int height)",
delegate(CommandParam parameters) {
eventTileset = new EventTileset(parameters.GetString(0),
null, parameters.GetPoint(1));
});
//=====================================================================================
AddCommand("Tile",
"string name",
"(int sheetX, int sheetY)",
delegate(CommandParam parameters) {
useTemporary = false;
if (tileset != null)
{
Point2I location = parameters.GetPoint(0);
tileData = tileset.TileData[location.X, location.Y];
}
else
{
tileData = new TileData();
tileData.Name = parameters.GetString(0);
}
baseTileData = tileData;
});
//=====================================================================================
AddCommand("TempTile", "string name",
delegate(CommandParam parameters) {
useTemporary = true;
tileData = new TileData();
tileData.Name = parameters.GetString(0);
baseTileData = tileData;
});
//=====================================================================================
AddCommand("EventTile", "string name",
delegate(CommandParam parameters) {
useTemporary = false;
eventTileData = new EventTileData();
eventTileData.Name = parameters.GetString(0);
baseTileData = eventTileData;
});
//=====================================================================================
AddCommand("Monster", "string name, string sprite, string monsterType, string monsterColor",
delegate(CommandParam parameters) {
useTemporary = false;
eventTileData = new EventTileData();
eventTileData.Clone(Resources.GetResource <EventTileData>("monster"));
eventTileData.Name = parameters.GetString(0);
baseTileData = eventTileData;
if (parameters.ChildCount > 1)
{
eventTileData.Sprite = resources.GetSpriteAnimation(parameters.GetString(1));
}
if (parameters.ChildCount > 2)
{
eventTileData.Properties.Set("monster_type", parameters.GetString(2));
}
if (parameters.ChildCount > 3)
{
MonsterColor color;
if (!Enum.TryParse <MonsterColor>(parameters.GetString(3), true, out color))
{
ThrowParseError("Invalid monster color: \"" + parameters.GetString(3) + "\"!");
}
eventTileData.Properties.Set("color", (int)color);
int imageVariantID = GameData.VARIANT_RED;
if (color == MonsterColor.Red)
{
imageVariantID = GameData.VARIANT_RED;
}
else if (color == MonsterColor.Blue)
{
imageVariantID = GameData.VARIANT_BLUE;
}
else if (color == MonsterColor.Green)
{
imageVariantID = GameData.VARIANT_GREEN;
}
else if (color == MonsterColor.Orange)
{
imageVariantID = GameData.VARIANT_ORANGE;
}
eventTileData.Properties.Set("image_variant", imageVariantID);
}
});
//=====================================================================================
AddCommand("End", "", delegate(CommandParam parameters) {
if (tileData != null)
{
if (tileData.Tileset == null)
{
if (useTemporary)
{
resources.AddResource <TileData>(tileData.Name, tileData);
}
else
{
Resources.AddResource <TileData>(tileData.Name, tileData);
}
}
tileData = null;
baseTileData = null;
}
else if (eventTileData != null)
{
if (eventTileData.Tileset == null)
{
if (useTemporary)
{
resources.AddResource <EventTileData>(eventTileData.Name, eventTileData);
}
else
{
Resources.AddResource <EventTileData>(eventTileData.Name, eventTileData);
}
}
eventTileData = null;
baseTileData = null;
}
else if (tileset != null)
{
Resources.AddResource <Tileset>(tileset.ID, tileset);
tileset = null;
}
else if (eventTileset != null)
{
Resources.AddResource <EventTileset>(eventTileset.ID, eventTileset);
eventTileset = null;
}
});
//=====================================================================================
// TILESET SETUP
//=====================================================================================
AddCommand("Default", "(int defaultSheetX, int defaultSheetY)",
delegate(CommandParam parameters) {
tileset.DefaultTile = parameters.GetPoint(0);
});
//=====================================================================================
// Config: data to configure tiles with a single character per tile.
AddCommand("Config", "", delegate(CommandParam parameters) {
string line = NextLine();
int y = 0;
while (!line.StartsWith("END;", StringComparison.OrdinalIgnoreCase))
{
if (y < tileset.Height)
{
for (int x = 0; x < line.Length && x < tileset.Width; x++)
{
tileset.ConfigureTile(tileset.TileData[x, y], line[x]);
}
}
line = NextLine();
y++;
}
});
//=====================================================================================
AddCommand("SetTile", "(int sheetX, int sheetY), string tileName",
delegate(CommandParam parameters) {
Point2I location = parameters.GetPoint(0);
if (tileset != null)
{
tileset.TileData[location.X, location.Y] =
resources.GetResource <TileData>(parameters.GetString(1));
}
else if (eventTileset != null)
{
eventTileset.TileData[location.X, location.Y] =
resources.GetResource <EventTileData>(parameters.GetString(1));
}
});
//=====================================================================================
// TILES
//=====================================================================================
AddCommand("Type", "string type",
delegate(CommandParam parameters) {
baseTileData.Type = Tile.GetType(parameters.GetString(0), true);
});
//=====================================================================================
AddCommand("Flags", "string flags...",
delegate(CommandParam parameters) {
for (int i = 0; i < parameters.ChildCount; i++)
{
TileFlags flags = TileFlags.None;
if (Enum.TryParse <TileFlags>(parameters.GetString(i), true, out flags))
{
tileData.Flags |= flags;
}
else
{
ThrowParseError("Invalid tile flag: \"" + parameters.GetString(i) + "\"!", parameters[i]);
}
}
});
//=====================================================================================
AddCommand("EnvType", "string envType",
delegate(CommandParam parameters) {
TileEnvironmentType envType = TileEnvironmentType.Normal;
if (Enum.TryParse <TileEnvironmentType>(parameters.GetString(0), true, out envType))
{
tileData.Properties.Set("environment_type", (int)envType);
}
else
{
ThrowParseError("Invalid tile environment type: \"" + parameters.GetString(0) + "\"!", parameters[0]);
}
});
//=====================================================================================
AddCommand("ResetWhen", "string resetCondition",
delegate(CommandParam parameters) {
TileResetCondition envType = TileResetCondition.LeaveRoom;
if (Enum.TryParse <TileResetCondition>(parameters.GetString(0), true, out envType))
{
tileData.ResetCondition = envType;
}
else
{
ThrowParseError("Invalid tile reset condition: \"" + parameters.GetString(0) + "\"!", parameters[0]);
}
});
//=====================================================================================
AddCommand("Conveyor", "string angle, float speed",
delegate(CommandParam parameters) {
string str = parameters.GetString(0).ToLower();
int angle = -1;
if (Angles.TryParse(str, true, out angle))
{
tileData.ConveyorAngle = angle;
}
else if (parameters[0].Type == CommandParamType.Integer)
{
tileData.ConveyorAngle = parameters.GetInt(0);
}
else
{
ThrowParseError("Unknown value for conveyor angle: " + str, parameters[0]);
}
tileData.ConveyorSpeed = parameters.GetFloat(1);
});
//=====================================================================================
// (string type, string name, var value)...
// (string type, string name, var value, string readableName, string editorType, string category, string description)...
// (string type, string name, var value, string readableName, (string editorType, string editorSubType), string category, string description, bool isHidden = false)...
AddCommand("Properties",
"(string type, string name, var otherData...)...",
CommandProperties);
//=====================================================================================
AddCommand("Event",
"string name, string readableName, string description",
"string name, string readableName, string description, (string params...)", // Params = (type1, name1, type2, name2...)
delegate(CommandParam parameters) {
Property property = Property.CreateString(parameters.GetString(0), "");
//property.SetDocumentation(parameters.GetString(1), "script", "", "Events", parameters.GetString(2), true, false);
baseTileData.Properties.Set(property.Name, property)
.SetDocumentation(parameters.GetString(1), "script", "", "Events", parameters.GetString(2), true, false);
// Create the event's script parameter list.
ScriptParameter[] scriptParams;
if (parameters.ChildCount > 3)
{
CommandParam paramList = parameters[3];
scriptParams = new ScriptParameter[paramList.ChildCount / 2];
for (int i = 0; i < scriptParams.Length; i++)
{
scriptParams[i] = new ScriptParameter()
{
Type = paramList.GetString(i * 2),
Name = paramList.GetString((i * 2) + 1)
};
}
}
else
{
scriptParams = new ScriptParameter[0];
}
// Add the event to the tile-data.
baseTileData.Events.AddEvent(new ObjectEvent(
parameters.GetString(0), // Name
parameters.GetString(1), // Readable name
parameters.GetString(2), // Description
scriptParams));
});
//=====================================================================================
AddCommand("Sprite",
"string spriteOrAnimationName",
"string spriteSheetName, (int sourceX, int sourceY), (int offsetX, int offsetY) = (0, 0)",
delegate(CommandParam parameters) {
if (parameters.ChildCount >= 2)
{
spriteBuilder.Begin(new Sprite(
resources.GetResource <SpriteSheet>(parameters.GetString(0)),
parameters.GetPoint(1),
parameters.GetPoint(2, Point2I.Zero)
));
baseTileData.Sprite = spriteBuilder.End();
}
else
{
baseTileData.Sprite = resources.GetSpriteAnimation(parameters.GetString(0));
}
});
//=====================================================================================
AddCommand("Size", "(int width, int height)", delegate(CommandParam parameters) {
tileData.Size = parameters.GetPoint(0);
});
//=====================================================================================
AddCommand("SpriteIndex",
"int index, string spriteOrAnim, string spriteAnimationName",
"int index, string spriteAnimationName",
"int index, string spriteSheetName, (int sourceX, int sourceY), (int offsetX, int offsetY) = (0, 0)",
delegate(CommandParam parameters) {
int index = parameters.GetInt(0);
if (tileData.SpriteList.Length <= index)
{
SpriteAnimation[] spriteList = new SpriteAnimation[index + 1];
for (int i = 0; i < spriteList.Length; i++)
{
if (i < tileData.SpriteList.Length)
{
spriteList[i] = tileData.SpriteList[i];
}
else
{
spriteList[i] = null;
}
}
tileData.SpriteList = spriteList;
}
if (parameters.ChildCount > 2 && parameters[2].Type == CommandParamType.Array)
{
spriteBuilder.Begin(new Sprite(
resources.GetResource <SpriteSheet>(parameters.GetString(1)),
parameters.GetPoint(2),
parameters.GetPoint(3, Point2I.Zero)
));
tileData.SpriteList[index] = spriteBuilder.End();
}
else
{
if (parameters.ChildCount == 3)
{
string typeName = parameters.GetString(1);
if (typeName == "sprite")
{
tileData.SpriteList[index] = resources.GetResource <Sprite>(parameters.GetString(2));
}
else if (typeName == "animation")
{
tileData.SpriteList[index] = resources.GetResource <Animation>(parameters.GetString(2));
}
else
{
ThrowParseError("Unknown sprite/animation type '" + typeName + "' (expected \"sprite\" or \"animation\")");
}
}
else
{
tileData.SpriteList[index] = resources.GetSpriteAnimation(parameters.GetString(1));
}
}
});
//=====================================================================================
AddCommand("SpriteList", "string spriteAnimationNames...", delegate(CommandParam parameters) {
SpriteAnimation[] spriteList = new SpriteAnimation[parameters.ChildCount];
for (int i = 0; i < parameters.ChildCount; i++)
{
spriteList[i] = resources.GetSpriteAnimation(parameters.GetString(i));
}
tileData.SpriteList = spriteList;
});
//=====================================================================================
AddCommand("SpriteObj",
"string spriteAnimationName",
"string spriteSheetName, (int sourceX, int sourceY), (int offsetX, int offsetY) = (0, 0)",
delegate(CommandParam parameters) {
if (parameters.ChildCount >= 2)
{
spriteBuilder.Begin(new Sprite(
resources.GetResource <SpriteSheet>(parameters.GetString(0)),
parameters.GetPoint(1),
parameters.GetPoint(2, Point2I.Zero)
));
tileData.SpriteAsObject = spriteBuilder.End();
}
else
{
tileData.SpriteAsObject = resources.GetSpriteAnimation(parameters.GetString(0));
}
});
//=====================================================================================
AddCommand("BreakAnim", "string animationName",
delegate(CommandParam parameters) {
tileData.BreakAnimation = resources.GetResource <Animation>(parameters.GetString(0));
});
//=====================================================================================
AddCommand("BreakSound", "string soundName",
delegate(CommandParam parameters) {
tileData.BreakSound = Resources.GetResource <Sound>(parameters.GetString(0));
});
//=====================================================================================
AddCommand("Model", "string collisionModelName",
delegate(CommandParam parameters) {
tileData.CollisionModel = resources.GetResource <CollisionModel>(parameters.GetString(0));
});
//=====================================================================================
AddCommand("Solid", "string collisionModelName",
delegate(CommandParam parameters) {
tileData.SolidType = TileSolidType.Solid;
tileData.CollisionModel = resources.GetResource <CollisionModel>(parameters.GetString(0));
});
//=====================================================================================
AddCommand("HalfSolid", "string collisionModelName",
delegate(CommandParam parameters) {
tileData.SolidType = TileSolidType.HalfSolid;
tileData.CollisionModel = resources.GetResource <CollisionModel>(parameters.GetString(0));
});
//=====================================================================================
AddCommand("Ledge", "string collisionModelName, string ledgeDirection",
delegate(CommandParam parameters) {
tileData.SolidType = TileSolidType.Ledge;
tileData.CollisionModel = resources.GetResource <CollisionModel>(parameters.GetString(0));
string dirName = parameters.GetString(1);
int direction;
if (Directions.TryParse(dirName, true, out direction))
{
tileData.LedgeDirection = direction;
}
else
{
ThrowParseError("Unknown value for ledge direction: " + dirName);
}
});
//=====================================================================================
AddCommand("Hurt", "int damage, (int areaX, int areaY, int areaWidth, int areaHeight)",
delegate(CommandParam parameters) {
tileData.HurtDamage = parameters.GetInt(0);
tileData.HurtArea = new Rectangle2I(
parameters[1].GetInt(0),
parameters[1].GetInt(1),
parameters[1].GetInt(2),
parameters[1].GetInt(3));
});
AddCommand("Clone", "string tileDataName",
delegate(CommandParam parameters) {
if (tileData != null)
{
tileData.Clone(resources.GetResource <TileData>(parameters.GetString(0)));
}
else if (eventTileData != null)
{
eventTileData.Clone(resources.GetResource <EventTileData>(parameters.GetString(0)));
}
});
// SPRITE SHEET ---------------------------------------------------------------
AddCommand("SpriteSheet",
"string path, (int cellWidth, int cellHeight), (int spacingX, int spacingY), (int offsetX, int offsetY)",
"string name, string path, (int cellWidth, int cellHeight), (int spacingX, int spacingY), (int offsetX, int offsetY)",
delegate(CommandParam parameters) {
//AddSpriteCommand("SpriteSheet", delegate(CommandParam parameters) {
if (parameters.ChildCount == 1)
{
// Start using the given sprite sheet.
SpriteSheet sheet = Resources.GetResource <SpriteSheet>(parameters.GetString(0));
spriteBuilder.SpriteSheet = sheet;
}
else
{
int i = 1;
// Create a new sprite sheet.
Image image = null;
string imagePath = parameters.GetString(0);
string sheetName = imagePath;
if (parameters.ChildCount == 5)
{
imagePath = parameters.GetString(1);
i = 2;
}
if (Resources.ImageExists(imagePath))
{
image = Resources.GetResource <Image>(imagePath);
}
else
{
image = Resources.LoadImage(Resources.ImageDirectory + imagePath);
}
if (sheetName.IndexOf('/') >= 0)
{
sheetName = sheetName.Substring(sheetName.LastIndexOf('/') + 1);
}
SpriteSheet sheet = new SpriteSheet(image,
parameters.GetPoint(i + 0),
parameters.GetPoint(i + 2),
parameters.GetPoint(i + 1));
if (useTemporary)
{
resources.AddResource <SpriteSheet>(sheetName, sheet);
}
else
{
Resources.AddResource <SpriteSheet>(sheetName, sheet);
}
spriteBuilder.SpriteSheet = sheet;
}
});
}
public static World CreateTestWorld()
{
// Create the world.
World world = new World();
world.StartLevelIndex = 0;
world.StartRoomLocation = new Point2I(2, 1);
world.StartTileLocation = new Point2I(3, 2);
// Load the levels from java level files.
world.Levels.Add(LoadJavaLevel("Content/Worlds/test_level.zwd"));
world.Levels.Add(LoadJavaLevel("Content/Worlds/interiors.zwd"));
world.Levels.Add(LoadJavaLevel("Content/Worlds/big_interiors.zwd"));
world.Levels[0].Properties.Set("id", "overworld");
world.Levels[1].Properties.Set("id", "interiors");
world.Levels[2].Properties.Set("id", "big_interiors");
TileData tdBlock = Resources.GetResource <TileData>("movable_block");
TileData tdDiamond = Resources.GetResource <TileData>("diamond_rock");
TileData tdBush = Resources.GetResource <TileData>("bush");
TileData tdPot = Resources.GetResource <TileData>("pot");
TileData tdRock = Resources.GetResource <TileData>("rock");
TileData tdGrass = Resources.GetResource <TileData>("grass");
TileData tdOwl = Resources.GetResource <TileData>("owl");
TileData tdLantern = Resources.GetResource <TileData>("lantern");
TileData tdSign = Resources.GetResource <TileData>("sign");
TileData tdChest = Resources.GetResource <TileData>("chest");
TileData tdReward = Resources.GetResource <TileData>("reward");
EventTileData etdWarp = Resources.GetResource <EventTileData>("warp");
Level level;
Room r;
TileDataInstance t;
EventTileDataInstance e;
// Setup the overworld rooms.
level = world.Levels[0];
r = level.GetRoomAt(2, 1);
t = r.CreateTile(tdOwl, 8, 1, 1);
t.Properties.Set("text", "Hello, World!");
t = r.CreateTile(tdChest, 7, 1, 1);
t.Properties.Set("reward", "heart_piece");
t = r.CreateTile(tdReward, 6, 3, 1);
t.Properties.Set("reward", "item_flippers_1");
t = r.CreateTile(tdSign, 1, 1, 1);
t.Properties.Set("text", "This will<n> prime your load catchers and boost your desktop wallpaper.");
t = r.CreateTile(tdReward, 2, 6, 1);
t.Properties.Set("reward", "heart_piece");
r.CreateTile(tdBlock, 2, 5, 1);
r.CreateTile(tdGrass, 2, 2, 1);
r.CreateTile(tdGrass, 2, 3, 1);
r.CreateTile(tdGrass, 2, 4, 1);
r.CreateTile(tdGrass, 3, 4, 1);
r.CreateTile(tdGrass, 4, 5, 1);
r.CreateTile(tdGrass, 3, 6, 1);
r.CreateTile(tdGrass, 4, 6, 1);
r.CreateTile(tdGrass, 5, 6, 1);
r.CreateTile(tdGrass, 4, 7, 1);
r.CreateTile(tdGrass, 5, 7, 1);
r.CreateTile(tdGrass, 6, 7, 1);
r.CreateTile(tdGrass, 7, 7, 1);
r.CreateTile(tdGrass, 7, 2, 1);
r.CreateTile(tdGrass, 8, 2, 1);
r.CreateTile(tdGrass, 8, 3, 1);
r = level.GetRoomAt(2, 2);
e = r.CreateEventTile(etdWarp, 16, 64);
e.Properties.Set("id", "warp_a");
e.Properties.Set("warp_type", "tunnel");
e.Properties.Set("destination_level", "overworld");
e.Properties.Set("destination_warp_point", "warp_b");
r = level.GetRoomAt(1, 1);
e = r.CreateEventTile(etdWarp, 64, 96);
e.Properties.Set("id", "warp_b");
e.Properties.Set("warp_type", "stairs");
e.Properties.Set("destination_level", "overworld");
e.Properties.Set("destination_warp_point", "warp_a");
r = level.GetRoomAt(new Point2I(1, 1));
r.CreateTile(tdDiamond, 1, 1, 1);
r.CreateTile(tdDiamond, 2, 2, 1);
r.CreateTile(tdDiamond, 2, 4, 1);
r.CreateTile(tdPot, 8, 2, 1);
r = level.GetRoomAt(new Point2I(3, 0));
r.CreateTile(tdLantern, 3, 2, 1);
r = level.GetRoomAt(new Point2I(1, 0));
r.CreateTile(tdRock, 8, 2, 1);
r = level.GetRoomAt(new Point2I(2, 0));
for (int x = 1; x < 8; x++)
{
for (int y = 2; y < 6; y++)
{
r.CreateTile(tdBush, x, y, 1);
}
}
// Set the rooms to random zones.
/*Random random = new Random();
* for (int x = 0; x < level.Width; x++) {
* for (int y = 0; y < level.Height; y++) {
* int index = random.Next(0, 3);
* Zone zone = GameData.ZONE_SUMMER;
* if (index == 1)
* zone = GameData.ZONE_GRAVEYARD;
* else if (index == 2)
* zone = GameData.ZONE_FOREST;
* level.GetRoom(new Point2I(x, y)).Zone = zone;
* }
* }*/
// Setup the interior rooms.
level = world.Levels[1];
r = level.GetRoomAt(2, 1);
r.Zone = GameData.ZONE_INTERIOR;
r.CreateTile(tdPot, 1, 2, 1);
r.CreateTile(tdPot, 1, 3, 1);
r.CreateTile(tdPot, 5, 1, 1);
r = level.GetRoomAt(3, 1);
r.Zone = GameData.ZONE_INTERIOR;
r.CreateTile(tdChest, 8, 1, 1);
r.CreateTile(tdPot, 8, 2, 1);
r.CreateTile(tdPot, 4, 6, 1);
r.CreateTile(tdPot, 5, 6, 1);
r.CreateTile(tdPot, 6, 6, 1);
r.CreateTile(tdPot, 7, 6, 1);
r.CreateTile(tdPot, 8, 6, 1);
// Save and load the world.
{
WorldFile worldFile = new WorldFile();
worldFile.Save("Content/Worlds/custom_world.zwd", world);
}
{
WorldFile worldFile = new WorldFile();
world = worldFile.Load("Content/Worlds/custom_world.zwd");
}
return(world);
}
