private PointInfo FindCrossPointOnWholePath(Vector3 vx, Vector3 vx1, Vector3 vx2, List <int> excludesIndex = null)
{
PointInfo info = null;
for (int i = 0; i < movePoints.Length - 1; i++)
{
if (null != excludesIndex && excludesIndex.Contains(i))
{
continue;
}
Vector3 p1 = movePoints[i];
Vector3 p2 = movePoints [i + 1];
Vector3 pInter = Vector3.zero;
bool cross = Vector2DUtils.LineLineIntersection(out pInter, p1, p2 - p1, vx, vx1 - vx);
if (!cross)
{
cross = Vector2DUtils.LineLineIntersection(out pInter, p1, p2 - p1, vx, vx2 - vx);
}
if (!cross)
{
continue;
}
if (0 != Vector2DUtils.PointOnWhichSideOfLineSegment(p1, p2, pInter))
{
continue;
}
info = new PointInfo();
info.position = pInter;
info.startIndex = i;
break;
}
return(info);
}
IEnumerator DoLoop()
{
while (true)
{
ShakeConfig config = configs [_curIndex];
float shakedTime = 0;
while (true && shakedTime < config.time)
{
Vector3 _position = transform.position;
if (!_pausing)
{
float m = config.scope * UnityEngine.Random.Range(-1f, 1f);
Vector2DUtils.ChangePosition(transform, _position.x + m, _position.y + m, _position.z);
shakedTime += Time.deltaTime;
}
// Log.Debug (" 1111 ... {0}",gameObject.name);
yield return(new WaitForSeconds(config.interval));
}
// Log.Debug (" 2222 ... {0}",gameObject.name);
_curIndex = (_curIndex + 1) % configs.Count;
yield return(new WaitForSeconds(interval));
}
}
protected override void Reset()
{
base.Reset();
animator.StopPlay();
if (null != _cor)
{
StopCoroutine(_cor);
}
int colorIndex = UnityEngine.Random.Range(0, colors.Length);
render.color = colors[colorIndex];
Vector2[] scope = Vector2DUtils.GetScreenScope();
float xbound = render.bounds.size.x * .5f;
float rightX = scope [1].x + xbound;
float leftX = scope [0].x - xbound;
float speed = UnityEngine.Random.Range(0.8f, Constants.speed_butterfly_move_max);
float startX = speed < Mathf.Lerp(0.5f, Constants.speed_butterfly_move_max, 0.5f)?rightX:leftX;
float startY = UnityEngine.Random.Range(scope[0].y, scope[1].y);
transform.position = new Vector3(startX, startY, transform.position.z);
Vector3 target1 = Camera.main.ScreenToWorldPoint(new Vector3(Screen.width * 0.5f, Screen.height * 0.5f, 0));
target1.z = transform.position.z;
gameObject.SetActive(true);
_cor = StartCoroutine(DoUpdate(speed, target1));
}
IEnumerator DoAttack()
{
attacking = true;
Vector3 startPos = transform.position;
Vector3 endPos = transform.position + new Vector3(0, attackDistance, 0);
while (transform.position.y - startPos.y < attackDistance)
{
if (!pausing)
{
Vector2DUtils.MoveToSmoothly(transform, endPos, attackSpeed);
}
yield return(null);
}
while (transform.position.y - startPos.y > Mathf.Epsilon)
{
if (!pausing)
{
Vector2DUtils.MoveToSmoothly(transform, startPos, attackSpeed);
}
yield return(null);
}
attacking = false;
animRun.StartPlay();
tracer.OnResume();
}
IEnumerator DoUpdate()
{
Vector2[] scope = Vector2DUtils.GetScreenScope();
float maxHeight = scope [1].y - scope [0].y;
while (true)
{
if (!pausing)
{
int index = UnityEngine.Random.Range(0, clouds.Length);
Cloud c = clouds [index];
if (!c.running)
{
float height = UnityEngine.Random.Range(0, maxHeight);
float speed = UnityEngine.Random.Range(0.05f, Constants.speed_cloud_move_max);
if (UnityEngine.Random.Range(0, 2) == 0)
{
speed *= -1;
}
float scale = UnityEngine.Random.Range(0.2f, 1.5f);
c.StartMove(height, speed, scale);
}
}
yield return(new WaitForSeconds(5f));
}
}
protected override void DoInit()
{
base.DoInit();
if (null == moveGuid)
{
moveGuid = GetComponentInChildren <EdgeCollider2D> ();
}
if (null == rigid)
{
rigid = GetComponent <Rigidbody2D> ();
}
if (null == collid2d)
{
collid2d = GetComponent <Collider2D> ();
}
rigid.isKinematic = true;
collid2d.isTrigger = true;
tracer = new XYTracerGuidMoveController();
tracer.transform = transform;
tracer.guid = moveGuid;
tracer.moveSpeed = moveSpeed;
tracer.ReachPointEvent += Tracer_ReachPointEvent;
tracer.FlipingEvent += Tracer_FlipingEvent;
tracer.ReachTargetEvent += Tracer_ReachTargetEvent;
tracer.excludesIndex = jumpIndexs;
animStare.loopCount = 1;
animStare.OnAnimateEvent += OnAnimateEventDelegate;
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.enemy);
}
public void StartMove(float height, float speed, float scale)
{
InitSelf();
pausing = false;
this.height = height;
this.speed = speed;
this.scale = scale;
if (null != _cor)
{
StopCoroutine(_cor);
_cor = null;
}
running = true;
transform.localScale = new Vector3(scale, scale, 1);
Vector2[] scope = Vector2DUtils.GetScreenScope();
float xbound = render.bounds.size.x * .5f;
float rightX = scope [1].x + xbound;
float leftX = scope [0].x - xbound;
float startX = speed < 0?rightX:leftX;
float targetX = speed < 0?leftX:rightX;
Vector2DUtils.ChangePositionX(transform, startX);
gameObject.SetActive(true);
_cor = StartCoroutine(DoUpdate(targetX));
}
void DrawOutLine()
{
if (EditorApplication.isCompiling || EditorApplication.isUpdating)
{
return;
}
Gizmos.color = color;
PolygonCollider2D[] polygions = gameObject.GetComponents <PolygonCollider2D>();
for (int i = 0; null != polygions && i < polygions.Length; i++)
{
PolygonCollider2D p2d = polygions [i];
DrawPolygion(p2d.points);
}
EdgeCollider2D[] edpos = gameObject.GetComponents <EdgeCollider2D>();
for (int i = 0; null != edpos && i < edpos.Length; i++)
{
EdgeCollider2D p2d = edpos [i];
DrawPolygion(p2d.points);
}
BoxCollider2D[] boxpos = gameObject.GetComponents <BoxCollider2D>();
for (int i = 0; null != boxpos && i < boxpos.Length; i++)
{
BoxCollider2D p2d = boxpos [i];
Vector2[] v2 = Vector2DUtils.GetBoxCollider2DScope(p2d);
DrawBoxOnWorld(Vector2DUtils.BoxScopeToPoints(v2));
}
}
public static void LineLineIntersection()
{
Vector3 pInter = Vector3.zero;
Vector3 p1 = new Vector3(0, 0);
Vector3 p2 = new Vector3(10, 10);
Vector3 vx = new Vector3(p1.x, 10);
Vector3 vx1 = new Vector3(p1.x, -10);
DebugUtils.DrawPoint(p1);
DebugUtils.DrawPoint(p2);
Debug.DrawLine(p1, p2);
Debug.DrawLine(vx, vx1);
// DebugUtils.DrawPoint (vx);
// DebugUtils.DrawPoint (vx1);
bool cross = Vector2DUtils.LineLineIntersection(out pInter, p1, p2, vx, vx1);
if (cross)
{
Log.Debug("has {0}", pInter);
Debug.DrawLine(Vector3.zero, pInter);
}
else
{
Log.Debug("null.....");
}
}
void Update()
{
if (!Vector2DUtils.IsInScreen(transform.position))
{
StopAct();
Log.Debug("go to pooll...");
}
}
IEnumerator DoUpdate(Vector3 center, Vector2 size, AnimationDoneCallBack callback, float animateTime)
{
Vector2[] scope = Vector2DUtils.GetScreenScope();
//to radius
size = size * 0.5f;
Vector3 lStart = new Vector3(scope[0].x - lr.bounds.size.x * 0.5f, center.y, center.z);
Vector3 lEnd = lStart;
lEnd.x = center.x - size.x - lr.bounds.size.x * 0.5f;
Vector3 tStart = new Vector3(center.x, scope[1].y + tr.bounds.size.y * 0.5f, center.z);
Vector3 tEnd = tStart;
tEnd.y = center.y + size.y + tr.bounds.size.y * 0.5f;
Vector3 rStart = new Vector3(scope[1].x + rr.bounds.size.x * 0.5f, center.y, center.z);
Vector3 rEnd = rStart;
rEnd.x = center.x + size.x + rr.bounds.size.x * 0.5f;
Vector3 bStart = new Vector3(center.x, scope[0].y - br.bounds.size.y * 0.5f, center.z);
Vector3 bEnd = bStart;
bEnd.y = center.y - size.y - br.bounds.size.y * 0.5f;
lr.transform.position = lStart;
tr.transform.position = tStart;
rr.transform.position = rStart;
br.transform.position = bStart;
if (Math.Abs(animateTime) > Mathf.Epsilon)
{
float lSpeed = ((lEnd - lStart) / animateTime).magnitude;
float tSpeed = ((tEnd - tStart) / animateTime).magnitude;
float rSpeed = ((rEnd - rStart) / animateTime).magnitude;
float bSpeed = ((bEnd - bStart) / animateTime).magnitude;
float timeUsed = 0;
while (timeUsed < animateTime)
{
if (!pausing)
{
timeUsed += Time.deltaTime;
Vector2DUtils.MoveToSmoothly(lr.transform, lEnd, lSpeed);
Vector2DUtils.MoveToSmoothly(tr.transform, tEnd, tSpeed);
Vector2DUtils.MoveToSmoothly(rr.transform, rEnd, rSpeed);
Vector2DUtils.MoveToSmoothly(br.transform, bEnd, bSpeed);
}
yield return(null);
}
}
lr.transform.position = lEnd;
tr.transform.position = tEnd;
rr.transform.position = rEnd;
br.transform.position = bEnd;
callback(center, size);
}
protected override void DoInit()
{
base.DoInit();
if (null == animWaggle)
{
animWaggle = GetComponent <SpriteAnimator> ();
}
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.enemy);
}
void Awake()
{
_collider = GetComponent <BoxCollider2D>();
_detector = new TouchDetector(_collider);
_boxScope = Vector2DUtils.GetBoxCollider2DScope(_collider);
_vertical = Mathf.Abs(_boxScope [1].y - _boxScope [0].y) > Mathf.Abs(_boxScope [1].x - _boxScope [0].x);
_detector.OnTouchEvent += OnTouchEvent;
}
public Vector2 FindClosestPointOnMovingLine(Vector2 target)
{
Vector2 p3 = target;
Vector2 p2 = movePoints[movingIndex];
Vector2 p1 = movePoints[GetNearByIndex()];
Vector2 np = Vector2DUtils.ClosestOnLine(p1, p2, p3);
return(np);
}
private void ReverseBuild()
{
Vector3 pos = Vector2.zero;
Vector3 pos1 = Vector2.zero;
int rCount = _renders.Count / (sprites.Count * 2);
for (int i = 0; i < sprites.Count; i++)
{
SpriteRenderer sp = sprites [i];
SpriteRenderer sr = Instantiate <SpriteRenderer>(sp);
GameObject ga = sr.gameObject;
ga.name = gameObject.name + "-" + rCount + "-" + i;
ga.transform.SetParent(transform);
_renders.Add(sr);
//reverse
SpriteRenderer sr1 = Instantiate <SpriteRenderer>(sp);
GameObject ga1 = sr1.gameObject;
ga1.name = gameObject.name + "-" + rCount + "-" + i + "_r";
ga1.transform.SetParent(transform);
_renders.Add(sr1);
switch (direction2D)
{
case Direction2D.down:
{
pos = new Vector2(0, -i * _unitSize.y);
pos1 = new Vector2(0, -(sprites.Count + sprites.Count - i - 1) * _unitSize.y);
//reverse
Vector2DUtils.UpsideDown(sr1.transform);
break;
}
default:
break;
}
pos = _startPos + pos;
pos.z = transform.position.z;
sr.transform.position = pos;
pos1 = _startPos + pos1;
pos1.z = transform.position.z;
sr1.transform.position = pos1;
}
_preCaculateSize = _renders.Count * _unitSize;
switch (direction2D)
{
case Direction2D.down:
{
_startPos.y = transform.position.y - _preCaculateSize.y;
break;
}
default:
break;
}
}
protected override void DoInit()
{
base.DoInit();
_timer = new SwitchTimer();
tongueGuid = GetComponentInChildren <EdgeCollider2D> ();
tongueGuid.enabled = false;
Vector2DUtils.ChangePositionZ(transform.parent, (float)ZIndexs.enemy);
edgeCollider = gameObject.AddComponent <EdgeCollider2D> ();
edgeCollider.isTrigger = true;
}
void DrawLines()
{
if (EditorApplication.isCompiling || EditorApplication.isUpdating)
{
return;
}
BoxCollider2D[] boxpos = gameObject.GetComponents <BoxCollider2D>();
for (int i = 0; null != boxpos && i < boxpos.Length; i++)
{
BoxCollider2D p2d = boxpos [i];
Vector2[] v2 = Vector2DUtils.GetBoxCollider2DScope(p2d);
//horizontal divide
if (divideX > 0)
{
float d = (v2 [1].x - v2 [0].x) / divideX;
for (int j = 0; j < divideX; j++)
{
float vx = v2 [0].x + j * d;
if (j % 2 != 0)
{
Gizmos.color = evenColor;
}
else
{
Gizmos.color = color;
}
Gizmos.DrawLine(new Vector2(vx, v2 [0].y), new Vector2(vx, v2 [1].y));
}
}
//vertical divide
if (divideY > 0)
{
float d = (v2 [1].y - v2 [0].y) / divideY;
for (int j = 0; j < divideY; j++)
{
float vy = v2 [0].y + j * d;
if (j % 2 == 0)
{
Gizmos.color = evenColor;
}
else
{
Gizmos.color = color;
}
Gizmos.DrawLine(new Vector2(v2 [0].x, vy), new Vector2(v2 [1].x, vy));
}
}
}
}
protected override void DoInit()
{
base.DoInit();
if (null == flyGuid)
{
flyGuid = GetComponentInChildren <EdgeCollider2D> ();
}
flyGuid.isTrigger = true;
_cor = StartCoroutine(DoMyUpdate());
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.enemy);
}
protected override void DoInit()
{
base.DoInit();
_rigid = GetComponent <Rigidbody2D> ();
_rigid.isKinematic = true;
_collid = GetComponent <Collider2D> ();
_collid.isTrigger = true;
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.o4);
_shakeEffect = GetComponent <ShakeEffect> ();
// _shakeEffect.autoStart = false;
}
protected override void DoInit()
{
base.DoInit();
if (crashSpeed <= 0f)
{
crashSpeed = Constants.o3_crash_speed;
}
extraLines = GetComponentsInChildren <EdgeCollider2D> ();
_circleCollider = GetComponent <CircleCollider2D> ();
_circleCollider.isTrigger = true;
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.o3);
}
protected override void DoInit()
{
base.DoInit();
if (null == rotateCenter)
{
rotateCenter = GameObjectUtils.FindAnyOne(this.gameObject, "rotateCenter").transform;
}
if (null == board)
{
board = GameObjectUtils.FindAnyOne(this.gameObject, "board").transform;
}
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.enemy);
}
IEnumerator DoMyUpdate()
{
while (true)
{
if (null == GameController.GetSingleton() || null == GameController.GetSingleton().levelsController || null == GameController.GetSingleton().levelsController.eggController)
{
//for design
yield return(null);
}
Vector3 pos = GameController.GetSingleton().levelsController.eggController.transform.position;
float dis = Mathf.Abs((pos - transform.position).magnitude);
//Log.Debug ("E1 see egg {0}",dis);
if (sensibleDistance > dis)
{
Log.Debug("E1 see egg {0}", dis);
//start fly
animIdle.StopPlay();
animFly.StartPlay();
GameController.singleton.audioController.PlayBirdFly();
break;
}
yield return(null);
}
while (true)
{
if (!Vector2DUtils.IsInScreen(transform.position))
{
Log.Debug("E1 out of screen");
gameObject.SetActive(false);
yield break;
}
if (_flyIndex > flyPoints.Length - 1)
{
gameObject.SetActive(false);
break;
}
Vector3 fp = flyPoints [_flyIndex];
Vector2DUtils.MoveToSmoothly(transform, fp, flySpeed);
if (fp == transform.position)
{
_flyIndex++;
}
yield return(null);
}
}
protected override void DoInit()
{
const int total = 3;
sprites = new System.Collections.Generic.List <UnityEngine.Sprite> (total);
for (int i = 0; i < total; i++)
{
Sprite sp = Resources.Load <Sprite> (string.Format("Img/O2-{0}", i + 1));
sprites.Add(sp);
}
base.DoInit();
Vector2DUtils.ChangePositionZ(transform, (float)ZIndexs.o2);
}
public void StartRun(Vector3 startPos = default(Vector3))
{
InitSelf();
Reset();
if (Vector3.zero != startPos)
{
Log.Info("start run at position {0}", startPos);
Vector2DUtils.ChangePositionY(transform, startPos.y);
}
else
{
transform.position = _startPos;
}
// gameObject.SetActive (true);
_rigid.isKinematic = false;
running = true;
}
public void Update()
{
if (!started)
{
return;
}
if (_pausing)
{
return;
}
Vector3 fp = movePoints [movingIndex];
Vector3 v = Vector2DUtils.MoveToSmoothly(transform, fp, moveSpeed);
// Log.Debug ("moving... {0},{1},{2},{3},{4}",movingIndex,fp,v,transform.position,moveSpeed);
int reachedPoint = -1;
if ((Vector2)fp == (Vector2)transform.position)
{
// Log.Debug ("OnReachPosition {0},{1}",fp , transform.position);
OnReachPosition(movingIndex, fliping);
reachedPoint = movingIndex;
if (!fliping)
{
if (movingIndex == movePoints.Length - 1)
{
HandleFlip();
}
else
{
movingIndex++;
}
}
else
{
if (movingIndex == 0)
{
HandleFlip();
}
else
{
movingIndex--;
}
}
}
PostUpdate(reachedPoint);
}
IEnumerator DoJump(Vector3 pos)
{
while (transform.position != pos)
{
if (!pausing)
{
Vector2DUtils.MoveToSmoothly(transform, pos, activeJumpSpeed);
}
yield return(null);
}
animJump.StopPlay();
animClimb.StartPlay();
Transform egg = GameController.GetSingleton().levelsController.eggController.transform;
tracer.target = egg;
tracer.Start();
Log.Debug("E9 start trace...");
}
IEnumerator DoMyUpdate()
{
Vector3 center = Vector3.zero;
if (Direction2D.right == _direction2D)
{
center = _branch.transform.position;
center.x = center.x - _branchSpriteSize.x * 0.5f;
}
else
{
center = _branch.transform.position;
center.x = center.x + _branchSpriteSize.x * 0.5f;
}
int up = 1;
while (true)
{
if (Vector2DUtils.IsOutsideScreen(transform.position, Direction2D.up))
{
Log.Debug("E10 out of screen");
gameObject.SetActive(false);
yield break;
}
if (!pausing)
{
_branch.transform.RotateAround(center, new Vector3(0, 0, 1), up * speed * Time.deltaTime);
// Log.Debug ("erule {0}", transform.eulerAngles);
float z = transform.eulerAngles.z;
if (up == 1 && z > angle && z < 180)
{
up = -1;
}
else if (up == -1 && z < 360 - angle && z > 180)
{
up = 1;
}
}
yield return(null);
}
}
public static void Angle()
{
Vector2 v1 = new Vector2(0, 0);
Vector2 v0 = new Vector2(0, 0);
float an = 0;
v1 = new Vector2(1, 1);
an = Vector2DUtils.XAngleOfLineSegment(v0, v1);
Log.Debug("{0} angle is {1}", v1, an);
v1 = new Vector2(-1, 1);
an = Vector2DUtils.XAngleOfLineSegment(v0, v1);
Log.Debug("{0} angle is {1}", v1, an);
v1 = new Vector2(-1, -1);
an = Vector2DUtils.XAngleOfLineSegment(v0, v1);
Log.Debug("{0} angle is {1}", v1, an);
v1 = new Vector2(1, -1);
an = Vector2DUtils.XAngleOfLineSegment(v0, v1);
Log.Debug("{0} angle is {1}", v1, an);
}
void DrawOutLine()
{
if (EditorApplication.isCompiling || EditorApplication.isUpdating)
{
return;
}
Vector2[] scope = Vector2DUtils.GetScreenScope();
Vector3 _p1 = Vector3.zero;
Vector3 _p2 = Vector3.zero;
_p1.y = transform.position.y;
_p1.x = scope[0].x;
_p2.y = transform.position.y;
_p2.x = scope[1].x;
Gizmos.color = color;
Gizmos.DrawLine(_p1, _p2);
}
void Update()
{
if (_startedShow && Vector2DUtils.IsOutsideScreen(transform.position, Direction2D.down, null))
{
Log.Debug("left screen, destroy.");
StopAct();
return;
}
if (pausing)
{
// Log.Debug (" 01 ...");
return;
}
float tdis = Mathf.Abs(transform.position.y - GameController.GetSingleton().levelsController.eggController.transform.position.y);
if (!_startedShow && tdis < 0.5f)
{
// Log.Debug (" 1 ...");
//start fall
Fall();
}
}
