public IEnumerator auto_play()
{
for (;;)
{
float time = MyRandom.Range(0.5f, 1f);
float dir = (float)((int)MyRandom.Range(0f, 8f)) * Mathf.PI * 0.25f;
for (var i = new Utility.WaitForSeconds(time, update_time_); !i.end(update_time_);)
{
autoplay_buttons_[(int)InputManager.Button.Horizontal] = (int)(Mathf.Cos(dir) * 128f);
autoplay_buttons_[(int)InputManager.Button.Vertical] = (int)(Mathf.Sin(dir) * 128f);
if (MyRandom.ProbabilityForSecond(1f, SystemManager.Instance.getDT()))
{
autoplay_buttons_[(int)InputManager.Button.Fire] = 0;
}
else
{
autoplay_buttons_[(int)InputManager.Button.Fire] = 1;
}
if (MyRandom.ProbabilityForSecond(0.6f, SystemManager.Instance.getDT()))
{
autoplay_buttons_[(int)InputManager.Button.Roll] = MyRandom.Range(-1, 2);
}
yield return(null);
if (hit_wall_)
{
break;
}
}
}
}
public override void update(float dt, double update_time)
{
var player = Player.Instance;
var diff = player.rigidbody_.transform_.position_ - rigidbody_.transform_.position_;
var dir = new Vector3(0f, 0f, diff.magnitude * 0.5f);
var lookat = player.rigidbody_.transform_.transformPosition(ref dir);
diff = lookat - rigidbody_.transform_.position_;
rigidbody_.transform_.rotation_ = (Quaternion.LookRotation(diff) *
Quaternion.Euler((Mathf.PerlinNoise((float)update_time * 0.4f, 0f) - 0.5f) * 10f,
(Mathf.PerlinNoise((float)update_time * 0.4f, 0.3f) - 0.5f) * 10f,
(Mathf.PerlinNoise((float)update_time * 0.4f, 0.6f) - 0.5f) * 10f));
var phase = update_time * 4f;
var mag = 3f;
var point = new Vector3((float)System.Math.Sin(phase) * mag, 2f, (float)System.Math.Cos(phase) * mag);
var target = player.rigidbody_.transform_.transformPosition(ref point);
if (MyRandom.Probability(0.005f))
{
spring_ratio_idx_ = MyRandom.Range(0, spring_ratio_table_.Length);
}
float spring_ratio = spring_ratio_table_[spring_ratio_idx_];
rigidbody_.addSpringForce(ref target, spring_ratio);
rigidbody_.addRelativeForceX(relative_force_table_[spring_ratio_idx_]);
rigidbody_.update(dt);
rigidbody_.solveForGround(1f, dt);
}
public override void update(float dt, double update_time)
{
if (MyCollider.getHitOpponentForEnemyBullet(collider_) != MyCollider.Type.None)
{
Vector3 intersect_point;
MyCollider.getIntersectPointForEnemyBullet(collider_, out intersect_point);
Spark.Instance.spawn(ref intersect_point, Spark.Type.EnemyBullet, update_time);
destroy();
return;
}
if (rigidbody_.transform_.position_.y < 0f)
{
WaterSurface.Instance.makeBump(ref rigidbody_.transform_.position_, 0.5f /* value */, 0.5f /* size */);
destroy();
var pos = new Vector3(rigidbody_.transform_.position_.x, -0.5f, rigidbody_.transform_.position_.z);
for (var i = 0; i < 4; ++i)
{
var spread = 2f;
var vel = new Vector3(Mathf.Cos(i * Mathf.PI * (2f / 8f)) * spread,
MyRandom.Range(5f, 7f),
Mathf.Sin(i * Mathf.PI * (2f / 8f)) * spread);
WaterSplash.Instance.spawn(ref pos, ref vel, update_time);
}
return;
}
rigidbody_.update(dt);
MyCollider.updateEnemyBullet(collider_, ref rigidbody_.transform_.position_);
if (update_time - start_ > MyRandom.Range(2f, 2.5f)) // 寿命
{
destroy();
return;
}
}
private void zako_update(float dt)
{
if (phase_ == Phase.Alive)
{
if (MyCollider.getHitOpponentForEnemy(collider_) != MyCollider.Type.None)
{
float p = 100f;
rigidbody_.addTorque(MyRandom.Range(-p, p),
MyRandom.Range(-p, p),
MyRandom.Range(-p, p));
life_ -= MyCollider.getHitPowerForEnemy(collider_);
if (life_ <= 0f)
{
Explosion.Instance.spawn(ref rigidbody_.transform_.position_, update_time_);
Hahen.Instance.spawn(ref rigidbody_.transform_.position_, update_time_);
SystemManager.Instance.registSound(DrawBuffer.SE.Explosion);
MyCollider.disableForEnemy(collider_);
phase_ = Phase.Dying;
}
else
{
Vector3 pos;
MyCollider.getIntersectPointForEnemy(collider_, out pos);
Spark.Instance.spawn(ref pos, Spark.Type.Bullet, update_time_);
}
}
}
rigidbody_.update(dt);
MyCollider.updateEnemy(collider_, ref rigidbody_.transform_.position_);
MyCollider.updateEnemyHoming(collider_homing_, ref rigidbody_.transform_.position_);
}
private void init(ref Vector3 position, ref Quaternion rotation, LockTarget lock_target)
{
// var rotation = Quaternion.identity;
base.init(ref position, ref rotation);
rigidbody_.init();
rigidbody_.transform_.position_ = position;
float theta;
if (MyRandom.Probability(0.5f))
{
theta = (MyRandom.Range(-1f, 1f) * Mathf.PI * 0.125f) * Mathf.Rad2Deg;
}
else
{
theta = (MyRandom.Range(-1f, 1f) * Mathf.PI * 0.125f + Mathf.PI) * Mathf.Rad2Deg;
}
var rot = Quaternion.Euler(0f, 0f, theta) * rotation;
var v = rot * new Vector3(20f, 0f, 0f);
rigidbody_.setVelocity(ref v);
lock_target_ = lock_target;
trail_locator_ = new Vector3(0, 0, -1);
// var col = new Color(0.1f, 1f, 0.5f);
var pos = rigidbody_.transform_.transformPosition(ref trail_locator_);
trail_id_ = Trail.Instance.spawn(ref pos,
0.2f /* width */,
Trail.Type.Missile);
arrival_time_ = MyRandom.Range(1.0f, 1.5f);
destroy_start_ = 0f;
}
public void update(float dt, double update_time, ref MyTransform parent_transform)
{
if (MyCollider.getHitOpponentForEnemy(collider_) != MyCollider.Type.None)
{
rigidbody_.addTorque(MyRandom.Range(-20f, 20f),
MyRandom.Range(-20f, 20f),
MyRandom.Range(-20f, 20f));
}
if (lock_target_.isHitted())
{
rigidbody_.addTorque(MyRandom.Range(-200f, 200f),
MyRandom.Range(-200f, 200f),
MyRandom.Range(-200f, 200f));
lock_target_.clearLock();
Explosion.Instance.spawn(ref lock_target_.updated_position_, update_time);
Hahen.Instance.spawn(ref lock_target_.updated_position_, update_time);
Shockwave.Instance.spawn(ref lock_target_.updated_position_, update_time);
SystemManager.Instance.registSound(DrawBuffer.SE.Explosion);
}
rigidbody_.addSpringTorque(ref parent_transform.rotation_, 30f /* torque_level */);
var pos = parent_transform.transformPosition(ref locator_);
rigidbody_.transform_.position_ = pos;
rigidbody_.update(dt);
MyCollider.updateEnemy(collider_, ref rigidbody_.transform_.position_);
lock_target_.update();
}
public override void update(float dt, double update_time)
{
if (is_held_)
{
return;
}
if (MyCollider.isDisabledBullet(collider_) && update_time - start_ > 0.1)
{
MyCollider.disableForBullet(collider_, false);
}
var collider_type = MyCollider.getHitOpponentForBullet(collider_);
if (collider_type != MyCollider.Type.None)
{
if (collider_type == MyCollider.Type.EnemyHoming)
{
Vector3 target;
MyCollider.getHitOpponentInfoPositionForBullet(collider_, out target);
var diff = target - rigidbody_.transform_.position_;
Vector3.Normalize(diff);
const float speed = 10f;
diff *= speed;
rigidbody_.setVelocity(ref diff);
}
else
{
Spark.Instance.spawn(ref rigidbody_.transform_.position_, Spark.Type.Bullet, update_time);
destroy();
return;
}
}
if (rigidbody_.transform_.position_.y < 0f)
{
WaterSurface.Instance.makeBump(ref rigidbody_.transform_.position_, 0.5f /* value */, 1f /* size */);
destroy();
var pos = new Vector3(rigidbody_.transform_.position_.x, -0.5f, rigidbody_.transform_.position_.z);
for (var i = 0; i < 8; ++i)
{
var spread = 2f;
var vel = new Vector3(Mathf.Cos(i * Mathf.PI * (2f / 8f)) * spread,
MyRandom.Range(5f, 7f),
Mathf.Sin(i * Mathf.PI * (2f / 8f)) * spread);
WaterSplash.Instance.spawn(ref pos, ref vel, update_time);
}
return;
}
prev_position_ = rigidbody_.transform_.position_;
rigidbody_.update(dt);
MyCollider.updateBullet(collider_, ref rigidbody_.transform_.position_);
if (update_time - start_ > MyRandom.Range(2f, 2.5f)) // 寿命
{
destroy();
return;
}
}
public void spawn(ref Vector3 pos, ref Vector3 velocity, double update_time)
{
if (velocity.y <= 0f && pos.y < 0f)
{
return;
}
int cnt = 0;
while (alive_table_[spawn_index_] != 0)
{
++spawn_index_;
if (spawn_index_ >= WATERSPLASH_MAX)
{
spawn_index_ = 0;
}
++cnt;
if (cnt >= WATERSPLASH_MAX)
{
Debug.LogError("EXCEED WaterSplash POOL!");
Debug.Assert(false);
return;
}
}
alive_table_[spawn_index_] = 1;
int id = spawn_index_;
var rot = MyRandom.Range(0, Mathf.PI * 2f);
positions_[id] = pos;
velocities_[id] = velocity;
uv2_list_[id] = new Vector2((float)update_time, rot);
}
private void zako2_update(float dt, float flow_speed)
{
if (MyCollider.getHitOpponentForEnemy(collider_) != MyCollider.Type.None)
{
rigidbody_.addTorque(MyRandom.Range(-200f, 200f),
MyRandom.Range(-200f, 200f),
MyRandom.Range(-200f, 200f));
life_ -= 20f;
}
if (lock_target_.isHitted())
{
rigidbody_.addTorque(MyRandom.Range(-200f, 200f),
MyRandom.Range(-200f, 200f),
MyRandom.Range(-200f, 200f));
lock_target_.clearLock();
life_ -= 100f;
}
if (life_ <= 0f && phase_ == Phase.Alive)
{
Explosion.Instance.spawn(ref lock_target_.updated_position_, update_time_);
Hahen.Instance.spawn(ref lock_target_.updated_position_, update_time_);
Shockwave.Instance.spawn(ref lock_target_.updated_position_, update_time_);
SystemManager.Instance.registSound(DrawBuffer.SE.Explosion);
MyCollider.disableForEnemy(collider_);
lock_target_.disable();
phase_ = Phase.Dying;
}
rigidbody_.update(dt);
MyCollider.updateEnemy(collider_, ref rigidbody_.transform_.position_);
lock_target_.update();
}
private void alpha_normal_act(float dt, double update_time)
{
if (target_fighter_ == null || MyRandom.Probability(0.025f, dt))
{
target_fighter_ = Fighter.searchFarest(fighter_id_, ref rigidbody_.transform_.position_);
}
if (target_fighter_ != null)
{
rigidbody_.addSpringTorqueCalcUp(ref target_fighter_.rigidbody_.transform_.position_,
2f /* torque_level */);
rigidbody_.addSpringTorqueCalcUp(ref CV.Vector3Zero,
0.1f /* torque_level */);
rigidbody_.addRelativeForceZ(250f);
var roti = rigidbody_.transform_.getInverseRotation();
var rvec = roti * rigidbody_.r_velocity_;
rigidbody_.addRelativeTorqueZ(rvec.y * 2f);
if (MyRandom.Probability(3.5f / 6f, dt))
{
var offset = new Vector3(0f, -0.3f, 0f);
var lpos = rigidbody_.transform_.transformPosition(ref offset);
var num = MyRandom.Range(6, 8);
for (var i = 0; i < num; ++i)
{
MissileManager.Instance.spawn(ref lpos,
ref rigidbody_.transform_.rotation_,
target_fighter_.target_id_, update_time);
}
Spark.Instance.spawn(ref lpos, Spark.Type.Bullet, update_time);
}
if (MyRandom.Probability(0.2f, dt))
{
rigidbody_.addRelativeTorqueX(MyRandom.Probability(0.5f) ? 20f : -20f);
}
}
}
public void init()
{
normal_list_ = new Vector3[LIGHTBALL_MAX];
for (var i = 0; i < normal_list_.Length; ++i)
{
float x = MyRandom.Range(-1f, 1f);
float y = MyRandom.Range(-1f, 1f);
float z = MyRandom.Range(0.75f, 1f);
float len2 = x * x + y * y + z * z;
float rlen = 1.0f / Mathf.Sqrt(len2);
normal_list_[i].x = x * rlen;
normal_list_[i].y = y * rlen;
normal_list_[i].z = z * rlen;
}
phase_list_ = new float[LIGHTBALL_MAX];
for (var i = 0; i < phase_list_.Length; ++i)
{
phase_list_[i] = MyRandom.Range(0f, 1f);
}
beam_id_ = Beam.Instance.spawn(0.8f /* width */, Beam.Type.LightBall);
beam_id_list_ = new int[LIGHTBALL_MAX];
for (var i = 0; i < beam_id_list_.Length; ++i)
{
beam_id_list_[i] = Beam.Instance.spawn(0.1f /* width */, Beam.Type.LightBall);
}
}
public override void update(float dt, double update_time)
{
bool refresh_target = false;
if (current_target_ == null)
{
refresh_target = true;
}
else
{
var probability = current_target_.getHitElapsed(update_time) < 1f ? 1f : 0.01f;
if (MyRandom.Probability(probability, dt))
{
refresh_target = true;
}
}
if (refresh_target)
{
Fighter closest_fighter = Fighter.searchClosest(ref rigidbody_.transform_.position_, current_target_);
if (closest_fighter != null)
{
current_target_ = closest_fighter;
}
}
if (current_target_ != null)
{
switch (phase_)
{
case 0:
{
var target = current_target_.rigidbody_.transform_.transformPositionZ(16f);
rigidbody_.addSpringForce(ref target, 4f /* spring ratio */);
if (time_ < update_time)
{
phase_ = 1;
time_ = (float)update_time + MyRandom.Range(5f, 28f);
}
}
break;
case 1:
{
var target = current_target_.rigidbody_.transform_.transformPositionZ(-2f);
rigidbody_.addSpringForce(ref target, 2f /* spring ratio */);
if (time_ < update_time)
{
phase_ = 0;
time_ = (float)update_time + MyRandom.Range(5f, 28f);
}
}
break;
}
rigidbody_.addSpringTorqueCalcUp(ref current_target_.rigidbody_.transform_.position_, 40f /* torque_level */);
rigidbody_.update(dt);
}
}
private void dragon_update(float dt)
{
if (MyCollider.getHitOpponentForEnemy(collider_) != MyCollider.Type.None)
{
float p = 100f;
rigidbody_.addTorque(MyRandom.Range(-p, p),
MyRandom.Range(-p, p),
MyRandom.Range(-p, p));
life_ -= 20f;
}
if (life_ <= 0f && phase_ == Phase.Alive)
{
MyCollider.disableForEnemy(collider_);
phase_ = Phase.Dying;
}
rigidbody_.update(dt);
MyCollider.updateEnemy(collider_, ref rigidbody_.transform_.position_);
MyCollider.updateEnemyHoming(collider_homing_, ref rigidbody_.transform_.position_);
// var head_transform = rigidbody_.transform_.add(ref HEAD_OFFSET);
dragon_.update(dt, update_time_, ref rigidbody_);
if (MyRandom.Probability(0.01f))
{
var head_pos = new Vector3(0f, 0f, 2f);
var pos = rigidbody_.transform_.transformPosition(ref head_pos);
if (pos.y > 0f)
{
EnemyLaser.create(ref pos, ref rigidbody_.transform_.rotation_, 40f /* speed */, update_time_);
SystemManager.Instance.registSound(DrawBuffer.SE.Laser);
}
}
if (MyRandom.Probability(0.1f))
{
var pos = rigidbody_.transform_.position_;
pos.x += MyRandom.Range(-1f, 1f);
pos.z += MyRandom.Range(-1f, 1f);
WaterSplash.Instance.spawn(ref pos,
ref CV.Vector3Zero, update_time_ - 0.2f);
}
if (-1f < rigidbody_.transform_.position_.y && rigidbody_.transform_.position_.y < 1f)
{
WaterSurface.Instance.makeBump(ref rigidbody_.transform_.position_, -0.1f /* value */, 1f /* size */);
if (MyRandom.Probability(0.1f))
{
var wpos = rigidbody_.transform_.position_;
wpos.y = -2f;
var vel = new Vector3(0f, MyRandom.Range(5f, 8f), 0f);
WaterSplash.Instance.spawn(ref wpos, ref vel, update_time_);
}
}
}
public void update(double update_time)
{
for (var i = 0; i < WATERSPLASH_MAX; ++i)
{
if (alive_table_[i] != 0)
{
if (update_time - uv2_list_[i].x > MyRandom.Range(0.9f, 1.5f))
{
destroy(i);
}
}
}
}
private IEnumerator act()
{
for (;;)
{
yield return(null);
var pos = new Vector3(MyRandom.Range(-15f, 15f), MyRandom.Range(-15f, 15f), -10f);
Enemy.create(ref pos, ref CV.QuaternionIdentity, Enemy.Type.Zako);
// for (var i = Utility.WaitForSeconds(0.20f, update_time_); i.MoveNext();) { yield return null; }
for (var i = new Utility.WaitForSeconds(0.2f, update_time_); !i.end(update_time_);)
{
yield return(null);
}
}
}
public void spawn(ref Vector3 pos, double update_time)
{
int id = spawn_index_;
++spawn_index_;
if (spawn_index_ >= EXPLOSION_MAX)
{
spawn_index_ = 0;
}
positions_[id] = pos;
var rot = MyRandom.Range(0, Mathf.PI * 2f);
uv2_list_[id] = new Vector2((float)update_time, rot);
}
public IEnumerator zako2_act()
{
rigidbody_.setDamper(2f);
rigidbody_.setRotateDamper(20f);
target_position_.x = MyRandom.Range(-5f, 5f);
target_position_.y = MyRandom.Range(-5f, 5f);
yield return(null);
for (var i = new Utility.WaitForSeconds(2.2f, update_time_); !i.end(update_time_);)
{
rigidbody_.addForceZ(-160f);
rigidbody_.addSpringForceXY(target_position_.x, target_position_.y, 2f);
yield return(null);
}
var sec = MyRandom.Range(3f, 5f);
var fired_time = update_time_;
var move_force = new Vector3(-target_position_.x, -target_position_.y, 0f);
move_force.Normalize();
move_force = Quaternion.Euler(0f, 0f, MyRandom.Range(-45f, 45f)) * move_force * 4f;
for (var i = new Utility.WaitForSeconds(sec, update_time_); !i.end(update_time_);)
{
rigidbody_.addTargetTorque(ref Player.Instance.rigidbody_.transform_.position_,
100f);
rigidbody_.addForce(ref move_force);
var target = Player.Instance.rigidbody_.transform_.position_;
if (update_time_ - fired_time > 0.4f)
{
EnemyBullet.create(ref rigidbody_.transform_.position_,
ref target,
50f /* speed */,
update_time_);
fired_time = update_time_;
}
yield return(null);
}
for (var i = new Utility.WaitForSeconds(4f, update_time_); !i.end(update_time_);)
{
rigidbody_.addOrientTorque(ref CV.Vector3Back, 100f);
rigidbody_.addForceZ(-80f);
yield return(null);
}
destroy();
}
private IEnumerator act()
{
const float RANGE = 300f;
for (var i = 0; i < 100; ++i)
{
var position = new Vector3(MyRandom.Probability(0.5f) ? -RANGE : RANGE,
MyRandom.Range(-RANGE, RANGE),
MyRandom.Range(-RANGE, RANGE));
var rotation = Quaternion.LookRotation(MyRandom.onSphere(1f));
Fighter.create(Fighter.Type.Alpha, ref position, ref rotation, update_time_);
}
for (;;)
{
yield return(null);
}
}
public override void update(float dt, float update_time)
{
update_time_ = update_time;
if (enumerator_ != null)
{
enumerator_.MoveNext();
}
if (alive_)
{
if (MyCollider.getHitOpponentForEnemy(collider_) != MyCollider.Type.None)
{
rigidbody_.addTorque(MyRandom.Range(-100f, 100f),
MyRandom.Range(-100f, 100f),
MyRandom.Range(-100f, 100f));
rigidbody_.addForceZ(-10000f);
Explosion.Instance.spawn(ref rigidbody_.transform_.position_, update_time);
Hahen.Instance.spawn(ref rigidbody_.transform_.position_, update_time);
SystemManager.Instance.registSound(DrawBuffer.SE.Explosion);
MyCollider.disableForEnemy(collider_);
lock_target_.disable();
phase_ = Phase.Dying;
}
if (lock_target_.isHitted())
{
rigidbody_.addTorque(MyRandom.Range(-100f, 100f),
MyRandom.Range(-100f, 100f),
MyRandom.Range(-100f, 100f));
rigidbody_.addForceZ(-10000f);
lock_target_.clearLock();
Explosion.Instance.spawn(ref lock_target_.updated_position_, update_time);
Hahen.Instance.spawn(ref lock_target_.updated_position_, update_time);
SystemManager.Instance.registSound(DrawBuffer.SE.Explosion);
MyCollider.disableForEnemy(collider_);
lock_target_.disable();
phase_ = Phase.Dying;
}
rigidbody_.update(dt);
MyCollider.updateEnemy(collider_, ref rigidbody_.transform_.position_);
lock_target_.update();
}
}
public void spawn(ref Vector3 pos, double update_time)
{
int id = spawn_index_;
++spawn_index_;
if (spawn_index_ >= EXPLOSION_MAX)
{
spawn_index_ = 0;
}
if (positions_ == null)
{
Debug.LogWarning("null???");
return;
}
positions_[id] = pos;
var rot = MyRandom.Range(0, Mathf.PI * 2f);
uv2_list_[id] = new Vector2((float)update_time, rot);
}
public IEnumerator zako_act()
{
rigidbody_.setDamper(2f);
rigidbody_.setRotateDamper(2f);
target_position_.x = MyRandom.Range(-20f, 20);
target_position_.y = MyRandom.Range(-20f, 20);
rigidbody_.addForceZ(40f);
yield return(null);
// for (var i = Utility.WaitForSeconds(10f, update_time_); i.MoveNext();) {
for (var i = new Utility.WaitForSeconds(10f, update_time_); !i.end(update_time_);)
{
rigidbody_.addForceX(target_position_.x - rigidbody_.transform_.position_.x * 2f);
rigidbody_.addForceY(target_position_.y - rigidbody_.transform_.position_.y * 2f);
rigidbody_.addForceZ(10f);
rigidbody_.addTorqueZ(-rigidbody_.velocity_.x * 1f);
if (MyRandom.ProbabilityForSecond(1.5f, SystemManager.Instance.getDT()))
{
var pos = Player.Instance.rigidbody_.transform_.position_;
pos.z += MyRandom.Range(-10f, 10f);
EnemyBullet.create(ref rigidbody_.transform_.position_,
ref pos,
50f /* speed */,
update_time_);
}
if (phase_ == Phase.Dying)
{
// for (var j = Utility.WaitForSeconds(0.1f, update_time_); j.MoveNext();) {
for (var j = new Utility.WaitForSeconds(0.1f, update_time_); j.end(update_time_);)
{
yield return(null);
}
break;
}
yield return(null);
}
destroy();
}
private IEnumerator act()
{
// SystemManager.Instance.registBgm(DrawBuffer.BGM.Battle);
{
var position = new Vector3(0f, -10f, 0f);
var rotation = Quaternion.Euler(-90f, 0f, 0f);
Enemy.create(Enemy.Type.Dragon, ref position, ref rotation);
}
for (;;)
{
{
var position = new Vector3(MyRandom.Range(-10f, 10f), -10f, MyRandom.Range(-10f, 10f));
var rotation = Quaternion.Euler(-90f, 0f, 0f);
Enemy.create(Enemy.Type.Zako, ref position, ref rotation);
}
for (var i = new Utility.WaitForSeconds(MyRandom.Range(1f, 3f), update_time_); !i.end(update_time_);)
{
yield return(null);
}
yield return(null);
}
}
public override void update(float dt, double update_time)
{
if (MyCollider.getHitOpponentForEnemyBullet(collider_) != MyCollider.Type.None)
{
Spark.Instance.spawn(ref rigidbody_.transform_.position_, Spark.Type.EnemyBullet, update_time);
destroy();
return;
}
if (rigidbody_.transform_.position_.y < -16f)
{
destroy();
var pos = new Vector3(rigidbody_.transform_.position_.x, -0.5f,
rigidbody_.transform_.position_.z);
for (var i = 0; i < 4; ++i)
{
var spread = 2f;
var vel = new Vector3(Mathf.Cos(i * Mathf.PI * (2f / 8f)) * spread,
MyRandom.Range(3f, 7f),
Mathf.Sin(i * Mathf.PI * (2f / 8f)) * spread);
WaterSplash.Instance.spawn(ref pos, ref vel, update_time);
}
return;
}
rigidbody_.update(dt);
MyCollider.updateEnemyBullet(collider_, ref rigidbody_.transform_.position_);
var diff = Player.Instance.rigidbody_.transform_.position_ - rigidbody_.transform_.position_;
if (diff.sqrMagnitude < (50f * 50f))
{
WaterSurface.Instance.makeBump(ref rigidbody_.transform_.position_, -1f /* value */, 1f /* size */);
}
if (update_time - start_ > 4f) // 寿命
{
destroy();
return;
}
}
public static Enemy create(Type type)
{
Enemy enemy = Enemy.create();
// enemy.type_ = type;
enemy.phase_ = Phase.Alive;
enemy.init();
switch (type)
{
case Type.None:
Debug.Assert(false);
break;
case Type.Zako:
{
var position = new Vector3(MyRandom.Range(-15f, 15f), MyRandom.Range(-6f, 6f), -100f);
enemy.zako_init(ref position, ref CV.QuaternionIdentity);
}
break;
case Type.Zako2:
{
var position = new Vector3(MyRandom.Range(-6f, 6f),
MyRandom.Range(-6f, 6f),
MyRandom.Range(194, 198f));
enemy.zako2_init(ref position, ref CV.Quaternion180Y);
}
break;
case Type.Dragon:
{
enemy.dragon_init();
}
break;
}
return(enemy);
}
IEnumerator loop()
{
ready_ = true;
GetComponent <MeshRenderer>().sharedMaterial = material_;
var range = 2.5f;
for (;;)
{
Shield.Instance.begin();
var pos = new Vector3(Random.Range(-range, range),
Random.Range(-range, range),
Random.Range(-range, range));
var target = new Vector3(0, 0, 0);
Shield.Instance.spawn(ref pos,
ref target,
Time.time,
(MyRandom.Range(0f, 1f) < 0.5f ?
Shield.Type.Green :
Shield.Type.Red));
Shield.Instance.end(0 /* front */);
yield return(null);
}
}
public override void update(float dt, float update_time)
{
update_time_ = update_time;
if (MyCollider.getHitOpponentForPlayer(collider_) != MyCollider.Type.None)
{
var pos = new Vector3(MyRandom.Range(-2f, 2f),
MyRandom.Range(-2f, 2f),
MyRandom.Range(-2f, 2f));
HUD.Instance.setDamagePoint(ref pos);
}
if (Options.Instance.AutoPlay)
{
enumerator_.MoveNext();
}
int hori = getButton(InputManager.Button.Horizontal);
int vert = getButton(InputManager.Button.Vertical);
bool fire_button = getButton(InputManager.Button.Fire) > 0;
int lr = getButton(InputManager.Button.Roll);
roll_target_ += (float)(lr) * 150f * dt;
roll_ = Mathf.Lerp(roll_, roll_target_, 0.1f);
const float MOVE_FORCE = 1f;
const float CURSOR_FORCE = 6f;
float sn = Mathf.Sin(roll_ * Mathf.Deg2Rad);
float cs = Mathf.Cos(roll_ * Mathf.Deg2Rad);
float vx = hori * cs - vert * sn;
float vy = hori * sn + vert * cs;
rigidbody_.addForceXY(vx * MOVE_FORCE, vy * MOVE_FORCE);
target_cursor_.addForceXY(vx * CURSOR_FORCE, vy * CURSOR_FORCE);
if (hori < 0)
{
pitch_acceleration_ += 2000f;
}
else if (hori > 0)
{
pitch_acceleration_ += -2000f;
}
// cursor update
{
// 外に向けさせない
float x = rigidbody_.transform_.position_.x + target_cursor_.transform_.position_.x;
float y = rigidbody_.transform_.position_.y + target_cursor_.transform_.position_.y;
float len2 = x * x + y * y;
float R = 64f;
if (len2 > Tube.RADIUS_SQR)
{
R = 256f;
}
target_cursor_.addForceX(-target_cursor_.transform_.position_.x * R);
target_cursor_.addForceY(-target_cursor_.transform_.position_.y * R);
target_cursor_.update(dt);
}
// pitch
pitch_acceleration_ += -pitch_ * 8f; // spring
pitch_acceleration_ += -pitch_velocity_ * 4f; // friction
pitch_velocity_ += pitch_acceleration_ * dt;
pitch_ += pitch_velocity_ * dt;
pitch_acceleration_ = 0f;
// rotate
rigidbody_.transform_.rotation_ = Quaternion.LookRotation(target_cursor_.transform_.position_) * Quaternion.Euler(0, 0, pitch_);
// update
rigidbody_.update(dt);
float radius = Tube.RADIUS - PLAYER_WIDTH2;
if (rigidbody_.transform_.position_.sqrMagnitude >= radius * radius)
{
hit_wall_ = true;
rigidbody_.cancelUpdateForTube(dt);
if (MyRandom.ProbabilityForSecond(60f, SystemManager.Instance.getDT()))
{
float x = rigidbody_.transform_.position_.x;
float y = rigidbody_.transform_.position_.y;
float z = rigidbody_.transform_.position_.z;
float len = Mathf.Sqrt(x * x + y * y);
float rlen = 1f / len;
float r = rlen * Tube.RADIUS;
var v = new Vector3(x * r, y * r, z);
Spark.Instance.spawn(ref v, Spark.Type.Orange, update_time);
}
}
else
{
hit_wall_ = false;
}
// collider
MyCollider.updatePlayer(collider_, ref rigidbody_.transform_.position_);
// fire bullets
if (fire_button && update_time - fire_time_ > 0.06667f)
{
var lpos = rigidbody_.transform_.transformPosition(ref l_bullet_locator_);
Bullet.create(ref lpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
var rpos = rigidbody_.transform_.transformPosition(ref r_bullet_locator_);
Bullet.create(ref rpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
SystemManager.Instance.registSound(DrawBuffer.SE.Bullet);
fire_time_ = update_time;
}
// fire missiles
if (fire_button && !prev_fire_button_) // tmp
{
bool fired = LockTarget.fireMissiles(this);
if (fired)
{
SystemManager.Instance.registSound(DrawBuffer.SE.Missile);
}
}
prev_fire_button_ = fire_button;
// trail
{
float flow_z = -30f * dt;
var lpos = rigidbody_.transform_.transformPosition(ref l_trail_locator_);
Trail.Instance.update(l_trail_, ref lpos, flow_z, update_time);
var rpos = rigidbody_.transform_.transformPosition(ref r_trail_locator_);
Trail.Instance.update(r_trail_, ref rpos, flow_z, update_time);
}
}
public void end(int front, CameraBase camera)
{
const float SIZE = 16f;
float size = SIZE;
switch (phase_)
{
case 0:
cnt_ = MyRandom.Range(300, 400);
cnt1_ = 0;
++phase_;
break;
case 1:
--cnt_;
if (cnt_ < 0)
{
cnt_ = 16;
size = 0f;
++phase_;
}
break;
case 2:
size = (float)(16 - cnt_) / 16f * SIZE;
--cnt_;
if (cnt_ < 0)
{
cnt_ = 12;
++phase_;
}
break;
case 3:
--cnt_;
if (cnt_ < 0)
{
cnt_ = 4;
++phase_;
}
break;
case 4:
--cnt_;
if (cnt_ < 0)
{
cnt_ = 12;
++cnt1_;
if (cnt1_ > 8)
{
phase_ = 0;
}
else
{
--phase_;
}
}
break;
}
if (phase_ != 2 && phase_ != 3)
{
return;
}
for (var i = 0; i < regist_index_; ++i)
{
var spos = (camera != null ?
camera.getScreenPoint(ref positions_[i]) :
positions_[i]);
float size0 = spos.z > 1f ? size : 0f;
vertices_[front][i * 6 + 0].x = spos.x + size0;
vertices_[front][i * 6 + 0].y = spos.y;
vertices_[front][i * 6 + 1].x = spos.x;
vertices_[front][i * 6 + 1].y = spos.y + size0;
vertices_[front][i * 6 + 2].x = spos.x - size0;
vertices_[front][i * 6 + 2].y = spos.y;
vertices_[front][i * 6 + 3].x = spos.x;
vertices_[front][i * 6 + 3].y = spos.y - size0;
vertices_[front][i * 6 + 4].x = spos.x + size0 * 2f;
vertices_[front][i * 6 + 4].y = spos.y - size0 * 3f;
vertices_[front][i * 6 + 5].x = spos.x + size0 * 4f;
vertices_[front][i * 6 + 5].y = spos.y - size0 * 3f;
}
}
private IEnumerator fetch_auto()
{
for (;;)
{
for (var w = new Utility.WaitForSeconds(MyRandom.Range(2f, 4f), update_time_);
!w.end(update_time_);)
{
if (latest_.horizontal_ < 0f)
{
for (var w0 = new Utility.WaitForSeconds(MyRandom.Range(0.1f, 1f), update_time_);
!w0.end(update_time_);)
{
latest_.left_button_ = true;
yield return(null);
}
}
else
{
for (var w0 = new Utility.WaitForSeconds(MyRandom.Range(0.1f, 1f), update_time_);
!w0.end(update_time_);)
{
latest_.right_button_ = true;
yield return(null);
}
}
for (var w0 = new Utility.WaitForSeconds(MyRandom.Range(0.1f, 0.6f), update_time_);
!w0.end(update_time_);)
{
yield return(null);
}
yield return(null);
}
if (MyRandom.Probability(0.5f))
{
for (var w = new Utility.WaitForSeconds(MyRandom.Range(0.8f, 1.2f), update_time_);
!w.end(update_time_);)
{
latest_.jump_button_ = true;
yield return(null);
}
}
if (MyRandom.Probability(0.1f))
{
for (var w = new Utility.WaitForSeconds(MyRandom.Range(3f, 4f), update_time_);
!w.end(update_time_);)
{
for (var w0 = new Utility.WaitForSeconds(MyRandom.Range(0.2f, 0.4f), update_time_);
!w0.end(update_time_);)
{
latest_.left_button_ = true;
yield return(null);
}
for (var w0 = new Utility.WaitForSeconds(MyRandom.Range(0.2f, 0.4f), update_time_);
!w0.end(update_time_);)
{
latest_.right_button_ = true;
yield return(null);
}
yield return(null);
}
}
for (var w = new Utility.WaitForSeconds(MyRandom.Range(0.2f, 0.8f), update_time_);
!w.end(update_time_);)
{
yield return(null);
}
yield return(null);
}
}
public override void update(float dt, double update_time)
{
var controller = Controller.Instance.getLatest();
muscle_motion_.setTarget(posture_apose_);
if (controller.isLeftButtonUp())
{
throwing_cnt_l_ = (int)(0.5f / dt);
}
if (controller.isRightButtonUp())
{
throwing_cnt_r_ = (int)(0.5f / dt);
}
if (throwing_cnt_l_ > 0)
{
muscle_motion_.setTarget(posture_throw_l_arm_);
// muscle_motion_.addTorqueY(MuscleMotion.Parts.Ribs2, 8000f);
// muscle_motion_.addTorqueY(MuscleMotion.Parts.Hip, 8000f);
// muscle_motion_.addTorqueX(MuscleMotion.Parts.L_Thigh, 8000f);
// muscle_motion_.addTorqueX(MuscleMotion.Parts.L_Knee, 8000f);
if (throwing_cnt_l_ < (int)(0.45f / dt))
{
fire_left(update_time);
}
--throwing_cnt_l_;
}
if (throwing_cnt_r_ > 0)
{
muscle_motion_.setTarget(posture_throw_r_arm_);
// muscle_motion_.addTorqueY(MuscleMotion.Parts.Ribs2, -8000f);
// muscle_motion_.addTorqueY(MuscleMotion.Parts.Hip, -8000f);
// muscle_motion_.addTorqueX(MuscleMotion.Parts.R_Thigh, 8000f);
// muscle_motion_.addTorqueX(MuscleMotion.Parts.R_Knee, 8000f);
if (throwing_cnt_r_ < (int)(0.45f / dt))
{
fire_right(update_time);
}
--throwing_cnt_r_;
}
if (controller.isLeftButtonDown())
{
MuscleMotion.Node node = muscle_motion_.getNode(MuscleMotion.Parts.L_Wrist);
fire_left(update_time);
left_held_bullet_ = Bullet.create(ref node.rigidbody_.transform_.position_,
ref CV.QuaternionIdentity);
}
if (controller.isRightButtonDown())
{
MuscleMotion.Node node = muscle_motion_.getNode(MuscleMotion.Parts.R_Wrist);
fire_right(update_time);
right_held_bullet_ = Bullet.create(ref node.rigidbody_.transform_.position_,
ref CV.QuaternionIdentity);
}
if (controller.isLeftButton())
{
throwing_cnt_l_ = 0;
throwing_cnt_r_ -= (int)(0.25f / dt);
muscle_motion_.setTarget(posture_pre_throw_l_arm_);
bullet_tame_left_ += dt;
}
if (controller.isRightButton())
{
throwing_cnt_l_ -= (int)(0.25f / dt);
throwing_cnt_r_ = 0;
muscle_motion_.setTarget(posture_pre_throw_r_arm_);
bullet_tame_right_ += dt;
}
if (left_held_bullet_ != null)
{
MuscleMotion.Node node = muscle_motion_.getNode(MuscleMotion.Parts.L_Wrist);
left_held_bullet_.setPosition(ref node.rigidbody_.transform_.position_);
left_held_bullet_.setPower(Mathf.Clamp(bullet_tame_left_, 0.25f, 2f));
}
if (right_held_bullet_ != null)
{
MuscleMotion.Node node = muscle_motion_.getNode(MuscleMotion.Parts.R_Wrist);
right_held_bullet_.setPosition(ref node.rigidbody_.transform_.position_);
right_held_bullet_.setPower(Mathf.Clamp(bullet_tame_right_, 0.25f, 2f));
}
if (controller.isJumpButton() && on_ground_)
{
muscle_motion_.getRootNode().rigidbody_.addRelativeTorqueX(1000f);
muscle_motion_.setTarget(posture_pre_jump_,
MuscleMotion.PartsBit.LowerBody |
MuscleMotion.PartsBit.Ribs |
MuscleMotion.PartsBit.Ribs2 |
MuscleMotion.PartsBit.Ribs3);
jump_tame_duration_ += dt;
}
if (controller.isJumpButtonUp())
{
if (jump_tame_duration_ > 0.5f)
{
jump_propel_remain_ = Mathf.Min((jump_tame_duration_ - 0.5f) + 0.5f, 1f) * 2f;
rigidbody_.addForceY(1000f);
WaterSurface.Instance.makeBump(ref rigidbody_.transform_.position_,
-1f /* value */, 1f /* size */);
on_ground_time_ = 0f;
somersault_ = MyRandom.Probability(0.25f);
}
jump_tame_duration_ = 0f;
}
float hori = controller.getHorizontal();
float ground_height = 1.25f;
if (hori != 0f)
{
ground_height = 1f;
}
if (jump_propel_remain_ > 0f)
{
rigidbody_.addForceY(100f);
jump_propel_remain_ -= dt;
}
on_ground_ = (rigidbody_.transform_.position_.y <= 1f);
rigidbody_.addTargetTorque(ref look_at_, 500f /* torque_level */, -1f /* max_level */);
rigidbody_.addRelativeForceX(hori * 64f);
if (hori != 0f)
{
rigidbody_.addRelativeForceZ(10f);
}
rigidbody_.addForceY(-9.8f * 5f); // gravity
if (rigidbody_.transform_.position_.y < ground_height)
{
rigidbody_.addSpringForceY(ground_height, 100f);
}
rigidbody_.solveForGround(0.0f /* ground_height */, dt);
rigidbody_.addRelativeTorqueZ(-hori * 100f);
{
var forward = rigidbody_.transform_.rotation_ * CV.Vector3Forward;
var q = Quaternion.LookRotation(forward);
rigidbody_.addSpringTorque(ref q, 10000f);
}
rigidbody_.update(dt);
if (rigidbody_.transform_.position_.y < 5f)
{
WaterSurface.Instance.makeBump(ref rigidbody_.transform_.position_, -0.05f /* value */, 0.6f /* size */);
var pos = rigidbody_.transform_.position_;
pos.y = -2f;
float vel_y;
if (hori != 0f)
{
vel_y = MyRandom.Range(7f, 9f);
}
else
{
vel_y = MyRandom.Range(5f, 7f);
}
var vel = new Vector3(0f,
vel_y,
0f);
if (MyRandom.Probability(0.2f))
{
WaterSplash.Instance.spawn(ref pos, ref vel, update_time);
}
}
var root_node = muscle_motion_.getRootNode();
root_node.rigidbody_.transform_.position_ =
rigidbody_.transform_.position_ + new Vector3((Mathf.PerlinNoise((float)update_time * 4f, 0.0f) - 0.5f) * 0.04f,
(Mathf.PerlinNoise((float)update_time * 4f, 0.5f) - 0.5f) * 0.04f,
(Mathf.PerlinNoise((float)update_time * 4f, 1.0f) - 0.5f) * 0.04f);
if (somersault_ && on_ground_time_ < 0.25f)
{
root_node.rigidbody_.addRelativeTorqueX(-3000f);
muscle_motion_.getNode(MuscleMotion.Parts.Ribs).rigidbody_.addRelativeTorqueX(-3000f);
muscle_motion_.getNode(MuscleMotion.Parts.Ribs2).rigidbody_.addRelativeTorqueX(-3000f);
muscle_motion_.getNode(MuscleMotion.Parts.Ribs3).rigidbody_.addRelativeTorqueX(-3000f);
muscle_motion_.getNode(MuscleMotion.Parts.Hip).rigidbody_.addRelativeTorqueX(-3000f);
}
else
{
root_node.rigidbody_.addTorqueY(hori * 1000f);
root_node.rigidbody_.addRelativeTorqueZ(-hori * 1000f);
root_node.rigidbody_.addSpringTorque(ref rigidbody_.transform_.rotation_, 4000f);
}
muscle_motion_.addTorqueX(MuscleMotion.Parts.L_Tale1, MyRandom.Range(500f, 1200f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.L_Tale4, MyRandom.Range(-4000f, 4000f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.R_Tale1, MyRandom.Range(500f, 1200f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.R_Tale4, MyRandom.Range(-4000f, 4000f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.L_SusoBack, MyRandom.Range(300f, 600f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.L_SusoFront, MyRandom.Range(-600f, -300f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.R_SusoBack, MyRandom.Range(300f, 600f));
muscle_motion_.addTorqueX(MuscleMotion.Parts.R_SusoFront, MyRandom.Range(-600f, -300f));
Vector3 e_pos;
if (jump_tame_duration_ > 0.75f || on_ground_time_ < 1f)
{
var node = muscle_motion_.getNode(MuscleMotion.Parts.Head);
node.rigidbody_.addRelativeTorqueX(-4000f);
}
else if (MyCollider.getNearestEnemyPosition(out e_pos))
{
muscle_motion_.getNode(MuscleMotion.Parts.Head).rigidbody_.addSpringTorque(ref e_pos, 4000f);
}
{
var intersect_point = CV.Vector3Zero;
if (MyCollider.getHitOpponentForPlayer(collider_, ref intersect_point) == MyCollider.Type.EnemyBullet)
{
var node = muscle_motion_.getNode(MuscleMotion.Parts.Ribs3);
var torque = MyRandom.onSphere(1f) * 5000f;
node.rigidbody_.addTorque(ref torque);
Shield.Instance.spawn(ref intersect_point,
ref rigidbody_.transform_.position_,
update_time,
Shield.Type.Green);
SystemManager.Instance.registSound(DrawBuffer.SE.Shield);
// hit_time_ = (float)update_time;
// hit_position_ = intersect_point;
}
MyCollider.updatePlayer(collider_, ref rigidbody_.transform_.position_);
}
muscle_motion_.update(dt);
on_ground_time_ += dt;
}
private IEnumerator unitychan_act()
{
float wait_sec;
for (;;)
{
wait_sec = MyRandom.Range(5f, 15f);
for (var i = new Utility.WaitForSeconds(wait_sec, update_time_); !i.end(update_time_);)
{
yield return(null);
}
unitychan_height_ratio_ = 4f / 128f;
for (unitychan_width_ratio_ = 0f;
unitychan_width_ratio_ < 1f;
unitychan_width_ratio_ += 8f * current_dt_)
{
yield return(null);
}
unitychan_width_ratio_ = 1f;
for (;
unitychan_height_ratio_ < 1f;
unitychan_height_ratio_ += 8f * current_dt_)
{
yield return(null);
}
unitychan_height_ratio_ = 1f;
DrawBuffer.SE voice = DrawBuffer.SE.VoiceIkuyo;
switch (MyRandom.Range(0, 5))
{
case 0:
voice = DrawBuffer.SE.VoiceIkuyo;
unitychan_kind_ = MySprite.Kind.UnityChanLaugh;
break;
case 1:
voice = DrawBuffer.SE.VoiceUwaa;
unitychan_kind_ = MySprite.Kind.UnityChanOuch;
break;
case 2:
voice = DrawBuffer.SE.VoiceSorosoro;
unitychan_kind_ = MySprite.Kind.UnityChanLaugh;
break;
case 3:
voice = DrawBuffer.SE.VoiceOtoto;
unitychan_kind_ = MySprite.Kind.UnityChanGrin;
break;
case 4:
voice = DrawBuffer.SE.VoiceYoshi;
unitychan_kind_ = MySprite.Kind.UnityChanGrin;
break;
}
SystemManager.Instance.registSound(voice);
wait_sec = MyRandom.Range(2f, 3f);
for (var i = new Utility.WaitForSeconds(wait_sec, update_time_); !i.end(update_time_);)
{
yield return(null);
}
for (;
unitychan_height_ratio_ > 4f / 128f;
unitychan_height_ratio_ -= 8f * current_dt_)
{
yield return(null);
}
unitychan_height_ratio_ = 4f / 128f;
for (;
unitychan_width_ratio_ > 0f;
unitychan_width_ratio_ -= 8f * current_dt_)
{
yield return(null);
}
unitychan_width_ratio_ = 0f;
}
}
