public Door(Texture2D texture, Vector2 openPosition, Vector2 closePosition, OpenState state = OpenState.Closed)
: this(texture, closePosition)
{
if (state == OpenState.Open) position = openPosition;
this.openPosition = openPosition;
this.closePosition = closePosition;
doorType = DoorType.Opening;
//hitBox.omitBottom = true; //TODO: Change omit based on direction door is moving
}
public Wardrobe(String fancyName, Room room, Material material, Size size, double price, int numberOfShelves, DoorType typeOfDoor, bool mirror,
bool builtInLamp)
: base(fancyName, room, material, size, price)
{
this.numberOfShelves = numberOfShelves;
this.typeOfDoor = typeOfDoor;
this.mirror = mirror;
this.builtInLamp = builtInLamp;
}
public Door(int p_id, DoorType p_type, string p_mapName)
{
this.mapName = p_mapName;
base.texture = new GameTexture("door.bmp", new Size(0x40, 0x40), TextureDisposePolicy.NeverDispose);
this.id = p_id;
this.destinationMap = "";
this.rec = new RectangleF(0f, 32f, 32f, 32f);
this.SetDoorType(p_type);
base.objectClass = ObjectClass.Door;
}
public UseDoor(Vector2 position, int width, int height, DoorType doorType, string levelPath, int spawnPoint)
{
Position = position;
Width = width;
Height = height;
DoorType = doorType;
LevelPath = levelPath;
SpawnPoint = spawnPoint;
Enabled = true;
}
public Door(Texture2D texture, Vector2 position, OpenState state = OpenState.Closed)
: this(texture, position)
{
doorType = DoorType.Fading;
if (state == OpenState.Open)
{
alpha = 0;
}
else
{
alpha = 255;
}
}
public TDCDoor(DoorType mDoorType, bool mIsOff, TDGGame mGame, TDCSwitch mSwitchComponent, TDCRecalculateSprites mRecalculateSprites)
{
_doorType = mDoorType;
_game = mGame;
_isOff = mIsOff;
_switchComponent = mSwitchComponent;
_recalculateSpritesComponent = mRecalculateSprites;
_switchComponent.OnTurnOff += SetRecalculationNeeded;
_switchComponent.OnTurnOn += SetRecalculationNeeded;
}
private static async Task <bool> CreateLiftAsync(ILiftsService liftsService)
{
string userId = "U1";
LiftType liftType = (LiftType)Enum.Parse(typeof(LiftType), "Пътнически");
int numberOfStops = 4;
int capacity = 450;
DoorType doorType = (DoorType)Enum.Parse(typeof(DoorType), "АВ");
string manufacturerId = "M1";
string productionNumber = "123";
string cityId = "C1";
string address = "A1";
var isCreated = await liftsService.CreateAsync(userId, liftType, numberOfStops, capacity, doorType, manufacturerId, productionNumber, cityId, address);
return(isCreated);
}
public void Shuffle(List <HackingNodeInfo> list, DoorType type)
{
int hackSeed = GetHackSeedByDoorType(type);
System.Random rng = new System.Random(hackSeed);
int n = list.Count;
while (n > 1)
{
n--;
int k = rng.Next(n + 1);
HackingNodeInfo value = list[k];
list[k] = list[n];
list[n] = value;
}
}
/// <summary>
/// connect two cells together with a certain door type
/// </summary>
/// <param name="other">the other cell to be connect with</param>
/// <param name="type">the type of door connection</param>
/// <param name="bothWays">connect both cells</param>
public void ConnectCells(Cell other, DoorType doorType, bool bothWays = true)
{
var dirX = x - other.x;
var dirY = y - other.y;
DoorType applyType = doorType;
if (bothWays)
{
applyType = DoorType.Open;
}
doorTypes[getDoorIndex(dirX, dirY)] = applyType;
if (bothWays)
{
other.ConnectCells(this, doorType, false);
}
}
public void GetDoorTypeByIdReturnsOkAndDoorTypeWhenEverythingIsCorrect()
{
var doorType = new DoorType();
_doorTypeRepositoryMock.Setup(m => m.GetById(It.IsAny <int>()))
.Returns(doorType);
_mapperMock.Setup(m => m.Map <DoorTypeReturnModel>(It.IsAny <DoorType>()))
.Returns(new DoorTypeReturnModel());
var result = _sut.GetEntityById(0) as OkObjectResult;
Assert.That(result, Is.Not.Null);
var value = result.Value as DoorTypeReturnModel;
Assert.That(value, Is.Not.Null);
_doorTypeRepositoryMock.Verify(m => m.GetById(It.IsAny <int>()), Times.Once);
}
//IEnumerator DoorState2(bool open)
//{
// float timer = 0;
// Vector3 ori = open ? _startPos : _endPos;
// Vector3 tar = open ? _endPos : _startPos;
// while (timer<= Duration)
// {
// float t = timer / Duration;
// transform.position = Vector3.Lerp(ori, tar, aniCurve.Evaluate(t));
// timer += Time.deltaTime;
// yield return null;
// }
//}
#endregion
IEnumerator DoorState(DoorType newTYPE)
{
doorType = DoorType.Animation;
float timer = 0;
//起始点 《====》 结束点
Vector3 startPos = (newTYPE == DoorType.Open) ? _endPos : _startPos;
Vector3 endPos = (newTYPE == DoorType.Open) ? _startPos : _endPos;
while (timer <= Duration)
{
float t = timer / Duration;
transform.position = Vector3.Lerp(startPos, endPos, aniCurve.Evaluate(t));
timer += Time.deltaTime;
yield return(null);
}
doorType = newTYPE;
}
/// <summary>
/// 返回单个图片路径
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static String GetImagePath(DoorType type)
{
switch (type)
{
case DoorType.黄门:
return("/res/icons/background/8.png");
case DoorType.蓝门:
return("/res/icons/background/9.png");
case DoorType.红门:
return("/res/icons/background/10.png");
case DoorType.铁门:
return("/res/icons/background/11.png");
}
return(null);
}
private void SetSimState(bool is_door_open, IList <int> cells)
{
PrimaryElement component = GetComponent <PrimaryElement>();
float num = component.Mass / (float)cells.Count;
for (int i = 0; i < cells.Count; i++)
{
int num2 = cells[i];
DoorType doorType = this.doorType;
if (doorType == DoorType.Pressure || doorType == DoorType.Sealed || doorType == DoorType.ManualPressure)
{
World.Instance.groundRenderer.MarkDirty(num2);
if (is_door_open)
{
SimMessages.Dig(num2, Game.Instance.callbackManager.Add(new Game.CallbackInfo(OnSimDoorOpened, false)).index);
if (ShouldBlockFallingSand)
{
SimMessages.ClearCellProperties(num2, 4);
}
else
{
SimMessages.SetCellProperties(num2, 4);
}
}
else
{
HandleVector <Game.CallbackInfo> .Handle handle = Game.Instance.callbackManager.Add(new Game.CallbackInfo(OnSimDoorClosed, false));
float temperature = component.Temperature;
if (temperature <= 0f)
{
temperature = component.Temperature;
}
int gameCell = num2;
SimHashes elementID = component.ElementID;
CellElementEvent doorClose = CellEventLogger.Instance.DoorClose;
float mass = num;
float temperature2 = temperature;
int index = handle.index;
SimMessages.ReplaceAndDisplaceElement(gameCell, elementID, doorClose, mass, temperature2, byte.MaxValue, 0, index);
SimMessages.SetCellProperties(num2, 4);
}
}
}
}
public void SwitchDoors(DoorType type)
{
if (type == DoorType.EXIT)
{
//entryDoor.GetComponentInChildren<Animator>().SetTrigger("Cancel");
entryDoor.transform.position = exitDoor.transform.position;
exitDoor.transform.position = tempDoor.transform.position;
tempDoor.transform.position = new Vector3(0, 50, 0);
}
else if (type == DoorType.ENTRANCE)
{
//exitDoor.GetComponentInChildren<Animator>().SetTrigger("Cancel");
exitDoor.transform.position = entryDoor.transform.position;
entryDoor.transform.position = tempDoor.transform.position;
tempDoor.transform.position = new Vector3(0, 50, 0);
}
}
public Door(DoorType type)
{
// Based on Standard Uk Door sizes
if (type == DoorType.Single)
{
Height = 2.0;
Length = 0.7;
}
else if (type == DoorType.Double)
{
Height = 2.0;
Length = 1.2;
}
else
{
Height = 2.1;
Length = 3.0;
}
}
void Start()
{
player = PlayerSingleton.Instance.player;
levelGenerator = LevelGeneratorSingleton.Instance.levelGenerator;
switch (this.gameObject.tag)
{
case "north":
yoff = 1;
xoff = 0;
direction = Direction.North;
break;
case "south":
yoff = -1;
xoff = 0;
direction = Direction.South;
break;
case "east":
yoff = 0;
xoff = 1;
direction = Direction.East;
break;
case "west":
yoff = 0;
xoff = -1;
direction = Direction.West;
break;
default:
break;
}
doorType = levelGenerator.GetDoorType(xoff, yoff);
// Rotate sprite if North/South
if (direction == Direction.North || direction == Direction.South)
{
spriteRenderer.transform.Rotate(Vector3.forward, 90, Space.World);
}
}
private void AddQue(GameObject que, DoorType orientation, int playerNum)
{
if (displayedQues.ContainsKey(playerNum))
{
if (displayedQues[playerNum].orientation == orientation)
{
return;
}
Destroy(displayedQues[playerNum].que);
displayedQues[playerNum] = new QueNode(que, orientation);
}
else
{
displayedQues.Add(playerNum, new QueNode(que, orientation));
}
que.transform.position = new Vector3(
transform.position.x + xOffset,
transform.position.y + yOffset,
transform.position.z + zOffset);
}
/// <summary>
/// 返回四张图片路径,形成动画
/// </summary>
/// <param name="ftype">何种类型的门</param>
/// <returns></returns>
public String[] GetImagePaths(DoorType type)
{
switch (type)
{
//case door_type.商店中:
// return new string[] { "/res/icons/background/29.png", "/res/icons/background/31.png", "/res/icons/background/29.png", "/res/icons/background/31.png" };
case DoorType.黄门:
return(new string[] { "/res/icons/background/12.png", "/res/icons/background/16.png", "/res/icons/background/20.png" });
case DoorType.蓝门:
return(new string[] { "/res/icons/background/13.png", "/res/icons/background/17.png", "/res/icons/background/21.png" });
case DoorType.红门:
return(new string[] { "/res/icons/background/14.png", "/res/icons/background/18.png", "/res/icons/background/22.png" });
case DoorType.铁门:
return(new string[] { "/res/icons/background/15.png", "/res/icons/background/19.png", "/res/icons/background/23.png" });
}
return(null);
}
public GameObject CreateDoor(Cell cell, DoorState state, DoorType type, GameObject doorsLayer = null)
{
if (doorsLayer == null)
{
doorsLayer = GameObject.Find("Doors");
}
var doorGameObj = GameObject.Instantiate(DoorPrefab);
doorGameObj.name = string.Format("Door_{0}_{1}", cell.Position.r, cell.Position.c);
doorGameObj.transform.position = cell.WorldPosition;
doorGameObj.transform.parent = doorsLayer.transform;
var doorController = doorGameObj.GetComponent <DoorController>();
doorController.State = state;
doorController.Type = type;
return(doorGameObj);
}
/// <summary>
/// Returns a different hacking seed based on door type to create a set of doors with the same seed
/// </summary>
private int GetHackSeedByDoorType(DoorType type)
{
switch (type)
{
case DoorType.atmos:
return((int)seed[1]);
case DoorType.command:
return((int)seed[2]);
case DoorType.engineering:
return((int)seed[3]);
case DoorType.maintenance:
return((int)seed[4]);
case DoorType.medical:
return((int)seed[5]);
case DoorType.mining:
return((int)seed[6]);
case DoorType.civilian:
return((int)seed[7]);
case DoorType.research:
return((int)seed[8]);
case DoorType.science:
return((int)seed[9]);
case DoorType.security:
return((int)seed[10]);
case DoorType.virology:
return((int)seed[11]);
default:
return((int)seed[0]);
}
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.E) && playerInRange)
{
if (isOpen)
{
Close();
}
else
{
if ((thisDoorType == DoorType.locked) && (playerInventory.Key == 3))
{
playerInventory.Key -= 3;
KeySignal.Raise();
thisDoorType = DoorType.normal;
Open();
}
else if (thisDoorType == DoorType.normal)
{
Open();
}
}
}
// Main monster blocking the door
// for now player does this
else if (Input.GetKeyDown(KeyCode.B) && playerInRange && thisDoorType != DoorType.locked)
{
cooldownTimer = cooldown;
doorSprite.color = Color.red;
// if the door open to begin with
if (isOpen)
{
Close();
}
if (thisDoorType == DoorType.normal)
{
thisDoorType = DoorType.blocked;
}
}
BlockedDoorCooldown();
}
public Door(Object p_obj)
{
type = EntityType.ITEM;
tag = "Door";
name = p_obj.name;
closeOnEnter = p_obj.properties.CloseOnEnter;
tileToOpen = p_obj.properties.TileToOpen;
doorType = (DoorType)p_obj.properties.DoorType;
doorSide = p_obj.properties.DoorSide;
isOpen = false;
if (doorType == DoorType.KEY)
{
canOpen = false;
}
position = new Vector2(p_obj.x, p_obj.y);
size = new Vector2(16f, 16f);
state = State.ACTIVE;
hitboxSize = new Vector2(16f, 16f);
hitboxOffset = new Vector2(0f, 0f);
UpdateAABB();
}
protected override void Start()
{
base.Start();
spriteRenderer = GetComponent <SpriteRenderer>();
closedDoorSprite = spriteRenderer.sprite;
rm = GetComponent <RoomMove>();
uniqueID = UnityEngine.SceneManagement.SceneManager.GetActiveScene() + name + transform.position;
if (InfoManager.Instance.doors.TryGetValue(uniqueID, out DoorType temp))
{
OpenBy = temp;
if (OpenBy == DoorType.None)
{
SetDoorType(DoorType.None);
}
}
else
{
InfoManager.Instance.doors.Add(uniqueID, OpenBy);
}
}
public void StreamScene(DoorType type, string sceneName)
{
bool sceneLoaded = false;
for (int i = 0; i < loadedScenes.Count; i++)
{
if (loadedScenes[i] == sceneName)
{
sceneLoaded = true;
break;
}
}
if (type == DoorType.Load && !sceneLoaded)
{
StartCoroutine(LoadAsyncAdditive(sceneName));
}
else if (type == DoorType.Unload && sceneLoaded)
{
StartCoroutine(UnloadAysnc(sceneName));
}
}
public void BlockedDoorCooldown()
{
if (cooldownTimer > 0)
{
cooldownTimer -= Time.deltaTime;
}
if (cooldownTimer < 0)
{
cooldownTimer = 0;
thisDoorType = DoorType.normal;
monsterBrain.blockedDoors--;
if (playerInRange)
{
item.color = Color.green;
}
else
{
item.color = Color.white;
}
}
}
// Use this for initialization
void Start()
{
currentHouse = PlayerManager.Instance.houseSelected;
door = FindObjectOfType <Door>();
player = FindObjectOfType <Player>();
guitarHeroGame = GetComponent <GuitarHero>();
fightGame = GetComponent <Fight>();
gameUi = FindObjectOfType <GameUi>();
currentPlayerCash = 0;
maxImpatience = currentHouse.impatience;
impatience = 0;
//ADRIEN
conv = Resources.Load("Sounds/Conversation" + Random.Range(1, 3)) as AudioClip;
switch (currentHouse.doorType)
{
case House.DoorType.Level1:
doorType = Resources.Load("Doors/PoorDoor") as DoorType;
break;
case House.DoorType.Level2:
doorType = Resources.Load("Doors/BasicDoor") as DoorType;
break;
case House.DoorType.Level3:
doorType = Resources.Load("Doors/RichDoor") as DoorType;
break;
}
clientCash = currentHouse.budget;
fightGame.minimumFightJauge = doorType.strenght;
fightGame.increaseValue = PlayerManager.Instance.currentShoes.resistance;
saleState = SaleState.Talk;
door.SetTrigger("DoorLose");
guitarHeroGame.StartSale();
}
private void add(DoorType orientation, int playernum)
{
//don't add a node of the same type twice
foreach (QueNode n in displayedQues.Values)
{
if (n.orientation == orientation)
{
displayedQues[playernum] = n;
return;
}
}
GameObject que;
switch (orientation)
{
default:
que = Instantiate(GeneralOpenQue);
break;
case DoorType.North:
que = Instantiate(NorthOpenQue);
break;
case DoorType.South:
que = Instantiate(SouthOpenQue);
break;
case DoorType.East:
que = Instantiate(EastOpenQue);
break;
case DoorType.West:
que = Instantiate(WestOpenQue);
break;
}
AddQue(que, orientation, playernum);
}
private static DoorPairing[] FindPossiblePairs(RoomInfo[] listOne, DoorInfo two, bool?onlyConnected = null)
{
List <DoorPairing> retVal = new List <DoorPairing>();
foreach (RoomInfo outRoom in listOne)
{
foreach (DoorInfo outDoor in outRoom.doorList)
{
if (outDoor == two)
{
continue;
}
DoorType type = (DoorType)(-(int)outDoor.doorType);
if ((onlyConnected == null || (onlyConnected.Value == (two.connectedDoor != null))) && two.doorType == type)
{
retVal.Add(new DoorPairing(outDoor, two));
}
}
}
return(retVal.ToArray());
}
public DoorType GetDoorTypeById(int Id)
{
DoorType pDoorType = new DoorType();
string sql = @"[spGetDoorType] '{0}' ";
sql = string.Format(sql, Id);
try
{
DataSet ds = new DataSet();
ds = _MB.CreaDS(ds, "DoorType", sql, _CN);
if (ds.Tables["DoorType"].Rows.Count > 0)
{
foreach (DataRow item in ds.Tables["DoorType"].Rows)
{
pDoorType = new DoorType()
{
Id = int.Parse(item["Id"].ToString()),
Status = new Status()
{
Id = int.Parse(item["IdStatus"].ToString()), Description = item["DescripStatus"].ToString()
},
Description = item["Description"].ToString(),
CreationDate = (item["CreationDate"].ToString() != "") ? DateTime.Parse(item["CreationDate"].ToString()) : DateTime.Parse("01/01/1900"),
ModificationDate = (item["ModificationDate"].ToString() != "") ? DateTime.Parse(item["ModificationDate"].ToString()) : DateTime.Parse("01/01/1900"),
CreatorUser = int.Parse(item["CreatorUser"].ToString()),
ModificationUser = int.Parse(item["ModificationUser"].ToString()),
};
}
}
return(pDoorType);
}
catch (Exception)
{
throw;
}
}
// Update is called once per frame
protected override void Update()
{
base.Update();
if (cantEnemigos > 0 && isInCombatRoom)
{
if (!doOnce)
{
doorType = DoorType.defaultDoor;
animator.SetBool("Close", true);
animator.SetBool("Open", false);
doOnce = true;
}
}
else
{
if (doOnce)
{
doorType = DoorType.automaticDoor;
isOpen = false;
doOnce = false;
}
}
}
/// <summary>
/// Create the "connect" cells to connect "from" cell to "to" cell
/// </summary>
/// <param name="from">the starting cell</param>
/// <param name="to">the end cell</param>
/// <param name="maxIterations">the maximum number of trials before failing</param>
/// <returns>True if the connection succeeded and False otherwise</returns>
public bool makeConnection(Cell from, Cell to, int maxIterations)
{
List <int[]> points = this.getConnectionPoints(from, to, maxIterations);
if (points.Count == 0)
{
return(false);
}
foreach (int[] p in points)
{
if (!this.usedSpaces.ContainsKey(p[0] + "," + p[1]))
{
Cell currentCell = new Cell(p[0], p[1], CellType.Connection, null);
this.usedSpaces.Add(currentCell.getLocationString(), currentCell);
}
}
for (int i = 1; i < points.Count; i++)
{
int[] p = points[i];
Cell previousCell = this.usedSpaces[points[i - 1][0] + "," + points[i - 1][1]];
Cell currentCell = this.usedSpaces[p[0] + "," + p[1]];
DoorType door = DoorType.Open;
if (previousCell.node != null)
{
if (previousCell.node.type == MissionGraph.NodeType.Lever)
{
door = DoorType.LeverLock;
}
}
if (currentCell.getDoor(currentCell.x - previousCell.x, currentCell.y - previousCell.y) == 0)
{
currentCell.connectCells(previousCell, door);
}
}
return(true);
}
private void DisassmItem(ItemSeeker seeker)
{
result.AppendLine();
switch (seeker.ItemType)
{
case ItemTypeIndex.Nothing:
throw new ItemDisassmException("Encountered an unexpected item type when disassembling an item.");
case ItemTypeIndex.Enemy:
// byte: Enemy code and sprite slot
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Enemy, sprite slot = " + seeker.SpriteSlot.ToString());
// byte: hard flag (0x80), enemy type
WriteLine(ByteDirective(seeker.SubTypeByte),
"Enemy type = " + seeker.EnemyTypeIndex + (seeker.EnemyIsHard ? ", hard enemy" : ""));
// Byte: screen position
WriteLine(ByteDirective(seeker.ScreenPosition.Value),
"Screen X = " + seeker.ScreenPosition.X.ToString() + " Y = " + seeker.ScreenPosition.Y.ToString());
break;
case ItemTypeIndex.PowerUp:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Power Up");
// byte: Item type
WriteLine(ByteDirective(seeker.SubTypeByte),
"Type = " + seeker.PowerUpName);
// Byte: screen position
WriteLine(ByteDirective(seeker.ScreenPosition.Value),
"Screen X = " + seeker.ScreenPosition.X.ToString() + " Y = " + seeker.ScreenPosition.Y.ToString());
break;
case ItemTypeIndex.Mella:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Mella");
break;
case ItemTypeIndex.Elevator:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Elevator");
// byte: Item type
WriteLine(ByteDirective(seeker.SubTypeByte),
"Type = " + seeker.Destination.ToString());
break;
case ItemTypeIndex.Turret:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Turret, type = " + seeker.SpriteSlot.ToString());
// Byte: screen position
WriteLine(ByteDirective(seeker.ScreenPosition.Value),
"Screen X = " + seeker.ScreenPosition.X.ToString() + " Y = " + seeker.ScreenPosition.Y.ToString());
break;
case ItemTypeIndex.MotherBrain:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Mother Brain");
break;
case ItemTypeIndex.Zebetite:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Zebetite, index = " + seeker.SpriteSlot.ToString());
break;
case ItemTypeIndex.Rinkas:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Rinka " + seeker.SpriteSlot.ToString());
break;
case ItemTypeIndex.Door:
// byte: Door
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Doop");
// byte: Door type
var doorType = seeker.SubTypeByte;
DoorSide side = (DoorSide)(doorType & 0xF0);
DoorType type = (DoorType)(doorType & 0x0F);
WriteLine(ByteDirective(seeker.SubTypeByte),
"Door: " + side.ToString() + " " + type.ToString());
break;
case ItemTypeIndex.PalSwap:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Palette Swap");
break;
case ItemTypeIndex.Unused_b:
case ItemTypeIndex.Unused_c:
case ItemTypeIndex.Unused_d:
case ItemTypeIndex.Unused_e:
case ItemTypeIndex.Unused_f:
// byte: Item code
WriteLine(ByteDirective(seeker.ItemTypeByte),
"Invalid Item Type!");
break;
default:
throw new ItemDisassmException("Unexpected item type in DisassmItem");
break;
}
}
public void addWardrobe(String fancyName, Room room, Material material, Size size, double price, int numberOfShelves, DoorType typeOfDoor, bool mirror,
bool builtInLamp, int count)
{
this.addFurniture(new Wardrobe(fancyName, room, material, size, price, numberOfShelves, typeOfDoor, mirror, builtInLamp), count);
}
public DoorBase_LockedDownstair(DoorType subtype, Node _node, int _UDLR)
{
init_ObjectBase(ObjectBaseType.DOOR, (int)subtype, _node);
UDLR = _UDLR;
}
public void SetDoorType(DoorType p_type)
{
this.doorType = p_type;
if ((this.doorType == DoorType.Shop) || (this.doorType == DoorType.Church))
{
this.closedFrame = 3;
}
if (this.doorType == DoorType.LockedGreen)
{
this.closedFrame = 4;
}
if (this.doorType == DoorType.LockedRed)
{
this.closedFrame = 5;
}
if (this.doorType == DoorType.StoneLocked)
{
this.closedFrame = 7;
}
if (this.IsWalkDoor())
{
this.closedFrame = 6;
this.rec = new RectangleF(0f, 0f, 64f, 64f);
}
this.doorFrame = this.closedFrame;
}
public ChangeDoor ChangeDoor(DoorSide side, DoorType type)
{
return(new ChangeDoor(queue, CurrentScreen, side, type));
}
public ConditionalDoor(Vector2 position, int width, int height, DoorType doorType, string levelPath, int spawnPoint)
: base(position, width, height, doorType, levelPath, spawnPoint)
{
Enabled = false;
}
public void AddDoor(DoorType type, int ID, int destDoorID, string destMap, bool waterTransition, bool flipped)
{
Door item = new Door(ID, type, this.mapFilename) {
Location = new PointF(this.screenPos.X, this.screenPos.Y),
DestinationDoor = destDoorID,
DestinationMap = destMap,
IsWaterTransition = waterTransition,
Flipped = flipped
};
this.objects.Add(item);
this.doors.Add(item);
}
public void OpenByBell()
{
currentDoorType = DoorType.Normal;
}
public Doorway(int x, int y, int height, int width, Side SideIn)
: base(x, y, height, width)
{
this.SideIn = SideIn;
Type = DoorType.TwoWay;
}
private HelpPageComponent CreatePageComponent(int yPosition, string title, string paragraph, DoorType door)
{
Door o = new Door(1, door, "");
if (door == DoorType.StoneLocked)
{
o.DestinationDoor = 50;
}
HelpPageComponent component = this.CreatePageComponent(yPosition, title, paragraph, o);
component.sectionGraphic.Y = yPosition - 0x10;
component.sectionGraphic.X = 8f;
return component;
}
