From: Michael Andreen <harv@ruin.nu>
Date: Mon, 13 May 2002 16:46:32 +0000 (+0000)
Subject: now compiles with gcc 3.1, might not work with gcc 3.0 though (not sure)
X-Git-Url: https://ruin.nu/git/?p=hbs.git;a=commitdiff_plain;h=20b89dab5346f13dc17b368b92de89eebf00ac11

now compiles with gcc 3.1, might not work with gcc 3.0 though (not sure)
---

diff --git a/bs/fleet.cpp b/bs/fleet.cpp
index 4fc5be5..4072788 100644
--- a/bs/fleet.cpp
+++ b/bs/fleet.cpp
@@ -166,7 +166,7 @@ vector<int> Fleet::RacesAllowed() const
 
 //////////////////////////////////////////////////////////////////////////
 //
-unsigned Fleet::score(int tick = 0) const
+unsigned Fleet::score(int tick) const
 {
 	unsigned tot_score = 0;
 
@@ -187,7 +187,7 @@ unsigned Fleet::score(int tick = 0) const
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::setFleet(string unittype, int number, int tick = 0)
+void Fleet::setFleet(string unittype, int number, int tick)
 {
 	int earlier = 0;
 	int ticks = m_Fleet[unittype].size();
@@ -204,7 +204,7 @@ void Fleet::setFleet(string unittype, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::addFleet(std::string unittype, int number, int tick = 0)
+void Fleet::addFleet(std::string unittype, int number, int tick)
 {
 	int earlier = 0;
 	int ticks = m_Fleet[unittype].size();
@@ -221,7 +221,7 @@ void Fleet::addFleet(std::string unittype, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-int	 Fleet::fleet(string unittype, int tick = 0)
+int	 Fleet::fleet(string unittype, int tick)
 {
 
 	int ticks = m_Fleet[unittype].size();
@@ -241,7 +241,7 @@ int	 Fleet::fleet(string unittype, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-int Fleet::blockedFleet(std::string unittype, int tick = 0)
+int Fleet::blockedFleet(std::string unittype, int tick)
 {
 	int ticks = m_BlockedFleet[unittype].size();
 	if (ticks == 0)
@@ -257,7 +257,7 @@ int Fleet::blockedFleet(std::string unittype, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::setBlockedFleet(std::string unittype, int number, int tick = 0)
+void Fleet::setBlockedFleet(std::string unittype, int number, int tick)
 {
 	int ticks = m_BlockedFleet[unittype].size();
 
@@ -273,7 +273,7 @@ void Fleet::setBlockedFleet(std::string unittype, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::addToThis(std::vector<Fleet*> fleets, int tick = 0)
+void Fleet::addToThis(std::vector<Fleet*> fleets, int tick)
 {
 	for (UnitList::iterator i = s_Units.begin();  i != s_Units.end(); ++i)
 	{
@@ -292,7 +292,7 @@ void Fleet::addToThis(std::vector<Fleet*> fleets, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::distributeLossesGains(std::vector<Fleet*> fleets, int tick = 0)
+void Fleet::distributeLossesGains(std::vector<Fleet*> fleets, int tick)
 {
 	for (UnitList::iterator i = s_Units.begin(); i != s_Units.end(); ++i)
 	{
@@ -332,7 +332,7 @@ void Fleet::distributeLossesGains(std::vector<Fleet*> fleets, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-std::vector<Fleet*> Fleet::calculateSide(std::vector<Fleet*> fleets, int stays = 0, int tick = 0)
+std::vector<Fleet*> Fleet::calculateSide(std::vector<Fleet*> fleets, int stays, int tick)
 {
 	vector<Fleet*> fl;
 	for (vector<Fleet*>::iterator i = fleets.begin(); i != fleets.end(); ++i)
@@ -352,7 +352,7 @@ std::vector<Fleet*> Fleet::calculateSide(std::vector<Fleet*> fleets, int stays =
 
 //////////////////////////////////////////////////////////////////////////
 //
-int Fleet::freeFleet(std:: string unittype, int tick = 0)
+int Fleet::freeFleet(std:: string unittype, int tick)
 {
 	int bticks = m_BlockedFleet[unittype].size();
 
@@ -562,7 +562,7 @@ void Fleet::takeEMP(std::string unittype, int number)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::killFleet(std::string unittype, int number, int tick = 0)
+void Fleet::killFleet(std::string unittype, int number, int tick)
 {
 	int earlier = 0;
 	int ticks = m_Fleet[unittype].size();
@@ -579,7 +579,7 @@ void Fleet::killFleet(std::string unittype, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::setResource(std::string type, int number, int tick = 0)
+void Fleet::setResource(std::string type, int number, int tick)
 {
 
 	int ticks = m_Resources[type].size();
@@ -590,7 +590,7 @@ void Fleet::setResource(std::string type, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::addResource(std::string type, int number, int tick = 0)
+void Fleet::addResource(std::string type, int number, int tick)
 {
 
 	int ticks = m_Resources[type].size();
@@ -603,7 +603,7 @@ void Fleet::addResource(std::string type, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-int Fleet::resource(std::string type, int tick = 0) const
+int Fleet::resource(std::string type, int tick) const
 {
 	if (tick < 0)
 		return 0;
@@ -658,7 +658,7 @@ void Fleet::printFleet()
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::blockFleet(std::string unittype, int number, int tick = 0)
+void Fleet::blockFleet(std::string unittype, int number, int tick)
 {
 	if (m_BlockedFleet[unittype].size() >= 1)
 	{
@@ -677,7 +677,7 @@ void Fleet::blockFleet(std::string unittype, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::distributeCappedRoids(std::vector<Fleet*> fleets, int tick = 0)
+void Fleet::distributeCappedRoids(std::vector<Fleet*> fleets, int tick)
 {
 	for (ResourceList::iterator i = m_Resources.begin(); i != m_Resources.end(); ++i)
 	{
@@ -717,7 +717,7 @@ void Fleet::distributeCappedRoids(std::vector<Fleet*> fleets, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::addFleet(std::map<string, int> units, int tick = 0)
+void Fleet::addFleet(std::map<string, int> units, int tick)
 {
 	for (map<string, int>::iterator i = units.begin(); i != units.end(); ++i)
 		addFleet(i->first, i->second, tick);
@@ -739,7 +739,7 @@ void Fleet::setStays(int ticks)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::calculateLostStealships(string unittype, std::map<std::string, int> stolen, int tick = 1)
+void Fleet::calculateLostStealships(string unittype, std::map<std::string, int> stolen, int tick)
 {
 	int stealscore = 0;
 	for (map<string, int>::iterator i = stolen.begin(); i != stolen.end(); ++i)
@@ -755,7 +755,7 @@ void Fleet::calculateLostStealships(string unittype, std::map<std::string, int>
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Fleet::distributeStolenShips(std::map<std::string, std::map<std::string, int> > stolen, std::vector<Fleet*> fleets, int tick = 0)
+void Fleet::distributeStolenShips(std::map<std::string, std::map<std::string, int> > stolen, std::vector<Fleet*> fleets, int tick)
 {
 	for(map<string, map<string, int> >::iterator i = stolen.begin(); i != stolen.end(); ++i)
 	{
diff --git a/bs/fleetview.cpp b/bs/fleetview.cpp
index 3935616..03a24c9 100644
--- a/bs/fleetview.cpp
+++ b/bs/fleetview.cpp
@@ -227,7 +227,7 @@ void FleetView::slotRoidsChanged(const QString& type, int value)
 
 /////////////////////////////////////////////////////////////////////
 //
-void FleetView::slotViewTickRange(int min = -1, int max = -1)
+void FleetView::slotViewTickRange(int min, int max)
 {
 	if (min > -1)
 		m_iMinTick = min;
diff --git a/bs/planet.cpp b/bs/planet.cpp
index 4133277..935c65d 100644
--- a/bs/planet.cpp
+++ b/bs/planet.cpp
@@ -31,7 +31,7 @@ Planet::~Planet(){
 
 //////////////////////////////////////////////////////////////////////////
 //
-unsigned Planet::planetScore(int tick = 0) const
+unsigned Planet::planetScore(int tick) const
 {
 	int ticks = m_Score.size();
 	if (ticks == 0)
@@ -47,7 +47,7 @@ unsigned Planet::planetScore(int tick = 0) const
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::setPlanetScore(unsigned number, int tick = 0)
+void Planet::setPlanetScore(unsigned number, int tick)
 {
 	int earlier = 0;
 	int ticks = m_Score.size();
@@ -64,7 +64,7 @@ void Planet::setPlanetScore(unsigned number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::addPlanetScore(unsigned number, int tick = 0)
+void Planet::addPlanetScore(unsigned number, int tick)
 {
 	int earlier = 0;
 	int ticks = m_Score.size();
@@ -80,7 +80,7 @@ void Planet::addPlanetScore(unsigned number, int tick = 0)
 }
 //////////////////////////////////////////////////////////////////////////
 //
-int Planet::roids(std::string type, int tick = 0) const
+int Planet::roids(std::string type, int tick) const
 {
 	// const... I would like [] as for const types: int ticks = m_Roids[type].size();
 	
@@ -108,7 +108,7 @@ int Planet::roids(std::string type, int tick = 0) const
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::setRoids(std::string type, int number, int tick = 0)
+void Planet::setRoids(std::string type, int number, int tick)
 {
 	int ticks = m_Roids[type].size();
 	int roids = 0;
@@ -122,7 +122,7 @@ void Planet::setRoids(std::string type, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::takeRoids(std::string type, int number, int tick = 0)
+void Planet::takeRoids(std::string type, int number, int tick)
 {
 	int ticks = m_Roids[type].size();
 	int roids = 0;
@@ -221,7 +221,7 @@ void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::calcOneTick(Planet* friendly, Fleet* hostile, std::map<std::string, std::map<std::string, int> >& stealfriendly, std::map<std::string, std::map<std::string, int> >&  stealhostile, int tick = 1)
+void Planet::calcOneTick(Planet* friendly, Fleet* hostile, std::map<std::string, std::map<std::string, int> >& stealfriendly, std::map<std::string, std::map<std::string, int> >&  stealhostile, int tick)
 {
 	if (planetScore(tick - 1) > 0)
 		setCapping(float(planetScore(tick - 1)) / hostile->score() /  10, tick);
@@ -312,7 +312,7 @@ void Planet::calcOneTick(Planet* friendly, Fleet* hostile, std::map<std::string,
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick = 1)
+void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick)
 {
 	for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
 	{
@@ -326,7 +326,7 @@ void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick = 1)
 
 //////////////////////////////////////////////////////////////////////////
 //
-float Planet::capping(int tick = 0)
+float Planet::capping(int tick)
 {
 	int ticks = m_Capping.size();
 
@@ -340,7 +340,7 @@ float Planet::capping(int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::setCapping(float capping, int tick = 0)
+void Planet::setCapping(float capping, int tick)
 {
 	int ticks = m_Capping.size();
 
diff --git a/bs/unittype.cpp b/bs/unittype.cpp
index 36bd4ed..836ddb9 100644
--- a/bs/unittype.cpp
+++ b/bs/unittype.cpp
@@ -93,7 +93,7 @@ void UnitType::addTarget(string target)
  * If it finds the position it inserts the target there, if it reaches the end 
  * before it finds the correct possition it adds the target to the end. 
  */
-void UnitType::insTarget(string target, int index = 0)
+void UnitType::insTarget(string target, int index)
 {
 
 	vector<string>::iterator i = m_vTarget.begin();