// Update is called once per frame
void Update()
{
if (Door1.activeSelf == false && Door2.activeSelf == false && Door3.activeSelf == false)
{
Door4.SetActive(false);
}
}
IEnumerator OpenLateralDoors()
{
yield return(new WaitForSeconds(TimeToPlayTraps));
Door3.OpenDoor();
Door4.OpenDoor();
}
/// <summary>
/// Initializes a new instance of the <see cref="Marcher4"/> class.
/// </summary>
/// <param name="startDirection">The start direction.</param>
/// <param name="startX">The start X.</param>
/// <param name="startY">The start Y.</param>
/// <remarks></remarks>
public Marcher4(Door4 startDirection, int startX, int startY)
{
Contract.Requires(startDirection.ExactlyOneValueSet());
Contract.Requires(startX >= 0 && startY >= 0);
Direction = startDirection;
X = startX;
Y = startY;
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.CompareTag("Player") && !activated)
{
activated = true;
controller.TurnOnTrap(TimeToPlayTraps);
if (Door1 != null)
{
Door1.CloseDoor();
Door2.CloseDoor();
StartCoroutine(OpenDoors());
}
else if (Door3 != null)
{
Door3.CloseDoor();
Door4.CloseDoor();
StartCoroutine(OpenLateralDoors());
}
}
}
/// <summary>
/// Ermittelt, ob eine Vorwärtsbewegung möglich ist.
/// </summary>
/// <param name="door">Die zu testende Tür</param>
/// <returns><c>true</c>, wenn Vorwärtsbewegung möglich, ansonsten <c>false</c></returns>
public bool CanMoveForward(Door4 door)
{
return door.ContainsDoor(Direction);
}
/// <summary>
/// Ermittelt, ob eine Rechtsbewegung möglich ist.
/// </summary>
/// <param name="door">Die zu testende Tür</param>
/// <returns><c>true</c>, wenn Rechtsbewegung möglich, ansonsten <c>false</c></returns>
public bool CanTurnRight(Door4 door)
{
switch (Direction)
{
case Door4.North:
return door.ContainsDoor(Door4.East);
case Door4.South:
return door.ContainsDoor(Door4.West);
case Door4.East:
return door.ContainsDoor(Door4.South);
case Door4.West:
return door.ContainsDoor(Door4.North);
default:
throw new InvalidOperationException("Ungültiger Zustand: " + Direction);
}
}
public static bool ContainsDoor(this Door4 item, Door4 door)
{
return (item & door) == door;
}
/// <summary>
/// Wandelt ein <see cref="Wall4"/>-Array in ein <see cref="Door4"/>-Array um
/// </summary>
/// <param name="walls">Die Wände.</param>
/// <returns>Das <see cref="Door4"/>-Array</returns>
/// <remarks></remarks>
public static Door4[,] ToDoorArray(this Wall4[,] walls)
{
Contract.Requires(walls != null);
Contract.Ensures(Contract.Result<Door4[,]>() != null);
int width = walls.GetLength(0);
int height = walls.GetLength(1);
Contract.Assert(width >= 0 && height >= 0);
Door4[,] doors = new Door4[width, height];
for (int y=0; y<height; ++y)
{
for (int x = 0; x < height; ++x)
{
doors[x, y] = walls[x, y].ToDoor();
}
}
return doors;
}
public DistanceTrackingEventArgs(int x, int y, Door4 currentDirection)
{
X = x;
Y = y;
CurrentDirection = currentDirection;
}
/// <summary>
/// Legt fest, dass eine Tür durchschritten wurde
/// </summary>
/// <param name="set">Das Lookup-Set</param>
/// <param name="room">Der Raum</param>
/// <param name="direction">Die Richtung</param>
private static void SetBeenThere(HashSet<Tuple<IRoom4, Door4>> set, IRoom4 room, Door4 direction)
{
Contract.Requires(set != null);
Contract.Requires(room != null);
Contract.Requires(direction.ExactlyOneValueSet());
set.Add(new Tuple<IRoom4, Door4>(room, direction));
}
/// <summary>
/// Ermittelt, ob eine Tür bereits durchschritten wurde
/// </summary>
/// <param name="set">Das Lookup-Set</param>
/// <param name="room">Der Raum</param>
/// <param name="direction">Die Richtung</param>
/// <returns><c>true</c>, wenn der angegebene Raum bereits durch diese Tür verlassen wurde, ansonsten <c>false</c></returns>
private static bool BeenThere(HashSet<Tuple<IRoom4, Door4>> set, IRoom4 room, Door4 direction)
{
Contract.Requires(set != null);
Contract.Requires(room != null);
Contract.Requires(direction.ExactlyOneValueSet());
return set.Contains(new Tuple<IRoom4, Door4>(room, direction));
}
