public bool get_Mover_Utilizar_Ineractivo(ObjetoInteractivo interactivo, Celda celda, int _habilidad)
{
if (cuenta.esta_ocupado || interactivo_utilizado != null)
{
return(false);
}
if (interactivo == null || !interactivo.es_utilizable)
{
return(false);
}
interactivo_utilizado = interactivo;
habilidad = _habilidad;
switch (cuenta.juego.manejador.movimientos.get_Mover_A_Celda(celda, mapa.celdas_ocupadas(), true, 1))
{
case ResultadoMovimientos.EXITO:
case ResultadoMovimientos.MISMA_CELDA:
get_Utilizar_Elemento();
return(true);
default:
limpiar();
return(false);
}
}
public Cell(short prmCellId, bool prmIsActive, CellTypes prmCellType, bool prmIsInLineOfSight, byte _nivel, byte _slope, short prmInteractiveObjectId, short _layer_object_1_num, short _layer_object_2_num, Map prmMap)
{
cellId = prmCellId;
isActive = prmIsActive;
cellType = prmCellType;
layer_object_1_num = _layer_object_1_num;
layer_object_2_num = _layer_object_2_num;
isInLineOfSight = prmIsInLineOfSight;
layer_ground_nivel = _nivel;
layer_ground_slope = _slope;
if (prmInteractiveObjectId != -1)
{
interactiveObject = new ObjetoInteractivo(prmInteractiveObjectId, this);
prmMap.interactives.TryAdd(cellId, interactiveObject);
}
byte mapWidth = prmMap.mapWidth;
int loc5 = cellId / ((mapWidth * 2) - 1);
int loc6 = cellId - (loc5 * ((mapWidth * 2) - 1));
int loc7 = loc6 % mapWidth;
y = loc5 - loc7;
x = (cellId - ((mapWidth - 1) * y)) / mapWidth;
}
void Update()
{
if (controller == null)
{
Debug.Log("Mando no inicializado");
}
if (controller.GetPressDown(triggerButton)) // Aquí van todas las posibles acciones con el botón Trigger
{
float minDistancia = float.MaxValue;
float distancia;
foreach (ObjetoInteractivo objeto in objetoscercanos) // Calcula distancia de cada objeto al mando y comprueba si es la mínima
{
distancia = (objeto.transform.position - transform.position).sqrMagnitude; // Calcula distancia, no vector
if (distancia < minDistancia)
{
minDistancia = distancia;
objetoMasCercano = objeto;
}
}
objetoAgarrado = objetoMasCercano; // El objeto que se agarrará es el que tenga la menor distancia al mando
objetoMasCercano = null; // Borra el objeto más cercano una vez agarrado
if (objetoAgarrado)
{
if (objetoAgarrado.EstaAgarrando()) // Si el objeto ya está siendo agarrado (por otro mando) termina agarre con el
{ // otro mando para comenzar a agarrar con el nuevo
objetoAgarrado.FinAgarre(this);
}
objetoAgarrado.ComienzoAgarre(this); // Comienza a agarrar el objeto
}
}
if (controller.GetPressUp(triggerButton) && objetoAgarrado != null) // Botón trigger no está pulsado y hay un objeto agarrado
{
objetoAgarrado.FinAgarre(this);
}
if (controller.GetPressDown(gripButton)) // Aquí van todas las acciones con el botón Grip
{
if (objetoPulsable && gripPulsando == false) // Si hay un objeto pulsable en el collider y Trigger no estaba pulsado antes
{
objetoPulsable.CambiaEstado(); // Cambia el estado del botón
gripPulsando = true; // Se cambia bandera para evitar que encienda y apague mientras se pulsa
}
}
if (controller.GetPressUp(gripButton))
{
gripPulsando = false; // Se reinicia la bandera
}
/*gripButtonPressed = controller.GetPress(gripButton);
*
* triggerButtonDown = controller.GetPressDown(triggerButton);
* triggerButtonUp = controller.GetPressUp(triggerButton);
* triggerButtonPressed = controller.GetPress(triggerButton);*/
}
public Celda(short _id, bool esta_activa, TipoCelda _tipo, bool _es_linea_vision, byte _nivel, byte _slope, short _objeto_interactivo_id, short _layer_object_1_num, short _layer_object_2_num, Map map)
{
id = _id;
activa = esta_activa;
tipo = _tipo;
layer_object_1_num = _layer_object_1_num;
layer_object_2_num = _layer_object_2_num;
es_linea_vision = _es_linea_vision;
layer_ground_nivel = _nivel;
layer_ground_slope = _slope;
if (_objeto_interactivo_id != -1)
{
objeto_interactivo = new ObjetoInteractivo(_objeto_interactivo_id, this);
map.interactivos.TryAdd(id, objeto_interactivo);
}
byte mapa_anchura = map.anchura;
int _loc5 = id / ((mapa_anchura * 2) - 1);
int _loc6 = id - (_loc5 * ((mapa_anchura * 2) - 1));
int _loc7 = _loc6 % mapa_anchura;
y = _loc5 - _loc7;
x = (id - ((mapa_anchura - 1) * y)) / mapa_anchura;
}
public void evento_Recoleccion_Acabada(RecoleccionResultado resultado)
{
robado = false;
interactivo_recolectando = null;
cuenta.Estado_Cuenta = EstadoCuenta.CONECTADO_INACTIVO;
recoleccion_acabada?.Invoke(resultado);
}
private bool get_Intentar_Mover_Interactivo(KeyValuePair <short, ObjetoInteractivo> interactivo)
{
interactivo_recolectando = interactivo.Value;
byte distancia_detener = 1;
ObjetosInventario arma = cuenta.juego.personaje.inventario.get_Objeto_en_Posicion(InventarioPosiciones.ARMA);
if (arma != null)
{
distancia_detener = get_Distancia_herramienta(arma.id_modelo);
}
ResultadoMovimientos resultado_movimiento = cuenta.juego.manejador.movimientos.get_Mover_A_Celda(interactivo_recolectando.celda, mapa.celdas_ocupadas(), true, distancia_detener);
switch (resultado_movimiento)
{
case ResultadoMovimientos.EXITO:
case ResultadoMovimientos.MISMA_CELDA:
get_Intentar_Recolectar_Interactivo();
return(true);
default:
get_Cancelar_Interactivo();
return(false);
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
interactivo_utilizado = null;
cuenta = null;
disposed = true;
}
}
public bool get_Utilizar_Interactivo(int _celda_id, int _habilidad = -1)
{
ObjetoInteractivo interactivo = mapa.get_Interactivo(_celda_id);
if (interactivo == null || !interactivo.es_utilizable)
{
return(false);
}
return(get_Mover_Utilizar_Ineractivo(interactivo, interactivo.celda, _habilidad));
}
public bool utilizarInteractivo(int celda_id, int habilidad = -1)
{
ObjetoInteractivo interactive = cuenta.juego.mapa.get_Interactivo(celda_id);
if (interactive?.es_utilizable == false)
{
return(false);
}
manejador_acciones.enqueue_Accion(new UtilizarInteractivoAccion(celda_id, habilidad), true);
return(true);
}
public void evento_Recoleccion_Acabada(RecoleccionResultado resultado, short celda_id)
{
if (interactivo_recolectando == null || interactivo_recolectando.celda.cellId != celda_id)
{
return;
}
robado = false;
interactivo_recolectando = null;
cuenta.AccountState = AccountStates.CONNECTED_INACTIVE;
recoleccion_acabada?.Invoke(resultado);
}
public void evento_Recoleccion_Acabada(RecoleccionResultado resultado, short celda_id)
{
if (interactivo_recolectando == null || interactivo_recolectando.celda.id != celda_id)
{
return;
}
robado = false;
interactivo_recolectando = null;
cuenta.AccountStatus = AccountStatus.ConnectedInactive;
recoleccion_acabada?.Invoke(resultado);
}
public void evento_Recoleccion_Acabada(RecoleccionResultado resultado, short celda_id)
{
if (interactivo_recolectando == null || interactivo_recolectando.celda.id != celda_id)
{
return;
}
robado = false;
interactivo_recolectando = null;
cuenta.Estado_Cuenta = EstadoCuenta.CONECTADO_INACTIVO;
recoleccion_acabada?.Invoke(resultado);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
pathfinder.Dispose();
}
interactivos_no_utilizables.Clear();
interactivos_no_utilizables = null;
interactivo_recolectando = null;
pathfinder = null;
cuenta = null;
disposed = true;
}
}
private void OnTriggerExit(Collider other)
{
ObjetoInteractivo objetoInteractuando = other.GetComponent <ObjetoInteractivo>(); // Un objeto que ha salido del collider del mando
if (objetoInteractuando) // Si el objeto que ha salido es un ObjetoInteractivo
{
objetoscercanos.Remove(objetoInteractuando); // Quita del HashSet ese objeto
}
//***HAY QUE PROBAR ESTO***//
ObjetoPulsable esObjetoPulsable = other.GetComponent <ObjetoPulsable>(); // Se comprueba si el objeto que ha salido es pulsable
if (esObjetoPulsable != null) // Si es pulsable, se pone objetoPulsable = null y se
{ // reinicializa la variable de comprobacion esObjetoPulsable
objetoPulsable = null;
esObjetoPulsable = null;
}
//***HAY QUE PROBAR ESTO***//
}
private bool get_Intentar_Mover_Interactivo(KeyValuePair <short, ObjetoInteractivo> interactivo)
{
interactivo_recolectando = interactivo.Value;
ResultadoMovimientos resultado = cuenta.juego.manejador.movimientos.get_Mover_A_Celda(interactivo_recolectando.celda, mapa.celdas_ocupadas, true);
switch (resultado)
{
case ResultadoMovimientos.EXITO:
case ResultadoMovimientos.MISMA_CELDA:
get_Intentar_Recolectar_Interactivo();
return(true);
default:
get_Cancelar_Interactivo();
return(false);
}
}
private void OnTriggerEnter(Collider other)
{
Debug.Log("trigger");
ObjetoInteractivo objetoInteractuando = other.GetComponent <ObjetoInteractivo>(); // Un objeto que simplemente ha entrado en el collider del mando
if (objetoInteractuando) // Si el objeto que ha entrado es un ObjetoInteractivo
{
objetoscercanos.Add(objetoInteractuando); // Añade al HashSet ese objeto
}
//***HAY QUE PROBAR ESTO***//
ObjetoPulsable esObjetoPulsable = other.GetComponent <ObjetoPulsable>(); // esObjetoPulsable es la variable donde se comprueba si es
if (esObjetoPulsable != null) // pulsable y objetoPulsable donde se guarda la referencia
{ // del objeto que ha entrado y es pulsable
Debug.Log("esObjetoPulsable");
objetoPulsable = esObjetoPulsable;
}
//***HAY QUE PROBAR ESTO***//
}
private bool get_Intentar_Mover_Interactivo(KeyValuePair <short, ObjetoInteractivo> interactivo)
{
interactivo_recolectando = interactivo.Value;
byte distancia_detener = 1;
InventoryObject arma = cuenta.game.character.inventario.get_Objeto_en_Posicion(InventorySlots.WEAPON);
if (arma != null)
{
distancia_detener = get_Distancia_herramienta(arma.id_modelo);
}
switch (cuenta.game.manager.movimientos.get_Mover_A_Celda(interactivo_recolectando.celda, mapa.celdas_ocupadas(), true, distancia_detener))
{
case ResultadoMovimientos.EXITO:
case ResultadoMovimientos.SameCell:
get_Intentar_Recolectar_Interactivo();
return(true);
default:
get_Cancelar_Interactivo();
return(false);
}
}
private void OnTriggerExit(Collider other)
{
Rigidbody rigidbodyAnterior = discoAnterior.GetComponent <Rigidbody>();
ObjetoInteractivo objetoInteractivo = discoAnterior.GetComponent <ObjetoInteractivo>();
// Solo cuando el anuladorTriggerSalida lo permita (sea false)
if (anuladorTriggerSalida == false)
{
// Si sale un disco del LectorDiscos
if (other.tag == "Disco")
{
// Se activa la gravedad del discoAnterior
rigidbodyAnterior.isKinematic = false;
rigidbodyAnterior.useGravity = true;
// Ya no se está reproduciendo música
hayDiscoPuesto = false;
}
}
// Se vuelve a permitir el trigger de salida
anuladorTriggerSalida = false;
// Si sale el mando del lector de discos se vuelve a poder coger el disco que está puesto
if ((other.tag == "Mando") && anuladorTriggerMando == false)
{
// Si hay disco puesto se vuelve a activar el component ObjetoInteractivo del disco para poder volver a cogerlo
if (hayDiscoPuesto)
{
objetoInteractivo.enabled = true;
rigidbodyAnterior.useGravity = false;
rigidbodyAnterior.isKinematic = false;
}
anuladorTriggerMando = true;
}
}
public Celda(short _id, TipoCelda _tipo, bool _es_linea_vision, byte _nivel, byte _slope, short _objeto_interactivo_id, short layer_object_1_num, short layer_object_2_num, Mapa _mapa)
{
id = _id;
if (texturas_teleport.Contains(layer_object_1_num) || texturas_teleport.Contains(layer_object_2_num))
{
tipo = TipoCelda.CELDA_TELEPORT;
}
else if (_tipo == TipoCelda.CELDA_TELEPORT)
{
tipo = TipoCelda.CELDA_CAMINABLE;
}
else
{
tipo = _tipo;
}
es_linea_vision = _es_linea_vision;
layer_ground_nivel = _nivel;
layer_ground_slope = _slope;
objeto_interactivo_id = _objeto_interactivo_id;
mapa = _mapa;
if (objeto_interactivo_id != -1)
{
objeto_interactivo = new ObjetoInteractivo(objeto_interactivo_id, id);
}
byte mapa_anchura = mapa.anchura;
int _loc5 = id / ((mapa_anchura * 2) - 1);
int _loc6 = id - (_loc5 * ((mapa_anchura * 2) - 1));
int _loc7 = _loc6 % mapa_anchura;
y = _loc5 - _loc7;
x = (id - ((mapa_anchura - 1) * y)) / mapa_anchura;
}
public void get_Cancelar_Interactivo() => interactivo_recolectando = null;
public void limpiar()
{
interactivo_recolectando = null;
interactivos_no_utilizables.Clear();
robado = false;
}
// Cuando un objeto ha entrado en el collider de LectorDiscos
private void OnTriggerEnter(Collider other)
{
Debug.Log("Ha entrado algo");
if ((other.tag == "Disco") && (other.GetComponent <ObjetoInteractivo>().EstaAgarrando()))
{
// El disco que ha entrado es el actual
Disco discoActual = other.GetComponent <Disco>();
objetoInteractivo = discoActual.GetComponent <ObjetoInteractivo>();
Rigidbody rigidbody = discoActual.GetComponent <Rigidbody>();
// Almacena la anterior música a la asignación
compruebaCambio = musicaDiscoActual;
// Se almacena la música correspondiente al disco que ha entrado
musicaDiscoActual = discoActual.musica;
// Comprueba si ha habido algún cambio
if (musicaDiscoActual != compruebaCambio)
{
hazCambio = true;
}
else
{
audioSource.Play();
}
if (hayDiscoPuesto)
{
// Desactivo el trigger para evitar que al sacar el disco detecte la salida del mismo
anuladorTriggerSalida = true;
// Se pone el discoAnterior en su posición inicial
discoAnterior.transform.localPosition = posicionInicialJazz;
discoAnterior.transform.rotation = rotacionInicialJazz;
// Se activa la gravedad del discoAnterior
Rigidbody rigidbodyAnterior = discoAnterior.GetComponent <Rigidbody>();
rigidbodyAnterior.useGravity = true;
rigidbodyAnterior.isKinematic = false;
}
rigidbody.isKinematic = true;
// Se coloca el disco que ha entrado en la posición de reproducción
discoActual.transform.position = posicionReproduciendo;
discoActual.transform.rotation = rotacionReproduciendo;
anuladorTriggerMando = false;
// Se desactiva objetoInteractivo del disco para evitar que se siga cogiendo. Se activa en OnTriggerExit
objetoInteractivo.enabled = false;
// Ahora se sabe que hay disco puesto para las siguientes reproducciones
hayDiscoPuesto = true;
// Se almacena la anterior música para la próxima vez que se meta un disco
musicaDiscoAnterior = musicaDiscoActual;
// Se almacena la referencia en discoAnterior para el siguiente cambio de disco
discoAnterior = discoActual;
}
}
public void limpiar()
{
interactivo_utilizado = null;
habilidad = 0;
}
