void TatortTendencyParser::readDataFromFile() {
_userRatings.clear();
_episodeRatings.clear();
_detectiveRatings.clear();
Logger::getInstance()->log("reading map 'userRatings' from file ...", LOG_DEBUG);
readMapFromFile(&_userRatings, _userRatingsFilename);
Logger::getInstance()->log("reading map 'episodeRatings' from file ...", LOG_DEBUG);
readMapFromFile(&_episodeRatings, _episodeRatingsFilename);
Logger::getInstance()->log("reading map 'detectiveRatings' from file ...", LOG_DEBUG);
readMapFromFile(&_detectiveRatings, _detectiveRatingsFilename);
Logger::getInstance()->log("reading maps from file done!", LOG_DEBUG);
}
void GameState::serverLoop(bool generateMap, size_t player, std::string username) {
readyClients = 1;
totalClients = stillConnected = player;
if (generateMap)
map = generator->generate(32, 25, 2);
else
readMapFromFile();
mapData = map->printTiles();
auto pos = findFreePosition();
compressedMap = "";
for (int i = 0; i < map->getHeight(); i++)
{
std::string line = "";
for (int j = 0; j < map->getWidth(); j++)
{
line += std::to_string( (unsigned int)mapData[i][j] );
}
compressedMap += line;
}
nameList = new std::set<std::string>();
endpoint = new ip::tcp::endpoint(ip::tcp::v4(), GameState::tcpPort);
acceptor = new ip::tcp::acceptor(service, *endpoint);
socket = new ip::tcp::socket(service);
sessions = new std::vector<std::shared_ptr<ServerSession>>();
entities = new std::vector<std::shared_ptr<Entity>>();
entities->resize(player*3);
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
character = std::make_shared<Entity>(position.x, position.y, this, true, 0);
(*entities)[0] = character;
}
for (auto i = player; i < player * 3; i++)
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
(*entities)[i] = std::make_shared<Entity>(position.x, position.y, this, false, i);
}
sessions->push_back(nullptr);
registerName(username);
vacantPlayers = player - 1;
if (vacantPlayers == 0)
inGame = true;
accept();
service.run();
std::cout << "Finished server thread" << std::endl;
}
void GameState::serverLoop(bool generateMap, size_t player, std::string username) {
yourID = 0;
readyClients = 1;
totalClients = stillConnected = player;
if (generateMap)
map = generator->generate(32, 25, 2);
else
readMapFromFile();
mapData = map->printTiles();
auto pos = findFreePosition();
compressMap();
nameList = new std::set<std::string>();
endpoint = new ip::tcp::endpoint(ip::tcp::v4(), GameState::tcpPort);
acceptor = new ip::tcp::acceptor(service, *endpoint);
socket = new ip::tcp::socket(service);
sessions = new std::vector<std::shared_ptr<ServerSession>>();
entities = new std::vector<std::shared_ptr<Entity>>();
entities->resize( Universal::ENTITY_COUNT );
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
character = std::make_shared<Entity>(position.x, position.y, this, true, 0);
(*entities)[0] = character;
}
for (auto i = player; i < Universal::ENTITY_COUNT; i++)
{
auto position = findFreePosition();
reserveMap(position.x, position.y);
(*entities)[i] = std::make_shared<Entity>(position.x, position.y, this, false, i);
}
sessions->push_back(nullptr);
registerName(username);
vacantPlayers = player - 1;
if (vacantPlayers == 0)
inGame = true;
accept();
service.run();
}
void GameEngine::creatMap()
{
coord.X = 250;
coord.Y = 300;
allocateVertexesHexhagonesHarbors();
readMapFromFile();
calcCoords();
setHexagonsTypes();
setHexagonDices();
setHarborsTypes();
}
ProbabilisticModelPtr TrainVariableLengthInhomogeneousMarkovChain::create(
ProbabilisticModelParameters & parameters, double & loglikelihood,
int & sample_size) const {
ProbabilisticModelParameterValuePtr alphabetpar =
parameters.getMandatoryParameterValue("alphabet");
ProbabilisticModelParameterValuePtr trainingsetpar =
parameters.getMandatoryParameterValue("training_set");
ProbabilisticModelParameterValuePtr cutpar =
parameters.getMandatoryParameterValue("cut");
ProbabilisticModelParameterValuePtr lengthpar =
parameters.getMandatoryParameterValue("length");
ProbabilisticModelParameterValuePtr phasedpar =
parameters.getMandatoryParameterValue("phased");
ProbabilisticModelParameterValuePtr maxorderpar =
parameters.getMandatoryParameterValue("maxorder");
ProbabilisticModelParameterValuePtr weightspar =
parameters.getMandatoryParameterValue("weights");
if ((alphabetpar == NULL) || (trainingsetpar == NULL)
|| (lengthpar == NULL) || (cutpar == NULL) || (phasedpar == NULL)) {
std::cerr << help() << std::endl;
exit(-1);
}
std::map <std::string, double> weights;
if(weightspar != NULL) {
readMapFromFile(weights, weightspar->getString());
}
AlphabetPtr alphabet = AlphabetPtr(new Alphabet());
alphabet->initializeFromVector(alphabetpar ->getStringVector());
SequenceEntryList sample_set;
readSequencesFromFile(sample_set, alphabet, trainingsetpar->getString());
double cut = cutpar->getDouble();
int length = lengthpar->getInt();
std::vector<ContextTreePtr> positional_distribution;
int phased = phasedpar->getInt();
positional_distribution.resize(length);
sample_size = 0;
int order = maxorderpar->getInt();
for (int i = 0; i < length; i++) {
SequenceEntryList positionalSample;
for(int j = 0; j < (int)sample_set.size(); j++)
{
int nseq = 0;
std::string name = sample_set[j]->getName();
while(true)
{
int start = (length) * nseq - order + i;
if(start < 0) {
nseq++;
continue;
}
int end = (length) * nseq + i;
if(end >= (int)(sample_set[j]->getSequence()).size())
break;
Sequence s;
for(int k = start; k <= end; k++)
s.push_back((sample_set[j]->getSequence())[k]);
SequenceEntryPtr entry = SequenceEntryPtr (new SequenceEntry(alphabet));
entry->setSequence(s);
entry->setName(name);
positionalSample.push_back(entry);
nseq++;
}
}
#if 0
int o = i;
for (int j = 0; j < (int) sample_set.size(); j++) {
if(!phased) {
Sequence s;
s.resize(o + 1);
int l = 0;
int m = i - o;
if (m < 0)
m = 0;
while ((m < (int) (sample_set[j]->getSequence()).size()) && (l <= o)) {
s[l] = (sample_set[j]->getSequence())[m];
l++;
m++;
}
SequenceEntryPtr entry = SequenceEntryPtr (new SequenceEntry(alphabet));
entry->setSequence(s);
positionalSample.push_back(entry);
} else {
o = int(log( (double) (sample_set[j]->getSequence()).size()));
int m = i - o;
if(m < 0) { m = 0; o = o -i;}
int last_m = m;
while((m < (int) (sample_set[j]->getSequence()).size())) {
Sequence s;
s.resize(o+1);
int l = 0;
while ((m < (int) (sample_set[j]->getSequence()).size()) && (l <= o)) {
s[l] = (sample_set[j]->getSequence())[m];
l++;
m++;
}
m = last_m + length;
last_m = m;
SequenceEntryPtr entry = SequenceEntryPtr (new SequenceEntry(alphabet));
entry->setSequence(s);
positionalSample.push_back(entry);
}
}
}
#endif
ContextTreePtr tree = ContextTreePtr(new ContextTree(alphabet));
tree->initializeCounter(positionalSample, order, 1, weights);
tree->pruneTreeSmallSampleSize(400);
tree->pruneTree(cut);
tree->normalize();
positional_distribution[i] = tree;
}
InhomogeneousMarkovChainPtr model = InhomogeneousMarkovChainPtr(new InhomogeneousMarkovChain());
model->setPositionSpecificDistribution(positional_distribution);
model->setAlphabet(alphabet);
model->phased(phased);
loglikelihood = 0.0;
for (int j = 0; j < (int) sample_set.size(); j++) {
sample_size += (sample_set[j]->getSequence()).size();
loglikelihood += model->evaluate((sample_set[j]->getSequence()), 0, (sample_set[j]->getSequence()).size()
- 1);
}
return model;
}
