spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C#-Quelltext

public  bool CheckFoundObjects()
    {
        for (int i = 0; i < questObjects.Length  ; i++) 
        {
            if (questObjects [i] == null) 
            {
                Debug.Log ("Questfail");

                lc.challenges.ObjectFindQuests -= 1;
                vorundnach .hatAuswirkungen = false;
                destroyME ();
                break;
            }

            if (!questObjects [i].GetComponent <StaticObjectTopFind > ().einstellungen.wurdeBereitsGefunden) 
            {   
                return false;
            }

        }

    return true;
    }

C#-Quelltext

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class LevelController : MonoBehaviour 
{


    [System .Serializable ]
    public class Aufbau
    {
        [Header ("Teleport")]
        public Teleporter [] Teleporter;
        public TeleZIEL [] TeleporterZiele;

        [Header("Wegpunkte")]
        public KI_Wegpunkt[] Wegpunkte ;
    
        [Header("Spawnpunkte")]
        public Spawn[] Spawnpunkte;

        [Header("Positionen")]
        public STARTPOS StartPosition;
        public TargetZone targetZone;   

    }
    public Aufbau aufbau ;
    [SerializeField ]

    [System.Serializable ]
    public class Personen
    {
        [Header("Survive")]
        public List <CharacterStats> MustSurviveThisMission = new List<CharacterStats> ();
        public bool survived = true;

        [Header("Reach Zone")]
        public List <GameObject  > MustReachTargetZone = new List<GameObject > ();
        public bool reached = false;

        [Header("Kill")]
        public bool KillAllEnemies = true;
        public bool KillSpecificVillain = false;
        public CharacterStats  Villain;
        public bool VillainKilled = false;
        public bool Allkilled = false;

        [Header("to find")]
        public bool thereArePeopleToFind = false;
        public List <GameObject > PersonsToFind = new List<GameObject> ();
        public bool AllPeopleFound = false;
        public string specificPersonName;

        [Header("Auftraggeber")]
        public List <string> Auftraggeber = new List<string> ();
        public List <Quest > AngenommeneAufträge = new List <Quest > ();
    
    }
    public Personen personen;
    [SerializeField ]

    [System .Serializable ]
    public class Challenges
    {
        [Header("Point Goals")]
        public bool Culture = false;
        public float CulturePointsToBreak = 0;
        public bool Detection = false;
        public float DetectSkillToBreak = 0;
        public bool Loyality = false;
        public float LoyalitySkillToBreak = 0;
        public bool Shooting = false;
        public float ShootSkillToBreak = 0;
        public bool CurrentPoints = false;
        public float CurrentPointsToBreak = 0;

        [Header("bring Object to Person")]
        [Tooltip ("Questobjects [0] = zielperson, alle weiteren sind die zu bringenden Objekte")]
        public ItemManager Reciever;
        public List <Item> bringsel = new List<Item> ();
        public int bringselCount = 0;
        public bool delivered = false;
        

        [Header("Static Objects Finding")]
        public List < StaticObjectTopFind> ObjectsToFind = new List<StaticObjectTopFind> ();
        public bool allfound = false;
        public int totalFound = 0;

        [Header("ObjectDestruction")]
        public bool SpecificObjectToDestroy = false;
        public zzz SpecificObject;
        public string SpecificObjectName;
        public bool specificObjectDestroyed = false;

        [Header("Drops collected")]
        public int DropsCollected = 0;
        public List <BonusDrops > BonusDrops = new List<BonusDrops> ();
        public int TotalBonusDrops = 0;
        public bool allDropsFound = false;

        [Header("angenommene Quests")]
        public int CharacterQuests = 0;
        public int PointQuests = 0;
        public int ObjectFindQuests = 0;
        public int ObjectDestructQuests = 0;
        public int PersonFindQuests = 0;

        [Header("All Quests in Level")]
        public int AllQuestsInThisLevel = 0;
        public List <Quest> Questlist = new List<Quest> ();

    }
    public Challenges challenges;
    [SerializeField ]

    [System .Serializable ]
    public class Collections
    {
        public int Artefacts = 0;
        public int Tools =0;
        public int Boni =0;
        public int Hints = 0;
    }
    public Collections collections;
    [SerializeField ]

    [System .Serializable ]
    public class Settings
    {
        public AudioClip QuestSuccessSND;
        public AudioClip MissionSuccessSND;
        public AudioClip MissionFailSND;
    }
    public Settings settings;
    [SerializeField ]

    private GameController gc;
    private bool missionfailed = false;
    private CharacterStats Player;
    public int checkint = 0;
    private  InfotextScript  Anzeige; 
    private InfotextScript Anzeige2_unten;
    private InfotextScript Anzeige3;
    public bool missionAccomplished = false;
    public int storageObjects;
    private Quest[] qL;
    private BonusDrops[] bD;
    public int total;
    private int startaufstellung;

    void Start () 
    {
        gc = GameObject.FindObjectOfType <GameController > ();
        Player = GameObject.FindGameObjectWithTag ("Player").GetComponent <CharacterStats> ();
        Anzeige = GameObject.FindGameObjectWithTag ("InfoText").GetComponent <InfotextScript > ();
        Anzeige2_unten  = GameObject.FindGameObjectWithTag ("DialogText").GetComponent <InfotextScript > ();
        Anzeige3 = GameObject.FindGameObjectWithTag ("QuestText").GetComponent <InfotextScript > ();
        qL = GameObject.FindObjectsOfType <Quest> ();
        foreach (Quest q in qL) 
        {
            challenges.Questlist.Add (q);
        }

        dropSetup ();
        challenges.TotalBonusDrops = challenges.BonusDrops.Count;

        getPositions ();
        getTransporters ();
        getWaypoints ();
        checkint = 0;
        challenges.AllQuestsInThisLevel = challenges.Questlist.Count + challenges .CharacterQuests +challenges .PointQuests + challenges .ObjectFindQuests +challenges .ObjectDestructQuests + challenges .PersonFindQuests  ;
        startChallenges ();
        storageObjects = challenges.ObjectsToFind.Count;
        total = checkint;
        startaufstellung = checkint;
        if (personen.MustSurviveThisMission.Count > 0) 
        { // das ist für den Fall, das wenn bei Start bereits eine Person überleben soll, der quest in dem Moment ja schon gewonnen wurde.
            Player.egS.accomplished_Quests += 1;
        } 
        if (checkint == 0) //Für den Fall, das keine Aufgabe zu Levelbeginn besteht. nach dem ersten gelösten Quest wäre die Mission gewonnen, unabhängig wieviele Quests im Level sind.
        { 
            // um das zu verhindern gibts hier die Pro-forma Aufgabenstellung für jedes Level: Spieler muß Zielgebiet erreichen. 
            personen .MustReachTargetZone .Add (Player .gameObject );
            startChallenges ();
            total = checkint;
            startaufstellung = checkint;
        }
    
    
    }

    void Update () 
    {
        SurvivalTest ();
        TestTargetZoneReached ();
        KillAllTest ();
        KillSpecificTest ();
        DestroySpecificObject ();
        Pointchecks ();
        checkObjects ();
        PersonFindTest ();
        BringselTest ();
        DropsManagement ();
        missionCheck ();

    }
    // werden die Bonusdrops eigentlich im Missionserfolg berücksichtigt?
    public void dropSetup()
    {
        bD  = GameObject.FindObjectsOfType <BonusDrops > ();
        foreach (BonusDrops  b in bD ) 
        {
            challenges.BonusDrops .Add (b);
        }
    }

    void getTransporters()
    {

        aufbau.Teleporter = GameObject.FindObjectsOfType <Teleporter > ();
        aufbau.TeleporterZiele = GameObject.FindObjectsOfType <TeleZIEL > ();
    }

    void getWaypoints()
    {
        aufbau.Wegpunkte = GameObject.FindObjectsOfType <KI_Wegpunkt > ();

    }

    void getPositions()
    {
        aufbau.StartPosition = GameObject.FindObjectOfType <STARTPOS > ();
        aufbau.targetZone = GameObject.FindObjectOfType <TargetZone > ();

    }

    void BringselTest()
    {
        if (challenges.Reciever == null)
            return;
        
        if (challenges.bringsel.Count == 0 && challenges .Reciever != null) 
        {
            challenges.delivered = true;
        }

        if (challenges.delivered )
        {
            Erfolgsmeldung ("alle Bringesl abgegeben", 0, settings .QuestSuccessSND );
            Debug.Log("alle Bringesl abgegeben");
            challenges.CharacterQuests -= 1;
        }



    }


    void SurvivalTest()
    {
        if (personen.MustSurviveThisMission.Count  == 0 || personen .survived)
            return;


        foreach (CharacterStats c in personen .MustSurviveThisMission) 
        {
            if (c.egS.health <= 0) 
            {
                personen.survived = false;
                missionFail ();
                break;
            }
        }


    }

    void TestTargetZoneReached()
    {
        if (personen.MustReachTargetZone.Count == 0 || personen .reached)
            return;
        
//      foreach (GameObject g in personen .MustReachTargetZone) 
//      {
//          CharacterStats cS = g.GetComponent <CharacterStats > ();
//          if (!personen.MustSurviveThisMission.Contains (cS)) 
//          {
//              personen.MustSurviveThisMission.Add (cS); // damit dieZonen Personen auf jeden Fall am Leben bleiben, bis sie in der Zone sind
//          }
//      }

        Checkmatch ();

        if (Checkmatch () && !personen.reached) 
        {
            Erfolgsmeldung ("Alle Personen im Zielgebiet", 0, settings .QuestSuccessSND );
            Debug.Log("Person angekommen");
            challenges.CharacterQuests -= 1;
            personen .reached = true;
        }
    }

    public  bool Checkmatch()
    {
        if (aufbau.targetZone .PersonsInTargetZone .Count != personen .MustReachTargetZone .Count )
            return false;

        for (int i = 0; i < personen .MustReachTargetZone .Count ; i++) 
        {
            foreach (GameObject P in aufbau.targetZone .PersonsInTargetZone) 
            {
                if (P == personen .MustReachTargetZone [i])
                    return true;
            }
        }
        return false;
    }

    void KillAllTest()
    {
        if (personen.Allkilled || !personen .KillAllEnemies)
            return ;

        if (personen.KillAllEnemies) 
        {
            if (gc.teamSP.Feinde.Count == 0) 
            {
            //  Erfolgsmeldung + 1;
                Erfolgsmeldung ("Alle Gegner " +  " sind tot!", 0 , settings .QuestSuccessSND );
                challenges.CharacterQuests -= 1;
                personen.Allkilled = true;
            }

        }

    }

    void KillSpecificTest()
    {
        if (personen.Villain != null) 
        {
            personen.KillSpecificVillain = true;
        }

        if (!personen.KillSpecificVillain || personen .VillainKilled )
            return;

        if (personen.Villain.egS.health <= 0) 
        {
            // Erfolgsmeldung +1;
            Erfolgsmeldung (personen.Villain.egS.Name  + " ist tot!", 0 , settings .QuestSuccessSND );
            challenges.CharacterQuests -= 1;
            personen .VillainKilled = true;
        }
    }

    void DestroySpecificObject()
    {
        if (challenges .SpecificObject != null) 
        {
            challenges .SpecificObjectToDestroy  = true;
        }

        if (!challenges.SpecificObjectToDestroy || challenges.specificObjectDestroyed) 
        {
            challenges.SpecificObjectToDestroy = false;
            return;
        }

        if (challenges .SpecificObject.ges <= 0) 
        {
            challenges.SpecificObject = null;
            challenges.ObjectDestructQuests -= 1;
            challenges  .specificObjectDestroyed  = true;
            Erfolgsmeldung (challenges.SpecificObjectName  +  "zerstört!", 0 , settings .QuestSuccessSND );
            challenges.SpecificObjectName = null;
    
        }
    }




    void checkObjects()
    {
        if (!challenges .allfound && challenges.ObjectsToFind.Count == 0 && challenges .ObjectFindQuests > 0) 
            {
                Erfolgsmeldung ("Alle Objekte gefunden!", 0, settings.QuestSuccessSND);
                storageObjects = 0;
                challenges.ObjectFindQuests -= 1;
                challenges.allfound = true;
            }
    
    }


    void PersonFindTest()
    {
        if (personen.thereArePeopleToFind) 
        {
            if (personen.PersonsToFind.Count == 0 && !personen.AllPeopleFound) 
            {
                Erfolgsmeldung (personen.specificPersonName + " gefunden!", 0, settings.QuestSuccessSND);
                challenges.PersonFindQuests -= 1;
                personen.AllPeopleFound = true;
                personen.thereArePeopleToFind = false;
                personen.specificPersonName = "";
            }

        }

    }

public  void startChallenges()
    {
        if (personen.PersonsToFind.Count > 0) 
        {
            challenges.PersonFindQuests += 1;   
        }

        if (challenges.Reciever != null)
            challenges.CharacterQuests += 1;

        
        if (personen.MustReachTargetZone.Count > 0) 
            challenges.CharacterQuests += 1;
        
//      if (personen.MustSurviveThisMission.Count > 0) // bleibt, für den Fall, das im Verlauf eines Levels eine Figur unter Schutz gestellt werden muß.
//          challenges.CharacterQuests += 1;
        
        if (personen.KillAllEnemies) 
            challenges.CharacterQuests += 1;
        
        if (personen.KillSpecificVillain || personen.Villain != null) 
        challenges.CharacterQuests += 1;


        if (challenges .SpecificObjectToDestroy  || challenges .SpecificObject  != null) 
        challenges.ObjectDestructQuests  += 1;
        

        if (challenges .Culture )
            challenges.PointQuests  += 1;
        
        if (challenges .Detection )
            challenges.PointQuests  += 1;

        if (challenges .Loyality )
            challenges.PointQuests  += 1;

        if (challenges .Shooting )
            challenges.PointQuests  += 1;

        if (challenges .CurrentPoints)
            challenges.PointQuests  += 1;

        if (challenges.ObjectsToFind.Count > 0)
            challenges.ObjectFindQuests +=1 ;

    //challenges .AllQuestsInThisLevel = challenges.Questlist.Count ;
        challenges.AllQuestsInThisLevel = challenges .CharacterQuests +challenges .PointQuests + challenges .ObjectFindQuests +challenges .ObjectDestructQuests + challenges .PersonFindQuests  ;
        checkint = challenges .AllQuestsInThisLevel ;
}

    void Pointchecks()
    {
        
        if (challenges.Culture) 
        {
            if (Player.egS.culture >= challenges.CulturePointsToBreak) 
            {
                Erfolgsmeldung ("Kulturziel erreicht" + "\n" + "neuer Wert: "+ Player.egS .culture.ToString () , 0,settings .QuestSuccessSND );
                challenges.PointQuests -= 1;
                challenges.Culture = false;
            }
        }
        if (challenges.Detection ) 
        {
            if (Player.egS.detecting >= challenges.DetectSkillToBreak ) 
            {
                Erfolgsmeldung ("SpähSkills verbessert" + "\n" + "neuer Wert: "+ Player.egS .detecting .ToString (),  0,settings .QuestSuccessSND );
                challenges.PointQuests -= 1;
                challenges.Detection = false;
            }
        }
        if (challenges.Loyality ) 
        {
            if (Player.egS.loyality  >= challenges.LoyalitySkillToBreak ) 
            {
                Erfolgsmeldung ("Loyalität verbessert" + "\n" + "neuer Wert: "+ Player.egS .loyality.ToString () ,  0,settings .QuestSuccessSND );
                challenges.PointQuests -= 1;
                challenges.Loyality  = false;
            }
        }
        if (challenges.Shooting ) 
        {
            if (Player.egS.shooting  >= challenges.ShootSkillToBreak) 
            {
                Erfolgsmeldung ("SchießSkills verbessert" + "\n" + "neuer Wert: "+ Player.egS .shooting .ToString () ,  0,settings .QuestSuccessSND );
                challenges.PointQuests -= 1;
                challenges.Shooting = false;
            }
        }
        if (challenges.CurrentPoints ) 
        {
            if (Player.egS.currentPoints >= challenges.CurrentPointsToBreak) 
            {
                Erfolgsmeldung ("Punkestand verbessert" + "\n" + "neuer Wert: "+ ((float)Player.egS .currentPoints ).ToString () , 0, settings .QuestSuccessSND );
                challenges.PointQuests -= 1;
                challenges.CurrentPoints = false;
            }
        }

    }

    void DropsManagement ()
    {
        if (challenges.TotalBonusDrops == 0)
            return;

        if (challenges.DropsCollected == challenges.TotalBonusDrops && !challenges.allDropsFound  )
        {
        //Erfolgsmeldung ("Alle BonusDrops gefunden!", 0, settings .QuestSuccessSND );
            Anzeige .DisplayInfo ("Alle BonusDrops gefunden!");
            AudioSource.PlayClipAtPoint (settings.QuestSuccessSND, Player.transform.position, 1);
            challenges.allDropsFound = true;

        }

    }


    void Erfolgsmeldung(string was, float wert, AudioClip snd)
    {
        if (challenges.AllQuestsInThisLevel > 0 && checkint > 0)
            checkint -= 1;

        AudioSource.PlayClipAtPoint (snd, Player.transform.position, 1);
        Anzeige3.DisplayInfo (was);
    }

    public void missionFail()
    {
        if (!missionfailed) 
        {
            Anzeige .DisplayInfo ("Mission failed");
            AudioSource.PlayClipAtPoint (settings.MissionFailSND , Player.transform.position, 1);
            missionfailed = true;
        }
    }

    void missionCheck()
    {


        if (checkint == 0 && !missionAccomplished && challenges .AllQuestsInThisLevel > 0) 
        {
            missionVictory ();
            missionAccomplished = true;
        }

    }

    void missionVictory()
    {
        if (!missionAccomplished) 
        {
            Erfolgsmeldung ("Mission erfolgreich!", 0, settings.MissionSuccessSND);
            Anzeige2_unten . DisplayInfo (Player.egS .accomplished_Quests + startaufstellung  + " / " + total + " Quests erfüllt!");
            Invoke ("EndGame", 5.0f);
        }
    }

    void EndGame()
    {
        Application.Quit  ();
    }
}

