using UnityEngine;
using System;
using System.Collections;
namespace pools
{
public class GameObjectPool {

     private GameObject _prefab;
     private Stack available;
     private ArrayList all;
         
     private Action<GameObject> initAction;
     private bool setActiveRecursively;
         
     // ---- getters & setters ----
     #region getters & setters
         
     // returns the prefab being used by the pool.
     public GameObject prefab {
      get { return _prefab; }
     }
         
     // returns the number of active objects.
     public int numActive {
      get { return all.Count - available.Count; }
     }
         
     // returns the number of available objects.
     public int numAvailable {
      get { return available.Count; }
     }
         
     #endregion
     // ---- constructor ----
     #region constructor
         
     public GameObjectPool(GameObject prefab, uint initialCapacity, Action<GameObject> initAction, bool setActiveRecursively) {
      this._prefab = prefab;
      this.initAction = initAction;
      this.setActiveRecursively = setActiveRecursively;
          
      available =    (initialCapacity > 0)    ? new Stack((int) initialCapacity)  : new Stack();
      all =  (initialCapacity > 0)    ? new ArrayList((int) initialCapacity)    : new ArrayList();
     }
         
     #endregion
     // ---- public methods ----
     #region public methods
         
     public GameObject Spawn(Vector3 position, Quaternion rotation) {
      GameObject result;
          
      if (available.Count == 0){
           
       // create an object and initialize it.
       result = GameObject.Instantiate(prefab, position, rotation) as GameObject;
           
       // run optional initialization method on the object
       if (initAction != null) initAction(result);
           
       all.Add(result);
           
      } else {
       result = available.Pop() as GameObject;
           
       // get the result's transform and reuse for efficiency.
       // calling gameObject.transform is expensive.
       Transform resultTrans = result.transform;
       resultTrans.position = position;
       resultTrans.rotation = rotation;
           
       SetActive(result, true);
      }
          
      return result;
     }
         
     public bool Destroy(GameObject target) {
      if (!available.Contains(target)) {
       available.Push(target);
           
       SetActive(target, false);
       return true;
      }
          
      return false;
     }
         
     // Unspawns all the game objects created by the pool.
     public void DestroyAll() {
      for (int i=0; i<all.Count; i++) {
       GameObject target = all[i] as GameObject;
           
       if (target.active) Destroy(target);
      }
     }
         
     // Unspawns all the game objects and clears the pool.
     public void Clear() {
      DestroyAll();
      available.Clear();
      all.Clear();
     }
         
         
      public bool Unspawn (GameObject obj)
     {
      if (!available.Contains (obj)) {
       // Make sure we don't insert it twice.
       available.Push (obj);
       SetActive (obj, false);
       return true;
       // Object inserted back in stack.
      }
      return false;
      // Object already in stack.
          
          
     }
         
     // Applies the provided function to some or all of the pool's game objects.
     public void ForEach(Action<GameObject> action, bool activeOnly) {
      for (int i=0; i<all.Count; i++){
       GameObject target  = all[i] as GameObject;
           
       if (!activeOnly || target.active) action(target);
      }
     }
         
         
      public void prePopulate (int num)
     {
      GameObject[] array = new GameObject[num];
      for (int i = 0; i < num; i++) {
       array[i] = Spawn (Vector3.zero, Quaternion.identity);
       SetActive (array[i], true);
      }
      for (int j = 0; j < num; j++) {
       Unspawn (array[j]);
      }
     }
         
     #endregion
     // ---- protected methods ----
     #region protected methods
         
     // Activates or deactivates the provided game object using the method
     // specified by the setActiveRecursively flag.
     protected void SetActive(GameObject target, bool value) {
      if (setActiveRecursively) target.SetActiveRecursively(value);
      else target.active = value;
     }
         
     #endregion
}
}

GameObjectPool bulletPull;
public GameObject bulletPrefab;

void Start(){     
      bulletPull = new GameObjectPool(bulletPrefab,99,bulletHandler,true);
                    bulletPull.prePopulate(99);
}

void bulletHandler(GameObject target){     
target.name = "bullet";
}

bulletPull = new GameObjectPool(bulletPrefab,99,bulletHandler,true);

bulletPull.prePopulate(99);

void bulletHandler(GameObject target){     
target.name = "bullet";
}

bulletPull.Spawn (new Vector3 (0, 0, 0), Quaternion.identity);

