void static ApplyMiningSettings()
{
QSettings settings;
if (settings.contains("bMiningEnabled"))
SetBoolArg("-gen", settings.value("bMiningEnabled").toBool());
if (settings.contains("nMiningIntensity"))
SetArg("-genproclimit", settings.value("nMiningIntensity").toString().toStdString());
// stop
GenerateBitcoins(false, NULL);
// start
GenerateBitcoins(GetBoolArg("-gen", false), pwalletMain);
}
// FOR SYNCED MESSAGES
void CGame::ActionReceived(const Action& action, int playernum)
{
if (action.command == "cheat") {
SetBoolArg(gs->cheatEnabled, action.extra);
if (gs->cheatEnabled)
logOutput.Print("Cheating!");
else
logOutput.Print("No more cheating");
}
else if (action.command == "nohelp") {
SetBoolArg(gs->noHelperAIs, action.extra);
selectedUnits.PossibleCommandChange(NULL);
logOutput.Print("LuaUI control is %s", gs->noHelperAIs ? "disabled" : "enabled");
}
else if (action.command == "nospecdraw") {
bool buf;
SetBoolArg(buf, action.extra);
inMapDrawer->SetSpecMapDrawingAllowed(buf);
}
else if (action.command == "godmode") {
if (!gs->cheatEnabled)
logOutput.Print("godmode requires /cheat");
else {
SetBoolArg(gs->godMode, action.extra);
CLuaUI::UpdateTeams();
if (gs->godMode) {
logOutput.Print("God Mode Enabled");
} else {
logOutput.Print("God Mode Disabled");
}
CPlayer::UpdateControlledTeams();
}
}
else if (action.command == "globallos") {
if (!gs->cheatEnabled) {
logOutput.Print("globallos requires /cheat");
} else {
SetBoolArg(gs->globalLOS, action.extra);
if (gs->globalLOS) {
logOutput.Print("Global LOS Enabled");
} else {
logOutput.Print("Global LOS Disabled");
}
}
}
else if (action.command == "nocost" && gs->cheatEnabled) {
if (unitDefHandler->ToggleNoCost()) {
logOutput.Print("Everything is for free!");
} else {
logOutput.Print("Everything costs resources again!");
}
}
else if (action.command == "give" && gs->cheatEnabled) {
std::string s = "give "; //FIXME lazyness
s += action.extra;
// .give [amount] <unitName> [team] <@x,y,z>
const vector<string> &args = CSimpleParser::Tokenize(s, 0);
if (args.size() < 3) {
logOutput.Print("Someone is spoofing invalid .give messages!");
return;
}
float3 pos;
if (sscanf(args[args.size() - 1].c_str(), "@%f,%f,%f", &pos.x, &pos.y, &pos.z) != 3) {
logOutput.Print("Someone is spoofing invalid .give messages!");
return;
}
int amount = 1;
int team = playerHandler->Player(playernum)->team;
int amountArgIdx = -1;
int teamArgIdx = -1;
if (args.size() == 5) {
amountArgIdx = 1;
teamArgIdx = 3;
}
else if (args.size() == 4) {
if (args[1].find_first_not_of("0123456789") == string::npos) {
amountArgIdx = 1;
} else {
teamArgIdx = 2;
}
}
if (amountArgIdx >= 0) {
const string& amountStr = args[amountArgIdx];
amount = atoi(amountStr.c_str());
if ((amount < 0) || (amountStr.find_first_not_of("0123456789") != string::npos)) {
logOutput.Print("Bad give amount: %s", amountStr.c_str());
return;
}
}
if (teamArgIdx >= 0) {
const string& teamStr = args[teamArgIdx];
team = atoi(teamStr.c_str());
if ((!teamHandler->IsValidTeam(team)) || (teamStr.find_first_not_of("0123456789") != string::npos)) {
logOutput.Print("Bad give team: %s", teamStr.c_str());
return;
}
}
const string unitName = (amountArgIdx >= 0) ? args[2] : args[1];
if (unitName == "all") {
// player entered ".give all"
int numRequestedUnits = unitDefHandler->unitDefs.size() - 1; /// defid=0 is not valid
int currentNumUnits = teamHandler->Team(team)->units.size();
int sqSize = (int) streflop::ceil(streflop::sqrt((float) numRequestedUnits));
// make sure team unit-limit not exceeded
if ((currentNumUnits + numRequestedUnits) > uh->MaxUnitsPerTeam()) {
numRequestedUnits = uh->MaxUnitsPerTeam() - currentNumUnits;
}
// make sure square is entirely on the map
float sqHalfMapSize = sqSize / 2 * 10 * SQUARE_SIZE;
pos.x = std::max(sqHalfMapSize, std::min(pos.x, float3::maxxpos - sqHalfMapSize - 1));
pos.z = std::max(sqHalfMapSize, std::min(pos.z, float3::maxzpos - sqHalfMapSize - 1));
for (int a = 1; a <= numRequestedUnits; ++a) {
float posx = pos.x + (a % sqSize - sqSize / 2) * 10 * SQUARE_SIZE;
float posz = pos.z + (a / sqSize - sqSize / 2) * 10 * SQUARE_SIZE;
float3 pos2 = float3(posx, pos.y, posz);
const UnitDef* ud = unitDefHandler->GetUnitDefByID(a);
if (ud) {
const CUnit* unit = unitLoader->LoadUnit(ud, pos2, team, false, 0, NULL);
if (unit) {
unitLoader->FlattenGround(unit);
}
}
}
}
else if (!unitName.empty()) {
int numRequestedUnits = amount;
int currentNumUnits = teamHandler->Team(team)->units.size();
if (currentNumUnits >= uh->MaxUnitsPerTeam()) {
LogObject() << "Unable to give any more units to team " << team << "(current: " << currentNumUnits << ", max: " << uh->MaxUnits() << ")";
return;
}
// make sure team unit-limit is not exceeded
if ((currentNumUnits + numRequestedUnits) > uh->MaxUnitsPerTeam()) {
numRequestedUnits = uh->MaxUnitsPerTeam() - currentNumUnits;
}
const UnitDef* unitDef = unitDefHandler->GetUnitDefByName(unitName);
if (unitDef != NULL) {
int xsize = unitDef->xsize;
int zsize = unitDef->zsize;
int squareSize = (int) streflop::ceil(streflop::sqrt((float) numRequestedUnits));
int total = numRequestedUnits;
float3 minpos = pos;
minpos.x -= ((squareSize - 1) * xsize * SQUARE_SIZE) / 2;
minpos.z -= ((squareSize - 1) * zsize * SQUARE_SIZE) / 2;
for (int z = 0; z < squareSize; ++z) {
for (int x = 0; x < squareSize && total > 0; ++x) {
float minposx = minpos.x + x * xsize * SQUARE_SIZE;
float minposz = minpos.z + z * zsize * SQUARE_SIZE;
const float3 upos(minposx, minpos.y, minposz);
const CUnit* unit = unitLoader->LoadUnit(unitDef, upos, team, false, 0, NULL);
if (unit) {
unitLoader->FlattenGround(unit);
}
--total;
}
}
logOutput.Print("Giving %i %s to team %i", numRequestedUnits, unitName.c_str(), team);
} else {
int allyteam = -1;
if (teamArgIdx < 0) {
team = -1; // default to world features
allyteam = -1;
} else {
allyteam = teamHandler->AllyTeam(team);
}
const FeatureDef* featureDef = featureHandler->GetFeatureDef(unitName);
if (featureDef) {
int xsize = featureDef->xsize;
int zsize = featureDef->zsize;
int squareSize = (int) streflop::ceil(streflop::sqrt((float) numRequestedUnits));
int total = amount; // FIXME -- feature count limit?
float3 minpos = pos;
minpos.x -= ((squareSize - 1) * xsize * SQUARE_SIZE) / 2;
minpos.z -= ((squareSize - 1) * zsize * SQUARE_SIZE) / 2;
for (int z = 0; z < squareSize; ++z) {
for (int x = 0; x < squareSize && total > 0; ++x) {
float minposx = minpos.x + x * xsize * SQUARE_SIZE;
float minposz = minpos.z + z * zsize * SQUARE_SIZE;
float minposy = ground->GetHeightReal(minposx, minposz);
const float3 upos(minposx, minposy, minposz);
CFeature* feature = new CFeature();
// Initialize() adds the feature to the FeatureHandler -> no memory-leak
feature->Initialize(upos, featureDef, 0, 0, team, allyteam, "");
--total;
}
}
logOutput.Print("Giving %i %s (feature) to team %i",
numRequestedUnits, unitName.c_str(), team);
}
else {
logOutput.Print(unitName + " is not a valid unitname");
}
}
}
}
else if (action.command == "destroy" && gs->cheatEnabled) {
std::stringstream ss(action.extra);
logOutput.Print("Killing units: %s", action.extra.c_str());
do {
unsigned id;
ss >> id;
if (!ss)
break;
if (id >= uh->units.size())
continue;
if (uh->units[id] == NULL)
continue;
uh->units[id]->KillUnit(false, false, 0);
} while (true);
}
/** Initialize bitcoin.
* @pre Parameters should be parsed and config file should be read.
*/
bool AppInit2(boost::thread_group& threadGroup)
{
// ********************************************************* Step 1: setup
#ifdef _MSC_VER
// Turn off Microsoft heap dump noise
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));
#endif
#if _MSC_VER >= 1400
// Disable confusing "helpful" text message on abort, Ctrl-C
_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
#endif
#ifdef WIN32
// Enable Data Execution Prevention (DEP)
// Minimum supported OS versions: WinXP SP3, WinVista >= SP1, Win Server 2008
// A failure is non-critical and needs no further attention!
#ifndef PROCESS_DEP_ENABLE
// We define this here, because GCCs winbase.h limits this to _WIN32_WINNT >= 0x0601 (Windows 7),
// which is not correct. Can be removed, when GCCs winbase.h is fixed!
#define PROCESS_DEP_ENABLE 0x00000001
#endif
typedef BOOL (WINAPI *PSETPROCDEPPOL)(DWORD);
PSETPROCDEPPOL setProcDEPPol = (PSETPROCDEPPOL)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "SetProcessDEPPolicy");
if (setProcDEPPol != NULL) setProcDEPPol(PROCESS_DEP_ENABLE);
#endif
#ifndef WIN32
umask(077);
// Clean shutdown on SIGTERM
struct sigaction sa;
sa.sa_handler = HandleSIGTERM;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
// Reopen debug.log on SIGHUP
struct sigaction sa_hup;
sa_hup.sa_handler = HandleSIGHUP;
sigemptyset(&sa_hup.sa_mask);
sa_hup.sa_flags = 0;
sigaction(SIGHUP, &sa_hup, NULL);
#endif
if (!CheckDiskSpace())
return false;
// ********************************************************* Step 2: parameter interactions
nNodeLifespan = GetArg("-addrlifespan", 7);
nMinStakeInterval = GetArg("-minstakeinterval", 0);
nMinerSleep = GetArg("-minersleep", 500);
// Largest block you're willing to create.
// Limit to betweeen 1K and MAX_BLOCK_SIZE-1K for sanity:
nBlockMaxSize = GetArg("-blockmaxsize", MAX_BLOCK_SIZE_GEN/2);
nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE-1000), nBlockMaxSize));
// How much of the block should be dedicated to high-priority transactions,
// included regardless of the fees they pay
nBlockPrioritySize = GetArg("-blockprioritysize", 27000);
nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize);
// Minimum block size you want to create; block will be filled with free transactions
// until there are no more or the block reaches this size:
nBlockMinSize = GetArg("-blockminsize", 0);
nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize);
// Fee-per-kilobyte amount considered the same as "free"
// Be careful setting this: if you set it to zero then
// a transaction spammer can cheaply fill blocks using
// 1-satoshi-fee transactions. It should be set above the real
// cost to you of processing a transaction.
if (mapArgs.count("-mintxfee"))
ParseMoney(mapArgs["-mintxfee"], nMinTxFee);
if (fDebug)
LogPrintf("nMinerSleep %u\n", nMinerSleep);
CheckpointsMode = Checkpoints::STRICT;
std::string strCpMode = GetArg("-cppolicy", "strict");
if (strCpMode == "strict")
CheckpointsMode = Checkpoints::STRICT;
if (strCpMode == "advisory")
CheckpointsMode = Checkpoints::ADVISORY;
if (strCpMode == "permissive")
CheckpointsMode = Checkpoints::PERMISSIVE;
nDerivationMethodIndex = 0;
fTestNet = GetBoolArg("-testnet");
if (!SelectParamsFromCommandLine())
return InitError("Invalid combination of -testnet and -regtest.");
if (GetBoolArg("-thinmode"))
nNodeMode = NT_THIN;
if (fTestNet)
{
SoftSetBoolArg("-irc", true);
}
if (mapArgs.count("-bind"))
{
// when specifying an explicit binding address, you want to listen on it
// even when -connect or -proxy is specified
SoftSetBoolArg("-listen", true);
}
if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0)
{
// when only connecting to trusted nodes, do not seed via DNS, or listen by default
SoftSetBoolArg("-dnsseed", false);
SoftSetBoolArg("-listen", false);
}
if (mapArgs.count("-proxy"))
{
// to protect privacy, do not listen by default if a proxy server is specified
SoftSetBoolArg("-listen", false);
}
if (!GetBoolArg("-listen", true))
{
// do not map ports or try to retrieve public IP when not listening (pointless)
SoftSetBoolArg("-upnp", false);
SoftSetBoolArg("-discover", false);
}
if (mapArgs.count("-externalip"))
{
// if an explicit public IP is specified, do not try to find others
SoftSetBoolArg("-discover", false);
}
if (GetBoolArg("-salvagewallet"))
{
// Rewrite just private keys: rescan to find transactions
SoftSetBoolArg("-rescan", true);
}
if (fTestNet)
{
nStakeMinAge = 1 * 60 * 60; // test net min age is 1 hour
nCoinbaseMaturity = 10; // test maturity is 10 blocks
};
// ********************************************************* Step 3: parameter-to-internal-flags
fDebug = !mapMultiArgs["-debug"].empty();
// Special-case: if -debug=0/-nodebug is set, turn off debugging messages
const std::vector<std::string>& categories = mapMultiArgs["-debug"];
if (GetBoolArg("-nodebug", false) || std::find(categories.begin(), categories.end(), std::string("0")) != categories.end())
fDebug = false;
// -debug implies fDebug*, unless otherwise specified
if (fDebug)
{
SoftSetBoolArg("-debugnet", true);
SoftSetBoolArg("-debugsmsg", true);
SoftSetBoolArg("-debugchain", true);
SoftSetBoolArg("-debugringsig", true);
};
fDebugNet = GetBoolArg("-debugnet");
fDebugSmsg = GetBoolArg("-debugsmsg");
fDebugChain = GetBoolArg("-debugchain");
fDebugRingSig = GetBoolArg("-debugringsig");
fDebugPoS = GetBoolArg("-debugpos");
fNoSmsg = GetBoolArg("-nosmsg");
// Check for -socks - as this is a privacy risk to continue, exit here
if (mapArgs.count("-socks"))
return InitError(_("Error: Unsupported argument -socks found. Setting SOCKS version isn't possible anymore, only SOCKS5 proxies are supported."));
bitdb.SetDetach(GetBoolArg("-detachdb", false));
if (fDaemon)
fServer = true;
else
fServer = GetBoolArg("-server", false);
/* force fServer when running without GUI */
if (!fHaveGUI)
fServer = true;
fPrintToConsole = GetBoolArg("-printtoconsole");
fPrintToDebugLog = SoftSetBoolArg("-printtodebuglog", true);
fLogTimestamps = GetBoolArg("-logtimestamps");
if (mapArgs.count("-timeout"))
{
int nNewTimeout = GetArg("-timeout", 5000);
if (nNewTimeout > 0 && nNewTimeout < 600000)
nConnectTimeout = nNewTimeout;
};
if (mapArgs.count("-paytxfee"))
{
if (!ParseMoney(mapArgs["-paytxfee"], nTransactionFee))
return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s'"), mapArgs["-paytxfee"].c_str()));
if (nTransactionFee > 0.25 * COIN)
InitWarning(_("Warning: -paytxfee is set very high! This is the transaction fee you will pay if you send a transaction."));
};
fConfChange = GetBoolArg("-confchange", false);
fEnforceCanonical = GetBoolArg("-enforcecanonical", true);
if (mapArgs.count("-mininput"))
{
if (!ParseMoney(mapArgs["-mininput"], nMinimumInputValue))
return InitError(strprintf(_("Invalid amount for -mininput=<amount>: '%s'"), mapArgs["-mininput"].c_str()));
};
// ********************************************************* Step 4: application initialization: dir lock, daemonize, pidfile, debug log
// Sanity check
if (!InitSanityCheck())
return InitError(_("Initialization sanity check failed. PerfectCoin is shutting down."));
std::string strDataDir = GetDataDir().string();
std::string strWalletFileName = GetArg("-wallet", "wallet.dat");
// strWalletFileName must be a plain filename without a directory
if (strWalletFileName != fs::basename(strWalletFileName) + fs::extension(strWalletFileName))
return InitError(strprintf(_("Wallet %s resides outside data directory %s."), strWalletFileName.c_str(), strDataDir.c_str()));
// Make sure only a single Bitcoin process is using the data directory.
fs::path pathLockFile = GetDataDir() / ".lock";
FILE* file = fopen(pathLockFile.string().c_str(), "a"); // empty lock file; created if it doesn't exist.
if (file)
fclose(file);
static boost::interprocess::file_lock lock(pathLockFile.string().c_str());
if (!lock.try_lock())
return InitError(strprintf(_("Cannot obtain a lock on data directory %s. PerfectCoin is probably already running."), strDataDir.c_str()));
if (GetBoolArg("-shrinkdebugfile", !fDebug))
ShrinkDebugFile();
LogPrintf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
LogPrintf("PerfectCoin version %s (%s)\n", FormatFullVersion().c_str(), CLIENT_DATE.c_str());
LogPrintf("Operating in %s mode.\n", GetNodeModeName(nNodeMode));
LogPrintf("Using OpenSSL version %s\n", SSLeay_version(SSLEAY_VERSION));
if (!fLogTimestamps)
LogPrintf("Startup time: %s\n", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
LogPrintf("Default data directory %s\n", GetDefaultDataDir().string().c_str());
LogPrintf("Used data directory %s\n", strDataDir.c_str());
std::ostringstream strErrors;
if (fDaemon)
{
fprintf(stdout, "PerfectCoin server starting\n");
fflush(stdout);
};
int64_t nStart;
/* *********************************************************
Step 4.5: adjust parameters for nNodeMode
********************************************************* */
switch (nNodeMode)
{
case NT_FULL:
if (GetBoolArg("-nothinssupport"))
{
LogPrintf("Thin support disabled.\n");
nLocalServices &= ~(THIN_SUPPORT);
};
if (GetBoolArg("-nothinstealth"))
{
LogPrintf("Thin stealth support disabled.\n");
nLocalServices &= ~(THIN_STEALTH);
};
break;
case NT_THIN:
SetBoolArg("-staking", false);
// -- clear services
nLocalServices &= ~(NODE_NETWORK);
nLocalServices &= ~(THIN_SUPPORT);
nLocalServices &= ~(THIN_STAKE);
nLocalServices &= ~(THIN_STEALTH);
nLocalRequirements |= (THIN_SUPPORT);
if (GetBoolArg("-thinfullindex"))
{
LogPrintf("Thin full index enabled.\n");
fThinFullIndex = true;
} else
{
nThinIndexWindow = GetArg("-thinindexmax", 4096);
if (nThinIndexWindow < 4096)
{
LogPrintf("Thin index window minimum size is %d.\n", 4096);
nThinIndexWindow = 4096;
};
LogPrintf("Thin index window size %d.\n", nThinIndexWindow);
};
if (GetBoolArg("-nothinstealth"))
{
LogPrintf("Thin stealth disabled.\n");
} else
{
nLocalRequirements |= (THIN_STEALTH);
};
break;
default:
break;
};
// -- thin and full
if (fNoSmsg)
nLocalServices &= ~(SMSG_RELAY);
if (initialiseRingSigs() != 0)
return InitError("initialiseRingSigs() failed.");
// ********************************************************* Step 5: verify database integrity
uiInterface.InitMessage(_("Verifying database integrity..."));
if (!bitdb.Open(GetDataDir()))
{
std::string msg = strprintf(_("Error initializing database environment %s!"
" To recover, BACKUP THAT DIRECTORY, then remove"
" everything from it except for wallet.dat."), strDataDir.c_str());
return InitError(msg);
};
if (GetBoolArg("-salvagewallet"))
{
// Recover readable keypairs:
if (!CWalletDB::Recover(bitdb, strWalletFileName, true))
return false;
};
if (fs::exists(GetDataDir() / strWalletFileName))
{
CDBEnv::VerifyResult r = bitdb.Verify(strWalletFileName, CWalletDB::Recover);
if (r == CDBEnv::RECOVER_OK)
{
std::string msg = strprintf(_("Warning: wallet.dat corrupt, data salvaged!"
" Original wallet.dat saved as wallet.{timestamp}.bak in %s; if"
" your balance or transactions are incorrect you should"
" restore from a backup."), strDataDir.c_str());
uiInterface.ThreadSafeMessageBox(msg, _("PerfectCoin"), CClientUIInterface::BTN_OK | CClientUIInterface::ICON_WARNING | CClientUIInterface::MODAL);
};
if (r == CDBEnv::RECOVER_FAIL)
return InitError(_("wallet.dat corrupt, salvage failed"));
};
// ********************************************************* Step 6: network initialization
nMaxThinPeers = GetArg("-maxthinpeers", 8);
nBloomFilterElements = GetArg("-bloomfilterelements", 1536);
if (mapArgs.count("-onlynet"))
{
std::set<enum Network> nets;
BOOST_FOREACH(std::string snet, mapMultiArgs["-onlynet"])
{
enum Network net = ParseNetwork(snet);
if (net == NET_UNROUTABLE)
return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet.c_str()));
nets.insert(net);
};
for (int n = 0; n < NET_MAX; n++)
{
enum Network net = (enum Network)n;
if (!nets.count(net))
SetLimited(net);
};
};