C#-Quelltext

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine .UI;

public class Quest : MonoBehaviour 
{
    private GameController gc;
    private LevelController lc;
    private Radar radar ;
    public string Titel;

    public enum Type
    {
        PointsTobreak, ObjectsToFind, PersonToKill, PersonToProtect, KillAllEnemies, PersonToZone, DestroySpecificObject, PersonToFind, DeliverToPerson
    }
    public Type type;

    public enum Points
    {
        JustPoints, Shooting, Loyality, Detecting, Culture
    }
    public Points points;

    public bool AufgabeAngenommen = false;
    public GameObject [] questObjects;
    public int pointstobreak;
    public string []Message;
    private string  Auftraggeber;
    private KI_dialog parent;
    private CharacterStats  player;
    private TargetZone tZ;

    [System .Serializable ]
    public class VorundNachher
    {
    
        [Header ("Bedingungen und Auswirkungen")]
    public bool imDone = false;
    public bool hatAuswirkungen = false;
    public bool hatVorbedingungen = false;
    public List <GameObject > AuswirkungsObjekte = new List<GameObject> ();
    public List <GameObject> VorbedingungsObjekte = new List <GameObject>();

        public enum StateVor
        {
            SetActive, SetInactive, Destroy, Instantitate, SetToFollow
        }
        public StateVor stateVor;
        public enum StateNach
        {
            SetActive, SetInactive, Destroy, Instantitate, SetToFollow
        }
        public StateNach stateNach;
    }
    [SerializeField ]
    public VorundNachher vorundnach;


