// Write out conversations to entity keyvals
void ConversationEntity::writeToEntity() {
// Try to convert the weak_ptr reference to a shared_ptr
Entity* entity = Node_getEntity(_entityNode.lock());
assert(entity != NULL);
// greebo: Remove all conversation-related spawnargs first
clearEntity(entity);
for (ConversationMap::const_iterator i = _conversations.begin();
i != _conversations.end();
++i)
{
// Obtain the conversation and construct the key prefix from the index
const Conversation& conv = i->second;
std::string prefix = "conv_" + string::to_string(i->first) + "_";
// Set the entity keyvalues
entity->setKeyValue(prefix + "name", conv.name);
entity->setKeyValue(prefix + "actors_must_be_within_talkdistance",
conv.actorsMustBeWithinTalkdistance ? "1" : "0");
entity->setKeyValue(prefix + "talk_distance", string::to_string(conv.talkDistance));
entity->setKeyValue(prefix + "actors_always_face_each_other_while_talking",
conv.actorsAlwaysFaceEachOther ? "1" : "0");
entity->setKeyValue(prefix + "max_play_count", string::to_string(conv.maxPlayCount));
// Write the actor list
for (Conversation::ActorMap::const_iterator a = conv.actors.begin();
a != conv.actors.end(); ++a)
{
std::string actorKey = prefix + "actor_" + string::to_string(a->first);
entity->setKeyValue(actorKey, a->second);
}
// Write all the commands
for (Conversation::CommandMap::const_iterator c = conv.commands.begin();
c != conv.commands.end(); ++c)
{
std::string cmdPrefix = prefix + "cmd_" + string::to_string(c->first) + "_";
try {
const ConversationCommandInfo& cmdInfo =
ConversationCommandLibrary::Instance().findCommandInfo(c->second->type);
entity->setKeyValue(cmdPrefix + "type", cmdInfo.name);
entity->setKeyValue(cmdPrefix + "actor", string::to_string(c->second->actor));
entity->setKeyValue(cmdPrefix + "wait_until_finished", c->second->waitUntilFinished ? "1" : "0");
for (ConversationCommand::ArgumentMap::const_iterator a = c->second->arguments.begin();
a != c->second->arguments.end(); ++a)
{
entity->setKeyValue(cmdPrefix + "arg_" + string::to_string(a->first), a->second);
}
}
catch (std::runtime_error e) {
rError() << "Unrecognised conversation command ID: " << c->second->type << std::endl;
}
}
}
}
void setGhost(Entity ** matrix, Entity * buffer, int y)
{
#pragma omp parallel for
for (int i = 0; i < SIZEX + 2; i++)
{
copyEntity(&matrix[i][y], &buffer[i]);
clearEntity(&matrix[i][y]);
}
}
// Write out Objectives to entity keyvals
void ObjectiveEntity::writeToEntity()
{
UndoableCommand cmd("saveObjectives");
// Try to convert the weak_ptr reference to a shared_ptr
Entity* entity = Node_getEntity(_entityNode.lock());
assert(entity != NULL);
// greebo: Remove all objective-related spawnargs first
clearEntity(entity);
for (ObjectiveMap::const_iterator i = _objectives.begin();
i != _objectives.end();
++i)
{
// Obtain the Objective and construct the key prefix from the index
const Objective& o = i->second;
std::string prefix = "obj" + string::to_string(i->first) + "_";
// Set the entity keyvalues
entity->setKeyValue(prefix + "desc", o.description);
entity->setKeyValue(prefix + "ongoing", o.ongoing ? "1" : "0");
entity->setKeyValue(prefix + "visible", o.visible ? "1" : "0");
entity->setKeyValue(prefix + "mandatory", o.mandatory ? "1" : "0");
entity->setKeyValue(prefix + "irreversible",
o.irreversible ? "1" : "0");
entity->setKeyValue(prefix + "state", string::to_string(o.state));
// Write an empty "objN_difficulty" value when this objective applies to all levels
entity->setKeyValue(prefix + "difficulty", o.difficultyLevels);
entity->setKeyValue(prefix + "enabling_objs", o.enablingObjs);
entity->setKeyValue(prefix + "script_complete", o.completionScript);
entity->setKeyValue(prefix + "script_failed", o.failureScript);
entity->setKeyValue(prefix + "target_complete", o.completionTarget);
entity->setKeyValue(prefix + "target_failed", o.failureTarget);
entity->setKeyValue(prefix + "logic_success", o.logic.successLogic);
entity->setKeyValue(prefix + "logic_failure", o.logic.failureLogic);
// Write the Components for this Objective
writeComponents(entity, prefix, o);
}
// Export the mission success/failure logic
writeMissionLogic(*entity);
// Export objective conditions
writeObjectiveConditions(*entity);
}
/**
* Envoie une entité tant que sont état n'est pas final.
* @param game L'état du jeu
* @param hero Le héros
* @param entity L'entité à envoyer
* @param board Le plateau de jeu
*/
void throwEntity(GameState* game, Eceman* hero, Entity* entity, char board[ROWS][COLS]) {
unsigned int i;
i = 0;
while (entity->state != FINAL) {
i++;
if (i % 20000000 != 0)
continue;
clearEntity(board, entity);
moveEntity(game, hero, entity, board);
drawEntity(board, entity);
}
}
void GameBoard::handleBulletCollision( int x, int y, int x_step, int y_step, bool playerType )
{
ZZTEntity ent = entity( x, y );
if ( playerType )
{
switch( ent.id() ) {
case ZZTEntity::Object:
// send :shot message
break;
case ZZTEntity::Breakable:
case ZZTEntity::Gem:
clearEntity( x, y );
musicStream()->playEvent( AbstractMusicStream::Breakable );
break;
case ZZTEntity::Bear:
case ZZTEntity::Ruffian:
case ZZTEntity::Slime:
case ZZTEntity::Shark:
case ZZTEntity::Lion:
case ZZTEntity::Tiger:
case ZZTEntity::CentipedeHead:
case ZZTEntity::CentipedeSegment:
deleteThing( ent.thing() );
musicStream()->playEvent( AbstractMusicStream::KillEnemy );
break;
default: break;
}
}
else
{
switch( ent.id() ) {
case ZZTEntity::Player:
// hurt player
break;
default: break;
}
}
}
int main(int argc, char **argv)
{
int threadsLimit = 0;
int c;
while ((c = getopt (argc, argv, "n:t")) != -1)
{
switch (c)
{
case 'n':
threadsLimit = atoi(optarg);
break;
case 't':
benchmark = true;
break;
default:
;
}
}
if (threadsLimit) {
omp_set_dynamic(0);
omp_set_num_threads(threadsLimit);
}
clock_t start;
start = clock();
bool *locks = (bool *)malloc((SIZEX + 2) * sizeof(bool));
for (int i = 0; i < SIZEX + 2; i++)
locks[i] = false;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
initRandom(0, rank);
Entity **matrix_a = createMatrix(SIZEX + 2, SIZEY + 2);
Entity **matrix_b = createMatrix(SIZEX + 2, SIZEY + 2);
initMatrix(matrix_a, SIZEX, SIZEY);
MPI_Type_contiguous(sizeof(Entity), MPI_BYTE, &cell_t);
MPI_Type_commit(&cell_t);
MPI_Type_vector(SIZEX + 2, 1, 1, cell_t, &row_t);
MPI_Type_commit(&row_t);
MPI_Type_contiguous(sizeof(Counter), MPI_BYTE, &counter_t);
MPI_Type_commit(&counter_t);
Entity * northBuffer = (Entity *) malloc((SIZEX + 2) * sizeof(Entity));
Entity * southBuffer = (Entity *) malloc((SIZEX + 2) * sizeof(Entity));
if (!benchmark) {
// update local counter and sync
updateCounter(matrix_a);
syncCounter();
printHeader(rank);
printCSV(0, rank);
}
for (int n = 0; n < STEPS; n++)
{
// set adjacent borders
if (rank == NORTH)
{
MPI_Recv(northBuffer, 1, row_t, SOUTH, TAG, MPI_COMM_WORLD, &status);
setBorder(northBuffer, matrix_a, SIZEY+1);
setBuffer(matrix_a, northBuffer, SIZEY);
MPI_Send(northBuffer, 1, row_t, SOUTH, TAG, MPI_COMM_WORLD);
}
if (rank == SOUTH)
{
setBuffer(matrix_a, southBuffer, 1);
MPI_Send(southBuffer, 1, row_t, NORTH, TAG, MPI_COMM_WORLD);
MPI_Recv(southBuffer, 1, row_t, NORTH, TAG, MPI_COMM_WORLD, &status);
setBorder(southBuffer, matrix_a, 0);
}
#pragma omp parallel for default(none) shared(matrix_a, matrix_b, n, locks) schedule(static, SIZEX/omp_get_max_threads())
for (int i = 1; i <= SIZEX; i++)
{
lock(i, locks);
#pragma omp parallel for
for (int j = 1; j <= SIZEY; j++)
process(matrix_a, matrix_b, i, j);
unlock(i, locks);
}
// merge adjacent border
if (rank == NORTH)
{
MPI_Recv(northBuffer, 1, row_t, SOUTH, TAG, MPI_COMM_WORLD, &status);
mergeGhost(northBuffer, matrix_b, SIZEY);
setGhost(matrix_b, northBuffer, SIZEY+1);
MPI_Send(northBuffer, 1, row_t, SOUTH, TAG, MPI_COMM_WORLD);
}
if (rank == SOUTH)
{
setGhost(matrix_b, southBuffer, 0);
MPI_Send(southBuffer, 1, row_t, NORTH, TAG, MPI_COMM_WORLD);
MPI_Recv(southBuffer, 1, row_t, NORTH, TAG, MPI_COMM_WORLD, &status);
mergeGhost(southBuffer, matrix_b, 1);
}
// clear original adjacent border in matrix_a
for (int i = 0; i < SIZEX + 2; i++)
clearEntity(&matrix_a[i][rank == NORTH ? SIZEY + 1 : 0]);
//some times it can not move back, then stay in the border
transferInBorder(matrix_a, matrix_b);
moveBackInBorder(matrix_b);
// swap matrixes
Entity **matrix_t = matrix_a;
matrix_a = matrix_b;
matrix_b = matrix_t;
if (!benchmark)
{
updateCounter(matrix_a);
syncCounter();
printCSV(n+1, rank);
}
}
if (benchmark)
printf("Thread: %d, Time: %f sec\n", omp_get_max_threads(), (double)(clock() - start) / CLOCKS_PER_SEC);
destroyMatrix(matrix_a);
destroyMatrix(matrix_b);
free(northBuffer);
free(southBuffer);
MPI_Finalize();
return 0;
}
void ComponentLibrary::clearEntity(ex::Entity e, T first, Args... args) {
if (e.has_component<T>()) {
e.remove<T>();
}
clearEntity(e, args...);
}
