/// <summary>
    /// Gets the sinn by identifier.
    /// </summary>
    /// <returns>The sinn by identifier.</returns>
    private static T GetSinnAngeborenById <T>(int naturId) where T : IID
    {
        List <T> naturSinne;

        Type itemType = typeof(T);

        if (itemType == typeof(Sinn))
        {
            naturSinne = MidgardResourceReader.GetMidgardResource <AngeboreneFertigkeiten> (MidgardResourceReader.MidgardAngeboren).listSinne as List <T>;
        }
        else
        {
            naturSinne = MidgardResourceReader.GetMidgardResource <AngeboreneFertigkeiten> (MidgardResourceReader.MidgardAngeboren).listAngFertigkeiten as List <T>;
        }

        T retSinn = naturSinne [0];

        foreach (T sinn in naturSinne)
        {
            if (sinn.id == naturId)
            {
                retSinn = sinn;
                break;
            }
        }

        return(retSinn);
    }
    /// <summary>
    /// Prepares the angeborene fertigkeiten mit den Standardwerten.
    /// </summary>
    public static void PrepareAngeboreneFertigkeiten(MidgardCharakter mChar)
    {
        //Hole die angeborenen Eigenschaften
        List <Sinn> sinne = MidgardResourceReader.GetMidgardResource <AngeboreneFertigkeiten>(MidgardResourceReader.MidgardAngeboren).listSinne;

        mChar.listSinne = sinne;
    }
    public void SetTypAndSex()
    {
        Toolbox          globalVars = Toolbox.Instance;
        MidgardCharakter mCharacter = globalVars.mCharacter;
        //Lädt die relevante ID für die ausgewählten optionstext
        int AbID = ObjectXMLHelper.GetChosenOptionIndex(AbTyp.captionText.text, MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen);

        mCharacter.Archetyp = (AbenteuerTyp)AbID - 1;        //Achtung enum nullbasiert
        mCharacter.Sex      = (Geschlecht)SexTyp.value;
    }
    /// <summary>
    /// Gets the kategorieid for Abenteurertyp
    /// </summary>
    /// <returns>The minimum value for abenteuer typ.</returns>
    /// <param name="aTyp">A typ.</param>
    /// <param name="basisRef">Basis reference.</param>
    public static int GetKategorieForAbenteurerTyp(int aTyp)
    {
        //Hole KategorieId
        List <AbenteurerTyp> listATypen = MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen;
        int kategorieId = 0;

        foreach (AbenteurerTyp item in listATypen)
        {
            if (item.id == aTyp)
            {
                kategorieId = item.katID.id;
                break;
            }
        }

        return(kategorieId);
    }
    public void SetCharacterSpecies()
    {
        Toolbox          globalVars = Toolbox.Instance;
        MidgardCharakter mCharacter = globalVars.mCharacter;

        Rassen midgardRassen = MidgardResourceReader.GetMidgardResource <Rassen> (MidgardResourceReader.MidgardRassen);

        //Achtung: Hole die ID der Rasse
        int rassenID = ObjectXMLHelper.GetChosenOptionIndex(DropRasse.captionText.text, midgardRassen.rassenListe);

        mCharacter.Spezies = (Races)rassenID - 1;        //Achtung: enum o-basiert


        //Jetzt müsssen die Optionen für die nächste Dropdown gesetzt werden: Wähle dazu die Abenteuertypen mit der entsprechenden RassenID
        List <AbenteurerTyp> listeTypen = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, rassenID);

        ObjectXMLHelper.FillDropBoxMidgardObject <AbenteurerTyp> (listeTypen, DropATyp);
    }
    /// <summary>
    /// Gets the minimum value for abenteuer typ entsprechend der verlangen basiseigenschaft
    /// </summary>
    /// <returns>The minimum value for abenteuer typ.</returns>
    /// <param name="aTyp">A typ.</param>
    /// <param name="basisRef">Basis reference.</param>
    private static int GetMinValueForAbenteuerTyp(int aTyp, int basisRef)
    {
        //Hole empfohlene Mindestwerte für den AbenteurerTyp
        List <AbenteurerTyp> listATypen = MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen;
        int minStATyp = 0;

        foreach (AbenteurerTyp item in listATypen)
        {
            if (item.id == aTyp)
            {
                List <BasiseigenschaftRef> minWerteATyp = item.restriktionen.basisEigenschaften;
                foreach (BasiseigenschaftRef minWert in minWerteATyp)
                {
                    if (minWert.id == basisRef)
                    {
                        minStATyp = minWert.minValue;
                    }
                }
            }
        }

        return(minStATyp);
    }
