public Tile GetTile(DoorTileData t)
{
if (t.Door == null)
{
throw new ArgumentNullException("Invalid map format. Door item should be at door tile.");
}
SetMinimapTile(Color.Purple);
var initializer = new DoorInitializer {
Door = CreateDoor(t)
};
initializer.HasButton = t.Door.HasButton;
initializer.Direction = t.Orientation == Orientation.NorthSouth ? MapDirection.North : MapDirection.East;
var res = new DoorTile(initializer);
sidesCreator.SetupSidesAsync(initializer, currentGridPosition, res);
res.Renderer = builder.Factories.RenderersSource.GetDoorTileRenderer(res, builder.WallTexture, builder.DoorButtonTexture);
this.initializer = initializer;
return(res);
}
private void addExit(RoomComponent room)
{
DoorTile exit = DoorTile.CreateInstance <DoorTile>();
exit.direction = Enums.Direction.DOWN;
room.addDoor(exit);
}
/// <summary>
/// Maybe we should use Reflections at some point. #justsayin
/// </summary>
/// <param name="interactive"></param>
/// <param name="animation"></param>
/// <param name="properties"></param>
/// <param name="position"></param>
/// <returns></returns>
public static BasicTile LoadTile(bool interactive, bool animation, TiledProperties properties, Index2 position)
{
BasicTile result = null;
if (interactive && animation)
{
switch (properties.GetProperty("Type"))
{
case "CellDoor":
//result = new CellDoor("cellDoor", position);
//break;
case "Door":
result = new DoorTile("door", position);
break;
default:
result = new InteractiveTile("door", position);
break;
}
}
else if (animation && !interactive)
{
result = new AnimatedTile("flower", position);
}
else if (!interactive && !animation)
{
result = new BasicTile("dirt", position);
}
else
{
throw new NotSupportedException("No Tile should be interacitve but not animated");
}
result.AddProperties(properties);
return(result);
}
public void createDoorData(int dirCnt)
{
int cnt = 0;
while (cnt < dirCnt)
{
DoorTile door = DoorTile.CreateInstance <DoorTile>();
door.sprite = doorTexture;
door.colliderType = Tile.ColliderType.Sprite;
door.direction = (Enums.Direction)currentRoom.getDirections()[cnt];
if (!currentRoom.hasDoor(door))
{
currentRoom.addDoor(door);
}
else
{
door = currentRoom.findDoor(door);
if (door.locked)
{
door.sprite = lockDoorTexture;
}
else
{
door.sprite = doorTexture;
}
}
cnt++;
}
}
private void AddTileInBetween()
{
// Default is a FloorTile
tileToAdd = new FloorTile();
// If a key has been placed, immediately place a door
if (doorsPlaced < keysPlaced)
{
tileToAdd = new DoorTile();
(tileToAdd as DoorTile).SecondarySpriteColor = ChooseColor(doorsPlaced);
doorsPlaced++;
}
// Always have a chance to place a door after a key has been placed
else if (placeDoors && randomChance(doorChance))
{
tileToAdd = new DoorTile();
(tileToAdd as DoorTile).SecondarySpriteColor = ChooseColor(keysPlaced, true, true);
}
tiles.Add(tileToAdd, pointBetween.X, pointBetween.Y);
behindDoorInfo[next.X, next.Y] = behindDoorInfo[current.X, current.Y];
if (tiles.GetType(pointBetween) == TileType.Door)
{
// If a door is placed, next is behind all the doors it is currently behind as well as the newly placed door.
behindDoorInfo[next.X, next.Y] |= GetFlagFromColor((tiles.GetTile(pointBetween) as DoorTile).SecondarySpriteColor);
}
}
public void lockDoors(List <RoomComponent> rooms)
{
int numOfRooms = rooms.Count - 1;
int roomToLock = (int)RNGenerator.Instance.getNextNumber(0, numOfRooms);
while (roomToLock == 0 || rooms[roomToLock].getDirections().Count != 1)
{
roomToLock = (int)RNGenerator.Instance.getNextNumber(0, numOfRooms);
}
int direction = rooms[roomToLock].getDirections()[0];
RoomComponent room = rooms[roomToLock];
RoomComponent lockedOut = room.getNeighbour(direction);
DoorTile lockedDoor = DoorTile.CreateInstance <DoorTile>();
lockedDoor.direction = lockedOut.findDirection(room);
lockedDoor.locked = true;
lockedOut.addDoor(lockedDoor);
placeKeys(1, numOfRooms, roomToLock, direction, rooms, room);
addExit(room);
}
//Adds door to list of doors if it isn't already there
public void addDoor(DoorTile door)
{
if (!doors.Contains(door))
{
doors.Add(door);
}
}
//Used for retrieving right exit so player can leave room to the next one
void OnTriggerStay2D(Collider2D collision)
{
if (collision.gameObject.CompareTag("Player"))
{
//playerposition in grid-cell coordinates used for retrieving the right door tile
Vector3Int tilePos = doormap.WorldToCell(GameObject.Find("Player").transform.position);
DoorTile door = doormap.GetTile <DoorTile>(tilePos);
if (door)
{
//If door is locked and player has key the door gets opened and player gets ported to next room
if (door.locked && collision.gameObject.GetComponent <PlayerComponent>().getKeys() > 0)
{
door.locked = false;
collision.gameObject.GetComponent <PlayerComponent>().decrKeys();
//DungeonMaster needs to move player to the next room
master.moveForward(tilePos, doormap.GetTile <DoorTile>(tilePos).direction);
GameObject.Find("KeyCounter").GetComponent <Text>().text = collision.gameObject.GetComponent <PlayerComponent>().getKeys().ToString();
}
//If door is levelexit, dungeonmaster needs to create the next level
else if (door.direction == Enums.Direction.DOWN)
{
master.nextLevel();
}
else if (!door.locked)
{
master.moveForward(tilePos, doormap.GetTile <DoorTile>(tilePos).direction);
}
}
}
}
//------------------------------------------------------------------------------------------------------------------------
// collisionDoor()
//------------------------------------------------------------------------------------------------------------------------
private void collisionDoor(GameObject other)
{
if (other is DoorTile)
{
DoorTile dTile = other as DoorTile;
_game.SwitchRoom(dTile.Goto);
}
}
//Gets desired door
public DoorTile findDoor(DoorTile door)
{
foreach (DoorTile temp in doors)
{
if (temp.direction == door.direction)
{
return(temp);
}
}
return(null);
}
//Checks if room has door
public bool hasDoor(DoorTile door)
{
bool result = false;
foreach (DoorTile temp in doors)
{
if (temp.direction == door.direction)
{
result = true;
break;
}
}
return(result);
}
//Used to make sure that there are doors where they need to be
public void insertMissingDoors()
{
int cnt = 1;
while (cnt <= 4)
{
if (currentRoom.hasNeighbour(cnt) && !currentRoom.hasDirection(cnt))
{
DoorTile door = DoorTile.CreateInstance <DoorTile>();
door.sprite = doorTexture;
door.colliderType = Tile.ColliderType.Sprite;
door.direction = (Enums.Direction)cnt;
currentRoom.addDoor(door);
}
cnt++;
}
}
public override void SetCharacter(Character character)
{
Debug.Assert(doorTile != null);
DoorTile door = doorTile.GetComponent <DoorTile>();
if (!this.sprung)
{
if (openDoor)
{
door.OpenDoor();
}
else
{
door.CloseDoor();
}
}
base.SetCharacter(character);
}
private void GenerateTile(int col, int row, RoomTemplate.TileType tileType)
{
GameObject tileObject;
switch (tileType)
{
case RoomTemplate.TileType.EMPTY:
return;
case RoomTemplate.TileType.FLOOR:
tileObject = Instantiate(tileObjects.floorTile, transform);
break;
case RoomTemplate.TileType.WALL:
tileObject = Instantiate(tileObjects.wallTile, transform);
break;
case RoomTemplate.TileType.DOOR:
tileObject = Instantiate(tileObjects.doorTile, transform);
DoorTile door = tileObject.GetComponent <DoorTile>();
door.Deactivate();
doors.Add(door);
break;
case RoomTemplate.TileType.SPAWN:
tileObject = Instantiate(tileObjects.spawnTile, transform);
tileObject.transform.localPosition = new Vector2(col, -row);
spawnPoint = tileObject.transform.position;
break;
case RoomTemplate.TileType.EXIT:
tileObject = Instantiate(tileObjects.exitTile, transform);
break;
case RoomTemplate.TileType.TRIGGER:
tileObject = Instantiate(tileObjects.triggerTile, transform);
tileObject.GetComponent <TriggerTile>().SetRoom(this);
break;
default:
return;
}
tileObject.transform.localPosition = new Vector2(col, -row);
}
//------------------------------------------------------------------------------------------------------------------------
// spawnObjects()
//------------------------------------------------------------------------------------------------------------------------
public void SpawnObjects(Map levelData)
{
if (levelData.ObjectGroups == null || levelData.ObjectGroups.Length == 0)
{
return;
}
ObjectGroup objectGroup = levelData.ObjectGroups[0];
if (objectGroup.Objects == null || objectGroup.Objects.Length == 0)
{
return;
}
foreach (TiledObject obj in objectGroup.Objects)
{
switch (obj.Name)
{
case "Door":
_door = new DoorTile(ObjSpriteSheet, ObjCols, ObjRows, obj);
_door.SetFrame(obj.GetIntProperty("Type") - 1);
_door.x = obj.X + _door.width / 2;
_door.y = obj.Y - _door.height / 2;
AddChild(_door);
break;
case "Player":
_player = new Player(obj.X, obj.Y, Game, this);
AddChild(_player);
break;
case "Activity":
_activity = new ActivityTile(ObjSpriteSheet, ObjCols, ObjRows, obj);
_activity.SetFrame(obj.GetIntProperty("Type") - 1);
_activity.x = obj.X + _activity.width;
_activity.y = obj.Y + _activity.height;
AddChild(_activity);
break;
}
}
}
/// <summary>
/// Places a tile between the two points, creating the loop.
/// </summary>
private void AddLoopTile(Point one, Point two)
{
tileToAdd = new FloorTile();
behindDoorFlags difference = behindDoorInfo[one.X, one.Y] ^ behindDoorInfo[two.X, two.Y];
// Check if the difference is exactly one door color
if (Enum.IsDefined(typeof(behindDoorFlags), difference))
{
tileToAdd = new DoorTile();
(tileToAdd as DoorTile).SecondarySpriteColor = ChooseColor((int)Math.Log((int)difference, 2), false, false);
}
if ((!Enum.IsDefined(typeof(behindDoorFlags), difference) && difference != 0) || randomChance(loopHoleChance))
{
tileToAdd = new HoleTile();
if (randomChance(0.5))
{
tileToAdd = new GuardTile();
}
}
tiles.Add(tileToAdd, PointBetween(one, two).X, PointBetween(one, two).Y);
}
void rotateDoor(DoorTile door)
{
//If the room has been built before, doors already got rotated in right direction
if (builtRooms.Contains(currentRoom.getRoomNumber()))
{
return;
}
else
{
//Stores the rotation we want to use in degree
Quaternion rotation;
//Matrix we need to use to rotate our tile to right direction
Matrix4x4 rotationM;
switch (door.direction)
{
case Enums.Direction.EAST:
rotation = Quaternion.Euler(0, 0, -90.0f);
rotationM = Matrix4x4.Rotate(rotation);
door.transform *= rotationM;
break;
case Enums.Direction.SOUTH:
rotation = Quaternion.Euler(0, 0, 180.0f);
rotationM = Matrix4x4.Rotate(rotation);
door.transform *= rotationM;
break;
case Enums.Direction.WEST:
rotation = Quaternion.Euler(0, 0, 90.0f);
rotationM = Matrix4x4.Rotate(rotation);
door.transform *= rotationM;
break;
}
}
}
public virtual IRenderer GetDoorTileRenderer(DoorTile doorTile, Texture2D frameTexture, Texture2D buttonTexture)
{
return(new DoorTileRenderer(doorTile, frameTexture, buttonTexture));
}
void LoadEditorTemplates()
{
//Foreach .lvl files add it to the list
string[] fileNames = Directory.GetFiles(Directory.GetCurrentDirectory() + @"\roomtemplates\");
try
{
foreach (string file in fileNames)
{
StreamReader streamreader = new StreamReader(file);
string importedlevel = streamreader.ReadToEnd();
streamreader.Close();
string[] contents = importedlevel.Replace("\r\n", "").Replace("\n", "").Replace("\r", "").Split('-');
CurrentTemplateName = Strip(file);
TemplateButton result = new TemplateButton(UnselectedSummary, CurrentTemplateName, DoorTiles, 0);
string[] solids = contents[0].Split(':')[1].Split(',');
foreach (string s in solids)
{
if (s != "")
{
string[] pair = s.Split('/');
result.Template.Tiles[Convert.ToInt32(pair[0]), Convert.ToInt32(pair[1])] = SolidTile.Copy();
}
}
string[] doors = contents[1].Split(':')[1].Split(',');
foreach (string d in doors)
{
if (d != "")
{
string[] pair = d.Split('/');
result.Template.Tiles[Convert.ToInt32(pair[0]), Convert.ToInt32(pair[1])] = DoorTile.Copy();
}
}
string[] payout = contents[2].Split(':')[1].Split('/');
result.Template.Payout = new Vector2I(Convert.ToInt32(payout[0]), Convert.ToInt32(payout[1]));
string[] creatures = contents[3].Split(':')[1].Split(',');
foreach (string c in creatures)
{
if (c != "")
{
string[] pair = c.Split('=');
int hash = Convert.ToInt32(pair[0]);
Enemy enemy = EnemyButtons.Single(x => x.Enemy.Hash == hash).Enemy;
Enemy guy = enemy.Copy(new Vector2I(Convert.ToInt32(pair[1].Split('/')[0]), Convert.ToInt32(pair[1].Split('/')[1])), enemy.Hash);
result.Template.Entities.Add(guy);
}
}
result.Template.Difficulty = Convert.ToInt32(contents[4].Split(':')[1]);
TemplateButtons.Add(result);
}
}
catch (Exception e)
{
Console.WriteLine("The file could not be read:");
Console.WriteLine(e.Message);
}
TemplateButtons.Sort();
ReallignTemplates();
}
public void SetDoorTile(DoorTile tile)
{
OnDoorTile = true;
doorTile = tile;
}
void HandleEditorInput(Button button, bool LeftClick)
{
if (LeftClick)
{
switch (button.Action)
{
case "quit":
Quit();
break;
case "templatestab":
CurrentTab = Tab.TEMPLATES;
button.Sprite = SelectedTab;
foreach (Button b in EditorButtons)
{
if (b.Action == "enemy")
{
((EnemyButton)b).Visable = false;
}
else if (b.Action == "enemiestab")
{
b.Sprite = UnselectedTab;
}
}
ReallignTemplates();
break;
case "enemiestab":
CurrentTab = Tab.ENEMIES;
button.Sprite = SelectedTab;
foreach (Button b in EditorButtons)
{
if (b.Action == "room")
{
((TemplateButton)b).Visable = false;
}
else if (b.Action == "templatestab")
{
b.Sprite = UnselectedTab;
}
}
ReallignEnemies();
break;
case "up":
if (CurrentTab == Tab.TEMPLATES)
{
CurrentTemplateIndex--;
if (CurrentTemplateIndex < 0)
{
CurrentTemplateIndex = 0;
}
else
{
foreach (TemplateButton B in TemplateButtons)
{
B.Position.Y += 51;
}
}
ReallignTemplates();
}
else
{
CurrentEnemyIndex--;
if (CurrentEnemyIndex < 0)
{
CurrentEnemyIndex = 0;
}
else
{
foreach (EnemyButton E in EnemyButtons)
{
E.Position.Y += 51;
}
}
ReallignEnemies();
}
break;
case "down":
if (CurrentTab == Tab.TEMPLATES)
{
CurrentTemplateIndex++;
if (CurrentTemplateIndex > TemplateButtons.Count() - 7)
{
CurrentTemplateIndex = TemplateButtons.Count() - 7;
}
else
{
foreach (TemplateButton B in TemplateButtons)
{
B.Position.Y -= 51;
}
}
ReallignTemplates();
}
else
{
CurrentEnemyIndex++;
if (CurrentEnemyIndex > EnemyButtons.Count() - 7)
{
CurrentEnemyIndex = EnemyButtons.Count() - 7;
}
else
{
foreach (EnemyButton E in EnemyButtons)
{
E.Position.Y -= 51;
}
}
ReallignEnemies();
}
break;
case "sprite":
if (CurrentEnemy.Sprite == Enemy1)
{
CurrentEnemy.Sprite = Enemy2;
}
else if (CurrentEnemy.Sprite == Enemy2)
{
CurrentEnemy.Sprite = Enemy3;
}
else if (CurrentEnemy.Sprite == Enemy3)
{
CurrentEnemy.Sprite = Enemy4;
}
else if (CurrentEnemy.Sprite == Enemy4)
{
CurrentEnemy.Sprite = Enemy1;
}
break;
case "hp":
CurrentEnemy.HP++;
CurrentEnemy.MaxHP++;
break;
case "damage":
CurrentEnemy.Damage++;
break;
case "break":
//Pause to debug
break;
case "room":
if (((TemplateButton)button).Visable && CurrentTab == Tab.TEMPLATES)
{
foreach (TemplateButton c in TemplateButtons)
{
c.Sprite = UnselectedSummary;
}
button.Sprite = SelectedSummary;
CurrentTemplate = ((TemplateButton)button).Template;
}
break;
case "enemy":
if (((EnemyButton)button).Visable && CurrentTab == Tab.ENEMIES)
{
foreach (EnemyButton e in EnemyButtons)
{
e.Sprite = UnselectedSummary;
}
button.Sprite = SelectedSummary;
CurrentEnemy = ((EnemyButton)button).Enemy;
}
break;
case "save":
SaveContent();
break;
case "new":
if (CurrentTab == Tab.TEMPLATES)
{
CurrentTemplateName = Convert.ToString(Convert.ToInt32(CurrentTemplateName.Split('.')[0]) + 1);
TemplateButton result = new TemplateButton(UnselectedSummary, CurrentTemplateName + ".lvl", DoorTiles, 0);
TemplateButtons.Add(result);
TemplateButtons.Sort();
ReallignTemplates();
}
else if (CurrentTab == Tab.ENEMIES)
{
CurrentCreatureName = Convert.ToString(Convert.ToInt32(CurrentCreatureName.Split('.')[0]) + 1) + ".nme";
EnemyButton result = new EnemyButton(UnselectedSummary, Enemy1, CurrentCreatureName);
EnemyButtons.Add(result);
EnemyButtons.Sort();
ReallignEnemies();
}
break;
case "door":
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 10; j++)
{
if (MouseOver(i, j))
{
CurrentTemplate.Tiles[i, j] = DoorTile.Copy();
}
}
}
break;
case "item":
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 10; j++)
{
if (MouseOver(i, j))
{
HealthPotion newthing = GenericItem.Copy(new Vector2I(i, j), GenericItem.Hash);
if (CurrentTemplate.Entities.Contains(newthing))
{
CurrentTemplate.Entities.Remove(newthing);
}
else
{
CurrentTemplate.Entities.Add(newthing);
}
}
}
}
break;
case "prize":
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 10; j++)
{
if (MouseOver(i, j))
{
CurrentTemplate.Payout = new Vector2I(i, j);
}
}
}
break;
case "difficulty":
CurrentTemplate.Difficulty++;
break;
}
}
else
{
switch (button.Action)
{
case "hp":
CurrentEnemy.HP--;
CurrentEnemy.MaxHP--;
break;
case "sprite":
if (CurrentEnemy.Sprite == Enemy1)
{
CurrentEnemy.Sprite = Enemy4;
}
else if (CurrentEnemy.Sprite == Enemy2)
{
CurrentEnemy.Sprite = Enemy3;
}
else if (CurrentEnemy.Sprite == Enemy3)
{
CurrentEnemy.Sprite = Enemy2;
}
else if (CurrentEnemy.Sprite == Enemy4)
{
CurrentEnemy.Sprite = Enemy1;
}
break;
case "damage":
CurrentEnemy.Damage--;
break;
case "difficulty":
CurrentTemplate.Difficulty--;
break;
}
}
}