    private InfotextScript  dtx;

    void Awake()
    {
        if (Titel != null)
            this.gameObject.name = Titel;

        gc = GameObject.FindObjectOfType <GameController> ();
        lc = GameObject.FindObjectOfType <LevelController > ();
        radar = GameObject.FindObjectOfType <Radar> ();
        parent = GetComponentInParent <KI_dialog > ();
        if (parent == null) {
            Auftraggeber = "Gott";
        } 
        else 
        {
            Auftraggeber = parent.GetComponentInParent <CharacterStats > ().egS.Name;
        }

        player = GameObject.FindGameObjectWithTag ("Player").GetComponent<CharacterStats > ();
        tZ = GameObject.FindObjectOfType <TargetZone > ();
        dtx = GameObject.FindGameObjectWithTag ("DialogText").GetComponent <InfotextScript >();
    }


    void Update()
    {
        if (!AufgabeAngenommen) { // was passiert, wenn vor der Annahme des Quests eines der Questobjekte weg ist
            
            foreach (GameObject g in questObjects) 
            {
                if (g == null) 
                {
                    destroyME ();
                }
            }
        }
        else  // nach annahme des Quests
        {
            switch (type) 
            {
            case Type.ObjectsToFind:
            vorundnach.imDone = CheckFoundObjects ();
                break;
            case Type.PersonToFind :
                vorundnach .imDone = CheckFoundPersons ();
                break;
            case Type.PointsTobreak:
                PointCheck ();
                break;
            case Type.PersonToKill:
                vorundnach .imDone = checkVillain ();
                break;
            case Type.KillAllEnemies:
                vorundnach .imDone = CheckDeadEnemies ();
                break;
            case Type.PersonToZone:
                vorundnach .imDone = personZoneCheck ();
                break;
            case Type.DestroySpecificObject :
                vorundnach .imDone =  checkObjectToDestroy();
                break;
            case Type.DeliverToPerson :
                vorundnach .imDone =  DeliveryCheck();
                break;
            }

        }


        if (vorundnach .imDone) 
        {
            player.egS.accomplished_Quests += 1;


            if (vorundnach .hatAuswirkungen)
                Auswirkung();
            
            vorundnach .imDone = false;
            destroyME ();
        }

    }