示例#7
0
    /// <summary>
    /// Test Rasse Mensch. Ermöglicht 30 Abenteurertypen.
    /// Test auf  enthaltenen Assassinen, Barbar und Ordenskrieger
    /// </summary>
    public void SetSpeciesMenschTest()
    {
        _mCharacter.Spezies = Races.Mensch;
        int raceId = (int)_mCharacter.Spezies + 1;
        List <AbenteurerTyp> listeTypen = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, raceId);

        Assert.AreEqual(_ANZAHL_ABENTEUERERTYPEN_PRO_MENSCH, listeTypen.Count);

        var assassine = listeTypen [0];

        StringAssert.AreEqualIgnoringCase("assassine", assassine.name);

        var barbarNord = listeTypen [1];

        StringAssert.Contains("Barbar", barbarNord.name);

        var ordenskrieger = listeTypen [14];

        StringAssert.AreEqualIgnoringCase("Ordenskrieger", ordenskrieger.name);
    }
示例#8
0
    public void GetNumberRassenTest()
    {
        Rassen midgardRassen = MidgardResourceReader.GetMidgardResource <Rassen> (MidgardResourceReader.MidgardRassen);

        Assert.AreEqual(this._ANZAHLRASSEN, midgardRassen.rassenListe.Count);
    }
示例#9
0
    public void SetSpeciesZwergTest()
    {
        _mCharacter.Spezies = Races.Zwerg;
        int raceIdZwerg = (int)_mCharacter.Spezies + 1;
        List <AbenteurerTyp> listeTypenZwerg = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, raceIdZwerg);

        Assert.AreEqual(_ANZAHL_ABENTEUERERTYPEN_PRO_ZWERG, listeTypenZwerg.Count);

        var beschwoerer = listeTypenZwerg [3];

        StringAssert.AreEqualIgnoringCase("beschwörer", beschwoerer.name);
    }
示例#10
0
    /// <summary>
    /// Anzahl Abenteurertypen Halbling:7, Stichprobe 1
    /// </summary>
    public void SetSpeciesHalblingTest()
    {
        _mCharacter.Spezies = Races.Halbling;
        int raceIdHalbling = (int)_mCharacter.Spezies + 1;
        List <AbenteurerTyp> listeTypenHalblinge = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, raceIdHalbling);

        Assert.AreEqual(_ANZAHL_ABENTEUERERTYPEN_PRO_HALBLING, listeTypenHalblinge.Count);

        var waldi = listeTypenHalblinge [2];

        StringAssert.AreEqualIgnoringCase("waldläufer", waldi.name);
    }
示例#11
0
    /// <summary>
    /// Anzahl Abenteurertypen Elf: 9, Stichprobe 3
    /// </summary>
    public void SetSpeciesWaldgnomTest()
    {
        const int _NUMBERABENTEURERTYPEN = 9;

        _mCharacter.Spezies = Races.Waldgnom;
        int raceIdWaldgnom = (int)_mCharacter.Spezies + 1;
        List <AbenteurerTyp> listeTypenWaldgnom = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, raceIdWaldgnom);

        Assert.AreEqual(_NUMBERABENTEURERTYPEN, listeTypenWaldgnom.Count);

        var spitzi = listeTypenWaldgnom [2];

        StringAssert.AreEqualIgnoringCase("spitzbube", spitzi.name);

        var waldi = listeTypenWaldgnom [3];

        StringAssert.AreEqualIgnoringCase("waldläufer", waldi.name);
    }
