public void ReceiveHouse(PlayerEntity playerEntity)
{
if (rank < 9)
{
DaggerfallUI.MessageBox(NoHouseId);
}
else if ((flags & HouseFlagMask) > 0)
{
DaggerfallUI.MessageBox(HardStrings.serviceReceiveHouseAlready);
}
else
{ // Give a house if one availiable
if (DaggerfallBankManager.OwnsHouse)
{
DaggerfallUI.MessageBox((int)TransactionResult.ALREADY_OWN_HOUSE);
}
else
{
BuildingDirectory buildingDirectory = GameManager.Instance.StreamingWorld.GetCurrentBuildingDirectory();
if (buildingDirectory)
{
List <BuildingSummary> housesForSale = buildingDirectory.GetHousesForSale();
if (housesForSale.Count > 0)
{
BuildingSummary house = housesForSale[UnityEngine.Random.Range(0, housesForSale.Count)];
DaggerfallBankManager.AllocateHouseToPlayer(house, GameManager.Instance.PlayerGPS.CurrentRegionIndex);
flags = flags | HouseFlagMask;
DaggerfallUI.MessageBox(HouseId);
return;
}
}
DaggerfallUI.MessageBox((int)TransactionResult.NO_HOUSES_FOR_SALE);
}
}
}
/// <summary>
/// Gets BuildingSummary array generated from DFBlock data.
/// </summary>
/// <param name="blockData"></param>
/// <returns></returns>
public static BuildingSummary[] GetBuildingData(DFBlock blockData)
{
// Store building information
int buildingCount = blockData.RmbBlock.SubRecords.Length;
BuildingSummary[] buildings = new BuildingSummary[buildingCount];
for (int i = 0; i < buildingCount; i++)
{
// Create building summary
buildings[i] = new BuildingSummary();
// Set building data
DFLocation.BuildingData buildingData = blockData.RmbBlock.FldHeader.BuildingDataList[i];
buildings[i].NameSeed = buildingData.NameSeed;
buildings[i].FactionId = buildingData.FactionId;
buildings[i].LocationId = buildingData.LocationId;
buildings[i].BuildingType = buildingData.BuildingType;
buildings[i].Quality = buildingData.Quality;
// Set building transform info
DFBlock.RmbSubRecord subRecord = blockData.RmbBlock.SubRecords[i];
buildings[i].Position = new Vector3(subRecord.XPos, 0, BlocksFile.RMBDimension - subRecord.ZPos) * MeshReader.GlobalScale;
buildings[i].Rotation = new Vector3(0, -subRecord.YRotation / BlocksFile.RotationDivisor, 0);
buildings[i].Matrix = Matrix4x4.TRS(buildings[i].Position, Quaternion.Euler(buildings[i].Rotation), Vector3.one);
}
return(buildings);
}
/// <summary>
/// Gets BuildingSummary array generated from DFBlock data.
/// DFBlock data should be provided from RMBLayout.GetLocationBuildingData() output.
/// Otherwise not all building data will be present.
/// </summary>
/// <param name="blockData">DFBlock data.</param>
/// <param name="layoutX">X coordindate in map layout used to generate building key.</param>
/// <param name="layoutY">Y coordindate in map layout used to generate building key.</param>
/// <returns>BuildingSummary.</returns>
public static BuildingSummary[] GetBuildingData(DFBlock blockData, int layoutX = -1, int layoutY = -1)
{
// Store building information
int buildingCount = blockData.RmbBlock.SubRecords.Length;
BuildingSummary[] buildings = new BuildingSummary[buildingCount];
for (int i = 0; i < buildingCount; i++)
{
// Create building summary
buildings[i] = new BuildingSummary();
// Set building data
DFLocation.BuildingData buildingData = blockData.RmbBlock.FldHeader.BuildingDataList[i];
buildings[i].buildingKey = BuildingDirectory.MakeBuildingKey((byte)layoutX, (byte)layoutY, (byte)i);
buildings[i].NameSeed = buildingData.NameSeed;
buildings[i].FactionId = buildingData.FactionId;
buildings[i].BuildingType = buildingData.BuildingType;
buildings[i].Quality = buildingData.Quality;
// Set building transform info
DFBlock.RmbSubRecord subRecord = blockData.RmbBlock.SubRecords[i];
buildings[i].Position = new Vector3(subRecord.XPos, 0, BlocksFile.RMBDimension - subRecord.ZPos) * MeshReader.GlobalScale;
buildings[i].Rotation = new Vector3(0, -subRecord.YRotation / BlocksFile.RotationDivisor, 0);
buildings[i].Matrix = Matrix4x4.TRS(buildings[i].Position, Quaternion.Euler(buildings[i].Rotation), Vector3.one);
// First model of record is building model
if (subRecord.Exterior.Block3dObjectRecords.Length > 0)
{
buildings[i].ModelID = subRecord.Exterior.Block3dObjectRecords[0].ModelIdNum;
}
}
return(buildings);
}
public static int GetHousePrice(BuildingSummary house)
{
// Get model data and radius which defines price
ModelData modelData;
DaggerfallUnity.Instance.MeshReader.GetModelData(house.ModelID, out modelData);
float houseRadius = modelData.DFMesh.Radius;
return((int)(houseRadius * housePriceMult));
}
/// <summary>
/// Gets building summary.
/// </summary>
/// <param name="key">Building key.</param>
/// <param name="buildingSummaryOut">Building summary out.</param>
/// <returns>True if lookup successful.</returns>
public bool GetBuildingSummary(int key, out BuildingSummary buildingSummaryOut)
{
if (!buildingDict.ContainsKey(key))
{
buildingSummaryOut = new BuildingSummary();
return(false);
}
buildingSummaryOut = buildingDict[key];
return(true);
}
public static void AllocateHouseToPlayer(BuildingSummary house, int regionIndex)
{
// Set player owned house for this region
DFLocation location = GameManager.Instance.PlayerGPS.CurrentLocation;
int mapID = location.MapTableData.MapId;
houses[regionIndex].location = location.Name;
houses[regionIndex].mapID = mapID;
houses[regionIndex].buildingKey = house.buildingKey;
// Ensure building is discovered
GameManager.Instance.PlayerGPS.DiscoverBuilding(house.buildingKey);
// Add interior scene to permanent list
SaveLoadManager.StateManager.AddPermanentScene(DaggerfallInterior.GetSceneName(mapID, house.buildingKey));
}
public static int GetHousePrice(BuildingSummary house)
{
// Get model data and radius which defines price
ModelData modelData;
DaggerfallUnity.Instance.MeshReader.GetModelData(house.ModelID, out modelData);
PlayerEntity player = GameManager.Instance.PlayerEntity;
float playerPers = ((player.Stats.LivePersonality - 50) * .001f) * -1;
float playerWill = ((player.Stats.LiveWillpower - 50) * .0005f) * -1; // 9% difference positive or negative total.
float playerLuck = ((player.Stats.LiveLuck - 50) * .0003f) * -1;
float mercantileValue = (player.Skills.GetLiveSkillValue(DFCareer.Skills.Mercantile) * .0012f) * -1;
float etiquetteValue = (player.Skills.GetLiveSkillValue(DFCareer.Skills.Etiquette) * .0002f) * -1; // 16% difference positive or negative total.
float streetwiseValue = (player.Skills.GetLiveSkillValue(DFCareer.Skills.Streetwise) * .0002f) * -1;
float playerPriceMod = playerPers + playerWill + playerLuck + mercantileValue + etiquetteValue + streetwiseValue + 1; // Overall Maximum increase or decrease is 25% for house price.
float houseRadius = modelData.DFMesh.Radius; // So first change I may as well make is having player stats and skills have some effect on the price of purchasing and selling property, not a huge effect, but something to simulate haggling or negotiation of some sort, possibly for boats as well. Thinking Personality, Luck, Mercantile, and maybe some Etiquete and Streetwise.
return((int)Mathf.Round((houseRadius * housePriceMult) * playerPriceMod));
}
public static void AllocateHouseToPlayer(BuildingSummary house, int regionIndex)
{
// Set player owned house for this region
DFLocation location = GameManager.Instance.PlayerGPS.CurrentLocation;
int mapID = location.MapTableData.MapId;
houses[regionIndex].location = location.Name;
houses[regionIndex].mapID = mapID;
houses[regionIndex].buildingKey = house.buildingKey;
// Ensure building is discovered
GameManager.Instance.PlayerGPS.DiscoverBuilding(house.buildingKey);
// Add interior scene to permanent list
SaveLoadManager.StateManager.AddPermanentScene(DaggerfallInterior.GetSceneName(mapID, house.buildingKey));
// Add note to journal
GameManager.Instance.PlayerEntity.Notebook.AddNote(
TextManager.Instance.GetText("DaggerfallUI", "houseDeed").Replace("%town", location.Name).Replace("%region", MapsFile.RegionNames[regionIndex]));
}
private void Display3dModelSelection(int selectedIdx)
{
if (goModel)
{
Object.Destroy(goModel);
goModel = null;
}
// Position camera and set model id
uint modelId = 0;
if (housesForSale == null)
{
camera.transform.position = new Vector3(0, 12, DaggerfallBankManager.GetShipCameraDist((ShipType)selectedIdx));
modelId = DaggerfallBankManager.GetShipModelId((ShipType)selectedIdx);
}
else
{
camera.transform.position = new Vector3(0, 3, -20);
BuildingSummary house = housesForSale[selectedIdx];
modelId = house.ModelID;
}
// Inject custom GameObject if available else create standard mesh game object for the model
goModel = MeshReplacement.ImportCustomGameobject(modelId, goBankPurchase.transform, new Matrix4x4());
if (goModel == null)
{
goModel = GameObjectHelper.CreateDaggerfallMeshGameObject(modelId, goBankPurchase.transform);
}
goModel.layer = layer;
// Apply current climate
ClimateBases climateBase = ClimateSwaps.FromAPIClimateBase(GameManager.Instance.PlayerGPS.ClimateSettings.ClimateType);
ClimateSeason season = (DaggerfallUnity.WorldTime.Now.SeasonValue == DaggerfallDateTime.Seasons.Winter) ? ClimateSeason.Winter : ClimateSeason.Summer;
DaggerfallMesh dfMesh = goModel.GetComponent <DaggerfallMesh>();
dfMesh.SetClimate(climateBase, season, WindowStyle.Day);
}
// Check if non-house building is unlocked and enterable
private bool BuildingIsUnlocked(BuildingSummary buildingSummary)
{
bool unlocked = false;
DFLocation.BuildingTypes type = buildingSummary.BuildingType;
// TODO: Guild structures can become unlocked 24hr depending on player rank
// Handle House1 through House4
// TODO: Figure out the rest of house door calculations.
if (type >= DFLocation.BuildingTypes.House1 && type <= DFLocation.BuildingTypes.House4 &&
DaggerfallUnity.Instance.WorldTime.Now.IsDay)
{
unlocked = true;
}
// Handle other structures (stores, temples, taverns, palaces)
else if (type <= DFLocation.BuildingTypes.Palace)
{
unlocked = (openHours[(int)type] <= DaggerfallUnity.Instance.WorldTime.Now.Hour &&
closeHours[(int)type] > DaggerfallUnity.Instance.WorldTime.Now.Hour);
}
return(unlocked);
}
public static TransactionResult PurchaseHouse(BuildingSummary house, int regionIndex)
{
if (house.buildingKey < 1)
{
return(TransactionResult.NONE);
}
int amount = GetHousePrice(house);
PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
var playerGold = playerEntity.GetGoldAmount();
var accountGold = BankAccounts[regionIndex].accountGold;
if (amount > playerGold + accountGold)
{
return(TransactionResult.NOT_ENOUGH_GOLD);
}
amount = playerEntity.DeductGoldAmount(amount);
bankAccounts[regionIndex].accountGold -= amount;
AllocateHouseToPlayer(house, regionIndex);
return(TransactionResult.PURCHASED_HOUSE);
}
public static TransactionResult PurchaseHouse(BuildingSummary house, int regionIndex)
{
if (house.buildingKey < 1)
{
return(TransactionResult.NONE);
}
int amount = GetHousePrice(house);
PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
var playerGold = playerEntity.GetGoldAmount();
var accountGold = BankAccounts[regionIndex].accountGold;
if (amount > playerGold + accountGold)
{
return(TransactionResult.NOT_ENOUGH_GOLD);
}
amount = playerEntity.DeductGoldAmount(amount);
bankAccounts[regionIndex].accountGold -= amount;
// Set player owned house for this region
DFLocation location = GameManager.Instance.PlayerGPS.CurrentLocation;
int mapID = location.MapTableData.MapId;
houses[regionIndex].location = location.Name;
houses[regionIndex].mapID = mapID;
houses[regionIndex].buildingKey = house.buildingKey;
// Ensure building is discovered
GameManager.Instance.PlayerGPS.DiscoverBuilding(house.buildingKey);
// Add interior scene to permanent list
SaveLoadManager.StateManager.AddPermanentScene(DaggerfallInterior.GetSceneName(mapID, house.buildingKey));
return(TransactionResult.PURCHASED_HOUSE);
}
public static int GetHouseSellPrice(BuildingSummary house)
{
return((int)(GetHousePrice(house) * deedSellMult));
}
public void GeneratePurchaseHousePopup(BuildingSummary house)
{
GeneratePopup(DaggerfallBankManager.PurchaseHouse(house, regionIndex));
}
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;
}