    void destroyME()
    {
        if (parent == null)
            return;
        
        lc.challenges.Questlist.Remove (this);
        parent.basics.quest.Remove (this);
        parent.basics.Questnummer -= 1;
        Destroy (this.gameObject);
    }


public  void LogToLevel()
    {
        AufgabeAngenommen = true;
        lc.total += 1;

        if (vorundnach .hatVorbedingungen)
            Vorbereitung  ();

        switch (type) 
        {
        case Type.ObjectsToFind:
            Objects ();
            break;
        case Type.PersonToFind:
            Personen ();
            break;
        case Type.PointsTobreak:
            reachPoints ();
            break;
        case Type.PersonToKill:
            KillVillain ();
            break;
        case Type.KillAllEnemies:
            KillAllEnemies ();
            break;
        case Type.PersonToProtect:
            protectPerson ();
            break;
        case Type.PersonToZone:
            persontozone ();
            break;
        case Type.DestroySpecificObject:
            destroieObject ();
            break;
        case Type.DeliverToPerson:
            Delivery ();
            break;
        }

    }

    void Delivery()
    {
        lc.challenges.Reciever  = questObjects [0].GetComponent <ItemManager >();

        foreach(GameObject g in questObjects )
        {
            Debug.Log (g);
            if (g.GetComponent <Item> ()) 
            {
                g.GetComponent <Item> ().besitzergefunden = false;
                g.GetComponent <Item> ().itemSetup.Besitzer = questObjects [0];
                lc.challenges.bringsel.Add (g.GetComponent <Item> ());
                Radar.RemoveRadarObjekt (g);
                Radar.RegisterRadarObjekte (g, radar.Radarmarker [5]);
            }
        }

    
        setnewChallenge ();
    }


