void Start()
{
gerente = GetComponent <CreatureManager>();
ParaliseNoTempo();
esseGolpe.IniciaGolpe(gameObject);
tempoDecorrido -= GolpePersonagem.RetornaGolpePersonagem(gameObject, esseGolpe.Nome).TempoDeInstancia;
}
public static void CreateRenderingData(
CreatureManager creature_manager,
ref Vector3[] vertices,
ref Vector3[] normals,
ref Vector4[] tangents,
ref Color32[] colors,
ref Vector2[] uvs,
ref int[] triangles,
ref List <int> final_indices,
CreatureMeshModifier mesh_modifier = null)
{
if (mesh_modifier != null)
{
vertices = new Vector3[mesh_modifier.num_pts];
normals = new Vector3[mesh_modifier.num_pts];
tangents = new Vector4[mesh_modifier.num_pts];
colors = new Color32[mesh_modifier.num_pts];
uvs = new Vector2[mesh_modifier.num_pts];
triangles = new int[mesh_modifier.m_maxIndice];
final_indices = new List <int>(new int[mesh_modifier.m_maxIndice]);
}
else
{
vertices = new Vector3[creature_manager.target_creature.total_num_pts];
normals = new Vector3[creature_manager.target_creature.total_num_pts];
tangents = new Vector4[creature_manager.target_creature.total_num_pts];
colors = new Color32[creature_manager.target_creature.total_num_pts];
uvs = new Vector2[creature_manager.target_creature.total_num_pts];
triangles = new int[creature_manager.target_creature.total_num_indices];
final_indices = new List <int>(new int[creature_manager.target_creature.total_num_indices]);
}
}
public override void initData(CreatureManager creature_manager, CreatureAsset creature_asset)
{
var cur_char = creature_manager.GetCreature();
m_isValid = false;
m_numIndices = cur_char.total_num_indices;
}
// Use this for initialization
void Start()
{
_behaviour = this.GetComponent <CreatureManager>();
_gameState = GameState.Scanning;
StartPositionMarker.SetActive(false);
EndPositionMarker.SetActive(false);
_gestureRecognizer = new UnityEngine.XR.WSA.Input.GestureRecognizer();
_gestureRecognizer.SetRecognizableGestures(UnityEngine.XR.WSA.Input.GestureSettings.Tap);
_gestureRecognizer.TappedEvent += _gestureRecognizer_TappedEvent;
SpatialMappingManager.Instance.StartObserver();
if (Testing)
{
StartPositionMarker.SetActive(true);
EndPositionMarker.SetActive(true);
StartPositionMarker.transform.position = new Vector3(0, 0, 1);
EndPositionMarker.transform.position = new Vector3(0, 0, 0);
_scanTime = 0.0f;
_gameState = GameState.StartPlaying;
}
}
public override void OnDrawGizmos()
{
Gizmos.color = Color.yellow;
Gizmos.DrawLine(boid.transform.position, boid.transform.position + (force));
CreatureManager.Log("Theta" + theta);
CreatureManager.Log("Force" + force);
}
static void CalculaDano(CreatureManager doAtacado, GameObject atacante, IGolpeBase golpe)
{
float multiplicador = 1;
for (int i = 0; i < doAtacado.MeuCriatureBase.CaracCriature.contraTipos.Length; i++)
{
if (golpe.Tipo.ToString() == doAtacado.MeuCriatureBase.CaracCriature.contraTipos[i].Nome)
{
multiplicador *= doAtacado.MeuCriatureBase.CaracCriature.contraTipos[i].Mod;
}
}
CriatureBase cDoAtacante = atacante.GetComponent <CreatureManager>().MeuCriatureBase;
Atributos A = cDoAtacante.CaracCriature.meusAtributos;
int potenciaDoAtacante = (golpe.Caracteristica == caracGolpe.colisao)
?
Mathf.RoundToInt(A.Ataque.Minimo + (A.Ataque.Corrente - A.Ataque.Minimo) * Random.Range(0.85f, 1))
:
Mathf.RoundToInt(A.Poder.Minimo + (A.Poder.Corrente - A.Poder.Minimo) * Random.Range(0.85f, 1));
GolpePersonagem golpePersonagem = cDoAtacante.GerenteDeGolpes.ProcuraGolpeNaLista(cDoAtacante.NomeID, golpe.Nome);
CalculoC(multiplicador, golpe, golpePersonagem, potenciaDoAtacante, doAtacado, cDoAtacante);
}
public ApresentaDerrota(CharacterManager manager, CreatureManager inimigoDerrotado)
{
this.manager = manager;
this.inimigoDerrotado = inimigoDerrotado;
textos = BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.apresentaDerrota).ToArray();
fase = FaseDaDerrota.abreMensagem;
}
void OnTriggerEnter(Collider col)
{
if (col.gameObject.tag == "Player" && !GameController.g.MyKeys.VerificaAutoShift(chave))
{
cm = InsereInimigoEmCampo.RetornaInimigoEmCampo(C);
if (golpeDeInspector)
{
for (int i = 0; i < C.GerenteDeGolpes.meusGolpes.Count; i++)
{
cm.MeuCriatureBase.GerenteDeGolpes.meusGolpes[i] = PegaUmGolpeG2.RetornaGolpe(C.GerenteDeGolpes.meusGolpes[i].Nome);
}
}
if (pvDeInspector)
{
cm.MeuCriatureBase.CaracCriature.meusAtributos.PV.Maximo = C.CaracCriature.meusAtributos.PV.Maximo;
cm.MeuCriatureBase.CaracCriature.meusAtributos.PV.Corrente = C.CaracCriature.meusAtributos.PV.Corrente;
}
GameController.g.EncontroAgoraCom(cm);
tutorManager.IniciouLuta(cm, this);
}
else if (GameController.g.MyKeys.VerificaAutoShift(chave))
{
gameObject.SetActive(false);
}
}
public static void AoHeroi(CharacterManager manager /*,bool retornaCamera = true*/)
{
AplicadorDeCamera.cam.FocarBasica(manager.transform, 3, 7);
CreatureManager C = manager.CriatureAtivo;
if (C != null)
{
C.Estado = CreatureManager.CreatureState.seguindo;
if (C.GetComponent <UnityEngine.AI.NavMeshAgent>())
{
C.GetComponent <UnityEngine.AI.NavMeshAgent>().enabled = true;
}
}
manager.Estado = EstadoDePersonagem.aPasseio;
if (GameController.g.MyKeys.VerificaAutoShift(KeyShift.estouNoTuto))
{
GameController.g.HudM.ModoHeroi();
}
else
{
GameController.g.HudM.ModoLimpo();
}
}
void Awake()
{
instance = this;
chunkManager = new ChunkManager();
creatureManager = new CreatureManager();
}
public World()
{
instance = this;
creatureManager = new CreatureManager();
chunkManager = new ChunkManager();
}
void FillAnimationNames()
{
CreatureAsset creature_asset = (CreatureAsset)target;
CreatureManager creature_manager = creature_asset.GetCreatureManager();
if (creature_manager == null)
{
return;
}
Dictionary <string, CreatureModule.CreatureAnimation> all_animations
= creature_manager.animations;
animation_names.Clear();
foreach (string cur_name in all_animations.Keys)
{
animation_names.Add(cur_name);
}
animation_clip_overrides = creature_asset.animation_clip_overides;
if (animation_clip_overrides.Count == 0)
{
foreach (string cur_name in all_animations.Keys)
{
var cur_animation = all_animations[cur_name];
animation_clip_overrides.Add(cur_name,
new CreatureAnimationAssetData((int)cur_animation.start_time,
(int)cur_animation.end_time));
}
}
}
public Chromosome(int chromosome, GenomeManager thisGenome, CreatureManager hManager)
{
genes = new Gene[GlobalGEPSettings.CHROMOSOME_LENGTH];
genome = thisGenome;
chromosomeNumber = chromosome;
GenerateChromosome(hManager.generator);
}
public void AoCriature(CreatureManager inimigo = null)
{
estado = EstadoDePersonagem.comMeuCriature;
criatureAtivo = GameObject.Find("CriatureAtivo").GetComponent <CreatureManager>();
////GameController.g.HudM.Btns.BotoesDoCriature(this);
MbAlternancia.AoCriature(criatureAtivo, inimigo);
}
static void VerificaVida(GameObject atacante, CreatureManager doAtacado, Animator a)
{
if (doAtacado.MeuCriatureBase.CaracCriature.meusAtributos.PV.Corrente <= 0)
{
a.SetBool("cair", true);
UnityEngine.AI.NavMeshAgent nav = a.GetComponent <UnityEngine.AI.NavMeshAgent>();
if (nav.enabled)
{
nav.Stop();// nav.isStopped = true;
}
/* doAtacado.MudaParaDerrotado();
*
* if (!doAtacado.gerenteCri)
* {
* AplicaSelvagemDerrotado aSD = doAtacado.gameObject.AddComponent<AplicaSelvagemDerrotado>();
* aSD.oDerrotado = doAtacado;
* aSD.oQDerrotou = atacante.GetComponent<GerenciadorDeCriature>();
*
* }
* else
* {
* //Morte de um criature selvagem
* }
*/
}
}
public static void EnableSkinSwap(
String swap_name_in,
bool active,
CreatureManager creature_manager,
CreatureAsset creature_asset,
ref bool skin_swap_active,
ref string skin_swap_name,
ref int[] skin_swap_triangles,
ref List <int> final_skin_swap_indices)
{
skin_swap_active = active;
if (!skin_swap_active)
{
skin_swap_name = "";
skin_swap_triangles = null;
final_skin_swap_indices = null;
}
else
{
skin_swap_name = swap_name_in;
if (creature_asset.creature_meta_data != null)
{
final_skin_swap_indices = new List <int>();
creature_asset.creature_meta_data.buildSkinSwapIndices(
skin_swap_name,
creature_manager.GetCreature().render_composition,
final_skin_swap_indices);
skin_swap_triangles = new int[final_skin_swap_indices.Count];
}
}
}
/// <summary>
///CreatureManager`1 构造函数 的测试
///</summary>
public void CreatureManagerConstructorTest1Helper <T>()
where T : BaseCreature
{
CreatureManager <T> target = new CreatureManager <T>();
Assert.Inconclusive("TODO: 实现用来验证目标的代码");
}
public static CreatureManager RetornaInimigoEmCampo(encontravel encontrado, CharacterManager manager)
{
Debug.Log(encontrado.nome);
GameObject M = elementosDoJogo.el.criature(encontrado.nome.ToString());
Transform doCriatureAtivo = manager.CriatureAtivo.transform;
Vector3 instancia = doCriatureAtivo.position + 10 * doCriatureAtivo.forward;
Debug.Log(M);
/*
* RaycastHit hit = new RaycastHit ();
* if(Physics.Linecast(posHeroi,posHeroi+10*tHeroi.forward,out hit))
* {
* instancia = hit.point+Vector3.up;
* }
*/
melhoraPos melhoraPF = new melhoraPos();
instancia = melhoraPF.posEmparedado(instancia, doCriatureAtivo.position);
instancia = melhoraPF.novaPos(instancia, M.transform.lossyScale.y);
GameObject InimigoX = MonoBehaviour.Instantiate(M, instancia, Quaternion.identity) as GameObject;
int nivel = Random.Range(encontrado.nivelMin, encontrado.nivelMax);
CreatureManager retorno = InimigoX.GetComponent <CreatureManager>();
retorno.MeuCriatureBase
= new CriatureBase(encontrado.nome, nivel);
retorno.IA = new IA_Agressiva();
retorno.IA.Start(retorno);
retorno.Estado = CreatureManager.CreatureState.selvagem;
return(retorno);
}
public RGBColourTrait(string trait, int id, Gene gene, string abbreviation, CreatureManager hManager) : base(id, gene, abbreviation)
{
traitName = trait + " " + id;
switch (id)
{
case 0:
traitName += " Red";
rgb = "red";
break;
case 1:
traitName += " Green";
rgb = "green";
break;
case 2:
traitName += " Blue";
rgb = "blue";
break;
}
traitID = abbreviation + id;
rawID = id;
EvaluateGene(gene, hManager);
}
public void ResetState()
{
creatureJSON = null;
compressedCreatureJSON = null;
creature_manager = null;
is_dirty = false;
}
private void EvaluateColour(List <Trait> traits, CreatureManager hManager)
{
float r = 0.0f, g = 0.0f, b = 0.0f;
for (int i = 0; i < traits.Count; i++)
{
RGBColourTrait trait = (RGBColourTrait)traits[i];
trait.EvaluateGene(trait.attachedToGene, hManager);
switch (trait.rgb.ToLower())
{
case "red":
r = traits[i].numericValue;
break;
case "green":
g = traits[i].numericValue;
break;
case "blue":
b = traits[i].numericValue;
break;
}
}
}
public void CreateBendPhysics(string anim_clip)
{
if (bend_physics_data != null)
{
bend_physics_data.clearPhysicsChain();
bend_physics_data = null;
}
CreatureManager cur_manager = creature_renderer.creature_manager;
if (physics_container != null)
{
Destroy(physics_container);
}
cur_manager.RunAtTime(cur_manager.GetActiveAnimationStartTime());
physics_container = new GameObject("CreaturePhysicsContainer");
bend_physics_data =
CreatureModule.CreaturePhysicsData.PhysicsUtil.CreateBendPhysicsChain(
physics_container,
creature_renderer.gameObject,
cur_manager.GetCreature().render_composition,
anim_clip,
creature_renderer.creature_asset.physics_assets);
}
protected void IniciaUsoDesseItem(GameObject dono, bool podeUsar, bool temTipo = true, NomeTipos nomeDoTipo = NomeTipos.nulo)
{
Manager = GameController.g.Manager;
CriatureAlvoDoItem = Manager.CriatureAtivo;
if (podeUsar && temTipo && RetirarUmItem(Manager, this, 1))
{
GameController.g.HudM.ModoCriature(false);
InicializacaoComum(dono, Manager.CriatureAtivo.transform);
Estado = EstadoDeUsoDeItem.animandoBraco;
}
else
{
Estado = EstadoDeUsoDeItem.finalizaUsaItem;
if (!temTipo)
{
GameController.g.HudM.Painel.AtivarNovaMens(string.Format(
BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.itens)[3], nomeDoTipo), 30, 5);
}
else if (!podeUsar)
{
GameController.g.HudM.Painel.AtivarNovaMens(string.Format(
BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.mensLuta)[2],
CriatureAlvoDoItem.MeuCriatureBase.NomeEmLinguas), 30, 5);
}
}
}
void Awake()
{
instance = this;
style.fontSize = 18;
style.normal.textColor = Color.white;
DontDestroyOnLoad(this);
Cursor.visible = false;
}
public static void InsereCriatureEmJogo(GameObject G, CharacterManager este, bool aplicarComandos = false)
{
G.name = "CriatureAtivo";
CreatureManager C = G.GetComponent <CreatureManager>();
C.TDono = este.transform;
C.MeuCriatureBase = este.Dados.CriaturesAtivos[0];
}
void Init()
{
CreatureManager.Init();
CreatureManager._Wolf = GameData.instance._Wolf;
CreatureManager._Sheep = GameData.instance._Sheep;
CreatureManager.Create(ECreatureSpecies.Wolf, new Vector3(Random.value * 25f, 0.5f, Random.value * 25f));
CreatureManager.Create(ECreatureSpecies.Sheep, new Vector3(Random.value * 25f, 0.5f, Random.value * 25f));
}
public frmAddEditCreature(CreatureManager creatureMgr, CreatureTypeManager creatureTMgr, CreatureDietManager creatureDMgr)
{
this._type = CreatureForm.Add;
this._creatureManager = creatureMgr;
this._creatureTypeManager = creatureTMgr;
this._creatureDietManager = creatureDMgr;
InitializeComponent();
}
public static void InsereEstouEmDano(CreatureManager doAtacado, Animator animatorDoAtacado, IGolpeBase golpe)
{
EstouEmDano eED = doAtacado.gameObject.AddComponent <EstouEmDano>();
eED.esseGolpe = golpe;
eED.animator = animatorDoAtacado;
eED.gerente = doAtacado;
}
/// <summary>
///CreatureManager`1 构造函数 的测试
///</summary>
public void CreatureManagerConstructorTestHelper <T>()
where T : BaseCreature
{
int iCapacity = 0; // TODO: 初始化为适当的值
CreatureManager <T> target = new CreatureManager <T>(iCapacity);
Assert.Inconclusive("TODO: 实现用来验证目标的代码");
}
public Renderer(GraphicsDevice device,
CreatureManager manager_in,
ref Texture2D texture_in)
{
creature_manager = manager_in;
renderTexture = texture_in;
CreateRenderingData(device);
}
public void InitData()
{
if (creature_renderer) {
// init the render data
CreatureManager ref_manager = creature_renderer.creature_asset.GetCreatureManager();
creature_manager = new CreatureManager(ref_manager.target_creature);
creature_manager.animations = ref_manager.animations;
var target_creature = creature_manager.target_creature;
MeshBoneUtil.MeshRenderBoneComposition render_composition =
target_creature.render_composition;
var regions_map = render_composition.getRegionsMap ();
if (regions_map.ContainsKey (switch_region) == false) {
return;
}
var cur_region = regions_map [switch_region];
int uv_index = cur_region.getStartPtIndex() * 2;
var global_uvs = target_creature.global_uvs;
switch_min_uv = new Vector2(global_uvs[uv_index], global_uvs[uv_index + 1]);
switch_max_uv = new Vector2(switch_min_uv.x, switch_min_uv.y);
for(int i = 0; i < cur_region.getNumPts(); i++) {
float cur_u = global_uvs[uv_index];
float cur_v = global_uvs[uv_index + 1];
if(cur_u < switch_min_uv.x) {
switch_min_uv.x = cur_u;
}
else if(cur_u > switch_max_uv.x) {
switch_max_uv.x = cur_u;
}
if(cur_v < switch_min_uv.y) {
switch_min_uv.y = cur_v;
}
else if(cur_v > switch_max_uv.y) {
switch_max_uv.y = cur_v;
}
uv_index += 2;
}
List<int> render_indices = creature_manager.target_creature.global_indices;
min_indice = render_indices[cur_region.getStartIndex()];
for(int i = 0; i < cur_region.getNumIndices(); i++) {
int cur_indice = render_indices[cur_region.getStartIndex() + i];
if(cur_indice < min_indice)
{
min_indice = cur_indice;
}
}
}
}
public void InitData()
{
if (creature_asset) {
CreatureManager ref_manager = creature_asset.GetCreatureManager();
creature_manager = new CreatureManager(ref_manager.target_creature);
creature_manager.animations = ref_manager.animations;
creature_manager.active_blend_run_times = new Dictionary<string, float>(ref_manager.active_blend_run_times);
creature_manager.active_blend_animation_names = new List<string>(ref_manager.active_blend_animation_names);
creature_manager.auto_blend_names = new List<string>(ref_manager.auto_blend_names);
SetActiveAnimation(active_animation_name);
creature_manager.SetIsPlaying(true);
}
}
