//TODO: IDEA: Make debug menu to set the position of the model through the view to make it easier to debug through the editor
protected override void OnViewReady()
{
ViewDeltaTransform = new EntityTransform();
ViewDeltaTransform.Scale = Vector3.zero;
SelfModel = MVCUtil.GetModel <EntityModel>(this);
}
public EntityTransform GetTransformPosition(EEntityTransform launchPos)
{
EntityTransform anyEntity = null;
foreach (EntityTransform entityTransform in m_entityTranforms)
{
if (anyEntity == null)
{
anyEntity = entityTransform;
}
if (entityTransform.EntityTransformType == launchPos)
{
return(entityTransform);
}
}
//If the character doesnt have any entityTransform we create one
if (anyEntity == null)
{
GameObject objToSpawn = new GameObject("Center");
anyEntity = objToSpawn.AddComponent <EntityTransform>();
anyEntity.EntityTransformType = EEntityTransform.Center;
objToSpawn.transform.SetParent(transform);
objToSpawn.transform.localPosition = new Vector3(0, 0.4f, 0);
}
return(anyEntity);
}
public void RpcSpawnImpactParticle(string prefabName, int transformPos)
{
EntityTransform entityTransform = m_mobaEntity.GetTransformPosition((EEntityTransform)transformPos);
GameObject particle = SpawnManager.instance.InstantiatePool(prefabName, entityTransform.transform.position, entityTransform.transform.rotation);
particle.transform.SetParent(entityTransform.transform);
}
/// <summary>
/// Get the entity transformation for the entity with the given ID.
/// </summary>
/// <returns></returns>
public EntityTransform GetEntityTransform(string id, Transform initial)
{
// NB: if no ID is specified, do not persist state.
if (id != null && id != "")
{
var found = EntityTransforms.Find(state => state.Id == id);
if (found != null && !found.UseOriginalPosition)
{
return(found);
}
}
EntityTransform newState = new EntityTransform
{
Id = id,
InitialPosition = initial.position,
Position = initial.position,
InitialRotation = initial.rotation,
Rotation = initial.rotation,
};
EntityTransforms.Add(newState);
return(newState);
}
private IList <ExplodeData> ToExplodeData(EntityTransform entityTransform)
{
List <ExplodeData> remoteMeshes = new List <ExplodeData>();
ToExplodeDataImpl(entityTransform, remoteMeshes);
return(remoteMeshes);
}
public void RpcSpawnDeathParticle()
{
m_deathParticle = SpawnManager.instance.InstantiatePool(DeathParticlePrefab, Vector3.zero, Quaternion.identity);
EntityTransform canvasTrasnform = GetTransformPosition(DeathParticlePosition);
m_deathParticle.transform.SetParent(canvasTrasnform.transform);
m_deathParticle.transform.localPosition = Vector3.zero;
}
void OnRotate(Vector2 rawRotation)
{
Vector2 rotation = Config.RotationSpeed * Time.deltaTime * rawRotation;
Utils.clamp(ref rotation, -Config.MaxRotationSpeed, Config.MaxRotationSpeed);
EntityTransform.Rotate(new Vector3(-rotation.y, 0, 0), Space.Self);
EntityTransform.Rotate(new Vector3(0, rotation.x, 0), Space.World);
}
public void RpcLevelUp()
{
EntityTransform entityTransform = GetTransformPosition(EEntityTransform.Floor);
GameObject sideEffectObj = SpawnManager.instance.InstantiatePool("FX_LvlUp", entityTransform.transform.position, entityTransform.transform.rotation);
Particle prefab = sideEffectObj.GetComponent <Particle>();
prefab.Initialize("", this, null, false);
}
public CaveInputProcessor(InputConfig config, CaveInputBinding binding, InputController controller) : base(config, binding, controller)
{
binding.MovementJoystick.OnXAxisMove += amount => EntityTransform.Rotate(0, amount * Config.RotationSpeed, 0);
binding.MovementJoystick.OnYAxisMove += amount => EntityTransform.Translate(0, 0, amount * Config.MovementSpeed);
binding.NodePointer.OnPointed += OnNodePointed;
binding.NodeChooser.OnPointed += OnNodeChooserMoved;
binding.ExitNodeTraverseMode.OnPress += ExitNodeTraverseMode;
}
private void OnMove(Vector2 direction)
{
if (Controller.GraphController.GraphMode.Value == GraphMode.NODE_TRAVERSE)
{
return;
}
direction *= Config.MovementSpeed;
EntityTransform.Translate(direction.y, 0, direction.x, Space.Self);
}
public void OnInstantiate()
{
m_attacker = null;
m_target = null;
m_targetPos = Vector3.zero;
m_targetTransform = null;
m_ability = null;
m_expended = false;
}
private void OnMovementJoystickYAxisMove(float amount)
{
if (Controller.GraphController.GraphMode.Value != GraphMode.FREE_FLIGHT || Controller.BlockType.HasValue)
{
return;
}
var translation = CaveInputBinding.Flystick(binding.MovementJoystick.Instance).pose.rotation *Vector3.forward;
EntityTransform.Translate(Config.MovementSpeed * amount * translation, Space.World);
}
public void Initialize(MobaEntity attacker, MobaEntity target, Ability ability, OnProjectileExpended expendedCallback = null)
{
m_expended = false;
m_attacker = attacker;
m_target = target;
m_targetTransform = target.GetTransformPosition(EEntityTransform.Center);
m_ability = ability;
onProjectileExpended = expendedCallback;
m_targetTeam = m_attacker.GetAbilityTargetTeam(m_ability.AbilityBase.Allegiance);
OnStart();
}
public Particle ClientSpawnParticle(MobaEntity entity, string particlePrefab, EEntityTransform position)
{
EntityTransform entityTransform = entity.GetTransformPosition(position);
GameObject sideEffectObj = SpawnManager.instance.InstantiatePool(particlePrefab, entityTransform.transform.position, entityTransform.transform.rotation);
int projectileInstanceID = sideEffectObj.GetInstanceID();
Particle prefab = sideEffectObj.GetComponent <Particle>();
prefab.Initialize(particlePrefab + "_" + projectileInstanceID, entity);
m_particles.Add(prefab.ServerInstanceId, prefab);
return(prefab);
}
public EntityTransform(Entity entity, EntityTransform parent)
{
var toWorld = UnityEngine.Matrix4x4.TRS(entity.Position.toUnityPos(), entity.Rotation.toUnity(), entity.Scale.toUnity());
if (parent != null)
{
toWorld = parent.ToWorld * toWorld;
}
Entity = entity;
ToWorld = toWorld;
ToLocal = toWorld.inverse;
Parent = parent;
}
public SideEffectPrefab SpawnSideEffectPrefab(SideEffect effect, EntityTransform entityTransform)
{
GameObject sideEffectObj = SpawnManager.instance.InstantiatePool(effect.Prefab, entityTransform.transform.position, entityTransform.transform.rotation);
int projectileInstanceID = sideEffectObj.GetInstanceID();
SideEffectPrefab prefab = sideEffectObj.GetComponent <SideEffectPrefab>();
prefab.Initialize(effect.Prefab + "_" + projectileInstanceID);
m_sideEffectPrefabList.Add(prefab.ServerInstanceId, prefab);
int transformPosint = (int)entityTransform.EntityTransformType;
RpcSpawnSideEffectPrefab(effect.EffectIdentifier, prefab.ServerInstanceId, transformPosint);
return(prefab);
}
public override void Run()
{
m_attacker.transform.rotation = m_entityRotation;
AbilityBase abilityBase = AbilityManager.instance.GetAbilityBase(m_abilityIdentifier);
Ability ability = m_attacker.EntityAbilities.GetAbility(abilityBase.AttackType);
EntityTransform launchPos = m_attacker.GetTransformPosition(abilityBase.LaunchPos);
GameObject projectileObj = SpawnManager.instance.InstantiatePool(m_projectileIdentifier + "Client", launchPos.transform.position, launchPos.transform.rotation);
AbilityComponent abilityComponent = projectileObj.GetComponent <AbilityComponent>();
abilityComponent.ServerInstanceId = m_instanceId;
abilityComponent.Initialize(m_attacker, m_targetPos, ability);
m_attacker.EntityAbilities.CacheActiveAbility(abilityComponent);
}
public virtual void ApplyEffect(Ability ability, MobaEntity attacker, MobaEntity reciever)
{
m_ability = ability;
m_attacker = attacker;
m_reciever = reciever;
m_endTime = Time.time + m_duration;
m_intervalTime = m_duration / (float)m_ticks;
if (!string.IsNullOrEmpty(m_prefab))
{
EntityTransform entityTransform = reciever.GetTransformPosition(m_effectPos);
m_prefabGameobject = reciever.EntityAbilities.SpawnSideEffectPrefab(this, entityTransform);
m_prefabGameobject.transform.SetParent(entityTransform.transform);
}
}
static void Test5()
{
var et = new EntityTransform();
et.SrcConn = "BBX";
et.DesConn = "BBX2";
et.AllowInsertIdentity = true;
//et.ShowSQL = true;
//et.Transform();
foreach (var item in EntityFactory.LoadEntities(et.SrcConn, true))
{
var eop = EntityFactory.CreateOperate(item);
et.TransformTable(eop);
}
}
private void RpcSpawnParticle(string entityInstanceId, string particlePrefab, string serverInstanceId, int position)
{
MobaEntity entity = GameManager.instance.GetMobaEntity(entityInstanceId);
if (entity == null)
{
Debug.LogError("Entity not found");
return;
}
EntityTransform entityTransform = entity.GetTransformPosition((EEntityTransform)position);
GameObject sideEffectObj = SpawnManager.instance.InstantiatePool(particlePrefab, entityTransform.transform.position, entityTransform.transform.rotation);
Particle prefab = sideEffectObj.GetComponent <Particle>();
prefab.Initialize(serverInstanceId, entity);
m_particles.Add(prefab.ServerInstanceId, prefab);
}
static void Test13()
{
var file = @"E:\BaiduYunDownload\xiaomi.db";
var file2 = Path.ChangeExtension(file, "sqlite");
DAL.AddConnStr("src", "Data Source=" + file, null, "sqlite");
DAL.AddConnStr("des", "Data Source=" + file2, null, "sqlite");
if (!File.Exists(file2))
{
var et = new EntityTransform();
et.SrcConn = "src";
et.DesConn = "des";
//et.PartialTableNames.Add("xiaomi");
//et.PartialCount = 1000000;
et.Transform();
}
var sw = new Stopwatch();
var dal = DAL.Create("src");
var eop = dal.CreateOperate(dal.Tables[0].TableName);
sw.Start();
var count = eop.Count;
sw.Stop();
XTrace.WriteLine("{0} 耗时 {1}ms", count, sw.ElapsedMilliseconds);
sw.Reset(); sw.Start();
count = eop.FindCount();
sw.Stop();
XTrace.WriteLine("{0} 耗时 {1}ms", count, sw.ElapsedMilliseconds);
var entity = eop.Create();
entity["username"] = "******";
entity.Save();
count = eop.FindCount();
Console.WriteLine(count);
entity.Delete();
count = eop.FindCount();
Console.WriteLine(count);
}
public void RpcSpawnSideEffectPrefab(string effectIdentifier, string serverInstanceId, int transformPos)
{
SideEffect effect = AbilityManager.instance.GetSideEffect(effectIdentifier);
EntityTransform entityTransform = m_mobaEntity.GetTransformPosition((EEntityTransform)transformPos);
GameObject sideEffectObj = SpawnManager.instance.InstantiatePool(effect.Prefab, entityTransform.transform.position, entityTransform.transform.rotation);
sideEffectObj.transform.SetParent(entityTransform.transform);
SideEffectPrefab prefab = sideEffectObj.GetComponent <SideEffectPrefab>();
CustomAudioSource audioSource = null;
if (!string.IsNullOrEmpty(effect.EffectSound))
{
audioSource = AudioManager.instance.Play3dSound(effect.EffectSound, effect.Volume, entityTransform.gameObject, effect.LoopSound);
}
prefab.Initialize(serverInstanceId, audioSource);
m_sideEffectPrefabList.Add(prefab.ServerInstanceId, prefab);
}
private void ToExplodeDataImpl(EntityTransform entityTransform, IList <ExplodeData> list)
{
if (entityTransform == null)
{
return;
}
foreach (var child in entityTransform.Children)
{
ToExplodeDataImpl(child, list);
}
if (entityTransform.Entity.FindComponentOfType <Remote.MeshComponent>() != null)
{
list.Add(new ExplodeData(entityTransform));
}
;
}
private IList <ExplodeData> CaptureRemoteMeshes(RemoteEntitySyncObject syncObject)
{
Entity rootEntity = null;
if (syncObject != null)
{
rootEntity = syncObject.Entity;
}
EntityTransform entityTransform = null;
if (rootEntity != null)
{
entityTransform = rootEntity.CreateTransformSnapshot();
}
return(ToExplodeData(entityTransform));
}
public void Start()
{
_inputable = new MouseInput();
_playerInstance = _player.CreatePlayer();
_ballInstance = _ball.CreateBall(this);
_arrowInstance = _arrow.CreateArrow();
_aiInstance = _ai.CreateAI();
_mapInstance = _map.CreateMap();
_blocks = new List <Block>();
_blocks.Add(_block.CreateBlock(new Vector3(LeftBlockX, BlockY, BlockZ)));
_blocks.Add(_block.CreateBlock(new Vector3(CenterBlockX, BlockY, BlockZ)));
_blocks.Add(_block.CreateBlock(new Vector3(RightBlockX, BlockY, BlockZ)));
_entityTransform = new EntityTransform(Camera.main, _playerInstance, _ballInstance,
_arrowInstance, _aiInstance);
_difficultGame = new DifficultGame();
_saveState = new SaveState(_ballInstance);
_uiManager.GameManager = this;
StartGame();
}
private void LaunchAbilityTarget()
{
switch (m_ability.AbilityBase.Processor)
{
case AbilityProcessorType.DamageImpact:
foreach (MobaEntity entity in m_targets)
{
new DamageProcess(m_attacker, entity, m_ability);
if (m_ability.AbilityBase.ImpactParticleIdentifier != "")
{
EntityTransform impactTarget = entity.GetTransformPosition(m_ability.AbilityBase.LaunchPos);
SpawnManager.instance.InstantiatePool(m_ability.AbilityBase.ImpactParticleIdentifier, impactTarget.transform.position, impactTarget.transform.rotation);
entity.EntityAbilities.RpcSpawnImpactParticle(m_ability.AbilityBase.ImpactParticleIdentifier, (int)EEntityTransform.Center);
}
}
break;
case AbilityProcessorType.LaunchAbility:
foreach (MobaEntity targetEntity in m_targets)
{
EntityTransform spawnPos = m_attacker.GetTransformPosition(m_ability.AbilityBase.LaunchPos);
GameObject projectileObj = SpawnManager.instance.InstantiatePool(m_ability.AbilityBase.ProjectileIdentifier, spawnPos.transform.position, spawnPos.transform.rotation);
AbilityComponent projectile = projectileObj.GetComponent <AbilityComponent>();
projectile.Initialize(m_attacker, targetEntity, m_ability, m_attacker.EntityAbilities.ServerAbilityHit);
int projectileInstanceID = projectile.gameObject.GetInstanceID();
projectile.ServerInstanceId = m_ability.AbilityBase.ProjectileIdentifier + "_" + projectileInstanceID;
m_attacker.EntityAbilities.CacheActiveAbility(projectile);
m_attacker.EntityAbilities.RpcSpawnTargetProjectile(m_attacker.transform.rotation, m_ability.AbilityBase.ProjectileIdentifier, projectile.ServerInstanceId, projectile.Ability.AbilityBase.Identifier, targetEntity.InstanceId, NetworkTime.Instance.ServerStep());
}
break;
case AbilityProcessorType.CastSideEffectsOnly:
foreach (MobaEntity targetEntity in m_targets)
{
targetEntity.EntityAbilities.ApplyAbilityEffects(m_ability, m_attacker);
}
break;
default:
break;
}
}
public void Initialize(MobaEntity entity)
{
if (m_entity == null)
{
m_entity = entity;
if (!string.IsNullOrEmpty(entity.EntityData.m_canvasPrefab))
{
GameObject canvasObj = SpawnManager.instance.InstantiatePool(entity.EntityData.m_canvasPrefab, Vector3.zero, Quaternion.identity);
EntityTransform canvasTrasnform = m_entity.GetTransformPosition(EEntityTransform.Head);
canvasObj.transform.SetParent(canvasTrasnform.transform);
canvasObj.transform.localPosition = Vector3.zero;
m_characterCanvas = canvasObj.GetComponent <CharacterCanvas>();
m_characterCanvas.Initialize(m_entity);
}
}
else
{
m_characterCanvas.Initialize(m_entity);
}
}
/// <summary>
/// This creates a "snapshot" of an entity's global positions and rotation. This includes the entity's entire hierarchy.
/// </summary>
private static EntityTransform CreateTransformSnapshotImpl(this Entity entity, EntityTransform parent)
{
if (entity == null)
{
return(null);
}
EntityTransform entityTranform = new EntityTransform(entity, parent);
var children = entity.Children;
foreach (var child in children)
{
var childTransform = CreateTransformSnapshotImpl(child, entityTranform);
if (childTransform != null)
{
entityTranform.Children.Add(childTransform);
}
}
return(entityTranform);
}
public virtual void Die(DamageProcess damageProcess)
{
if (OnDeathCallBack != null)
{
OnDeathCallBack(damageProcess);
}
m_entityAbilities.RemoveAllSideEffects();
EntityBehaviour.StopAllBehaviours();
StopAgent(false);
m_dead = true;
EntityAnimator.ChangeState(EEntityState.Dead);
if (!string.IsNullOrEmpty(DeathParticlePrefab))
{
RpcSpawnDeathParticle();
m_deathParticle = SpawnManager.instance.InstantiatePool(DeathParticlePrefab, Vector3.zero, Quaternion.identity);
EntityTransform canvasTrasnform = GetTransformPosition(DeathParticlePosition);
m_deathParticle.transform.SetParent(canvasTrasnform.transform);
m_deathParticle.transform.localPosition = Vector3.zero;
}
switch (RespawnType)
{
case EEntityRespawnType.NoRespawn:
break;
case EEntityRespawnType.NoRespawnAndDestroy:
StartCoroutine(NoRespawnAndDestroyCoroutine());
break;
case EEntityRespawnType.RespawnAndReset:
StartCoroutine(RespawnAndResetCoroutine());
break;
default:
break;
}
}
public Enemy(int hp, EntityTransform entityTransform) : base(hp, entityTransform)
{
IsHit = false;
}