    bool DeliveryCheck()
    {
        foreach (Item i in lc.challenges .bringsel) 
        {
            Debug.Log ("Testlauf1");
            if (i.besitzergefunden) 
            {

                lc.challenges.bringsel.Remove (i);

            }

        }

        if (lc.challenges.bringsel.Count == 0) 
        {
            Debug.Log ("Testlauf2");
            lc.challenges.delivered = true;
            return true;
        }
        return false;
    }



    // finden von Personen //
    void Personen()
    {
        lc.personen.thereArePeopleToFind = true;
        foreach (GameObject g in questObjects) 
        {

            g.GetComponent <CharacterStats > ().egS .wurde_gefunden = false;
            lc.personen.specificPersonName = g.GetComponent <CharacterStats > ().egS.Name;
            lc.personen .PersonsToFind.Add (g);
            Radar.RemoveRadarObjekt (g);
            Radar.RegisterRadarObjekte (g, radar.Radarmarker [5]);

        }
        setnewChallenge ();

    }

    public  bool CheckFoundPersons()
    {
        for (int i = 0; i < questObjects.Length  ; i++) 
        {
            if (!questObjects [i].GetComponent <CharacterStats  > ().egS .wurde_gefunden) 
            {   
                return false;
            }

        }

        return true;
    }

