/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
SubscribeToTickEvent();
//init doorBodyInitPosition and doorBody
if (PhysicsModel != null)
{
for (int n = 0; n < PhysicsModel.Bodies.Length; n++)
{
if (PhysicsModel.Bodies[n].Name == "door" || PhysicsModel.Bodies[n].Name == "door1")
{
Mat4 transform = PhysicsModel.ModelDeclaration.Bodies[n].GetTransform();
doorBody1InitPosition = transform.Item3.ToVec3();
}
else if (PhysicsModel.Bodies[n].Name == "door2")
{
Mat4 transform = PhysicsModel.ModelDeclaration.Bodies[n].GetTransform();
doorBody2InitPosition = transform.Item3.ToVec3();
}
}
doorBody1 = PhysicsModel.GetBody("door1");
if (doorBody1 == null)
{
doorBody1 = PhysicsModel.GetBody("door");
}
doorBody2 = PhysicsModel.GetBody("door2");
}
UpdateDoorBodies();
UpdateAttachedObjects();
}
protected override void OnTick()
{
base.OnTick();
if (firstWay == true)
{
ActivateWayMovement();
}
UpdateGeneralTask();
CalculateThings();
chassisBody = PhysicsModel.GetBody("main");
if (chassisBody == null)
{
Log.Error("Emrah Helli: \"main\" chassisBody dose not exists.");
return;
}
float diff = Position.Z - flyHeight;
float force = -diff - chassisBody.LinearVelocity.Z;
MathFunctions.Clamp(ref force, -10, 10);
chassisBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta,
new Vec3(0, 0, force * 3) * chassisBody.Mass, new Vec3(0, 0, 1));
chassisBody.AngularDamping = 1;
this.flyHeight = TaskPosition.Z;
float ZA = ZADiffAngle * 4;
if (ZA < 20 && ZA > -20)
{
chassisBody.AngularVelocity = new Vec3
(chassisBody.AngularVelocity.X, chassisBody.AngularVelocity.Y, ZA);
}
else if (ZA > 20)
{
chassisBody.AngularVelocity = new Vec3
(chassisBody.AngularVelocity.X, chassisBody.AngularVelocity.Y, -2);
}
else if (ZA < -20)
{
chassisBody.AngularVelocity = new Vec3
(chassisBody.AngularVelocity.X, chassisBody.AngularVelocity.Y, 2);
}
chassisBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(Velocity * chassisBody.Mass, 0, 0), new Vec3(-1, 0, 0));
chassisBody.LinearDamping = 1;
//check outside Map position
Bounds checkBounds = Map.Instance.InitialCollisionBounds;
checkBounds.Expand(new Vec3(300, 300, 10000));
if (!checkBounds.IsContainsPoint(Position))
{
SetDeleted();
}
}
private void Client_ReceiveHitCall(RemoteEntityWorld sender, ReceiveDataReader reader)
{
Vec3 hitPosition = reader.ReadVec3();
string hitShapeBodyName = reader.ReadString();
string hitShapeName = reader.ReadString();
Vec3 hitNormal = reader.ReadVec3();
MapObject hitMapObject = Entities.Instance.GetByNetworkUIN(reader.ReadVariableUInt32()) as MapObject;
if (!reader.Complete())
{
return;
}
Position = hitPosition;
Shape hitShape = null;
if (PhysicsModel != null)
{
Body body = PhysicsModel.GetBody(hitShapeBodyName);
if (body != null)
{
hitShape = body.GetShape(hitShapeName);
}
}
OnHit(hitShape, hitNormal, hitMapObject);
}
///////////////////////////////////////////
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
SubscribeToTickEvent();
CreateThreads();
magnetBody = PhysicsModel.GetBody("magnet");
if (magnetBody != null)
{
magnetBody.Collision += magnetBody_Collision;
}
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
SetTurnToPosition(Position + Rotation.GetForward() * 100);
if (PhysicsModel != null)
{
PhysicsModel.PopFromWorld();
Damager_Ball = PhysicsModel.GetBody("Damager_Ball");
Damager_Ball_Player = PhysicsModel.GetBody("CT");
//if (Damager_Ball_Player != null)
//{
// //this.Type.BallRadius = .5f;//((Damager_Ball_Player.Shapes[0].Volume * 3f) / (4f * (float)Math.PI) * .333333f);
// foreach (Body body in PhysicsModel.Bodies)
// body.Collision += new Body.CollisionDelegate(body_Collision);
//}
if (!EntitySystemWorld.Instance.IsEditor())
{
Damager_Ball_Player.Shapes[0].Density = PhysicsDensity;
Damager_Ball_Player.Shapes[0].DynamicFriction = PhysicsDynamicFriction;
Damager_Ball_Player.Shapes[0].Restitution = PhysicsBounciness; //Bounciness
Damager_Ball_Player.Shapes[0].StaticFriction = PhysicsStaticFriction;
Damager_Ball_Player.Shapes[0].SpecialLiquidDensity = PhysicsLiquidDensity;
Damager_Ball_Player.Shapes[0].ContactGroup = (int)ContactGroup.Dynamic;
Damager_Ball_Player.EnableGravity = true;
Damager_Ball_Player.LinearVelocity = linearVelocityForSerialization;
}
if (!EntitySystemWorld.Instance.IsEditor())
{
if (Damager_Ball_Player == null)
{
Log.Error("Damager_Ball.type: \"Damager_Ball\" body does not exist. The Physics Body is Named incorrectly?");
}
}
SubscribeToTickEvent();
CheckPhysicsProperties();
PhysicsModel.PushToWorld();
}
//Incin
//if activeMaxTurrets turret was out from before RemoveMiniTurret it
//if (turret != null)
//{
// turret.SetForDeletion(false);
// turretTimer = 0; //reset remove timer
// activeturrets = 0; //reset turret counts
//}
}
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
AKJetBody = PhysicsModel.GetBody("Jet");
if (AKJetBody == null)
{
Log.Error("AKJet: \"AKJet\" AKJetBody does not exist.");
return;
}
Stall = false;
AddTimer();
}
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
HelliBody = PhysicsModel.GetBody("Helli");
if (HelliBody == null)
{
Log.Error("Helli: \"Helli\" HelliBody dose not exists.");
return;
}
SubscribeToTickEvent();
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
AddTimer();
if (!EngineApp.Instance.IsResourceEditor)
{
if (PhysicsModel == null)
{
Log.Error("Forklift: Physics model not exists.");
return;
}
forkliftBody = PhysicsModel.GetBody("forklift");
if (forkliftBody == null)
{
Log.Error("Forklift: \"forklift\" body not exists.");
return;
}
leftwheelBody = PhysicsModel.GetBody("leftwheel");
rightwheelBody = PhysicsModel.GetBody("rightwheel");
forkBody = PhysicsModel.GetBody("fork");
up1Body = PhysicsModel.GetBody("up1");
up2Body = PhysicsModel.GetBody("up2");
b2Body = PhysicsModel.GetBody("b2");
b1Body = PhysicsModel.GetBody("b1");
wheelRearRightBody = PhysicsModel.GetBody("wheelRearRight");
wheelRearLeftBody = PhysicsModel.GetBody("wheelRearLeft");
foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
{
if (attachedObject.Alias == "leftWheel")
{
leftWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "rightWheel")
{
rightWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
}
if (leftWheel.wheelHelpers.Count != 0)
{
wheelsPositionYOffset = Math.Abs(leftWheel.wheelHelpers[0].PositionOffset.Y);
}
}
//initialize currentGear
currentGear = Type.Gears.Find(delegate(ForkliftType.Gear gear)
{
return(gear.Number == 0);
});
}
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
AKVTOLBody = PhysicsModel.GetBody("Jet");
if (AKVTOLBody == null)
{
Log.Error("AKVTOL: \"AKVTOL\" AKVTOLBody dose not exists.");
return;
}
AddTimer();
EngineDir = 90f;
}
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
SubscribeToTickEvent();
if (EntitySystemWorld.Instance.WorldSimulationType != WorldSimulationTypes.Editor)
{
if (PhysicsModel == null)
{
Log.Error("Class AKCar: Physics model not exists.");
return;
}
chassisBody = PhysicsModel.GetBody("AKCar");
if (chassisBody == null)
{
Log.Error("Class AKCar: \"AKCar\" body dose not exists.");
return;
}
//chassisBody.Collision += chassisBody_Collision;
foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
{
if (attachedObject.Alias == "leftTrack")
{
leftTrack.trackHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "rightTrack")
{
rightTrack.trackHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
}
if (leftTrack.trackHelpers.Count != 0)
{
tracksPositionYOffset = Math.Abs(leftTrack.trackHelpers[0].PositionOffset.Y);
}
}
//initialize currentGear
currentGear = Type.Gears.Find(delegate(AKCarType.Gear gear)
{
return(gear.Number == 0);
});
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
if (PhysicsModel != null)
{
turretBody = PhysicsModel.GetBody("turret");
baseBody = PhysicsModel.GetBody("base");
}
if (!EntitySystemWorld.Instance.IsEditor())
{
if (turretBody == null)
{
Log.Error("Turret: \"turret\" body not exists.");
}
if (baseBody == null)
{
Log.Error("Turret: \"base\" body not exists.");
}
}
//mainGun
foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
{
MapObjectAttachedMapObject attachedMapObject = attachedObject as MapObjectAttachedMapObject;
if (attachedMapObject == null)
{
continue;
}
mainGun = attachedMapObject.MapObject as Gun;
if (mainGun != null)
{
mainGunAttachedObject = attachedMapObject;
mainGunOffsetPosition = attachedMapObject.PositionOffset;
break;
}
}
SubscribeToTickEvent();
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
AddTimer();
//init doorBodyInitPosition and doorBody
if (PhysicsModel != null)
{
for (int n = 0; n < PhysicsModel.Bodies.Length; n++)
{
if (PhysicsModel.Bodies[n].Name == "door")
{
Mat4 transform = PhysicsModel.ModelDeclaration.Bodies[n].GetTransform();
doorBodyInitPosition = transform.Item3.ToVec3();
break;
}
}
doorBody = PhysicsModel.GetBody("door");
}
UpdateDoorBody();
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
AddTimer();
if (EntitySystemWorld.Instance.WorldSimulationType != WorldSimulationTypes.Editor)
{
if (PhysicsModel == null)
{
Log.Error("AKtank: Physics model not exists.");
return;
}
chassisBody = PhysicsModel.GetBody("chassis");
if (chassisBody == null)
{
Log.Error("AKtank: \"chassis\" body not exists.");
return;
}
foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
{
if (attachedObject.Alias == "leftTrack")
{
leftTrack.trackHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "rightTrack")
{
rightTrack.trackHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "leftWheel")
{
Track.WheelObject wo = new Track.WheelObject();
wo.mesh = (MapObjectAttachedMesh)attachedObject;
float rad = wo.mesh.MeshObject.Bounds.GetRadius();
wo.circumference = 2 * MathFunctions.PI * rad;
leftTrack.wheels.Add(wo);
}
if (attachedObject.Alias == "rightWheel")
{
Track.WheelObject wo = new Track.WheelObject();
wo.mesh = (MapObjectAttachedMesh)attachedObject;
float rad = wo.mesh.MeshObject.Bounds.GetRadius();
wo.circumference = 2 * MathFunctions.PI * rad;
leftTrack.wheels.Add(wo);
}
}
if (leftTrack.trackHelpers.Count != 0)
{
tracksPositionYOffset = Math.Abs(leftTrack.trackHelpers[0].PositionOffset.Y);
}
}
//initialize currentGear
currentGear = Type.Gears.Find(delegate(AKtankType.Gear gear)
{
return(gear.Number == 0);
});
//replace track materials
if (EntitySystemWorld.Instance.WorldSimulationType != WorldSimulationTypes.Editor)
{
InitTracksAnimation();
}
}
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary>
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
if (!EntitySystemWorld.Instance.IsEditor())
{
if (PhysicsModel == null)
{
Log.Error("Vehicle: Physics model not exists.");
return;
}
chassisBody = PhysicsModel.GetBody("chassis");
if (chassisBody == null)
{
Log.Error("Vehicle: \"chassis\" body not exists.");
return;
}
foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
{
if (attachedObject.Alias == "LFWheel")
{
LFWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "RFWheel")
{
RFWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "LRWheel")
{
LRWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
if (attachedObject.Alias == "RRWheel")
{
RRWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject);
}
}
if (LFWheel.wheelHelpers.Count != 0)
{
LFWheelPositionYOffset = Math.Abs(LFWheel.wheelHelpers[0].PositionOffset.Y);
}
if (LRWheel.wheelHelpers.Count != 0)
{
LRWheelPositionYOffset = Math.Abs(LRWheel.wheelHelpers[0].PositionOffset.Y);
}
if (RFWheel.wheelHelpers.Count != 0)
{
RFWheelPositionYOffset = Math.Abs(RFWheel.wheelHelpers[0].PositionOffset.Y);
}
if (RRWheel.wheelHelpers.Count != 0)
{
RRWheelPositionYOffset = Math.Abs(RRWheel.wheelHelpers[0].PositionOffset.Y);
}
//initialize currentGear
currentGear = Type.Gears.Find(delegate(CarType.Gear gear)
{
return(gear.Number == 0);
});
}
AddTimer();
}
private void TickRotation()
{
bool onGround = LFWheel.onGround || RFWheel.onGround;
float carspeed = GetWheelsSpeed();
float LFWheelThrottle = 0;
float RFWheelThrottle = 0;
if (Intellect != null)
{
Body WFR = PhysicsModel.GetBody("FR");
Body WFL = PhysicsModel.GetBody("FL");
Body WRR = PhysicsModel.GetBody("RR");
Body WRL = PhysicsModel.GetBody("RL");
float wheelspeed = GetWheelsSpeed() * 2;
Vec3 Wspeed = new Vec3(0, wheelspeed,
0) * chassisBody.Rotation.GetNormalize();
if (onGround)
{
WFR.AngularVelocity = Wspeed;
WFL.AngularVelocity = Wspeed;
WRR.AngularVelocity = Wspeed;
WRL.AngularVelocity = Wspeed;
}
{
ServoMotor motor_1 = PhysicsModel.GetMotor("wheel1") as ServoMotor;
ServoMotor motor_2 = PhysicsModel.GetMotor("wheel2") as ServoMotor;
if (motor_1 != null)
{
if (motor_2 != null)
{
float turnspeed = 0.5f;
MathFunctions.Clamp(ref turnspeed, 0.5f, 0.5f);
Radian needAngle = motor_1.DesiredAngle;
if (Intellect.IsControlKeyPressed(GameControlKeys.Left))
{
if (carspeed > 2)
{
LFWheelThrottle -= turnspeed;
RFWheelThrottle += turnspeed;
}
if (carspeed < -1)
{
LFWheelThrottle += turnspeed;
RFWheelThrottle -= turnspeed;
}
needAngle -= 0.2f;
}
else if (Intellect.IsControlKeyPressed(GameControlKeys.Right))
{
if (carspeed > 2)
{
LFWheelThrottle += turnspeed;
RFWheelThrottle -= turnspeed;
}
if (carspeed < -1)
{
LFWheelThrottle -= turnspeed;
RFWheelThrottle += turnspeed;
}
needAngle += 0.2f;
}
else
{
needAngle = 0f;
}
MathFunctions.Clamp(ref needAngle, new Degree(-37.0f).InRadians(),
new Degree(37.0f).InRadians());
motor_1.DesiredAngle = needAngle;
motor_2.DesiredAngle = needAngle;
}
}
}
}
}
protected override void OnPostCreate(bool loaded)
{
base.OnPostCreate(loaded);
current_gears = Type.CONF.SoundGears.Find(delegate(SSDCType.SSDC_CONF.SoundGear gear)
{
return(gear.Number == 0);
});
if (EngineApp.Instance.ApplicationType != EngineApp.ApplicationTypes.ResourceEditor)
{
if (PhysicsModel == null)
{
Log.Error("Car: Physics model not exists.");
return;
}
car_body = PhysicsModel.GetBody("chassis");
dmd_shape = car_body.GetShape("dmd");
if (car_body == null)
{
Log.Error("Car: \"chassis\" body not exists.");
return;
}
if (dmd_shape == null)
{
Log.Error("Car: \"dmd\" shape not exists.");
return;
}
attached_mesh = GetFirstAttachedObjectByAlias("dmd") as MapObjectAttachedMesh;
if (attached_mesh == null)
{
Log.Error("Car: mesh by \"dmd\" alias not exists.");
return;
}
else
{
mesh_name = this.Name;
attached_mesh.MeshObject.Mesh.Save("Data\\" + mesh_name + ".mesh");
attached_mesh.MeshName = mesh_name + ".mesh";
mesh = attached_mesh.MeshObject.Mesh;
if (Type.CONF.RandomMaterials.Any())
{
attached_mesh.MeshObject.SetMaterialNameForAllSubObjects(Type.CONF.RandomMaterials[World.Instance.Random.Next(0, Type.CONF.RandomMaterials.Count)].Path);
}
}
if (Type.CONF.Deformation)
{
ParsingMesh();
}
}
if (EntitySystemWorld.Instance.WorldSimulationType != WorldSimulationTypes.Editor)
{
SubscribeToTickEvent();
MapObjectAttachedObject[] ortbrake = GetAllAttachedObjectsByAlias("brake");
for (int i = 0; i < ortbrake.Length; i++)
{
MapObjectAttachedRibbonTrail rt = ortbrake[i] as MapObjectAttachedRibbonTrail;
if (rt != null)
{
rtbrake.Add(rt.RibbonTrail);
}
}
}
if (car_body != null)
{
car_body.Collision += OnCollision;
}
}
