/// <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); } }