/// <summary>
/// Get LiveSpeed adjusted for swimming, walking, crouching or riding
/// </summary>
/// <returns>Speed based on player.Stats.LiveSpeed</returns>
public float GetBaseSpeed()
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseSpeed = 0;
float playerSpeed = player.Stats.LiveSpeed;
if (playerMotor == null) // fixes null reference bug.
{
playerMotor = GameManager.Instance.PlayerMotor;
}
// crouching speed penalty doesn't apply if swimming.
if (playerMotor.IsCrouching && !levitateMotor.IsSwimming)
{
baseSpeed = (playerSpeed + dfCrouchBase) / classicToUnitySpeedUnitRatio;
}
else if (playerMotor.IsRiding)
{
baseSpeed = (playerSpeed + dfRideBase) / classicToUnitySpeedUnitRatio;
}
else
{
baseSpeed = GetWalkSpeed(player);
}
return(baseSpeed);
}
void Move(Vector3 direction, bool upOrDown = false)
{
if (playerSwimming)
{
// Do not allow player to swim up out of water, as he would immediately be pulled back in, making jerky movement and playing the splash sound repeatedly
if ((direction.y > 0) && (playerMotor.controller.transform.position.y + (50 * MeshReader.GlobalScale) - 0.93f) >=
(GameManager.Instance.PlayerEnterExit.blockWaterLevel * -1 * MeshReader.GlobalScale))
{
direction.y = 0;
}
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseSpeed = playerMotor.GetBaseSpeed();
moveSpeed = playerMotor.GetSwimSpeed(baseSpeed);
}
// There's a fixed speed for up/down movement
if (upOrDown)
{
moveSpeed = 80f / PlayerMotor.classicToUnitySpeedUnitRatio;
}
collisionFlags = playerMotor.controller.Move(direction * moveSpeed * Time.deltaTime);
// Reset to levitate speed in case it has been changed by swimming
moveSpeed = 4.0f;
}
private void ClimbMovement()
{
controller.Move(Vector3.up * Time.deltaTime);
if (climbingContinueTimer <= (playerMotor.systemTimerUpdatesPerSecond * 15))
{
climbingContinueTimer += Time.deltaTime;
}
else
{
climbingContinueTimer = 0;
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
player.TallySkill(DFCareer.Skills.Climbing, 1);
int skill = player.Skills.GetLiveSkillValue(DFCareer.Skills.Climbing);
if (player.Race == Entity.Races.Khajiit)
{
skill += 30;
}
Mathf.Clamp(skill, 5, 95);
if ((UnityEngine.Random.Range(1, 101) > 90) ||
(UnityEngine.Random.Range(1, 101) > skill))
{
isClimbing = false;
}
}
}
/// <summary>
/// Get LiveSpeed adjusted for running
/// </summary>
/// <param name="baseSpeed"></param>
/// <returns></returns>
public float GetRunSpeed()
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseRunSpeed = (player.Stats.LiveSpeed + dfWalkBase) / classicToUnitySpeedUnitRatio;
return(baseRunSpeed * (1.35f + (player.Skills.GetLiveSkillValue(DFCareer.Skills.Running) / 200f)));
}
/// <summary>
/// Get LiveSpeed adjusted for swimming, walking, crouching or riding
/// </summary>
/// <returns>Speed based on player.Stats.LiveSpeed</returns>
public float GetBaseSpeed()
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseSpeed = 0;
float playerSpeed = player.Stats.LiveSpeed;
if (playerMotor == null) // fixes null reference bug.
{
playerMotor = GameManager.Instance.PlayerMotor;
}
// crouching speed penalty doesn't apply if swimming.
if (playerMotor.IsCrouching && !levitateMotor.IsSwimming)
{
baseSpeed = (playerSpeed + dfCrouchBase) * GameManager.Instance.PlayerEntity.EquipmentEncumbranceSpeedMod / classicToUnitySpeedUnitRatio;
}
else if (playerMotor.IsRiding)
{
float rideSpeed = (GameManager.Instance.TransportManager.TransportMode == TransportModes.Cart) ? dfCartBase : dfRideBase;
baseSpeed = (playerSpeed + rideSpeed) / classicToUnitySpeedUnitRatio;
}
else
{
baseSpeed = GetWalkSpeed(player);
}
return(baseSpeed);
}
/// <summary>
/// Get LiveSpeed adjusted for swimming
/// </summary>
/// <param name="baseSpeed"></param>
/// <returns></returns>
public float GetSwimSpeed(float baseSpeed)
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float swimSpeed = (baseSpeed * (player.Skills.GetLiveSkillValue(DFCareer.Skills.Swimming) / 200f)) + (baseSpeed / 4);
return(swimSpeed);
}
void AddMovement(Vector3 direction, bool upOrDown = false)
{
if (playerSwimming && GameManager.Instance.PlayerEntity.IsWaterWalking)
{
// Swimming with water walking on makes player move at normal speed in water
moveSpeed = GameManager.Instance.PlayerMotor.Speed;
moveDirection += direction * moveSpeed;
return;
}
else if (playerSwimming)
{
// Do not allow player to swim up out of water, as he would immediately be pulled back in, making jerky movement and playing the splash sound repeatedly
if ((direction.y > 0) && (playerMotor.controller.transform.position.y + (50 * MeshReader.GlobalScale) - 0.93f) >=
(GameManager.Instance.PlayerEnterExit.blockWaterLevel * -1 * MeshReader.GlobalScale) &&
!playerLevitating)
{
direction.y = 0;
}
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseSpeed = speedChanger.GetBaseSpeed();
moveSpeed = speedChanger.GetSwimSpeed(baseSpeed);
}
// There's a fixed speed for up/down movement
if (upOrDown)
{
moveSpeed = 80f / PlayerSpeedChanger.classicToUnitySpeedUnitRatio;
}
moveDirection += direction * moveSpeed;
// Reset to levitate speed in case it has been changed by swimming
moveSpeed = levitateMoveSpeed;
}
public float GetClimbingSpeed(float baseSpeed)
{
// Climbing effect states "target can climb twice as well" - doubling climbing speed
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float climbingBoost = player.IsEnhancedClimbing ? 2f : 1f;
return((baseSpeed / 3) * climbingBoost);
}
void Start()
{
player = GameManager.Instance.PlayerEntity;
playerMotor = GetComponent <PlayerMotor>();
levitateMotor = GetComponent <LevitateMotor>();
controller = GetComponent <CharacterController>();
playerEnterExit = GetComponent <PlayerEnterExit>();
acrobatMotor = GetComponent <AcrobatMotor>();
}
/// <summary>
/// Get LiveSpeed adjusted for running
/// </summary>
/// <param name="baseSpeed"></param>
/// <returns></returns>
public float GetRunSpeed(float baseSpeed)
{
if (useRunSpeedOverride)
{
return(runSpeedOverride);
}
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
return(baseSpeed * (1.25f + (player.Skills.GetLiveSkillValue(DFCareer.Skills.Running) / 200f)));
}
/// <summary>
/// Assigns basic starting gear to a new character.
/// </summary>
public void AssignStartingGear(PlayerEntity playerEntity)
{
// Get references
ItemCollection items = playerEntity.Items;
ItemEquipTable equipTable = playerEntity.ItemEquipTable;
// Starting clothes are gender-specific
DaggerfallUnityItem shortShirt = null;
DaggerfallUnityItem casualPants = null;
if (playerEntity.Gender == Genders.Female)
{
shortShirt = ItemBuilder.CreateWomensClothing(WomensClothing.Short_shirt_closed, playerEntity.Race, 1);
casualPants = ItemBuilder.CreateWomensClothing(WomensClothing.Casual_pants, playerEntity.Race);
}
else
{
shortShirt = ItemBuilder.CreateMensClothing(MensClothing.Short_shirt_closed_top, playerEntity.Race, 1);
casualPants = ItemBuilder.CreateMensClothing(MensClothing.Casual_pants, playerEntity.Race);
}
// Randomise shirt dye and pants variant
shortShirt.dyeColor = ItemBuilder.RandomClothingDye();
ItemBuilder.RandomizeVariant(casualPants);
// Add a wagon
// This is required for now as shops not currently implemented
// Wagon is easy to obtain anyway (150g) and most player can affored right out of Privateer's Hold
// TODO: Remove this once shops can sell this item to players as normal
items.AddItem(ItemBuilder.CreateItem(ItemGroups.Transportation, (int)Transportation.Small_cart));
// Add spellbook, all players start with one
items.AddItem(ItemBuilder.CreateItem(ItemGroups.MiscItems, (int)MiscItems.Spellbook));
// Add and equip clothing
items.AddItem(shortShirt);
items.AddItem(casualPants);
equipTable.EquipItem(shortShirt);
equipTable.EquipItem(casualPants);
// Always add ebony dagger until biography implemented
items.AddItem(ItemBuilder.CreateWeapon(Weapons.Dagger, WeaponMaterialTypes.Ebony));
// Add a cuirass
items.AddItem(ItemBuilder.CreateArmor(playerEntity.Gender, playerEntity.Race, Armor.Cuirass, ArmorMaterialTypes.Leather));
// Add alternate weapons
items.AddItem(ItemBuilder.CreateWeapon(Weapons.Longsword, WeaponMaterialTypes.Steel));
items.AddItem(ItemBuilder.CreateWeapon(Weapons.Katana, WeaponMaterialTypes.Iron));
items.AddItem(ItemBuilder.CreateWeapon(Weapons.Staff, WeaponMaterialTypes.Silver));
// Add some ingredients
for (int i = 0; i < 10; i++)
{
items.AddItem(ItemBuilder.CreateRandomIngredient());
}
}
/// <summary>
/// Get LiveSpeed adjusted for walking
/// </summary>
/// <param name="player">the PlayerEntity to use</param>
/// <returns></returns>
public float GetWalkSpeed(Entity.PlayerEntity player)
{
if (useWalkSpeedOverride)
{
return(walkSpeedOverride);
}
else
{
return((player.Stats.LiveSpeed + dfWalkBase) * GameManager.Instance.PlayerEntity.EquipmentEncumbranceSpeedMod / classicToUnitySpeedUnitRatio);
}
}
/// <summary>
/// Get LiveSpeed adjusted for walking
/// </summary>
/// <param name="player">the PlayerEntity to use</param>
/// <returns></returns>
public float GetWalkSpeed(Entity.PlayerEntity player)
{
if (useWalkSpeedOverride)
{
return(walkSpeedOverride);
}
else
{
return((player.Stats.LiveSpeed + dfWalkBase) / classicToUnitySpeedUnitRatio);
}
}
public float GetRunSpeed(float baseSpeed)
{
if (useRunSpeedOverride)
{
return(runSpeedOverride);
}
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float runSpeed = baseSpeed * (1.25f + (player.Skills.Running / 200f));
return(runSpeed);
}
/// <summary>
/// Get LiveSpeed adjusted for walking
/// </summary>
/// <param name="player">the PlayerEntity to use</param>
/// <returns></returns>
public float GetWalkSpeed(Entity.PlayerEntity player)
{
if (useWalkSpeedOverride)
{
return(walkSpeedOverride);
}
else
{
float drag = 0.5f * (100 - (player.Stats.LiveSpeed >= 30 ? player.Stats.LiveSpeed : 30));
return((player.Stats.LiveSpeed + dfWalkBase - drag) / classicToUnitySpeedUnitRatio);
}
}
private void Start()
{
player = GameManager.Instance.PlayerEntity;
acrobatMotor = GetComponent <AcrobatMotor>();
controller = GetComponent <CharacterController>();
speedChanger = GetComponent <PlayerSpeedChanger>();
groundMotor = GetComponent <PlayerGroundMotor>();
climbingMotor = GetComponent <ClimbingMotor>();
playerScanner = GetComponent <PlayerMoveScanner>();
hangingMotor = GetComponent <HangingMotor>();
}
void Start()
{
player = GameManager.Instance.PlayerEntity;
playerMotor = GetComponent <PlayerMotor>();
groundMotor = GetComponent <PlayerGroundMotor>();
levitateMotor = GetComponent <LevitateMotor>();
controller = GetComponent <CharacterController>();
playerEnterExit = GetComponent <PlayerEnterExit>();
acrobatMotor = GetComponent <AcrobatMotor>();
speedChanger = GetComponent <PlayerSpeedChanger>();
stepDetector = GetComponent <PlayerStepDetector>();
}
/// <summary>
/// Get LiveSpeed adjusted for swimming, walking, crouching or riding
/// </summary>
/// <returns>Speed based on player.Stats.LiveSpeed</returns>
public float GetBaseSpeed()
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseSpeed = 0;
float playerSpeed = player.Stats.LiveSpeed;
if (playerMotor == null) // fixes null reference bug.
{
playerMotor = GameManager.Instance.PlayerMotor;
}
// crouching speed penalty doesn't apply if swimming.
if (playerMotor.IsCrouching && !levitateMotor.IsSwimming)
{
baseSpeed = (playerSpeed + dfCrouchBase) / classicToUnitySpeedUnitRatio;
}
else if (playerMotor.IsRiding)
{
float rideSpeed = (GameManager.Instance.TransportManager.TransportMode == TransportModes.Cart) ? dfCartBase : dfRideBase;
baseSpeed = (playerSpeed + rideSpeed) / classicToUnitySpeedUnitRatio;
}
else
{
baseSpeed = GetWalkSpeed(player);
}
//COMBAT OVERHAUL\\
//Adds if then trigger for unsheathed mode and attack mode. Lowers player movement speed by multiplying end base spend by
//a set float value.default if .4 and .75f;
float Aspeedmodifider = FPSConsoleCommands.ChangeMovementMods.EAttackModifier;
float Sspeedmodifider = FPSConsoleCommands.ChangeMovementMods.ESheathedModifier;
if (Aspeedmodifider == 0)
{
Aspeedmodifider = .4f;
}
if (Sspeedmodifider == 0)
{
Sspeedmodifider = .85f;
}
if (GameManager.Instance.WeaponManager.Sheathed == false && GameManager.Instance.WeaponManager.IsAttacking == false)
{
baseSpeed = baseSpeed * Sspeedmodifider;
}
else if (GameManager.Instance.WeaponManager.IsAttacking == true)
{
baseSpeed = baseSpeed * Aspeedmodifider;
}
return(baseSpeed);
}
/// <summary>
/// Get LiveSpeed adjusted for running
/// </summary>
/// <param name="baseSpeed"></param>
/// <returns></returns>
public float GetRunSpeed(float baseSpeed)
{
if (useRunSpeedOverride)
{
return(runSpeedOverride);
}
else
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseRunSpeed = playerMotor.IsRiding ? baseSpeed : (player.Stats.LiveSpeed + dfWalkBase) / classicToUnitySpeedUnitRatio;
return(baseRunSpeed * (1.35f + (player.Skills.GetLiveSkillValue(DFCareer.Skills.Running) / 200f)));
}
}
private void EntityBehaviour_OnSetEntity(DaggerfallEntity oldEntity, DaggerfallEntity newEntity)
{
if (oldEntity != null)
{
oldEntity.OnDeath -= PlayerEntity_OnDeath;
}
if (newEntity != null)
{
playerEntity = newEntity as PlayerEntity;
playerEntity.OnDeath += PlayerEntity_OnDeath;
}
}
// Capture this message so we can play pain voice
public void RemoveHealth(int amount)
{
if (dfAudioSource && DaggerfallUnity.Settings.CombatVoices && Random.Range(1, 101) <= 40)
{
Entity.PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
bool heavyDamage = amount >= playerEntity.MaxHealth / 4;
SoundClips sound = Entity.DaggerfallEntity.GetRaceGenderPainSound(playerEntity.Race, playerEntity.Gender, heavyDamage);
float pitch = dfAudioSource.AudioSource.pitch;
dfAudioSource.AudioSource.pitch = pitch + Random.Range(0, 0.3f);
dfAudioSource.PlayOneShot((int)sound, 0, 1f);
dfAudioSource.AudioSource.pitch = pitch;
}
}
void Start()
{
player = GameManager.Instance.PlayerEntity;
playerMotor = GetComponent <PlayerMotor>();
//groundMotor = GetComponent<PlayerGroundMotor>();
levitateMotor = GetComponent <LevitateMotor>();
controller = GetComponent <CharacterController>();
playerEnterExit = GetComponent <PlayerEnterExit>();
acrobatMotor = GetComponent <AcrobatMotor>();
speedChanger = GetComponent <PlayerSpeedChanger>();
rappelMotor = GetComponent <RappelMotor>();
//hangingMotor = GetComponent<HangingMotor>();
moveScanner = GetComponent <PlayerMoveScanner>();
}
private void Start()
{
player = GameManager.Instance.PlayerEntity;
playerMotor = GetComponent <PlayerMotor>();
acrobatMotor = GetComponent <AcrobatMotor>();
levitateMotor = GetComponent <LevitateMotor>();
controller = GetComponent <CharacterController>();
speedChanger = GetComponent <PlayerSpeedChanger>();
groundMotor = GetComponent <PlayerGroundMotor>();
rappelMotor = GetComponent <RappelMotor>();
climbingMotor = GetComponent <ClimbingMotor>();
scanner = GetComponent <PlayerMoveScanner>();
camTransform = GameManager.Instance.MainCamera.transform;
}
private void Start()
{
player = GameManager.Instance.PlayerEntity;
acrobatMotor = GetComponent <AcrobatMotor>();
controller = GetComponent <CharacterController>();
speedChanger = GetComponent <PlayerSpeedChanger>();
groundMotor = GetComponent <PlayerGroundMotor>();
climbingMotor = GetComponent <ClimbingMotor>();
playerScanner = GetComponent <PlayerMoveScanner>();
//hangingMotor = GetComponent<HangingMotor>();
// Prevent save while rappeling, erializing that case is not worth the trouble
GameManager.Instance.SaveLoadManager.RegisterPreventSaveCondition(() => rappelStage != RappelStage.Inactive);
}
public void StockMerchantMagicItems(PlayerGPS.DiscoveredBuilding buildingData, bool onlySoulGems = false)
{
stockedDate = CreateStockedDate(DaggerfallUnity.Instance.WorldTime.Now);
items.Clear();
int buildingQuality = buildingData.quality;
Game.Entity.PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
int playerLuck = playerEntity.Stats.LiveLuck;
int numOfItems = (buildingData.quality / 2) + 1;
if (!onlySoulGems)
{
for (int i = 0; i <= numOfItems; i++)
{
// Create magic item which is already identified
DaggerfallUnityItem magicItem = ItemBuilder.CreateRandomMagicItem(playerEntity.Gender, playerEntity.Race, -1, buildingQuality, playerLuck);
magicItem.IdentifyItem();
items.AddItem(magicItem);
}
items.AddItem(ItemBuilder.CreateItem(ItemGroups.MiscItems, (int)MiscItems.Spellbook));
}
if (onlySoulGems)
{
numOfItems *= 2;
}
for (int i = 0; i <= numOfItems; i++)
{
DaggerfallUnityItem magicItem;
if (Dice100.FailedRoll(25))
{
// Empty soul trap
magicItem = ItemBuilder.CreateItem(ItemGroups.MiscItems, (int)MiscItems.Soul_trap);
magicItem.value = 5000;
magicItem.TrappedSoulType = MobileTypes.None;
}
else
{
// Filled soul trap
magicItem = ItemBuilder.CreateRandomlyFilledSoulTrap();
}
items.AddItem(magicItem);
}
}
public void StockMerchantGuildPotions(PlayerGPS.DiscoveredBuilding buildingData) // I'll want to work on this more at some point, but for now it works well enough for testing at least.
{
stockedDate = CreateStockedDate(DaggerfallUnity.Instance.WorldTime.Now);
items.Clear();
int buildingQuality = buildingData.quality;
Game.Entity.PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
int playerLuck = playerEntity.Stats.LiveLuck;
int n = buildingQuality * 3;
while (n-- >= 0)
{
items.AddItem(ItemBuilder.CreateRandomPotion(UnityEngine.Random.Range(1, 3)));
}
}
// Capture this message so we can play pain voice
public void RemoveHealth(int amount)
{
// Racial override can suppress optional attack voice
RacialOverrideEffect racialOverride = GameManager.Instance.PlayerEffectManager.GetRacialOverrideEffect();
bool suppressCombatVoices = racialOverride != null && racialOverride.SuppressOptionalCombatVoices;
if (dfAudioSource && DaggerfallUnity.Settings.CombatVoices && !suppressCombatVoices && Dice100.SuccessRoll(40))
{
Entity.PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
bool heavyDamage = amount >= playerEntity.MaxHealth / 4;
SoundClips sound = Entity.DaggerfallEntity.GetRaceGenderPainSound(playerEntity.Race, playerEntity.Gender, heavyDamage);
float pitch = dfAudioSource.AudioSource.pitch;
dfAudioSource.AudioSource.pitch = pitch + Random.Range(0, 0.3f);
dfAudioSource.PlayOneShot((int)sound, 0, 1f);
dfAudioSource.AudioSource.pitch = pitch;
}
}
public float GetBaseSpeed()
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float baseSpeed = 0;
float playerSpeed = player.Stats.LiveSpeed;
if (isCrouching)
{
baseSpeed = (playerSpeed + dfCrouchBase) / classicToUnitySpeedUnitRatio;
}
else if (riding)
{
baseSpeed = (playerSpeed + dfRideBase) / classicToUnitySpeedUnitRatio;
}
else
{
baseSpeed = GetWalkSpeed(player);
}
return(baseSpeed);
}
public bool StealthCheck()
{
if (distanceToPlayer > 1024 * MeshReader.GlobalScale)
{
return(false);
}
uint gameMinutes = DaggerfallUnity.Instance.WorldTime.DaggerfallDateTime.ToClassicDaggerfallTime();
if (gameMinutes == timeOfLastStealthCheck)
{
return(detectedPlayer);
}
PlayerMotor playerMotor = GameManager.Instance.PlayerMotor;
if (playerMotor.IsMovingLessThanHalfSpeed)
{
if ((gameMinutes & 1) == 1)
{
return(detectedPlayer);
}
}
else if (hasEncounteredPlayer)
{
return(true);
}
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
if (player.TimeOfLastStealthCheck != gameMinutes)
{
player.TallySkill(DaggerfallConnect.DFCareer.Skills.Stealth, 1);
player.TimeOfLastStealthCheck = gameMinutes;
}
timeOfLastStealthCheck = gameMinutes;
int stealthRoll = 2 * ((int)(distanceToPlayer / MeshReader.GlobalScale) * player.Skills.GetLiveSkillValue(DaggerfallConnect.DFCareer.Skills.Stealth) >> 10);
return(Random.Range(1, 101) > stealthRoll);
}
/// <summary>
/// Redraws paper doll image and selection mask.
/// Call this after changing equipment, loading a new game, etc.
/// Only call when required as constructing paper doll image is expensive.
/// </summary>
/// <param name="playerEntity"></param>
public void Refresh(PlayerEntity playerEntity = null)
{
// Get current player entity if one not provided
if (playerEntity == null)
playerEntity = GameManager.Instance.PlayerEntity;
// Update paper doll
ClearPaperDoll();
RefreshBackground(playerEntity);
BlitCloakInterior(playerEntity);
BlitBody(playerEntity);
BlitItems(playerEntity);
// Destroy old paper doll texture
characterPanel.BackgroundTexture = null;
GameObject.Destroy(paperDollTexture);
paperDollTexture = null;
// Update paper doll texture
paperDollTexture = ImageReader.GetTexture(paperDollColors, paperDollWidth, paperDollHeight);
characterPanel.BackgroundTexture = paperDollTexture;
//// Create image from selection mask
//DFPalette palette = new DFPalette();
//byte value = 20;
//for (int i = 0; i < 256; i++)
//{
// palette.Set(i, value, value, value);
// value += 8;
//}
//DFBitmap bitmap = new DFBitmap(paperDollWidth, paperDollHeight);
//bitmap.Palette = palette;
//bitmap.Data = (byte[])paperDollIndices.Clone();
//Color32[] testColors = bitmap.GetColor32(255);
//string path = @"d:\test\blits\selection.png";
//Texture2D texture = ImageProcessing.MakeTexture2D(ref testColors, paperDollWidth, paperDollHeight, TextureFormat.RGBA32, false);
//ImageProcessing.SaveTextureAsPng(texture, path);
}
public override void OnPush()
{
base.OnPush();
// Reset counters
hoursRemaining = 0;
totalHours = 0;
waitTimer = 0;
// Get references
playerEntity = GameManager.Instance.PlayerEntity;
hud = DaggerfallUI.Instance.DaggerfallHUD;
}
/// <summary>
/// Generates an array of items based on loot chance matrix.
/// </summary>
/// <param name="key">Starting loot table key. Used for special handling.</param>
/// <param name="matrix">Loot chance matrix.</param>
/// <param name="playerLevel">Level of player.</param>
/// <returns>DaggerfallUnityItem array.</returns>
public static DaggerfallUnityItem[] GenerateRandomLoot(string key, LootChanceMatrix matrix, PlayerEntity playerEntity)
{
float chance;
List<DaggerfallUnityItem> items = new List<DaggerfallUnityItem>();
// Random gold
int goldCount = Random.Range(matrix.MinGold, matrix.MaxGold) * playerEntity.Level;
if (goldCount > 0)
{
items.Add(ItemBuilder.CreateGoldPieces(goldCount));
}
// Random weapon
chance = matrix.WP * playerEntity.Level;
while (Random.Range(1, 100) < chance)
{
items.Add(ItemBuilder.CreateRandomWeapon(playerEntity.Level));
chance *= 0.5f;
}
// Random armor
chance = matrix.AM * playerEntity.Level;
while (Random.Range(1, 100) < chance)
{
items.Add(ItemBuilder.CreateRandomArmor(playerEntity.Level, playerEntity.Gender, playerEntity.Race));
chance *= 0.5f;
}
// Random ingredients
RandomIngredient(matrix.C1 * playerEntity.Level, ItemGroups.CreatureIngredients1, items);
RandomIngredient(matrix.C2 * playerEntity.Level, ItemGroups.CreatureIngredients2, items);
RandomIngredient(matrix.C3 * playerEntity.Level, ItemGroups.CreatureIngredients3, items);
RandomIngredient(matrix.P1 * playerEntity.Level, ItemGroups.PlantIngredients1, items);
RandomIngredient(matrix.P2 * playerEntity.Level, ItemGroups.PlantIngredients2, items);
RandomIngredient(matrix.M1 * playerEntity.Level, ItemGroups.MiscellaneousIngredients1, items);
RandomIngredient(matrix.M2 * playerEntity.Level, ItemGroups.MiscellaneousIngredients2, items);
// TEMP: Magic item chance is just another shot at armor or weapon for now
chance = matrix.MI * playerEntity.Level;
while (Random.Range(1, 100) < chance)
{
if (Random.value < 0.5f)
items.Add(ItemBuilder.CreateRandomWeapon(playerEntity.Level));
else
items.Add(ItemBuilder.CreateRandomArmor(playerEntity.Level, playerEntity.Gender, playerEntity.Race));
chance *= 0.5f;
}
// Random clothes
chance = matrix.CL * playerEntity.Level;
while (Random.Range(1, 100) < chance)
{
items.Add(ItemBuilder.CreateRandomClothing(playerEntity.Gender));
chance *= 0.5f;
}
// Random religious item
chance = matrix.RL * playerEntity.Level;
while (Random.Range(1, 100) < chance)
{
items.Add(ItemBuilder.CreateRandomReligiousItem());
chance *= 0.5f;
}
// Special humanoid handling
// Daggerfall seems to always drop between 1-3 weapons and 2-5 armor pieces regardless of player level
// This is probably totally off track, but for now generating closer results than loot table alone
// TODO: Revisit humanoid loot tables later
if (key == "HM")
{
// Create 1-3 weapons
int count = Random.Range(1, 3);
for (int i = 0; i < count; i++)
{
items.Add(ItemBuilder.CreateRandomWeapon(playerEntity.Level));
}
// Create 2-5 armor pieces
count = Random.Range(2, 5);
for (int i = 0; i < count; i++)
{
items.Add(ItemBuilder.CreateRandomArmor(playerEntity.Level, playerEntity.Gender, playerEntity.Race));
}
}
return items.ToArray();
}
IEnumerator AnimateWeapon()
{
while (true)
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
float speed = 0;
float time = 0;
if (player != null)
{
if (WeaponType == WeaponTypes.Bow)
{
time = GameManager.classicUpdateInterval;
}
else
{
speed = 3 * (115 - player.Stats.LiveSpeed);
time = speed / 980; // Approximation of classic frame update
}
}
if (weaponAnims != null && ShowWeapon)
{
int frameBeforeStepping = currentFrame;
// Special animation for unarmed attack to left
if ((WeaponType == WeaponTypes.Melee || WeaponType == WeaponTypes.Werecreature) &&
WeaponState == WeaponStates.StrikeLeft)
{
// Step frame
currentFrame = leftUnarmedAnims[leftUnarmedAnimIndex];
leftUnarmedAnimIndex++;
if (leftUnarmedAnimIndex >= leftUnarmedAnims.Length)
{
ChangeWeaponState(WeaponStates.Idle);
leftUnarmedAnimIndex = 0;
}
}
else
{
// Step frame
currentFrame++;
if (currentFrame >= weaponAnims[(int)weaponState].NumFrames)
{
if (IsPlayingOneShot())
{
ChangeWeaponState(WeaponStates.Idle); // If this is a one-shot anim go to queued weapon state
if (WeaponType == WeaponTypes.Bow)
{
ShowWeapon = false; // Immediately hide bow so its idle frame doesn't show before it is hidden for its cooldown
}
}
else if (WeaponType == WeaponTypes.Bow)
{
currentFrame = 3;
}
else
{
currentFrame = 0; // Otherwise keep looping frames
}
}
}
// Only update if the frame actually changed
if (frameBeforeStepping != currentFrame)
{
UpdateWeapon();
}
}
yield return(new WaitForSeconds(time));
}
}
void Update()
{
// Automatically update weapons from inventory when PlayerEntity available
if (playerEntity != null)
UpdateHands();
else
playerEntity = GameManager.Instance.PlayerEntity;
// Toggle weapon sheath
if (InputManager.Instance.ActionStarted(InputManager.Actions.ReadyWeapon))
ToggleSheath();
// Toggle weapon hand
if (InputManager.Instance.ActionComplete(InputManager.Actions.SwitchHand))
ToggleHand();
// Do nothing if weapons sheathed
if (Sheathed)
{
ShowWeapons(false);
return;
}
// Reset tracking if user not holding down 'SwingWeapon' button and no attack in progress
//if (!Input.GetButton("Fire2") && !isAttacking)
if (!InputManager.Instance.HasAction(InputManager.Actions.SwingWeapon) && !isAttacking)
{
lastAction = MouseDirections.None;
actionCount = 0;
isAttacking = false;
ShowWeapons(true);
return;
}
// Handle attack in progress
if (IsLeftHandAttacking() || IsRightHandAttacking())
{
isAttacking = true;
return;
}
// If an attack was in progress it is now complete.
// Attempt to transfer damage based on last attack hand.
if (isAttacking)
{
// Complete attack
isAttacking = false;
// Transfer melee damage
if (lastAttackHand == 0)
MeleeDamage(LeftHandWeapon);
else if (lastAttackHand == 1)
MeleeDamage(RightHandWeapon);
}
// Restore weapon visibility
ShowWeapons(true);
// Track mouse attack and exit if no action registered
TrackMouseAttack();
if (lastAction == MouseDirections.None || actionCount < TriggerCount)
return;
// Time for attacks
ExecuteAttacks();
}
// Copy body parts to target
void BlitBody(PlayerEntity entity)
{
// Get gender-based body parts
ImageData nudeBody = new ImageData();
ImageData clothedBody = new ImageData();
ImageData head = new ImageData();
if (entity.Gender == Genders.Male)
{
nudeBody = ImageReader.GetImageData(entity.RaceTemplate.PaperDollBodyMaleUnclothed, 0, 0, true);
clothedBody = ImageReader.GetImageData(entity.RaceTemplate.PaperDollBodyMaleClothed, 0, 0, true);
head = ImageReader.GetImageData(entity.RaceTemplate.PaperDollHeadsMale, entity.FaceIndex, 0, true);
}
else if (entity.Gender == Genders.Female)
{
nudeBody = ImageReader.GetImageData(entity.RaceTemplate.PaperDollBodyFemaleUnclothed, 0, 0, true);
clothedBody = ImageReader.GetImageData(entity.RaceTemplate.PaperDollBodyFemaleClothed, 0, 0, true);
head = ImageReader.GetImageData(entity.RaceTemplate.PaperDollHeadsFemale, entity.FaceIndex, 0, true);
}
else
{
return;
}
// Draw standard body
BlitPaperDoll(nudeBody);
// Censor nudity if this setting enabled by using welded-on clothes.
// But only if censored part of body is actually unclothed.
// Otherwise welded-on clothes can be visible around equipped clothes.
// This involves a special blit to draw top and bottom halves independently.
if (!DaggerfallUnity.Settings.PlayerNudity)
{
if (!entity.ItemEquipTable.IsUpperClothed())
BlitUpperBody(clothedBody);
if (!entity.ItemEquipTable.IsLowerClothed())
BlitLowerBody(clothedBody);
}
// Blit head
BlitPaperDoll(head);
}
public static bool GetPlayer(out GameObject playerObject, out PlayerEntity playerEntity)
{
playerObject = GameManager.Instance.PlayerObject;
playerEntity = GameManager.Instance.PlayerEntity;
return (playerObject != null & playerEntity != null);
}
void BlitCloakInterior(PlayerEntity entity)
{
// Draw cloak2 interior - stops here if this cloak is drawn
DaggerfallUnityItem cloak2 = entity.ItemEquipTable.GetItem(EquipSlots.Cloak2);
if (cloak2 != null)
{
ImageData interior2 = DaggerfallUnity.Instance.ItemHelper.GetCloakInteriorImage(cloak2);
BlitPaperDoll(interior2, (byte)cloak2.EquipSlot);
return;
}
// Draw cloak1 interior
DaggerfallUnityItem cloak1 = entity.ItemEquipTable.GetItem(EquipSlots.Cloak1);
if (cloak1 != null)
{
ImageData interior1 = DaggerfallUnity.Instance.ItemHelper.GetCloakInteriorImage(cloak1);
BlitPaperDoll(interior1, (byte)cloak1.EquipSlot);
}
}
public void ClimbingCheck(ref CollisionFlags collisionFlags)
{
// Get pre-movement position for climbing check
lastHorizontalPosition = new Vector2(controller.transform.position.x, controller.transform.position.z);
if (isClimbing)
{
collisionFlags = CollisionFlags.Sides;
}
// Get collision flags for swimming as well, so it's possible to climb out of water TODO: Collision flags from swimming aren't working
else if (levitateMotor.IsSwimming)
{
collisionFlags = levitateMotor.CollisionFlags;
}
// Climbing
uint gameMinutes = DaggerfallUnity.Instance.WorldTime.DaggerfallDateTime.ToClassicDaggerfallTime();
if (!InputManager.Instance.HasAction(InputManager.Actions.MoveForwards) ||
(collisionFlags & CollisionFlags.Sides) == 0 ||
failedClimbingCheck ||
levitateMotor.IsLevitating ||
playerMotor.IsRiding ||
Vector2.Distance(lastHorizontalPosition, new Vector2(controller.transform.position.x, controller.transform.position.z)) >= (0.003f)) // Approximation based on observing classic in-game
{
isClimbing = false;
showClimbingModeMessage = true;
climbingStartTimer = 0;
timeOfLastClimbingCheck = gameMinutes;
}
else
{
if (climbingStartTimer <= (playerMotor.systemTimerUpdatesPerSecond * 14))
{
climbingStartTimer += Time.deltaTime;
}
else
{
if (!isClimbing)
{
if (showClimbingModeMessage)
{
DaggerfallUI.AddHUDText(UserInterfaceWindows.HardStrings.climbingMode);
}
// Disable further showing of climbing mode message until current climb attempt is stopped
// to keep it from filling message log
showClimbingModeMessage = false;
isClimbing = true;
}
// Initial check to start climbing
if ((gameMinutes - timeOfLastClimbingCheck) > 18)
{
Entity.PlayerEntity player = GameManager.Instance.PlayerEntity;
player.TallySkill(DFCareer.Skills.Climbing, 1);
timeOfLastClimbingCheck = gameMinutes;
if (UnityEngine.Random.Range(1, 101) > 95)
{
if (UnityEngine.Random.Range(1, 101) > player.Skills.GetLiveSkillValue(DFCareer.Skills.Climbing))
{
isClimbing = false;
failedClimbingCheck = true;
}
}
}
}
}
if (isClimbing)
{
ClimbMovement();
}
}
public void StockHouseContainer(PlayerGPS.DiscoveredBuilding buildingData)
{
stockedDate = CreateStockedDate(DaggerfallUnity.Instance.WorldTime.Now);
items.Clear();
DFLocation.BuildingTypes buildingType = buildingData.buildingType;
uint modelIndex = (uint)TextureRecord;
//int buildingQuality = buildingData.quality;
byte[] privatePropertyList = null;
DaggerfallUnityItem item = null;
Game.Entity.PlayerEntity playerEntity = GameManager.Instance.PlayerEntity;
if (buildingType < DFLocation.BuildingTypes.House5)
{
if (modelIndex >= 2)
{
if (modelIndex >= 4)
{
if (modelIndex >= 11)
{
if (modelIndex >= 15)
{
privatePropertyList = DaggerfallLootDataTables.privatePropertyItemsModels15AndUp[(int)buildingType];
}
else
{
privatePropertyList = DaggerfallLootDataTables.privatePropertyItemsModels11to14[(int)buildingType];
}
}
else
{
privatePropertyList = DaggerfallLootDataTables.privatePropertyItemsModels4to10[(int)buildingType];
}
}
else
{
privatePropertyList = DaggerfallLootDataTables.privatePropertyItemsModels2to3[(int)buildingType];
}
}
else
{
privatePropertyList = DaggerfallLootDataTables.privatePropertyItemsModels0to1[(int)buildingType];
}
if (privatePropertyList == null)
{
return;
}
int randomChoice = Random.Range(0, privatePropertyList.Length);
ItemGroups itemGroup = (ItemGroups)privatePropertyList[randomChoice];
int continueChance = 100;
bool keepGoing = true;
while (keepGoing)
{
if (itemGroup != ItemGroups.MensClothing && itemGroup != ItemGroups.WomensClothing)
{
if (itemGroup == ItemGroups.MagicItems)
{
item = ItemBuilder.CreateRandomMagicItem(playerEntity.Level, playerEntity.Gender, playerEntity.Race);
}
else if (itemGroup == ItemGroups.Books)
{
item = ItemBuilder.CreateRandomBook();
}
else
{
if (itemGroup == ItemGroups.Weapons)
{
item = ItemBuilder.CreateRandomWeapon(playerEntity.Level);
}
else if (itemGroup == ItemGroups.Armor)
{
item = ItemBuilder.CreateRandomArmor(playerEntity.Level, playerEntity.Gender, playerEntity.Race);
}
else
{
System.Array enumArray = DaggerfallUnity.Instance.ItemHelper.GetEnumArray(itemGroup);
item = new DaggerfallUnityItem(itemGroup, Random.Range(0, enumArray.Length));
}
}
}
else
{
item = ItemBuilder.CreateRandomClothing(playerEntity.Gender, playerEntity.Race);
}
continueChance >>= 1;
if (DFRandom.rand() % 100 > continueChance)
{
keepGoing = false;
}
items.AddItem(item);
}
}
}
// Update player background panel
void RefreshBackground(PlayerEntity entity)
{
if (lastBackgroundName != entity.RaceTemplate.PaperDollBackground)
{
ImageData data = ImageReader.GetImageData(entity.RaceTemplate.PaperDollBackground, 0, 0, false, false);
Texture2D texture = ImageReader.GetSubTexture(data, backgroundSubRect);
backgroundPanel.BackgroundTexture = texture;
backgroundPanel.Size = new Vector2(texture.width, texture.height);
lastBackgroundName = entity.RaceTemplate.PaperDollBackground;
}
}
// Blit items
void BlitItems(PlayerEntity entity)
{
// Create list of all equipped items
List<DaggerfallUnityItem> equippedItems = new List<DaggerfallUnityItem>();
// Find equipped slots, skip empty slots
foreach (var item in entity.ItemEquipTable.EquipTable)
{
if (item != null)
{
equippedItems.Add(item);
}
}
// Sort equipped items by draw order
List<DaggerfallUnityItem> orderedItems = equippedItems.OrderBy(o => o.drawOrder).ToList();
// Blit item images
foreach(var item in orderedItems)
{
BlitItem(item);
}
}
