protected override void EntraNoModoFinalizacao(CriatureBase C)
{
Estado = EstadoDeUsoDeItem.emEspera;
if (GameController.g.HudM.MenuDePause.EmPause)
{
Finaliza();
}
else if (!esqueceu)
{
nomesGolpes nomeDoGolpe = GolpePorAprender(C);
GameController.g.HudM.Painel.AtivarNovaMens(
string.Format(BancoDeTextos.RetornaFraseDoIdioma(ChaveDeTexto.aprendeuGolpe),
C.NomeEmLinguas,
GolpeBase.NomeEmLinguas(nomeDoGolpe))
, 30
);
GameController.g.HudM.P_Golpe.Aciona(PegaUmGolpeG2.RetornaGolpe(nomeDoGolpe));
estadoDoAprendeGolpe = EstadoDoAprendeGolpe.aprendiSemEsquecer;
}
else if (esqueceu)
{
GameController.g.StartCoroutine(TerminaDaquiAPouco());
}
}
void AoEscolherumCriature(int indice)
{
GameController g = GameController.g;
DadosDoPersonagem dados = g.Manager.Dados;
HudManager hudM = g.HudM;
if (dados.CriaturesAtivos.Count < dados.maxCarregaveis)
{
CriatureBase C = dados.CriaturesArmagedados[indice];
hudM.UmaMensagem.ConstroiPainelUmaMensagem(VoltarDoEntraArmagedado,
string.Format(frasesDeArmagedom[3], C.NomeEmLinguas, C.CaracCriature.mNivel.Nivel)
);
dados.CriaturesArmagedados.Remove(C);
dados.CriaturesAtivos.Add(C);
}
else
{
CriatureBase C = dados.CriaturesArmagedados[indice];
Debug.Log(indice);
indiceDoSubstituido = indice;
Debug.Log(indiceDoSubstituido);
hudM.UmaMensagem.ConstroiPainelUmaMensagem(MostraOsQueSaem,
string.Format(frasesDeArmagedom[4], C.NomeEmLinguas, C.CaracCriature.mNivel.Nivel)
);
GameController.g.HudM.EntraCriatures.FinalizarHud();
}
}
public static void EnergiaEVidaCheia(CriatureBase C)
{
Atributos A = C.CaracCriature.meusAtributos;
A.PV.Corrente = A.PV.Maximo;
A.PE.Corrente = A.PE.Maximo;
}
public void SetarCriature(CriatureBase C, System.Action <int> ao, bool armagedom = false)
{
this.armagedom = armagedom;
Acao += ao;
Atributos A = C.CaracCriature.meusAtributos;
imgDoCriature.texture = GameController.g.El.RetornaMini(C.NomeID);
nomeCriature.text = C.NomeEmLinguas;
txtNivelNum.text = C.CaracCriature.mNivel.Nivel.ToString();
txtPVnum.text = A.PV.Corrente + " / " + A.PV.Maximo;
txtPEnum.text = A.PE.Corrente + " / " + A.PE.Maximo;
txtListaDeStatus.text = "";
if (A.PV.Corrente <= 0)
{
Text[] txtS = GetComponentsInChildren <Text>();
for (int i = 1; i < txtS.Length - 2; i++)
{
txtS[i].color = Color.gray;
}
txtS[0].color = new Color(1, 1, 0.75f);
txtListaDeStatus.text = "derrotado";
}
else
{
txtListaDeStatus.text = "preparado";
}
}
protected override void EscolhiEmQuemUsar(int indice)
{
indiceDoEscolhido = indice;
CriatureBase C = GameController.g.Manager.Dados.CriaturesAtivos[indice];
Atributos A = C.CaracCriature.meusAtributos;
Usara usara = VerificaUso(C);
if (usara.diferenteDeNulo && !usara.jaTem || A.PV.Corrente <= 0)
{
if (C.GerenteDeGolpes.meusGolpes.Count >= 4 && A.PV.Corrente > 0)
{
VerificaQualEsquecer(C, UsarOuNaoUsarMenu);
GameController.g.HudM.P_EscolheUsoDeItens.gameObject.SetActive(false);
GameController.g.HudM.MenuDePause.EsconderPainelDeItens();
}
else
{
EscolhiEmQuemUsar(indice, A.PV.Corrente > 0, true);
}
}
else if (!usara.diferenteDeNulo)
{
MensDeUsoDeItem.MensNaoPodeAprenderGolpe(NomeBasico, C.NomeEmLinguas);
}
else if (usara.jaTem)
{
MensDeUsoDeItem.MensjaConheceGolpe(C.NomeEmLinguas, NomeEmLinguas(ID), GolpeBase.NomeEmLinguas(GolpePorAprender(C)));
}
}
public static void AplicacaoDoItemComMenu(CharacterManager manager, CriatureBase C, int valor, System.Action umaAcao)
{
/*
* Atributos A = C.CaracCriature.meusAtributos;
*
* switch (Q)
* {
* case TipoQuantitativo.PV:
* RecuperaPV(A, valor);
* break;
* case TipoQuantitativo.PE:
* RecuperaPE(A, valor);
* break;
* case TipoQuantitativo.perfeicao:
* CriatureBase.EnergiaEVidaCheia(C);
* break;
* }*/
PainelStatus ps = GameController.g.HudM.P_EscolheUsoDeItens;
GameController.g.HudM.AtualizaDadosDaHudVida(false);
GameController.g.StartCoroutine(
ParticulaDeCoisasBoas.ParticulasMaisBotao(ps.GetComponent <RectTransform>(),
() =>
{
ps.ReligarMeusBotoes();
umaAcao();
})
);
ps.DesligarMeusBotoes();
ps.BtnMeuOutro(manager.Dados.CriaturesAtivos.IndexOf(C));
}
void SubstituiArmagedado(int indice)
{
GameController g = GameController.g;
DadosDoPersonagem dados = g.Manager.Dados;
Debug.Log(indiceDoSubstituido);
CriatureBase temp = dados.CriaturesArmagedados[indiceDoSubstituido];
dados.CriaturesArmagedados[indiceDoSubstituido] = dados.CriaturesAtivos[indice];
dados.CriaturesAtivos[indice] = temp;
Debug.Log(dados.CriaturesAtivos[indice].NomeID + " : " + dados.CriaturesArmagedados[indiceDoSubstituido].NomeID + " : " + temp.NomeID);
tempString = string.Format(frasesDeArmagedom[6], temp.NomeEmLinguas, temp.CaracCriature.mNivel.Nivel,
dados.CriaturesArmagedados[indiceDoSubstituido].NomeEmLinguas,
dados.CriaturesArmagedados[indiceDoSubstituido].CaracCriature.mNivel.Nivel
);
if (indice == 0)
{
dados.CriatureSai = -1;
g.HudM.EntraCriatures.FinalizarHud();
GameController.g.HudM.Painel.EsconderMensagem();
replace = new ReplaceManager(g.Manager, g.Manager.CriatureAtivo.transform, FluxoDeRetorno.armagedom);
fase = fasesDoArmagedom.fazendoUmaTroca;
}
else
{
g.HudM.UmaMensagem.ConstroiPainelUmaMensagem(VoltarDoEntraArmagedado, tempString);
}
}
protected override void AplicaEfeito(CriatureBase C)
{
if (!esqueceu)
{
C.GerenteDeGolpes.meusGolpes.Add(PegaUmGolpeG2.RetornaGolpe(GolpePorAprender(C)));
}
EntraNoModoFinalizacao(C);
}
Usara VerificaUso(CriatureBase C)
{
nomesGolpes golpePorAprender = GolpePorAprender(C);
return(new Usara()
{
diferenteDeNulo = golpePorAprender != nomesGolpes.nulo,
jaTem = C.GerenteDeGolpes.TemEsseGolpe(golpePorAprender)
});
}
void AtualizaDadosDaHudVida(HudVida essaHud, CriatureBase C)
{
Atributos A = C.CaracCriature.meusAtributos;
essaHud.PV.text = A.PV.Corrente + " \t/\t " + A.PV.Maximo;
essaHud.PE.text = A.PE.Corrente + " \t/\t " + A.PE.Maximo;
essaHud.nomeCriature.text = C.NomeID.ToString();
essaHud.nivel.text = C.G_XP.Nivel.ToString();
essaHud.barraDeVida.fillAmount = (float)A.PV.Corrente / A.PV.Maximo;
essaHud.barraDeEnergia.fillAmount = (float)A.PE.Corrente / A.PE.Maximo;
}
public void TodosCriaturesPerfeitos()
{
for (int i = 0; i < CriaturesAtivos.Count; i++)
{
CriatureBase.EnergiaEVidaCheia(CriaturesAtivos[i]);
int num = GameController.g.ContStatus.StatusDoHeroi.Count - 1;
for (int j = num; j >= 0; j--)
{
GameController.g.ContStatus.StatusDoHeroi[j].RetiraComponenteStatus();
}
}
}
public static bool UsaItemDeRecuperacao(CriatureBase meuCriature)
{
Atributos A = meuCriature.CaracCriature.meusAtributos;
if (A.PV.Corrente < A.PV.Maximo && A.PV.Corrente > 0)
{
return(true);
}
else
{
return(false);
}
}
protected override void OpcaoEscolhida(int escolha)
{
GameController g = GameController.g;
CriatureBase C = g.Manager.Dados.CriaturesAtivos[escolha];
nomesGolpes golpePorAprender = GolpePorAprender(C);
indiceDoEscolhido = escolha;
g.HudM.Painel.EsconderMensagem();
/*
* bool foi = false;
* g.HudM.Painel.EsconderMensagem();
*
* if (golpePorAprender != nomesGolpes.nulo)
* foi = true;
*
* bool jaTem = C.GerenteDeGolpes.TemEsseGolpe(golpePorAprender);
*/
Usara usara = VerificaUso(C);
if (usara.diferenteDeNulo && !usara.jaTem)
{
if (C.GerenteDeGolpes.meusGolpes.Count >= 4)
{
VerificaQualEsquecer(C, UsarOuNaoUsar);
}
else
{
base.OpcaoEscolhida(escolha);
}
}
else if (usara.jaTem)
{
g.HudM.UmaMensagem.ConstroiPainelUmaMensagem(() => { Estado = EstadoDeUsoDeItem.finalizaUsaItem; },
string.Format(BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.itens)[4],
C.NomeEmLinguas, NomeEmLinguas(ID), GolpeBase.NomeEmLinguas(golpePorAprender)
)
);
}
else if (!usara.diferenteDeNulo)
{
g.HudM.UmaMensagem.ConstroiPainelUmaMensagem(() => { Estado = EstadoDeUsoDeItem.finalizaUsaItem; },
string.Format(BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.itens)[5],
C.NomeEmLinguas, NomeBasico
)
);
}
g.HudM.Menu_Basico.FinalizarHud();
}
public static void InsereStatusSimples(CreatureManager levou, StatusTemporarioBase S, int numStatus)
{
//int numStatus = StatusTemporarioBase.ContemStatus(TipoStatus.envenenado, C);
CriatureBase C = levou.MeuCriatureBase;
if (numStatus == -1)
{
InserindoNovoStatus(levou, C, S);
}
else
{
DatesForTemporaryStatus d = C.StatusTemporarios[numStatus];
d.Quantificador = Mathf.Max(S.Dados.Quantificador, d.Quantificador + 1);
d.TempoSignificativo += 15f / 14f * S.Dados.TempoSignificativo;
}
}
public static int ContemStatus(TipoStatus esseStatus, CriatureBase X)
{
int retorno = -1;
if (X.StatusTemporarios.Count > 0)
{
foreach (DatesForTemporaryStatus sT in X.StatusTemporarios)
{
if (sT.Tipo == esseStatus)
{
retorno = X.StatusTemporarios.IndexOf(sT);
}
}
}
return(retorno);
}
/*
* public bool SouOMesmoQue(CriatureBase C)
* {
* bool retorno = false;
*
* if (C.NomeID == nome
* &&
* C.CaracCriature.mNivel.Nivel==caracCriature.mNivel.Nivel
* &&
* C.CaracCriature.mNivel.XP == caracCriature.mNivel.XP
* &&
* C.CaracCriature.meusAtributos.PV.Corrente == caracCriature.meusAtributos.PV.Corrente
* &&
* C.CaracCriature.meusAtributos.PV.Maximo == caracCriature.meusAtributos.PV.Maximo
* &&
* C.CaracCriature.meusAtributos.PE.Corrente == caracCriature.meusAtributos.PE.Corrente
* &&
* C.CaracCriature.meusAtributos.PE.Maximo == caracCriature.meusAtributos.PE.Maximo
* )
* retorno = true;
* return retorno;
* }*/
public object Clone()
{
CriatureBase retorno =
new CriatureBase()
{
NomeID = NomeID,
alturaCamera = alturaCamera,
distanciaCamera = distanciaCamera,
alturaCameraLuta = alturaCameraLuta,
distanciaCameraLuta = distanciaCameraLuta,
CaracCriature = new CaracteristicasDeCriature()
{
meusTipos = (NomeTipos[])CaracCriature.meusTipos.Clone(),
distanciaFundamentadora = CaracCriature.distanciaFundamentadora,
meusAtributos =
{
PV = { Taxa = caracCriature.meusAtributos.PV.Taxa },
PE = { Taxa = caracCriature.meusAtributos.PE.Taxa },
Ataque = { Taxa = caracCriature.meusAtributos.Ataque.Taxa },
Defesa = { Taxa = caracCriature.meusAtributos.Defesa.Taxa },
Poder = { Taxa = caracCriature.meusAtributos.Poder.Taxa }
},
contraTipos = caracCriature.contraTipos
},
GerenteDeGolpes = new GerenciadorDeGolpes()
{
listaDeGolpes = gerenteG.listaDeGolpes,
},
Mov = new CaracteristicasDeMovimentacao()
{
velocidadeAndando = mov.velocidadeAndando,
caracPulo = new CaracteristicasDePulo()
{
alturaDoPulo = mov.caracPulo.alturaDoPulo,
tempoMaxPulo = mov.caracPulo.tempoMaxPulo,
velocidadeSubindo = mov.caracPulo.velocidadeSubindo,
velocidadeDescendo = mov.caracPulo.velocidadeDescendo,
velocidadeDuranteOPulo = mov.caracPulo.velocidadeDuranteOPulo,
amortecimentoNaTransicaoDePulo = mov.caracPulo.amortecimentoNaTransicaoDePulo
}
}
};
return(retorno);
}
void VerificaQualEsquecer(CriatureBase C, System.Action <bool> acao)
{
Estado = EstadoDeUsoDeItem.emEspera;
HudManager hudM = GameController.g.HudM;
nomesGolpes nomeDoGolpe = GolpePorAprender(C);
hudM.H_Tenta.Aciona(C, nomeDoGolpe,
string.Format(BancoDeTextos.RetornaFraseDoIdioma(ChaveDeTexto.precisaEsquecer), C.NomeEmLinguas)
, acao);
hudM.Painel.AtivarNovaMens(
string.Format(BancoDeTextos.RetornaFraseDoIdioma(ChaveDeTexto.tentandoAprenderGolpe),
C.NomeEmLinguas,
GolpeBase.NomeEmLinguas(nomeDoGolpe))
, 24
);
hudM.P_Golpe.Aciona(PegaUmGolpeG2.RetornaGolpe(nomeDoGolpe));
}
void UsarOuNaoUsarMenu(bool usou)
{
CriatureBase C = GameController.g.Manager.Dados.CriaturesAtivos[indiceDoEscolhido];
esqueceu = usou;
if (usou)
{
GameController.g.HudM.UmaMensagem.ConstroiPainelUmaMensagem(TrocouComMenu,
string.Format(BancoDeTextos.RetornaFraseDoIdioma(ChaveDeTexto.aprendeuGolpeEsquecendo),
C.NomeEmLinguas,
"",
GolpeBase.NomeEmLinguas(GolpePorAprender(C))));
}
else
{
GameController.g.HudM.UmaMensagem.ConstroiPainelUmaMensagem(DesistiuDeAprenderComMenu,
string.Format(BancoDeTextos.RetornaFraseDoIdioma(ChaveDeTexto.naoAprendeuGolpeNovo),
C.NomeEmLinguas,
GolpeBase.NomeEmLinguas(GolpePorAprender(C))));
}
}
public static void InserindoNovoStatus(
CreatureManager levou,
CriatureBase C,
StatusTemporarioBase S, bool eLoad = false)
{
C.StatusTemporarios.Add(S.Dados);
if (levou != null)
{
if (levou.name == "CriatureAtivo")
{
GameController.g.ContStatus.AdicionaStatusAoHeroi(S);
}
else
{
GameController.g.ContStatus.AdicionaStatusAoInimigo(S);
}
}
else
{
GameController.g.ContStatus.AdicionaStatusAoHeroi(S);
}
}
protected void EscolhiEmQuemUsar(
int indice,
bool vaiUsar,
bool tipoCerto,
int valor = 0,
int corrente = 0,
int maximo = 0,
NomeTipos recuperaDoTipo = NomeTipos.nulo)
{
CharacterManager manager = GameController.g.Manager;
CriatureBase C = manager.Dados.CriaturesAtivos[indice];
if (vaiUsar && tipoCerto)
{
if (Consumivel)
{
RetirarUmItem(manager, this, 1, FluxoDeRetorno.menuHeroi);
}
AcaoDoItemConsumivel(C);
ItemQuantitativo.AplicacaoDoItemComMenu(manager, C, valor, VerificaTemMaisParaUsar);
}
else if (!tipoCerto)
{
MensDeUsoDeItem.MensNaoTemOTipo(recuperaDoTipo.ToString());
}
else if (corrente <= 0)
{
MensDeUsoDeItem.MensDeMorto(C.NomeEmLinguas);
}
else if (corrente >= maximo)
{
MensDeUsoDeItem.MensDeNaoPrecisaDesseItem(C.NomeEmLinguas);
}
}
public AnimaPoseDeCaptura(CriatureBase oCapturado)
{
this.oCapturado = oCapturado;
animator = GameController.g.Manager.GetComponent <Animator>();
DadosDoPersonagem dados = GameController.g.Manager.Dados;
if (dados.CriaturesAtivos.Count < dados.maxCarregaveis)
{
dados.CriaturesAtivos.Add(oCapturado);
foiParaArmagedom = false;
}
else
{
dados.CriaturesArmagedados.Add(oCapturado);
/*
* linhas para encher a vida e retirar status quando o Criature for para o Armagedom
*/
// statusTemporarioBase.limpaStatus(oCapturado, -1);
Atributos A = oCapturado.CaracCriature.meusAtributos;
A.PV.Corrente = A.PV.Maximo;
A.PE.Corrente = A.PE.Maximo;
/**************************************************/
foiParaArmagedom = true;
}
//Trofeus.ProcurarTrofeuDeCriature(oCapturado.NomeID);
animator.SetBool("travar", true);
animator.SetBool("chama", false);
animator.Play("capturou");
}
public CriatureBase(nomesCriatures X, int nivel = 1)
{
CriatureBase Y = personagemG2.RetornaUmCriature(X); //(CriatureBase)(personagemG2.Criatures[X].Clone());
caracCriature = Y.CaracCriature;
gerenteG = Y.GerenteDeGolpes;
mov = Y.Mov;
alturaCamera = Y.alturaCamera;
distanciaCamera = Y.distanciaCamera;
alturaCameraLuta = Y.alturaCameraLuta;
distanciaCameraLuta = Y.distanciaCameraLuta;
nome = X;
if (nivel > 1)
{
caracCriature.IncrementaNivel(nivel);
}
gerenteG.meusGolpes = new List <GolpeBase>();
gerenteG.meusGolpes.AddRange(GolpesAtivos(nivel, gerenteG.listaDeGolpes.ToArray()));
VerificaSomaDeTaxas();
}
public virtual void AcaoDoItemConsumivel(CriatureBase C)
{
throw new System.NotImplementedException();
}
public static bool PrecisaDePerfeicao(CriatureBase meuCriature)
{
return(UsaItemDeRecuperacao(meuCriature) || UsaItemDeEnergia(meuCriature) || meuCriature.StatusTemporarios.Count > 0);
}
protected virtual nomesGolpes GolpePorAprender(CriatureBase C)
{
return(C.GerenteDeGolpes.ProcuraGolpeNaLista(C.NomeID, golpeDoPergaminho[0]).Nome);
}
