public EffectData LoadEffect(int id, ulong guid, GTTransform data, Transform parent, bool retain = true)
{
EffectData tab = new EffectData(id, guid, data, parent, retain);
Effects[tab.GUID] = tab;
return(tab);
}
public void Test_GT2GT1()
{
Console.WriteLine("Same Direction:");
{
var gt = new Tuple <double, double, double, double, double, double>(100, 1.1, 105, 1.1d, 800, 2.2);
var newgt = GTTransform.TransGT2ToGT1(gt.Item1, gt.Item2, gt.Item3, gt.Item4, 0, true);
Console.WriteLine($"{gt}:{newgt:F3}");
}
{
var gt = new Tuple <double, double, double, double, double, double>(105, 5.1, 105, 1.1d, 800, 2.2);
var newgt = GTTransform.TransGT2ToGT1(gt.Item1, gt.Item2, gt.Item3, gt.Item4, 0, true);
Console.WriteLine($"{gt}:{newgt:F3}");
}
Console.WriteLine("Inverse Direction:");
{
//gt2work, gt2raw, gt2calib, gt2calibraw, gt1calib, gt1calibraw
var gt = new Tuple <double, double, double, double, double, double>(100, 1.1, 105, 1.1d, 800, 2.2);
var newgt1 = GTTransform.TransGT2ToGT1(gt.Item1, gt.Item2, gt.Item3, gt.Item4, 70, false);
Console.WriteLine($"{gt.Item1:F2},{gt.Item2:F2},{gt.Item3:F2},{gt.Item4:F2},{gt.Item5:F2},{gt.Item6:F2}:{newgt1:F3}");
Console.WriteLine("GT1 Transform:");
var gt1 = new Tuple <double, double, double, double>(800, newgt1, 800, 2.2d);
var newgt2 = GTTransform.TransGT2ToGT1(gt1.Item1, gt1.Item2, gt1.Item3, gt1.Item4, 0);
Console.WriteLine($"{gt1}:{newgt2:F3}");
}
}
public Character AddActorLocalSync(XCharacter data)
{
if (data == null)
{
return(null);
}
GTTransform dTrans = GTTransform.Create(data.PosX, data.PosY, data.PosZ, data.Face);
Character cc = AddActor(data.Id, (EBattleCamp)data.Camp, (EActorType)data.Type, dTrans, data, false);
cc.Carrer = data.Carrer;
cc.IsRemoteActor = true;
switch (cc.Type)
{
case EActorType.MONSTER:
cc.EnableAI(true);
cc.OnDeadFinish = () =>
{
if (cc != null && cc.CacheTransform != null)
{
cc.CacheTransform.gameObject.SetActive(false);
GTEventCenter.FireEvent(GTEventID.TYPE_ACTOR_KILL_MONSTER, cc.GUID, cc.ID);
cc.OnDeadFinish = null;
}
};
break;
case EActorType.NPC:
cc.EnableAI(true);
break;
}
return(cc);
}
private void ShowModel()
{
if (mPlayer != null)
{
GTWorld.Instance.DelActor(mPlayer);
}
GTTransform param = GTTransform.Default;
DRole roleDB = mRoleDBList[mRoleIndex];
mPlayer = GTWorld.Instance.AddRole(roleDB.ActorID, param);
mPlayer.EnableCharacter(false);
mPlayer.EnableRootMotion(false);
mPlayer.Action.Play("idle");
if (roleDB.DisplayWeapon > 0)
{
mPlayer.Avatar.ChangeAvatar(8, roleDB.DisplayWeapon);
}
mPlayer.CacheTransform.localPosition = mRoleModelPos;
mPlayer.CacheTransform.localEulerAngles = mRoleModelEuler;
GameObject go = mPlayer.Obj;
go.transform.position = mRoleModelPos;
go.transform.eulerAngles = mRoleModelEuler;
go.SetActive(true);
}
protected override bool MakeResult(Character cc)
{
if (cc == null)
{
return(false);
}
EffectData unit = null;
if (World)
{
Transform p = cc.Avatar.GetBindTransform(Bind);
unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, Retain);
unit.CacheTransform.parent = p;
unit.CacheTransform.localPosition = Offset;
unit.CacheTransform.localEulerAngles = Euler;
unit.CacheTransform.parent = null;
unit.CacheTransform.localScale = Scale;
}
else
{
Transform p = cc.Avatar.GetBindTransform(Bind);
unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, GTTransform.Create(Offset, Euler, Scale), p, Retain);
}
unit.Release(Duration);
return(true);
}
protected override bool Trigger()
{
base.Trigger();
if (World)
{
Transform p = Skill.Caster.Avatar.GetBindTransform(CasterBind);
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, Retain);
Unit.CacheTransform.parent = p;
Unit.CacheTransform.localPosition = Offset;
Unit.CacheTransform.localEulerAngles = Euler;
Unit.CacheTransform.parent = null;
Unit.CacheTransform.localScale = Scale;
Unit.CacheTransform.localEulerAngles = Euler + Skill.Caster.Euler;
}
else
{
Transform p = Skill.Caster.Avatar.GetBindTransform(CasterBind);
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, GTTransform.Create(Offset, Euler, Scale), p, Retain);
}
for (int i = 0; i < Children.Count; i++)
{
Children[i].ApplyCenter = Unit.CacheTransform;
Children[i].ApplyHitPoint = Unit.Pos;
Children[i].ApplyHitDir = Vector3.zero;
}
Unit.Release(Duration);
return(true);
}
public EffectData(int id, ulong guid, GTTransform data, Transform parent, bool retain)
{
this.ID = id;
this.GUID = guid > 0 ? guid : GTGUID.NewGUID();
this.Parent = parent;
this.Retain = retain;
this.Cfg = ReadCfgEffect.GetDataById(id);
if (Cfg == null)
{
Debug.LogError("不存在特效ID =" + ID);
return;
}
GameObject go = GTPoolManager.Instance.GetObject(Cfg.Path);
if (go == null)
{
go = new GameObject(ID.ToString());
}
this.CacheTransform = go.transform;
NGUITools.SetLayer(go, GTLayer.LAYER_EFFECT);
this.CacheTransform.parent = this.Parent != null ? Parent : null;
this.CacheTransform.localScale = Vector3.one;
this.CacheTransform.localEulerAngles = data.Euler;
this.CacheTransform.localPosition = data.Pos;
this.TriggerObject = go.GET <ETriggerObject>();
}
public static GTTransform Create(float x, float y, float z, float vx, float vy, float vz)
{
GTTransform data = new GTTransform();
data.Pos = new Vector3(x, y, z);
data.Euler = Quaternion.FromToRotation(Vector3.forward, new Vector3(vx, vy, vz)).eulerAngles;
return(data);
}
public static GTTransform Create(float x, float y, float z, float face)
{
GTTransform data = new GTTransform();
data.Pos = new Vector3(x, y, z);
data.Euler = new Vector3(0, face, 0);
return(data);
}
public static GTTransform Create(Vector3 pos, float face)
{
GTTransform data = new GTTransform();
data.Pos = pos;
data.Euler = new Vector3(0, face, 0);
return(data);
}
public static GTTransform Create(Vector3 pos, Vector3 angle, Vector3 scale)
{
GTTransform data = new GTTransform();
data.Pos = pos;
data.Euler = angle;
return(data);
}
public override void Trigger()
{
base.Trigger();
GTTransform data = GTTransform.Create(Pos, EulerAngles);
m_EffectData = GTWorld.Instance.Ect.LoadEffect(EffectID, 0, data, null, false);
m_EffectData.Release(EffectLifeTime);
}
public Character AddMainPlayer(GTTransform bornData)
{
XCharacter data = GTGlobal.Main;
Main = AddActor(data.Id, EBattleCamp.CT_PVE_PLAYER, EActorType.PLAYER, bornData, data, true);
Main.Carrer = data.Carrer;
Main.OnDead = OnDeadForMain;
return(Main);
}
public Character AddActor(int id, EBattleCamp camp, EActorType type, GTTransform bornData, XCharacter data, bool isMain = false)
{
Character cc = new Character(id, data == null ? GTGUID.NewGUID() : data.GUID, type, camp, isMain);
bornData.Pos = GTTools.NavSamplePosition(bornData.Pos);
cc.Load(bornData);
cc.SyncData(data, ESyncDataType.TYPE_ALL);
SetCharacterParent(cc);
Characters.Add(cc);
return(cc);
}
IEnumerator DoSummon()
{
for (int i = 0; i < Count; i++)
{
yield return(new WaitForSeconds(Interval));
Vector3 bornPoint = GTTools.RandomOnCircle(Skill.Caster.Pos, MinRadius, MaxRadius);
Vector3 bornEuler = Vector3.zero;
GTTransform kt = GTTransform.Create(bornPoint, bornEuler);
GTWorld.Instance.AddActor(Id, Skill.Caster.Camp, ActorType, kt, null, false);
}
}
public Character AddActorSync(XCharacter data)
{
if (data == null)
{
return(null);
}
GTTransform dTrans = GTTransform.Create(data.PosX, data.PosY, data.PosZ, data.Face);
Character cc = AddActor(data.Id, (EBattleCamp)data.Camp, (EActorType)data.Type, dTrans, data, false);
cc.Carrer = data.Carrer;
cc.IsRemoteActor = true;
return(cc);
}
public Character AddMainPartner(int pos)
{
XCharacter data = null;
switch (pos)
{
case 1:
data = GTGlobal.MainPartner1;
break;
case 2:
data = GTGlobal.MainPartner2;
break;
}
if (data == null)
{
return(null);
}
Vector3 offset = Vector3.zero;
switch (pos)
{
case 1:
offset = new Vector3(-2, 0, 0);
break;
case 2:
offset = new Vector3(2, 0, 0);
break;
}
GTTransform bornData = new GTTransform();
bornData.Euler = Main.Euler;
bornData.Pos = Main.Pos + offset;
Character actor = AddActor(data.Id, EBattleCamp.CT_PVE_PLAYER, EActorType.PARTNER, bornData, data);
actor.Host = Main;
actor.FollowOffset = offset;
actor.EnableAI(true);
switch (pos)
{
case 1:
Main.Partner1 = actor;
break;
case 2:
Main.Partner2 = actor;
break;
}
return(actor);
}
public void Test_GT()
{
//gt1work, gt1raw, gt1calib, gt1calibraw
Console.WriteLine("GT1 Transform:");
var gt = new Tuple <double, double, double, double>(100, 1.1, 105, 1.1d);
var newgt = GTTransform.TransGT(gt.Item1, gt.Item2, gt.Item3, gt.Item4);
Console.WriteLine($"{gt}:{newgt:F3}");
var newgt2 = GTTransform.TransGT2ToGT1(gt.Item1, gt.Item2, gt.Item3, gt.Item4);
Console.WriteLine($"{gt}:{newgt2:F3}");
}
protected override bool Trigger()
{
base.Trigger();
GameObject go = GameObject.Find(ParentPath);
if (go != null)
{
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, GTTransform.Create(Offset, Euler, Scale), go.transform, Retain);
Unit.Release(Duration);
return(true);
}
else
{
return(false);
}
}
public void TryStartMount()
{
XCharacter data = GTGlobal.Main;
if (data.Mount == 0)
{
CharacterHelper.CalcCharacterOperateError(Resp.TYPE_RIDE_NONE);
return;
}
if (GTLauncher.Instance.CurrCopyType != ECopyType.TYPE_CITY &&
GTLauncher.Instance.CurrCopyType != ECopyType.TYPE_WORLD)
{
CharacterHelper.CalcCharacterOperateError(Resp.TYPE_RIDE_NOTDOATSCENE);
return;
}
if (GTWorld.Main.IsFSMLayer2() || GTWorld.Main.IsFSMLayer3())
{
CharacterHelper.CalcCharacterOperateError(Resp.TYPE_RIDE_NOTDOATFSM);
return;
}
if (GTWorld.Main.IsRide)
{
CharacterHelper.CalcCharacterOperateError(Resp.TYPE_RIDE_ING);
return;
}
if (GTWorld.Main.FSM == FSMState.FSM_SKILL)
{
CharacterHelper.CalcCharacterOperateError(Resp.TYPE_SKILL_CASTING);
return;
}
Vector3 pos = GTWorld.Main.Pos;
Vector3 euler = GTWorld.Main.Euler;
GTTransform bornData = GTTransform.Create(pos, euler);
GTWorld.Main.Mount = GTWorld.Instance.AddActor(data.Mount, EBattleCamp.CT_NONE, EActorType.MOUNT, bornData, null, false);
GTWorld.Main.Mount.Host = GTWorld.Main;
Resp resp = GTWorld.Main.Command.Get <CommandRideBegin>().Do();
if (resp == Resp.TYPE_YES)
{
GTWorld.Main.PausedAI(true);
}
CharacterHelper.CalcCharacterOperateError(resp);
}
public override void Enter()
{
if (World)
{
Transform p = Carryer.Avatar.GetBindTransform(Bind);
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, Retain);
Unit.CacheTransform.parent = p;
Unit.CacheTransform.localPosition = Offset;
Unit.CacheTransform.localEulerAngles = Euler;
Unit.CacheTransform.parent = null;
Unit.CacheTransform.localScale = Scale;
Unit.CacheTransform.localEulerAngles = Euler + Carryer.Euler;
}
else
{
Transform p = Carryer.Avatar.GetBindTransform(Bind);
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, GTTransform.Create(Offset, Euler, Scale), p, Retain);
}
}
void OnLoadAvatar()
{
if (WorldMap.MapData != null)
{
for (int i = 0; i < WorldMap.MapData.MapBorns.Count; i++)
{
MapBorn b = WorldMap.MapData.MapBorns[i];
switch ((EBattleCamp)b.ID)
{
case EBattleCamp.CT_PVE_PLAYER:
GTTransform data = GTTransform.Create(b.Pos, b.Face);
AddMainPlayer(data);
GTCameraManager.Instance.CreateMainCamera(Main.CacheTransform);
GTCameraManager.Instance.CreateMiniCamera(Main.CacheFixEuler);
GTNetworkSend.Instance.TrySyncIdle();
break;
}
}
}
}
public void Load(ActFlyObj obj, HitCallbackFly hitCallback)
{
mFlyObj = obj;
if (obj.World)
{
Transform p = obj.Skill.Caster.Avatar.GetBindTransform(obj.CasterBind);
mUnit = GTWorld.Instance.Ect.LoadEffect(obj.ID, 0, obj.Retain);
mUnit.CacheTransform.parent = p;
mUnit.CacheTransform.localPosition = obj.Offset;
mUnit.CacheTransform.localEulerAngles = obj.Euler;
mUnit.CacheTransform.parent = null;
mUnit.CacheTransform.localScale = obj.Scale;
mUnit.CacheTransform.localEulerAngles = obj.Euler + obj.Skill.Caster.Euler;
}
else
{
Transform p = obj.Skill.Caster.Avatar.GetBindTransform(obj.CasterBind);
mUnit = GTWorld.Instance.Ect.LoadEffect(obj.ID, 0, GTTransform.Create(obj.Offset, obj.Euler, obj.Scale), p, obj.Retain);
}
mUnit.TriggerEnter = (other) => { hitCallback(this, other); };
mIsLoaded = true;
CacheTransform = mUnit.CacheTransform;
}
protected override int RunLoop()
{
//in case of manual operations
Platform.AssertAutoMode(this);
//wait start
while ((!DIStart1.GetDiSts() || !DIStart2.GetDiSts()))
{
Thread.Sleep(100);
JoinIfPause();
AbortIfCancel("cancel trans wait start");
if (Station.Id == 1 && Machine.Ins.Settings.Common.LeftAutoTryRun)
{
break;
}
if (Station.Id == 2 && Machine.Ins.Settings.Common.RightAutoTryRun)
{
break;
}
}
Log(string.Empty, LogLevel.None);
if ((Station.Id == 1 && Machine.Ins.Settings.Common.LeftSensorCheck) ||
(Station.Id == 2 && Machine.Ins.Settings.Common.RightSensorCheck))
{
//检查定位传感器
if (!DISensorCheck1.GetDiSts() || !DISensorCheck2.GetDiSts())
{
Station.Machine.Beep();
Log($"{Station.Name} - {Name} 定位传感器检测异常", LogLevel.Warning);
return(0);
}
}
if ((Station.Id == 1 && Machine.Ins.Settings.Common.LeftFinSensorCheck) ||
(Station.Id == 2 && Machine.Ins.Settings.Common.RightFinSensorCheck))
{
//检查fin传感器
if (!CheckProductFin())
{
//return to wait start
return(0);
}
}
//new product
Product = new Thermo1Product()
{
ProductType = Project.ThermoProductType.ToString(),
Description = Station.Name + "-" + Project.ProductName + "-" + CfgSettings.Version,
SPCItems = Project.SPCItems,
};
Product.ClearSpc();
//push data to measure tasks
WaitTaskDown.Product = Product;
WaitTaskUp.Product = Product;
TestProcessControl.OnTestStartEvent(Product);
TestProcessControl.OnTestingEvent(Product);
DOBtnLight1.SetDo();
DOBtnLight2.SetDo();
//cy clamp
if (Project.ProjectName.Contains("HeightCalib"))
{
DoClampCylinderY.SetDo(this, true, 100, ignoreOrWaringOrError: null);
}
else if (Project.ThermoProductType == ThermoProductType.FullModule)
{
Clamper.ClampModule();
}
else if (Project.ThermoProductType == ThermoProductType.VaporChamber)
{
Clamper.ClampVC();
}
else
{
Clamp(true);
}
//move work
Platform.MoveAbs(0, "Work");
{
VioTransInp.SetVio(this);
//start waiting
Log("Measure Start......\n-----------------------------------------------", LogLevel.Info);
//set measure start
VioTransFinishUp.SetVio(this);
VioTransFinishDown.SetVio(this);
{
//wait barcode finish update barcode
VioBarcodeFinish.WaitVioAndClear(this);
TestProcessControl.OnTestingEvent(Product);
}
//wait measure finish
VioMeasureFinishUp.WaitVioAndClear(this);
VioMeasureFinishDown.WaitVioAndClear(this);
Log("Measure Finish......\n-----------------------------------------------", LogLevel.Info);
}
//move wait pos
Platform.MoveAbs(0, "Wait");
//update results
//calc flatness
if (Thermo1GeometryCalculator != null)
{
//transform raw data to same coord
GTTransform.TransformRawData(Station.Name, CfgSettings.Calibration, Product);
var data = Thermo1GeometryCalculator.Calculate(Product);
Log($"Flatness Calc: {data.ToString()}");
}
SaveProductData();
Clamper.Release();
DOBtnLight1.SetDo(false);
DOBtnLight2.SetDo(false);
return(0);
}
public Character AddRole(int id, GTTransform bornData)
{
return(AddActor(id, EBattleCamp.CT_NONE, EActorType.PLAYER, bornData, null, false));
}
protected override bool Trigger()
{
Vector3 origin = Skill.Caster.Avatar.GetBindPosition(Bind);
RaycastHit hit;
if (Physics.Raycast(origin, Skill.Caster.Dir, out hit, MaxDis))
{
Collider col = hit.collider;
if (HitEffectID > 0)
{
EffectData unit = GTWorld.Instance.Ect.LoadEffect(HitEffectID, 0, GTTransform.Create(hit.point, Vector3.zero), null, true);
unit.Release(HitEffectDuration);
}
CharacterView view = col.GetComponent <CharacterView>();
if (view != null)
{
if (Skill.Caster.Match(Affect, view.Owner))
{
for (int i = 0; i < Children.Count; i++)
{
Children[i].ApplyHitPoint = hit.point;
Children[i].ApplyHitDir = Vector3.up;
Children[i].ClearAttackList();
Children[i].AddInAttackList(view.Owner);
}
End();
}
}
}
return(base.Trigger());
}
static GTTransform()
{
Default = new GTTransform();
}
