STGを２００行以内で＠２８０行【改善策募集】

Siv3DでSTGを作ります。
目標は

>１．200行以内に収めること（Mainのみ）
２．http://play-siv3d.hateblo.jp/ と似た書き方
３．華やかであること
４．STGとして遊べること

です。
現状
>280行→長い
画面→地味
STG→死なない

改善策求む

```Siv3D:Main.cpp

# include <Siv3D.hpp>
//March2014

class Mover
{
public:

	Mover(
		const Vec2& pos, 
		const Vec2& velocity, 
		double radius
		) :
		m_pos(pos),
		m_velocity(velocity),
		m_radius(radius)
	{

	}

	virtual void update()
	{
		m_pos += m_velocity;

		if (!RectF(Window::Size()).intersects(Circle(m_pos, m_radius)))
		{
			m_isActive = false;
		}

		++m_count;
	}

	virtual void draw()
	{
		RectF(2.0 * Vec2(m_radius, m_radius)).setCenter(m_pos).draw();
	}

	void setPos(const Vec2& pos)
	{
		m_pos = pos;
	}

	const Vec2& getPos() const
	{
		return m_pos;
	}

	void setRadius(double radius)
	{
		m_radius = radius;
	}
	 
	double getRadius() const
	{
		return m_radius;
	}

	void setActive(bool isActive)
	{
		m_isActive = isActive;
	}

	bool isActive() const
	{
		return m_isActive;
	}

protected:

	Vec2 m_pos;

	Vec2 m_velocity;

	double m_radius;

	bool m_isActive = true;

	unsigned m_count = 0;

};

class Object : public Mover
{
public:

	Object(
		const Vec2& pos,
		vector<std::shared_ptr<Mover>>& bullets,
		const Vec2& velocity,
		double radius		
		) :
		Mover(pos, velocity, radius),
		m_bullets(bullets)
	{

	}

	void update() override
	{
		Mover::update();

		if (m_count % 30 == 0)
		{
			m_bullets.emplace_back(std::make_shared<Mover>(m_pos, Vec2::Down * 5.0, 2.5));
		}
	}

	void setHp(int hp)
	{
		m_hp = hp;

		if (m_hp <= 0)
		{
			m_isActive = false;
		}
	}

	int getHp() const
	{
		return m_hp;
	}

protected:

	int m_hp = 3;

	vector<std::shared_ptr<Mover>>& m_bullets;
};

class Player : public Object
{
public:

	Player(
		const Vec2& pos, 
		vector<std::shared_ptr<Mover>>& bullets,
		const Vec2& velocity = Vec2(0.0, 0.0), 
		double radius = 10.0
		) :
		Object(pos, bullets, velocity, radius)
	{
		m_hp = 10;
	}

	void update() override
	{
		m_velocity = Vec2(0.0, 0.0);

		const double speed = 5.0;

		if (Input::KeyLeft.pressed)
		{
			m_velocity += Vec2::Left * speed;
		}
		if (Input::KeyRight.pressed)
		{
			m_velocity += Vec2::Right * speed;
		}
		if (Input::KeyUp.pressed)
		{
			m_velocity += Vec2::Up * speed;
		}
		if (Input::KeyDown.pressed)
		{
			m_velocity += Vec2::Down * speed;
		}
		if (Input::KeyZ.pressed)
		{
			m_bullets.emplace_back(std::make_shared<Mover>(m_pos, Vec2::Up * 20.0, 10.0));
		}

		if (RectF(Window::Size()).contains(Circle(m_pos + m_velocity, m_radius)))
		{
			Mover::update();
		}
	}
};

bool CheckBullet(const std::shared_ptr<Object>& Object, const std::shared_ptr<Mover>& bullet)
{
	const Circle circleBullet(bullet->getPos(), bullet->getRadius());

	const Circle circleObject(Object->getPos(), Object->getRadius());

	if (circleBullet.intersects(circleObject))
	{
		Object->setHp(Object->getHp() - 1);

		bullet->setActive(false);

		return true;
	}
	else
	{
		return false;
	}
}

void Main()
{
	Window::SetTitle(L"Z:打つ 十字キー:移動");

	int score = 0;

	const Vec2 startPos = Vec2(Window::Width() / 2.0, Window::Height() * 4.0 / 5.0);

	vector<std::shared_ptr<Object>> enemies;
	vector<std::shared_ptr<Mover>> bulletsEnemy;
	vector<std::shared_ptr<Mover>> bulletsPlayer;
	std::shared_ptr<Player> player = std::make_shared<Player>(startPos, bulletsPlayer);
	
	while (System::Update())
	{
		if (System::FrameCount() % Random(30, 60) == 0)
		{
			enemies.emplace_back(std::make_shared<Object>(RandomVec2(Window::Width(), 0.0), bulletsEnemy, Vec2(0.0, 1.0), 20.0));
		}

		for (auto& enemy : enemies)
		{
			enemy->update();
		}

		for (auto& bullet : bulletsEnemy)
		{
			bullet->update();

			if (CheckBullet(player, bullet))
			{
				Rect(Window::Size()).draw(Palette::Red);
			}
		}

		for (auto& bullet : bulletsPlayer)
		{
			bullet->update();

			for (auto& enemy : enemies)
			{
				if (CheckBullet(enemy, bullet))
				{
					score += 1;
				}
			}
		}

		player->update();

		Erase_if(bulletsEnemy, [](const std::shared_ptr<Mover>& bullet){return !bullet->isActive(); });
		Erase_if(bulletsPlayer, [](const std::shared_ptr<Mover>& bullet){return !bullet->isActive(); });
		Erase_if(enemies, [](const std::shared_ptr<Object>& enemy){return !enemy->isActive(); });
		
		//描画
		for (auto& enemy : enemies)
		{
			enemy->draw();
		}

		for (auto& bullet : bulletsEnemy)
		{
			bullet->draw();
		}

		for (auto& bullet : bulletsPlayer)
		{
			bullet->draw();
		}

		player->draw();

		ClearPrint();
		Println(score);
		Println(player->getHp());
		Println(bulletsEnemy.size());
		Println(bulletsPlayer.size());
		Println(enemies.size());
	}

	
}

```