public void TestPersönlicheAusstrahlung()
    {
        mCharacter.Spezies  = Races.Mensch;
        mCharacter.Archetyp = AbenteuerTyp.BN;         //egal
        CharacterEngine.ComputeBasisIn(this.mCharacter);
        CharacterEngine.ComputeErscheinung(this.mCharacter);
        CharacterEngine.ComputePsychisch(this.mCharacter);

        Assert.GreaterOrEqual(mCharacter.pA, _MIN_D100);
        Assert.LessOrEqual(mCharacter.pA, _MAX_D100);
    }
    public void TestIntelligenzZaubertalentElf()
    {
        this._mCharacter.Spezies = Races.Elf;

        int In = CharacterEngine.ComputeBasisIn(this._mCharacter);

        Assert.GreaterOrEqual(In, this._IN_MIN_ELF, "Elfenintelligenz zu gering");

        int Zt = CharacterEngine.ComputeBasisZt(this._mCharacter);

        Assert.GreaterOrEqual(In, this._ZT_MIN_ELF, "Elfentzaubertalent zu gering");
    }
    public void TestWkSb()
    {
        mCharacter.Spezies  = Races.Mensch;
        mCharacter.Archetyp = AbenteuerTyp.Gl;         //egal

        CharacterEngine.ComputeBasisIn(this.mCharacter);
        CharacterEngine.ComputeBasisKo(this.mCharacter);
        CharacterEngine.ComputePsychisch(this.mCharacter);

        CharacterEngine.ComputePsychisch(this.mCharacter);

        Assert.GreaterOrEqual(mCharacter.Wk, _MIN_D100);
        Assert.LessOrEqual(mCharacter.Wk, _MAX_D100);

        Assert.GreaterOrEqual(mCharacter.Sb, _MIN_D100);
        Assert.LessOrEqual(mCharacter.Sb, _MAX_D100);

        Debug.Log(mCharacter.Sb);
    }
Beispiel #4
0
    public void TestePAMenschForAllATypen()
    {
        _mCharacter.Spezies = Races.Mensch;
        var aTypen = Enum.GetValues(typeof(AbenteuerTyp));

        try {
            foreach (AbenteuerTyp aTyp in aTypen)
            {
                _mCharacter.Archetyp = aTyp;
                CharacterEngine.ComputeBasisIn(this._mCharacter);
                CharacterEngine.ComputeErscheinung(this._mCharacter);
                CharacterEngine.ComputePsychisch(this._mCharacter);                  //enthält pA!!
                int pA = _mCharacter.pA;

                switch (_mCharacter.Archetyp)
                {
                case AbenteuerTyp.Hä:
                    Assert.GreaterOrEqual(pA, this._HAE_PA, "Händler pA zu gering, pA:" + pA);
                    break;

                case AbenteuerTyp.Gl:
                    Assert.GreaterOrEqual(pA, this._GL_PA, "Glücksritter pA zu gering , pA:" + pA);
                    break;

                case AbenteuerTyp.Ba:
                    Assert.GreaterOrEqual(pA, this._BA_PA, "Barde pA zu gering, pA:" + pA);
                    break;

                case AbenteuerTyp.Tm:
                    Assert.GreaterOrEqual(pA, this._TM_PA, "Tiermeister pA zu gering, pA:" + pA);
                    break;

                default:
                    break;
                }
            }
        } catch (AssertionException asEx) {
            Debug.Log(asEx.ToString());
            Assert.Fail();
        }
    }
Beispiel #5
0
    public void SetBasisIn()
    {
        Toolbox globalVars = Toolbox.Instance;

        inIn.text = CharacterEngine.ComputeBasisIn(globalVars.mCharacter).ToString();
    }
Beispiel #6
0
    public void TesteIntelligenzMenschForAllATypen()
    {
        _mCharacter.Spezies = Races.Mensch;
        var aTypen = Enum.GetValues(typeof(AbenteuerTyp));

        try {
            foreach (AbenteuerTyp aTyp in aTypen)
            {
                _mCharacter.Archetyp = aTyp;
                int In = CharacterEngine.ComputeBasisIn(this._mCharacter);                  //Geschicklichkeit

                switch (_mCharacter.Archetyp)
                {
                case AbenteuerTyp.Er:
                    Assert.GreaterOrEqual(In, this._ER_IN, "Ermittler Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Hä:
                    Assert.GreaterOrEqual(In, this._HAE_IN, "Händler Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Ku:
                    Assert.GreaterOrEqual(In, this._KU_IN, "Kundschafter Intelligenz zu gering , In:" + In);
                    break;

                case AbenteuerTyp.Sp:
                    Assert.GreaterOrEqual(In, this._SP_IN, "Spitzbube Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Wa:
                    Assert.GreaterOrEqual(In, this._WA_IN, "Waldläufer Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Ba:
                    Assert.GreaterOrEqual(In, this._BA_IN, "Barde Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Tm:
                    Assert.GreaterOrEqual(In, this._TM_IN, "Tiermeister Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Be:
                case AbenteuerTyp.Dr:
                case AbenteuerTyp.Hx:
                case AbenteuerTyp.Ma:
                case AbenteuerTyp.PF:
                case AbenteuerTyp.PHa:
                case AbenteuerTyp.PHe:
                case AbenteuerTyp.PK:
                case AbenteuerTyp.PM:
                case AbenteuerTyp.PT:
                case AbenteuerTyp.PW:
                case AbenteuerTyp.Th:
                    Assert.GreaterOrEqual(In, this._ZAUBERER_IN, "Zauberer Intelligenz " + aTyp.ToString() + " zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Hl:
                    Assert.GreaterOrEqual(In, this._HL_IN, "Heiler Intelligenz zu gering, In:" + In);
                    break;

                case AbenteuerTyp.Sc:
                    Assert.GreaterOrEqual(In, this._SC_IN, "Schamane Intelligenz zu gering, In:" + In);
                    break;

                default:
                    break;
                }
            }
        } catch (AssertionException asEx) {
            Debug.Log(asEx.ToString());
            Assert.Fail();
        }
    }