/// <summary>
/// Transition player through an interior door to building exterior. Player must be inside.
/// Interior stores information about exterior, no need for extra params.
/// </summary>
public void TransitionExterior(bool doFade = false)
{
// Exit if missing required components or not currently inside
if (!ReferenceComponents() || !interior || !isPlayerInside)
{
return;
}
// Raise event
RaiseOnPreTransitionEvent(TransitionType.ToBuildingExterior);
// Find closest door and position player outside of it
StaticDoor closestDoor;
Vector3 closestDoorPos = DaggerfallStaticDoors.FindClosestDoor(transform.position, ExteriorDoors, out closestDoor);
Vector3 normal = DaggerfallStaticDoors.GetDoorNormal(closestDoor);
Vector3 position = closestDoorPos + normal * (controller.radius * 3f);
world.SetAutoReposition(StreamingWorld.RepositionMethods.Offset, position);
EnableExteriorParent();
// Player is now outside building
isPlayerInside = false;
// Fire event
RaiseOnTransitionExteriorEvent();
// Fade in from black
if (doFade)
{
DaggerfallUI.Instance.FadeHUDFromBlack();
}
}
/// <summary>
/// Transition player through an interior door to building exterior. Player must be inside.
/// Interior stores information about exterior, no need for extra params.
/// </summary>
public void TransitionExterior()
{
// Exit if missing required components or not currently inside
if (!ReferenceComponents() || !interior || !isPlayerInside)
{
return;
}
// Raise event
RaiseOnPreTransitionEvent(TransitionType.ToBuildingExterior);
// Find closest exterior door
Vector3 exitDoorPos = Vector3.zero;
int doorIndex = -1;
DaggerfallStaticDoors exteriorDoors = interior.ExteriorDoors;
if (exteriorDoors)
{
if (!exteriorDoors.FindClosestDoorToPlayer(transform.position, interior.EntryDoor.recordIndex, out exitDoorPos, out doorIndex))
{
// Could not find exterior door or fall back to entry door
// Just push player outside of building, better than having them trapped inside
exitDoorPos = transform.position + transform.forward * 4;
}
}
// Enable exterior parent
if (ExteriorParent != null)
{
ExteriorParent.SetActive(true);
}
// Disable interior parent
if (InteriorParent != null)
{
InteriorParent.SetActive(false);
}
// Destroy interior game object
Destroy(interior.gameObject);
interior = null;
// Set player outside exterior door position
transform.position = exitDoorPos;
if (doorIndex >= 0)
{
// Adjust player position and facing
Vector3 normal = exteriorDoors.GetDoorNormal(doorIndex);
transform.position += normal * (controller.radius * 2f);
SetFacing(normal);
SetStanding();
}
// Player is now outside building
isPlayerInside = false;
// Fire event
RaiseOnTransitionExteriorEvent();
}
private void AddDoors(StaticDoor[] doors, GameObject target)
{
if (doors != null && target != null)
{
DaggerfallStaticDoors c = target.AddComponent <DaggerfallStaticDoors>();
c.Doors = doors;
}
}
/// <summary>
/// Transition player through an interior door to building exterior. Player must be inside.
/// Interior stores information about exterior, no need for extra params.
/// </summary>
public void TransitionExterior(bool doFade = false)
{
// Exit if missing required components or not currently inside
if (!ReferenceComponents() || !interior || !isPlayerInside)
{
return;
}
// Raise event
RaiseOnPreTransitionEvent(TransitionType.ToBuildingExterior);
//// Find closest exterior door
//Vector3 exitDoorPos = Vector3.zero;
//int doorIndex = -1;
//DaggerfallStaticDoors exteriorDoors = interior.ExteriorDoors;
//if (exteriorDoors)
//{
// if (!exteriorDoors.FindClosestDoorToPlayer(transform.position, interior.EntryDoor.recordIndex, out exitDoorPos, out doorIndex))
// {
// // Could not find exterior door or fall back to entry door
// // Just push player outside of building, better than having them trapped inside
// exitDoorPos = transform.position + transform.forward * 4;
// }
//}
// Find closest door and position player outside of it
StaticDoor closestDoor;
Vector3 closestDoorPos = DaggerfallStaticDoors.FindClosestDoor(transform.position, exteriorDoors, out closestDoor);
Vector3 normal = DaggerfallStaticDoors.GetDoorNormal(closestDoor);
Vector3 position = closestDoorPos + normal * (controller.radius * 2f);
world.SetAutoReposition(StreamingWorld.RepositionMethods.Offset, position);
EnableExteriorParent();
//// Set player outside exterior door position
//transform.position = exitDoorPos;
//if (doorIndex >= 0)
//{
// // Adjust player position and facing
// Vector3 normal = exteriorDoors.GetDoorNormal(doorIndex);
// transform.position += normal * (controller.radius * 2f);
// //SetFacing(normal);
// SetStanding();
//}
// Player is now outside building
isPlayerInside = false;
// Fire event
RaiseOnTransitionExteriorEvent();
// Fade in from black
if (doFade)
{
DaggerfallUI.Instance.FadeHUDFromBlack();
}
}
// Check if raycast hit a static door
private bool StaticDoorCheck(RaycastHit hitInfo, out DaggerfallStaticDoors door)
{
door = hitInfo.transform.GetComponent <DaggerfallStaticDoors>();
if (door == null)
{
return(false);
}
return(true);
}
private static void AddStaticDoors(StaticDoor[] doors, GameObject target)
{
DaggerfallStaticDoors c = target.GetComponent <DaggerfallStaticDoors>();
if (c == null)
{
c = target.AddComponent <DaggerfallStaticDoors>();
}
if (doors != null && target != null)
{
c.Doors = doors;
}
}
// Look for doors on object, then on direct parent
private DaggerfallStaticDoors GetDoors(Transform transform, out Transform owner)
{
owner = null;
DaggerfallStaticDoors doors = transform.GetComponent <DaggerfallStaticDoors>();
if (!doors)
{
doors = transform.GetComponentInParent <DaggerfallStaticDoors>();
if (doors)
{
owner = doors.transform;
}
}
else
{
owner = doors.transform;
}
return(doors);
}
void Update()
{
if (mainCamera == null)
{
return;
}
// Fire ray into scene
if (InputManager.Instance.ActionStarted(InputManager.Actions.ActivateCenterObject))
{
// Using RaycastAll as hits can be blocked by decorations or other models
// When this happens activation feels unresponsive to player
// Also processing hit detection in order of priority
Ray ray = new Ray(mainCamera.transform.position, mainCamera.transform.forward);
RaycastHit[] hits;
hits = Physics.RaycastAll(ray, RayDistance);
if (hits != null)
{
// Check each hit in range for action, exit on first valid action processed
for (int i = 0; i < hits.Length; i++)
{
// Check for a static door hit
Transform doorOwner;
DaggerfallStaticDoors doors = GetDoors(hits[i].transform, out doorOwner);
if (doors && playerEnterExit)
{
StaticDoor door;
if (doors.HasHit(hits[i].point, out door))
{
if (door.doorType == DoorTypes.Building && !playerEnterExit.IsPlayerInside)
{
// Hit door while outside, transition inside
playerEnterExit.TransitionInterior(doorOwner, door, true);
return;
}
else if (door.doorType == DoorTypes.Building && playerEnterExit.IsPlayerInside)
{
// Hit door while inside, transition outside
playerEnterExit.TransitionExterior(true);
return;
}
else if (door.doorType == DoorTypes.DungeonEntrance && !playerEnterExit.IsPlayerInside)
{
if (playerGPS)
{
// Hit dungeon door while outside, transition inside
playerEnterExit.TransitionDungeonInterior(doorOwner, door, playerGPS.CurrentLocation, true);
return;
}
}
else if (door.doorType == DoorTypes.DungeonExit && playerEnterExit.IsPlayerInside)
{
// Hit dungeon exit while inside, transtion outside
playerEnterExit.TransitionDungeonExterior(true);
return;
}
}
}
// Check for an action door hit
DaggerfallActionDoor actionDoor;
if (ActionDoorCheck(hits[i], out actionDoor))
{
actionDoor.ToggleDoor();
}
// Check for action record hit
DaggerfallAction action;
if (ActionCheck(hits[i], out action))
{
action.Receive(this.gameObject, DaggerfallAction.TriggerTypes.Direct);
}
// Check for lootable object hit
DaggerfallLoot loot;
if (LootCheck(hits[i], out loot))
{
// For bodies, check has treasure first
if (loot.ContainerType == LootContainerTypes.CorpseMarker && loot.Items.Count == 0)
{
DaggerfallUI.AddHUDText(HardStrings.theBodyHasNoTreasure);
return;
}
// Open inventory window with loot as remote target
DaggerfallUI.Instance.InventoryWindow.LootTarget = loot;
DaggerfallUI.PostMessage(DaggerfallUIMessages.dfuiOpenInventoryWindow);
}
}
}
}
}
void Update()
{
if (mainCamera == null)
{
return;
}
// Change activate mode
if (InputManager.Instance.ActionStarted(InputManager.Actions.StealMode))
{
ChangeInteractionMode(PlayerActivateModes.Steal);
}
else if (InputManager.Instance.ActionStarted(InputManager.Actions.GrabMode))
{
ChangeInteractionMode(PlayerActivateModes.Grab);
}
else if (InputManager.Instance.ActionStarted(InputManager.Actions.InfoMode))
{
ChangeInteractionMode(PlayerActivateModes.Info);
}
else if (InputManager.Instance.ActionStarted(InputManager.Actions.TalkMode))
{
ChangeInteractionMode(PlayerActivateModes.Talk);
}
// Fire ray into scene
if (InputManager.Instance.ActionStarted(InputManager.Actions.ActivateCenterObject))
{
// TODO: Clean all this up
// Ray origin is slightly below camera height to ensure it originates inside player's own collider
// This prevents ray from intersecting with player's own collider and blocking looting or low triggers
Ray ray = new Ray(transform.position + Vector3.up * 0.7f, mainCamera.transform.forward);
RaycastHit hit;
RayDistance = 75f; // Approximates classic at full view distance (default setting). Classic seems to do raycasts for as far as it can render objects.
bool hitSomething = Physics.Raycast(ray, out hit, RayDistance);
if (hitSomething)
{
bool hitBuilding = false;
bool buildingUnlocked = false;
DFLocation.BuildingTypes buildingType = DFLocation.BuildingTypes.AllValid;
StaticBuilding building = new StaticBuilding();
#region Hit Checks
// Trigger quest resource behaviour click on anything but NPCs
QuestResourceBehaviour questResourceBehaviour;
if (QuestResourceBehaviourCheck(hit, out questResourceBehaviour))
{
if (!(questResourceBehaviour.TargetResource is Person))
{
if (hit.distance > (DefaultActivationDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
return;
}
// Only trigger click when not in info mode
if (currentMode != PlayerActivateModes.Info)
{
TriggerQuestResourceBehaviourClick(questResourceBehaviour);
}
}
}
// Check for a static building hit
Transform buildingOwner;
DaggerfallStaticBuildings buildings = GetBuildings(hit.transform, out buildingOwner);
if (buildings)
{
if (buildings.HasHit(hit.point, out building))
{
hitBuilding = true;
// Get building directory for location
BuildingDirectory buildingDirectory = GameManager.Instance.StreamingWorld.GetCurrentBuildingDirectory();
if (!buildingDirectory)
{
return;
}
// Get detailed building data from directory
BuildingSummary buildingSummary;
if (!buildingDirectory.GetBuildingSummary(building.buildingKey, out buildingSummary))
{
return;
}
// Check if door is unlocked
buildingUnlocked = BuildingIsUnlocked(buildingSummary);
// Store building type
buildingType = buildingSummary.BuildingType;
if (currentMode == PlayerActivateModes.Info)
{
// Discover building
GameManager.Instance.PlayerGPS.DiscoverBuilding(building.buildingKey);
// Get discovered building
PlayerGPS.DiscoveredBuilding db;
if (GameManager.Instance.PlayerGPS.GetDiscoveredBuilding(building.buildingKey, out db))
{
// TODO: Check against quest system for an overriding quest-assigned display name for this building
DaggerfallUI.AddHUDText(db.displayName);
if (!buildingUnlocked && buildingType < DFLocation.BuildingTypes.Temple &&
buildingType != DFLocation.BuildingTypes.HouseForSale)
{
string storeClosedMessage = HardStrings.storeClosed;
storeClosedMessage = storeClosedMessage.Replace("%d1", openHours[(int)buildingType].ToString());
storeClosedMessage = storeClosedMessage.Replace("%d2", closeHours[(int)buildingType].ToString());
DaggerfallUI.Instance.PopupMessage(storeClosedMessage);
}
}
}
}
}
// Check for a static door hit
Transform doorOwner;
DaggerfallStaticDoors doors = GetDoors(hit.transform, out doorOwner);
if (doors && playerEnterExit)
{
StaticDoor door;
if (doors.HasHit(hit.point, out door))
{
// Check if close enough to activate
if (hit.distance > (DoorActivationDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
return;
}
if (door.doorType == DoorTypes.Building && !playerEnterExit.IsPlayerInside)
{
// Discover building
GameManager.Instance.PlayerGPS.DiscoverBuilding(building.buildingKey);
// TODO: Implement lockpicking and door bashing for exterior doors
// For now, any locked building door can be entered by using steal mode
if (!buildingUnlocked)
{
if (currentMode != PlayerActivateModes.Steal)
{
string Locked = "Locked.";
DaggerfallUI.Instance.PopupMessage(Locked);
return;
}
else // Breaking into building
{
PlayerEntity player = GameManager.Instance.PlayerEntity;
//player.TallyCrimeGuildRequirements(true, 1);
}
}
// If entering a shop let player know the quality level
// If entering an open home, show greeting
if (hitBuilding)
{
const int houseGreetingsTextId = 256;
DaggerfallMessageBox mb;
if (buildingUnlocked && buildingType >= DFLocation.BuildingTypes.House1 &&
buildingType <= DFLocation.BuildingTypes.House4)
{
string greetingText = DaggerfallUnity.Instance.TextProvider.GetRandomText(houseGreetingsTextId);
mb = DaggerfallUI.MessageBox(greetingText);
}
else
{
mb = PresentShopQuality(building);
}
if (mb != null)
{
// Defer transition to interior to after user closes messagebox
deferredInteriorDoorOwner = doorOwner;
deferredInteriorDoor = door;
mb.OnClose += Popup_OnClose;
return;
}
}
// Hit door while outside, transition inside
TransitionInterior(doorOwner, door, true);
return;
}
else if (door.doorType == DoorTypes.Building && playerEnterExit.IsPlayerInside)
{
// Hit door while inside, transition outside
playerEnterExit.TransitionExterior(true);
return;
}
else if (door.doorType == DoorTypes.DungeonEntrance && !playerEnterExit.IsPlayerInside)
{
if (playerGPS)
{
// Hit dungeon door while outside, transition inside
playerEnterExit.TransitionDungeonInterior(doorOwner, door, playerGPS.CurrentLocation, true);
return;
}
}
else if (door.doorType == DoorTypes.DungeonExit && playerEnterExit.IsPlayerInside)
{
// Hit dungeon exit while inside, ask if access wagon or transition outside
if (GameManager.Instance.PlayerEntity.Items.Contains(ItemGroups.Transportation, (int)Transportation.Small_cart))
{
DaggerfallMessageBox messageBox = new DaggerfallMessageBox(DaggerfallUI.UIManager, DaggerfallMessageBox.CommonMessageBoxButtons.YesNo, 38, DaggerfallUI.UIManager.TopWindow);
messageBox.OnButtonClick += DungeonWagonAccess_OnButtonClick;
DaggerfallUI.UIManager.PushWindow(messageBox);
return;
}
else
{
playerEnterExit.TransitionDungeonExterior(true);
}
}
}
}
// Check for an action door hit
DaggerfallActionDoor actionDoor;
if (ActionDoorCheck(hit, out actionDoor))
{
// Check if close enough to activate
if (hit.distance > (DoorActivationDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
return;
}
if (currentMode == PlayerActivateModes.Steal && actionDoor.IsLocked && !actionDoor.IsOpen)
{
actionDoor.AttemptLockpicking();
}
else
{
actionDoor.ToggleDoor(true);
}
}
// Check for action record hit
DaggerfallAction action;
if (ActionCheck(hit, out action))
{
if (hit.distance <= (DefaultActivationDistance * MeshReader.GlobalScale))
{
action.Receive(this.gameObject, DaggerfallAction.TriggerTypes.Direct);
}
}
// Check for lootable object hit
DaggerfallLoot loot;
if (LootCheck(hit, out loot))
{
switch (currentMode)
{
case PlayerActivateModes.Info:
if (loot.ContainerType == LootContainerTypes.CorpseMarker && !string.IsNullOrEmpty(loot.entityName))
{
string message = string.Empty;
if (loot.isEnemyClass)
{
message = HardStrings.youSeeADeadPerson;
}
else
{
message = HardStrings.youSeeADead;
message = message.Replace("%s", loot.entityName);
}
DaggerfallUI.Instance.PopupMessage(message);
}
break;
case PlayerActivateModes.Grab:
case PlayerActivateModes.Talk:
case PlayerActivateModes.Steal:
// Check if close enough to activate
if (loot.ContainerType == LootContainerTypes.CorpseMarker)
{
if (hit.distance > CorpseActivationDistance * MeshReader.GlobalScale)
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
break;
}
}
else if (hit.distance > TreasureActivationDistance * MeshReader.GlobalScale)
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
break;
}
// For bodies, check has treasure first
if (loot.ContainerType == LootContainerTypes.CorpseMarker && loot.Items.Count == 0)
{
DaggerfallUI.AddHUDText(HardStrings.theBodyHasNoTreasure);
break;
}
// Open inventory window with loot as remote target
DaggerfallUI.Instance.InventoryWindow.LootTarget = loot;
DaggerfallUI.PostMessage(DaggerfallUIMessages.dfuiOpenInventoryWindow);
break;
}
}
// Check for static NPC hit
StaticNPC npc;
if (NPCCheck(hit, out npc))
{
switch (currentMode)
{
case PlayerActivateModes.Info:
PresentNPCInfo(npc);
break;
case PlayerActivateModes.Grab:
case PlayerActivateModes.Talk:
case PlayerActivateModes.Steal:
if (hit.distance > (StaticNPCActivationDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
break;
}
StaticNPCClick(npc);
break;
}
}
// Check for mobile NPC hit
MobilePersonNPC mobileNpc = null;
if (MobilePersonMotorCheck(hit, out mobileNpc))
{
switch (currentMode)
{
case PlayerActivateModes.Info:
case PlayerActivateModes.Grab:
case PlayerActivateModes.Talk:
if (hit.distance > (MobileNPCActivationDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
break;
}
GameManager.Instance.TalkManager.TalkToMobileNPC(mobileNpc);
break;
case PlayerActivateModes.Steal:
if (!mobileNpc.PickpocketByPlayerAttempted)
{
if (hit.distance > (PickpocketDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
break;
}
mobileNpc.PickpocketByPlayerAttempted = true;
Pickpocket();
}
break;
}
}
// Check for mobile enemy hit
DaggerfallEntityBehaviour mobileEnemyBehaviour;
if (MobileEnemyCheck(hit, out mobileEnemyBehaviour))
{
EnemyEntity enemyEntity = mobileEnemyBehaviour.Entity as EnemyEntity;
switch (currentMode)
{
case PlayerActivateModes.Info:
case PlayerActivateModes.Grab:
case PlayerActivateModes.Talk:
if (enemyEntity != null)
{
MobileEnemy mobileEnemy = enemyEntity.MobileEnemy;
bool startsWithVowel = "aeiouAEIOU".Contains(mobileEnemy.Name[0].ToString());
string message;
if (startsWithVowel)
{
message = HardStrings.youSeeAn;
}
else
{
message = HardStrings.youSeeA;
}
message = message.Replace("%s", mobileEnemy.Name);
DaggerfallUI.Instance.PopupMessage(message);
}
break;
case PlayerActivateModes.Steal:
// Classic allows pickpocketing of NPC mobiles and enemy mobiles.
// In early versions the only enemy mobiles that can be pickpocketed are classes,
// but patch 1.07.212 allows pickpocketing of creatures.
// For now, the only enemy mobiles being allowed by DF Unity are classes.
if (mobileEnemyBehaviour && (mobileEnemyBehaviour.EntityType != EntityTypes.EnemyClass))
{
break;
}
// Classic doesn't set any flag when pickpocketing enemy mobiles, so infinite attempts are possible
if (enemyEntity != null && !enemyEntity.PickpocketByPlayerAttempted)
{
if (hit.distance > (PickpocketDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
break;
}
enemyEntity.PickpocketByPlayerAttempted = true;
Pickpocket(mobileEnemyBehaviour);
}
break;
}
}
// Trigger ladder hit
DaggerfallLadder ladder = hit.transform.GetComponent <DaggerfallLadder>();
if (ladder)
{
if (hit.distance > (DefaultActivationDistance * MeshReader.GlobalScale))
{
DaggerfallUI.SetMidScreenText(HardStrings.youAreTooFarAway);
return;
}
ladder.ClimbLadder();
}
#endregion
}
}
}
/// <summary>
/// Transition player through an exterior door into building interior.
/// </summary>
/// <param name="doorOwner">Parent transform owning door array..</param>
/// <param name="door">Exterior door player clicked on.</param>
public void TransitionInterior(Transform doorOwner, StaticDoor door, bool doFade = false, bool start = true)
{
// Ensure we have component references
if (!ReferenceComponents())
{
return;
}
// Copy owner position to door
// This ensures the door itself is all we need to reposition interior
// Useful when loading a save and doorOwner is null (as outside world does not exist)
if (doorOwner)
{
door.ownerPosition = doorOwner.position;
door.ownerRotation = doorOwner.rotation;
}
if (!start)
{
// Update scene cache from serializable state for exterior->interior transition
SaveLoadManager.CacheScene(world.SceneName);
// Explicitly deregister all stateful objects since exterior isn't destroyed
SaveLoadManager.DeregisterAllSerializableGameObjects(true);
// Clear all stateful objects from world loose object tracking
world.ClearStatefulLooseObjects();
}
// Raise event
RaiseOnPreTransitionEvent(TransitionType.ToBuildingInterior, door);
// Ensure expired rooms are removed
GameManager.Instance.PlayerEntity.RemoveExpiredRentedRooms();
// Get climate
ClimateBases climateBase = ClimateBases.Temperate;
if (OverrideLocation)
{
climateBase = OverrideLocation.Summary.Climate;
}
else if (playerGPS)
{
climateBase = ClimateSwaps.FromAPIClimateBase(playerGPS.ClimateSettings.ClimateType);
}
// Layout interior
// This needs to be done first so we know where the enter markers are
GameObject newInterior = new GameObject(DaggerfallInterior.GetSceneName(playerGPS.CurrentLocation, door));
newInterior.hideFlags = defaultHideFlags;
interior = newInterior.AddComponent <DaggerfallInterior>();
// Try to layout interior
// If we fail for any reason, use that old chestnut "this house has nothing of value"
try
{
interior.DoLayout(doorOwner, door, climateBase, buildingDiscoveryData);
}
catch
{
DaggerfallUI.AddHUDText(HardStrings.thisHouseHasNothingOfValue);
Destroy(newInterior);
return;
}
// Position interior directly inside of exterior
// This helps with finding closest enter/exit point relative to player position
interior.transform.position = door.ownerPosition + (Vector3)door.buildingMatrix.GetColumn(3);
interior.transform.rotation = GameObjectHelper.QuaternionFromMatrix(door.buildingMatrix);
// Position player above closest enter marker
Vector3 marker;
if (!interior.FindClosestEnterMarker(transform.position, out marker))
{
// Could not find an enter marker, probably not a valid interior
Destroy(newInterior);
return;
}
// Enumerate all exterior doors belonging to this building
DaggerfallStaticDoors exteriorStaticDoors = interior.ExteriorDoors;
if (exteriorStaticDoors && doorOwner)
{
List <StaticDoor> buildingDoors = new List <StaticDoor>();
for (int i = 0; i < exteriorStaticDoors.Doors.Length; i++)
{
if (exteriorStaticDoors.Doors[i].recordIndex == door.recordIndex)
{
StaticDoor newDoor = exteriorStaticDoors.Doors[i];
newDoor.ownerPosition = doorOwner.position;
newDoor.ownerRotation = doorOwner.rotation;
buildingDoors.Add(newDoor);
}
}
SetExteriorDoors(buildingDoors.ToArray());
}
// Assign new interior to parent
if (InteriorParent != null)
{
newInterior.transform.parent = InteriorParent.transform;
}
// Cache some information about this interior
buildingType = interior.BuildingData.BuildingType;
factionID = interior.BuildingData.FactionId;
// Set player to marker position
// TODO: Find closest door for player facing
transform.position = marker + Vector3.up * (controller.height * 0.6f);
SetStanding();
EnableInteriorParent();
// Add quest resources
GameObjectHelper.AddQuestResourceObjects(SiteTypes.Building, interior.transform, interior.EntryDoor.buildingKey);
// Update serializable state from scene cache for exterior->interior transition (unless new/load game)
if (!start)
{
SaveLoadManager.RestoreCachedScene(interior.name);
}
// Raise event
RaiseOnTransitionInteriorEvent(door, interior);
// Fade in from black
if (doFade)
{
DaggerfallUI.Instance.FadeHUDFromBlack();
}
}
void Update()
{
if (mainCamera == null)
{
return;
}
// Change activate mode
if (InputManager.Instance.ActionStarted(InputManager.Actions.StealMode))
{
ChangeInteractionMode(PlayerActivateModes.Steal);
}
else if (InputManager.Instance.ActionStarted(InputManager.Actions.GrabMode))
{
ChangeInteractionMode(PlayerActivateModes.Grab);
}
else if (InputManager.Instance.ActionStarted(InputManager.Actions.InfoMode))
{
ChangeInteractionMode(PlayerActivateModes.Info);
}
else if (InputManager.Instance.ActionStarted(InputManager.Actions.TalkMode))
{
ChangeInteractionMode(PlayerActivateModes.Talk);
}
// Fire ray into scene
if (InputManager.Instance.ActionStarted(InputManager.Actions.ActivateCenterObject))
{
// TODO: Clean all this up and support mobile enemy info-clicks
// Using RaycastAll as hits can be blocked by decorations or other models
// When this happens activation feels unresponsive to player
// Also processing hit detection in order of priority
Ray ray = new Ray(mainCamera.transform.position, mainCamera.transform.forward);
RaycastHit[] hits;
hits = Physics.RaycastAll(ray, RayDistance);
if (hits != null)
{
// Check each hit in range for action, exit on first valid action processed
bool hitBuilding = false;
StaticBuilding building = new StaticBuilding();
for (int i = 0; i < hits.Length; i++)
{
#region Hit Checks
// Check for a static building hit
Transform buildingOwner;
DaggerfallStaticBuildings buildings = GetBuildings(hits[i].transform, out buildingOwner);
if (buildings)
{
if (buildings.HasHit(hits[i].point, out building))
{
hitBuilding = true;
// Show building info
if (currentMode == PlayerActivateModes.Info)
{
PresentBuildingInfo(building);
}
}
}
// Check for a static door hit
Transform doorOwner;
DaggerfallStaticDoors doors = GetDoors(hits[i].transform, out doorOwner);
if (doors && playerEnterExit)
{
StaticDoor door;
if (doors.HasHit(hits[i].point, out door))
{
if (door.doorType == DoorTypes.Building && !playerEnterExit.IsPlayerInside)
{
// If entering a shop let player know the quality level
if (hitBuilding)
{
DaggerfallMessageBox mb = PresentShopQuality(building);
if (mb != null)
{
// Defer transition to interior to after user closes messagebox
deferredInteriorDoorOwner = doorOwner;
deferredInteriorDoor = door;
mb.OnClose += ShopQualityPopup_OnClose;
return;
}
}
// Hit door while outside, transition inside
playerEnterExit.TransitionInterior(doorOwner, door, true);
return;
}
else if (door.doorType == DoorTypes.Building && playerEnterExit.IsPlayerInside)
{
// Hit door while inside, transition outside
playerEnterExit.TransitionExterior(true);
return;
}
else if (door.doorType == DoorTypes.DungeonEntrance && !playerEnterExit.IsPlayerInside)
{
if (playerGPS)
{
// Hit dungeon door while outside, transition inside
playerEnterExit.TransitionDungeonInterior(doorOwner, door, playerGPS.CurrentLocation, true);
return;
}
}
else if (door.doorType == DoorTypes.DungeonExit && playerEnterExit.IsPlayerInside)
{
// Hit dungeon exit while inside, transition outside
playerEnterExit.TransitionDungeonExterior(true);
return;
}
}
}
// Check for an action door hit
DaggerfallActionDoor actionDoor;
if (ActionDoorCheck(hits[i], out actionDoor))
{
if (currentMode == PlayerActivateModes.Steal && actionDoor.IsLocked)
{
if (actionDoor.IsNoLongerPickable)
{
return;
}
else
{
actionDoor.AttemptLockpicking();
}
}
else
{
actionDoor.ToggleDoor();
}
}
// Check for action record hit
DaggerfallAction action;
if (ActionCheck(hits[i], out action))
{
action.Receive(this.gameObject, DaggerfallAction.TriggerTypes.Direct);
}
// Check for lootable object hit
DaggerfallLoot loot;
if (LootCheck(hits[i], out loot))
{
// For bodies, check has treasure first
if (loot.ContainerType == LootContainerTypes.CorpseMarker && loot.Items.Count == 0)
{
DaggerfallUI.AddHUDText(HardStrings.theBodyHasNoTreasure);
return;
}
// Open inventory window with loot as remote target
DaggerfallUI.Instance.InventoryWindow.LootTarget = loot;
DaggerfallUI.PostMessage(DaggerfallUIMessages.dfuiOpenInventoryWindow);
}
// Check for static NPC hit
StaticNPC npc;
if (NPCCheck(hits[i], out npc))
{
switch (currentMode)
{
case PlayerActivateModes.Info:
PresentNPCInfo(npc);
break;
case PlayerActivateModes.Grab:
case PlayerActivateModes.Talk:
SpecialNPCClick(npc);
QuestorCheck(npc);
break;
}
}
// Trigger general quest resource behaviour click
// Note: This will cause a second click on special NPCs, look into a way to unify this handling
QuestResourceBehaviour questResourceBehaviour;
if (QuestResourceBehaviourCheck(hits[i], out questResourceBehaviour))
{
TriggerQuestResourceBehaviourClick(questResourceBehaviour);
}
#endregion
}
}
}
}
void Update()
{
if (mainCamera == null || uiOwner.GetComponent <UIManager>().isUIOpen)
{
return;
}
// Fire ray into scene
if (Input.GetButtonDown("Fire1"))
{
// Using RaycastAll as hits can be blocked by decorations or other models
// When this happens activation feels unresponsive to player
// Also processing hit detection in order of priority
Ray ray = new Ray(mainCamera.transform.position, mainCamera.transform.forward);
RaycastHit[] hits;
hits = Physics.RaycastAll(ray, RayDistance);
if (hits != null)
{
// Check each hit in range for action, exit on first valid action processed
for (int i = 0; i < hits.Length; i++)
{
// Check for an action door hit
DaggerfallActionDoor actionDoor;
if (ActionDoorCheck(hits[i], out actionDoor))
{
actionDoor.ToggleDoor();
return;
}
// Check for action record hit
DaggerfallAction action;
if (ActionCheck(hits[i], out action))
{
action.Play();
return;
}
// Check for a static door hit
Transform doorOwner;
DaggerfallStaticDoors doors = GetDoors(hits[i].transform, out doorOwner);
if (doors && playerEnterExit)
{
StaticDoor door;
if (doors.HasHit(hits[i].point, out door))
{
if (door.doorType == DoorTypes.Building && !playerEnterExit.IsPlayerInside)
{
// Hit door while outside, transition inside
playerEnterExit.TransitionInterior(doorOwner, door);
return;
}
else if (door.doorType == DoorTypes.Building && playerEnterExit.IsPlayerInside)
{
// Hit door while inside, transition outside
playerEnterExit.TransitionExterior();
return;
}
else if (door.doorType == DoorTypes.DungeonEntrance && !playerEnterExit.IsPlayerInside)
{
if (playerGPS)
{
// Hit dungeon door while outside, transition inside
playerEnterExit.TransitionDungeonInterior(doorOwner, door, playerGPS.CurrentLocation);
return;
}
}
else if (door.doorType == DoorTypes.DungeonExit && playerEnterExit.IsPlayerInside)
{
// Hit dungeon exit while inside, transtion outside
playerEnterExit.TransitionDungeonExterior();
return;
}
}
}
}
}
}
}
// Check if raycast hit a static door
private bool StaticDoorCheck(RaycastHit hitInfo, out DaggerfallStaticDoors door)
{
door = hitInfo.transform.GetComponent<DaggerfallStaticDoors>();
if (door == null)
return false;
return true;
}
/// <summary>
/// Transition player through a dungeon entrance door into dungeon interior.
/// </summary>
/// <param name="doorOwner">Parent transform owning door array.</param>
/// <param name="door">Exterior door player clicked on.</param>
public void TransitionDungeonInterior(Transform doorOwner, StaticDoor door, DFLocation location, bool doFade = false)
{
// Ensure we have component references
if (!ReferenceComponents())
{
return;
}
// Reset dungeon block on entering dungeon
lastPlayerDungeonBlockIndex = -1;
playerDungeonBlockData = new DFLocation.DungeonBlock();
// Override location if specified
if (OverrideLocation != null)
{
DFLocation overrideLocation = dfUnity.ContentReader.MapFileReader.GetLocation(OverrideLocation.Summary.RegionName, OverrideLocation.Summary.LocationName);
if (overrideLocation.Loaded)
{
location = overrideLocation;
}
}
// Raise event
RaiseOnPreTransitionEvent(TransitionType.ToDungeonInterior, door);
// Layout dungeon
GameObject newDungeon = GameObjectHelper.CreateDaggerfallDungeonGameObject(location, DungeonParent.transform);
newDungeon.hideFlags = defaultHideFlags;
dungeon = newDungeon.GetComponent <DaggerfallDungeon>();
// Find start marker to position player
if (!dungeon.StartMarker)
{
// Could not find a start marker
Destroy(newDungeon);
return;
}
EnableDungeonParent();
// Set to start position
MovePlayerToMarker(dungeon.StartMarker);
// Find closest dungeon exit door to orient player
StaticDoor[] doors = DaggerfallStaticDoors.FindDoorsInCollections(dungeon.StaticDoorCollections, DoorTypes.DungeonExit);
if (doors != null && doors.Length > 0)
{
Vector3 doorPos;
int doorIndex;
if (DaggerfallStaticDoors.FindClosestDoorToPlayer(transform.position, doors, out doorPos, out doorIndex))
{
// Set player facing away from door
PlayerMouseLook playerMouseLook = GameManager.Instance.PlayerMouseLook;
if (playerMouseLook)
{
Vector3 normal = DaggerfallStaticDoors.GetDoorNormal(doors[doorIndex]);
playerMouseLook.SetFacing(normal);
}
}
}
// Raise event
RaiseOnTransitionDungeonInteriorEvent(door, dungeon);
// Fade in from black
if (doFade)
{
DaggerfallUI.Instance.FadeHUDFromBlack();
}
}
public void UpdateMarkers(bool RemoveMarkersOnly = false)
{
foreach (GameObject marker in buildingInfoCollection)
{
if (marker.GetComponent <BuildingMarker>() != null)
{
BuildingMarker markerInstance = marker.GetComponent <BuildingMarker>();
Destroy(markerInstance.marker.attachedDoorIcon);
Destroy(markerInstance.marker.attachedLabel);
Destroy(markerInstance.marker.attachedMesh);
Destroy(markerInstance.marker.attachedQuestIcon);
Destroy(markerInstance.marker.attachedIcon);
Destroy(markerInstance);
}
if (marker != null)
{
Destroy(marker);
}
}
buildingInfoCollection.Clear();
buildingInfoCollection = new List <GameObject>();
if (RemoveMarkersOnly)
{
return;
}
generatingMarkers = true;
//Vector3 position = currentCityNav.WorldToScenePosition(new DFPosition(Minimap.currentLocation.Summary.MapPixelX, Minimap.currentLocation.Summary.MapPixelX), true);
List <BuildingSummary> housesForSaleList = buildingDirectory.GetHousesForSale();
foreach (DaggerfallRMBBlock block in blockArray)
{
Vector3 blockPosition = block.transform.position;
//setup a new static buildings object to hold the rmb blocks static buildings object.
DaggerfallStaticBuildings staticBuildingContainer = block.GetComponentInChildren <DaggerfallStaticBuildings>();
//if there are not any buildings in this block, stop code from crashing script and return.
if (staticBuildingContainer == null)
{
continue;
}
//resize static building array based on the number of static building pbjects in the container.
StaticBuildingArray = new StaticBuilding[staticBuildingContainer.transform.childCount];
//load blocks static building array into the empty array for looping through.
StaticBuildingArray = staticBuildingContainer.Buildings;
// Find the doors for the buildings and drop into a list for referencing below when setting up individual building information.
StaticDoor[] doors = DaggerfallStaticDoors.FindDoorsInCollections(GameManager.Instance.StreamingWorld.CurrentPlayerLocationObject.StaticDoorCollections, DoorTypes.Building);
List <CombineInstance> houseMeshList = new List <CombineInstance>();
//runs through building array.
foreach (StaticBuilding building in StaticBuildingArray)
{
//sets up and grabes the current buildings material, summary object/info, placing/final position, game model.
BuildingSummary SavedBuilding = new BuildingSummary();
buildingDirectory.GetBuildingSummary(building.buildingKey, out SavedBuilding);
if (SavedBuilding.BuildingType == DFLocation.BuildingTypes.AllValid)
{
continue;
}
Vector3 markerPosition = new Vector3(0, 0, 0);
if (building.size.z > tallestSpot)
{
tallestSpot = building.size.z;
}
//create gameobject for building marker.
GameObject buildingMarkerObject = GameObjectHelper.CreateDaggerfallMeshGameObject(SavedBuilding.ModelID, null, false, null, true, false);
buildingMarkerObject.GetComponent <Renderer>().enabled = false;
buildingMarkerObject.transform.position = new Vector3(blockPosition.x + SavedBuilding.Position.x, blockPosition.y + tallestSpot + 10f, blockPosition.z + SavedBuilding.Position.z);
//buildingMarkerObject.SetActive(false);
BuildingMarker buildingsInfo = buildingMarkerObject.AddComponent <BuildingMarker>();
MeshRenderer buildingMesh = buildingMarkerObject.GetComponent <MeshRenderer>();
buildingsInfo.marker.attachedMesh = buildingMarkerObject;
buildingMarkerObject.transform.position = buildingMarkerObject.transform.position;
buildingMarkerObject.transform.Rotate(SavedBuilding.Rotation);
buildingMarkerObject.layer = Minimap.layerMinimap;
buildingMarkerObject.transform.localScale = new Vector3(1, 0.01f, 1);
buildingMarkerObject.name = string.Concat(SavedBuilding.BuildingType.ToString(), " Marker ", SavedBuilding.buildingKey);
buildingMesh.shadowCastingMode = 0;
buildingMesh.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
buildingMesh.motionVectorGenerationMode = MotionVectorGenerationMode.ForceNoMotion;
//Destroy(buildingMarkerObject.GetComponent<MeshCollider>());
//grab and store all building info into the building marker object.
buildingsInfo.marker.staticBuilding = building;
buildingsInfo.marker.buildingSummary = SavedBuilding;
buildingsInfo.marker.buildingKey = SavedBuilding.buildingKey;
foreach (BuildingSummary buildingInfo in housesForSaleList)
{
if (buildingInfo.BuildingType == DFLocation.BuildingTypes.HouseForSale)
{
buildingsInfo.marker.buildingType = DFLocation.BuildingTypes.HouseForSale;
}
else
{
buildingsInfo.marker.buildingType = SavedBuilding.BuildingType;
}
}
buildingsInfo.marker.buildingLocation = GameManager.Instance.PlayerGPS.CurrentLocation;
//buildingPositionList.Add(new Vector3(block.transform.position.x + SavedBuilding.Position.x, SavedBuilding.Position.y, block.transform.position.z + SavedBuilding.Position.z));
buildingsInfo.marker.position = buildingMarkerObject.transform.position;
foreach (StaticDoor buildingsDoor in doors)
{
if (building.buildingKey == buildingsDoor.buildingKey)
{
buildingsInfo.marker.doorPosition = DaggerfallStaticDoors.GetDoorPosition(buildingsDoor);
}
}
//setup ref properties for quest resource locator below.
bool pcLearnedAboutExistence = false;
bool receivedDirectionalHints = false;
bool locationWasMarkedOnMapByNPC = false;
string overrideBuildingName = string.Empty;
//check if the building contains a quest using quest resouces. If found to contain a quest, mark it so.
if (GameManager.Instance.TalkManager.IsBuildingQuestResource(GameManager.Instance.PlayerGPS.CurrentMapID, buildingsInfo.marker.buildingKey, ref overrideBuildingName, ref pcLearnedAboutExistence, ref receivedDirectionalHints, ref locationWasMarkedOnMapByNPC))
{
Minimap.lastQuestMarkerPosition = buildingsInfo.marker.position;
buildingsInfo.marker.questActive = true;
}
//save building to building collection. This is more for other modders to use how they wish, since it contains all the building info for every building in a city.
buildingInfoCollection.Add(buildingMarkerObject);
}
}
markersGenerated = true;
}
/// <summary>
/// Transition player through an exterior door into building interior.
/// </summary>
/// <param name="doorOwner">Parent transform owning door array..</param>
/// <param name="door">Exterior door player clicked on.</param>
public void TransitionInterior(Transform doorOwner, StaticDoor door, bool doFade = false)
{
// Ensure we have component references
if (!ReferenceComponents())
{
return;
}
// Copy owner position to door
// This ensures the door itself is all we need to reposition interior
// Useful when loading a save and doorOwner is null (as outside world does not exist)
if (doorOwner)
{
door.ownerPosition = doorOwner.position;
door.ownerRotation = doorOwner.rotation;
}
// Raise event
RaiseOnPreTransitionEvent(TransitionType.ToBuildingInterior, door);
// Get climate
ClimateBases climateBase = ClimateBases.Temperate;
if (OverrideLocation)
{
climateBase = OverrideLocation.Summary.Climate;
}
else if (playerGPS)
{
climateBase = ClimateSwaps.FromAPIClimateBase(playerGPS.ClimateSettings.ClimateType);
}
// Layout interior
// This needs to be done first so we know where the enter markers are
GameObject newInterior = new GameObject(string.Format("DaggerfallInterior [Block={0}, Record={1}]", door.blockIndex, door.recordIndex));
newInterior.hideFlags = defaultHideFlags;
interior = newInterior.AddComponent <DaggerfallInterior>();
// Try to layout interior
// If we fail for any reason, use that old chestnut "this house has nothing of value"
try
{
interior.DoLayout(doorOwner, door, climateBase);
}
catch
{
DaggerfallUI.AddHUDText(UserInterfaceWindows.HardStrings.thisHouseHasNothingOfValue);
Destroy(newInterior);
return;
}
// Position interior directly inside of exterior
// This helps with finding closest enter/exit point relative to player position
interior.transform.position = door.ownerPosition + (Vector3)door.buildingMatrix.GetColumn(3);
interior.transform.rotation = GameObjectHelper.QuaternionFromMatrix(door.buildingMatrix);
// Position player above closest enter marker
Vector3 marker;
if (!interior.FindClosestEnterMarker(transform.position, out marker))
{
// Could not find an enter marker, probably not a valid interior
Destroy(newInterior);
return;
}
// Enumerate all exterior doors belonging to this building
DaggerfallStaticDoors exteriorStaticDoors = interior.ExteriorDoors;
if (exteriorStaticDoors && doorOwner)
{
List <StaticDoor> buildingDoors = new List <StaticDoor>();
for (int i = 0; i < exteriorStaticDoors.Doors.Length; i++)
{
if (exteriorStaticDoors.Doors[i].recordIndex == door.recordIndex)
{
StaticDoor newDoor = exteriorStaticDoors.Doors[i];
newDoor.ownerPosition = doorOwner.position;
newDoor.ownerRotation = doorOwner.rotation;
buildingDoors.Add(newDoor);
}
}
SetExteriorDoors(buildingDoors.ToArray());
}
// Assign new interior to parent
if (InteriorParent != null)
{
newInterior.transform.parent = InteriorParent.transform;
}
// Cache some information about this interior
buildingType = interior.BuildingData.BuildingType;
// Set player to marker position
// TODO: Find closest door for player facing
transform.position = marker + Vector3.up * (controller.height * 0.6f);
SetStanding();
EnableInteriorParent();
// Raise event
RaiseOnTransitionInteriorEvent(door, interior);
// Fade in from black
if (doFade)
{
DaggerfallUI.Instance.FadeHUDFromBlack();
}
}
/// <summary>
/// Instantiate base RDB block by DFBlock data.
/// </summary>
/// <param name="blockData">Block data.</param>
/// <param name="textureTable">Optional texture table for dungeon.</param>
/// <param name="allowExitDoors">Add exit doors to block.</param>
/// <param name="cloneFrom">Clone and build on a prefab object template.</param>
/// <returns>Block GameObject.</returns>
public static GameObject CreateBaseGameObject(
ref DFBlock blockData,
int[] textureTable = null,
bool allowExitDoors = true,
DaggerfallRDBBlock cloneFrom = null)
{
DaggerfallUnity dfUnity = DaggerfallUnity.Instance;
if (!dfUnity.IsReady)
{
return(null);
}
// Use default texture table if one not specified
if (textureTable == null)
{
textureTable = StaticTextureTables.DefaultTextureTable;
}
// Create gameobject
GameObject go;
string name = string.Format("DaggerfallBlock [{0}]", blockData.Name);
if (cloneFrom != null)
{
go = GameObjectHelper.InstantiatePrefab(cloneFrom.gameObject, name, null, Vector3.zero);
}
else
{
go = new GameObject(name);
go.AddComponent <DaggerfallRDBBlock>();
}
// Setup combiner
ModelCombiner combiner = null;
if (dfUnity.Option_CombineRDB)
{
combiner = new ModelCombiner();
}
// Add parent node
GameObject modelsNode = new GameObject("Models");
GameObject actionModelsNode = new GameObject("Action Models");
modelsNode.transform.parent = go.transform;
actionModelsNode.transform.parent = go.transform;
// Add models
List <StaticDoor> exitDoors;
AddModels(
dfUnity,
ref blockData,
textureTable,
allowExitDoors,
out exitDoors,
combiner,
modelsNode.transform,
actionModelsNode.transform);
// Apply combiner
if (combiner != null)
{
if (combiner.VertexCount > 0)
{
combiner.Apply();
GameObject cgo = GameObjectHelper.CreateCombinedMeshGameObject(
combiner,
"CombinedModels",
modelsNode.transform,
dfUnity.Option_SetStaticFlags);
cgo.GetComponent <DaggerfallMesh>().SetDungeonTextures(textureTable);
}
}
// Add exit doors
if (exitDoors.Count > 0)
{
DaggerfallStaticDoors c = go.AddComponent <DaggerfallStaticDoors>();
c.Doors = exitDoors.ToArray();
}
return(go);
}