bulletPull.Unspawn(myGameObject);

void Awake(){     
LoadData();
}

void LoadData(){     

     string filepath = "data.xml";     
     XmlDocument xmlDoc = new XmlDocument ();     
     xmlDoc.Load(filepath);     

      XmlNodeList levelList = xmlDoc.GetElementsByTagName ("Level");         
                    foreach (XmlNode level in levelList)     
                          {
                       XmlNode  node = level.SelectSingleNode("player");
                       XmlAttributeCollection attr = node.Attributes;
                       string s1 = attr[0].Value;
                       float x_coord = System.Convert.ToSingle (s1);
                       s1 = attr[1].Value;
                       float y_coord = System.Convert.ToSingle (s1);
                       s1 = attr[2].Value;
                       float z_coord = System.Convert.ToSingle (s1);
                       playerPosition = new Vector3(x_coord,y_coord,z_coord);

                           }

}

XmlNodeList levelList = xmlDoc.GetElementsByTagName ("Level");  

foreach (XmlNode level in levelList)

  XmlNode node = level.SelectSingleNode("player");

  XmlAttributeCollection attr = node.Attributes;

      
                       string s1 = attr[0].Value;
                       float x_coord = System.Convert.ToSingle (s1);
                       s1 = attr[1].Value;
                       float y_coord = System.Convert.ToSingle (s1);
                       s1 = attr[2].Value;
                       float z_coord = System.Convert.ToSingle (s1);

playerPosition = new Vector3(x_coord,y_coord,z_coord);

public class SaveController : MonoBehaviour {

Transform playerTransform;

void Awake(){   
playerTransform = GameObject.Find("player").transform;   //добавили трансформ игрока;
}

void SaveGame(){   

    string filepath = "data.xml";
    XmlDocument xmlDoc = new XmlDocument ();
    XmlNode rootNode = null;
        if (!File.Exists(filepath))
        {   
        rootNode = xmlDoc.CreateElement ("level");
        xmlDoc.AppendChild (rootNode);
       }
       else {   
      xmlDoc.Load(filepath);
       rootNode = xmlDoc.DocumentElement;
             }
       
     rootNode.RemoveAll ();   
        
          
              XmlElement elmNew = xmlDoc.CreateElement ("player");
                  
                  XmlAttribute position_X = xmlDoc.CreateAttribute ("position_x");   
                  position_X.Value = playerTransform.position.x.ToString();
      XmlAttribute position_Y = xmlDoc.CreateAttribute ("position_y");
      position_Y.Value = playerTransform.position.y.ToString ();
      elmNew.SetAttributeNode (position_X);
      elmNew.SetAttributeNode (position_Y);
      rootNode.AppendChild (elmNew);   
       
     xmlDoc.Save (filepath);   

}

void Update(){   
   if (Input.GetKeyDown (KeyCode.S)) {
     SaveGame();
    }
}
}

  XmlElement elmNew = xmlDoc.CreateElement ("player");
                  
                  XmlAttribute position_X = xmlDoc.CreateAttribute ("position_x");   
                  position_X.Value = playerTransform.position.x.ToString();
      XmlAttribute position_Y = xmlDoc.CreateAttribute ("position_y");
      position_Y.Value = playerTransform.position.y.ToString ();
      elmNew.SetAttributeNode (position_X);
      elmNew.SetAttributeNode (position_Y);
      rootNode.AppendChild (elmNew);   
       
     xmlDoc.Save (filepath);

public class myObjects : MonoBehaviour {
   
public enum TYPEOF{ player,monster,npc }  
public TYPEOF typeOf;
public Transform selfTransform;

void Awake(){  
selfTransform = transform;
}
}

//К переменным
List<myObjects> objs = new List<myObjects>();

   for (int i=0;i<objs.Count;i++){  
             XmlElement elmNew = xmlDoc.CreateElement (objs[i].typeOf.ToString());
                
                 XmlAttribute position_X = xmlDoc.CreateAttribute ("position_x");  
                 position_X.Value = objs[i].selfTransform.position.x.ToString();
     XmlAttribute position_Y = xmlDoc.CreateAttribute ("position_y");
     position_Y.Value = objs[i].selfTransform.position.y.ToString ();
     elmNew.SetAttributeNode (position_X);
     elmNew.SetAttributeNode (position_Y);
     rootNode.AppendChild (elmNew);  
              
              
             }