    // Objekte //
    void Objects()
    {
        
        foreach (GameObject g in questObjects) 
        {
            StaticObjectTopFind stof = g.GetComponent <StaticObjectTopFind > ();
            stof.einstellungen.wurdeBereitsGefunden = false;
            lc.challenges.ObjectsToFind.Add (stof);
            Radar.RegisterRadarObjekte (g, radar.Radarmarker [5]);

        }
        setnewChallenge ();

    }

    public  bool CheckFoundObjects()
    {
        for (int i = 0; i < questObjects.Length  ; i++) 
        {
            if (questObjects [i] == null) 
            {
                Debug.Log ("Questfail");
                lc.challenges.ObjectFindQuests -= 1;
                vorundnach .hatAuswirkungen = false;
                destroyME ();
                break;
            }

            if (!questObjects [i].GetComponent <StaticObjectTopFind > ().einstellungen.wurdeBereitsGefunden) 
            {   
                return false;
            }

        }

    return true;
    }

    // All Enemies //
    void KillAllEnemies()
    {
        lc.personen.KillAllEnemies = true;

        setnewChallenge ();
    }

    public bool CheckDeadEnemies()
    {
        if (gc.teamSP.Feinde.Count == 0) 
        {
            return true;
        }
        return false;
    }

    // Objekt zerstören //
    void destroieObject ()
    {

        if (questObjects [0] == null)  //falls schon tot zerstört 
        {
            return;
        }

        lc.challenges .SpecificObjectToDestroy = true;
        lc.challenges .SpecificObject = questObjects [0].GetComponent <zzz >();
        lc.challenges.SpecificObjectName = questObjects [0].GetComponent <zzz > ().Bezeichnung;
        lc.challenges.specificObjectDestroyed = false; // was, wenn der oberbösewicht schon tot ist?
        Radar.RegisterRadarObjekte (lc.challenges .SpecificObject .gameObject , radar.Radarmarker [7]);
        setnewChallenge ();

    }

