public SplineActorNode(int idx, float x, float y, IMEPackage p, PathingGraphEditor grapheditor)
: base(idx, p, grapheditor)
{
var splprop = export.GetProperty <ArrayProperty <StructProperty> >("Connections");
if (splprop != null)
{
foreach (var prop in splprop)
{
var spcomp = prop.GetProp <ObjectProperty>("SplineComponent");
var cmpidx = spcomp?.Value ?? 0;
var cntcomp = prop.GetProp <ObjectProperty>("ConnectTo");
pcc.TryGetUExport(cntcomp?.Value ?? 0, out ExportEntry cnctn);
if (spcomp != null && cmpidx > 0)
{
var component = pcc.GetUExport(cmpidx);
var spline = new Spline(component, grapheditor, cnctn);
Splines.Add(spline);
spline.Pickable = false;
g.nodeLayer.AddChild(spline);
}
connections.Add(cnctn);
}
}
Vector3 tangent = CommonStructs.GetVector3(export, "SplineActorTangent", new Vector3(300f, 0f, 0f));
//(float controlPointX, float controlPointY, _) = tangent;
(float controlPointX, float controlPointY, float controlPointZ) = ActorUtils.GetLocalToWorld(export).TransformNormal(tangent);
LeaveTangentControlNode = new SplinePointControlNode(this, controlPointX, controlPointY, controlPointZ, UpdateMode.LeaveTangent);
ArriveTangentControlNode = new SplinePointControlNode(this, -controlPointX, -controlPointY, controlPointZ, UpdateMode.ArriveTangent);
AddChild(LeaveTangentControlNode);
AddChild(ArriveTangentControlNode);
shape = PPath.CreatePolygon(edgeShape);
outlinePen = new Pen(color);
shape.Pen = outlinePen;
shape.Brush = splineNodeBrush;
shape.Pickable = false;
AddChild(shape);
float w = shape.Width;
float h = shape.Height;
Bounds = new RectangleF(0, 0, w, h);
SText val = new SText(idx.ToString())
{
Pickable = false,
TextAlignment = StringAlignment.Center
};
val.X = w / 2 - val.Width / 2;
val.Y = h / 2 - val.Height / 2;
AddChild(val);
SetOffset(x, y);
}
public virtual void Die()
{
isDead = true;
ActorUtils.Play(audioSource);
//ActorUtils.TriggerDieAnimation(animator);
GameplayManager.Instance.OnActorDied(this);
Destroy(this.gameObject);
}
private void Start()
{
currentHealth = staticData.health;
SetCurrentHealthText();
if (animator != null)
{
ActorUtils.TriggerIdleAnimation(animator);
}
}
public override void Attack()
{
base.Attack();
//-- attack player
ActorUtils.TriggerAttackAnimation(animator);
//ActorUtils.Log(gameObject, "Attack");
if (preferredWeapon == null)
{
ActorUtils.Log(gameObject, "NoWeapon");
Debug.LogError("Enemy preferredWeapon must be defined");
}
Transform player = GameplayManager.Instance.Player.transform;
GameObject weapon = Instantiate(preferredWeapon, weaponSpawnPoint.position, Quaternion.identity);
float shootingAngle = 30f;
weapon.GetComponent <Rigidbody>().velocity = BallisticVelocity(player, shootingAngle);
}
public virtual void TakeDamage(float amount, WeaponSO.DamageType damageType)
{
if (isDead)
{
return;
}
currentHealth -= amount;
SetCurrentHealthText();
if (currentHealth <= 0)
{
Die();
}
else // using ActorUtils to "take a hit"
{
//ActorUtils.Play(staticData.takeDamageAudio);
//ActorUtils.TriggerTakeDamageAnimation(animator);
ActorUtils.Log(gameObject, "TakeDamage [" + amount + "]");
}
}
static ActorSystemSetup CreateBasicActorSystemAsset()
{
// Create the system asset
var asset = ActorUtils.CreateActorSystemSetup();
// Create the actors
var bridgeSetup = asset.CreateActorSetup <SampleBridgeActor>(); // bridge from the UI
var manifestSetup = asset.CreateActorSetup <ManifestActor>(); // load data from the manifest
var spatialSetup = asset.CreateActorSetup <SampleSpatialActor>(); // filter spatial instance entries
var instanceStreamingSetup = asset.CreateActorSetup <InstanceStreamingActor>(); // stream instance entries in batches
var gameObjectCreatorSetup = asset.CreateActorSetup <GameObjectCreatorActor>(); // gather SyncMesh, SyncMaterial and SyncTexture dependencies
var gameObjectConverterSetup = asset.CreateActorSetup <GameObjectConverterActor>(); // gather Mesh, Material and Texture asset dependencies
var gameObjectBuilderSetup = asset.CreateActorSetup <GameObjectBuilderActor>(); // instantiate GameObject
var unityResourceSetup = asset.CreateActorSetup <UnityResourceActor>(); // manage Mesh, Material and Texture assets
var modelResourceSetup = asset.CreateActorSetup <ModelResourceActor>(); // manage SyncModel
var dataProviderSetup = asset.CreateActorSetup <SampleDataProviderActor>(); // provide access to resource files
var meshConverterSetup = asset.CreateActorSetup <MeshConverterActor>(); // convert SyncMesh to Mesh
var materialConverterSetup = asset.CreateActorSetup <MaterialConverterActor>(); // convert SyncMaterial to Material
var textureConverterSetup = asset.CreateActorSetup <TextureConverterActor>(); // convert SyncTexture to Texture
var jobSetup = asset.CreateActorSetup <JobActor>(); // run jobs on the main thread
var pubSubSetup = asset.CreateActorSetup <PubSubActor>(); // manage event system
var dummySetup = asset.CreateActorSetup <SampleDummyActor>(); // connect to mandatory outputs not required in this sample
// Connect the actors
asset.ConnectRpc <UpdateManifests>(bridgeSetup, manifestSetup);
asset.ConnectRpc <GetManifests>(manifestSetup, dataProviderSetup);
asset.ConnectNet <EntryDataChanged>(manifestSetup, dummySetup);
asset.ConnectNet <SpatialDataChanged>(manifestSetup, spatialSetup);
asset.ConnectNet <UpdateStreaming>(spatialSetup, instanceStreamingSetup);
asset.ConnectNet <GameObjectCreated>(instanceStreamingSetup, dummySetup);
asset.ConnectRpc <CreateGameObject>(instanceStreamingSetup, gameObjectCreatorSetup);
asset.ConnectNet <ReleaseEntryData>(gameObjectCreatorSetup, manifestSetup);
asset.ConnectNet <ReleaseResource>(gameObjectCreatorSetup, modelResourceSetup);
asset.ConnectRpc <AcquireEntryData>(gameObjectCreatorSetup, manifestSetup);
asset.ConnectRpc <AcquireResource>(gameObjectCreatorSetup, modelResourceSetup);
asset.ConnectRpc <AcquireEntryDataFromModelData>(gameObjectCreatorSetup, manifestSetup);
asset.ConnectRpc <ConvertToGameObject>(gameObjectCreatorSetup, gameObjectConverterSetup);
asset.ConnectNet <ReleaseUnityResource>(gameObjectConverterSetup, unityResourceSetup);
asset.ConnectNet <ReleaseEntryData>(gameObjectConverterSetup, manifestSetup);
asset.ConnectRpc <AcquireEntryDataFromModelData>(gameObjectConverterSetup, manifestSetup);
asset.ConnectRpc <AcquireUnityResource>(gameObjectConverterSetup, unityResourceSetup);
asset.ConnectRpc <BuildGameObject>(gameObjectConverterSetup, gameObjectBuilderSetup);
asset.ConnectRpc <AcquireResource>(unityResourceSetup, modelResourceSetup);
asset.ConnectNet <ReleaseResource>(unityResourceSetup, modelResourceSetup);
asset.ConnectRpc <ConvertResource <SyncMesh> >(unityResourceSetup, meshConverterSetup);
asset.ConnectRpc <ConvertResource <SyncMaterial> >(unityResourceSetup, materialConverterSetup);
asset.ConnectRpc <ConvertResource <SyncTexture> >(unityResourceSetup, textureConverterSetup);
asset.ConnectRpc <GetSyncModel>(modelResourceSetup, dataProviderSetup);
asset.ConnectRpc <DelegateJob>(meshConverterSetup, jobSetup);
asset.ConnectNet <ReleaseUnityResource>(materialConverterSetup, unityResourceSetup);
asset.ConnectNet <ReleaseEntryData>(materialConverterSetup, manifestSetup);
asset.ConnectRpc <AcquireUnityResource>(materialConverterSetup, unityResourceSetup);
asset.ConnectRpc <AcquireEntryDataFromModelData>(materialConverterSetup, manifestSetup);
return(asset);
}
public void UpdateSplines(UpdateMode mode, bool save = false)
{
if (mode == UpdateMode.ArriveTangent || mode == UpdateMode.LeaveTangent)
{
Vector3 worldCoords;
if (mode == UpdateMode.ArriveTangent)
{
worldCoords = new Vector3(ArriveTangentControlNode.OffsetX, ArriveTangentControlNode.OffsetY, ArriveTangentControlNode.Z);
LeaveTangentControlNode.SetOffset(-worldCoords.X, -worldCoords.Y);
worldCoords = -worldCoords;
}
else
{
worldCoords = new Vector3(LeaveTangentControlNode.OffsetX, LeaveTangentControlNode.OffsetY, LeaveTangentControlNode.Z);
ArriveTangentControlNode.SetOffset(-worldCoords.X, -worldCoords.Y);
}
if (save)
{
//will cause a refresh,so no need to update UI
export.WriteProperty(CommonStructs.Vector3Prop(ActorUtils.GetWorldToLocal(export).TransformNormal(worldCoords), "SplineActorTangent"));
return;
}
foreach (Spline spline in Splines)
{
spline.SplineInfo.Points[0].ArriveTangent = -worldCoords;
spline.SplineInfo.Points[0].LeaveTangent = worldCoords;
UpdateSpline(spline);
}
foreach (SplineActorNode prevSplineActor in LinksFrom)
{
foreach (Spline spline in prevSplineActor.Splines)
{
if (spline.NextActor == export)
{
spline.SplineInfo.Points[1].ArriveTangent = worldCoords;
spline.SplineInfo.Points[1].LeaveTangent = -worldCoords;
UpdateSpline(spline);
}
}
}
}
else
{
float z = (float)SharedPathfinding.GetLocation(export).Z;
Vector3 location = new Vector3(OffsetX, OffsetY, z);
if (save)
{
//will cause a refresh,so no need to update UI
SharedPathfinding.SetLocation(export, location.X, location.Y, location.Z);
return;
}
foreach (Spline spline in Splines)
{
spline.SplineInfo.Points[0].OutVal = location;
UpdateSpline(spline);
}
foreach (SplineActorNode prevSplineActor in LinksFrom)
{
foreach (Spline spline in prevSplineActor.Splines)
{
if (spline.NextActor == export)
{
spline.SplineInfo.Points[1].OutVal = location;
UpdateSpline(spline);
}
}
}
}
PathingGraphEditor.UpdateEdgeStraight(ArriveTangentControlNode.Edge);
PathingGraphEditor.UpdateEdgeStraight(LeaveTangentControlNode.Edge);
void UpdateSpline(Spline spline)
{
spline.RegenerateReparamTable();
for (int i = 0; i < spline.ReparamTable.Points.Count; i++)
{
(float x, float y, _) = spline.SplineInfo.Eval(spline.ReparamTable.Points[i].OutVal, Vector3.Zero);
spline.nodes[i].SetOffset(x, y);
}
if (spline.nodes.Count > 7)
{
var directionVector = new Vector2(spline.nodes[7].OffsetX, spline.nodes[7].OffsetY) - new Vector2(spline.nodes[5].OffsetX, spline.nodes[5].OffsetY);
directionVector.Normalize();
spline.nodes[6].Rotation = (float)(Math.Atan2(directionVector.X, -directionVector.Y) * 180 / Math.PI);
}
foreach (PathfindingEditorEdge edge in spline.edges)
{
PathingGraphEditor.UpdateEdgeStraight(edge);
}
}
}
