immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use MakeUnique with level parser classes

master
Piotr Dziwinski 2015-07-17 20:36:01 +02:00
parent 35043e04de
commit b3b6435039
28 changed files with 207 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/graphics/engine/pyro.h
View File

@ -27,7 +27,6 @@
#include "common/event.h"
#include "common/global.h"
#include "common/make_unique.h"
#include "graphics/core/color.h"
#include "graphics/engine/pyro_type.h"

11
src/object/auto/auto.cpp
View File

@ -23,6 +23,7 @@
#include "app/app.h"
#include "common/event.h"
#include "common/make_unique.h"
#include "object/level/parserline.h"
#include "object/level/parserparam.h"
@ -419,11 +420,11 @@ void CAuto::SetMotor(bool bMotor)
bool CAuto::Write(CLevelParserLine* line)
{
line->AddParam("aType", CLevelParserParamUPtr{new CLevelParserParam(m_type)});
line->AddParam("aBusy", CLevelParserParamUPtr{new CLevelParserParam(m_bBusy)});
line->AddParam("aTime", CLevelParserParamUPtr{new CLevelParserParam(m_time)});
line->AddParam("aProgressTime", CLevelParserParamUPtr{new CLevelParserParam(m_progressTime)});
line->AddParam("aProgressTotal", CLevelParserParamUPtr{new CLevelParserParam(m_progressTotal)});
line->AddParam("aType", MakeUnique<CLevelParserParam>(m_type));
line->AddParam("aBusy", MakeUnique<CLevelParserParam>(m_bBusy));
line->AddParam("aTime", MakeUnique<CLevelParserParam>(m_time));
line->AddParam("aProgressTime", MakeUnique<CLevelParserParam>(m_progressTime));
line->AddParam("aProgressTotal", MakeUnique<CLevelParserParam>(m_progressTotal));
return false;
}