    bool checkObjectToDestroy()
    {
        if (questObjects [0] == null || questObjects [0].GetComponent <zzz >().ges  <= 0)  
        {
            return true;
        }
        return false;
    }

    // Bösewicht //
    void KillVillain ()
    {

        if (questObjects [0] == null)  //falls der schon tot ist 
        {
            return;
        }

        lc.personen.KillSpecificVillain = true;
        lc.personen.Villain = questObjects [0].GetComponent <CharacterStats >();
        lc.personen.VillainKilled = false; // was, wenn der oberbösewicht schon tot ist?

        setnewChallenge ();

    }

    bool checkVillain()
    {
        if (questObjects [0] != null && questObjects [0].GetComponent <CharacterStats >().egS .health <= 0)  
        {
            return true;
        }
        return false;
    }

    // braucht nicht auf done gesetzt zu werden , da eh bestanden, solange die leben. falls nicht, ists eh aus
    void protectPerson()
    {
        foreach (GameObject g in questObjects) 
        {
            CharacterStats cS = g.GetComponent <CharacterStats > ();
            if (cS.egS.health <= 0) //wenn einer der zu beschützenden schon tot sein sollte
            {
                lc.missionFail ();
                break;
            }

            lc.personen.MustSurviveThisMission.Add (cS);
        }

        setnewChallenge ();
    }   


    // Punkte erreicht //
    void reachPoints()
    {

        switch (points) 
        {

        case Points.Culture:
            lc.challenges.Culture = true;
            lc.challenges.CulturePointsToBreak += pointstobreak;
            setnewChallenge ();
            break;
        case Points.Detecting:
            lc.challenges.Detection = true;
            lc.challenges.DetectSkillToBreak += pointstobreak;
            setnewChallenge ();
            break;
        case Points.Shooting:
            lc.challenges.Shooting = true;
            lc.challenges.ShootSkillToBreak += pointstobreak;
            setnewChallenge ();
            break;
        case Points.Loyality:
            lc.challenges.Loyality = true;
            lc.challenges.LoyalitySkillToBreak += pointstobreak;
            setnewChallenge ();
            break;
        case Points.JustPoints:
            lc.challenges.CurrentPoints = true;
            lc.challenges.CurrentPointsToBreak += pointstobreak;
            setnewChallenge ();
            break;

        }
    }

    void PointCheck()
    {
        switch (points) 
        {

        case Points.Culture:

            if (player.egS.culture >= pointstobreak)
                vorundnach .imDone = true;
                break;
        case Points.Detecting:

            if (player.egS.detecting >= pointstobreak)
                vorundnach .imDone = true;
                    break;
        case Points.Shooting:

            if (player.egS.shooting >= pointstobreak)
                vorundnach .imDone = true;
                    break;
        case Points.Loyality:
            
            if (player.egS.loyality >= pointstobreak)
                vorundnach .imDone = true;
            break;
        case Points.JustPoints:

            if (player.egS.currentPoints >= pointstobreak)
                vorundnach .imDone = true;

            break;

        }
    }

    // persons in Zone
    void persontozone()
    {

        TargetZone t = GameObject.FindObjectOfType <TargetZone > ();


        foreach (GameObject g in questObjects) 
        {
            CharacterStats cS = g.GetComponent <CharacterStats > ();
            if (cS.egS.health < 0 ) 
            {
                lc.missionFail ();
                break;
            }

            if (!lc.personen.MustReachTargetZone.Contains (g))
            lc.personen.MustReachTargetZone.Add (g);
//
//
//          if (!lc.personen .MustSurviveThisMission .Contains (cS))
//              lc.personen.MustSurviveThisMission.Add (cS); // damit dieZonen Personen auf jeden Fall am Leben bleiben, bis sie in der Zone sind
            
        }
        lc.personen.reached = false;
        setnewChallenge ();
    }

