//**********************************************************
//初期化
public void initEnemy(FormationDataBean d)
{
data = d;
Vector2 vec;
switch(data.movement){
case "Vector":
//1番目のx,yのセットをベクトルの方向としてセット
vec = new Vector2 (data.bezierParam[0], data.bezierParam[1]).normalized; //単位ベクトル
this.GetComponent<Rigidbody2D>().AddForce(vec * data.speed);
//２番目のx,yのyをストップ座標としてセットする。
if(data.bezierParam[3] != 0){
//viewport座標で指定
Vector3 tmpPos = common.getWorldPosFromViewPos (new Vector3(0f,data.bezierParam [3] / 100, 0f));
stopY = tmpPos.y;
}
break;
case "GravityRandom":
Vector3 pos = transform.position;
pos.x = (Random.value * 5) - 2.5f;
this.transform.position = pos;
break;
case "Bezier":
myBezier = new Bezier(new Vector3 (this.transform.position.x, this.transform.position.y, this.transform.position.z),
common.getWorldPosFromViewPos (new Vector3 (data.bezierParam [0] / 100, data.bezierParam [1] / 100, 0f)),
common.getWorldPosFromViewPos (new Vector3 (data.bezierParam [2] / 100, data.bezierParam [3] / 100, 0f)),
common.getWorldPosFromViewPos (new Vector3 (data.bezierParam [4] / 100, data.bezierParam [5] / 100, 0f))
);
break;
}
}
public void Aim ( Vector3 pos, Vector3 dir ) {
if ( thrown ) { return; }
RaycastHit hit = new RaycastHit ();
if ( Physics.Raycast ( pos, dir, out hit, range ) ) {
endNormal = hit.normal;
bezier = new Bezier ( this.transform.position, dir, Vector3.up, hit.point );
} else if ( Physics.Raycast ( pos + dir * range, Vector3.down, out hit, Mathf.Infinity ) ) {
endNormal = hit.normal;
bezier = new Bezier ( this.transform.position, dir, Vector3.up, hit.point );
}
if ( lineRenderer != null && bezier != null ) {
lineRenderer.SetVertexCount ( 32 );
for ( int i = 0; i < 32; i++ ) {
float time = ( i * 1.0f ) * ( 1.0f / 32f );
lineRenderer.SetPosition ( i, bezier.GetPointAtTime ( time ) );
}
}
distance = Vector3.Distance ( pos, hit.point );
}
void addPoint(BezierPath path, BezierPath.PathPoint point)
{
Undo.RegisterUndo(path, "create bezier point");
// if lsat point, add new. if middle point, add point inbetween
if(path.points.Count - 1 == path.points.IndexOf(point))
{
// add at end
BezierPath.PathPoint p = new BezierPath.PathPoint();
if(point.h1.magnitude < Mathf.Epsilon)
p.p1 = point.p1 + (Vector3.right) * 2;
else
p.p1 = point.p1 + (point.h1).normalized * 2;
p.h1 = point.h1;
path.points.Add(p);
selectedPoint = p;
}
else
{
// add in middle
BezierPath.PathPoint point2 = path.points[path.points.IndexOf(point) + 1];
Bezier b = new Bezier(point.p1, point.h1, -point2.h1, point2.p1);
BezierPath.PathPoint p = new BezierPath.PathPoint();
p.p1 = b.GetPointAtTime(0.5f);
p.h1 = b.GetPointAtTime(0.6f) - p.p1;
path.points.Insert(path.points.IndexOf(point) + 1, p);
}
}
// Use this for initialization
void Start()
{
_lineRenderer = this.GetComponent<LineRenderer>();
MyBezier = new Bezier(Point1.position, Point2.position, Point3.position, Point4.position);
GenerateSpline();
}
void SetTarget(Creature target)
{
m_target = target;
Vector3 handle1 = transform.position;
handle1 += (transform.forward+transform.up)*(Vector3.Distance(transform.position, target.transform.position)*0.5f);
Vector3 handle2 = target.transform.position;
handle2.y = 3f;
m_bezier = new Bezier(gameObject, target.gameObject, handle1, handle2, 0.06f);
}
public Vector2[] CalculateEvenlySpacedPoints(float spacing, float resolution = 1)
{
List <Vector2> evenlySpacedPoints = new List <Vector2>();
evenlySpacedPoints.Add(points[0]);
Vector2 previousPoint = points[0];
float dstSinceLastEvenPoint = 0;
for (int segmentIndex = 0; segmentIndex < NumSegment; segmentIndex++)
{
Vector2[] p = GetPointsInSegment(segmentIndex);
float controlNetLength = Vector2.Distance(p[0], p[1]) + Vector2.Distance(p[1], p[2]) + Vector2.Distance(p[2], p[3]);
float estimatedCurveLength = Vector2.Distance(p[0], p[3]) + controlNetLength / 2f;
int divisions = Mathf.CeilToInt(estimatedCurveLength * resolution * 10);
float t = 0;
while (t <= 1)
{
t += 1f / divisions;
Vector2 pointOnCurve = Bezier.EvaluateCubic(p[0], p[1], p[2], p[3], t);
dstSinceLastEvenPoint += Vector2.Distance(previousPoint, pointOnCurve);
while (dstSinceLastEvenPoint >= spacing)
{
float overshootDst = dstSinceLastEvenPoint - spacing;
Vector2 newEvenlySpacedPoint = pointOnCurve + (previousPoint - pointOnCurve).normalized * overshootDst;
evenlySpacedPoints.Add(newEvenlySpacedPoint);
dstSinceLastEvenPoint = overshootDst;
previousPoint = newEvenlySpacedPoint;
}
previousPoint = pointOnCurve;
}
}
return(evenlySpacedPoints.ToArray());
}
void Update()
{
Collider[] col = Physics.OverlapSphere(transform.position, radius);
foreach (var item in col)
{
item.transform.LookAt(transform);
float delay = Mathf.Lerp(2, magnetDelay, Mathf.InverseLerp(5, 0, Vector3.Distance(transform.position, item.transform.position)));
Destroy(item, delay);
}
u = Mathf.MoveTowards(u, uTarget, vel * Time.deltaTime);
transform.position = bezier.calcBezier(u);
if (u == uTarget)
{
if (bezier.dir)
{
bezier = bezier.dir as Bezier;
u = uIni;
}
else
{
enabled = false;
}
}
}
public BezierChart(ChartView BaseChart)
{
bezier = new Bezier();
var = new Variables.Variables();
BaseChart.Chart.Title.Text = "Bezier series";
bezier.FillSampleValues(10);
bezier.LinePen.Visible = true;
bezier.LinePen.Transparency = 0;
bezier.LinePen.Width = 2;
bezier.LinePen.Color = var.GetPaletteBasic[0].AddLuminosity(-0.1);
bezier.Smoothed = true;
BaseChart.Chart.Series.Add(bezier);
BaseChart.Chart.Axes.Left.Visible = true;
BaseChart.Chart.Axes.Bottom.Visible = true;
BaseChart.Chart.Axes.Left.Increment = 20;
BaseChart.Chart.Axes.Left.AxisPen.Visible = true;
BaseChart.Chart.Legend.Visible = false;
BaseChart.Chart.Axes.Left.Visible = true;
BaseChart.Chart.Axes.Left.AxisPen.Visible = true;
BaseChart.Chart.Axes.Left.Ticks.Transparency = 100;
BaseChart.Chart.Axes.Bottom.Visible = true;
BaseChart.Chart.Axes.Bottom.AxisPen.Visible = true;
BaseChart.Chart.Axes.Left.Grid.Visible = true;
BaseChart.Chart.Axes.Left.SetMinMax(BaseChart.Chart.Axes.Left.MinYValue, BaseChart.Chart.Axes.Left.MaxYValue);
BaseChart.Chart.Axes.Bottom.SetMinMax(0, BaseChart.Chart.Axes.Bottom.MaxXValue);
}
//makes velocity vector's magnitude equal to one, so just shows the direction of the velocity
public Vector3 GetDirection(float t)
{
return((transform.TransformPoint(Bezier.GetFirstDerivative(points[0], points[1], points[2], points[3], t)) - transform.position).normalized);
}
public static Vector3 GetPointPosition(Vector3 start, Vector3 end, Vector3 helper, float t)
{
return(Bezier.Calculate(start, helper, end, t));
}
//Function called externally from BezierCurveInspector.cs to access a specific handle point on our curve
public Vector3 GetPoint(float t_)
{
return(this.transform.TransformPoint(Bezier.GetPoint(this.points[0], this.points[1], this.points[2], this.points[3], t_)));
}
void Move()
{
if (enemy2) {
if (enemyAi[aiIndex].MovePattern == 2 || enemyAi[aiIndex].MovePattern == 5 || enemyAi[aiIndex].MovePattern == 7) {
this.gameObject.GetComponent<Animator>().SetBool("Right", true);
}
else if (enemyAi[aiIndex].MovePattern == 3 || enemyAi[aiIndex].MovePattern == 4 || enemyAi[aiIndex].MovePattern == 6) {
this.gameObject.GetComponent<Animator>().SetBool("Left", true);
}
else {
this.gameObject.GetComponent<Animator>().SetBool("Right", false);
this.gameObject.GetComponent<Animator>().SetBool("Left", false);
}
}
if (circle) {
Vector3 bezPos = bezier.GetPointAtTime(bezTimer);
this.transform.position = new Vector3(bezPos.x, bezPos.y, 0);
if (bezTimer <= DirectionData.bezierDirectionData[enemyAi[aiIndex].BezId].bezTime) {
bezTimer += 0.001f;
}
else {
circle = false;
}
}
else {
GetComponent<Rigidbody2D>().velocity = EnemyMoveDirection[enemyAi[aiIndex].MovePattern] * enemyAi[aiIndex].Speed;
if (bezInit) {
if (bezWarmUpTimer >= DirectionData.bezierDirectionData[enemyAi[aiIndex].BezId].bezWarmTime) {
DirectionData.BezierBase bezData = DirectionData.bezierDirectionData[enemyAi[aiIndex].BezId];
bezier = new Bezier(this.transform.localPosition, bezData.CtlPoint1, bezData.CtlPoint2, bezData.endPoint);
circle = true;
}
bezWarmUpTimer += Time.deltaTime;
}
}
}
public Vector3 GetLocalVelocity(float t)
{
return(Bezier.GetFirstDerivative(Vector3.zero, points[0], points[1], points[2], t));
}
public Bezier_Curve(List <Vector3> p_)
{
bezier = new Bezier(p_);
}
public void Execute(ArchetypeChunk chunk, int index, int entityOffset)
{
var localToParentAcessor = chunk.GetNativeArray(localToParentType);
var animationAcessor = chunk.GetNativeArray(splineAnimationType);
var justSpawnedAcessor = default(NativeArray <JustSpawned>);
if (chunk.Has(justSpawnedType))
{
justSpawnedAcessor = chunk.GetNativeArray(justSpawnedType);
}
for (int i = 0; i < chunk.Count; i++)
{
SplineAnimationSpeed anim = animationAcessor[i];
var elements = elementAcessor[anim.spline];
var segments = segmentAcessor[anim.spline];
if (anim.index >= elements.Length)
{
continue;
}
float move = anim.speed * deltaTime;
if (justSpawnedAcessor.IsCreated)
{
move = anim.speed * justSpawnedAcessor[i].deltaTime;
}
float left;
SplineSegment segment = segments[anim.segIndex];
while (move >= (left = (segment.end - anim.t) / (segment.end - segment.start) * segment.length))
{
move -= left;
if (++anim.segIndex >= segments.Length || segments[anim.segIndex].start == 0)
{
if (anim.isLoop)
{
if (++anim.index >= elements.Length)
{
anim.index = 0;
anim.segIndex = 0;
}
}
else
{
if (++anim.index >= elements.Length - 1)
{
anim.index = elements.Length;
anim.segIndex = 0;
anim.t = 0;
break;
}
}
}
segment = segments[anim.segIndex];
anim.t = segment.start;
}
if (anim.index >= elements.Length)
{
SplineElement last = elements[elements.Length - 1];
localToParentAcessor[i] = new LocalToParent {
Value = math.float4x4(last.rotation, last.point)
};
}
else
{
anim.t += (move / segment.length) * (segment.end - segment.start);
SplineElement start = elements[anim.index];
SplineElement end = anim.index < elements.Length - 1 ? elements[anim.index + 1] : elements[0];
float3 position = Bezier.GetPoint(start.point, start.point + start.forward, end.point + end.backward, end.point, anim.t);
quaternion rotation = math.nlerp(start.rotation, end.rotation, anim.t);
localToParentAcessor[i] = new LocalToParent {
Value = math.float4x4(rotation, position)
};
}
animationAcessor[i] = anim;
}
}
void Update () {
//reset array transform
if (TestNullReferenceTransform()) {
pointsTransform = ReCalculateArrayTransform();
}
if (pointsTransform.Length < 2 && previewCountPointsTransform != pointsTransform.Length)
{
points = new Vector3[0];
lineRenderer.SetVertexCount(0);
}
previewCountPointsTransform = pointsTransform.Length;
//inherit points for array transform
if (pointsTransform.Length > 1 ) {
points = new Vector3[pointsTransform.Length];
for (int i = 0; i < pointsTransform.Length; i++)
points[i] = pointsTransform[i].position;
}
//exit if not met the basic conditions
if (points.Length < 2)
return;
//create lights
if (points.Length != previewCountPoints && onLight || onLight && lights == null)
{
DestroyLights();
lights = new Light[points.Length - 1];
for (int i = 0; i < points.Length - 1; i++)
{
Vector3 midPoint = Vector3.Lerp(points[i], points[i + 1], 0.5f);
GameObject go = new GameObject("light " + i.ToString());
go.transform.position = midPoint;
go.transform.parent = gameObject.transform;
lights[i] = go.AddComponent<Light>();
}
}
previewCountPoints = points.Length;
//Destroy lights
if (!onLight && lights != null)
DestroyLights();
if (Time.time > lastTimeChangePosition + delayChangedPosition)
{
lastTimeChangePosition = Time.time;
//save prewiev state line
if (listSmoothingPointsPatch.Count > 0)
{
previewListSmoothingPointsPatch.Clear();
previewListSmoothingPointsPatch.AddRange(listSmoothingPointsPatch);
}
listSmoothingPointsPatch.Clear();
listBasePointsPatch.Clear();
AnimationCurve curveTurbulent = new AnimationCurve(new Keyframe(0, peripheryAmplititude * scale), new Keyframe(1, centralAmplitude * scale), new Keyframe(2, peripheryAmplititude * scale));
for (int i = 0; i < points.Length - 1; i++)
{
//create point for line electricity
List<Vector3> listBasePoints = new List<Vector3>();
Vector3 directionToPoint2 = points[i + 1] - points[i];
float fullDistance = Vector3.Distance(points[i], points[i + 1]);
int countPoints = (int)(fullDistance / minDistanceBeetwenPoints) + 1;
float currentDistance = (fullDistance / countPoints);
for (int g = 0; g < countPoints + 1; g++)
{
Vector3 newPointPosition = points[i] + (directionToPoint2.normalized * (currentDistance * g));
float coeffEvolute = ((float)g / (float)(countPoints )) * 2;
Vector3 axisRandom = Quaternion.AngleAxis(Random.Range(-180, 180), directionToPoint2) * new Vector3(directionToPoint2.y, directionToPoint2.x * -1, 0) ;
newPointPosition = newPointPosition + (axisRandom.normalized * (Random.Range(-curveTurbulent.Evaluate(coeffEvolute), curveTurbulent.Evaluate(coeffEvolute))));
listBasePoints.Add(newPointPosition);
}
listBasePointsPatch.AddRange(listBasePoints);
//Move lights to midle points line electricity
if (onLight)
lights[i].transform.position = Vector3.Lerp(points[i], points[i + 1], 0.5f);
//create points smoothing
Bezier bezier = new Bezier(listBasePoints.ToArray());
int countSmoothingPoints = (int)(fullDistance / minDistanceBeetwenSmoothingPoints);
listSmoothingPointsPatch.AddRange(bezier.GetSmoothingPoints(countSmoothingPoints));
}
}
//apply light setting
if (onLight)
foreach (Light l in lights)
{
l.color = color;
l.intensity = (Random.Range(centralAmplitude, centralAmplitude * 0.8f) * lightIntesity) *scale;
}
// lerp prewiev state to next state
List<Vector3> mixedListSmoothingPointsPatch = new List<Vector3>();
if (previewListSmoothingPointsPatch.Count > 0)
{
float mixCoefficient = (Time.time - lastTimeChangePosition) / delayChangedPosition;
for (int i = 0; i < Mathf.Min(previewListSmoothingPointsPatch.Count, listSmoothingPointsPatch.Count); i++)
mixedListSmoothingPointsPatch.Add(Vector3.Lerp(previewListSmoothingPointsPatch[i], listSmoothingPointsPatch[i], mixCoefficient));
}
else
mixedListSmoothingPointsPatch.AddRange(listSmoothingPointsPatch);
//set parametrs to lineRenderer
lineRenderer.SetVertexCount(mixedListSmoothingPointsPatch.Count);
for (int p = 0; p < mixedListSmoothingPointsPatch.Count; p++)
lineRenderer.SetPosition(p, mixedListSmoothingPointsPatch[p]);
lineRenderer.SetWidth(Width, Width);
lineRenderer.SetColors(color, color);
}
void Start()
{
myBezier = new Bezier( new Vector3( -1f, 1f, -1f ), Random.insideUnitSphere * 2f, Random.insideUnitSphere * 2f, new Vector3( 3f, 1f, 3f ) );
}
/// <summary>
/// ベジェ曲線計算用のパラメータを設定
/// </summary>
private void ConputeNextBezierCurve()
{
if (nextControlPointIndex == -1)
{
return;
}
Vector3 prevHandle;
Vector3 nextHandle;
if (!isReverse)
{
prevHandle = GetNextControlPoint().prevHandle;
nextHandle = GetCurrentControlPoint().nextHandle;
}
else
{
prevHandle = GetNextControlPoint().nextHandle;
nextHandle = GetCurrentControlPoint().prevHandle;
}
if (nextHandle != GetCurrentControlPoint().position || prevHandle != GetNextControlPoint().position)
{
bezier = new Bezier();
bezier.p0 = GetCurrentControlPoint().position;
bezier.p1 = nextHandle;
bezier.p2 = prevHandle;
bezier.p3 = GetNextControlPoint().position;
}
else
{
bezier = null;
}
}
// Update is called once per frame
void Update()
{
Vector3 currentHumanPos = transform.position;
tick += SpeedScale;
if (calculateMovement) {
moveDirection = movePath.GetPointAtTime(Mathf.Lerp(0, 1, tick));
} else if (!reachedTarget && !calculateMovement)
{
Building closestBuilding = GetClosestBuilding(currentHumanPos);
var randomOtherBuildings = from build in Buildings where build != closestBuilding && build != targetBuilding select build;
Building rndBuilding1 = randomOtherBuildings.ElementAt(Random.Range(0, randomOtherBuildings.Count()));
Building rndBuilding2 = randomOtherBuildings.ElementAt(Random.Range(0, randomOtherBuildings.Count()));
movePath = new Bezier(currentHumanPos, rndBuilding1.transform.position, rndBuilding2.transform.position, targetBuilding.transform.position);
calculateMovement = true;
} else
{
Building closestBuilding = GetClosestBuilding(currentHumanPos);
var randomOtherBuildings = from build in Buildings where build != closestBuilding && build != targetBuilding select build;
Building rndBuilding1 = randomOtherBuildings.ElementAt(Random.Range(0, randomOtherBuildings.Count()));
Building rndBuilding2 = randomOtherBuildings.ElementAt(Random.Range(0, randomOtherBuildings.Count()));
movePath = new Bezier(currentHumanPos, rndBuilding1.transform.position, rndBuilding2.transform.position, targetBuilding.transform.position);
calculateMovement = true;
/*
Vector3 targetPos = targetBuilding.transform.position;
//Rect duempelArea = new Rect(targetPos.x - duempelOffset, targetPos.y - duempelOffset, duempelOffset, duempelOffset);
tangentPos = currentHumanPos + (movePath.p3 - movePath.p2);
Random.seed += 200;
movePath = new Bezier(currentHumanPos,
new Vector3(targetPos.x + Random.Range(-0.2f, 0.2f), targetPos.y + Random.Range(-0.2f, 0.2f), 0),
new Vector3(targetPos.x + Random.Range(-1.0f, 1.0f), targetPos.y + Random.Range(-1.0f, 1.0f), 0),
new Vector3(targetPos.x + Random.Range(-0.2f, 0.2f), targetPos.y + Random.Range(-0.2f, 0.2f), 0));
calculateMovement = true;
tangentPos = movePath.p1;
duempeln = true;
*/
}
if (duempeln)
{
duempelTimer++;
}
if (duempeln && (duempelTimer > duempelTimerMax))
{
duempelTimer = 0;
tick = 0;
calculateMovement = false;
}
if ((Vector3.Distance(currentHumanPos, targetBuilding.transform.position) < visitedRange) && newTargetSet)
{
tick = 0;
reachedTarget = true;
duempeln = true;
newTargetSet = false;
calculateMovement = false;
}
transform.position = moveDirection;
}
protected override void UpdateAction(float elapse)
{
bool flag = true;
for (int i = 0; i < this.missileInsts.Count; i++)
{
this.missileInsts[i].timeStamp += elapse;
if (this.missileInsts[i].status == 0)
{
flag = false;
if (this.missileInsts[i].timeStamp >= this.missileOffests[i].delayTime)
{
this.missileInsts[i].status = 1;
if (base.variables.skillTarget != null)
{
if (this.Spine && base.variables.skillTarget.SpineTransform != null)
{
this.missileInsts[i].target = base.variables.skillTarget.SpineTransform.gameObject;
this.missileInsts[i].startPos = this.missileInsts[i].target.transform.position;
}
else
{
this.missileInsts[i].target = base.variables.skillTarget.gameObject;
this.missileInsts[i].startPos = this.missileInsts[i].target.transform.position;
}
}
if (base.variables.skillCaster != null)
{
this.missileInsts[i].targetPos = base.variables.skillCaster.transform.position;
this.missileInsts[i].targetPos += base.variables.skillCaster.transform.forward * this.ForwardOffset;
ArcaneMissilesAction.MissileInstance expr_1DC_cp_0 = this.missileInsts[i];
expr_1DC_cp_0.targetPos.y = expr_1DC_cp_0.targetPos.y + this.YOffset;
}
float num = Vector3.Distance(this.missileInsts[i].startPos, this.missileInsts[i].targetPos);
Transform transform = PoolMgr.SpawnParticleSystem(this.MissilePrefab.transform, this.missileInsts[i].startPos, Quaternion.identity, 1f);
if (transform == null)
{
global::Debug.LogError(new object[]
{
"Instantiate MissilePrefab object error!"
});
}
this.missileInsts[i].go = transform.gameObject;
this.missileInsts[i].duration = Mathf.Max(this.missileOffests[i].DurationMin, num / this.missileOffests[i].speed);
this.missileInsts[i].timeStamp = 0f;
if (this.missileOffests[i].DoDamage)
{
this.missileInsts[i].damage = (long)this.DoEffect(base.variables.skillInfo, base.variables.skillCaster, base.variables.skillTarget);
}
}
}
else if (this.missileInsts[i].go != null)
{
flag = false;
if (this.missileInsts[i].timeStamp >= this.missileInsts[i].duration)
{
this.OnReachTarget(this.missileInsts[i]);
}
else
{
float num2 = this.missileInsts[i].timeStamp / this.missileInsts[i].duration;
num2 *= num2;
Vector3 vector = base.variables.skillCaster.transform.position;
vector.y += this.YOffset;
vector += base.variables.skillCaster.transform.forward * this.ForwardOffset;
Bezier bezier = new Bezier(this.missileInsts[i].startPos, base.variables.skillCaster.transform.right * this.missileOffests[i].offest.x + Vector3.up * this.missileOffests[i].offest.y - base.variables.skillCaster.transform.forward * this.missileOffests[i].offest.z, Vector3.zero, vector);
Vector3 pointAtTime = bezier.GetPointAtTime(Mathf.Clamp01(num2));
this.missileInsts[i].go.transform.position = pointAtTime;
Vector3 forward = this.missileInsts[i].startPos - pointAtTime;
if (forward.sqrMagnitude > 0.1f)
{
Quaternion to = Quaternion.LookRotation(forward);
this.missileInsts[i].go.transform.rotation = Quaternion.Slerp(this.missileInsts[i].go.transform.rotation, to, Time.deltaTime * 10f);
}
}
}
}
if (flag)
{
base.Finish();
}
}
public static void SingleStateLinkField( Rect position, GUIContent label, SerializedProperty property )
{
StateBehaviour behaviour = property.serializedObject.targetObject as StateBehaviour;
if( behaviour == null || behaviour.stateID == 0 || behaviour.stateMachine == null || property.isArray )
{
EditorGUI.HelpBox( position,"This is Arbor Editor only.",MessageType.Error );
return;
}
int controlID = EditorGUIUtility.GetControlID( s_StateLinkHash,EditorGUIUtility.native,position );
Event currentEvent = Event.current;
EventType eventType = currentEvent.GetTypeForControl( controlID );
ArborFSMInternal stateMachine = behaviour.stateMachine;
State state = stateMachine.GetStateFromID( behaviour.stateID );
SerializedProperty stateIDProperty = property.FindPropertyRelative( "stateID" );
SerializedProperty lineEnableProperty = property.FindPropertyRelative( "lineEnable" );
SerializedProperty lineStartProperty = property.FindPropertyRelative( "lineStart" );
SerializedProperty lineStartTangentProperty = property.FindPropertyRelative( "lineStartTangent" );
SerializedProperty lineEndProperty = property.FindPropertyRelative( "lineEnd" );
SerializedProperty lineEndTangentProperty = property.FindPropertyRelative( "lineEndTangent" );
SerializedProperty lineColorProperty = property.FindPropertyRelative( "lineColor" );
SerializedProperty lineColorChangedProperty = property.FindPropertyRelative( "lineColorChanged" );
ArborEditorWindow window = ArborEditorWindow.GetCurrent();
State linkState = stateMachine.GetStateFromID( stateIDProperty.intValue );
bool dragging = ( GUIUtility.hotControl == controlID && currentEvent.button == 0 );
State targetState = dragging? _DragTargetState : linkState;
Vector2 nowPos = currentEvent.mousePosition;
Vector2 leftPos = new Vector2( position.x+8,position.center.y );
Vector2 rightPos = new Vector2( position.x+position.width-8,position.center.y );
Bezier bezier = new Bezier();
if( targetState != null )
{
bezier = GetTargetBezier( state,targetState,leftPos,rightPos );
}
else if( dragging )
{
bezier = GetTargetBezier( state,nowPos,leftPos,rightPos );
}
else
{
bezier.startPos = rightPos;
}
Rect boxRect = new Rect( bezier.startPos.x-8,position.y,16,position.height );
Vector2 statePosition = new Vector2( state.position.x,state.position.y );
bezier.startPos += statePosition;
bezier.startTangent += statePosition;
bezier.endPos += statePosition;
bezier.endTangent += statePosition;
Rect colorRect = position;
colorRect.x += colorRect.width - 32 - 16;
colorRect.width = 32;
Color lineColor = Color.white;
if( lineColorChangedProperty.boolValue )
{
lineColor = lineColorProperty.colorValue;
}
switch( eventType )
{
case EventType.MouseDown:
if( position.Contains( nowPos ) && !colorRect.Contains( nowPos ) )
{
if( currentEvent.button == 0 )
{
GUIUtility.hotControl = GUIUtility.keyboardControl = controlID;
_DragTargetState = null;
if( window != null )
{
window.DragBranchEnable( true );
window.DragBranchBezie( bezier.startPos,bezier.startTangent,bezier.endPos,bezier.endTangent );
window.DragBranchHoverStateID( 0 );
}
lineEnableProperty.boolValue = false;
currentEvent.Use ();
}
}
break;
case EventType.MouseDrag:
if( GUIUtility.hotControl == controlID && currentEvent.button == 0 )
{
DragAndDrop.PrepareStartDrag();
State nextState = GetStateFromPosition( stateMachine, nowPos+statePosition );
if( nextState != null && nextState != state )
{
if( window )
{
window.DragBranchHoverStateID( nextState.stateID );
}
_DragTargetState = nextState;
}
else
{
if( window )
{
window.DragBranchHoverStateID( 0 );
}
_DragTargetState = null;
}
currentEvent.Use ();
}
break;
case EventType.MouseUp:
if( GUIUtility.hotControl == controlID )
{
if( currentEvent.button == 0 )
{
GUIUtility.hotControl = 0;
if( _DragTargetState != linkState )
{
Undo.RecordObject( behaviour,"Link State" );
if( _DragTargetState != null )
{
stateIDProperty.intValue = _DragTargetState.stateID;
}
else
{
stateIDProperty.intValue = 0;
}
lineEnableProperty.boolValue = stateIDProperty.intValue != 0;
lineStartProperty.vector2Value = bezier.startPos;
lineStartTangentProperty.vector2Value = bezier.startTangent;
lineEndProperty.vector2Value = bezier.endPos;
lineEndTangentProperty.vector2Value = bezier.endTangent;
//EditorUtility.SetDirty( behaviour );
}
if( window != null )
{
window.DragBranchEnable(false);
window.DragBranchHoverStateID( 0 );
window.Repaint();
}
_DragTargetState = null;
currentEvent.Use ();
}
}
break;
case EventType.Repaint:
if( GUIUtility.hotControl == controlID && currentEvent.button == 0 )
{
if( window )
{
window.DragBranchBezie( bezier.startPos,bezier.startTangent,bezier.endPos,bezier.endTangent );
}
}
else if( linkState != null )
{
lineEnableProperty.boolValue = true;
lineStartProperty.vector2Value = bezier.startPos;
lineStartTangentProperty.vector2Value = bezier.startTangent;
lineEndProperty.vector2Value = bezier.endPos;
lineEndTangentProperty.vector2Value = bezier.endTangent;
}
bool on = GUIUtility.hotControl == controlID && currentEvent.button == 0 || linkState != null;
Color savedColor = GUI.backgroundColor;
GUI.backgroundColor = new Color( lineColor.r,lineColor.g,lineColor.b );
EditorStyles.miniButton.Draw( position,label,controlID,on );
GUI.backgroundColor = savedColor;
EditorStyles.radioButton.Draw( boxRect,GUIContent.none,controlID,on );
break;
}
EditorGUI.BeginChangeCheck();
lineColor = EditorGUI.ColorField( colorRect,lineColor );
if( EditorGUI.EndChangeCheck() )
{
lineColorProperty.colorValue = new Color( lineColor.r,lineColor.g,lineColor.b );
lineColorChangedProperty.boolValue = true;
}
}
static Bezier GetTargetBezier( State state,State target,Vector2 leftPos,Vector2 rightPos)
{
bool right = true;
Bezier bezier = new Bezier();
if( target != null )
{
Rect targetRect = target.position;
targetRect.x -= state.position.x;
targetRect.y -= state.position.y;
Pivot findPivot = null;
List<Pivot> pivots = new List<Pivot>();
pivots.Add( new Pivot( new Vector2( targetRect.xMin,targetRect.yMin + 32.0f ),-Vector2.right ) );
pivots.Add( new Pivot( new Vector2( targetRect.xMax,targetRect.yMin + 32.0f ),Vector2.right ) );
if( targetRect.x == 0.0f )
{
if( targetRect.y > 0.0f )
{
findPivot = pivots[0];
right = false;
}
else
{
findPivot = pivots[1];
right = true;
}
}
else
{
float findDistance = 0.0f;
foreach( Pivot pivot in pivots )
{
Vector2 vl = leftPos-pivot.position;
Vector2 vr = rightPos-pivot.position;
float leftDistance = vl.magnitude;
float rightDistance = vr.magnitude;
float distance = 0.0f;
bool checkRight = false;
if( leftDistance > rightDistance )
{
distance = rightDistance;
checkRight = true;
}
else
{
distance = leftDistance;
checkRight = false;
}
if( findPivot == null || distance < findDistance )
{
findPivot = pivot;
findDistance = distance;
right = checkRight;
}
}
}
if( right )
{
bezier.startPos = rightPos;
bezier.startTangent = rightPos + new Vector2( 100.0f,0.0f );
}
else
{
bezier.startPos = leftPos;
bezier.startTangent = leftPos - new Vector2( 100.0f,0.0f );
}
bezier.endPos = findPivot.position;
bezier.endTangent = bezier.endPos + findPivot.normal * 100;
}
return bezier;
}
static Bezier GetTargetBezier( State state,Vector2 targetPos,Vector2 leftPos,Vector2 rightPos )
{
Bezier bezier = new Bezier();
bezier.endPos = targetPos;
bool right = (targetPos-leftPos).magnitude > (targetPos-rightPos).magnitude;
if( right )
{
bezier.startPos = rightPos;
bezier.startTangent = rightPos + new Vector2( 100.0f,0.0f );
}
else
{
bezier.startPos = leftPos;
bezier.startTangent = leftPos - new Vector2( 100.0f,0.0f );
}
bezier.endTangent = bezier.startTangent;
return bezier;
}
void AlignmentSwitch(Vector3 startPoint, Vector3 endPoint)
{
Bezier b = new Bezier(Vector3.zero, Vector3.zero, Vector3.zero, Vector3.zero);
Vector3 dif = new Vector3((startPoint.x - endPoint.x) / 2, (startPoint.y - endPoint.y) / 2, (startPoint.z - endPoint.z) / 2);
switch (Alignment)
{
case ArcAlignment.Straight:
for (int i = 0; i < Points.Count; i++)
{
float n = (float)(i) / (float)(Points.Count - 1);
Points[i] = Vector3.Lerp(Position, endPoint, n);
Line.SetPosition(i, Points[i]);
}
break;
case ArcAlignment.YZCurve:
dif.x = 0;
b = new Bezier(startPoint, -dif, dif, endPoint);
for (int i = 0; i < Points.Count; i++)
{
float n = (float)(i) / (float)(Points.Count - 1);
Vector3 newPoint = new Vector3(Points[i].x, b.GetPointAtTime(n).y, b.GetPointAtTime(n).z);
Points[i] = newPoint;
Line.SetPosition(i, Points[i]);
}
break;
case ArcAlignment.XZCurve:
dif.y = 0;
b = new Bezier(startPoint, -dif, dif, endPoint);
for (int i = 0; i < Points.Count; i++)
{
float n = (float)(i) / (float)(Points.Count - 1);
Vector3 newPoint = new Vector3(b.GetPointAtTime(n).x, Points[i].y, b.GetPointAtTime(n).z);
Points[i] = newPoint;
Line.SetPosition(i, Points[i]);
}
break;
case ArcAlignment.XCurve:
dif.y = 0; dif.z = 0;
b = new Bezier(startPoint, -dif, dif, endPoint);
for (int i = 0; i < Points.Count; i++)
{
float n = (float)(i) / (float)(Points.Count - 1);
Vector3 newPoint = new Vector3(b.GetPointAtTime(n).x, Points[i].y, Points[i].z);
Points[i] = b.GetPointAtTime(n);;
Line.SetPosition(i, Points[i]);
}
break;
case ArcAlignment.YCurve:
dif.x = 0; dif.z = 0;
b = new Bezier(startPoint, -dif, dif, endPoint);
for (int i = 0; i < Points.Count; i++)
{
float n = (float)(i) / (float)(Points.Count - 1);
Vector3 newPoint = new Vector3(Points[i].x, b.GetPointAtTime(n).y, Points[i].z);
Points[i] = newPoint;
Line.SetPosition(i, Points[i]);
}
break;
case ArcAlignment.ZCurve:
dif.x = 0; dif.y = 0;
b = new Bezier(startPoint, -dif, dif, endPoint);
for (int i = 0; i < Points.Count; i++)
{
float n = (float)(i) / (float)(Points.Count - 1);
Vector3 newPoint = new Vector3(Points[i].x, Points[i].y, b.GetPointAtTime(n).z);
Points[i] = newPoint;
Line.SetPosition(i, Points[i]);
}
break;
default:
break;
}
FindDistanceToNextDirective();
}
protected override void UpdateAction(float elapse)
{
if (this.missileInstances.Count == 0)
{
base.Finish();
return;
}
this.timer += elapse;
if (this.timer > this.durationMax)
{
this.OnReachTarget();
return;
}
if (this.target != null && !base.variables.skillTarget.IsDead)
{
this.targetPosition = this.target.transform.position;
this.targetPosition.y = this.targetPosition.y + this.YOffset;
if (this.moveType == MultiBezierMissilesAction.MoveType.TargetToStart)
{
this.targetPosition += this.target.transform.forward * this.ForwardOffset;
this.targetPosition += this.target.transform.right * this.RightOffset;
}
}
for (int i = 0; i < this.missileInstances.Count; i++)
{
GameObject gameObject = this.missileInstances[i];
if (!(gameObject == null))
{
if (this.timer > this.missileDuration[i])
{
PoolMgr.spawnPool.Despawn(gameObject.transform, this.MissileDeleteDelay);
this.missileInstances[i] = null;
}
float num = this.timer / this.missileDuration[i];
num *= num;
if (this.moveType == MultiBezierMissilesAction.MoveType.StartToTarget || this.target == null)
{
Bezier bezier = new Bezier(this.startPosition, base.variables.skillCaster.transform.right * this.missileOffests[i].offest.x + Vector3.up * this.missileOffests[i].offest.y + base.variables.skillCaster.transform.forward * this.missileOffests[i].offest.z, Vector3.zero, this.targetPosition);
Vector3 pointAtTime = bezier.GetPointAtTime(Mathf.Clamp01(num));
gameObject.transform.position = pointAtTime;
Vector3 forward = this.targetPosition - pointAtTime;
if (forward.sqrMagnitude > 0.1f)
{
Quaternion to = Quaternion.LookRotation(forward);
gameObject.transform.rotation = Quaternion.Slerp(gameObject.transform.rotation, to, Time.deltaTime * 10f);
}
}
else
{
Vector3 position = base.variables.skillCaster.transform.position;
position.y += this.YOffset;
Bezier bezier2 = new Bezier(this.targetPosition, base.variables.skillCaster.transform.right * this.missileOffests[i].offest.x + Vector3.up * this.missileOffests[i].offest.y - base.variables.skillCaster.transform.forward * this.missileOffests[i].offest.z, Vector3.zero, position);
Vector3 pointAtTime2 = bezier2.GetPointAtTime(Mathf.Clamp01(num));
gameObject.transform.position = pointAtTime2;
Vector3 forward2 = this.startPosition - pointAtTime2;
if (forward2.sqrMagnitude > 0.1f)
{
Quaternion to2 = Quaternion.LookRotation(forward2);
gameObject.transform.rotation = Quaternion.Slerp(gameObject.transform.rotation, to2, Time.deltaTime * 10f);
}
}
}
}
}
void Start()
{
_splinePointDict = new Dictionary<Vector3, float>();
MyBezier = new Bezier(Point1.position, Point2.position, Point3.position, Point4.position);
}
// Update is called once per frame
void Update()
{
if (m_isDestroying == true)
return;
if (m_selfDestoryTime < Time.time)
{
if (m_weapon != null)
m_weapon.OnDestroyBullet();
Bomb();
return;
}
if (m_target == null && m_lastSearchTime <= Time.time)
{
m_lastSearchTime = Time.time + m_searchCoolTime;
Creature[] searchedTargets = Bullet.SearchTarget(transform.position, m_ownerCreature.GetMyEnemyType(), m_searchRange);
if (searchedTargets != null)
{
m_target = searchedTargets[Random.Range(0, searchedTargets.Length)];
Vector3 handle1 = transform.position;
handle1 += (transform.forward+transform.up)*(Vector3.Distance(transform.position, m_target.transform.position)*0.5f);
Vector3 handle2 = m_target.transform.position;
handle2.y = 3f;
m_bezier = new Bezier(gameObject, m_target.gameObject, handle1, handle2, m_speed*0.01f);
}
}
if (m_bezier != null)
{
if (m_bezier.Update() == false)
{
if (m_weapon != null)
m_weapon.OnDestroyBullet();
Bomb();
m_bezier = null;
}
}
/*
float destAngle = transform.eulerAngles.y;
if (m_target != null)
{
destAngle = Mathf.Atan2(m_target.transform.position.z-transform.position.z, m_target.transform.position.x-transform.position.x) * Mathf.Rad2Deg;
}
transform.eulerAngles = Quaternion.RotateTowards(transform.rotation, Quaternion.Euler(new Vector3(0, -destAngle, 0)), 300f*Time.deltaTime).eulerAngles;
transform.Translate(Mathf.Clamp(m_accel, 0, 0.2f), 0, 0, transform);
m_accel += Time.fixedDeltaTime*Time.fixedDeltaTime*m_speed;
*/
}
void OnDrawGizmos()
{
if (transform.childCount == 0)
{
return;
}
Gizmos.color = Color.red;
int index = 0;
const float radius = 0.2f;
const int n = 50; // 頂点数
Bezier bezier = new Bezier(n);
if (Application.isPlaying)
{
Gizmos.color = Color.blue;
Gizmos.DrawSphere(controlPoints[index].position + transform.position, radius);
while (index < controlPoints.Length - 1)
{
bezier.p0 = controlPoints[index + 0].position + transform.position;
bezier.p1 = controlPoints[index + 0].nextHandle + transform.position;
bezier.p2 = controlPoints[index + 1].prevHandle + transform.position;
bezier.p3 = controlPoints[index + 1].position + transform.position;
// ベジェ曲線による移動ルートを書く
if (bezier.CheckBezier())
{
Vector3[] bezierPositions = bezier.GetAllPoint();
Gizmos.color = Color.red;
for (int i = 0; i < bezierPositions.Length - 1; i++)
{
Gizmos.DrawLine(bezierPositions[i], bezierPositions[i + 1]);
}
}
else
{
// 直線による移動ルートを書く
Gizmos.color = Color.red;
Gizmos.DrawLine(bezier.p0, bezier.p3);
}
index++;
}
}
else
{
Gizmos.color = Color.blue;
Gizmos.DrawSphere(transform.GetChild(0).position, radius);
while (index < transform.childCount - 1)
{
// ベジェ曲線による移動ルートを書く
if (transform.GetChild(index + 0).GetComponent<CurveNode>() != null)
{
bezier.p0 = transform.GetChild(index + 0).position;
bezier.p1 = transform.GetChild(index + 1).position;
bezier.p2 = transform.GetChild(index + 2).position;
bezier.p3 = transform.GetChild(index + 3).position;
Vector3[] bezierPositions = bezier.GetAllPoint();
Gizmos.color = Color.red;
for (int i = 0; i < bezierPositions.Length - 1; i++)
{
Gizmos.DrawLine(bezierPositions[i], bezierPositions[i + 1]);
}
Gizmos.color = Color.blue;
Gizmos.DrawLine(bezier.p0, bezier.p1);
Gizmos.DrawLine(bezier.p3, bezier.p2);
index += 3;
}
else
{
Gizmos.color = Color.red;
Gizmos.DrawLine(transform.GetChild(index + 0).position, transform.GetChild(index + 1).position);
index++;
}
}
}
}
private static void DrawConnection(EventCall ev, Bezier b)
{
const float tangentSize = 50;
float diff = b.end.x - b.start.x;
diff = Mathf.Sign(diff) * Mathf.Min(Mathf.Abs(diff), tangentSize);
var p1 = b.start;
var p2 = b.end;
var p3 = p1;
var p4 = p2;
if (b.startTangent == Bezier.Tangent.Auto)
{
p3 += new Vector2(diff, 0);
}
else if (b.startTangent == Bezier.Tangent.Negative)
{
p3 -= new Vector2(Math.Abs(diff), 0);
}
else if (b.startTangent == Bezier.Tangent.Positive)
{
p3 += new Vector2(Math.Abs(diff), 0);
}
else if (b.startTangent == Bezier.Tangent.NegativeUnscaled)
{
p3 -= new Vector2(tangentSize, 0);
}
else if (b.startTangent == Bezier.Tangent.PositiveUnscaled)
{
p3 += new Vector2(tangentSize, 0);
}
if (b.endTangent == Bezier.Tangent.Auto)
{
p4 -= new Vector2(diff, 0);
}
else if (b.endTangent == Bezier.Tangent.Negative)
{
p4 -= new Vector2(Math.Abs(diff), 0);
}
else if (b.endTangent == Bezier.Tangent.Positive)
{
p4 += new Vector2(Math.Abs(diff), 0);
}
else if (b.endTangent == Bezier.Tangent.NegativeUnscaled)
{
p4 -= new Vector2(tangentSize, 0);
}
else if (b.endTangent == Bezier.Tangent.PositiveUnscaled)
{
p4 += new Vector2(tangentSize, 0);
}
Color c = ev.color;
Color prevColor = Handles.color;
Handles.color = c;
Handles.DrawBezier(p1, p2, p3, p4, c, (Texture2D)UnityEditor.Graphs.Styles.selectedConnectionTexture.image, EdgeGUI.kEdgeWidth);
foreach (var trigger in EdgeTriggersTracker.GetTimings(ev))
{
Vector3 pos = EdgeGUI.CalculateBezierPoint(trigger, p1, p3, p4, p2);
Handles.DrawSolidArc(pos, Vector3.back, pos + Vector3.up, 360, EdgeGUI.kEdgeWidth);
}
Handles.color = prevColor;
}
IEnumerator TravelPath()
{
isTraveling = true;
anim.SetBool("Run", true);
Walk.Play(0);
Vector3 a, b, c = pathToTravel[0].Position;
yield return(LookAt(pathToTravel[1].Position));
if (Owned)
{
Grid.DecreaseVisibility(currentTravelLocation ? currentTravelLocation : pathToTravel[0], VisionRange);
}
float t = Time.deltaTime * travelSpeed;
for (int i = 1; i < pathToTravel.Count; i++)
{
currentTravelLocation = pathToTravel[i];
a = c;
b = pathToTravel[i - 1].Position;
c = (b + currentTravelLocation.Position) * 0.5f;
if (Owned)
{
Grid.IncreaseVisibility(currentTravelLocation, VisionRange);
if (currentTravelLocation.Item)
{
currentTravelLocation.Item.Effect(this);
Grid.SendRemoveItem(currentTravelLocation.Item);
}
}
else
{
unitRenderer.enabled = currentTravelLocation.IsVisible;
}
for (; t < 1f; t += Time.deltaTime * travelSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
yield return(null);
}
if (Owned)
{
Grid.DecreaseVisibility(currentTravelLocation, VisionRange);
}
t -= 1f;
}
currentTravelLocation = null;
a = c;
b = location.Position;
c = b;
if (Owned)
{
Grid.IncreaseVisibility(location, VisionRange);
}
for (; t < 1f; t += Time.deltaTime * travelSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
yield return(null);
}
transform.localPosition = location.Position;
orientation = transform.localRotation.eulerAngles.y;
ListPool <HexCell> .Add(pathToTravel);
pathToTravel = null;
isTraveling = false;
anim.SetBool("Run", false);
Walk.Stop();
}
public Vector3 GetLocalPoint(float t)
{
return(Bezier.GetPoint(Vector3.zero, points[0], points[1], points[2], t));
}
public void visitBezier(Bezier curve)
{
pointsOfCurvs.Add(curve.P0);
}
public static Vector3 GetPointPosition(Vector3 start, Vector3 end, float t, float multiply)
{
Vector3 additionalPoint = Bezier.CenterOf(start, end) - new Vector3(0, multiply * Vector3.Distance(start, end) / 2, 0);
return(Bezier.Calculate(start, additionalPoint, end, t));
}
public void ReturnsP2WhenTIsOne()
{
var p = Bezier.GetPoint(p0, p1, p2, 1f);
Assert.That(p, Is.EqualTo(p2));
}
IEnumerator FollowPath()
{
Vector3 a, b, c = transform.position;
if (path.Length == 0)
{
yield break;
}
else if (path.Length == 1)
{
yield return(LookAt(path[0].worldPos));
float ti = Time.deltaTime * moveSpeed;
for (; ti < 1f; ti += Time.deltaTime * moveSpeed * 2)
{
transform.localPosition = Vector3.Lerp(c, path[0].worldPos, ti);
yield return(null);
}
transform.localPosition = path[0].worldPos;
yield break;
}
Node currentNode;
World.nodes.TryGetValue(new Vector2Int(path[1].Q, path[1].R), out currentNode);
if (!World.planetNodes.ContainsKey(new Vector2Int(path[1].Q, path[1].R)))
{
PathRequestManager.RequestPath(new PathRequest(
World.nodes[World.nodeCoordFromWorldPos(transform.position)],
new List <PlanetNode>()
{
World.planetNodes[World.nodeCoordFromWorldPos(target)]
},
OnPathFound));
yield break;
}
occupyNode(currentNode);
yield return(LookAt(path[1].worldPos));
float t = Time.deltaTime * moveSpeed;
for (; t < 1f; t += Time.deltaTime * moveSpeed * 2)
{
transform.localPosition = Vector3.Lerp(c, (path[1].worldPos + c) / 2, t); //Bezier.GetPoint(a, b, c, t);
yield return(null);
}
t -= 1f;
c = transform.position;
for (int i = 2; i < path.Length; i++)
{
World.nodes.TryGetValue(new Vector2Int(path[i].Q, path[i].R), out currentNode);
if (!World.planetNodes.ContainsKey(new Vector2Int(path[i].Q, path[i].R)))
{
PathRequestManager.RequestPath(new PathRequest(
World.nodes[World.nodeCoordFromWorldPos(transform.position)],
new List <PlanetNode>()
{
World.planetNodes[World.nodeCoordFromWorldPos(target)]
},
OnPathFound));
for (; t < 1f; t += Time.deltaTime * moveSpeed)
{
transform.localPosition = c + (path[i - 1].worldPos - c) * t;
//we just go forward to the centre so we don't need to change the rotation here
yield return(null);
}
yield break;
}
occupyNode(currentNode);
a = c;
b = path[i - 1].worldPos;
c = (b + path[i].worldPos) * 0.5f;
for (; t < 1f; t += Time.deltaTime * moveSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
float angle = Mathf.Atan2(d.y, d.x) * Mathf.Rad2Deg;
transform.localRotation = Quaternion.AngleAxis(angle - 90, Vector3.forward);
yield return(null);
}
t -= 1f;
}
a = c;
b = path[path.Length - 1].worldPos;
c = b;
for (; t < 1f; t += Time.deltaTime * moveSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
float angle = Mathf.Atan2(d.y, d.x) * Mathf.Rad2Deg;
transform.localRotation = Quaternion.AngleAxis(angle - 90, Vector3.forward);
yield return(null);
}
transform.localPosition = path[path.Length - 1].worldPos;
path = null;
}
// Use this for initialization
void Awake()
{
oldPos = transform.localPosition;
moveBezier = new Bezier(rootPos[0], rootPos[1], rootPos[2], rootPos[3]);
}
IEnumerator TravelPath()
{
Vector3 a, b, c = pathToTravel[0].Position;
yield return(LookAt(pathToTravel[1].Position));
if (!currentTravelLocation)
{
currentTravelLocation = pathToTravel[0];
}
Grid.DecreaseVisibility(currentTravelLocation, VisionRange);
int currentColumn = currentTravelLocation.ColumnIndex;
float t = Time.deltaTime * travelSpeed;
for (int i = 1; i < pathToTravel.Count; i++)
{
currentTravelLocation = pathToTravel[i];
a = c;
b = pathToTravel[i - 1].Position;
int nextColumn = currentTravelLocation.ColumnIndex;
if (currentColumn != nextColumn)
{
if (nextColumn < currentColumn - 1)
{
a.x -= HexMetrics.innerDiameter * HexMetrics.wrapSize;
b.x -= HexMetrics.innerDiameter * HexMetrics.wrapSize;
}
else if (nextColumn > currentColumn + 1)
{
a.x += HexMetrics.innerDiameter * HexMetrics.wrapSize;
b.x += HexMetrics.innerDiameter * HexMetrics.wrapSize;
}
Grid.MakeChildOfColumn(transform, nextColumn);
currentColumn = nextColumn;
}
c = (b + currentTravelLocation.Position) * 0.5f;
Grid.IncreaseVisibility(pathToTravel[i], VisionRange);
for (; t < 1f; t += Time.deltaTime * travelSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
yield return(null);
}
Grid.DecreaseVisibility(pathToTravel[i], VisionRange);
t -= 1f;
}
currentTravelLocation = null;
a = c;
b = location.Position;
c = b;
Grid.IncreaseVisibility(location, VisionRange);
for (; t < 1f; t += Time.deltaTime * travelSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
yield return(null);
}
transform.localPosition = location.Position;
orientation = transform.localRotation.eulerAngles.y;
ListPool <HexCell> .Add(pathToTravel);
pathToTravel = null;
}
public Vector3 GetVelocity(float t)
{
return(transform.TransformPoint(Bezier.GetFirstDerivative(points[0], points[1], points[2], points[3], t)) - transform.position);
}
void Start()
{
_splinePointDict = new Dictionary <Vector3, float>();
MyBezier = new Bezier(Point1.position, Point2.position, Point3.position, Point4.position);
}
protected override void UpdateAction(float elapse)
{
if (this.missile == null)
{
base.Finish();
return;
}
if (this.curveType == TargetMissileAction.CurveType.Bezier)
{
float num = Time.time - this.timeStamp;
if (num > this.BezierDutationMin)
{
this.OnTouchTarget(this.targetPosition);
return;
}
if (this.target != null && !base.variables.skillTarget.IsDead)
{
this.targetPosition = this.target.transform.position;
}
Bezier bezier = new Bezier(this.startPosition, base.transform.right * this.BezierOffest.x + Vector3.up * this.BezierOffest.y + base.transform.forward * this.BezierOffest.z, Vector3.zero, this.targetPosition);
float num2 = num / this.BezierDutationMin;
num2 *= num2;
Vector3 pointAtTime = bezier.GetPointAtTime(num2);
this.missile.transform.position = pointAtTime;
Vector3 forward = this.targetPosition - pointAtTime;
if (forward.sqrMagnitude > 0.1f)
{
Quaternion to = Quaternion.LookRotation(forward);
this.damping += 0.9f;
this.missile.transform.rotation = Quaternion.Slerp(this.missile.transform.rotation, to, Time.deltaTime * this.damping);
}
}
else
{
if (this.target != null && !base.variables.skillTarget.IsDead)
{
this.targetPosition = this.target.transform.position;
}
Vector3 vector = this.Accel * Time.deltaTime;
this.speed.x = Mathf.Clamp(this.speed.x + vector.x, 1f, this.SpeedMax.x);
this.speed.y = Mathf.Clamp(this.speed.y + vector.y, 1f, this.SpeedMax.y);
this.speed.z = Mathf.Clamp(this.speed.z + vector.z, 1f, this.SpeedMax.z);
if (this.parabolaAngle <= 0f)
{
Vector3 vector2 = this.targetPosition - this.missile.transform.position;
if (vector2 != Vector3.zero)
{
Quaternion to2 = Quaternion.LookRotation(vector2);
this.damping += 0.9f;
this.missile.transform.rotation = Quaternion.Slerp(this.missile.transform.rotation, to2, Time.deltaTime * this.damping);
}
Vector3 vector3 = this.speed * Time.deltaTime;
this.missile.transform.position += vector2.normalized * vector3.x;
this.missile.transform.position += vector2.normalized * vector3.y;
this.missile.transform.position += vector2.normalized * vector3.z;
if (vector2.magnitude < vector3.magnitude)
{
this.OnTouchTarget(this.targetPosition);
return;
}
}
else
{
this.missile.transform.LookAt(this.targetPosition);
float num3 = this.Speed.x * this.Speed.y * this.Speed.z * Time.deltaTime;
float num4 = CombatHelper.Distance2D(this.missile.transform.position, this.targetPosition);
float num5 = (this.distanceToTarget > 0f) ? (Mathf.Min(1f, num4 / this.distanceToTarget) * this.parabolaAngle) : 0f;
num5 = Mathf.Clamp(-num5, -this.parabolaAngle, this.parabolaAngle);
this.missile.transform.rotation = this.missile.transform.rotation * Quaternion.Euler(num5, 0f, 0f);
this.missile.transform.Translate(Vector3.forward * num3);
if (num4 < num3)
{
this.OnTouchTarget(this.targetPosition);
return;
}
}
}
}
protected override void UpdateTrail(TrailGraphics trail, float deltaTime)
{
if (!trail.activeSelf)
{
return;
}
int trailPointIdx = 0;
for (int i = 0; i < controlPoints.Count; i++)
{
trail.points[trailPointIdx].position = controlPoints[i].position;
trail.points[trailPointIdx].forwardDirection = controlPoints[i].forward;
trailPointIdx++;
if (i < controlPoints.Count - 1)
{
Vector3 cp1, cp2;
float distance = Vector3.Distance(controlPoints[i].position, controlPoints[i + 1].position) / 2;
if (i == 0)
{
cp1 = controlPoints[i].position + (controlPoints[i + 1].position - controlPoints[i].position).normalized * distance;
}
else
{
cp1 = controlPoints[i].position + (controlPoints[i + 1].position - controlPoints[i - 1].position).normalized * distance;
}
int nextIdx = i + 1;
if (nextIdx == controlPoints.Count - 1)
{
cp2 = controlPoints[nextIdx].position + (controlPoints[nextIdx - 1].position - controlPoints[nextIdx].position).normalized * distance;
}
else
{
cp2 = controlPoints[nextIdx].position + (controlPoints[nextIdx - 1].position - controlPoints[nextIdx + 1].position).normalized * distance;
}
TrailPoint current = trail.points[trailPointIdx - 1];
TrailPoint next = trail.points[trailPointIdx + pointsInMiddle];
for (int j = 0; j < pointsInMiddle; j++)
{
float t = (((float)j + 1) / ((float)pointsInMiddle + 1));
trail.points[trailPointIdx].position = Bezier.CalculateCubic(t, controlPoints[i].position, cp1, cp2, controlPoints[i + 1].position);
trail.points[trailPointIdx].timeSoFar = Mathf.Lerp(current.timeSoFar, next.timeSoFar, t);
trail.points[trailPointIdx].forwardDirection = Vector3.Lerp(current.forwardDirection, next.forwardDirection, t);
trailPointIdx++;
}
}
}
int lastCPIdx = (pointsInMiddle + 1) * (controlPoints.Count - 1);
int prevCPIdx = lastCPIdx - pointsInMiddle - 1;
int activeCount = lastCPIdx + 1;
float distance2Src = trail.points[prevCPIdx].distance2Src;
for (int i = prevCPIdx + 1; i < activeCount; i++)
{
distance2Src += Vector3.Distance(trail.points[i - 1].position, trail.points[i].position);
trail.points[i].distance2Src = distance2Src;
}
}
public BezierLengthDemoControl() : base()
{
Bezier = new Bezier(((double)Width * 0.1D), ((double)Height * 0.9D), ((double)Width * 0.2D), ((double)Height * 0.2D), ((double)Width * 0.7D), ((double)Height * 0.8D), ((double)Width * 0.8D), ((double)Height * 0.1D));
}
public void ReturnsP0WhenTIsZero()
{
var p = Bezier.GetPoint(p0, p1, p2, 0f);
Assert.That(p, Is.EqualTo(p0));
}
private void GenPrimitives()
{
SizeF csize = this.ClientSize;
// since backbuffer size is the same as this.Client size.
Random r = new Random(7737);
int w = (int)csize.Width;
int h = (int)csize.Height;
if (m_sampleDrawing == SampleDrawings.FillSolidRects
|| m_sampleDrawing == SampleDrawings.Draw_Rects)
{
int itemCount = 300;
m_rects.Clear();
for (int i = 0; i < itemCount; i++)
{
int cx = r.Next(-40, w);
int cy = r.Next(-40, h);
int width = r.Next(20, 140);
int height = r.Next(20, 140);
Rectangle rect =
new Rectangle(cx, cy, width, height);
m_rects.Add(rect);
}
if (m_sampleDrawing == SampleDrawings.FillSolidRects)
{
m_drawInfo = string.Format("Fill {0} solid rectangles", itemCount);
}
else
{
m_drawInfo = string.Format("Draw {0} rectangles", itemCount);
}
}
else if (m_sampleDrawing == SampleDrawings.DrawRandomLines1 ||
m_sampleDrawing == SampleDrawings.DrawRandomLines2)
{
int itemCount = 2000;
m_lines.Clear();
for (int i = 0; i < itemCount; i++)
{
PointF pt1 = new PointF(r.Next(w), r.Next(h));
PointF pt2 = new PointF(r.Next(w), r.Next(h));
m_lines.Add(new Line(pt1, pt2));
}
if (m_sampleDrawing == SampleDrawings.DrawRandomLines1)
{
m_drawInfo = string.Format("Draw {0} lines width = 1", itemCount);
}
else
{
m_drawInfo = string.Format("Draw {0} lines width = 2", itemCount);
}
}
else if (m_sampleDrawing == SampleDrawings.DrawBeziers)
{
r = new Random(7737);
int itemCount = 200;
Bezier bz = new Bezier();
bz.P1 = new PointF(0, 0);
bz.P2 = new PointF(20, 25);
bz.P3 = new PointF(40, -25);
bz.P4 = new PointF(60, 25);
m_beziers.Clear();
for (int i = 0; i < itemCount; i++)
{
Bezier b = new Bezier();
SizeF sz = new SizeF();
sz.Width = r.Next(w);
sz.Height = r.Next(h);
b.P1 = bz.P1 + sz;
b.P2 = bz.P2 + sz;
b.P3 = bz.P3 + sz;
b.P4 = bz.P4 + sz;
m_beziers.Add(b);
}
m_drawInfo = string.Format("Draw {0} beziers", itemCount);
}
else if (m_sampleDrawing == SampleDrawings.DrawText)
{
r = new Random(7737);
int itemCount = 200;
m_texts.Clear();
for (int i = 0; i < itemCount; i++)
{
PointF pt = new PointF(r.Next(w), r.Next(h));
m_texts.Add(pt);
}
m_drawInfo = string.Format("Draw {0} text", itemCount);
}
else if (m_sampleDrawing == SampleDrawings.DrawBitmaps)
{
m_drawInfo = "Draw overlapping transparent bitmaps";
}
m_fps = 0.0f;
UpdateInfo();
}
public void LoadFromFile(string filename)
{
var p = new XMLSerializer();
Scene scene;
try
{
scene = p.DeserializeFromFile(filename);
}
catch (Exception)
{
return;
}
ClearScene();
var catPoints = new List <CatPoint>(scene.Points.Length);
for (int i = 0; i < scene.Points.Length; i++)
{
var pos = scene.Points[i].Position;
var pt = CreateCatPoint(new Vector3(pos.X, pos.Y, pos.Z), false);
pt.Name = scene.Points[i].Name;
catPoints.Add(pt);
}
foreach (var bezierCurveC0 in scene.BezierCurvesC0)
{
var curve = new Bezier(bezierCurveC0.Points.Select(x => catPoints[x]), this)
{
Name = bezierCurveC0.Name
};
if (bezierCurveC0.DisplayPolygonSpecified)
{
curve.ShowPolygon = bezierCurveC0.DisplayPolygon;
}
AddNewModel(curve);
}
foreach (var bezierCurveC2 in scene.BezierCurvesC2)
{
var curve = new BezierC2(bezierCurveC2.Points.Select(x => catPoints[x]), this)
{
Name = bezierCurveC2.Name
};
if (bezierCurveC2.DisplayPolygonSpecified)
{
curve.ShowPolygon = bezierCurveC2.DisplayPolygon;
}
AddNewModel(curve);
}
foreach (var interpolationBezierCurveC2 in scene.InterpolationBezierCurvesC2)
{
var curve = new BsplineInterpolator(interpolationBezierCurveC2.Points.Select(x => catPoints[x]), this)
{
Name = interpolationBezierCurveC2.Name
};
if (interpolationBezierCurveC2.DisplayPolygonSpecified)
{
curve.ShowPolygon = interpolationBezierCurveC2.DisplayPolygon;
}
AddNewModel(curve);
}
foreach (var bezierSurfaceC0 in scene.BezierSurfacesC0)
{
var patches = new List <Patch>();
var ptches = new Patch[bezierSurfaceC0.PatchesV, bezierSurfaceC0.PatchesU];
foreach (var bezierSurfaceC0Patch in bezierSurfaceC0.Patches)
{
var pts = new CatPoint[4, 4];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
pts[i, j] = catPoints[bezierSurfaceC0Patch.Points[j, i]];
}
}
var patch = new BezierPatch(pts)
{
ShowPolygon = false,
HeightDiv = bezierSurfaceC0Patch.SurfaceDivisionsV,
WidthDiv = bezierSurfaceC0Patch.SurfaceDivisionsU,
Name = bezierSurfaceC0Patch.Name,
VPos = bezierSurfaceC0Patch.PatchU,
UPos = bezierSurfaceC0Patch.PatchV
};
AddNewModel(patch);
patches.Add(patch);
ptches[bezierSurfaceC0Patch.PatchV, bezierSurfaceC0Patch.PatchU] = patch;
}
var surfacePoints = patches.SelectMany(x => x.EnumerateCatPoints()).Distinct().ToList();
var surface = new Surface(SurfaceType.Bezier, ptches, surfacePoints, this, false, false)
{
Name = bezierSurfaceC0.Name,
PatchesU = bezierSurfaceC0.PatchesU,
PatchesV = bezierSurfaceC0.PatchesV,
};
AddNewModel(surface);
}
foreach (var bezierSurfaceC2 in scene.BezierSurfacesC2)
{
var patches = new List <Patch>();
var ptches = new Patch[bezierSurfaceC2.PatchesV, bezierSurfaceC2.PatchesU];
foreach (var bezierSurfaceC2Patch in bezierSurfaceC2.Patches)
{
var pts = new CatPoint[4, 4];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
pts[i, j] = catPoints[bezierSurfaceC2Patch.Points[j, i]];
}
}
var patch = new BSplinePatch(pts)
{
ShowPolygon = false,
HeightDiv = bezierSurfaceC2Patch.SurfaceDivisionsV,
WidthDiv = bezierSurfaceC2Patch.SurfaceDivisionsU,
Name = bezierSurfaceC2Patch.Name,
UPos = bezierSurfaceC2Patch.PatchU,
VPos = bezierSurfaceC2Patch.PatchV
};
AddNewModel(patch);
patches.Add(patch);
ptches[bezierSurfaceC2Patch.PatchV, bezierSurfaceC2Patch.PatchU] = patch;
}
var loopedV = true;
var loopedU = true;
for (int i = 0; i < 3; i++)
{
var pat = ptches[0, 0].GetCatPoint(i, 0);
var pat2 = ptches[0, bezierSurfaceC2.PatchesU - 1].GetCatPoint(i + 1, 0);
if (pat != pat2 ||
ptches[0, 0].GetCatPoint(i, 1) != ptches[0, bezierSurfaceC2.PatchesU - 1].GetCatPoint(i + 1, 1) ||
ptches[0, 0].GetCatPoint(i, 2) != ptches[0, bezierSurfaceC2.PatchesU - 1].GetCatPoint(i + 1, 2))
{
loopedU = false;
break;
}
}
if (loopedU)
{
for (int i = 0; i < ptches.GetLength(0); i++)
{
if (ptches[i, 0].GetCatPoint(0, 3) != ptches[i, bezierSurfaceC2.PatchesU - 1].GetCatPoint(1, 3) ||
ptches[i, 0].GetCatPoint(1, 3) != ptches[i, bezierSurfaceC2.PatchesU - 1].GetCatPoint(2, 3) ||
ptches[i, 0].GetCatPoint(2, 3) != ptches[i, bezierSurfaceC2.PatchesU - 1].GetCatPoint(3, 3))
{
loopedU = false;
break;
}
}
}
for (int i = 0; i < 3; i++)
{
if (ptches[0, 0].GetCatPoint(0, i) != ptches[bezierSurfaceC2.PatchesV - 1, 0].GetCatPoint(0, i + 1) ||
ptches[0, 0].GetCatPoint(0, i) != ptches[bezierSurfaceC2.PatchesV - 1, 0].GetCatPoint(0, i + 1) ||
ptches[0, 0].GetCatPoint(0, i) != ptches[bezierSurfaceC2.PatchesV - 1, 0].GetCatPoint(0, i + 1))
{
loopedV = false;
break;
}
}
if (loopedV)
{
for (int i = 0; i < ptches.GetLength(1); i++)
{
if (ptches[0, i].GetCatPoint(3, 0) != ptches[bezierSurfaceC2.PatchesV - 1, i].GetCatPoint(3, 1) ||
ptches[0, i].GetCatPoint(3, 1) != ptches[bezierSurfaceC2.PatchesV - 1, i].GetCatPoint(3, 2) ||
ptches[0, i].GetCatPoint(3, 2) != ptches[bezierSurfaceC2.PatchesV - 1, i].GetCatPoint(3, 3))
{
loopedV = false;
break;
}
}
}
if (loopedU == loopedV)
{
Console.WriteLine($"Surf: {bezierSurfaceC2.Name}");
}
var surfacePoints = patches.SelectMany(x => x.EnumerateCatPoints()).Distinct().ToList();
var surface = new Surface(SurfaceType.BSpline, ptches, surfacePoints, this, loopedU, loopedV)
{
Name = bezierSurfaceC2.Name,
PatchesU = bezierSurfaceC2.PatchesU,
PatchesV = bezierSurfaceC2.PatchesV
};
AddNewModel(surface);
}
}
public void link_two_maps(MapContainer item)
{
//return;
string ordered_state1;
string ordered_state2;
if (string.Compare(this.parentName, item.parentName) < 0)
{
ordered_state1 = this.parentName;
ordered_state2 = item.parentName;
}
else
{
ordered_state1 = item.parentName;
ordered_state2 = this.parentName;
}
var flows = this.mapController.county_flattened[new Tuple <string, string>(ordered_state1, ordered_state2)];
Dictionary <String, InteractableMap> lchild1 = new Dictionary <string, InteractableMap>();
foreach (var ma2p in this.GetComponentsInChildren <InteractableMap>())
{
lchild1[ma2p.name] = ma2p;
}
Dictionary <String, InteractableMap> lchild2 = new Dictionary <string, InteractableMap>();
foreach (var ma2p in item.GetComponentsInChildren <InteractableMap>())
{
lchild2[ma2p.name] = ma2p;
}
foreach (var val in flows.Take(100))
{
InteractableMap origin;
InteractableMap destination;
Transform origin_t;
Transform dest_t;
if (val.Item1 == this.parentName)
{
origin = lchild1[val.Item2];
destination = lchild2[val.Item4];
origin_t = this.transform;
dest_t = item.transform;
}
else
{
origin = lchild2[val.Item2];
destination = lchild1[val.Item4];
origin_t = item.transform;
dest_t = this.transform;
}
var flowData = val.Item5;
Bezier b = new Bezier(origin_t, origin, destination, 0.1F * (0.00000199192F * flowData + 0.05F), dest_t);
this.internalLines.Add(b);
item.internalLines.Add(b);
}
}
public Vector3 GetPoint(float t)
{
return(transform.TransformPoint(Bezier.GetPoint(points[0], points[1], points[2], points[3], t)));
}
private void Start()
{
this.reportGrabbed = delegate(bool x)
{
if (!(this.moved) && (this.level > 0))
{
//this.transform.localScale = new Vector3(1F, 1F, 1F);
this.transform.parent = this.transform.root.GetComponent <MapController>().transform;
//this.stack_remove(this, 0);
this.moved = true;
}
};
var mc = this.transform.root.GetComponent <MapController>();
if (mc != null && this.transform.root.GetComponent <MapController>().startUp)
{
//Debug.Log(this.transform.root);
string file = Application.streamingAssetsPath + "/" + mc.mainMap;
this.parentName = "America";
this.level = 0;
MapRenderer map = new MapRenderer();
//GameObject plane = GameObject.CreatePrimitive(PrimitiveType.Plane);
//plane.transform.rotation = Quaternion.Euler(new Vector3(0, 90, -90));
//plane.transform.parent = this.gameObject.transform;
map.drawMultiple(this.gameObject, reportGrabbed, file, 0, this.transform.root.GetComponent <MapController>().haveTooltip, this.transform.root.GetComponent <MapController>().mapScale, parentName);
this.transform.root.GetComponent <MapController>().startUp = false;
Dictionary <String, InteractableMap> lchild = new Dictionary <string, InteractableMap>();
foreach (var ma2p in this.GetComponentsInChildren <InteractableMap>())
{
lchild[ma2p.name] = ma2p;
}
foreach (var pair in mc.flattenedList["America"].Take(100))
{
try
{
var origin = lchild[pair.Item1];
var destination = lchild[pair.Item2];
var flowData = pair.Item3;
Bezier b = new Bezier(this.transform, origin, destination, 0.1F * (0.00000199192F * flowData + 0.05F));
internalLines.Add(b);
}
catch { }
//b.line.startWidth = 0.1F * (0.00000699192F * flowData + 0.05F);
//Debug.Log("line width = " + b.line.startWidth.ToString());
//b.line.endWidth = b.line.startWidth;
//b.line.material = new Material(Shader.Find("Sprites/Default"));
//b.line.startColor = Color.green; //new Color(253, 187, 45, 255);
//b.line.endColor = Color.blue; // new Color(34, 193,195, 255);
}
}
}
void Update()
{
transform.position = Bezier.GetPoint(p0.position, p1.position, p2.position, p3.position, t);
transform.rotation = Quaternion.LookRotation(Bezier.GetFirstDerivative(p0.position, p1.position, p2.position, p3.position, t));
}
private static List <Vector2> intersect(Line b1, Bezier b2, bool filter_self, bool filter_other)
{
return(intersect(b2, b1, filter_other, filter_self));
}
