private void CargarInventario(Inventario inventario)
{
for (int i = 0; i < inventario.DevolverNumeroObjetos(); i++)
{
inventario.SustituyeObjeto(ObjetoInventario.LoadObjeto(Manager.rutaObjetoInventario + inventario.DevolverObjeto(i).ID.ToString() + ".xml"), i);
}
}
public void EliminarObjeto(ObjetoInventario objetoInventario) //Elimina 1 stock del objeto seleccionado
{
objetos.Remove(objetoInventario.item);
//objetosInventario.Remove(objetoInventario.gameObject);
objetoInventario.Destruir();
Debug.Log("ObjetoInventario eliminado: " + objetoInventario);
DeterminarSiguienteCasilla();
}
void CrearInventarioObjetos(XmlNode objeto)
{
GameObject ObjetoNuevoUI = GameObject.Instantiate(mostrarInfoPrefab, ContenedorObjetos);
ObjetoInventario NuevoObjetoInventario = new ObjetoInventario(objeto);
NuevoObjetoInventario.ActualizarInvetario(ObjetoNuevoUI);
}
//
public static void Asignar(ObjetoInventario de, ObjetoInventario a)
{
de.Nombre = a.Nombre;
de.Tipo = a.Tipo;
de.Objeto = a.Objeto;
de.sprite = a.sprite;
de.descripcion = a.descripcion;
de.Extra1 = a.Extra1;
}
public void BotarObjeto(ObjetoInventario objetoADropear)
{
GameObject ObjetoDrop = new GameObject(objetoADropear.item.NombreItem, typeof(Objeto));
ObjetoDrop.GetComponent <Objeto>().item = objetoArrastrado.item;
ObjetoDrop.GetComponent <Objeto>().cantidad = objetoADropear.CantidadStock;
ObjetoDrop.transform.position = AtributosJugador.atributosJugador.transform.position;
objetos.Remove(objetoADropear.item);
Destroy(objetoADropear.gameObject);
}
//Eventos
private void BeginDrag(Casilla casilla)
{
Debug.Log("Draggeando " + casilla);
if (casilla.GetComponentInChildren <ObjetoInventario>() != null)
{
casillaArrastrada = casilla;
objetoArrastrado = casilla.GetComponentInChildren <ObjetoInventario>();
objetoArrastrado.gameObject.GetComponent <Image>().raycastTarget = false;
objetoArrastrado.transform.SetParent(PanelInventario.panelInventario.transform);
}
}
//
public static void Asignar(ObjetoInventario de, ObjetoInventario a)
{
de.Nombre = a.Nombre;
de.Tipo = a.Tipo;
de.Objeto = a.Objeto;
de.sprite = a.sprite;
de.descripcion = a.descripcion;
de.Extra1 = a.Extra1;
}
public bool AñadirObjeto(Item item, int cantidad)
{
DeterminarSiguienteCasilla();
//Primero checkea si es consumible y además es nuevo objeto
if (((item.apilable == true && !objetos.Contains(item) && !InventarioLleno) || (item.apilable == false && !InventarioLleno))) //Revisar si funciona al implementar stack
{
System.Type[] componentes = { typeof(ObjetoInventario), typeof(Image) };
Debug.Log("Añadiendo " + item.NombreItem);
objetos.Add(item);
GameObject nuevoObjeto = new GameObject(item.NombreItem, componentes);
ObjetoInventario nuevoObjetoInventario = nuevoObjeto.GetComponent <ObjetoInventario>();
nuevoObjeto.GetComponent <Image>().sprite = item.artwork;
nuevoObjetoInventario.item = item;
nuevoObjetoInventario.transform.SetParent(casillas[CasillaVacia].transform);
nuevoObjetoInventario.CantidadStock = cantidad;
//Ajustar Rectransform de nuevo objeto en inventario
RectTransform rectTransform = nuevoObjeto.GetComponent <RectTransform>();
rectTransform.anchorMax = new Vector2(1, 1);
rectTransform.anchorMin = new Vector2(0, 0);
rectTransform.pivot = new Vector2(0.5f, 0.5f);
rectTransform.localScale = new Vector3(0.7f, 0.7f, 1);
rectTransform.localPosition = Vector3.zero;
nuevoObjetoInventario.name = item.NombreItem;
casillas[CasillaVacia].ObtenerObjetoInventario();
casillas[CasillaVacia].ActualizarTextoStock(cantidad);
objetosInventario.Add(nuevoObjeto); //Añadir a la lista de objetos
nuevoObjeto.GetComponent <Image>().material = GestorMateriales.gestorMateriales.materiales[indiceMaterialInventario];
return(true);
}
else if (item.apilable == true && objetos.Contains(item))
{
Debug.Log("Objeto Apilable");
for (int i = 0; i < casillas.Count; i++) //Bugeado al eliminar un objeto en una casilla con número superior al número de objetos
{
try
{
if (item == casillas[i].GetComponentInChildren <ObjetoInventario>().item)
{
casillas[i].GetComponentInChildren <ObjetoInventario>().CantidadStock++;
break;
}
}
catch { }
}
PanelInventario.panelInventario.ActualizarTextos();
return(true);
}
return(false);
}
public void UsarObjeto(ObjetoInventario objetoInventario)
{ //Busca Objeto en inventario
if (objetoInventario.item is Equipamiento) //Revisa si el objeto es equipable
{
EquiparObjetoDesdeInventario(objetoInventario);
}
else if (objetoInventario.item.UsarObjeto())
{
if (objetoInventario.CantidadStock <= 1)
{
objetos.Remove(objetoInventario.item);
}
objetoInventario.ReducirStock(1);
}
}
private void EndDrag(Casilla casilla)
{
Debug.Log("Terminó de dragear " + casilla.name);
if (objetoArrastrado.transform.parent == PanelInventario.panelInventario.transform) //No se soltó en ninguna casilla
{
BotarObjeto(objetoArrastrado);
//GameObject ObjetoDrop = new GameObject(objetoArrastrado.item.NombreItem,typeof(Objeto));
//ObjetoDrop.GetComponent<Objeto>().item = objetoArrastrado.item;
//ObjetoDrop.GetComponent<Objeto>().cantidad = objetoArrastrado.CantidadStock;
//ObjetoDrop.transform.position = AtributosJugador.atributosJugador.transform.position;
//objetos.Remove(objetoArrastrado.item);
//Destroy(objetoArrastrado.gameObject);
}
objetoArrastrado = null;
}
public void Eliminar(int slot)
{
ObjetoInventario aux = new ObjetoInventario();
if (Cantidad[slot] == 0 || Cantidad[slot] < 0)
{
ObjetoInventario.Asignar(Objetos[slot], aux);
}
else
{
Cantidad[slot]--;
if (Cantidad[slot] == 0 || Cantidad[slot] < 0)
{
ObjetoInventario.Asignar(Objetos[slot], aux);
}
}
}
public void AddObjeto(int IDObjeto, int cantidad)
{
int numObjeto = ObjetoInventarioLugar(IDObjeto);
//Si no existe el objeto, lo añadimos
if (numObjeto == -1)
{
ObjetoInventario objetoInventario = ObjetoInventario.LoadObjeto(Manager.rutaObjetoInventario + IDObjeto.ToString() + ".xml");
objetoInventario.cantidad = cantidad;
objetos.Add(objetoInventario);
Manager.instance.AddObjetoReciente(objetoInventario, cantidad); //se añade también a la lista de objetos recientes
}
//Si existe, aumentamos en 1 la cantidad
else
{
objetos[numObjeto].cantidad += cantidad;
Manager.instance.AddObjetoReciente(objetos[numObjeto], cantidad); //se añade también a la lista de objetos recientes
}
}
private void EquiparObjetoDesdeInventario(ObjetoInventario objetoInventario)
{
Equipamiento objetoEquipado;
if (PanelEquipamiento.Equipamiento.Equipar((Equipamiento)objetoInventario.item, out objetoEquipado))
{
Debug.Log("Objeto previamente equipado es " + objetoEquipado);
DeterminarSiguienteCasilla();
if (objetoEquipado != null)
{
objetoInventario.item = objetoEquipado; //Traspasar Objeto del inventario
objetoInventario.gameObject.GetComponent <Image>().sprite = objetoEquipado.artwork; //Actualizar artwork del objeto
}
else
{
objetoInventario.Destruir();
}
}
PanelesInventario.panelesInventario.tooltipObjetos.AparecerOcultar(false);
}
public void Eliminar(int slot)
{
ObjetoInventario aux = new ObjetoInventario();
if (Cantidad[slot] == 0 || Cantidad[slot] < 0)
{
ObjetoInventario.Asignar(Objetos[slot], aux);
}
else
{
Cantidad[slot]--;
if (Cantidad[slot] == 0 || Cantidad[slot] < 0)
{
ObjetoInventario.Asignar(Objetos[slot], aux);
}
}
}
//public PuntosInventario[] PuntoEquipo = new PuntosInventario[2];
//
public void AgregarObjeto(int ID)
{
for (int i = 0; i < Objetos.Length; i++)
{
if (Objetos[i].Objeto == null)
{
//
ObjetoInventario.Asignar(Objetos[i], DB.Database[ID]);
Cantidad[i]++;
return;
//
}
else
{
if (Objetos[i].Objeto == DB.Database[ID].Objeto)
{
Cantidad[i]++;
return;
}
}
}
print("No hay espacios libres");
}
private void Drop(Casilla casilla)
{
Debug.Log("Dropeando en casilla " + casilla.name);
casillaArrastrada.GetComponentInChildren <Text>().enabled = true;
ObjetoInventario objetoEnNuevaCasilla = casilla.GetComponentInChildren <ObjetoInventario>();
if (objetoEnNuevaCasilla != null) //Existe un objeto en la casilla de destino
{
objetoEnNuevaCasilla.transform.position = casillaArrastrada.transform.position;
objetoEnNuevaCasilla.transform.SetParent(casillaArrastrada.transform);
objetoEnNuevaCasilla.ActualizarCasillaPadre();
casillaArrastrada.ActualizarTextoStock(objetoEnNuevaCasilla.CantidadStock);
}
else
{ //No existe objeto en la casilla
casillaArrastrada.ActualizarTextoStock(0);
}
if (casilla as CasillaEquipamiento)
{ //Dropeo objeto en casilla de equipamiento
Debug.Log("En casilla Equipamiento");
EquiparObjetoDesdeInventario(objetoArrastrado);
}
else if (casilla as Basurero)
{ //Dropeo objeto en basurero
EliminarObjeto(objetoArrastrado);
casillaArrastrada.ActualizarTextoStock(0);
}
else
{
objetoArrastrado.transform.SetParent(casilla.transform);
objetoArrastrado.gameObject.GetComponent <Image>().raycastTarget = true;
objetoArrastrado.transform.position = casilla.transform.position;
objetoArrastrado.ActualizarCasillaPadre();
casilla.ActualizarTextoStock(objetoArrastrado.CantidadStock);
}
}
public void AddObjetoReciente(ObjetoInventario objetoInventario, int cantidad)
{
objetosRecientes.Add(new ObjetoReciente(objetoInventario, cantidad));
}
public void SustituyeObjeto(ObjetoInventario objetoInventario, int indice)
{
objetos[indice] = objetoInventario;
}
public void Usar(int slot)
{
if (Objetos[slot].Objeto != null)
{
if (Objetos[slot].Tipo == Tipo.Consumibles)
{
print(Objetos[slot].Nombre + "fue usado");
}
else if (Objetos[slot].Tipo == Tipo.equipo)
{
if (Objetos[slot].Extra1 == "Helado 1")
//
{
if (Equipo[0].Objeto != null)
{
int aux = 0;
for (int i = 0; i < DB.Database.ToArray().Length; i++)
{
if (DB.Database[i].Objeto == Equipo[0].Objeto)
{
aux = i;
}
}
ObjetoInventario.Asignar(Equipo[0], Objetos[slot]);
Eliminar(slot);
AgregarObjeto(aux);
}
else
{
ObjetoInventario.Asignar(Equipo[0], Objetos[slot]);
Eliminar(slot);
}
//PuntoEquipo[0].Refrescar();
}
if (Objetos[slot].Extra1 == "Helado 2")
{
if (Equipo[1].Objeto != null)
{
int aux = 0;
for (int i = 0; i < DB.Database.ToArray().Length; i++)
{
if (DB.Database[i].Objeto == Equipo[1].Objeto)
{
aux = i;
}
}
ObjetoInventario.Asignar(Equipo[1], Objetos[slot]);
Eliminar(slot);
AgregarObjeto(aux);
}
else
{
ObjetoInventario.Asignar(Equipo[1], Objetos[slot]);
Eliminar(slot);
}
//PuntoEquipo[1].Refrescar();
}
}
else if (Objetos[slot].Tipo == Tipo.objetosclave)
{
print("No se puede usar el objeto");
}
}
}
public void ObtenerObjetoInventario()
{
objetoInventario = GetComponentInChildren <ObjetoInventario>();
}
public static ObjetoInventario LoadObjeto(string path)
{
ObjetoInventario objetoInventario = Manager.instance.DeserializeData <ObjetoInventario>(path);
return(objetoInventario);
}
public ObjetoReciente(ObjetoInventario objetoInventario, int cantidad)
{
objeto = objetoInventario;
this.cantidad = cantidad;
}
public ObjetoReciente(ObjetoInventario objetoInventario, int cantidad)
{
objeto = objetoInventario;
this.cantidad = cantidad;
}
public void SustituyeObjeto(ObjetoInventario objetoInventario, int indice)
{
objetos[indice] = objetoInventario;
}