    bool  personZoneCheck()
    {
        for (int i = 0; i < questObjects .Length ; i++) 
            {
            foreach (GameObject P in tZ .PersonsInTargetZone) 
                {
                    if (P ==questObjects[i])
                        return true;
                }
            }
            return false;
    }


    void setnewChallenge()
    {
        lc.personen.Auftraggeber.Add (Auftraggeber);
        lc.storageObjects = lc.challenges.ObjectsToFind.Count;
        lc.checkint = 0;
        lc.challenges.PersonFindQuests = 0;
        lc.challenges.CharacterQuests = 0;
        lc.challenges.PointQuests = 0;
        lc.challenges.ObjectDestructQuests = 0;
        lc.startChallenges ();
    }


    void Auswirkung ()
    {
        dtx.DisplayInfo (Auftraggeber + ": "+ Message  [3]);
        foreach (GameObject g in vorundnach .AuswirkungsObjekte  )
        {
            switch (vorundnach .stateNach ) 
        {
            case VorundNachher   .StateNach .SetActive:
                g.SetActive(true);
                break;
            case VorundNachher .StateNach.SetInactive:
                g.SetActive(false);
                break;
            case VorundNachher .StateNach.Instantitate:
                ins (g);
                break;
            case VorundNachher .StateNach.Destroy:
                Destroy (g);
                break;
            case VorundNachher .StateNach.SetToFollow:
                GameObject p = GameObject.FindGameObjectWithTag ("Player");
                p.GetComponent <Squad_Manager > ().TeamMitglieder.Add (g);
                g.GetComponent <AI> ().teamS.Kapitän =p.transform;
                g.GetComponent <AI> ().teamS.follow_in_team = true;
                g.GetComponent <AI> ().SetState (AIState.Follow);
                g.GetComponent<AI>().navmesh.SetDestination(p.transform.position);
                if (Vector3.Distance(p.transform.position , g.transform.position ) < g.GetComponent<AI>().navmesh.stoppingDistance)
                {
                    g.transform.root.GetComponent<AI>().forward = g.transform.root.GetComponent<AI>().LerpSpeed(g.transform.root.GetComponent<AI>().forward, 0, 15);
                }           
                Radar.RemoveRadarObjekt (g);
                Radar .RegisterRadarObjekte (g, radar .Radarmarker [2]);
                break;

        }
        }

    }


    void ins(GameObject g)
    {
    //  g = Instantiate (g, null, Quaternion.identity);
    }

    void Vorbereitung()
    {
        dtx.DisplayInfo ( ": "+ Message  [3]);
        foreach (GameObject g in vorundnach .VorbedingungsObjekte  )
        {
            switch (vorundnach .stateVor ) 
            {
            case VorundNachher   .StateVor .SetActive:
                g.SetActive(true);
                if (g.GetComponent <CharacterStats > ()) 
                {
                    Radar.RemoveRadarObjekt (g);
                }



                break;
            case VorundNachher .StateVor.SetInactive:
                g.SetActive(false);
                break;
            case VorundNachher .StateVor.Instantitate:
                ins (g);
                break;
            case VorundNachher .StateVor.Destroy:
                Destroy (g);
                break;
            case VorundNachher .StateVor.SetToFollow:
                GameObject p = GameObject.FindGameObjectWithTag ("Player");
                p.GetComponent <Squad_Manager > ().TeamMitglieder.Add (g);
                g.GetComponent <AI> ().teamS.Kapitän =p.transform;
                g.GetComponent <AI> ().teamS.follow_in_team = true;
                g.GetComponent <AI> ().SetState (AIState.Follow);
                g.GetComponent<AI>().navmesh.SetDestination(p.transform.position);
                if (Vector3.Distance(p.transform.position , g.transform.position ) < g.GetComponent<AI>().navmesh.stoppingDistance)
                {
                    g.transform.root.GetComponent<AI>().forward = g.transform.root.GetComponent<AI>().LerpSpeed(g.transform.root.GetComponent<AI>().forward, 0, 15);
                }           
                Radar.RemoveRadarObjekt (g);
                Radar .RegisterRadarObjekte (g, radar .Radarmarker [2]);
                break;

            }
        }
    }
}