示例#12
0
    /// <summary>
    /// Rasse Berggnom, 9 ATypen. Stichprobe auf 3
    /// </summary>
    public void SetSpeciesBerggnomTest()
    {
        _mCharacter.Spezies = Races.Berggnom;
        int raceIdBerggnom = (int)_mCharacter.Spezies + 1;
        List <AbenteurerTyp> listeTypenBerggnom = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, raceIdBerggnom);

        Assert.AreEqual(_ANZAHL_ABENTEUERERTYPEN_PRO_BERGGNOM, listeTypenBerggnom.Count);

        var spitzi = listeTypenBerggnom [2];

        StringAssert.AreEqualIgnoringCase("spitzbube", spitzi.name);

        var waldi = listeTypenBerggnom [3];

        StringAssert.AreEqualIgnoringCase("waldläufer", waldi.name);
    }
示例#13
0
    /// <summary>
    /// Rasse Elf, 8 ATypen. Stichprobe auf 3
    /// </summary>
    public void SetSpeciesElfTest()
    {
        _mCharacter.Spezies = Races.Elf;
        int raceIdElf = (int)_mCharacter.Spezies + 1;
        List <AbenteurerTyp> listeAbenteuererTypenElf = ObjectXMLHelper.GetMidgardObjectAByIndexB <AbenteurerTyp, RasseRef>(MidgardResourceReader.GetMidgardResource <AbenteurerTypen> (MidgardResourceReader.MidgardAbenteurerTypen).listAbenteurerTypen, raceIdElf);

        Assert.AreEqual(_ANZAHL_ABENTEUERERTYPEN_PRO_ELF, listeAbenteuererTypenElf.Count);

        var glücksritter = listeAbenteuererTypenElf [0];

        StringAssert.AreEqualIgnoringCase("glücksritter", glücksritter.name);

        var krieger = listeAbenteuererTypenElf [1];

        StringAssert.AreEqualIgnoringCase("krieger", krieger.name);

        var magier = listeAbenteuererTypenElf [7];

        StringAssert.AreEqualIgnoringCase("magier", magier.name);
    }
    /// <summary>
    /// Modifies the angeborene fertigkeiten durch Würfelwurf
    /// </summary>
    /// <param name="mChar">M char.</param>
    //TODO Modifikation für Rassen
    public static void ModifyAngeboreneFertigkeiten(MidgardCharakter mChar, int w100)
    {
        List <Sinn> sinne = MidgardResourceReader.GetMidgardResource <AngeboreneFertigkeiten>(MidgardResourceReader.MidgardAngeboren).listSinne;

        mChar.listSinne = sinne;
        if (w100 <= 2)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Sehen, 4);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 2 && w100 <= 4)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Hoeren, 4);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 4 && w100 <= 6)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Riechen, 4);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 6 && w100 <= 8)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Schmecken, 4);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 8 && w100 <= 10)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Tasten, 4);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 10 && w100 <= 20)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Sehen, 10);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 20 && w100 <= 30)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Hoeren, 10);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 30 && w100 <= 40)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Riechen, 10);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 40 && w100 <= 50)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Schmecken, 10);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 50 && w100 <= 60)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.Tasten, 10);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 60 && w100 <= 65)
        {
            Sinn sinn  = ModifyCharakterSinnNatur(Senses.SechsterSinn, 6);
            Sinn mSinn = ObjectXMLHelper.GetMidgardObjectById(mChar.listSinne, sinn.id);
            mSinn.value = sinn.value;
        }
        else if (w100 > 65 && w100 <= 70)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.Berserkergang, Mathf.FloorToInt(18 - mChar.Wk / 5));
            mChar.listAngeboren.Add(angFert);
        }
        else if (w100 > 70 && w100 <= 75)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.GuteReflexe, 9);
            mChar.listAngeboren.Add(angFert);
        }
        else if (w100 > 75 && w100 <= 80)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.Nachtsicht, 8);
            mChar.listAngeboren.Add(angFert);
        }
        else if (w100 > 80 && w100 <= 85)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.Richtungssinn, 12);
            mChar.listAngeboren.Add(angFert);
        }
        else if (w100 > 85 && w100 <= 90)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.Robustheit, 9);
            mChar.listAngeboren.Add(angFert);
        }
        else if (w100 > 90 && w100 <= 95)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.Wachgabe, 6);
            mChar.listAngeboren.Add(angFert);
        }
        else if (w100 > 95 && w100 <= 99)
        {
            AngeboreneFertigkeit angFert = ModifyCharakterSinnNatur(Natur.Einpraegen, 4);
            mChar.listAngeboren.Add(angFert);
        }
    }