public void CureDisease(Diseases disease)
        {
            // Find specific disease incumbent
            InstancedBundle[] bundles = GetDiseaseBundles();
            foreach (InstancedBundle bundle in bundles)
            {
                // Must have a live effect
                if (bundle.liveEffects == null || bundle.liveEffects.Count == 0)
                {
                    continue;
                }

                // Must be a disease effect
                if (!(bundle.liveEffects[0] is DiseaseEffect))
                {
                    continue;
                }

                // Must be correct type of disease effect
                DiseaseEffect effect = bundle.liveEffects[0] as DiseaseEffect;
                if (effect.ClassicDiseaseType == disease)
                {
                    effect.CureDisease();
                    Debug.LogFormat("Cured disease {0}", disease);
                }
            }
        }
Exemplo n.º 2
0
        public DaggerfallMessageBox CreateHealthStatusBox(IUserInterfaceWindow previous = null)
        {
            const int youAreHealthyID = 18;

            DaggerfallMessageBox healthBox = new DaggerfallMessageBox(uiManager, previous);

            // Show "You are healthy." if there are no diseases
            if (GameManager.Instance.PlayerEffectManager.DiseaseCount == 0)
            {
                healthBox.SetTextTokens(youAreHealthyID);
            }
            else
            {
                EntityEffectManager playerEffectManager = GameManager.Instance.PlayerEffectManager;

                // Get disease descriptions for each disease effect
                TextFile.Token[] tokens = null;
                EntityEffectManager.InstancedBundle[] bundles = playerEffectManager.DiseaseBundles;
                foreach (EntityEffectManager.InstancedBundle bundle in bundles)
                {
                    foreach (IEntityEffect effect in bundle.liveEffects)
                    {
                        if (effect is DiseaseEffect)
                        {
                            DiseaseEffect disease = (DiseaseEffect)effect;
                            if (disease.IncubationOver)
                            {
                                if (tokens == null)
                                {
                                    tokens = disease.ContractedMessageTokens;
                                }
                                else // Concatenate descriptions for multiple diseases with a new line in-between
                                {
                                    TextFile.Token[] tokens2   = disease.ContractedMessageTokens;
                                    TextFile.Token[] newTokens = new TextFile.Token[tokens.Length + tokens2.Length + 1];
                                    tokens.CopyTo(newTokens, 0);
                                    newTokens[tokens.Length] = TextFile.NewLineToken;
                                    tokens2.CopyTo(newTokens, tokens.Length + 1);
                                    tokens = newTokens;
                                }
                            }
                        }
                    }
                }

                // If no diseases were done with incubation, show "You are healthy."
                if (tokens == null)
                {
                    healthBox.SetTextTokens(youAreHealthyID);
                }
                else
                {
                    healthBox.SetTextTokens(tokens);
                }
            }
            healthBox.ClickAnywhereToClose = true;
            return(healthBox);
        }
        /// <summary>
        /// Helper to create a classic disease effect bundle.
        /// </summary>
        /// <param name="diseaseType">Classic disease type.</param>
        /// <returns>EntityEffectBundle.</returns>
        public EntityEffectBundle CreateDisease(Diseases diseaseType)
        {
            EffectBundleSettings settings = new EffectBundleSettings()
            {
                Version    = EntityEffectBroker.CurrentSpellVersion,
                BundleType = BundleTypes.Disease,
                Effects    = new EffectEntry[] { new EffectEntry(DiseaseEffect.GetClassicDiseaseEffectKey(diseaseType)) },
            };

            return(new EntityEffectBundle(settings, entityBehaviour));
        }
        // Taken from DaggerfallWorkshop.Game.DaggerfallUI::CreateHealthStatusBox()
        private string GetActiveEffectsMessage()
        {
            // Show "You are healthy." if there are no diseases and no poisons
            int diseaseCount = GameManager.Instance.PlayerEffectManager.DiseaseCount;
            int poisonCount  = GameManager.Instance.PlayerEffectManager.PoisonCount;

            if (diseaseCount > 0 || poisonCount > 0)
            {
                //Debug.Log(string.Format("ActiveEffects: {0} diseases, {1} poisons", diseaseCount, poisonCount));

                List <string>       messages            = new List <string>();
                EntityEffectManager playerEffectManager = GameManager.Instance.PlayerEffectManager;

                LiveEffectBundle[] bundles = playerEffectManager.EffectBundles;
                foreach (LiveEffectBundle bundle in bundles)
                {
                    foreach (IEntityEffect effect in bundle.liveEffects)
                    {
                        if (effect is DiseaseEffect)
                        {
                            string        diseaseType;
                            DiseaseEffect disease = (DiseaseEffect)effect;

                            if (effect is LycanthropyInfection)
                            {
                                diseaseType = "Lycanthropy";
                            }
                            else if (effect is VampirismInfection)
                            {
                                diseaseType = "Vampirism";
                            }
                            else
                            {
                                diseaseType = ((Diseases)((int)disease.ClassicDiseaseType)).ToString();
                            }

                            if (disease.IncubationOver)
                            {
                                messages.Add(
                                    string.Format(
                                        "You have contracted {0}",
                                        diseaseType
                                        )
                                    );
                            }
                            else
                            {
                                messages.Add(
                                    string.Format(
                                        "{0} is slowly creeping over you",
                                        diseaseType
                                        )
                                    );
                            }
                        }
                        else if (effect is PoisonEffect)
                        {
                            PoisonEffect poison     = (PoisonEffect)effect;
                            Poisons      poisonType = (Poisons)poison.CurrentVariant + 128;
                            if (poison.CurrentState != PoisonEffect.PoisonStates.Waiting)
                            {
                                messages.Add(
                                    string.Format(
                                        "You have {0} coursing through your veins",
                                        poisonType.ToString()
                                        )
                                    );
                            }
                            else
                            {
                                messages.Add(
                                    string.Format(
                                        "{0} is slowly seeping through your veins",
                                        poisonType.ToString()
                                        )
                                    );
                            }
                        }
                    }
                }

                if (messages.Count > 0)
                {
                    return(string.Join("\n", messages.ToArray()));
                }
            }

            return("");
        }