public static int CacheAllFromDB()
{
int c = 0;
SqlWrapper ms = new SqlWrapper();
DataTable dt = ms.ReadDatatable("SELECT * FROM doors");
foreach (DataRow row in dt.Rows)
{
Doors door = new Doors();
door.ID = (Int32)row["ID"];
door.Coordinates.x = (Single)row["X"];
door.Coordinates.y = (Single)row["Y"];
door.Coordinates.z = (Single)row["Z"];
door.hX = (Single)row["hx"];
door.hY = (Single)row["hy"];
door.hZ = (Single)row["hz"];
door.hW = (Single)row["hw"];
door.teleport_to_ID = (Int32)row["toid"];
door.teleport_to_PlayField = (Int32)(UInt32)row["toplayfield"];
door.proxy = (Boolean)row["proxy"];
door.playfield = (Int32)(UInt32)row["playfield"];
Program.zoneServer.Doors.Add(door);
c++;
}
return c;
}
public DoorFactory(
DiContainer container,
Doors doors)
{
_container = container;
_doors = doors;
}
public static Doors FindCorrespondingDoor(Doors door, Character ch)
{
if (door.teleport_to_ID == 0)
{
uint lastconcrete = ch.Stats.ExtenalDoorInstance.StatBaseValue;
foreach (Doors doors in Program.zoneServer.Doors)
{
if (lastconcrete == (uint)doors.ID)
{
return(doors);
}
}
}
foreach (Doors doors in Program.zoneServer.Doors)
{
if (doors != door)
{
if (doors.ID == door.teleport_to_ID)
{
return(doors);
}
}
}
return(null); // Should not happen EVER
}
public static int CacheAllFromDB()
{
int c = 0;
SqlWrapper ms = new SqlWrapper();
DataTable dt = ms.ReadDatatable("SELECT * FROM doors");
foreach (DataRow row in dt.Rows)
{
Doors door = new Doors();
door.ID = (Int32)row["ID"];
door.Coordinates.x = (Single)row["X"];
door.Coordinates.y = (Single)row["Y"];
door.Coordinates.z = (Single)row["Z"];
door.hX = (Single)row["hx"];
door.hY = (Single)row["hy"];
door.hZ = (Single)row["hz"];
door.hW = (Single)row["hw"];
door.teleport_to_ID = (Int32)row["toid"];
door.teleport_to_PlayField = (Int32)(UInt32)row["toplayfield"];
door.proxy = (Boolean)row["proxy"];
door.playfield = (Int32)(UInt32)row["playfield"];
Program.zoneServer.Doors.Add(door);
c++;
}
return(c);
}
public static Doors FindCorrespondingDoor(Doors door, Character ch)
{
if (door.teleport_to_ID == 0)
{
uint lastconcrete = ch.Stats.ExtenalDoorInstance.StatBaseValue;
foreach (Doors doors in Program.zoneServer.Doors)
{
if (lastconcrete == (uint)doors.ID)
{
return doors;
}
}
}
foreach (Doors doors in Program.zoneServer.Doors)
{
if (doors != door)
{
if (doors.ID == door.teleport_to_ID)
{
return doors;
}
}
}
return null; // Should not happen EVER
}
public HallsSouth(Game game, Torch.Object parent, byte[] data)
: base(game, data)
{
Name = "Coliseum Halls South";
SandbagImage = "Zones/Coliseum/Halls/south-sb";
Sandbag = Grid.FromBitmap(Game.Services, SandbagImage);
ImageLayers.Add(new ImageObject(Game, parent, "Zones/Coliseum/Halls/south"));
Doors.Add(new Door {
Location = new Rectangle(345, 550, 50, 35), Name = "cell", Orientation = Direction.Up
});
Doors.Add(new Door {
Location = new Rectangle(100, 100, 50, 35), Name = "halls-north", Orientation = Direction.Down
});
Doors.Add(new Door {
Location = new Rectangle(660, 300, 35, 50), Name = "halls-east", Orientation = Direction.Left
});
Objects.Add(new InteractiveObject {
Interact = SimpleDoor("coliseum/cell", "halls"), Location = new Rectangle(345, 585, 50, 25)
});
Objects.Add(new InteractiveObject {
Interact = SimpleDoor("coliseum/halls-north", "halls-south"), Location = new Rectangle(100, 90, 50, 15)
});
Objects.Add(new InteractiveObject {
Interact = SimpleDoor("coliseum/halls-east", "halls-south"), Location = new Rectangle(700, 300, 15, 50)
});
}
public virtual InteractiveTile CreateDoor(Tile original)
{
if (generationInfo != null)
{
if (generationInfo.ChildIsland)
{
Debug.Assert(generationInfo.EntrancesCount > 0);
}
else
{
Debug.Assert(generationInfo.EntrancesCount == 0);
}
}
var door = CreateDoorInstance();
Debug.Assert(door != null);
bool doorSet = SetTile(door, original.point);
Debug.Assert(doorSet);
door.DungeonNodeIndex = original.DungeonNodeIndex;
var doorInterface = door as IDoor;
Debug.Assert(doorInterface != null);
Doors.Add(doorInterface);
return(door);
}
public async void OnSaveDoors(object sender, EventArgs e)
{
try
{
IUserDialogs Dialogs = UserDialogs.Instance;
Dialogs.ShowLoading("Saving...");
await Task.Delay(2000);
Repository repository = new Repository();
Dialogs.HideLoading();
Doors doors = new Doors();
doors.PropertyAsset = new PropertyAsset();
doors.IDPropertyAsset = int.Parse(App.Current.Properties["PropertyId"].ToString());
doors.Brand = branddoor.Text;
doors.Warranty = warrantydoor.Text;
doors.Description = descripctiondoor.Text;
doors.Comments = commentsdoor.Text;
doors.FFile = fileNamedoor;
doors.IDUSERPropertyAsset = int.Parse(App.Current.Properties["UsersId"].ToString());
repository.PostDoors(doors);
await DisplayAlert("Doors", "The Door: " + branddoor.Text + " is saved ", "OK");
GoToPage();
}
catch (Exception ex)
{
await DisplayAlert("Doors", ex.Message, "OK");
}
}
internal void AddDoor(Door door)
{
Rectangle coordinates = GetCoordinates(door.Orientation, door.Alignment, 5, 20);
door.Coordinates = coordinates;
Doors.Add(door.Id, door);
}
public string TryGoNextRoom(string door, Player player)
{
foreach (var d in Doors)
{
if (door != d.DoorColor.ToString().ToLower() || !d.DoorOpen)
{
continue;
}
if ((int)d.DoorColor == player.Position)
{
player.Position++;
return($"You went through the {d.DoorColor.ToString().ToLower()} door");
}
if ((int)d.DoorColor + 1 == player.Position)
{
player.Position--;
return($"You went through the {d.DoorColor.ToString().ToLower()} door");
}
}
bool doorInRoom = Doors.Any(d => d.DoorColor.ToString().ToLower() == door);
return(doorInRoom ? "Door is closed" : "Door is not in this room");
}
/// <summary>
/// Attempt to build a room off a random point on a corridor.
/// </summary>
/// <returns>
/// True if the a room is built on the corridor. Otherwise, false.
/// </returns>
private bool BuildRoomOnCorridor()
{
//// the offest of start is to move one point in the direction
//// the room is being built, to ensure it has a discrete entry point
for (int attempt = 0; attempt < MaximumAttempts; attempt++)
{
int directionAwayFromCorridor;
Vector2 corridorPoint = GetCorridorPoint(out directionAwayFromCorridor);
Vector2 door;
Rect room = GetRoom(corridorPoint, directionAwayFromCorridor, out door);
if (RectangleFits(room))
{
BuildRectangle(room);
Rooms.Add(room);
Doors.Add(door);
Map[(int)door.x, (int)door.y] = (int)MapElements.Door;
_currentRoomCount++;
return(true);
}
}
return(false);
}
public Program()
{
lcd = new LCD(GridTerminalSystem);
doors = new Doors(GridTerminalSystem);
lights = new Lights(GridTerminalSystem);
dangerLights = new DangerLights(GridTerminalSystem);
}
public virtual void OnCollisionEnter2D(Collision2D coll)
{
//Handles collisions with players.
if (coll.gameObject.tag == "Player")
{
SoloPlayers p = coll.gameObject.GetComponent <SoloPlayers> ();
if (p.playerNum != owner)
{
hitPlayer(p);
}
//Ignores collision if colliding with player who performed that attack (so you can't hit yourself).
if (p.playerNum == owner)
{
Physics2D.IgnoreCollision(coll.gameObject.GetComponent <Collider2D> (), GetComponent <Collider2D> ());
}
}
if (coll.gameObject.tag == "Fusion")
{
Physics2D.IgnoreCollision(coll.gameObject.GetComponent <Collider2D> (), GetComponent <Collider2D> ());
}
if (coll.gameObject.tag == "Wall")
{
Doors d = coll.gameObject.GetComponent <Doors> ();
if (d != null)
{
if (owner == d.playerNum)
{
Destroy(coll.gameObject);
killProjectile();
}
}
}
}
private void Start()
{
parent = gameObject.GetComponentInParent <Doors>();
cont = FindObjectOfType <PlayerUIController>();
cont.doorPrice.enabled = false;
rend = gameObject.GetComponent <MeshRenderer>();
}
private bool TryAddNormalDoor(MapTile tile, Point location)
{
BlockType blockType;
Direction direction;
// ReSharper disable once SwitchStatementMissingSomeCases
switch (tile)
{
case MapTile.DoorUp:
blockType = BlockType.DoorUp;
direction = Direction.Up;
break;
case MapTile.DoorDown:
blockType = BlockType.DoorDown;
direction = Direction.Down;
break;
default:
return(false);
}
var door = new NormalDoor(_survivalManager, location, blockType);
Doors.Add(direction, door);
Drawables.Add(door);
Collidables.Add(door);
return(true);
}
public static void UpdateDoorHeading(Client cli)
{
SqlWrapper ms = new SqlWrapper();
Doors door = DoorinRange(cli.Character.PlayField, cli.Character.Coordinates, 4.0f);
if (door == null)
{
cli.SendChatText("No door in range to align");
return;
}
cli.SendChatText(
string.Format("Door {0} Heading before: {1} {2} {3} {4}", door.ID, door.hX, door.hY, door.hZ, door.hW));
AOCoord a = new AOCoord
{
x = cli.Character.Coordinates.x - door.Coordinates.x,
y = cli.Character.Coordinates.y - door.Coordinates.y,
z = cli.Character.Coordinates.z - door.Coordinates.z
};
Quaternion q = new Quaternion(a.x, a.y, a.z, 0);
cli.SendChatText(string.Format("Door {0} Heading now: {1} {2} {3} {4}", door.ID, q.x, q.y, q.z, q.w));
ms.SqlUpdate(
"UPDATE doors SET HX=" + String.Format(CultureInfo.InvariantCulture, "'{0}'", q.x) + ", HY="
+ String.Format(CultureInfo.InvariantCulture, "'{0}'", q.y) + ", HZ="
+ String.Format(CultureInfo.InvariantCulture, "'{0}'", q.z) + ", HW="
+ String.Format(CultureInfo.InvariantCulture, "'{0}'", q.w) + " WHERE ID=" + door.ID + ";");
door.hX = (float)q.x;
door.hY = (float)q.y;
door.hZ = (float)q.z;
door.hW = (float)q.w;
}
public void PostDoors(Doors doors)
{
System.Net.Http.HttpResponseMessage response = null;
using (var Client = new System.Net.Http.HttpClient())
{
try
{
var JSON = Newtonsoft.Json.JsonConvert.SerializeObject(doors);
var content = new StringContent(JSON, Encoding.UTF8, "text/json");
var URLWebAPI = "http://50.73.94.149/wsMaterialHouse/api/Doors";
response = Client.PostAsync(URLWebAPI, content).Result;
//Debug.WriteLine(response.StatusCode);
//if (response.StatusCode != System.Net.HttpStatusCode.OK)
//{
// throw new Exception();
//}
}
catch (Exception e)
{
throw e;
}
}
}
public void CloseDoor(Doors door)
{
string[] commands = null;
switch (door)
{
case Doors.MainDoor:
commands = new string[] { "mn dr cl" };
break;
case Doors.DropDoor:
commands = new string[] { "dr dr cl" };
break;
case Doors.CashboxDoor:
commands = new string[] { "bi dr cl" };
break;
case Doors.LogicDoor:
case Doors.CardCageDoor:
commands = new string[] { "logic cl" };
break;
}
if (commands != null)
{
WriteCOM(commands);
}
}
public void Boot()
{
Rooms = new List <Room>();
Room mainRoom = new Room(new PointF(0, 0), new PointF(750, 450));
mainRoom.isMainRoom = true;
mainRoom.AddDoor(Room.DoorPosition.Right, 50);
Room room1 = new Room(new PointF(0, 0), new PointF(150, 150));
room1.AddDoor(Room.DoorPosition.Down, 50);
Room room2 = new Room(new PointF(150, 0), new PointF(300, 150));
room2.AddDoor(Room.DoorPosition.Down, 50);
Room room3 = new Room(new PointF(500, 0), new PointF(750, 150));
room3.AddDoor(Room.DoorPosition.Down, 50);
Room room4 = new Room(new PointF(0, 300), new PointF(150, 450));
room4.AddDoor(Room.DoorPosition.Right, 50);
Room room5 = new Room(new PointF(300, 300), new PointF(550, 450));
room5.AddDoor(Room.DoorPosition.Left, 50);
Room room6 = new Room(new PointF(550, 300), new PointF(750, 450));
room6.AddDoor(Room.DoorPosition.Up, 50);
Rooms.Add(mainRoom);
Rooms.Add(room1);
Rooms.Add(room2);
Rooms.Add(room3);
Rooms.Add(room4);
Rooms.Add(room5);
Rooms.Add(room6);
EmergencyCheckpoint ec6 = new EmergencyCheckpoint(new PointF(750, 225), null);
EmergencyCheckpoint ec5 = new EmergencyCheckpoint(new PointF(640, 225), ec6);
EmergencyCheckpoint ec4 = new EmergencyCheckpoint(new PointF(400, 215), ec5);
EmergencyCheckpoint ec3 = new EmergencyCheckpoint(new PointF(225, 225), ec4);
EmergencyCheckpoint ec2 = new EmergencyCheckpoint(new PointF(75, 225), ec3);
EmergencyCheckpoint ec1 = new EmergencyCheckpoint(new PointF(225, 350), ec3);
EmergencyRoute.Add(ec6);
EmergencyRoute.Add(ec5);
EmergencyRoute.Add(ec4);
EmergencyRoute.Add(ec3);
EmergencyRoute.Add(ec2);
EmergencyRoute.Add(ec1);
Rooms.ForEach(room => {
Doors.AddRange(room.Doors);
Walls.AddRange(room.Walls);
});
}
public virtual void ToggleDoors(bool secure, bool open)
{
Doors.ForEachReverse(
d =>
{
if (d == null || d.Deleted || d.Map != Map)
{
Doors.Remove(d);
return;
}
if ((!d.Open || !CanCloseDoor(d)) && (d.Open || !CanOpenDoor(d)))
{
return;
}
d.Open = open;
d.Locked = secure;
if (_DoorTimerField == null)
{
return;
}
var t = _DoorTimerField.GetValue(d) as Timer;
if (t != null)
{
t.Stop();
}
});
}
public void EditBadge()
{
Console.Clear();
Console.WriteLine("What is the badge number to update?");
int input = int.Parse(Console.ReadLine());
foreach (Badge badge in Badge.BadgeDictionary.Keys)
{
if (badge.BadgeId == input)
{
Console.WriteLine();
PrintAccessSummary(badge);
Console.WriteLine("What would you like to do?\n\n" +
"1. Remove a door\n" +
"2. Add a door");
switch (Console.ReadLine())
{
case "1":
Console.WriteLine("\nWhich door would you like to remove?");
Doors door = (Doors)Enum.Parse(typeof(Doors), Console.ReadLine());
Badge.BadgeDictionary[badge].Remove(door);
Console.WriteLine("\nDoor Removed;");
break;
case "2":
Console.WriteLine("\nWhich door would you like to add?");
door = (Doors)Enum.Parse(typeof(Doors), Console.ReadLine());
Badge.BadgeDictionary[badge].Add(door);
break;
}
PrintAccessSummary(badge);
}
}
}
void Start()
{
doorsOpen_script = GateDoors.GetComponent <Doors>();
lightactivate_script = GateLight1.GetComponent <LightOn1>();
powerlight_script = PowerLight1.GetComponent <LightOn1>();
// message = "Gate Power 1 Activated";
}
void Start()
{
doorsOpen_script = GateDoors.GetComponent <Doors>();
anim = GetComponent <Animator>();
gategearactivate_script = GateGearObj.GetComponent <GateGear2>();
// message = "Gate Gear 2 Activated";
}
public RoomObject(Vector2 coord, Doors doors, float width, float height)
{
coordinateInGrid = coord;
this.doors = doors;
tileWidth = width;
tileHeight = height;
}
public void RemoveDoor()
{
var indexToRemove = _rand.Next(1, 3);
indexToRemove = MakeSureDoorToBeRemovedIsNotChosenDoor();
Doors.RemoveAt(DoorToRemove);
}
private void AddNewDoor()
{
var curSelectWindow = new SelectWindow();
var typeToAdd = curSelectWindow.SelectProductType();
BaseClasses.Door doorToAdd = null;
switch (typeToAdd)
{
case Helpers.AllNames.ProductClasses.k1MDType:
doorToAdd = new ViewModels.MDDoors.MDDoor();
break;
case Helpers.AllNames.ProductClasses.k4RDType:
doorToAdd = new ViewModels.RDDoors.RDDoor();
break;
default:
break;
}
if (doorToAdd != null)
{
doorToAdd.Edit();
Doors.Add(doorToAdd);
}
}
public void AddDoor(Doors aDoor)
{
if (!myDoors.Contains(aDoor))
{
myDoors.Add(aDoor);
}
}
public void TestDrawDoorsAddsRectangleForOneDoor()
{
System.Drawing.Rectangle doorBoundingBox = new System.Drawing.Rectangle(20, 50, 300, 500);
DetectedDoor detectedDoor = new DetectedDoor(doorBoundingBox, new System.Drawing.Size(0, 0), DetectedDoor.DetectionConfidence.LOW, 0, 0, "");
Canvas canvas = new Canvas();
List <DetectedDoor> doors = new List <DetectedDoor>();
doors.Add(detectedDoor);
Doors doorsTab = new Doors(null);
PrivateObject privateAccessor = new PrivateObject(doorsTab);
privateAccessor.Invoke("DrawDoors", doors, canvas);
// There was one door given so there should be one child in the canvas
Assert.AreEqual <int>(1, canvas.Children.Count);
// That one child rectangle should have the correct bounding box
System.Windows.Shapes.Rectangle doorShape = (System.Windows.Shapes.Rectangle)canvas.Children[0];
// Compare the two bounding boxes, they should be the same
Assert.AreEqual <double>(doorBoundingBox.Width, doorShape.Width);
Assert.AreEqual <double>(doorBoundingBox.Height, doorShape.Height);
Assert.AreEqual <double>(doorBoundingBox.Left, Canvas.GetLeft(doorShape));
Assert.AreEqual <double>(doorBoundingBox.Top, Canvas.GetTop(doorShape));
}
internal SittingDuck(ThreatController threatController, Game game, ILookup <ZoneLocation, DamageToken> initialDamage)
{
ThreatController = threatController;
threatController.ThreatAttackedShip += TakeAttack;
Game = game;
var redDoors = new Doors();
var blueDoors = new Doors();
var interceptors = new Interceptors();
var interceptorStation1 = CreateInterceptorStation1(threatController);
var interceptorStation2 = CreateInterceptorStation2(threatController);
var interceptorStation3 = CreateInterceptorStation3(threatController);
BlueDoors = blueDoors;
RedDoors = redDoors;
WhiteZone = CreateWhiteZone(threatController, initialDamage, redDoors, blueDoors);
RedZone = CreateRedZone(threatController, initialDamage, redDoors, WhiteZone, interceptors);
BlueZone = CreateBlueZone(threatController, initialDamage, WhiteZone, blueDoors);
ZonesByLocation = new Zone[] { RedZone, WhiteZone, BlueZone }.ToDictionary(zone => zone.ZoneLocation);
InterceptorStations = new [] { interceptorStation1, interceptorStation2, interceptorStation3 };
StationsByLocation = Zones
.SelectMany(zone => new Station[] { zone.LowerStation, zone.UpperStation })
.Concat(InterceptorStations)
.ToDictionary(station => station.StationLocation);
StandardStationsByLocation = Zones
.SelectMany(zone => new StandardStation[] { zone.LowerStation, zone.UpperStation })
.ToDictionary(station => station.StationLocation);
}
void Awake()
{
number_spawn = PlayerPrefs.GetInt(scenes, 0);
Vector3 pos_spawn = transform.TransformDirection(spawn[number_spawn].transform.GetChild(0).transform.position);
heroe = GameObject.Find("Heroe");
Movings other;
other = heroe.gameObject.GetComponent("Movings") as Movings;
other.camera = camera;
heroe.transform.position = pos_spawn;
if (heroe.gameObject.GetComponent <AudioSource>().enabled == false)
{
heroe.gameObject.GetComponent <AudioSource>().enabled = true;
}
Doors door_s = spawn[number_spawn].gameObject.GetComponent("Doors") as Doors;
if (door_s != null)
{
other.side = door_s.side;
if (door_s.side == "left")
{
camera.transform.position = new Vector3(7, 2.85f, 1.5f);
camera.transform.localEulerAngles = new Vector3(10, -100, 0);
}
else if (door_s.side == "right")
{
camera.transform.position = new Vector3(1.5f, 2.85f, 7);
camera.transform.localEulerAngles = new Vector3(10, -170, 0);
}
}
}
public List <ObjectDTO> SceneReconstruction(int planId)
{
List <ObjectDTO> objects = new List <ObjectDTO>();
List <BoxDTO> BoxesInPlan = Boxs.BoxesInPlan(planId);
foreach (BoxDTO box in BoxesInPlan)
{
List <BoardDTO> BoardsInBox = Boards.BoardsInBox(box.Id);
List <DrawerDTO> DrawersInBox = Drawers.DrawersInBox(box.Id);
List <DoorDTO> DoorsInBox = Doors.DoorsInBox(box.Id);
List <bool> PozicijeFioka = new List <bool>();
List <bool> PozicijeVrata = new List <bool>();
for (int i = 0; i < BoardsInBox.Count + 1; i++)
{
PozicijeFioka.Add(false);
PozicijeVrata.Add(false);
}
foreach (DrawerDTO d in DrawersInBox)
{
PozicijeFioka[d.pregrada] = true;
}
foreach (DoorDTO d in DoorsInBox)
{
PozicijeVrata[d.pregrada] = true;
}
ObjectDTO o = new ObjectDTO()
{
Width = box.Width,
Height = box.Height,
Depth = box.Depth,
Name = box.Name,
BoardThickness = box.BoardThickness,
PositionX = box.PositionX,
PositionY = box.PositionY,
PositionZ = box.PositionZ,
Texture = box.Texture,
childs = BoardsInBox,
nizFioka = DrawersInBox,
pozicije_fioka = PozicijeFioka,
nizVrata = DoorsInBox,
pozicije_vrata = PozicijeVrata,
vertikalno = box.vertikalno,
horizontalno = box.horizontalno,
globalX = box.globalX,
globalY = box.globalY,
globalZ = box.globalZ
};
objects.Add(o);
}
return(objects);
}
static void Main(string[] args)
{
Doors doors = new Doors(70);
Inhabitant homie = new Inhabitant("John Flitch", "90930293", "92832832");
HouseModel house = new HouseModel("malinowa 2", 90, 2);
Console.ReadKey();
}
public override void OnShot()
{
//already shot
if (GetComponent<Animator>() != null)
{
if (open == Doors.CLOSED)
{
Debug.Log("open");
GetComponent<Animator>().SetInteger("status", 1);
open = Doors.OPEN;
}
}
}
void OnTriggerEnter2D(Collider2D other){
if (other.name != "Player")
return;
if (open == Doors.OPEN)
{
open = Doors.GETIN;
GetComponent<Animator>().SetInteger("status", 2);
var player = GameObject.Find("Player");
player.GetComponent<SpriteRenderer>().enabled = false;
player.GetComponent<Player>().SetControllable(false);
FindObjectOfType<Level1>().CompleteObjective("getInCar");
}
}
// Use this for initialization
void Start () {
open = Doors.CLOSED;
}