int main(int argc, char **argv)
{
Arguments *args;
Rule *rules;
int rules_number;
int i;
srand(time(NULL));
args = processArguments(argc, argv);
if(args->mode == 0)
{
rules = processRuleFile(args);
for(i=0;i<args->name_number;i++)
{
if(args->name_length<1)
generateName(args->output_file, rules, 3+rand()%6);
else
generateName(args->output_file, rules, args->name_length);
}
}
else if(args->mode == 1)
{
rules = generateRules(args, &rules_number);
writeRules(rules, rules_number, args->output_file);
}
fclose(args->output_file);
return 0;
}
void Game::setUpPlayers(std::vector<GamePlayer*> &gPlayers){
//reset player count
Player::_playerCount = 0;
//Name, money, flags, computer/human
if (_isDemoMode == true) {
//default computer player names...
std::cout << "In setUpPlayers(), before setting up players, player count is " << Player::_playerCount <<std::endl;
while (Player::_playerCount < _numPlayers) { //use iterators instead?
std::string compName = generateName("COMP");
gPlayers.push_back(new AIGamePlayer(compName));//, _MAX_CHARACTERS_FOR_NAME, 500, true));
if (DEBUGGING) {
std::cout << "DEBUG: In game::setUpPlayers, new gameplayer setup...\n" << gPlayers.at(gPlayers.size() -1)->getName(false) << std::endl;
}
}
}
else {
do {
std::string answeryn = getYNFromQuestion("Will this player be human (y/n)?");
if (answeryn == "y") {
std::cout << "Please enter a name upto " << _MAX_CHARACTERS_FOR_NAME << " characters long. Leave blank for default name: " << std::endl;
std::string pName = getAlphaNumInput(_MAX_CHARACTERS_FOR_NAME, true);
//Maybe ask to stop inputting names(for < 5 player games
if (pName.empty())
{
gPlayers.push_back(new GamePlayer());
std::cout << "Players name will be: " << gPlayers.at(gPlayers.size() - 1)->getName(false) << std::endl;
}
else {
//code for non empty names
std::cout << "Player" << Player::_playerCount << " will be ";
gPlayers.push_back(new GamePlayer(pName, _MAX_CHARACTERS_FOR_NAME,500, true));
std::cout << gPlayers.at(gPlayers.size() - 1)->getName(false) << std::endl;
}
}
else { //not a human player
//enter code for computer player init
std::string compName = generateName("COMP");
gPlayers.push_back(new AIGamePlayer(compName));//, _MAX_CHARACTERS_FOR_NAME, 500, true));
}
} while (GamePlayer::_playerCount < _numPlayers);
}
/*
std::cout << "DEBUG: GAME::setUpPlayers" << std::endl;
std::cout << "After adding players in setUpPlayers(), player count is " << Player::_playerCount <<std::endl;
for (auto p: gPlayers) {
std::cout << *p << std::endl;
}
std::cout << "END Debug of GAME::SetupPlayers: SetupPlayers done..." << std::endl;
*/
}
bool task6(const cv::Mat& image) {
int suff = 1;
bool res = true;
for (int i = 0; i < task6c; ++i) {
cv::Mat tmp1, tmp2;
performLowPass(image, tmp1, task6v[i]);
res &= cv::imwrite(PATH + generateName("Task6-", suff++), tmp1);
performHighPass(image, tmp2, task6v[i]);
res &= cv::imwrite(PATH + generateName("Task6-", suff++), tmp2);
}
return res;
}
bool task5(const char* path) {
struct dirent *entry;
DIR *dp;
bool res = true;
int i = 1;
dp = opendir(path);
if (dp == NULL) {
std::cerr << "opendir: Path does not exist or could not be read." << std::endl;
return -1;
}
while ((entry = readdir(dp))) {
struct stat s;
std::string filename(path);
filename += (entry -> d_name);
if (stat(filename.c_str(), &s) == 0) {
if (s.st_mode & S_IFREG) {
cv::Mat image, filtered;
image = cv::imread(filename.c_str(), 1);
filterImage(image, filtered);
res &= cv::imwrite(PATH + generateName("Task5-", i++), filtered);
}
}
}
closedir(dp);
return true;
}
bool RemovableBackend::plug(const QString &devNode, const QString &label)
{
QString name = generateName(devNode);
QString id = generateId(devNode);
if(!m_removableIds.contains(id))
{
Medium *medium = new Medium(id, name);
medium->mountableState(devNode, QString::null, QString::null, false);
QStringList words = QStringList::split(" ", label);
QStringList::iterator it = words.begin();
QStringList::iterator end = words.end();
QString tmp = (*it).lower();
tmp[0] = tmp[0].upper();
QString new_label = tmp;
++it;
for(; it != end; ++it)
{
tmp = (*it).lower();
tmp[0] = tmp[0].upper();
new_label += " " + tmp;
}
medium->setLabel(new_label);
medium->setMimeType("media/removable_unmounted");
m_removableIds.append(id);
return !m_mediaList.addMedium(medium).isNull();
}
return false;
}
MiniWorld::MiniWorld(Planet* p, PlanetFace* pf):
planet(p),
model(1.0f),
tptr(new TrackerPointer<MiniWorld>(this, true)),
face(pf),
origin(face->toplevel->uvertex[0]),
v1(face->toplevel->uvertex[1]-face->toplevel->uvertex[0]),
v2(face->toplevel->uvertex[3]-face->toplevel->uvertex[0]),
x(pf->x*MINIWORLD_W*CHUNK_N),
z(pf->z*MINIWORLD_D*CHUNK_N),
generated(false),
modified(false),
constructionCanceled(false)
{
for(int i=0;i<MINIWORLD_W;i++)
{
for(int j=0;j<MINIWORLD_H;j++)
{
for(int k=0;k<MINIWORLD_D;k++)
{
chunks[i][j][k]=new Chunk(p,this,
x+i*CHUNK_N,
j*CHUNK_N,
z+k*CHUNK_N,
face->toplevel->uvertex[1]-face->toplevel->uvertex[0],
face->toplevel->uvertex[3]-face->toplevel->uvertex[0],
face->toplevel->uvertex[0]);
}
}
}
generateName();
planet->handler.requestContent(new MiniWorldDataRequest(*planet, *this, origin, v1, v2, x, 0, z, p->getNumBlocks(), planet->handler));
}
bool
AGActivities::generateInOutTraffic() {
/**
* outgoing traffic already done by generateTrips():
* people who work out of the city.
* Here are people from outside the city coming to work.
*/
if (myCity->peopleIncoming.empty()) {
return true;
}
if (myCity->cityGates.empty()) {
return false;
}
int num = 1;
std::list<AGAdult>::iterator itA;
for (itA = myCity->peopleIncoming.begin(); itA != myCity->peopleIncoming.end(); ++itA) {
int posi = myCity->statData.getRandomCityGateByIncoming();
std::string nom(generateName(num, "carIn"));
AGTrip wayTrip(myCity->cityGates[posi], itA->getWorkPosition().getPosition(), nom, itA->getWorkPosition().getOpening());
//now we put the estimated time of entrance in the city.
wayTrip.setDepTime(wayTrip.estimateDepTime(wayTrip.getTime(), myCity->statData.speedTimePerKm));
AGTrip retTrip(itA->getWorkPosition().getPosition(), myCity->cityGates[posi], nom, itA->getWorkPosition().getClosing());
trips.push_back(wayTrip);
trips.push_back(retTrip);
++num;
}
return true;
}
void GameObject::createGameObject(const String &name, const String &meshName)
{
mEntity = mSceneMgr->createEntity(generateName(name), meshName);
mSceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
mSceneNode->getUserObjectBindings().setUserAny("GameObject", Any(this));
mSceneNode->attachObject(mEntity);
}
Display::Display(const QString &display, QObject *parent) : QObject(parent),
m_display(display),
m_authenticator(new Authenticator(this)),
m_displayServer(new DisplayServer(this)),
m_socketServer(new SocketServer(this)),
m_greeter(new Greeter(this)) {
// connect signals
connect(m_socketServer, SIGNAL(login(QLocalSocket*,QString,QString,QString)), this, SLOT(login(QLocalSocket*,QString,QString,QString)));
connect(this, SIGNAL(loginFailed(QLocalSocket*)), m_socketServer, SLOT(loginFailed(QLocalSocket*)));
connect(this, SIGNAL(loginSucceeded(QLocalSocket*)), m_socketServer, SLOT(loginSucceeded(QLocalSocket*)));
if (Configuration::instance()->testing) {
// set auth path
m_authPath = "./sddm.auth";
} else {
// create auth dir if not existing
QDir authDir;
authDir.mkpath(Configuration::instance()->authDir());
// set auth path
m_authPath = QString("%1/A%2-%3").arg(Configuration::instance()->authDir()).arg(m_display).arg(generateName(6));
}
// set socket name
m_socket = QString("sddm-%1-%2").arg(m_display).arg(generateName(6));
}
void SceneNodeWrapper::createNode(const std::string& id)
{
if (mParentNode == 0 && mParentObject == 0) {
LOG(ERROR) << "Failed to create node \"" << mObjectId << "\" parent node is not set";
return;
}
if(!mParentNode) {
if(mParentObject->getType() == "node") {
mParentNode = static_cast<SceneNodeWrapper*>(mParentObject)->mNode;
} else {
mParentNode = mSceneManager->getRootSceneNode();
}
}
mObjectId = id;
std::string name = generateName();
if(mNode == 0) {
#if OGRE_VERSION_MAJOR == 2
// TODO: static/dynamic nodes
mNode = mParentNode->createChildSceneNode();
#else
mNode = mParentNode->createChildSceneNode(name);
#endif
LOG(TRACE) << "Creating scene node \"" << name << "\"";
} else {
LOG(TRACE) << "Updating scene node \"" << name << "\"";
}
}
bool SocketServer::start(const QString &displayName) {
// check if the server has been created already
if (m_server)
return false;
QString socketName = QString("sddm-%1-%2").arg(displayName).arg(generateName(6));
// log message
qDebug() << "Socket server starting...";
// create server
m_server = new QLocalServer(this);
// set server options
m_server->setSocketOptions(QLocalServer::UserAccessOption);
// start listening
if (!m_server->listen(socketName)) {
// log message
qCritical() << "Failed to start socket server.";
// return fail
return false;
}
// log message
qDebug() << "Socket server started.";
// connect signals
connect(m_server, SIGNAL(newConnection()), this, SLOT(newConnection()));
// return success
return true;
}
bool Shader::compileShaders()
{
ShaderManager& sm = ShaderManager::getInstance();
bool success = true;;
for (ShaderSourceInfo ssi : _shaderSourceInfoList)
{
ShaderInfo* si;
if(ssi.getFilename().length() > 0)
{
si = sm.loadShader(ssi.getFilename(), ssi.shaderType, ssi.name);
}
else{
si = sm.loadShaderFromSource(ssi.getSource(), ssi.shaderType, ssi.name, ssi.immutable);
}
_shaders.push_back(si);
if(si->glID == 0)
{
success = false;
}
}
if(_name.length() == 0)
{
generateName("AUTO");
}
return success;
}
unitDisplay MashStepTableModel::displayUnit(int column) const
{
QString attribute = generateName(column);
if ( attribute.isEmpty() )
return noUnit;
return (unitDisplay)Brewtarget::option(attribute, noUnit, this->objectName(), Brewtarget::UNIT).toInt();
}
void webcam::saveImage(const void *buff)
{
std::string name = shotsPath + generateName();
FILE * outfile = std::fopen(name.c_str(), "wb");
if(!outfile)
throw std::runtime_error("can't create file " + name);
fwrite (buff , 1 , width*height ,outfile);
std::fclose(outfile);
}
unitScale MashStepTableModel::displayScale(int column) const
{
QString attribute = generateName(column);
if ( attribute.isEmpty() )
return noScale;
return (unitScale)Brewtarget::option(attribute, noScale, this->objectName(), Brewtarget::SCALE).toInt();
}
//===========================================
// Entity::Entity
//
// Construct deep copy.
//===========================================
Entity::Entity(const Entity& copy)
: Asset(internString("Entity")),
m_silent(false),
m_parent(NULL) {
deepCopy(copy);
m_name = generateName();
++m_count;
}
/**
* Generates data section of output asm file.
*/
void CodeGenerator::data(void) {
comment("Data section:");
comment("---------------------------------------------------");
command(".data");
label("callstack:\t.space\t" << 1024*4);
label("datastack:\t.space\t" << 1024*4);
label("dataset:\t.space\t" << 1024*32);
SymbolTable::SymbolRecord *symRec;
// constants processing
std::vector<std::string*> *constants = compiler->symbolTable->getConstants();
for(size_t i=0; i < constants->size(); i++) {
symRec = compiler->symbolTable->getSymbol((*constants)[i], true);
switch(symRec->type) {
case SYM_CHAR:
switch(symRec->value->charVal) {
case '\t':
label(generateName(symRec->key) << ":\t" << ".byte\t" << (int)'\t');
break;
case '\n':
label(generateName(symRec->key) << ":\t" << ".byte\t" << (int)'\n');
break;
case '\'':
label(generateName(symRec->key) << ":\t" << ".byte\t" << (int)'\'');
break;
case '\\':
label(generateName(symRec->key) << ":\t" << ".byte\t" << (int)'\\');
break;
default:
label(generateName(symRec->key) << ":\t" << ".byte\t" << (int) symRec->value->charVal);
break;
}
break;
case SYM_INT:
label(generateName(symRec->key) << ":\t" << ".int\t" << symRec->value->intVal);
break;
case SYM_SHORT:
label(generateName(symRec->key) << ":\t" << ".short\t" << symRec->value->intVal);
break;
case SYM_STRING:
label(generateName(symRec->key) << ":\t" << ".ascii\t\"" << *symRec->value->stringVal << "\\000\"");
break;
default:
break;
}
}
// cleanup
constants->clear();
delete constants;
}
void FileManager::copyFileToFolder(QString originPath, QString originName,QString newPath,QString rename,int digits) {
QFileInfo* info = new QFileInfo(originPath + "/" + originName);
QString name = generateName(newPath,rename,info->completeSuffix(),digits);
copyFileToFolder(originPath,originName, newPath, name);
historyFromPath.push(originPath);
historyFromName.push(originName);
historyToPath.push(newPath);
historyToName.push(name);
historyType.push_back("folder");
delete info;
}
QString NameGenerator::generate(CH_RACE chRace, CH_CLASS chClass)
{
QString fullName;
qsrand(time(0));
for (int i = 0; i < 20; ++i) {
fullName = generateName() + " " +
generateSurname();
qDebug() << fullName;
}
return fullName;
}
GenerateLog::GenerateLog(){
iAdd=0;
NoOfFile = 0;
fileName[iAdd]=generateName();
outFile.open(fileName[iAdd].c_str());
iAdd++;
NoOfFile++;
// outFile.close();
fileNo = 1;
countCh = 0;
LineNo = 1;
iDel=0;
}
QString NameGenerator::generate()
{
QString fullName;
qsrand(time(0));
for (int i = 0; i < 20; ++i) {
fullName = generateName() + " " +
generateSurname();
qDebug() << fullName;
}
return fullName;
}
Display::Display(const int displayId, const int terminalId, QObject *parent) : QObject(parent),
m_displayId(displayId), m_terminalId(terminalId),
m_authenticator(new Authenticator(this)),
m_displayServer(new DisplayServer(this)),
m_socketServer(new SocketServer(this)),
m_greeter(new Greeter(this)) {
m_display = QString(":%1").arg(m_displayId);
// restart display after user session ended
connect(m_authenticator, SIGNAL(stopped()), this, SLOT(stop()));
// restart display after display server ended
connect(m_displayServer, SIGNAL(stopped()), this, SLOT(stop()));
// connect login signal
connect(m_socketServer, SIGNAL(login(QLocalSocket*,QString,QString,QString)), this, SLOT(login(QLocalSocket*,QString,QString,QString)));
// connect login result signals
connect(this, SIGNAL(loginFailed(QLocalSocket*)), m_socketServer, SLOT(loginFailed(QLocalSocket*)));
connect(this, SIGNAL(loginSucceeded(QLocalSocket*)), m_socketServer, SLOT(loginSucceeded(QLocalSocket*)));
// get auth dir
QString authDir = daemonApp->configuration()->authDir();
// use "." as authdir in test mode
if (daemonApp->configuration()->testing)
authDir = QLatin1String(".");
// create auth dir if not existing
QDir().mkpath(authDir);
// set auth path
m_authPath = QString("%1/A%2-%3").arg(authDir).arg(m_display).arg(generateName(6));
// set socket name
m_socket = QString("sddm-%1-%2").arg(m_display).arg(generateName(6));
}
//Function to generate StuffItem randomly
StuffItem* generateWeapon()
{
int price = doRand(100, 1000);
int type = doRand(0,6);
char *name = generateName(type);
int bonusATT = doRand(1,10);
int bonusDEFRel = doRand(1,5);
int bonusDEFAbs = doRand(1,10);
StuffItem* newStuff = stuffItem_ctor(name,price,type,bonusATT,bonusDEFRel,bonusDEFAbs);
return newStuff;
}
bool task3_3(const cv::Mat& image) {
int suff = 1;
bool r = true;
for (int i = 0; i < task3_3c; ++i) {
cv::Mat t1, t2, res;
threshold(image, task3_3v[i], t1);
cv::threshold(image, t2, task3_3v[i], 255, CV_8U);
cv::absdiff(t1, t2, res);
res.push_back(t1);
res.push_back(t2);
r &= cv::imwrite(PATH + generateName("Task3_3-", suff++), res);
}
return r;
}
bool task3_2(const cv::Mat& image) {
int suff = 1;
bool res = true;
for (int i = 0; i < task3_2c; ++i) {
cv::Mat grey(image);
grey.convertTo(grey, CV_32F);
grey /= 255;
cv::pow(grey, task3_2v[i], grey);
grey *= 255;
grey.convertTo(grey, CV_8U);
grey.push_back(image);
res &= cv::imwrite(PATH + generateName("Task3_2-", suff++), grey);
}
return res;
}
bool task3(const cv::Mat& image) {
int i = 1;
cv::Mat tmp;
bool res = true;
for (const double* dp = task3v; dp != task3v + task3c; ++dp) {
std::vector<cv::Mat> channels;
cv::split(image, channels);
for (VMit vmit = channels.begin(); vmit != channels.end(); ++vmit) {
addSaltAndPepper(*vmit, *vmit, *dp, *dp);
}
cv::merge(channels, tmp);
res &= cv::imwrite(PATH + generateName("noize/Task3-", i++), tmp);
}
return res;
}
bool task4(const cv::Mat& image) {
int suff = 1;
cv::Mat tmp;
bool res = true;
for (int i = 0; i < task4c; ++i) {
std::vector<cv::Mat> channels;
cv::split(image, channels);
for (VMit vmit = channels.begin(); vmit != channels.end(); ++vmit) {
addAdditiveNoize(*vmit, *vmit, task4v[2 * i], task4v[2 * i + 1]);
}
cv::merge(channels, tmp);
res &= cv::imwrite(PATH + generateName("noize/Task4-", suff++), tmp);
}
return res;
}
DataTypeEnum<Type>::DataTypeEnum(const Values & values_) : values{values_}
{
if (values.empty())
throw Exception{
"DataTypeEnum enumeration cannot be empty",
ErrorCodes::EMPTY_DATA_PASSED
};
fillMaps();
std::sort(std::begin(values), std::end(values), [] (auto & left, auto & right) {
return left.second < right.second;
});
name = generateName(values);
}
//===========================================
// Entity::Entity
//===========================================
Entity::Entity(long type)
: Asset(internString("Entity")),
m_type(type),
m_silent(false),
m_scale(1.f, 1.f),
m_transl(0.f, 0.f),
m_z(1),
m_rot(0.f),
m_lineWidth(0),
m_parent(NULL) {
// So that no Z values are 'exactly' equal
m_z += 0.1f * static_cast<float32_t>(rand()) / static_cast<float32_t>(RAND_MAX);
m_name = generateName();
++m_count;
}
// Setting the scale should clear any cell-level scaling options
void MashStepTableModel::setDisplayScale(int column, unitScale displayScale)
{
// MashStep* row; //disabled per-cell magic
QString attribute = generateName(column);
if ( attribute.isEmpty() )
return;
Brewtarget::setOption(attribute,displayScale,this->objectName(),Brewtarget::SCALE);
/* disabled cell-specific code
for (int i = 0; i < rowCount(); ++i )
{
row = getMashStep(i);
row->setDisplayScale(noScale);
}
*/
}
