/// <summary>
/// 创建中立障碍物
/// </summary>
/// <param name="vo">数据</param>
private DisplayOwner CreateNPCObstacle(VOBase vo, CreateActorParam otherParam)
{
_npcObstacleDict.Add(vo.ObjID.ID, vo);
var fixItem = GameObject.CreatePrimitive(PrimitiveType.Cube);
// 设置父级
ParentManager.Instance().SetParent(fixItem, ParentManager.ObstacleParent);
fixItem.layer = LayerMask.NameToLayer("Scenery");
//fixItem.name += i;
var fix = fixItem.AddComponent<FixtureData>();
var unitWidth = ClusterManager.Single.UnitWidth;
var mapWidth = ClusterManager.Single.MapWidth;
var mapHeight = ClusterManager.Single.MapHeight;
var offsetPos = LoadMap.Single.transform.position;
fix.AllData.MemberData = new VOBase()
{
ObjID = new ObjectID(ObjectID.ObjectType.NPCObstacle),
SpaceSet = 1,
};
fix.transform.localScale = new Vector3(unitWidth, unitWidth, unitWidth);
fix.transform.position = Utils.NumToPosition(offsetPos, new Vector2(otherParam.X, otherParam.Y), unitWidth, mapWidth, mapHeight);
fix.X = otherParam.X * unitWidth - mapWidth * unitWidth * 0.5f + offsetPos.x;
fix.Y = otherParam.Y * unitWidth - mapHeight * unitWidth * 0.5f + offsetPos.z;
fix.Diameter = 1;
var result = new DisplayOwner(fixItem, fix);
// 添加至ClusterManager中
//ClusterManager.Single.Add(fix);
DisplayerManager.Single.AddElement(vo.ObjID, result);
return result;
}
private void Awake()
{
if (this.gameObject.tag == "GroupParent")
{
this.scriptParentManager = this.GetComponent <ParentManager>();
}
}
/// <summary>
/// 创建基础弹道
/// </summary>
/// <param name="ball">弹道对象</param>
/// <param name="startPos">起始位置</param>
/// <param name="direction">飞行起始方向</param>
/// <param name="speed">飞行速度</param>
/// <param name="radius">物体半径</param>
/// <param name="hasGravity">是否受重力影响, 默认是</param>
/// <param name="grivity">重力系数, 默认9.8</param>
/// <returns>基础弹道</returns>
private Ballistic CreateBallistic(GameObject ball, Vector3 startPos,
Vector3 direction,
float speed,
float radius,
bool hasGravity = true,
float grivity = 9.8f)
{
if (ball == null)
{
return(null);
}
// 设置父级
ParentManager.Instance().SetParent(ball, ParentManager.BallisticParent);
var result = ball.AddComponent <Ballistic>();
result.StartPos = startPos;
result.Position = startPos;
result.Direction = direction;
result.Speed = speed;
result.Radius = radius;
result.HasGravity = hasGravity;
result.Gravity = grivity;
return(result);
}
public void DestroyAllGroup(ConstantManager.PointRatioType pointRatioType)
{
foreach (Transform group in this.objectGroups.transform)
{
if (group.gameObject.tag == "GroupParent")
{
ParentManager scriptParentManager = group.gameObject.GetComponent <ParentManager>();
ScoreManager.AddScoreToDestroyGroup(scriptParentManager.NumOfTargetChildren, pointRatioType);
Destroy(group.gameObject);
}
else if (group.gameObject.tag == "ParentOfBullets")
{
foreach (Transform bullet in group.transform)
{
Destroy(bullet.gameObject);
}
}
else if (group.gameObject.tag == "ParentOfTargets")
{
foreach (Transform target in group.transform)
{
Destroy(target.gameObject);
}
}
}
}
/// <summary>
/// Specifies a property (T1) to observe on the current notifying object, and its sub-properties (T2+) to observe
/// </summary>
/// <typeparam name="T0">The top-level (T0) notifyingObject, implements INotifyPropertyChanged</typeparam>
/// <typeparam name="T1">The property (T1) to observe on T0, implements INotifyPropertyChanged</typeparam>
/// <typeparam name="T2">The property (T2) to observe on T1, implements INotifyPropertyChanged</typeparam>
/// <typeparam name="T3">The property (T3) to observe on T2, implements INotifyPropertyChanged</typeparam>
/// <typeparam name="T4">The property (T4) to observe on T3</typeparam>
/// <param name="topLevelCallback"></param>
/// <param name="prop1Getter"></param>
/// <param name="prop2Getter"></param>
/// <param name="prop3Getter"></param>
/// <param name="prop4Getter"></param>
/// <returns></returns>
private NotificationChain DeepOn <T0, T1, T2, T3, T4> (
NotificationChainCallback topLevelCallback,
Expression <Func <T0, T1> > prop1Getter,
Expression <Func <T1, T2> > prop2Getter,
Expression <Func <T2, T3> > prop3Getter,
Expression <Func <T3, T4> > prop4Getter)
where T0 : class, INotifyPropertyChanged
where T1 : class, INotifyPropertyChanged
where T2 : class, INotifyPropertyChanged
where T3 : class, INotifyPropertyChanged
{
topLevelCallback.ThrowIfNull("topLevelCallback");
prop1Getter.ThrowIfNull("prop1Getter");
prop2Getter.ThrowIfNull("prop2Getter");
prop3Getter.ThrowIfNull("prop3Getter");
prop4Getter.ThrowIfNull("prop4Getter");
if (IsFinished || IsDisposed)
{
return(this);
}
On(prop1Getter);
var mgr = ParentManager.CreateOrGetManager(prop1Getter);
mgr.CreateOrGet("../" + DependentPropertyName)
.DeepOn(topLevelCallback, prop2Getter, prop3Getter, prop4Getter);
return(this);
}
private NotificationChain DeepOnCollection <T1, T2> (
NotificationChainCallback topLevelCallback,
Expression <Func <ObservableCollection <T1> > > collectionPropGetter,
Expression <Func <T1, T2> > prop1Getter)
where T1 : class, INotifyPropertyChanged
{
topLevelCallback.ThrowIfNull("topLevelCallback");
collectionPropGetter.ThrowIfNull("collectionPropGetter");
prop1Getter.ThrowIfNull("prop1Getter");
if (IsFinished || IsDisposed)
{
return(this);
}
// notify when the collection object completely changes
On(collectionPropGetter);
// notify when the collection is modified (items added/removed)
var mgr = ParentManager.CreateOrGetCollectionManager(collectionPropGetter);
mgr.CreateOrGet("../" + DependentPropertyName)
.On(CollectionNotificationChainManager.ObservedCollectionPropertyName)
.On(prop1Getter)
.AndCall(topLevelCallback);
return(this);
}
/// <summary>
/// 将对象放入对象池
/// </summary>
/// <param name="objID"></param>
/// <param name="obj"></param>
public void PushPool(ObjectID objID, DisplayOwner obj)
{
var control = obj.GameObj.GetComponent <RanderControl>();
// 回收未确认下兵的单位时randerControl为null
if (control != null)
{
control.DestoryFSM();
if (control.bloodBarCom != null)
{
control.bloodBarCom.DestorySelf();
}
control.gameObject.SetActive(false);
GameObject.Destroy(control);
}
var soldierType = obj.ClusterData.AllData.MemberData.Name;
// 清理数据
ClearDisplayer(obj);
if (!displayPool.ContainsKey(soldierType))
{
displayPool.Add(soldierType, new Stack <GameObject>());
}
// 设置父级
obj.GameObj.transform.parent = ParentManager.Instance().GetParent(ParentManager.PoolParent).transform;
displayPool[soldierType].Push(obj.GameObj);
}
private NotificationChain DeepOnCollection <T1, T2, T3, T4, T5> (
NotificationChainCallback topLevelCallback,
Expression <Func <ObservableCollection <T1> > > collectionPropGetter,
Expression <Func <T1, T2> > prop1Getter,
Expression <Func <T2, T3> > prop2Getter,
Expression <Func <T3, T4> > prop3Getter,
Expression <Func <T4, T5> > prop4Getter)
where T1 : class, INotifyPropertyChanged
where T2 : class, INotifyPropertyChanged
where T3 : class, INotifyPropertyChanged
where T4 : class, INotifyPropertyChanged
{
topLevelCallback.ThrowIfNull("topLevelCallback");
collectionPropGetter.ThrowIfNull("collectionPropGetter");
prop1Getter.ThrowIfNull("prop1Getter");
prop2Getter.ThrowIfNull("prop2Getter");
prop3Getter.ThrowIfNull("prop3Getter");
prop4Getter.ThrowIfNull("prop4Getter");
if (IsFinished || IsDisposed)
{
return(this);
}
On(collectionPropGetter);
var mgr = ParentManager.CreateOrGetCollectionManager(collectionPropGetter);
mgr.CreateOrGet("../" + DependentPropertyName)
.On(CollectionNotificationChainManager.ObservedCollectionPropertyName)
.DeepOn(topLevelCallback, prop1Getter, prop2Getter, prop3Getter, prop4Getter);
return(this);
}
//生成物体并指向移动方向
public GameObject InstantiateObject(string _name, Vector2 _pos)
{
LevelObject obj = levelObjectDictionary[_name];
GameObject go = Instantiate(obj.prefab, _pos, Quaternion.identity, ParentManager.Instance().GetParent("LevelObject"));
return(go);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="attacker">攻击者数据</param>
/// <param name="effectKey">子弹预设key(或path)</param>
/// <param name="releasePos">子弹飞行起点</param>
/// <param name="targetObj">子弹目标单位</param>
/// <param name="scopeRaduis">范围半径</param>
/// <param name="speed">子弹飞行速度</param>
/// <param name="durTime">范围特效持续时间</param>
/// <param name="taType">子弹飞行轨迹</param>
/// <param name="callback">攻击结束回调</param>
/// <param name="callbackForEveryOne">每个单位被击回调</param>
public PointToObjScopeGeneralAttack(PositionObject attacker,
string[] effectKey,
Vector3 releasePos,
GameObject targetObj,
float scopeRaduis,
float speed,
float durTime,
TrajectoryAlgorithmType taType,
Action callback,
Action <GameObject> callbackForEveryOne = null)
{
if (attacker == null)
{
//throw new Exception("攻击者集群数据为空");
return;
}
var key1 = effectKey[0];
var key2 = effectKey[1];
// 范围伤害
Action scopeDemage = () =>
{
var positionScopeAttack = new PositionScopeGeneralAttack(attacker, key2, targetObj.transform.position, scopeRaduis,
durTime, callback, callbackForEveryOne);
positionScopeAttack.Begin();
};
var effectData = attacker.AllData.EffectData;
var muzzleEffect = effectData.MuzzleFlashEffect;
var muzzleDurTime = effectData.MuzzleFlashEffectTime;
if (muzzleDurTime > 0)
{
// 对每个单位播受击特效
var muzzleAngle = Utils.GetAngleWithZ(attacker.gameObject.transform.forward);
// TODO 使用挂点
EffectsFactory.Single.CreatePointEffect(muzzleEffect,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
attacker.gameObject.transform.position,
new Vector3(1, 1, 1),
muzzleDurTime,
0,
null,
Utils.EffectLayer,
new Vector2(0, muzzleAngle)).Begin();
}
// 飞行轨迹
effect = EffectsFactory.Single.CreatePointToObjEffect(key1,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
releasePos,
targetObj,
new Vector3(1, 1, 1),
speed,
taType,
scopeDemage,
Utils.EffectLayer);
}
/// <summary>
/// サウンドオン
/// </summary>
public virtual void KeyOn()
{
IsSoundingStarted = true;
IsKeyOff = false;
IsSoundOff = false;
if (ParentModule.ModulationDepthes[NoteOnEvent.Channel] > 64 ||
ParentModule.Modulations[NoteOnEvent.Channel] > 0)
{
ModulationEnabled = true;
}
int ln = ParentManager.GetLastNoteNumber(NoteOnEvent.Channel);
if (ParentModule.Portamentos[NoteOnEvent.Channel] >= 64 || ln > 0x80)
{
if (ln >= 0)
{
ln &= 0x7f;
PortamentoDeltaNoteNumber = ln - NoteOnEvent.NoteNumber;
portStartNoteDeltSign = Math.Sign(PortamentoDeltaNoteNumber);
PortamentoEnabled = true;
}
}
var adsrs = Timbre.SDS.ADSR;
ActiveADSR = adsrs.Enable;
if (ActiveADSR)
{
AdsrEngine = new AdsrEngine();
AdsrEngine.SetAttackRate(Math.Pow(10d * (127d - adsrs.AR) / 127d, 2));
AdsrEngine.SetDecayRate(Math.Pow(100d * (adsrs.DR / 127d), 2));
AdsrEngine.SetReleaseRate(Math.Pow(60d * (adsrs.RR / 127d), 2));
AdsrEngine.SetSustainLevel((127d - adsrs.SL) / 127d);
AdsrEngine.Gate(true);
}
var efs = Timbre.SDS.FxS;
if (efs != null)
{
ActiveFx = efs.Enable;
}
SoundKeyOn?.Invoke(this, new SoundUpdatedEventArgs(NoteOnEvent.NoteNumber, NoteOnEvent.Velocity, lastPitch));
if (DrumTimbre != null)
{
HighPrecisionTimer.SetPeriodicCallback
(new Func <object, double>(processGateTime), DrumTimbre.GateTime, this, true);
}
}
public void BecomeChild(GameObject parent)
{
ParentManager scriptParentManager = parent.GetComponent <ParentManager>();
scriptParentManager.AddListObjectChildren(this.gameObject);
this.ObjectMyParent = parent;
this.IsRotation = false;
this.SpeedX = 0;
this.transform.SetParent(parent.transform);
}
public NotificationChain OnCollection <T1> (Expression <Func <ObservableCollection <T1> > > collectionPropGetter)
where T1 : class
{
collectionPropGetter.ThrowIfNull("collectionPropGetter");
// notify when the collection object completely changes
On(collectionPropGetter);
// notify when the collection is modified (items added/removed)
var mgr = ParentManager.CreateOrGetCollectionManager(collectionPropGetter);
mgr.CreateOrGet("../" + DependentPropertyName)
.On(CollectionNotificationChainManager.ObservedCollectionPropertyName)
.AndCall(myFireCallbacksCallback);
return(this);
}
public void GenerateMap()
{
int mapSizeX = NodeManager.Instance().nodeCountX;
int mapSizeY = NodeManager.Instance().nodeCountY;
nodeItems = new GameObject[mapSizeY, mapSizeX];
// 生成节点的真正源点
Vector2 originGeneratePoint;
originGeneratePoint.x = originPoint.x - mapSizeX / 2 * nodePaddingX;
if (mapSizeX % 2 == 0)
{
//originGeneratePoint.x -= nodePaddingX / 2;
}
originGeneratePoint.y = originPoint.y - mapSizeY / 2 * nodePaddingY;
if (mapSizeY % 2 == 0)
{
//originGeneratePoint.y -= nodePaddingY / 2;
}
for (int i = 0; i < mapSizeY; i++)
{
float specialX = 0;
if (evenLineOffsetX != 0)
{
specialX = i % 2 == 0 ? 0 : nodePaddingX * evenLineOffsetX;
}
for (int j = 0; j < mapSizeX; j++)
{
float y = i * nodePaddingY;
Vector2 pos = new Vector2(j * nodePaddingX + specialX, y);
pos += originGeneratePoint;
GameObject go = Instantiate(prefab_node, pos, Quaternion.identity, ParentManager.Instance().GetParent("Node"));
go.name = "Node_" + i + "_" + j;
nodeItems[i, j] = go;
go.GetComponent <NodeItem>().pos = new Vector2Int(i, j);
go.GetComponent <NodeItem>().absPos = new Vector2Int(i, j);
go.GetComponent <NodeItem>().Init();
go.GetComponent <NodeItem>().SetOrderInLayer(2 * (mapSizeY - i));
go.GetComponent <NodeItem>().ToggleFogOfWar(true);
}
}
}
/// <summary>
/// 生成行为节点
/// </summary>
/// <param name="paramsPacker">数据包装类</param>
/// <returns>行为节点</returns>
public override IFormula GetFormula(FormulaParamsPacker paramsPacker)
{
if (paramsPacker == null)
{
return(null);
}
// 替换替换符数据
ReplaceData(paramsPacker);
// 数据本地化
var myFormulaType = FormulaType;
var myReleasePos = ReleasePos;
var myReceivePos = ReceivePos;
IFormula result = null;
result = new Formula((callback, scope) =>
{
// 获取目标位置
var sourcePos = GetPosByType(myReleasePos, paramsPacker, scope);
var targetPos = GetPosByType(myReceivePos, paramsPacker, scope);
EffectBehaviorAbstract effect = null;
if (ReceivePos == 3)
{
effect = EffectsFactory.Single.CreateLinerEffect(EffectKey,
// TODO 应该使用挂点
paramsPacker.ReleaseMember.ClusterData.transform
, paramsPacker.ReceiverMenber.ClusterData.gameObject
, DurTime, callback, Utils.EffectLayer);
}
else
{
effect = EffectsFactory.Single.CreateLinerEffect(EffectKey,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
sourcePos, targetPos, DurTime, callback, Utils.EffectLayer);
}
effect.Begin();
}, myFormulaType);
return(result);
}
void Start()
{
poolDictionary = new Dictionary <string, Queue <GameObject> >();
poolParent = new Dictionary <string, Transform>();
foreach (Pool pool in pools)
{
Transform parent = ParentManager.Instance().GetParent(pool.tag);
poolParent.Add(pool.tag, parent);
Queue <GameObject> objPool = new Queue <GameObject>();
for (int i = 0; i < pool.size; i++)
{
GameObject obj = Instantiate(pool.prefab);
obj.SetActive(false);
obj.transform.SetParent(parent);
objPool.Enqueue(obj);
}
poolDictionary.Add(pool.tag, objPool);
}
}
IEnumerator GenerateCloud()
{
//随机云的种类，如果和上一朵相同就加一
int type = Random.Range(0, cloudPrefabs.Length);
if (type == lastCloudType)
{
type++;
type %= cloudPrefabs.Length;
}
lastCloudType = type;
//随机云的X坐标，如果和上一朵云太接近就重新生成
float randomX;
do
{
randomX = Random.Range(-rangeX, rangeX);
}while (Mathf.Abs(randomX - lastCloudX) < 2);
lastCloudX = randomX;
//生成云
GameObject cloud = Instantiate(cloudPrefabs[type], new Vector2(randomX, generateY), Quaternion.identity, ParentManager.Instance().GetParent("Cloud"));
//云有33%概率会遮挡小马
int random = Random.Range(0, 3);
if (random > 1)
{
cloud.GetComponent <SpriteRenderer>().sortingLayerName = "Cloud";
}
//持续下降
while (generatingCloud && cloud != null && cloud.transform.position.y > destoryY)
{
cloud.transform.Translate(Vector2.down * speed * Time.deltaTime);
yield return(null);
}
if (GameManager.Instance().gaming)
{
Destroy(cloud);
}
}
private void CollisionWithTarget(Collision2D collision)
{
if (ConstantManager.IsDebugMode)
{
Debug.Log("BulletCollider CollisionWithTarget");
}
TargetManager scriptTargetManager = collision.gameObject.GetComponent <TargetManager>();
ParentManager scriptParentManager = null;
GameObject objectGroupParent = null;
GameObject objectBulletParent = this.scriptBulletManager.ObjectMyParent;
GameObject objectTargetParent = scriptTargetManager.ObjectMyParent;
bool bulletIsIsolated = objectBulletParent.tag != "GroupParent";
bool targetIsIsolated = objectTargetParent.tag != "GroupParent";
if (objectBulletParent == objectTargetParent)
{
return;
}
this.scriptSEManager.PlaySEBulletHit();
if (bulletIsIsolated)
{
ScoreManager.AddScoreWhenBulletCollideWithTarget();
}
else
{
ScoreManager.AddScoreWhenGroupBulletCollideWithTarget();
}
if (bulletIsIsolated && targetIsIsolated)
{
objectGroupParent = Instantiate(this.prefabGroupParent) as GameObject;
if (!TipsBoolManager.isAlreadyTipsCollisionTargetAndBullet)
{
this.scriptOutputTips.SetNextTips(TipsTextManager.TipsCollisionTargetAndBullet);
TipsBoolManager.isAlreadyTipsCollisionTargetAndBullet = true;
}
}
else if (bulletIsIsolated)
{
objectGroupParent = objectTargetParent;
}
else
{
objectGroupParent = objectBulletParent;
}
scriptParentManager = objectGroupParent.GetComponent <ParentManager>();
if (bulletIsIsolated && targetIsIsolated)
{
scriptParentManager.SyncChild(scriptTargetManager);
objectGroupParent.transform.SetParent(this.objectParentOfGroups.transform);
}
if (bulletIsIsolated)
{
this.scriptBulletManager.BecomeChild(objectGroupParent);
scriptParentManager.NumOfBulletChildren++;
}
if (targetIsIsolated)
{
scriptTargetManager.BecomeChild(objectGroupParent);
scriptParentManager.NumOfTargetChildren++;
}
if (!bulletIsIsolated && !targetIsIsolated)
{
// Debug.Log("parent " + objectTargetParent.name);
ParentManager scriptTargetParentManager = objectTargetParent.GetComponent <ParentManager>();
foreach (GameObject child in scriptTargetParentManager.ListObjectChildren)
{
Debug.Log("child " + child.gameObject.name);
if (child.tag == "Bullet")
{
child.GetComponent <BulletManager>().BecomeChild(objectGroupParent);
Debug.Log("child Bullet " + child.name);
}
else if (child.tag == "Target")
{
child.GetComponent <TargetManager>().BecomeChild(objectGroupParent);
Debug.Log("child Target " + child.name);
}
}
/* 親要素のforeachで、時々、子要素を取得漏れする不具合あり
*
* foreach (Transform child in objectTargetParent.transform) {
* // Debug.Log("child " + child.gameObject.name);
*
* if (child.gameObject.tag == "Bullet") {
* child.gameObject.GetComponent<BulletManager>().BecomeChild(objectGroupParent);
* // Debug.Log("child Bullet " + child.gameObject.name);
*
* } else if (child.gameObject.tag == "Target") {
* child.gameObject.GetComponent<TargetManager>().BecomeChild(objectGroupParent);
* // Debug.Log("child Target " + child.gameObject.name);
*
* }
* }
*/
scriptParentManager.NumOfBulletChildren += scriptTargetParentManager.NumOfBulletChildren;
scriptParentManager.NumOfTargetChildren += scriptTargetParentManager.NumOfTargetChildren;
Destroy(objectTargetParent);
}
scriptParentManager.UpdateParametersWhenChildrenIsIncreasing();
/*
* Debug.Log("----------");
* Debug.Log("Bullet " + scriptParentManager.NumOfBulletChildren);
* Debug.Log("Target " + scriptParentManager.NumOfTargetChildren);
* Debug.Log("----------");
*/
}
/// <summary>
/// 创建防御塔
/// </summary>
/// <param name="turretVo">防御塔数据</param>
/// <param name="otherParam">其他参数</param>
/// <returns></returns>
private DisplayOwner CreateTurret(TurretVO turretVo, CreateActorParam otherParam)
{
if (turretVo == null || otherParam == null)
{
return null;
}
DisplayOwner result = null;
// 加载数据
var turretConfig = SData_armybase_c.Single.GetDataOfID(Utils.TurretBaseId + otherParam.Level);
turretVo.SetSoldierData(turretConfig);
//通过对象池创建角色
var turretObj = DisplayerManager.Single.CreateAvatar(turretVo);
turretObj.transform.position = new Vector3(otherParam.X, 0, otherParam.Y);
// 设置父级
ParentManager.Instance().SetParent(turretObj, ParentManager.BuildingParent);
// 区分阵营加载不同皮肤
switch (turretVo.Camp)
{
case Utils.MyCamp:
// 我方阵营
// 放入列表
_myTurretDict.Add(turretVo.ObjID.ID, turretVo);
// 旋转角度
turretObj.transform.Rotate(new Vector3(0, 90, 0));
break;
case Utils.EnemyCamp:
// 敌方阵营
// 放入列表
_enemyTurretDict.Add(turretVo.ObjID.ID, turretVo);
// 旋转角度
turretObj.transform.Rotate(new Vector3(0, -90, 0));
break;
}
// 设置位置
var height = SData_Constant.Single.GetDataOfID(Utils.SurfaceTypeConstantId).Value;
turretObj.transform.position = new Vector3(otherParam.X, height, otherParam.Y);
// 添加ClusterData
// TODO 添加BuildingClusterData
var cluster = turretObj.AddComponent<FixtureData>();
// 设置在地面上
cluster.Height = SData_Constant.Single.GetDataOfID(Utils.SurfaceTypeConstantId).Value;
cluster.CollisionGroup = Utils.SurfaceCollisionGroup;
cluster.AllData.MemberData = turretVo;
cluster.X = otherParam.X;
cluster.Y = otherParam.Y;
cluster.StopMove();
// 设置目标选择权重数据
var aimData = SData_armyaim_c.Single.GetDataOfID(turretVo.ArmyID);
cluster.AllData.SelectWeightData = new SelectWeightData(aimData);
// 创建外层持有类
result = new DisplayOwner(turretObj, cluster);
DisplayerManager.Single.AddElement(turretVo.ObjID, result);
// 加载单位Effect数据
var effectData = SData_effect_c.Single.GetDataOfID(turretVo.ArmyID);
cluster.AllData.EffectData = new EffectData(effectData);
// 创建RanderControl
var randerControl = turretObj.AddComponent<RanderControl>();
randerControl.PosObj = cluster;
result.RanderControl = randerControl;
// 启动RanderControl
randerControl.Begin();
// 创建事件检查器
var triggerRunner = turretObj.AddComponent<TriggerRunner>();
triggerRunner.Display = result;
return result;
}
public void RemoveFromLobby(ClientConnection client)
{
if (!ConnectedClients.Contains(client))
{
throw new ArgumentException("Client not connected to Lobby");
}
// Komunikat o opuszczeniu Lobby przez użytkownika
string username = client.Session.Get <string>("username");
var signal = new LobbySignalUserRemovedSerializer()
{
Signal = LobbySignalUserRemovedSerializer.SINGAL_USER_REMOVED,
Message = "User " + username + " left the lobby",
Username = username
};
var player = Game.GetPlayerByUsername(username);
if (player != null)
{
Game.RemovePlayer(player);
signal.WasSitted = true;
signal.PlaceTag = (int)player.Tag;
SetLobbyState(LobbyState.IDLE); // Użytkownik siedział przy stole, jeśli gra była w trakcie, należy ją zapauzować
}
else
{
signal.WasSitted = false;
}
var result = new StandardCommunicateSerializer()
{
CommunicateType = StandardCommunicateSerializer.TYPE_LOBBY_SIGNAL,
Data = signal.GetApiObject()
};
Broadcast(result.GetApiObject());
// Usuwamy klienta z Lobby
ConnectedClients.Remove(client);
client.BeforeDispose -= OnClientConnectionDisposed;
Console.WriteLine("Użytkownik usunięty z Lobby: " + username);
// Ustawianie nowego właściciela Lobby
if (LobbyOwner == client)
{
if (ConnectedClients.Count > 0)
{
LobbyOwner = ConnectedClients.First();
}
else
{
if (ParentManager == null)
{
Close();
}
else
{
ParentManager.CloseLobby(Id);
}
}
}
client.Dispose();
}
public void Begin()
{
// 如果攻击者已死则不进行攻击
if (attacker == null)
{
return;
}
// 范围内选择单位
var memberList = ClusterManager.Single.CheckRange(graphics, attacker.AllData.MemberData.Camp, true);
// 攻击者数据
var attackerDisplayOwner = DisplayerManager.Single.GetElementByPositionObject(attacker);
// 所有单位扣除生命
foreach (var member in memberList)
{
// 被攻击者数据
var beAttackDisplayOwner = DisplayerManager.Single.GetElementByPositionObject(member);
if (beAttackDisplayOwner == null || attackerDisplayOwner == null)
{
continue;
}
// 独计算是否命中, 是否伤害
var isMiss = HurtResult.AdjustIsMiss(attackerDisplayOwner, beAttackDisplayOwner);
if (!isMiss)
{
// 计算伤害值
var hurt = HurtResult.GetHurt(attackerDisplayOwner, beAttackDisplayOwner);
// 记录被击触发 记录扣血 伤害结算时结算
SkillManager.Single.SetTriggerData(new TriggerData()
{
HealthChangeValue = hurt,
ReceiveMember = attackerDisplayOwner,
ReleaseMember = beAttackDisplayOwner,
TypeLevel1 = TriggerLevel1.Fight,
TypeLevel2 = TriggerLevel2.BeAttack,
DemageType = DemageType.NormalAttackDemage,
IsCrit = HurtResult.IsCrit
});
// 回调每个受击单位
if (callbackForEveryOne != null && member != null)
{
callbackForEveryOne(member.gameObject);
}
var effect = member.AllData.EffectData;
var getHitEffect = effect.GetHitByBulletEffect;
var getHitDurTime = 0f;
// 分辨特效类型
switch (effect.BulletType)
{
case 1:
getHitEffect = effect.GetHitByBulletEffect;
getHitDurTime = effect.GetHitByBulletEffectTime;
break;
case 2:
getHitEffect = effect.GetHitByBombEffect;
getHitDurTime = effect.GetHitByBombEffectTime;
break;
}
if (getHitDurTime > 0)
{
// 对每个单位播受击特效
// TODO 使用挂点
EffectsFactory.Single.CreatePointEffect(getHitEffect,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
member.gameObject.transform.position,
new Vector3(1, 1, 1),
getHitDurTime,
0,
null,
Utils.EffectLayer).Begin();
}
}
else
{
// 闪避时事件
SkillManager.Single.SetTriggerData(new TriggerData()
{
ReceiveMember = attackerDisplayOwner,
ReleaseMember = beAttackDisplayOwner,
TypeLevel1 = TriggerLevel1.Fight,
TypeLevel2 = TriggerLevel2.Dodge
});
var beAttackVOBase = beAttackDisplayOwner.ClusterData.AllData.MemberData;
// 抛出miss事件
FightManager.Single.DoHealthChangeAction(beAttackDisplayOwner.GameObj, beAttackVOBase.TotalHp,
beAttackVOBase.CurrentHP, 0f, FightManager.HurtType.Miss, beAttackVOBase.ObjID.ObjType);
}
}
// 播放特效
EffectsFactory.Single.CreatePointEffect(effectKey,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
targetPos,
new Vector3(1, 1, 1),
durTime,
0,
callback,
Utils.EffectLayer).Begin();
}
/// <summary>
///
/// </summary>
/// <param name="attacker">攻击者数据</param>
/// <param name="beAttackMember">被攻击者数据</param>
/// <param name="effectKey">子弹预设key(或path)</param>
/// <param name="releasePos">子弹飞行起点</param>
/// <param name="targetObj">子弹目标单位</param>
/// <param name="speed">子弹飞行速度</param>
/// <param name="taType">子弹飞行轨迹</param>
/// <param name="callback">攻击结束回调</param>
public NormalGeneralAttack(PositionObject attacker,
PositionObject beAttackMember,
string effectKey,
Vector3 releasePos,
GameObject targetObj,
float speed,
TrajectoryAlgorithmType taType,
Action <GameObject> callback)
{
if (attacker == null || beAttackMember == null)
{
//throw new Exception("被攻击者或攻击者数据为空");
return;
}
// 特效数据
var effectData = beAttackMember.AllData.EffectData;
Action demage = () =>
{
var attackerDisplayOwner = DisplayerManager.Single.GetElementByPositionObject(attacker);
var beAttackerDisplayOwner = DisplayerManager.Single.GetElementByPositionObject(beAttackMember);
if (beAttackerDisplayOwner == null ||
attackerDisplayOwner == null ||
null == beAttackerDisplayOwner.ClusterData ||
null == beAttackerDisplayOwner.RanderControl)
{
return;
}
// 判断是否命中
var isMiss = HurtResult.AdjustIsMiss(attackerDisplayOwner, beAttackerDisplayOwner);
if (!isMiss)
{
// 计算伤害
// TODO 伤害计算加入Buff与技能的计算
var hurt = HurtResult.GetHurt(attackerDisplayOwner, beAttackerDisplayOwner);
// 记录被击触发 记录扣血 伤害结算时结算
SkillManager.Single.SetTriggerData(new TriggerData()
{
HealthChangeValue = hurt,
ReceiveMember = attackerDisplayOwner,
ReleaseMember = beAttackerDisplayOwner,
TypeLevel1 = TriggerLevel1.Fight,
TypeLevel2 = TriggerLevel2.BeAttack,
DemageType = DemageType.NormalAttackDemage,
IsCrit = HurtResult.IsCrit
});
// 命中时检测技能
SkillManager.Single.SetTriggerData(new TriggerData()
{
// 将造成的伤害带回
HealthChangeValue = hurt,
ReceiveMember = beAttackerDisplayOwner,
ReleaseMember = attackerDisplayOwner,
TypeLevel1 = TriggerLevel1.Fight,
TypeLevel2 = TriggerLevel2.Hit,
DemageType = DemageType.NormalAttackDemage
});
var getHitEffect = effectData.GetHitByBulletEffect;
var getHitDurTime = 0f;
// 分辨特效类型
switch (effectData.BulletType)
{
case 1:
getHitEffect = effectData.GetHitByBulletEffect;
getHitDurTime = effectData.GetHitByBulletEffectTime;
break;
case 2:
getHitEffect = effectData.GetHitByBombEffect;
getHitDurTime = effectData.GetHitByBombEffectTime;
break;
}
if (getHitDurTime > 0)
{
// 对每个单位播受击特效
// 计算旋转角度
var beAttackAngle = Utils.GetAngleWithZ(attacker.gameObject.transform.forward) + 180;
// TODO 使用挂点
EffectsFactory.Single.CreatePointEffect(getHitEffect,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
beAttackMember.gameObject.transform.position,
new Vector3(1, 1, 1),
getHitDurTime,
0,
null,
Utils.EffectLayer,
new Vector2(0, beAttackAngle)).Begin();
}
}
else
{
// 闪避时事件
SkillManager.Single.SetTriggerData(new TriggerData()
{
ReceiveMember = attackerDisplayOwner,
ReleaseMember = beAttackerDisplayOwner,
TypeLevel1 = TriggerLevel1.Fight,
TypeLevel2 = TriggerLevel2.Dodge
});
var beAttackVOBase = beAttackerDisplayOwner.ClusterData.AllData.MemberData;
// 抛出miss事件
FightManager.Single.DoHealthChangeAction(beAttackerDisplayOwner.GameObj, beAttackVOBase.TotalHp,
beAttackVOBase.CurrentHP, 0f, FightManager.HurtType.Miss, beAttackVOBase.ObjID.ObjType);
}
};
// 枪口火焰
var muzzleEffect = effectData.MuzzleFlashEffect;
var muzzleDurTime = effectData.MuzzleFlashEffectTime;
if (muzzleDurTime > 0)
{
// 对每个单位播枪口火焰特效
// 计算角度
var muzzleAngle = Utils.GetAngleWithZ(attacker.gameObject.transform.forward);
// TODO 使用挂点
EffectsFactory.Single.CreatePointEffect(muzzleEffect,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
attacker.gameObject.transform.position,
new Vector3(1, 1, 1),
muzzleDurTime,
0,
null,
Utils.EffectLayer,
new Vector2(0, muzzleAngle)).Begin();
}
Action action = () =>
{
if (callback != null && beAttackMember)
{
callback(beAttackMember.gameObject);
}
};
effect = EffectsFactory.Single.CreatePointToObjEffect(effectKey,
ParentManager.Instance().GetParent(ParentManager.BallisticParent).transform,
releasePos,
targetObj,
new Vector3(1, 1, 1),
speed,
taType,
demage + action,
Utils.EffectLayer);
}
public void ClearLevel()
{
ParentManager.Instance().ClearChilds("LevelObject");
}
/// <summary>
/// 创建单位
/// </summary>
/// <param name="soldier">单位数据</param>
/// <param name="param">数据参数</param>
/// <returns></returns>
private DisplayOwner CreateSoldier(FightVO soldier, CreateActorParam param)
{
if (soldier.ObjID.ObjType == ObjectID.ObjectType.MySoldier)
{
_mySoldiersDict.Add(soldier.ObjID.ID, soldier);
}
if (soldier.ObjID.ObjType == ObjectID.ObjectType.EnemySoldier)
{
_enemySoldiersDict.Add(soldier.ObjID.ID, soldier);
}
// 设置数据
var soldierId = param.SoldierID;
var config = SData_armybase_c.Single.GetDataOfID(soldierId);
soldier.SetSoldierData(config);
//var display = DP_FightPrefabManage.InstantiateAvatar(param);
//通过对象池创建角色
var display = DisplayerManager.Single.CreateAvatar(soldier);
display.transform.position = new Vector3(param.X, 0, param.Y);
// 设置父级
ParentManager.Instance().SetParent(display, ParentManager.ClusterParent);
// 创建渲染器
// var mfa = display.GetComponent<MFAModelRender>();
// mfa.ObjId = soldier.ObjID;
// 创建集群数据
var cluster = display.AddComponent<ClusterData>();
cluster.SetDataValue(soldier);
// mfa.Cluster = cluster;
// 设置空地高度
switch (soldier.GeneralType)
{
// 空中单位高度
case Utils.GeneralTypeAir:
cluster.Height = SData_Constant.Single.GetDataOfID(Utils.AirTypeConstantId).Value;
cluster.CollisionGroup = Utils.AirCollisionGroup;
break;
// 地面单位高度
case Utils.GeneralTypeBuilding:
case Utils.GeneralTypeSurface:
cluster.Height = SData_Constant.Single.GetDataOfID(Utils.SurfaceTypeConstantId).Value;
cluster.CollisionGroup = Utils.SurfaceCollisionGroup;
break;
}
//Debug.Log("类型: " + soldier.GeneralType + "高度: " + mfa.Cluster.Height);
// 添加至ClusterManager中
//cluster.Diameter *= ClusterManager.Single.UnitWidth;
cluster.StopMove();
// ClusterManager.Single.Add(mfa.Cluster);
// 创建外层持有类
var displayOwner = new DisplayOwner(display, cluster);
DisplayerManager.Single.AddElement(soldier.ObjID, displayOwner);
// 创建RanderControl
var randerControl = display.AddComponent<RanderControl>();
randerControl.PosObj = cluster;
displayOwner.RanderControl = randerControl;
// 挂载事件处理器
var triggerRunner = display.AddComponent<TriggerRunner>();
// 设置数据
triggerRunner.Display = displayOwner;
// 设置目标选择权重数据
var aimData = SData_armyaim_c.Single.GetDataOfID(soldier.ArmyID);
cluster.AllData.SelectWeightData = new SelectWeightData(aimData);
if (soldier.AttackType == Utils.BulletTypeScope)
{
// 加载单位的AOE数据
var aoeData = SData_armyaoe_c.Single.GetDataOfID(soldier.ArmyID);
cluster.AllData.AOEData = new ArmyAOEData(aoeData);
}
// 加载单位Effect数据
var effectData = SData_effect_c.Single.GetDataOfID(soldier.ArmyID);
cluster.AllData.EffectData = new EffectData(effectData);
// 加载单位
var armyTypeData = SData_UnitFightData_c.Single.GetDataOfID(soldier.ArmyID);
cluster.AllData.ArmyTypeData = new ArmyTypeData(armyTypeData);
cluster.AllData.ArmyTypeData.Camp = (short) soldier.Camp;
// 加载并设置技能
displayOwner.ClusterData.AllData.SkillInfoList = SkillManager.Single.CreateSkillInfoList(new List<int>()
{
soldier.Skill1,
soldier.Skill2,
soldier.Skill3,
soldier.Skill4,
soldier.Skill5,
},
displayOwner);
// 创建单位是将技能属性(如果有)附加到单位上
foreach (var skill in displayOwner.ClusterData.AllData.SkillInfoList)
{
SkillManager.Single.AttachSkillAttribute(skill, displayOwner.ClusterData.AllData.MemberData);
}
return displayOwner;
}
public void ClearCloud()
{
ParentManager.Instance().ClearChilds("Cloud");
}
public void Init()
{
worldObject = ParentManager.Instance().grandparent;
}
/// <summary>
/// 创建基地
/// </summary>
/// <param name="jidiVo">基地数据</param>
/// <param name="otherParam">其他参数</param>
/// <returns></returns>
private DisplayOwner CreateBase(JiDiVO jidiVo, CreateActorParam otherParam)
{
DisplayOwner result = null;
if (jidiVo == null || otherParam == null)
{
return result;
}
// 根据等级获得对应数据
var baseConfig = SData_armybase_c.Single.GetDataOfID(Utils.BaseBaseId + otherParam.Level);
jidiVo.SetSoldierData(baseConfig);
// 创建基地模型
// 通过对象池创建角色
var baseObj = DisplayerManager.Single.CreateAvatar(jidiVo);
baseObj.transform.position = new Vector3(otherParam.X, 0, otherParam.Y);
// 设置父级
ParentManager.Instance().SetParent(baseObj, ParentManager.BuildingParent);
switch (jidiVo.Camp)
{
case Utils.MyCamp:
_myJidiDict.Add(jidiVo.ObjID.ID, jidiVo);
// 旋转角度
baseObj.transform.Rotate(new Vector3(0, 90, 0));
break;
case Utils.EnemyCamp:
_enemyJidiDict.Add(jidiVo.ObjID.ID, jidiVo);
// 旋转角度
baseObj.transform.Rotate(new Vector3(0, -90, 0));
break;
}
// 获取距离地面高度
var height = SData_Constant.Single.GetDataOfID(Utils.SurfaceTypeConstantId).Value;
baseObj.transform.position = new Vector3(otherParam.X, height, otherParam.Y);
// TODO 添加BuildingClusterData
var cluster = baseObj.AddComponent<FixtureData>();
// 设置在地面上
cluster.Height = SData_Constant.Single.GetDataOfID(Utils.SurfaceTypeConstantId).Value;
cluster.CollisionGroup = Utils.SurfaceCollisionGroup;
cluster.AllData.MemberData = jidiVo;
cluster.X = otherParam.X;
cluster.Y = otherParam.Y;
cluster.StopMove();
// 保存基地位置
FightManager.Single.SetMemberPos(jidiVo.Camp, FightManager.MemberType.Base, new Vector3(cluster.X, cluster.Height, cluster.Y));
// 创建外层持有类
result = new DisplayOwner(baseObj, cluster);
DisplayerManager.Single.AddElement(jidiVo.ObjID, result);
// 创建RanderControl
var randerControl = baseObj.AddComponent<RanderControl>();
randerControl.PosObj = cluster;
result.RanderControl = randerControl;
randerControl.Begin();
// 创建事件检查器
var triggerRunner = baseObj.AddComponent<TriggerRunner>();
triggerRunner.Display = result;
return result;
}
