public void RemoveLaser()
{
if (detected_character != null)
{
if (detected_character.CompareTag("Main_Character"))
{
if (detected_character.GetComponent <Main_Character_Status_Manager>().status == MainCharacterStatus.Aimed)
{
detected_character.GetComponent <Main_Character_Status_Manager>().status = MainCharacterStatus.Normal;
}
}
else if (detected_character.CompareTag("Fairy"))
{
if (detected_character.GetComponent <Fairy_Status_Manager>().status == FairyStatus.Aimed)
{
detected_character.GetComponent <Fairy_Status_Manager>().status = FairyStatus.Normal;
}
}
}
shoot_star_time_count = 0;
detected_character = null;
detected_star = null;
detected_character = null;
detected_star = null;
hit_enemy = null;
LaserLine_disappear_time_count = 0;
CurrentLaserState = LaserState.Null;
ClearLaserLine();
}
public override void Start()
{
m_laserParameters = Engine.AssetManager.GetAsset <LaserParameters>("Arenas/Common/Laser.lua::Laser");
InitSprites();
m_state = LaserState.Off;
m_laserInTimer = new Timer(Engine.GameTime.Source, 1600);
m_laserOnTimer = new Timer(Engine.GameTime.Source, 5000);
m_laserOutTimer = new Timer(Engine.GameTime.Source, m_sparkFadeTimeMS);
m_laserCmp.Visible = false;
m_botSparkCmp.Visible = false;
m_topSparkCmp.Visible = false;
var bodyCmp = new RigidBodyComponent();
bodyCmp.Body.CollisionCategories = (Category)CollisionType.Wall;
m_laserFixture = FixtureFactory.AttachRectangle(
ConvertUnits.ToSimUnits(m_width),
ConvertUnits.ToSimUnits(m_height),
0,
ConvertUnits.ToSimUnits(m_laserPosition),
bodyCmp.Body);
Owner.Attach(bodyCmp);
Owner.RigidBodyCmp.OnCollision += new CollisionEvent(RigidBodyCmp_OnCollision);
Owner.RigidBodyCmp.Body.BodyType = BodyType.Static;
}
private void LateUpdate()
{
lasers.ForEach(ls => ls.is_active = false);
lasers = lasers.ConvertAll(ls =>
{
LaserState new_laser = laser_changes.Find(lsc => ls.laser_color.Equals(lsc.laser_color));
if (new_laser == null)
{
return(ls);
}
else
{
laser_changes.Remove(new_laser);
if (new_laser.target == null)
{
new_laser.target = ls.target;
}
return(new_laser);
}
});
lasers.AddRange(laser_changes);
laser_changes.Clear();
lasers.RemoveAll(ls => removed_lasers.Contains(ls.laser_color));
removed_lasers.Clear();
}
IEnumerator enterState(LaserState nextState)
{
switch (nextState) {
case LaserState.idle:
myState = LaserState.idle;
//turnOff laser
turnOffLaser();
yield return null;
break;
case LaserState.firing:
if( myState != LaserState.firing)
{turnOnLaser();}
myState = LaserState.firing;
yield return new WaitForSeconds(chargeTime);
StartCoroutine(leaveState(LaserState.firing));
break;
case LaserState.none:
break;
default:
break;
}
//StartCoroutine( leaveState (nextState));
}
// Start is called before the first frame update
void Start()
{
EventManager.instance.AddHandler <CharacterDied>(OnCharacterDied);
detected_character = null;
detected_star = null;
CurrentLaserState = LaserState.Null;
}
public void StartLaser()
{
m_state = LaserState.In;
m_laserInTimer.Start();
m_botSparkCmp.Sprite.SetAnimation("Normal");
m_topSparkCmp.Sprite.SetAnimation("Normal");
}
public SlaveLaser(string name)
{
lState = LaserState.FREE;
this.Name = name;
laser = new DAQMxTCL2012LaserControlHelper(Name);
laser.ConfigureSetLaserVoltage(0.0);
}
private void releaseLaser()
{
if (lState == LaserState.BUSY)
{
tcl.ReleaseLaser();
lState = LaserState.FREE;
}
}
private void setToLaserEngaged()
{
if (lState == LaserState.FREE)
{
lState = LaserState.BUSY;
tcl.ConfigureSetLaserVoltage(VoltageToLaser);
}
}
public void ResetLaser(Color color)
{
LaserState laser = lasers.Find(ls => ls.laser_color.Equals(color));
if (laser != null)
{
lasers.Remove(laser);
}
}
private void SetLaserState(LaserState laserState)
{
if (_currentLaserState == laserState)
{
return;
}
_currentLaserState = laserState;
}
public override void Spawn(Vector2 pos, Vector2 dir)
{
Animation = _animations[_currentAnim = 0];
base.Spawn(pos, dir);
_canCollide = false;
State = LaserState.Activating;
_timeAnim = 0;
_frameAnim = 0;
}
public Laser(string feedbackChannel, string photoDiode, Cavity cavity)
{
laser = new DAQMxTCL2012LaserControlHelper(feedbackChannel);
lState = LaserState.FREE;
Name = feedbackChannel;
FeedbackChannel = feedbackChannel;
PhotoDiodeChannel = photoDiode;
ParentCavity = cavity;
laser.ConfigureSetLaserVoltage(0.0);
}
public override Vector3?FireTrigger()
{
LaserState ls = worldState.GetLaserState(laser_color);
if (ls != null && ls.is_active)
{
return(ls.hit.point);
}
return(null);
}
public void Activate()
{
myTransform = transform;
ceilingXFloorY.x = GameObject.Find("CeilingFloor2").transform.position.y;
ceilingXFloorY.y = Floor_2Positioner.myY;
crossTransform = myTransform.parent.transform;
lr = GetComponent <LineRenderer>();
lr.enabled = false;
state = LaserState.Spread;
CalculateSpreadSpeed();
}
private void finalizeRamping()
{
tcl.ReleaseCavityHardware();
if (lState == LaserState.BUSY)
{
VoltageToLaser = 0.0;
tcl.SetLaserVoltage(0.0);
tcl.ReleaseLaser();
lState = LaserState.FREE;
}
}
private void OnOutOfScreenStateUpdate()
{
Vector3 nextPosition =
m_LaserPosition + (m_LaserDirection * LaserVelocity * Time.deltaTime);
Vector2 screenPosition = Camera.main.WorldToScreenPoint(nextPosition);
if ((screenPosition.x > 0) && (screenPosition.x < Screen.width) &&
(screenPosition.y > 0) && (screenPosition.y < Screen.height))
{
m_NextState = LaserState.Update;
}
}
private void SwitchLaser(LaserState state)
{
beatCount = 0;
if (state == LaserState.On)
{
spRenderer.enabled = true;
}
else
{
spRenderer.enabled = false;
}
}
public void Stop()
{
_canCollide = false;
State = LaserState.DeActivationTransition;
Animation = _animations[_currentAnim = 1];
_timeAnim = 0;
_frameAnim = Animation.Frames.Length - 1;
Animation.Animate(this, ref _timeAnim, ref _frameAnim, 0, true);
_timeAnim = 0;
_frameAnim = Animation.Frames.Length - 1;
}
public void StartAttack()
{
state = LaserState.Spread;
startPos = crossTransform.position;
startPos.y = ceilingXFloorY.x;
lrPos = startPos;
lr.SetPosition(0, lrPos);
lr.SetPosition(1, lrPos);
var hole = GameObject.Instantiate(spaceHolePrefab, lrPos, Quaternion.identity);
Destroy(hole, 0.5f);
lr.enabled = true;
attackElement.gameObject.SetActive(true);
}
public override Transform FireTrigger()
{
if (worldState == null || laser_color == null)
{
return(null);
}
LaserState ls = worldState.GetLaserState(laser_color);
if (Time.deltaTime != 0f && ls != null && ls.target != null)
{
return(ls.target);
}
return(null);
}
private void Alert()
{
var Enemy_Status = GetComponent <Enemy_Status_Manager>();
if (Enemy_Status.status == EnemyStatus.Alert)
{
alert_time_count += Time.deltaTime;
if (alert_time_count > Alert_Time)
{
alert_time_count = Alert_Time;
Enemy_Status.status = EnemyStatus.ShootCharacter;
CurrentLaserState = LaserState.Null;
hit_enemy = null;
}
}
}
private void OnFireStateUpdate()
{
// Checks for valid laser direction.
if (m_LaserDirection.magnitude >= 0.95f)
{
m_LaserRenderer.positionCount = 3;
m_LaserRenderer.SetPosition(0, m_StartPosition);
m_LaserRenderer.SetPosition(1, (m_StartPosition + m_LaserPosition) * 0.5f);
m_LaserRenderer.SetPosition(2, m_LaserPosition);
m_NextState = LaserState.Update;
}
else
{
m_NextState = LaserState.Inactive;
}
}
public override void Update()
{
base.Update();
if (computer != null)
{
int topMountRotation = computer.ReadPort(port);
topMount.transform.localRotation = Quaternion.Euler(new Vector3(topMountRotation, 0, 0));
int bottomMountRotation = computer.ReadPort(port + 1);
bottomMount.transform.localRotation = Quaternion.Euler(new Vector3(0, bottomMountRotation, 0));
int shouldFire = computer.ReadPort(port + 2);
switch (laserState)
{
case LaserState.Off:
laser.SetActive(false);
if (shouldFire != 0)
{
laserState = LaserState.Charging;
chargeStart = Time.time;
}
break;
case LaserState.Charging:
laser.SetActive(false);
if (shouldFire != 0 && Time.time - chargeStart > chargeTime)
{
laserState = LaserState.Firing;
fireStart = Time.time;
}
break;
case LaserState.Firing:
if (shouldFire == 0 || Time.time - fireStart > fireTime)
{
laserState = LaserState.Off;
}
else
{
laser.SetActive(true);
}
break;
}
}
}
private void OnUpdateStateUpdate()
{
m_LaserPosition += m_LaserDirection * LaserVelocity * Time.deltaTime;
m_LaserRenderer.SetPosition(m_LaserRenderer.positionCount++, m_LaserPosition);
var screenPosition = Camera.main.WorldToScreenPoint(m_LaserPosition);
if ((screenPosition.x < 0) || (screenPosition.x > Screen.width) ||
(screenPosition.y < 0) || (screenPosition.y > Screen.height))
{
// Clamps to screen space.
screenPosition.x = Mathf.Clamp(screenPosition.x, 0, Screen.width - 1);
screenPosition.y = Mathf.Clamp(screenPosition.y, 0, Screen.height - 1);
m_NextState = LaserState.OutOfScreen;
}
Vector2 hitUv = ScreenPointToViewCoordinate(screenPosition);
Vector2 depthUV = DepthSource.ScreenToDepthUV(hitUv);
float depth = DepthSource.GetDepthFromUV(depthUV, DepthSource.DepthArray);
if (screenPosition.z > depth)
{
Vector3 CurrentDirection = m_LaserDirection;
Vector3 normal = ComputeNormalMapFromDepthWeightedMeanGradient(hitUv);
// Checks if the normal is valid.
if (float.IsInfinity(normal.x) ||
float.IsNegativeInfinity(normal.x) ||
float.IsNaN(normal.x))
{
return;
}
// Transforms normal to the world space.
normal = Camera.main.transform.TransformDirection(normal);
m_LaserDirection = Reflect(CurrentDirection, normal);
// Adds collision quad.
VisualizeNormalVector(m_LaserPosition, normal);
m_LaserPosition = m_LaserPosition + (m_LaserDirection * LaserVelocity * Time.deltaTime);
m_LaserRenderer.SetPosition(m_LaserRenderer.positionCount++, m_LaserPosition);
}
}
private void Update()
{
if (m_NextState != m_CurrentState)
{
switch (m_NextState)
{
case LaserState.Inactive:
OnInactiveStateEnter();
break;
case LaserState.Fire:
OnFireStateEnter();
break;
case LaserState.Update:
OnUpdateStateEnter();
break;
case LaserState.OutOfScreen:
OnOutOfScreenStateEnter();
break;
}
m_CurrentState = m_NextState;
}
switch (m_CurrentState)
{
case LaserState.Fire:
OnFireStateUpdate();
break;
case LaserState.Update:
OnUpdateStateUpdate();
break;
case LaserState.OutOfScreen:
OnOutOfScreenStateUpdate();
break;
}
}
private void Update()
{
if (state == LaserState.Spread)
{
lr.SetPosition(0, startPos);
if (lrPos.y > ceilingXFloorY.y)
{
lrPos += Vector3.down * spreadSpeed * Time.deltaTime;
lr.SetPosition(1, lrPos);
attackElement.position = lrPos;
}
else
{
lrPos.y = ceilingXFloorY.y;
lr.SetPosition(1, lrPos);
lr.enabled = false;
state = LaserState.Attack;
attackElement.gameObject.SetActive(false);
}
}
}
public void LaserFired(RaycastHit hit, Color color)
{
LaserState laser = laser_changes.Find(ls => ls.laser_color.Equals(color));
if (laser != null)
{
laser.is_active = true;
laser.hit = hit;
}
else
{
laser = new LaserState();
laser.hit = hit;
if (hit.collider.GetComponent <Targetable>() != null)
{
laser.target = hit.collider.transform;
}
laser.is_active = true;
laser.laser_color = color;
laser_changes.Add(laser);
}
}
private void SwitchLaser(LaserState state)
{
beatCount = 0;
if (state == LaserState.On)
{
onLaserRenderer.enabled = true;
offLaserRenderer.enabled = false;
for (int i = 0; i < beamRendererList.Count; i++)
{
beamRendererList[i].enabled = true;
}
}
else
{
offLaserRenderer.enabled = true;
onLaserRenderer.enabled = false;
for (int i = 0; i < beamRendererList.Count; i++)
{
beamRendererList[i].enabled = false;
}
}
}
public void DisengageLock()
{
lState = LaserState.FREE;
laser.SetLaserVoltage(VoltageToLaser);
controller.UpdateUIState(Name, lState);
}
public void ArmLock()
{
lState = LaserState.LOCKING;
controller.UpdateUIState(Name, lState);
}
public void ArmLock()
{
lState = LaserState.LOCKING;
}
public void DisengageLock()
{
lState = LaserState.FREE;
}
protected virtual void Lock()
{
lState = LaserState.LOCKED;
}
private void finalizeRamping()
{
tcl.ReleaseCavityHardware();
if (lState == LaserState.BUSY)
{
VoltageToLaser = 0.0;
tcl.SetLaserVoltage(0.0);
tcl.ReleaseLaser();
lState = LaserState.FREE;
}
}
IEnumerator leaveState(LaserState oldState)
{
LaserState newState = LaserState.none;
switch (oldState) {
case LaserState.idle:
//enterState(LaserState.firing);
newState = LaserState.firing;
break;
case LaserState.firing:
//enterState(LaserState.idle);
newState = LaserState.idle;
StartCoroutine(enterState(LaserState.idle));
break;
case LaserState.none:
break;
default:
break;
}
yield return null;
}
private void setToLaserEngaged()
{
if (lState == LaserState.FREE)
{
lState = LaserState.BUSY;
tcl.ConfigureSetLaserVoltage(VoltageToLaser);
}
}
public void Lock()
{
lState = LaserState.LOCKED;
controller.UpdateUIState(Name, lState);
}
/// <summary>
/// Updates the Dart ship
/// </summary>
/// <param name="elapsedTime">The in-game time between the previous and current frame</param>
public override void Update(float elapsedTime)
{
switch (BES)
{
case birdEntranceState.flyOver:
this.position.Y -= elapsedTime * 500;
if (position.Y <= 2000) // -200
{
BES = birdEntranceState.enter;
}
break;
case birdEntranceState.enter:
PlayerShip player = ScrollingShooterGame.Game.Player;
Vector2 playerPosition = new Vector2(player.Bounds.Center.X, player.Bounds.Center.Y);
if (ScrollingShooterGame.LevelManager.scrollDistance > -7300 && ScrollingShooterGame.LevelManager.Scrolling == true)
{
ScrollingShooterGame.LevelManager.Scrolling = false;
this.position.Y = 3400;
scream.Play();
}
if (ScrollingShooterGame.LevelManager.Scrolling == false)
{
this.position.Y += elapsedTime * 100;
}
if (position.Y >= 3650 && ScrollingShooterGame.LevelManager.Scrolling == false)
{
BES = birdEntranceState.normal;
}
break;
case birdEntranceState.normal:
fireTimer += elapsedTime;
laserTimer += elapsedTime;
if (Health < 75 && !leftLaserDestroyed)
{
leftLaserDestroyed = true;
RightLaser.isOn = false;
hurt.Play();
}
if (Health < 50 && !rightLaserDestroyed)
{
rightLaserDestroyed = true;
LeftLaser.isOn = false;
hurt.Play();
}
float velocity = 1;
// Sense the player's position
player = ScrollingShooterGame.Game.Player;
playerPosition = new Vector2(player.Bounds.Center.X, player.Bounds.Center.Y);
if (playerPosition.X - Bounds.Center.X < -20)
{
this.position.X -= elapsedTime * 40 * velocity;
}
else
{
if (playerPosition.X - Bounds.Center.X > 20)
{
this.position.X += elapsedTime * 40 * velocity;
}
else
{
if (fireTimer > 0.6f)
{
ScrollingShooterGame.GameObjectManager.CreateProjectile(ProjectileType.BirdWrath, position + beakPosition);
fire.Play();
fireTimer = 0f;
}
}
}
if (fireTimer > 1.5f)
{
ScrollingShooterGame.GameObjectManager.CreateProjectile(ProjectileType.BirdWrath, position + beakPosition);
fire.Play();
fireTimer = 0f;
}
//Firein Mah Lazars!!
switch (laserState)
{
case LaserState.off:
if (laserTimer > 3f)
{
laserState = LaserState.turningOn;
laserAnimState = 0;
}
break;
case LaserState.turningOn:
laserAnimState++;
if (laserAnimState == NUMBER_OF_ANIM_STATES_LASER - 1)
{
laserState = LaserState.on;
laserTimer = 0f;
}
break;
case LaserState.on:
if (!rightLaserDestroyed) LeftLaser.isOn = true;
if (!leftLaserDestroyed) RightLaser.isOn = true;
LeftLaser.updatePosition(position.X + LeftLaserPosition.X, position.Y + LeftLaserPosition.Y);
RightLaser.updatePosition(position.X + RightLaserPosition.X, position.Y + RightLaserPosition.Y);
if (laserTimer > 3f)
{
LeftLaser.isOn = false;
RightLaser.isOn = false;
laserState = LaserState.turningOff;
}
break;
case LaserState.turningOff:
laserAnimState--;
if (laserAnimState == 0)
{
laserState = LaserState.off;
laserTimer = 0f;
}
break;
}
break;
case birdEntranceState.exit:
this.position.Y += elapsedTime * 500;
break;
}
if (Health <= 1)
{
ScrollingShooterGame.LevelManager.Scrolling = true;
death.Play();
}
}
private void releaseLaser()
{
if (lState == LaserState.BUSY)
{
tcl.ReleaseLaser();
lState = LaserState.FREE;
}
}
void planes()
{
Vector2 mousePos = Input.mousePosition;
float dist;
Ray ray = Camera.main.ScreenPointToRay(mousePos);
plane.distance = transform.position.z + 1f;
if ( plane.Raycast(ray, out dist)){
Vector3 point = ray.GetPoint(dist);
//Vector3 worldPos = Camera.main.ScreenToWorldPoint(new Vector3 (mousePos.x,mousePos.y,0));
Vector3 diff = point - transform.position;
diff.z = 0;
if(diff.magnitude > strafeSpeed * Time.deltaTime){
diff.Normalize();
diff *= strafeSpeed * Time.deltaTime;
transform.position += diff;
}
}
plane2.distance = transform.position.z + 10f;
if (plane2.Raycast (ray, out dist))
{
Vector3 point = ray.GetPoint(dist);
transform.LookAt(point);
if (laserState == LaserState.prepped && Input.GetMouseButtonDown(0)){
laserState = LaserState.firing;
laserTimeAccum = 0f;
laserTarget = point;
Ray collisionRay = Camera.main.ScreenPointToRay (Input.mousePosition);
Debug.Log ("Try to hit");
RaycastHit[] hitlist = Physics.RaycastAll(ray);
foreach(RaycastHit hit in hitlist){
Debug.Log ("We hit");
if (hit.collider.transform.tag == "Player"){
continue;
}
if (hit.collider.transform.tag == "enemy"){
Destroy(hit.collider.gameObject);
score+=100;
}
if (hit.collider.transform.tag == "civilian"){
Destroy(hit.collider.gameObject);
score-=100;
damage();
}
else{
Debug.Log("Hit a Wall: " + hit.collider.gameObject.name);
break;
}
}
}
}
if (laserState != LaserState.prepped)
{
laserTimeAccum += Time.deltaTime;
Vector3 diff = (laserTarget - transform.position).normalized;
Vector3 final = diff * laserLength;
laserRenderer.SetPosition(0, transform.position + diff * laserTimeAccum * 10);
laserRenderer.SetPosition(1, transform.position + final + diff * laserTimeAccum * 10);
if (laserState == LaserState.firing)
{
if (laserTimeAccum > laserFiringDuration)
{
laserState = LaserState.cooldown;
}
}
else if (laserState == LaserState.cooldown)
{
if (laserTimeAccum > laserCooldownDuration + laserFiringDuration)
{
laserState = LaserState.prepped;
}
}
}
if(invulnerable){
invTimer--;
if(invTimer <0){
invulnerable = false;
rigidbody.velocity = new Vector3(0,0,0);
}
} else{
transform.position = new Vector3( transform.position.x, transform.position.y, effectivePosition);
}
}
