public void Test_output_ser_deser()
{
var keychain = Keychain.From_random_seed();
var keyIdSet = keychain.Derive_key_id(1);
var commit = keychain.Commit(5, keyIdSet);
var switchCommit = keychain.Switch_commit(keyIdSet);
var switchCommitHash = SwitchCommitHash.From_switch_commit(switchCommit);
var msg = ProofMessage.Empty();
var proof = keychain.Range_proof(5, keyIdSet, commit, msg);
var outp = new Output {
Features = OutputFeatures.DefaultOutput,
Commit = commit,
SwitchCommitHash = switchCommitHash,
Proof = proof
};
var stream = new MemoryStream();
Ser.Serialize(stream, outp);
Console.WriteLine("-------");
Console.WriteLine(stream.ToArray().AsString());
Console.WriteLine("-------");
stream.Position = 0;
var dout = Ser.Deserialize(stream, new Output());
Assert.Equal(OutputFeatures.DefaultOutput, dout.Features);
Assert.Equal(outp.Commit.Value, dout.Commit.Value);
Assert.Equal(outp.Proof.Proof, dout.Proof.Proof);
}
public void TesteCalculaSubatributosAleatorio()
{
Random rnd = new Random();
calculador = new CalculadorSer();
GeradorSer gerador = new GeradorSer();
Ser ser = gerador.Gerar(rnd);
Assert.IsNotNull(ser.Iniciativa);
Assert.IsNotNull(ser.Destria);
Assert.IsNotNull(ser.Acao);
Assert.IsNotNull(ser.Turno);
Assert.IsNotNull(ser.Instinto);
Assert.IsNotNull(ser.Raciocinio);
Assert.IsNotNull(ser.Subconsciencia);
Assert.IsNotNull(ser.Autocontrole);
Assert.IsNotNull(ser.Altura);
Assert.IsNotNull(ser.Largura);
Assert.IsNotNull(ser.Comprimento);
Assert.IsNotNull(ser.Anatomia);
Assert.IsNotNull(ser.Animo);
Assert.IsNotNull(ser.Movimento);
Assert.IsNotNull(ser.Precisao);
Assert.IsNotNull(ser.Massa);
}
public Ser RemoveModificador(ModSomaNumero mod, Ser ser)
{
PropertyInfo propriedade = ser.GetType().GetProperty(mod.Alvo);
if (propriedade.PropertyType == typeof(int) || propriedade.PropertyType == typeof(decimal) || propriedade.PropertyType == typeof(double))
{
CalculadorNumero calculador = new CalculadorNumero();
if (propriedade.PropertyType == typeof(int))
{
int resultado = 0;
resultado = (int)propriedade.GetValue(ser, null) - (int)mod.Valor;
propriedade.SetValue(ser, resultado);
}
else if (propriedade.PropertyType == typeof(decimal))
{
decimal resultado = 0;
resultado = (decimal)propriedade.GetValue(ser, null) - mod.Valor;
propriedade.SetValue(ser, resultado);
}
else
{
double resultado = 0;
resultado = (double)propriedade.GetValue(ser, null) - decimal.ToDouble(mod.Valor);
propriedade.SetValue(ser, resultado);
}
return(ser);
}
else
{
throw new System.ArgumentException("Propriedade não é um int, decimal ou double.", mod.Alvo);
}
}
public void TesteCalculaKarma()
{
calculador = new CalculadorSer();
List <Especie> especies = new List <Especie>()
{
new Especie()
{
KarmaMin = 1
},
new Especie()
{
KarmaMin = 2
},
new Especie()
{
KarmaMin = 3
},
};
Ser ser = new Ser()
{
Especies = especies,
};
ser.Karma = calculador.CalculaKarma(ser);
Assert.AreEqual(3, ser.Karma);
}
public Ser RemoveModificador(ModZeraNumero mod, Ser ser)
{
PropertyInfo propriedade = ser.GetType().GetProperty(mod.Alvo);
propriedade.SetValue(ser, mod.ValorAnterior);
return(ser);
}
public void TesteNomesGeraSerAleatorio()
{
GeradorSer gerador = new GeradorSer();
Ser ser = gerador.Gerar(rnd);
Assert.IsTrue(ser.Nome.Length > 2);
}
public Ser RemoveModificador(ModAdicionaPericia mod, Ser ser)
{
if (ser.Pericias.Contains(mod.Alvo))
{
ser.Pericias.Remove(mod.Alvo);
}
return(ser);
}
//ModRemovePericia
public Ser AplicaModificador(ModRemovePericia mod, Ser ser)
{
if (ser.Pericias.Contains(mod.Alvo))
{
ser.Pericias.Remove(mod.Alvo);
}
return(ser);
}
public Ser RemoveModificador(ModRemovePericia mod, Ser ser)
{
if (!ser.Pericias.Contains(mod.Alvo))
{
ser.Pericias.Add(mod.Alvo);
}
return(ser);
}
//ModAdicionaPericia
public Ser AplicaModificador(ModAdicionaPericia mod, Ser ser)
{
if (!ser.Pericias.Contains(mod.Alvo))
{
ser.Pericias.Add(mod.Alvo);
}
return(ser);
}
//ModZeraNumero
public Ser AplicaModificador(ModZeraNumero mod, Ser ser)
{
PropertyInfo propriedade = ser.GetType().GetProperty(mod.Alvo);
mod.ValorAnterior = (decimal)propriedade.GetValue(ser);
propriedade.SetValue(ser, 0);
return(ser);
}
//Magnitude média dos atributos
//Pega magnitude do Rei se for maior que a média dos atributos
public int CalculaMagnitude(Ser ser)
{
int magTotal = ser.Forca.Porcentagem.Magnitude + ser.Destreza.Porcentagem.Magnitude + ser.Materia.Porcentagem.Magnitude + ser.Intelecto.Porcentagem.Magnitude + ser.Criatividade.Porcentagem.Magnitude + ser.Ideia.Porcentagem.Magnitude + ser.Existencia.Porcentagem.Magnitude;
magTotal = magTotal / 7;
return(magTotal);
}
public List <Energia> CriaListaEnergias(Ser ser)
{
List <Energia> resultado = new List <Energia>();
List <string> siglas = new List <string>();
foreach (Especie especie in ser.Especies)
{
foreach (Energia energia in especie.Energias)
{
//Só adiciona a energia se ela não for repetida (verificada pela sigla)
siglas = (from e in resultado select e.Sigla).ToList <string>();;
if (!siglas.Contains(energia.Sigla))
{
resultado.Add(new Energia(energia.Sigla));
}
}
}
//Energias: "AP", "CP", "EP", "HP", "MP", "QP", "SP", "PE", "PA";
foreach (Energia energia in resultado)
{
foreach (Especie especie in ser.Especies)
{
//Soma todas as quantidades das energias dentro de cada uma das espécies do ser
//Ex: pega todos os APs de todas as espécies e soma
energia.Quantidade = energia.Quantidade + (from e in especie.Energias where e.Sigla.Equals(energia.Sigla) select e).Sum(e => e.Quantidade);
}
switch (energia.Sigla)
{
case "AP":
energia.Quantidade = energia.Quantidade + Convert.ToDecimal(ser.BonusCP);
break;
case "HP":
energia.Quantidade = energia.Quantidade + Convert.ToDecimal(ser.BonusHP.ValorReal);
break;
case "MP":
energia.Quantidade = ser.Ki * (energia.Quantidade + Convert.ToDecimal(ser.BonusMP.ValorReal));
break;
case "SP":
energia.Quantidade = energia.Quantidade + ser.BonusSP;
break;
//Axé
case "XP":
energia.Quantidade = ser.Reis.Count * energia.Quantidade;
break;
default:
break;
}
energia.Quantidade = energia.Quantidade * ser.Nivel;
}
return(resultado);
}
private void Subser_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if ((sender as ListPicker).SelectedItem != ff)
{
SerId = ((sender as ListPicker).SelectedItem as Service).Id;
Ser.SelectedItem = ff1;
Ser.UpdateLayout();
}
}
//ModRemoveHabilidade
public Ser AplicaModificador(ModRemoveHabilidade mod, Ser ser)
{
if (ser.Habilidades.Contains(mod.Alvo))
{
ser.Habilidades.Remove(mod.Alvo);
}
return(ser);
}
public Ser RemoveModificador(ModAdicionaHabilidade mod, Ser ser)
{
if (ser.Habilidades.Contains(mod.Alvo))
{
ser.Habilidades.Remove(mod.Alvo);
}
return(ser);
}
//ModAdicionaHabilidade
public Ser AplicaModificador(ModAdicionaHabilidade modificador, Ser ser)
{
if (!ser.Habilidades.Contains(modificador.Alvo))
{
ser.Habilidades.Add(modificador.Alvo);
}
return(ser);
}
public Ser RemoveModificador(ModRemoveHabilidade mod, Ser ser)
{
if (!ser.Habilidades.Contains(mod.Alvo))
{
ser.Habilidades.Add(mod.Alvo);
}
return(ser);
}
public static void issue_burn_tx(
WalletConfig config,
Keychain keychain,
ulong amount,
ulong minimumConfirmations,
uint maxOutputs
)
{
keychain = Keychain.Burn_enabled(keychain, Identifier.Zero());
var chainTip = Checker.get_tip_from_node(config);
var currentHeight = chainTip.Height;
var _ = Checker.refresh_outputs(config, keychain);
var keyId = keychain.Root_key_id();
// select some spendable coins from the walvar
var coins = WalletData.Read_wallet(
config.DataFileDir, walletData => walletData.Select(
keyId.Clone(),
amount,
currentHeight,
minimumConfirmations,
maxOutputs,
false));
Log.Debug("selected some coins - {}", coins.Length);
var(partsArray, _) = inputs_and_change(coins, config, keychain, amount);
var parts = partsArray.ToList();
// add burn output and fees
var fee = Types.tx_fee((uint)coins.Length, 2, null);
parts.Add(c => c.Output(amount - fee, Identifier.Zero()));
// finalize the burn transaction and send
var(txBurn, _) = Build.Transaction(parts.ToArray(), keychain);
txBurn.Validate(keychain.Secp);
var txHex = HexUtil.to_hex(Ser.Ser_vec(txBurn));
var url = $"{config.CheckNodeApiHttpAddr}/v1/pool/push";
var json = JsonConvert.SerializeObject(new TxWrapper {
TxHex = txHex
});
var res = ApiClient.PostContentAsync(url, new StringContent(json, Encoding.UTF8, "application/json")).Result;
Log.Debug("{StatusCode}", res.StatusCode);
}
public Ser CalculaExperiencia(Ser ser)
{
//Pontos de Graduação (G) = 10^Magnitude do Personagem
//Pontos de Evolução (En) = Nivel * G
//Experiência Total (XPn) = (G*(nivel^2 - nivel)) / 2
ser.PontosGraduacao = (decimal)Math.Floor(Math.Pow(10, ser.Magnitude));
ser.PontosEvolucao = Math.Floor(ser.Nivel * (Decimal)(ser.PontosGraduacao));
ser.ExperienciaAtual = Math.Floor((ser.PontosGraduacao * ((decimal)Math.Pow(ser.Nivel, 2) - ser.Nivel)) / 2);
return(ser);
}
private void SaveAppSetting()
{
MemoryStream memoryStream = new MemoryStream();
Ser.WriteObject(memoryStream, Settings);
using (FileStream fileStream = File.Create(AppSettingPath))
{
memoryStream.Position = 0;
memoryStream.CopyTo(fileStream);
}
}
public void Simple_tx_ser()
{
var tx = Tx2I1O();
using (var vec = new MemoryStream())
{
Ser.Serialize(vec, tx);
Console.WriteLine(vec.Length);
Assert.True(vec.Length > 5360);
Assert.True(vec.Length < 5380);
}
}
void client_getSubServiceCompleted(object sender, getSubServiceCompletedEventArgs e)
{
List <Service> ss = e.Result.ToList();
// Ser.ItemsSource = e.Result;
ff1 = new Service();
ff1.Name = " ";
ss.Add(ff1);
Ser.ItemsSource = ss;
Ser.SelectedItem = ff1;
Ser.UpdateLayout();
IsInitSer = true;
}
/// Builds a PartialTx from data sent by a sender (not yet completed by the receiver).
public static PartialTx build_partial_tx(
ulong receiveAmount,
BlindingFactor blindSum,
Transaction transaction
)
{
return(new PartialTx
{
Amount = receiveAmount,
BlindSum = HexUtil.to_hex(blindSum.Key.Value),
Tx = HexUtil.to_hex(Ser.Ser_vec(transaction))
});
}
private List <Deslocamento> CalculaDeslocamentosBase(Ser ser)
{
List <Deslocamento> resultado = new List <Deslocamento>();
//Solo
resultado.Add(CalculaDesolocamentoSolo(ser));
//Ar
resultado.Add(CalculaDesolocamentoAr(ser));
//Mar
resultado.Add(CalculaDesolocamentoMar(ser));
//Espaço
resultado.Add(CalculaDesolocamentoEspaco(ser));
return(resultado);
}
public Natureza CalculaNatureza(Ser ser)
{
//Definido a partir da especie
Natureza resultado = new Natureza()
{
Apresentacao = (int)(from e in ser.Especies select e.Natureza.Apresentacao).Max(),
Concepcao = (int)(from e in ser.Especies select e.Natureza.Concepcao).Max(),
Honra = (int)(from e in ser.Especies select e.Natureza.Honra).Max(),
Moral = (int)(from e in ser.Especies select e.Natureza.Moral).Max(),
Percepcao = (int)(from e in ser.Especies select e.Natureza.Percepcao).Max(),
Personalidade = (int)(from e in ser.Especies select e.Natureza.Personalidade).Max()
};
return(resultado);
}
public void TesteCalculaExperiencia()
{
calculador = new CalculadorSer();
Ser ser = new Ser()
{
Magnitude = 2,
Nivel = 25
};
ser = calculador.CalculaExperiencia(ser);
Assert.AreEqual(100, ser.PontosGraduacao);
Assert.AreEqual(2500, ser.PontosEvolucao);
Assert.AreEqual(30000, ser.ExperienciaAtual);
}
//SP = 105*(pontos de todos atributos-7) (somar tracinhos)
private int CalculaBonusSP(Ser ser)
{
int resultado = 0;
resultado = ser.Forca.Pontos + ser.Materia.Pontos + ser.Destreza.Pontos + ser.Criatividade.Pontos + ser.Existencia.Pontos + ser.Ideia.Pontos + ser.Intelecto.Pontos;
resultado = (resultado - 7) * 105;
resultado = resultado + ser.EvolucaoCriatividade.PontosAtuais;
resultado = resultado + ser.EvolucaoDestreza.PontosAtuais;
resultado = resultado + ser.EvolucaoExistencia.PontosAtuais;
resultado = resultado + ser.EvolucaoForca.PontosAtuais;
resultado = resultado + ser.EvolucaoIdeia.PontosAtuais;
resultado = resultado + ser.EvolucaoIntelecto.PontosAtuais;
resultado = resultado + ser.EvolucaoMateria.PontosAtuais;
return(resultado);
}
public Ser CalculaSer(Ser ser)
{
//TODO: Calcular experiencia
//Carisma e Destino - A partir da Índole escolhida
ser.Carisma = ser.Indole.Carisma;
ser.Destino = ser.Indole.Destino;
//Especial - O maior especial das raças do ser
ser.Especial = CalculaEspecial(ser.Especies);
//Deslocamentos
ser.Deslocamentos = CalculaDeslocamentosBase(ser);
//Pericias
ser.Pericias = CriaListaPericiasSer(ser);
//Habilidades
ser.Habilidades = CriaListaHabilidades(ser);
//Cansaço
ser.CansacoMax = CalculaCansaco(ser);
//Natureza
ser.Natureza = CalculaNatureza(ser);
//Fé e Karma
ser.Fe = CalculaFe(ser);
ser.Karma = CalculaKarma(ser);
//Subatributos
ser = CalculaSubatributos(ser);
//Ira, FV, PS
ser.Ira = (from e in ser.Especies select e.IraMin).Max();
ser.ForcaVontade = (from e in ser.Especies select e.ForcaVontadeMin).Max();
ser.PoderMaximo = (from e in ser.Especies select e.PoderMaximoMax).Max();
//Resposta
ser.Resposta = CalculaResposta(ser);
//Fugacidade
ser.Fugacidade = CalculaFugacidade(ser);
//Deslocamento
ser.Deslocamentos = CalculaDeslocamentosBase(ser);
//Modificadores
ser.ModificadoresAtivos = ListaModificadoresAtivos(ser);
//Magnitude
ser.Magnitude = CalculaMagnitude(ser);
//Energias
ser.Energias = CriaListaEnergias(ser);
//Experiência
ser = CalculaExperiencia(ser);
//TODO: Ativar modificadores
return(ser);
}
public List <Modificador> ListaModificadoresAtivos(Ser ser)
{
List <Modificador> resultado = new List <Modificador>();
//Pericias
//Itens / Equips / Posses
//Virtudes
//Defeitos
//Reis
foreach (Pericia pericia in ser.Pericias)
{
if (pericia.Modificadores != null)
{
resultado.AddRange(pericia.Modificadores);
}
}
foreach (Item item in ser.Equipamentos)
{
if (item.Modificadores != null)
{
resultado.AddRange(item.Modificadores);
}
}
foreach (Item item in ser.Posses)
{
if (item.Modificadores != null)
{
resultado.AddRange(item.Modificadores);
}
}
foreach (Rei rei in ser.Reis)
{
if (rei.Modificadores != null)
{
resultado.AddRange(rei.Modificadores);
}
}
resultado.AddRange(ser.Dons);
resultado.AddRange(ser.Defeitos);
return(resultado);
}