10
src/object/auto/autoconvert.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autoconvert.h"
#include "common/make_unique.h"
#include "math/geometry.h"
#include "object/object_manager.h"
@ -359,11 +361,11 @@ bool CAutoConvert::Write(CLevelParserLine* line)
if ( m_phase == ACP_STOP ||
m_phase == ACP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

10
src/object/auto/autoderrick.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autoderrick.h"
#include "common/make_unique.h"
#include "graphics/engine/terrain.h"
#include "math/geometry.h"
@ -428,11 +430,11 @@ bool CAutoDerrick::Write(CLevelParserLine* line)
{
if ( m_phase == ADP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

10
src/object/auto/autodestroyer.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autodestroyer.h"
#include "common/make_unique.h"
#include "graphics/engine/pyro_manager.h"
#include "object/object_manager.h"
@ -352,11 +354,11 @@ bool CAutoDestroyer::Write(CLevelParserLine* line)
{
if ( m_phase == ADEP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

16
src/object/auto/autoegg.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autoegg.h"
#include "common/make_unique.h"
#include "graphics/engine/pyro_manager.h"
#include "math/geometry.h"
@ -300,14 +302,14 @@ bool CAutoEgg::Write(CLevelParserLine* line)
{
if ( m_phase == AEP_NULL ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aParamType", CLevelParserParamUPtr{new CLevelParserParam(m_type)});
line->AddParam("aParamValue1", CLevelParserParamUPtr{new CLevelParserParam(m_value)});
line->AddParam("aParamString", CLevelParserParamUPtr{new CLevelParserParam(m_alienProgramName)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
line->AddParam("aParamType", MakeUnique<CLevelParserParam>(m_type));
line->AddParam("aParamValue1", MakeUnique<CLevelParserParam>(m_value));
line->AddParam("aParamString", MakeUnique<CLevelParserParam>(m_alienProgramName));
return true;
}

9
src/object/auto/autofactory.cpp
View File

@ -21,6 +21,7 @@
#include "object/auto/autofactory.h"
#include "common/global.h"
#include "common/make_unique.h"
#include "math/geometry.h"
@ -521,11 +522,11 @@ bool CAutoFactory::Write(CLevelParserLine* line)
{
if ( m_phase == AFP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

11
src/object/auto/autolabo.cpp
View File

@ -21,6 +21,7 @@
#include "object/auto/autolabo.h"
#include "common/global.h"
#include "common/make_unique.h"
#include "common/misc.h"
#include "math/geometry.h"
@ -563,12 +564,12 @@ bool CAutoLabo::Write(CLevelParserLine* line)
{
if ( m_phase == ALAP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aResearch", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_research))});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
line->AddParam("aResearch", MakeUnique<CLevelParserParam>(static_cast<int>(m_research)));
return true;
}

10
src/object/auto/automush.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/automush.h"
#include "common/make_unique.h"
#include "object/object_manager.h"
#include "object/old_object.h"
#include "object/level/parserline.h"
@ -294,11 +296,11 @@ bool CAutoMush::Write(CLevelParserLine* line)
{
if ( m_phase == AMP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

10
src/object/auto/autonest.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autonest.h"
#include "common/make_unique.h"
#include "graphics/engine/terrain.h"
#include "object/object_manager.h"
@ -209,11 +211,11 @@ bool CAutoNest::Write(CLevelParserLine* line)
{
if ( m_phase == ANP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

10
src/object/auto/autonuclearplant.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autonuclearplant.h"
#include "common/make_unique.h"
#include "math/geometry.h"
#include "object/object_manager.h"
@ -426,11 +428,11 @@ bool CAutoNuclearPlant::Write(CLevelParserLine* line)
if ( m_phase == ANUP_STOP ||
m_phase == ANUP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

9
src/object/auto/autopowercaptor.cpp
View File

@ -20,6 +20,7 @@
#include "object/auto/autopowercaptor.h"
#include "common/make_unique.h"
#include "math/geometry.h"
@ -291,11 +292,11 @@ bool CAutoPowerCaptor::Write(CLevelParserLine* line)
{
if ( m_phase == APAP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

10
src/object/auto/autopowerplant.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autopowerplant.h"
#include "common/make_unique.h"
#include "graphics/engine/terrain.h"
#include "math/geometry.h"
@ -580,11 +582,11 @@ bool CAutoPowerPlant::Write(CLevelParserLine* line)
if ( m_phase == AENP_STOP ||
m_phase == AENP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

10
src/object/auto/autorepair.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autorepair.h"
#include "common/make_unique.h"
#include "object/object_manager.h"
#include "object/old_object.h"
#include "object/level/parserline.h"
@ -296,11 +298,11 @@ bool CAutoRepair::Write(CLevelParserLine* line)
{
if ( m_phase == ARP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

11
src/object/auto/autoresearch.cpp
View File

@ -21,6 +21,7 @@
#include "object/auto/autoresearch.h"
#include "common/global.h"
#include "common/make_unique.h"
#include "math/geometry.h"
@ -548,12 +549,12 @@ bool CAutoResearch::Write(CLevelParserLine* line)
{
if ( m_phase == ALP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aResearch", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_research))});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
line->AddParam("aResearch", MakeUnique<CLevelParserParam>(static_cast<int>(m_research)));
return true;
}

20
src/object/auto/autotower.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autotower.h"
#include "common/make_unique.h"
#include "math/geometry.h"
#include "object/object_manager.h"
@ -468,16 +470,16 @@ bool CAutoTower::Write(CLevelParserLine* line)
{
if ( m_phase == ATP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aTargetPos", CLevelParserParamUPtr{new CLevelParserParam(m_targetPos)});
line->AddParam("aAngleYactual", CLevelParserParamUPtr{new CLevelParserParam(m_angleYactual)});
line->AddParam("aAngleZactual", CLevelParserParamUPtr{new CLevelParserParam(m_angleZactual)});
line->AddParam("aAngleYfinal", CLevelParserParamUPtr{new CLevelParserParam(m_angleYfinal)});
line->AddParam("aAngleZfinal", CLevelParserParamUPtr{new CLevelParserParam(m_angleZfinal)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
line->AddParam("aTargetPos", MakeUnique<CLevelParserParam>(m_targetPos));
line->AddParam("aAngleYactual", MakeUnique<CLevelParserParam>(m_angleYactual));
line->AddParam("aAngleZactual", MakeUnique<CLevelParserParam>(m_angleZactual));
line->AddParam("aAngleYfinal", MakeUnique<CLevelParserParam>(m_angleYfinal));
line->AddParam("aAngleZfinal", MakeUnique<CLevelParserParam>(m_angleZfinal));
return true;
}

10
src/object/auto/autovault.cpp
View File

@ -20,6 +20,8 @@
#include "object/auto/autovault.h"
#include "common/make_unique.h"
#include "math/geometry.h"
#include "object/object_manager.h"
@ -350,11 +352,11 @@ bool CAutoVault::Write(CLevelParserLine* line)
{
if ( m_phase == ASAP_WAIT ) return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

4
src/object/brain.cpp
View File

@ -167,11 +167,11 @@ void CBrain::SetMotion(CMotion* motion)
bool CBrain::Write(CLevelParserLine* line)
{
line->AddParam("bVirusActive", CLevelParserParamUPtr{new CLevelParserParam(m_bActiveVirus)});
line->AddParam("bVirusActive", MakeUnique<CLevelParserParam>(m_bActiveVirus));
if ( m_object->GetType() == OBJECT_MOBILErs )
{
line->AddParam("bShieldActive", CLevelParserParamUPtr{new CLevelParserParam(m_secondaryTask != nullptr)});
line->AddParam("bShieldActive", MakeUnique<CLevelParserParam>(m_secondaryTask != nullptr));
}
return true;

5
src/object/level/parser.cpp
View File

@ -22,6 +22,7 @@
#include "app/app.h"
#include "common/make_unique.h"
#include "common/resources/resourcemanager.h"
#include "common/resources/inputstream.h"
#include "common/resources/outputstream.h"
@ -168,7 +169,7 @@ void CLevelParser::Load()
if (command.empty())
continue;
CLevelParserLineUPtr parserLine{new CLevelParserLine(lineNumber, command)};
auto parserLine = MakeUnique<CLevelParserLine>(lineNumber, command);
if (command.length() > 2 && command[command.length() - 2] == '.')
{
@ -239,7 +240,7 @@ void CLevelParser::Load()
std::string paramValue = line.substr(0, pos + 1);
boost::algorithm::trim(paramValue);
parserLine->AddParam(paramName, CLevelParserParamUPtr{new CLevelParserParam(paramName, paramValue)});
parserLine->AddParam(paramName, MakeUnique<CLevelParserParam>(paramName, paramValue));
if (pos == std::string::npos)
break;

6
src/object/level/parserline.cpp
View File

@ -19,8 +19,10 @@
#include "object/level/parserline.h"
#include "object/level/parser.h"
#include "common/logger.h"
#include "common/make_unique.h"
#include "object/level/parser.h"
CLevelParserLine::CLevelParserLine(std::string command)
{
@ -67,7 +69,7 @@ CLevelParserParam* CLevelParserLine::GetParam(std::string name)
return it->second.get();
}
CLevelParserParamUPtr paramUPtr(new CLevelParserParam(name, true));
auto paramUPtr = MakeUnique<CLevelParserParam>(name, true);
paramUPtr->SetLine(this);
CLevelParserParam* paramPtr = paramUPtr.get();
m_params.insert(std::make_pair(name, std::move(paramUPtr)));

21
src/object/level/parserparam.cpp
View File

@ -22,6 +22,7 @@
#include "app/app.h"
#include "common/logger.h"
#include "common/make_unique.h"
#include "common/pathman.h"
#include "common/resources/resourcemanager.h"
@ -61,27 +62,27 @@ CLevelParserParam::CLevelParserParam(bool value)
CLevelParserParam::CLevelParserParam(Gfx::Color value)
{
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.r)});
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.g)});
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.b)});
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.a)});
m_array.push_back(MakeUnique<CLevelParserParam>(value.r));
m_array.push_back(MakeUnique<CLevelParserParam>(value.g));
m_array.push_back(MakeUnique<CLevelParserParam>(value.b));
m_array.push_back(MakeUnique<CLevelParserParam>(value.a));
LoadArray();
}
CLevelParserParam::CLevelParserParam(Math::Point value)
{
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.x)});
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.y)});
m_array.push_back(MakeUnique<CLevelParserParam>(value.x));
m_array.push_back(MakeUnique<CLevelParserParam>(value.y));
LoadArray();
}
CLevelParserParam::CLevelParserParam(Math::Vector value)
{
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.x)});
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.y)});
m_array.push_back(CLevelParserParamUPtr{new CLevelParserParam(value.z)});
m_array.push_back(MakeUnique<CLevelParserParam>(value.x));
m_array.push_back(MakeUnique<CLevelParserParam>(value.y));
m_array.push_back(MakeUnique<CLevelParserParam>(value.z));
LoadArray();
}
@ -905,7 +906,7 @@ void CLevelParserParam::ParseArray()
{
boost::algorithm::trim(value);
if (value.empty()) continue;
CLevelParserParamUPtr param{new CLevelParserParam(m_name + "[" + boost::lexical_cast<std::string>(i) + "]", value)};
auto param = MakeUnique<CLevelParserParam>(m_name + "[" + boost::lexical_cast<std::string>(i) + "]", value);
param->SetLine(m_line);
m_array.push_back(std::move(param));
i++;

8
src/object/motion/motion.cpp
View File

@ -22,6 +22,8 @@
#include "app/app.h"
#include "common/make_unique.h"
#include "object/robotmain.h"
#include "object/old_object.h"
#include "object/level/parserline.h"
@ -162,9 +164,9 @@ bool CMotion::Write(CLevelParserLine* line)
{
if ( m_actionType == -1 ) return false;
line->AddParam("mType", CLevelParserParamUPtr{new CLevelParserParam(m_actionType)});
line->AddParam("mTime", CLevelParserParamUPtr{new CLevelParserParam(m_actionTime)});
line->AddParam("mProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("mType", MakeUnique<CLevelParserParam>(m_actionType));
line->AddParam("mTime", MakeUnique<CLevelParserParam>(m_actionTime));
line->AddParam("mProgress", MakeUnique<CLevelParserParam>(m_progress));
return false;
}

46
src/object/old_object.cpp
View File

@ -886,78 +886,78 @@ void COldObject::Write(CLevelParserLine* line)
{
Math::Vector pos;
line->AddParam("camera", CLevelParserParamUPtr{new CLevelParserParam(GetCameraType())});
line->AddParam("camera", MakeUnique<CLevelParserParam>(GetCameraType()));
if ( GetCameraLock() )
line->AddParam("cameraLock", CLevelParserParamUPtr{new CLevelParserParam(GetCameraLock())});
line->AddParam("cameraLock", MakeUnique<CLevelParserParam>(GetCameraLock()));
if ( GetEnergy() != 0.0f )
line->AddParam("energy", CLevelParserParamUPtr{new CLevelParserParam(GetEnergy())});
line->AddParam("energy", MakeUnique<CLevelParserParam>(GetEnergy()));
if ( GetCapacity() != 1.0f )
line->AddParam("capacity", CLevelParserParamUPtr{new CLevelParserParam(GetCapacity())});
line->AddParam("capacity", MakeUnique<CLevelParserParam>(GetCapacity()));
if ( GetShield() != 1.0f )
line->AddParam("shield", CLevelParserParamUPtr{new CLevelParserParam(GetShield())});
line->AddParam("shield", MakeUnique<CLevelParserParam>(GetShield()));
if ( GetRange() != 1.0f )
line->AddParam("range", CLevelParserParamUPtr{new CLevelParserParam(GetRange())});
line->AddParam("range", MakeUnique<CLevelParserParam>(GetRange()));
if ( !GetSelectable() )
line->AddParam("selectable", CLevelParserParamUPtr{new CLevelParserParam(GetSelectable())});
line->AddParam("selectable", MakeUnique<CLevelParserParam>(GetSelectable()));
if ( !GetEnable() )
line->AddParam("enable", CLevelParserParamUPtr{new CLevelParserParam(GetEnable())});
line->AddParam("enable", MakeUnique<CLevelParserParam>(GetEnable()));
// TODO: doesn't seem to be used
if ( GetFixed() )
line->AddParam("fixed", CLevelParserParamUPtr{new CLevelParserParam(GetFixed())});
line->AddParam("fixed", MakeUnique<CLevelParserParam>(GetFixed()));
if ( !GetClip() )
line->AddParam("clip", CLevelParserParamUPtr{new CLevelParserParam(GetClip())});
line->AddParam("clip", MakeUnique<CLevelParserParam>(GetClip()));
if ( GetLock() )
line->AddParam("lock", CLevelParserParamUPtr{new CLevelParserParam(GetLock())});
line->AddParam("lock", MakeUnique<CLevelParserParam>(GetLock()));
if ( GetProxyActivate() )
{
line->AddParam("proxyActivate", CLevelParserParamUPtr{new CLevelParserParam(GetProxyActivate())});
line->AddParam("proxyDistance", CLevelParserParamUPtr{new CLevelParserParam(GetProxyDistance()/g_unit)});
line->AddParam("proxyActivate", MakeUnique<CLevelParserParam>(GetProxyActivate()));
line->AddParam("proxyDistance", MakeUnique<CLevelParserParam>(GetProxyDistance()/g_unit));
}
if ( GetMagnifyDamage() != 1.0f )
line->AddParam("magnifyDamage", CLevelParserParamUPtr{new CLevelParserParam(GetMagnifyDamage())});
line->AddParam("magnifyDamage", MakeUnique<CLevelParserParam>(GetMagnifyDamage()));
if ( GetTeam() != 0 )
line->AddParam("team", CLevelParserParamUPtr{new CLevelParserParam(GetTeam())});
line->AddParam("team", MakeUnique<CLevelParserParam>(GetTeam()));
if ( GetGunGoalV() != 0.0f )
line->AddParam("aimV", CLevelParserParamUPtr{new CLevelParserParam(GetGunGoalV())});
line->AddParam("aimV", MakeUnique<CLevelParserParam>(GetGunGoalV()));
if ( GetGunGoalH() != 0.0f )
line->AddParam("aimH", CLevelParserParamUPtr{new CLevelParserParam(GetGunGoalH())});
line->AddParam("aimH", MakeUnique<CLevelParserParam>(GetGunGoalH()));
if ( GetAnimateOnReset() )
{
line->AddParam("resetCap", CLevelParserParamUPtr{new CLevelParserParam(GetAnimateOnReset())});
line->AddParam("resetCap", MakeUnique<CLevelParserParam>(GetAnimateOnReset()));
}
if ( m_bVirusMode )
line->AddParam("virusMode", CLevelParserParamUPtr{new CLevelParserParam(m_bVirusMode)});
line->AddParam("virusMode", MakeUnique<CLevelParserParam>(m_bVirusMode));
if ( m_virusTime != 0.0f )
line->AddParam("virusTime", CLevelParserParamUPtr{new CLevelParserParam(m_virusTime)});
line->AddParam("virusTime", MakeUnique<CLevelParserParam>(m_virusTime));
line->AddParam("ignoreBuildCheck", CLevelParserParamUPtr{new CLevelParserParam(GetIgnoreBuildCheck())});
line->AddParam("ignoreBuildCheck", MakeUnique<CLevelParserParam>(GetIgnoreBuildCheck()));
// Sets the parameters of the command line.
CLevelParserParamVec cmdline;
for(float value : m_cmdLine)
{
cmdline.push_back(CLevelParserParamUPtr{new CLevelParserParam(value)});
cmdline.push_back(MakeUnique<CLevelParserParam>(value));
}
if (cmdline.size() > 0)
line->AddParam("cmdline", CLevelParserParamUPtr{new CLevelParserParam(std::move(cmdline))});
line->AddParam("cmdline", MakeUnique<CLevelParserParam>(std::move(cmdline)));
if ( m_motion != nullptr )
{

2
src/object/old_object.h
View File

@ -26,8 +26,6 @@
#include "object/object.h"
#include "common/make_unique.h"
#include "object/interface/carrier_object.h"
#include "object/interface/interactive_object.h"
#include "object/interface/jostleable_object.h"

80
src/object/robotmain.cpp
View File

@ -914,9 +914,9 @@ bool CRobotMain::ProcessEvent(Event &event)
if (obj != nullptr)
{
CLevelParserLine line("CreateObject");
line.AddParam("type", CLevelParserParamUPtr{new CLevelParserParam(obj->GetType())});
line.AddParam("pos", CLevelParserParamUPtr{new CLevelParserParam(obj->GetPosition())});
line.AddParam("dir", CLevelParserParamUPtr{new CLevelParserParam(obj->GetRotationZ()/(Math::PI/180.0f))});
line.AddParam("type", MakeUnique<CLevelParserParam>(obj->GetType()));
line.AddParam("pos", MakeUnique<CLevelParserParam>(obj->GetPosition()));
line.AddParam("dir", MakeUnique<CLevelParserParam>(obj->GetRotationZ()/(Math::PI/180.0f)));
std::stringstream ss;
ss << line;
@ -4824,11 +4824,11 @@ void CRobotMain::IOWriteObject(CLevelParserLine* line, CObject* obj)
{
if (obj->GetType() == OBJECT_FIX) return;
line->AddParam("type", CLevelParserParamUPtr{new CLevelParserParam(obj->GetType())});
line->AddParam("id", CLevelParserParamUPtr{new CLevelParserParam(obj->GetID())});
line->AddParam("pos", CLevelParserParamUPtr{new CLevelParserParam(obj->GetPosition()/g_unit)});
line->AddParam("angle", CLevelParserParamUPtr{new CLevelParserParam(obj->GetRotation() * Math::RAD_TO_DEG)});
line->AddParam("zoom", CLevelParserParamUPtr{new CLevelParserParam(obj->GetScale())});
line->AddParam("type", MakeUnique<CLevelParserParam>(obj->GetType()));
line->AddParam("id", MakeUnique<CLevelParserParam>(obj->GetID()));
line->AddParam("pos", MakeUnique<CLevelParserParam>(obj->GetPosition()/g_unit));
line->AddParam("angle", MakeUnique<CLevelParserParam>(obj->GetRotation() * Math::RAD_TO_DEG));
line->AddParam("zoom", MakeUnique<CLevelParserParam>(obj->GetScale()));
if (obj->Implements(ObjectInterfaceType::Old))
{
@ -4842,34 +4842,34 @@ void CRobotMain::IOWriteObject(CLevelParserLine* line, CObject* obj)
if (pos.x != 0.0f || pos.y != 0.0f || pos.z != 0.0f)
{
pos /= g_unit;
line->AddParam("p" + boost::lexical_cast<std::string>(i), CLevelParserParamUPtr{new CLevelParserParam(pos)});
line->AddParam("p" + boost::lexical_cast<std::string>(i), MakeUnique<CLevelParserParam>(pos));
}
Math::Vector rot = oldObj->GetPartRotation(i);
if (rot.x != 0.0f || rot.y != 0.0f || rot.z != 0.0f)
{
rot /= (Math::PI/180.0f);
line->AddParam("a" + boost::lexical_cast<std::string>(i), CLevelParserParamUPtr{new CLevelParserParam(rot)});
line->AddParam("a" + boost::lexical_cast<std::string>(i), MakeUnique<CLevelParserParam>(rot));
}
Math::Vector scale = oldObj->GetPartScale(i);
if (scale.x != 1.0f || scale.y != 1.0f || scale.z != 1.0f)
{
line->AddParam("z" + boost::lexical_cast<std::string>(i), CLevelParserParamUPtr{new CLevelParserParam(scale)});
line->AddParam("z" + boost::lexical_cast<std::string>(i), MakeUnique<CLevelParserParam>(scale));
}
}
line->AddParam("trainer", CLevelParserParamUPtr{new CLevelParserParam(obj->GetTrainer())});
line->AddParam("option", CLevelParserParamUPtr{new CLevelParserParam(obj->GetOption())});
line->AddParam("trainer", MakeUnique<CLevelParserParam>(obj->GetTrainer()));
line->AddParam("option", MakeUnique<CLevelParserParam>(obj->GetOption()));
}
if (obj == m_infoObject)
line->AddParam("select", CLevelParserParamUPtr{new CLevelParserParam(1)});
line->AddParam("select", MakeUnique<CLevelParserParam>(1));
obj->Write(line);
if (obj->GetType() == OBJECT_BASE)
line->AddParam("run", CLevelParserParamUPtr{new CLevelParserParam(3)}); // stops and open (PARAM_FIXSCENE)
line->AddParam("run", MakeUnique<CLevelParserParam>(3)); // stops and open (PARAM_FIXSCENE)
if (obj->Implements(ObjectInterfaceType::Programmable))
{
@ -4878,7 +4878,7 @@ void CRobotMain::IOWriteObject(CLevelParserLine* line, CObject* obj)
int run = brain->GetProgram();
if (run != -1)
{
line->AddParam("run", CLevelParserParamUPtr{new CLevelParserParam(run+1)});
line->AddParam("run", MakeUnique<CLevelParserParam>(run+1));
}
auto& programs = brain->GetPrograms();
@ -4886,7 +4886,7 @@ void CRobotMain::IOWriteObject(CLevelParserLine* line, CObject* obj)
{
if (programs[i]->readOnly)
{
line->AddParam("scriptReadOnly" + boost::lexical_cast<std::string>(i+1), CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("scriptReadOnly" + boost::lexical_cast<std::string>(i+1), MakeUnique<CLevelParserParam>(true));
}
}
}
@ -4898,48 +4898,48 @@ bool CRobotMain::IOWriteScene(const char *filename, const char *filecbot, char *
CLevelParser levelParser(filename);
CLevelParserLineUPtr line;
line.reset(new CLevelParserLine("Title"));
line->AddParam("text", CLevelParserParamUPtr{new CLevelParserParam(std::string(info))});
line = MakeUnique<CLevelParserLine>("Title");
line->AddParam("text", MakeUnique<CLevelParserParam>(std::string(info)));
levelParser.AddLine(std::move(line));
//TODO: Do we need that? It's not used anyway
line.reset(new CLevelParserLine("Version"));
line->AddParam("maj", CLevelParserParamUPtr{new CLevelParserParam(0)});
line->AddParam("min", CLevelParserParamUPtr{new CLevelParserParam(1)});
line = MakeUnique<CLevelParserLine>("Version");
line->AddParam("maj", MakeUnique<CLevelParserParam>(0));
line->AddParam("min", MakeUnique<CLevelParserParam>(1));
levelParser.AddLine(std::move(line));
line.reset(new CLevelParserLine("Created"));
line->AddParam("date", CLevelParserParamUPtr{new CLevelParserParam(GetCurrentTimestamp())});
line = MakeUnique<CLevelParserLine>("Created");
line->AddParam("date", MakeUnique<CLevelParserParam>(GetCurrentTimestamp()));
levelParser.AddLine(std::move(line));
char* name = m_dialog->GetSceneName();
line.reset(new CLevelParserLine("Mission"));
line->AddParam("base", CLevelParserParamUPtr{new CLevelParserParam(std::string(name))});
line->AddParam("rank", CLevelParserParamUPtr{new CLevelParserParam(m_dialog->GetSceneRank())});
line = MakeUnique<CLevelParserLine>("Mission");
line->AddParam("base", MakeUnique<CLevelParserParam>(std::string(name)));
line->AddParam("rank", MakeUnique<CLevelParserParam>(m_dialog->GetSceneRank()));
if (std::string(name) == "custom")
{
line->AddParam("dir", CLevelParserParamUPtr{new CLevelParserParam(std::string(m_dialog->GetSceneDir()))});
line->AddParam("dir", MakeUnique<CLevelParserParam>(std::string(m_dialog->GetSceneDir())));
}
levelParser.AddLine(std::move(line));
line.reset(new CLevelParserLine("Map"));
line->AddParam("zoom", CLevelParserParamUPtr{new CLevelParserParam(m_map->GetZoomMap())});
line = MakeUnique<CLevelParserLine>("Map");
line->AddParam("zoom", MakeUnique<CLevelParserParam>(m_map->GetZoomMap()));
levelParser.AddLine(std::move(line));
line.reset(new CLevelParserLine("DoneResearch"));
line->AddParam("bits", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_researchDone[0]))});
line = MakeUnique<CLevelParserLine>("DoneResearch");
line->AddParam("bits", MakeUnique<CLevelParserParam>(static_cast<int>(m_researchDone[0])));
levelParser.AddLine(std::move(line));
float sleep, delay, magnetic, progress;
if (m_lightning->GetStatus(sleep, delay, magnetic, progress))
{
line.reset(new CLevelParserLine("BlitzMode"));
line->AddParam("sleep", CLevelParserParamUPtr{new CLevelParserParam(sleep)});
line->AddParam("delay", CLevelParserParamUPtr{new CLevelParserParam(delay)});
line->AddParam("magnetic", CLevelParserParamUPtr{new CLevelParserParam(magnetic/g_unit)});
line->AddParam("progress", CLevelParserParamUPtr{new CLevelParserParam(progress)});
line = MakeUnique<CLevelParserLine>("BlitzMode");
line->AddParam("sleep", MakeUnique<CLevelParserParam>(sleep));
line->AddParam("delay", MakeUnique<CLevelParserParam>(delay));
line->AddParam("magnetic", MakeUnique<CLevelParserParam>(magnetic/g_unit));
line->AddParam("progress", MakeUnique<CLevelParserParam>(progress));
levelParser.AddLine(std::move(line));
}
@ -4959,7 +4959,7 @@ bool CRobotMain::IOWriteScene(const char *filename, const char *filecbot, char *
CObject* cargo = dynamic_cast<CCarrierObject*>(obj)->GetCargo();
if (cargo != nullptr) // object transported?
{
line.reset(new CLevelParserLine("CreateFret"));
line = MakeUnique<CLevelParserLine>("CreateFret");
IOWriteObject(line.get(), cargo);
levelParser.AddLine(std::move(line));
}
@ -4970,14 +4970,14 @@ bool CRobotMain::IOWriteScene(const char *filename, const char *filecbot, char *
CObject* power = dynamic_cast<CPoweredObject*>(obj)->GetPower();
if (power != nullptr) // battery transported?
{
line.reset(new CLevelParserLine("CreatePower"));
line = MakeUnique<CLevelParserLine>("CreatePower");
IOWriteObject(line.get(), power);
levelParser.AddLine(std::move(line));
}
}
line.reset(new CLevelParserLine("CreateObject"));
line = MakeUnique<CLevelParserLine>("CreateObject");
IOWriteObject(line.get(), obj);
levelParser.AddLine(std::move(line));

10
src/object/subclass/exchange_post.cpp
View File

@ -197,7 +197,7 @@ void CExchangePost::Write(CLevelParserLine* line)
{
auto key = "info" + boost::lexical_cast<std::string>(i);
auto paramValue = info.name + "=" + boost::lexical_cast<std::string>(info.value);
line->AddParam(key, CLevelParserParamUPtr{new CLevelParserParam(paramValue)});
line->AddParam(key, MakeUnique<CLevelParserParam>(paramValue));
}
}
}
@ -656,11 +656,11 @@ bool CAutoInfo::Write(CLevelParserLine* line)
if (m_phase == Phase::Wait)
return false;
line->AddParam("aExist", CLevelParserParamUPtr{new CLevelParserParam(true)});
line->AddParam("aExist", MakeUnique<CLevelParserParam>(true));
CAuto::Write(line);
line->AddParam("aPhase", CLevelParserParamUPtr{new CLevelParserParam(static_cast<int>(m_phase))});
line->AddParam("aProgress", CLevelParserParamUPtr{new CLevelParserParam(m_progress)});
line->AddParam("aSpeed", CLevelParserParamUPtr{new CLevelParserParam(m_speed)});
line->AddParam("aPhase", MakeUnique<CLevelParserParam>(static_cast<int>(m_phase)));
line->AddParam("aProgress", MakeUnique<CLevelParserParam>(m_progress));
line->AddParam("aSpeed", MakeUnique<CLevelParserParam>(m_speed));
return true;
}

7
src/physics/physics.cpp
View File

@ -24,6 +24,7 @@
#include "common/event.h"
#include "common/global.h"
#include "common/make_unique.h"
#include "graphics/engine/camera.h"
#include "graphics/engine/engine.h"
@ -173,12 +174,12 @@ PhysicsType CPhysics::GetType()
bool CPhysics::Write(CLevelParserLine* line)
{
line->AddParam("motor", CLevelParserParamUPtr{new CLevelParserParam(m_motorSpeed)});
line->AddParam("motor", MakeUnique<CLevelParserParam>(m_motorSpeed));
if ( m_type == TYPE_FLYING )
{
line->AddParam("reactorRange", CLevelParserParamUPtr{new CLevelParserParam(GetReactorRange())});
line->AddParam("land", CLevelParserParamUPtr{new CLevelParserParam(GetLand())});
line->AddParam("reactorRange", MakeUnique<CLevelParserParam>(GetReactorRange()));
line->AddParam("land", MakeUnique<CLevelParserParam>(GetLand()));
}
return true;

15
src/ui/maindialog.cpp
View File

@ -28,6 +28,7 @@
#include "common/global.h"
#include "common/event.h"
#include "common/logger.h"
#include "common/make_unique.h"
#include "common/misc.h"
#include "common/profile.h"
#include "common/restext.h"
@ -6018,15 +6019,15 @@ void CMainDialog::WriteGamerPerso(char *gamer)
CLevelParser persoParser(GetSavegameDir()+"/"+gamer+"/face.gam");
CLevelParserLineUPtr line;
line.reset(new CLevelParserLine("Head"));
line->AddParam("face", CLevelParserParamUPtr{new CLevelParserParam(m_perso.face)});
line->AddParam("glasses", CLevelParserParamUPtr{new CLevelParserParam(m_perso.glasses)});
line->AddParam("hair", CLevelParserParamUPtr{new CLevelParserParam(m_perso.colorHair)});
line = MakeUnique<CLevelParserLine>("Head");
line->AddParam("face", MakeUnique<CLevelParserParam>(m_perso.face));
line->AddParam("glasses", MakeUnique<CLevelParserParam>(m_perso.glasses));
line->AddParam("hair", MakeUnique<CLevelParserParam>(m_perso.colorHair));
persoParser.AddLine(std::move(line));
line.reset(new CLevelParserLine("Body"));
line->AddParam("combi", CLevelParserParamUPtr{new CLevelParserParam(m_perso.colorCombi)});
line->AddParam("band", CLevelParserParamUPtr{new CLevelParserParam(m_perso.colorBand)});
line = MakeUnique<CLevelParserLine>("Body");
line->AddParam("combi", MakeUnique<CLevelParserParam>(m_perso.colorCombi));
line->AddParam("band", MakeUnique<CLevelParserParam>(m_perso.colorBand));
persoParser.AddLine(std::move(line));
persoParser.Save();