public static void LoadRaidMapScene(WorldMapHexagonTileData tileData, Ship ship)
    {
        SelectedTileData = tileData;
        SelectedShip = ship;

        Application.LoadLevel("RaidMap");
    }

		internal void Update(Ship[] s)
		{
			this.ships = s;

			if (this.ships.Length == 0)
			{
				this.RejuvenateTime = null;
				return;
			}

			var condition = this.ships.Min(x => x.Condition);
			if (condition != this.minCondition)
			{
				this.minCondition = condition;

				var rejuvnate = DateTimeOffset.Now; // 回復完了予測時刻

				while (condition < KanColleClient.Current.Settings.ReSortieCondition)
				{
					rejuvnate = rejuvnate.AddMinutes(3);
					condition += 3;
					if (condition > 49) condition = 49;
				}

				this.RejuvenateTime = rejuvnate <= DateTimeOffset.Now
					? (DateTimeOffset?)null
					: rejuvnate;
			}
		}

	// Use this for initialization
	void Start () {
		currentTimeTilChangePosition = 0;

		if(ship == null) {
			ship = gameObject.GetComponent<Ship>();
		}
	}

	// Use this for initialization
	void Start ()
	{
		ship = GetComponent<Ship> ();

		currentCooldown = cooldownTime;
	
	}

 public void TestAllStop0Radians()
 {
     var ship = new Ship(4000);
     Assert.AreEqual(0, ship.Velocity.Magnitude(), "new ship wasn't stopped");
     Assert.AreEqual(0, ship.Orientation, "ship wasn't oriented 0");
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.ImpulsePercentage = 100;
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     Assert.AreEqual(0, ship.Orientation, "ship turned during acceleration");
     ship.TargetSpeedMetersPerSecond = 0;
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     ship.Update(TimeSpan.FromSeconds(0.25));
     Assert.AreNotEqual(Vector3.Zero, ship.Velocity, "Ship couldn't have been stopped by now.");
     Assert.IsTrue(Utility.ApproximatelyEqual(0, ship.Orientation), "ship turned during all stop");
     ship.Update(TimeSpan.FromSeconds(0.25));
     Assert.AreEqual(Vector3.Zero, ship.Velocity, "velocity wasn't stopped long after all stop message sent");
 }

 // Use this for initialization
 void Start ()
 {
     m_Ship = GetComponent<Ship>();
     m_IsDashReady = true;
     m_StickDelay = 0.5f;
     m_DashCoolDown = 7;
 }

 public void UpdateBehaviour(Ship owner)
 {
     if (behaviour)
     {
         behaviour.UpdateForOwner(owner);
     }
 }

 protected override bool Equals(Ship other)
 {
     //doesn't check direction
     return ShipPosition.X == other.ShipPosition.X &&
         ShipPosition.Y == other.ShipPosition.Y &&
         Length == other.Length;
 }

 public void Start()
 {
     if(null == ship) {
         ship = GameObject.Find("Ship").GetComponent<Ship>();
     }
     ExhaustTrail.transform.parent = gameObject.transform;
 }

    public override void Activate(Ship activator)
    {
        var moorable = activator.Moorable;
        Debug.Assert(moorable);

        moorable.BeginAutoDocking(this);
    }

 public WeaponAuto(Ship ship, double fireInterval)
     : base(ship)
 {
     this.FireInterval = fireInterval;
     this.timer = new Timer();
     this.timer.Fire += new NotifyHandler(timer_Fire);
 }

 // Use this for initialization
 public Regroup(Ship inShip)
 {
     ship = inShip;
     target = ship.fleetLeader.transform;
     if(ship.photonView.isMine)
         ship.photonView.RPC("RegroupRPC", PhotonTargets.Others, null);
 }

 public override List<string> ExecuteOrder(Ship ship)
 {
     List<string> result = new List<string>();
     result.Add(moveShip(ship));
     this.IsCompleted = true;
     return result;
 }

 public MoveToShipAtRange(Ship targetShip, int range, LocationCollection locations)
 {
     this.OrderValues = new object[3];
     this.OrderValues[0] = targetShip;
     this.OrderValues[1] = range;
     this.OrderValues[2] = locations;
 }

	public DamageMessage (float dmg, Vector3 dir, float dmgFrce, Weapon.DamageBias bs, Weapon.WeaponType tp, Ship own)
	{
		damage = dmg;
		damageDirection = dir;
		damageForce = dmgFrce;
		bias = bs;
		type = tp;
		
		if (own != null)
			owner = own.gameObject;
		else
			return;
		
		hasShip = true;
		try
		{
			viewID = own.GetComponent<PhotonView>().viewID;
		}
		catch
		{
			Debug.Log(owner.name  + " does not have a photon View ID");
		}
		
		if (own is AiShip)
			player = false;
		else
			player = true;
	}

        protected override void ApplyPowerup(Ship ship)
        {
            //new EffectNode(Config.LightningSpriteSheet, this.Position);
            PlayerShip applyShip;
            applyShip = ship.GetRoot() as PlayerShip;

            //for (int i = Enemy.Enemies.Count - 1; i >= 0; i--)
            //{
            //    ProjectileBulletGreenBeam.FireBullet(Vector2.Normalize(Enemy.Enemies[i].Position - applyShip.Position), applyShip.Position);
            //}
            //for (int i = Enemy.Enemies.Count - 1; i >= 0; i--)
            //{
            //    ProjectileBulletGreenBeam.FireBullet(Vector2.Normalize(Enemy.Enemies[i].Position - applyShip.Position), applyShip.Position);
            //}
            //for (int i = Enemy.Enemies.Count - 1; i >= 0; i--)
            //{
            //    ProjectileBulletGreenBeam.FireBullet(Vector2.Normalize(Enemy.Enemies[i].Position - applyShip.Position), applyShip.Position);
            //}
            //for (int i = Enemy.Enemies.Count - 1; i >= 0; i--)
            //{
            //    ProjectileBulletGreenBeam.FireBullet(Vector2.Normalize(Enemy.Enemies[i].Position - applyShip.Position), applyShip.Position);
            //}
            //for (int i = Enemy.Enemies.Count - 1; i >= 0; i--)
            //{
            //    ProjectileBulletGreenBeam.FireBullet(Vector2.Normalize(Enemy.Enemies[i].Position - applyShip.Position), applyShip.Position);
            //}

            //AoEWeaponBurstWave tempWeapon = new AoEWeaponBurstWave(applyShip, 0, 200, 50f);
            AoEWeaponBurstWave tempWeapon = new AoEWeaponBurstWave(applyShip, 0, 100, 50f);
            tempWeapon.StartFire();
        }

        protected override void ApplyPowerup(Ship ship)
        {
            PlayerShip applyShip;
            EnemyPlayerShip applyAIShip;

            if (ship == Player.Ship)
            {
                if (Config.SoundFXOn)
                    GameStateManagementGame.Instance.soundManager.PlaySound("FX1", 0.7f);  
 
                applyShip = ship.GetRoot() as PlayerShip;

                if (applyShip.Shield.Health < Config.ShieldHealth)
                {
                    if (Config.ship1Active)
                        applyShip.Shield.ShieldRegen(Config.ShieldsPowerupValue + 5);
                    else
                        applyShip.Shield.ShieldRegen(Config.ShieldsPowerupValue);
                }
            }

            if (ship == Player.EnemyPlayer)
            {
                applyAIShip = ship.GetRoot() as EnemyPlayerShip;

                if (applyAIShip.Shield.Health < Config.ShieldHealth)
                    applyAIShip.Shield.ShieldRegen(Config.ShieldsPowerupValue);
            }
        }

        public static void AddDrones(Ship ship)
        {
            const int DRONE_BANDWIDTH_ID = 1271;
            var bandwidth = ship.GetAttributeById(DRONE_BANDWIDTH_ID)
                .Value;

            if (bandwidth <= 25)
            {
                AddDrones(ship, _hobgoblin, (int) bandwidth / 5);
                return;
            }

            if (bandwidth <= 50)
            {
                AddDrones(ship, _hammerhead, (int) bandwidth / 10);
                AddDrones(ship, _hobgoblin, ((int) bandwidth / 10) / 5);
                return;
            }
            //TODO verteilunug fuer <= 100 sieht normalerweise anders aus
            AddDrones(ship, _ogre, (int) bandwidth / 25);

            var rest = (int) bandwidth % 25;
            AddDrones(ship, _hammerhead, rest / 10);

            var restMed = rest % 10;
            AddDrones(ship, _hobgoblin, restMed / 5);
        }

 public void Activate(Ship activator, int slot)
 {
     if (Cooldown <= Mathf.Epsilon) //cd check
     {
         behaviour.Activate(activator, slot);
     }
 }

 public override void NotifyDeath(Ship ship, Ship killer)
 {
     if (ship.name == "Ghost Ship")
     {
         failed = true;
     }
 }