コード例 #1
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
TEST(ProcreationTests, SimpleProcreationTest)
{
    bug_list.clear();

    for (int i = 0; i < 10; i++)
    {
        // The provided code has "if (...health > REPRODUCE_HEALTH) instead of >=
        bug_list.push_back(initBug(i, i, rand() % 8, REPRODUCE_HEALTH + 2, i, i + 10));
    }
    initWorld();

    reproduceBugs();

    ASSERT_EQ(bug_list.size(), 20);
    for (int i = 10; i < bug_list.size(); i++)
    {
        auto &bug = bug_list[i];
        ASSERT_EQ(bug.x, i - 10);
        ASSERT_EQ(bug.y, i - 10);
        ASSERT_EQ(bug.dir, bug_list[i - 10].dir);
        ASSERT_EQ(bug.health, REPRODUCE_HEALTH / 2 + 1);
        ASSERT_EQ(bug.generation, i - 9);
        ASSERT_EQ(bug.age, 0);
    }
}
コード例 #2
0
void Simulator::init(Project &prj, BodyFactory &factory){
    initWorld(prj, factory, *this, pairs);
    initRTS(prj, receivers);
    std::cout << "number of receivers:" << receivers.size() << std::endl;
    m_totalTime = prj.totalTime();
    m_logTimeStep = prj.logTimeStep();
    m_kinematicsOnly = prj.kinematicsOnly();

    OpenHRP::CollisionSequence& collisions = state.collisions;

    collisions.length(pairs.size());
    for(size_t colIndex=0; colIndex < pairs.size(); ++colIndex){
        hrp::ColdetLinkPairPtr linkPair = pairs[colIndex];
        hrp::Link *link0 = linkPair->link(0);
        hrp::Link *link1 = linkPair->link(1);
        OpenHRP::LinkPair& pair = collisions[colIndex].pair;
        pair.charName1 = CORBA::string_dup(link0->body->name().c_str());
        pair.charName2 = CORBA::string_dup(link1->body->name().c_str());
        pair.linkName1 = CORBA::string_dup(link0->name.c_str());
        pair.linkName2 = CORBA::string_dup(link1->name.c_str());
    }

    m_nextLogTime = 0;
    appendLog();
}
コード例 #3
0
void TestColliderDetector::onEnter()
{
	CCLayer::onEnter();
	scheduleUpdate();
    
	//! load data
	CCArmatureDataManager::sharedArmatureDataManager()->addArmatureFileInfo("Cowboy.ExportJson");

	//! create armature
	armature = cocos2d::extension::CCArmature::create("Cowboy");
	armature->getAnimation()->play("FireWithoutBullet");
	armature->getAnimation()->setSpeedScale(0.2f);
	armature->setScaleX(-0.2f);
	armature->setScaleY(0.2f);
	armature->setPosition(ccp(CCDirector::sharedDirector()->getVisibleSize().width * 0.2, CCDirector::sharedDirector()->getVisibleSize().height * 0.5));
    
	//! bind armature's frame event to onFrameEvent
	armature->getAnimation()->setFrameEventCallFunc(this, frameEvent_selector(TestColliderDetector::onFrameEvent));
    
	addChild(armature);
    
	//! create armature2
	armature2 = cocos2d::extension::CCArmature::create("Cowboy");
	armature2->getAnimation()->play("Walk");
	armature2->setScaleX(-0.2f);
	armature2->setScaleY(0.2f);
	armature2->setPosition(ccp(CCDirector::sharedDirector()->getVisibleSize().width * 0.8, CCDirector::sharedDirector()->getVisibleSize().height * 0.5));
	addChild(armature2);
	
	//! add a CCPhysicsSprite,will show in FrameEvent
	bullet = CCPhysicsSprite::createWithSpriteFrameName("25.png");
	addChild(bullet);
    
	initWorld();
}
コード例 #4
0
ファイル: lighting.cpp プロジェクト: kbailo/487
void
init(void)
{
  mode = MOVECAM;
  object = TORUS;
  sphere_radius = INITRAD;

  /* Initial camera location and orientation */
  eye_pos0 = XVec4f(2.0, 3.0, 6.0, 1.0);
  gaze_dir0 = XVec4f(-2.0, -3.0, -6.1, 0.0); // c = (0,0,0); g = c - e
  top_dir0 = XVec4f(0.0, 1.0, 0.0, 0.0);
  zNear0 = -0.1;
  zFar0 = -25.0;
  fovy0 = 27.0;
  cam = Camera(eye_pos0, gaze_dir0, top_dir0, zNear0, zFar0, fovy0);

  glClearColor(0.0, 0.0, 0.0, 1.0);
  glMatrixMode(GL_TEXTURE);
  glLoadIdentity();
  glGetDoublev(GL_TEXTURE_MATRIX, cmodview);

  init_properties();
  
  /* YOUR CODE HERE . . .
   * Initialize your lights: some needs to be positioned
   * before viewing transform, others after.
  */
    //initialize eye light
    //glLightfv(lightname,param,value)
    
    glLightfv(EYELIGHT, GL_SPOT_DIRECTION, eyelight_position);
    glLightfv(EYELIGHT, GL_POSITION, eyelight_position);
  setup_view();           // in viewing.cpp
    glLightfv(SUNLIGHT, GL_POSITION, sunlight_position);
    glLightfv(OBJLIGHT, GL_POSITION, objlight_position);
  /* . . . AND/OR HERE */
    //initialize sun light
    
    
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  /* YOUR CODE HERE - enable various other pieces of OpenGL state
   * 1. Depth test, so that OpenGL has a sense of depth (Cf. glEnable())
   * 2. Automatic normalization of normals (Cf. glEnable())
   * 3. Back face culling (Cf. glEnable())
   * 4. Smooth shading of polygons (Cf. glShadeModel())
   * 5. Filled rendering of polygons (Cf. glPolygonMode())
  */
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);
    glEnable(GL_CULL_FACE);
    glShadeModel(GL_SMOOTH);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    
  glColor4f(0.0, 0.0, 1.0, 0.4);
  initWorld(); // TODO in objects.cpp

  return;
}
コード例 #5
0
	void CMazeGameEngine::startNextLevel()
	{
		//TODO: increase level difficulty
		_isNextLevelRequested = false;
		auto mazeDimensions = menu.getChosenMazeDimensions();
		initWorld(mazeDimensions.first, mazeDimensions.second,
			menu.getChosenNumOfAIPlayers(),
			menu.getChosenAIDifficultyLevel());
		setupWorld();
	}
コード例 #6
0
/*******************************************************************************
 * 関数定義
 ******************************************************************************/
int main(int argc, char *argv[])
{
	struct World world;
	int result;
	
	initWorld(&world);	// 世界の初期化(パーツ・コマンドリスト生成など)
	setPlayer(&world);	// プレイヤの受付とモンスターの生成
	
	do(judgment(&world, &result) != GAMEOVER) {	// 終了判定
		setCommand(&world);	// 各プレイヤからコマンドを受け付ける
		runAttack(&world);	// コマンドの実行
	}
コード例 #7
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
/* Makes sure bugs eat the food they move on top of */
TEST(MovementTests, EatingTest)
{
    bug_list.clear();
    bug_list.push_back(initBug(0, 0, 2));
    initWorld();

    world[0][1] = FOOD;
    moveBugs();

    ASSERT_EQ(world[0][1], 0);
    ASSERT_EQ(bug_list.size(), 1);
    ASSERT_EQ(bug_list[0].health, START_HEALTH + EAT_HEALTH - MOVE_HEALTH);
}
コード例 #8
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
TEST(BugKillingTests, SimpleBugKillingTest)
{
    bug_list.clear();
    bug_list.push_back(initBug(0, 0, 2, MOVE_HEALTH));
    bug_list.push_back(initBug(0, 0, 4, MOVE_HEALTH * 2));
    initWorld();

    moveBugs();
    killDeadBugs();

    ASSERT_EQ(bug_list.size(), 1);
    ASSERT_EQ(world[0][0], EMPTY);
    ASSERT_EQ(world[0][1], EMPTY);
    ASSERT_EQ(world[1][0], 0);
}
コード例 #9
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
TEST(BugKillingTests, NoSkipBugKillingTest) {
	bug_list.clear();
	bug_list.push_back(initBug(0, 0, NORTH, MOVE_HEALTH));
	bug_list.push_back(initBug(0, 0, SOUTH, MOVE_HEALTH));
	bug_list.push_back(initBug(0, 0, WEST, MOVE_HEALTH * 2));
	initWorld();

	moveBugs();
	killDeadBugs();

	ASSERT_EQ(bug_list.size(), 1);
	ASSERT_EQ(world[0][0], EMPTY);
	ASSERT_EQ(world[WORLD_SIZE-1][0], EMPTY);
	ASSERT_EQ(world[1][0], EMPTY);
	ASSERT_EQ(world[0][WORLD_SIZE-1], 0);
}
コード例 #10
0
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !CCLayer::init() )
    {
        return false;
    }
	this->screenSize = CCDirector::sharedDirector()->getVisibleSize();
 
	this->down_bar = NULL;
	score = 0;
	this->Xdownbar = 0;
	this->Xbird = 0;
	barTag = 0;

	//加载PLIST
	this->cache = CCSpriteFrameCache::sharedSpriteFrameCache();
	this->cache->addSpriteFramesWithFile("flappy_packer.plist","flappy_packer.png");


	CCSprite *startgame = CCSprite::createWithSpriteFrameName("getready.png");
	startgame->setPosition(ccp(this->screenSize.width/2,this->screenSize.height/2+300));
	addChild(startgame,1);


	//CCMenuItemImage *startgameItemImage = CCMenuItemImage::create("start.png","start.png",this,menu_selector(HelloWorld::gameEndCallback));
	CCMenuItemSprite  *startgameItemImage = CCMenuItemSprite::create(CCSprite::createWithSpriteFrameName("start.png"),
		CCSprite::createWithSpriteFrameName("start.png"),this,menu_selector(HelloWorld::gameEndCallback));
	CCMenu* menu = CCMenu::create(startgameItemImage,NULL);
	addChild(menu,1);

	CocosDenshion::SimpleAudioEngine::sharedEngine()->preloadEffect("mp3/fly.mp3");
	 CocosDenshion::SimpleAudioEngine::sharedEngine()->preloadEffect("mp3/dead.wav");
	 CocosDenshion::SimpleAudioEngine::sharedEngine()->preloadEffect("mp3/score.mp3");

	initWorld();

	addBg();
	addGround(123);
	addBrid();
	gameend = false;
	ispass = false;

	//scheduleOnce(schedule_selector(HelloWorld::startGame),1);
	return true;
}
コード例 #11
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
TEST(BugKillingTests, RemoveLastBugIfDead) {
	bug_list.clear();
	bug_list.push_back(initBug(0, 0, EAST, 0));
	bug_list.push_back(initBug(0, 1, EAST, MOVE_HEALTH * 3));
	bug_list.push_back(initBug(0, 2, EAST, MOVE_HEALTH * 3));
	bug_list.push_back(initBug(0, 3, EAST, 0));
	initWorld();

	moveBugs();
	killDeadBugs();

	ASSERT_EQ(bug_list.size(), 2);
	ASSERT_EQ(world[0][1], EMPTY);
	ASSERT_GE(world[0][2], 0);
	ASSERT_GE(world[0][3], 0);
	ASSERT_EQ(world[0][4], EMPTY);
}
コード例 #12
0
ファイル: world.cpp プロジェクト: Arc0re/deviant
World::World():
	gen(rd()),
	dis(0, 1),
	chanceStartAlive(0.4f),
    birthLimit(4),
	deathLimit(3),
	steps(3)
{
	Debug::print("Chances", chanceStartAlive);
	Debug::print("Birth limit", birthLimit);
	Debug::print("Death limit", deathLimit);

	initWorld();
	for (int i = 1; i <= steps; ++i) {
		doSimulationStep();
		Debug::print("Generation step", i);
	}
}
コード例 #13
0
ファイル: game.c プロジェクト: tversteeg/7DRL-2016
void runGame()
{
	hideCursor();

	initWorld();

	unsigned long curtime = ccTimeMilliseconds();
	double acctime = 0.0;

	while(true){
		ccEvent event = updateWindow();
		if(event.type == CC_EVENT_WINDOW_QUIT){
			break;
		}else if(event.type == CC_EVENT_KEY_DOWN){
			handleKeyDownWorld(event.keyCode);
		}else if(event.type == CC_EVENT_KEY_UP){
			handleKeyUpWorld(event.keyCode);
		}

		unsigned long newtime = ccTimeMilliseconds();
		double frametime = (newtime - curtime) * 0.001;
		curtime = newtime;

		if(frametime > FRAME_CAP){
			frametime = FRAME_CAP;
		}
		acctime += frametime;

		bool redraw = false;
		while(acctime >= FRAME_DELTA){
			acctime -= FRAME_DELTA;
			redraw = updateWorld();
		}

		if(redraw){
			renderWorld(2, 1, getWidth() - getGuiWidth() - 3, getHeight() - 8);
			renderGui(getWidth() - getGuiWidth(), 0);
		}
		renderWindow(2);
		
	}
}
コード例 #14
0
void HelloWorld::startGame( float dt)
{
	delete this->world;
	this->score = 0;
	this->down_bar = NULL;
	this->Xdownbar = 0;
	this->Xbird = 0;
	barTag = 0;
	barArray[0]=false;
	barArray[1]=false;

	isTouch = false;
	gameend = false;

	removeAllChildren();

	setTouchEnabled(true);
	
	initWorld();


	CCLabelAtlas* label2 = CCLabelAtlas::create("0123456789", "1.png", 17, 22, '0');
	addChild(label2, 1, 9);
	label2->setPosition(ccp(this->screenSize.width/2-30,this->screenSize.height/2+360));
	//label2->setColor(ccWHITE);
	label2->setScale(4);
	char string[12] = {0};
	sprintf(string,"%d",this->score);
	label2->setString(string);

	scheduleUpdate();
	schedule(schedule_selector(HelloWorld::addBar),1);
	//scheduleOnce(schedule_selector(HelloWorld::addBar),1);

	addBg();
	addGround(123);
	addBrid();
	addBarContainer();


}
コード例 #15
0
ファイル: HelloWorldScene.cpp プロジェクト: joyfish/code
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !CCLayer::init() )
    {
        return false;
    }
    
    screenSize = CCDirector::sharedDirector()->getVisibleSize();
    
    initWorld();
    addBarContainer();
    addBird();
    addGround();
    setTouchEnabled(true);
    startGame();
    
    
    return true;
}
コード例 #16
0
ファイル: Main.c プロジェクト: kursion/glThunderhawk
// Initialisation
void init(void)
{

    // GL modes
    glEnable(GL_DEPTH_TEST);

    // Couleur d'arrière plan en gris foncé
    glClearColor(0, 0, 0, 0);

    // Mode d'observation
    glMatrixMode(GL_MODELVIEW);

    // Matrice identitée
    glLoadIdentity();

    // Placement de l'observateur (camera)
    gluLookAt(obsX, obsY, obsZ, tarX, tarY, tarZ, repX, repY, repZ);

 	// Init World
 	initWorld();
}
コード例 #17
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
/* Makes sure bugs move properly in all directions */
TEST(MovementTests, SimpleMovementTest)
{
    bug_list.clear();

    for (int i = 0; i < 8; i++)
    {
        Bug b = initBug(0, 0, i);
        bug_list.push_back(b);
    }
    initWorld();

    moveBugs();
    ASSERT_EQ(bug_list.size(), 8);
    ASSERT_EQ(world[0][0], EMPTY);

    int i = 0;
    for (auto &bug : bug_list)
    {
        ASSERT_EQ(bug.x, newX(0, i));
        ASSERT_EQ(bug.y, newY(0, i));
        ASSERT_EQ(world[bug.x][bug.y], i++);
    }
}
コード例 #18
0
ファイル: view.c プロジェクト: LokiW/Gnomish
void initialize (int argc, char **argv) {
 
    //Initialize model
    initPlayer();
    initWorld();

    //Initialize GLUT
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(300,300);
    
    //Create a window with rendering context and everything else we need
    glutCreateWindow("Intro");
    glClearColor(0.0,0.0,0.0,0.0);
 
    //Assign the two used Msg-routines
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyPress);

    //Let GLUT get the msgs
    glutMainLoop();
}
コード例 #19
0
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    //////////////////////////////
    // 1. super init first
    if ( !CCLayer::init() )
    {
        return false;
    }
    
    ////////////////////////////////////////////////////
    // 下面添加创建自己的Sprite的代码
    ////////////////////////////////////////////////////
    
    mScreenSize = CCDirector::sharedDirector()->getVisibleSize();
    initWorld();
    addBird();
    addBarContainer();
    
    setTouchEnabled(true);
    
    scheduleOnce(schedule_selector(HelloWorld::startGame), 3);
    
    return true;
}
コード例 #20
0
ファイル: main.cpp プロジェクト: lemonade512/EE312
/* Makes sure bugs update their direction properly for all directions */
TEST(MovementTests, SimpleDirectionTest)
{
    bug_list.clear();

    for (int i = 0; i < 8; i++)
    {
        Bug b = initBug(0, 0, 0);
        memset(b.genes, 0, ARRAYSIZE(b.genes));
        b.genes[i] = GENE_TOTAL;

        bug_list.push_back(b);
    }
    initWorld();

    moveBugs();
    ASSERT_EQ(bug_list.size(), 8);

    // Each bug's direction should now be i
    int i = 0;
    for (auto &bug : bug_list)
    {
        ASSERT_EQ(bug.dir, i++);
    }
}
コード例 #21
0
ファイル: client.c プロジェクト: naknut/Project-Puzzle
/**
 * Author: 	 	Joel Denke, Marcus Isaksson
 * Description:		Run the game on client
 */
int main(int argc, char *argv[])
{
	int i, j, no, yb, keysHeld[323] = {0};
	int result = 0;
	SDL_Thread * eventBuffer;
	SDL_Thread * runBuffer;
	struct timer_t2 fps;
	
	char * server_ip = malloc(sizeof(char) * 16);
	char * elem = malloc(sizeof(char) * MESSAGE_SIZE);

	pColor = malloc(sizeof(SDL_Color));
	oColor = malloc(sizeof(SDL_Color));
	connection = malloc(sizeof(connection_data));

	for (i = 0; i < NO_BUFFERS; i++) {
		cb[i] = malloc(sizeof(cBuffer));
		b_lock[i] = SDL_CreateMutex();
	}

	strcpy(server_ip, "127.0.0.1");

	pColor->r = 0;
	pColor->g = 255;
	pColor->b = 255;
	oColor->r = 0;
	oColor->g = 0;
	oColor->b = 255;

	initGraphics();
	initSound();

	printf("Render menu\n");
	graphicsMenu(&gameWorld, server_ip);

	initSlots(cb[0], BUFFER_SIZE);
	initSlots(cb[1], NO_OBJECTS);
	initSlots(cb[2], BUFFER_SIZE);

	state = gStart;

	if (clientConnect(connection, server_ip) == 0)
	{
		eventBuffer = SDL_CreateThread(listenEventBuffer, &connection);

		while (1) {
			switch (state) {
				case gStart:
					runData(2);
					break;
				case gInit:
					timer_start(&fps);
					startDraw();
					drawLoadScr(SCREEN_WIDTH, SCREEN_HEIGHT);
					endDraw();

					initWorld();
					
					if (timer_get_ticks(&fps) < 1000 / FPS)
					{
						//delay the as much time as we need to get desired frames per second
						SDL_Delay( ( 1000 / FPS ) - timer_get_ticks(&fps) );
					}
					break;
				case gRunning :
					timer_start(&fps);
					drawGraphics();
					listenInput(keysHeld);

					// i = 0: players; i = 1: objects; i = 2: messages
					for (i = 0; i < NO_BUFFERS; i++) {
						runData(i);
					}

					if (timer_get_ticks(&fps) < 1000 / FPS)
					{
						//delay the as much time as we need to get desired frames per second
						SDL_Delay( ( 1000 / FPS ) - timer_get_ticks(&fps) );
					}

					break;
				case gExit :
					//sprintf(string, "%d,quit", connection->client_id);
					printf("Freeing music now\n");
					pauseMusic();
					freeMusic();
					end_session(connection);
					printf("Player is exit game now\n");
					exitClient(eventBuffer);
					break;
				default :
					printf("test\n");
					break;
			}
		}
	} else {
		printf("Misslyckade med att kontakta servern på ip-adress: '%s'\n", server_ip);
		state = gExit;
		pauseMusic();
		freeMusic();
		exitClient(eventBuffer);
	}

	return 0;
}
コード例 #22
0
int main(int argc, char **argv) {

    int i, j;
    int x, y, size;
    int w_breeding, s_breeding, w_starvation, gen_num;
    char type_code;
    FILE * input_file;

    w_number = 0;

    if(argc <= 5) {
        printf("ERROR: Expected 5 arguments provided %d.\n", argc);
        printf("Expected:\n./wolves-squirrels-serial <InputFile> <WolfBreedingPeriod> <SquirrelBreedingPeriod> <WolfStarvationPerior> <Generations>\n");
        return -1;
    }

    w_breeding = atoi(argv[2]);
    s_breeding = atoi(argv[3]);
    w_starvation = atoi(argv[4]);
    gen_num = atoi(argv[5]);

    input_file = fopen(argv[1], "r");
    if(input_file == NULL) {
        printf("ERROR: A valid input file is expected. %s is not a valid file.\n", argv[1]);
        return -1;
    }

    fscanf(input_file, "%d", &size);

    initWorld(size);

    while(fscanf(input_file, "%d %d %c", &x, &y, &type_code) != EOF) {
        world[0][x][y].type = type_code;
        world[1][x][y].type = type_code;
        if(world[0][x][y].type == wolf) {
            world[0][x][y].breeding_period = w_breeding;
            world[0][x][y].starvation_period = w_starvation;
        } else if(world[0][x][y].type == squirrel || world[0][x][y].type == squirrel_on_tree) {
            world[0][x][y].breeding_period = s_breeding;
        }
    }



    fclose(input_file);


#ifdef VERBOSE
    printf("INITIAL WORLD - w_number = %d\n", w_number);
    printWorldDetailed(size);
    printf("\n");
#endif

    /* Generate */
    while(gen_num != 0) {
        cleanWorld(size);

        /* 1st sub-generation - RED */
        for(i=0; i<size; i++) {
            for(j = i%2 == 0 ? 0 : 1 ; j<size; j+=2) {
                computeCell(i, j, s_breeding, w_breeding, w_starvation, size);
            }
        }

        /* 2nd sub-generation */
        for(i=0; i<size; i++) {
            for(j = i%2 == 0 ? 1 : 0 ; j<size; j+=2) {
                computeCell(i, j, s_breeding, w_breeding, w_starvation, size);
            }
        }


#ifdef VERBOSE
        printf("\n\nIteration %d:\n", gen_num);
        printWorldDetailed(size);
        printf("\n");
#endif

        gen_num--;
        w_number = (w_number+1) % 2;
    }

    /* Output */
    printWorldFormatted(size);

    return 0;
}
コード例 #23
0
ファイル: itd.c プロジェクト: ACCITD/ITD
int main(int argc,  char* argv[]) {
	int width = 1024, height = 768;
	if(argc == 5 && strcmp(argv[2], "-r") == 0 ){
		width = atoi(argv[3]);
		height = atoi(argv[4]);
	}
	else if(argc == 4 && strcmp(argv[1], "-r") == 0 ){
		width = atoi(argv[2]);
		height = atoi(argv[3]);	
	}
	
	/*Initialisation SDL, OpenGL etc */
	if( initWindow(width, height) == EXIT_FAILURE){
		perror("Impossible d'initialiser la fenêtre SDL, le programme va fermer.\n");
		exit(-1);
	}

	/* initialisation de SDL_TTF*/
	if(TTF_Init()== -1){
		printf("Error loading TTF: %s\n",TTF_GetError());
		exit(1);
	}
	bool askedForQuit = false;
	World world;
	world.towersList = NULL;
	world.map.name = NULL;
	world.map.tabXYConstruct = NULL;
	world.map.image = NULL;
	world.map.pathNodeList = NULL;
	Interface interface;
	interface.lstButtons = NULL;
	char* mapName= NULL;
	BUTTON_OF_MENU.lstMapName = NULL;
	BUTTON_OF_MENU.lstMapButton = NULL;
	BUTTON_OF_MENU.lstMapTextureIndex = NULL;
	bool play = false;
	
	List* lstMaps = createEmptyList();
	readDirectory(lstMaps);
	/* selection d'une carte en ligne de commande*/
	if (argc >= 2 && strcmp(argv[1], "-r") != 0){
		char* curMap = NULL;
		while( (curMap = (char*) nextData(lstMaps)) != NULL){
			if (strcmp(argv[1],curMap)==0){
				mapName = (char*) malloc(strlen(argv[1])*sizeof(char));
				if(mapName == NULL){
					fprintf(stderr, "Erreur fatale : impossible d'allouer la mémoire nécessaire.\n");
					exit(EXIT_FAILURE);
				}
				strcpy(mapName,argv[1]);
				play = true;
				break;	
			}	

		}
		if(! play) fprintf(stderr, "Erreur le nom donné en paramètre ne correspond à aucun fichier map\n");
		
	}
	freeListComplete(lstMaps);
	
/*-------------- GESTION DU MENU --------------------*/
do{

	interface.lstButtons = NULL;

	/* chargement des polices */
	int playIsPush = 0;
	int menuOpen = 0;
	int aideOpen = 0;
	initMenuGraphics();


	/* ouverture du répertoire data */

	while(!play && askedForQuit == false) {
		/* Récupération du temps au début de la boucle */
		Uint32 startTime = SDL_GetTicks();

		/* Placer ici le code de dessin du menu */		
		drawMenu(&menuOpen,&aideOpen,&playIsPush,mapName);

		/* Echange du front et du back buffer : mise à jour de la fenêtre */
		SDL_GL_SwapBuffers();

		/* Renvoie une chaine de caractère contenant le nom
		du fichier ITD choisi par l'utilisateur ou NULL si rien n'a encore été choisi */
		askedForQuit = handleMenuActions(&mapName,&playIsPush, &menuOpen,&aideOpen);

		if(playIsPush == 2) play = true;
		
		/* Calcul du temps écoulé */
		Uint32 elapsedTime = SDL_GetTicks() - startTime;
		/* Si trop peu de temps s'est écoulé, on met en pause le programme */
		if(elapsedTime < FRAMERATE_MILLISECONDS) {
			SDL_Delay(FRAMERATE_MILLISECONDS - elapsedTime);
		}

	}
	

/*-------------- GESTION DU JEU --------------------*/
	bool gameFinished = false;
	//Surtout à appeler APRES avoir initialisé la SDL
	char mapPath[50] = "data/";
	
	
	float width = .15;//10% de largeur
	float height = 1.; //Toute la hauteur
	float positionX = 0.85; //A 90% de la largeur
	float positionY = .0; //A 100% de la hauter
	
	if(!askedForQuit){
		strcat(mapPath, mapName);
		world = initWorld(mapPath);
		initGameGraphics();
		GAME_TEXTURES_ID.MAP_ID = makeTextureFromSurface(world.map.image);

		//Initialisation interface
		interface = initGameInterface(width, height, positionX, positionY);
	
		startWorld(&world);
	}
	while(!gameFinished && !askedForQuit) {
		/* Récupération du temps au début de la boucle */
		Uint32 startTime = SDL_GetTicks();
		
		/* On tente un nouveau cycle de tours de jeu si besoin. Le temps est 
		 géré par la fonction. La plupart du temps plusieurs tours de jeu sont
		 joués d'affilé. */
		worldNewStep(&world);
		

		drawWorld(&world);
		drawInterface(&interface, &world);
		/* Calcul du temps écoulé, si temps < 10 ms, on ne passe pas 
		au tour suivant.
		 */
		Uint32 elapsedTime = SDL_GetTicks() - startTime;
		/* Si trop peu de temps s'est écoulé, on ne dessine rien. */
		if(elapsedTime < FRAMERATE_MILLISECONDS) {

			 /* Echange du front et du back buffer : mise à jour de la fenêtre */
			SDL_GL_SwapBuffers();
      			SDL_Delay(FRAMERATE_MILLISECONDS - elapsedTime);
    			
		}
		
		/* Boucle traitant les evenements */
		askedForQuit = handleGameActions(&world, &interface, &gameFinished);
	}
	play = false;
	mapName = NULL;
	
	cleanWorld(&world);
	cleanInterface(&interface);
	
}while(! askedForQuit);
	/* Liberation des ressources */ 
	cleanExit(&world, &interface);

	return EXIT_SUCCESS;
}
コード例 #24
0
ファイル: Core.cpp プロジェクト: ProjectTB2D/First-Try-Duo
void Core::run() {

    initApp(640,480);
    initWorld("map/bbb.map");
    initView();


while(_app->isOpen()){

    _frameTime = _clockFrame.restart().asSeconds();

    sf::Event Event;
    while (_app->pollEvent(Event)){

            if (Event.type == sf::Event::Closed)
                _app->close();
            //if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::A)){

            //}

            if(Event.type == sf::Event::KeyReleased && Event.key.code == sf::Keyboard::Escape){
				_app->close();
			}

    }

/*    if(lagrefresh.GetElapsedTime() > 0.5){
        sprintf(txt, "%f", 1.f / _app->GetFrameTime());
        texte.SetText(txt);
        lagrefresh.Reset();
    }
*/

    _app->setView(*(g_core->getView()));

    _app->clear();

    // UPDATEWORLD()

    if(_menu->getEtat() != CRAFTER_OFF)
        _menu->update();

    _world->update();

    // RENDERWORLD()

    _world->render();

    // DISOLVE()

    _world->disolve();


    // *** VIEW : DEFAULT ***

    _app->setView(_app->getDefaultView());

    // Display Menu

    if(_menu->getEtat() != CRAFTER_OFF)
        _menu->render();

    // DISPLAY FPS

    sf::Text fpsMessage;
    int FPS;
    ostringstream oss;

    FPS = 1 / _frameTime;
    oss << "FPS : " << FPS;

    fpsMessage.setPosition(50.0f, 100.0f);
    fpsMessage.setColor(sf::Color(255,0,0,255));
    fpsMessage.setString(oss.str());
    fpsMessage.setCharacterSize(14);

    _app->draw(fpsMessage);


    // DISPLAY COMPLETE BUFFER

    _app->display();


}

}
コード例 #25
0
ファイル: wolves-squirrels-mpi.c プロジェクト: 2phost/CPD
int main(int argc, char **argv) {

    int i, j, z;
    int x, y, size;
    int w_breeding, s_breeding, w_starvation, gen_num;
    char type_code;
    char *file_name;
    FILE * input_file;
    double secs;
    int averow, extra, rank, n_processes, offset, rows;
    int mtype, dest, rowsAux, source;
    int aditional, start_line;

    struct world **proc_world;

    MPI_Init (&argc, &argv);
    MPI_Comm_rank (MPI_COMM_WORLD, &rank); //Rank, an integer, is used in MPI to be a process identifier associated with a communicator
    MPI_Comm_size (MPI_COMM_WORLD, &n_processes); //where size is the total number of processes in the MPI_Comm_world.

    /* Processo Master */
    if (rank == MASTER) {
        secs =  MPI_Wtime();

        if(argc <= 5) {
            printf("ERROR: Expected 5 arguments provided %d.\n", argc);
            printf("Expected:\n./wolves-squirrels-serial <InputFile> <WolfBreedingPeriod> <SquirrelBreedingPeriod> <WolfStarvationPerior> <Generations>\n");
            return -1;
        }

        w_breeding = atoi(argv[2]);
        s_breeding = atoi(argv[3]);
        w_starvation = atoi(argv[4]);
        gen_num = atoi(argv[5]);
        input_file = fopen(argv[1], "r");
        if(input_file == NULL) {
            printf("ERROR: A valid input file is expected. %s is not a valid file.\n", argv[1]);
            return -1;
        }

        /* Talvez dê para melhorar */
        fscanf(input_file, "%d", &size);

        initWorld(size);


        while(fscanf(input_file, "%d %d %c", &x, &y, &type_code) != EOF) {
            world_global[x][y].type = type_code;
            if(world_global[x][y].type == wolf) {
                world_global[x][y].breeding_period = w_breeding;
                world_global[x][y].starvation_period = w_starvation;
            } else if(world_global[x][y].type == squirrel) {
                world_global[x][y].breeding_period = s_breeding;
            }
        }

        fclose(input_file);


        /* Envia parcela a cada processo */
        averow = size / n_processes;
        extra = size % n_processes;
        offset = 0;
        mtype = FROM_MASTER;


        for(dest=1; dest<n_processes; dest++) {

            rowsAux = dest <= extra ? averow+1 : averow;
            MPI_Send(&offset, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);
            MPI_Send(&rowsAux, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);
            MPI_Send(&size, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);

            for(i=0; i < rowsAux; i++)
                MPI_Send(world_global[offset+i], sizeof(struct world)*size, MPI_BYTE, dest, mtype, MPI_COMM_WORLD);

            offset = offset + rowsAux;
        }

        proc_world = (struct world**) malloc(sizeof(struct world*)*(averow+1));
        for(i = 0; i < averow+1; i++) {
            proc_world[i] = (struct world*) malloc(sizeof(struct world)*size);
            for(j = 0; j < size; j ++) {
                proc_world[i][j].type = empty;
                proc_world[i][j].count = 0;
                proc_world[i][j].breeding_period = 0;
                proc_world[i][j].starvation_period = 0;
                proc_world[i][j].breed = 0;
                for(z=0; z < 5; z++)
                    world_global[i][j].conflicts[z]=NULL;
            }
        }


        for(i=1; i< averow+1; i++)
            proc_world[i] = world_global[offset+i];

#ifdef MPIVERBOSE
        printf("Distribuição: %lf\n", MPI_Wtime() - secs);
        secs = MPI_Wtime();
#endif
        aditional = 1;
    } else if(rank > 0) {

        mtype = FROM_MASTER;
        source = MASTER;
        MPI_Recv(&offset, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
        MPI_Recv(&rowsAux, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
        MPI_Recv(&size, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);

        proc_world = (struct world**) malloc(sizeof(struct world*)*(rowsAux+aditional));


        if(rank == 1) {
            aditional = 1;
            start_line = 0;
        } else {
            aditional = 2;
            start_line = 1;
        }

        for(i = 0; i < rowsAux+aditional; i++) {
            proc_world[i] = (struct world*) malloc(sizeof(struct world)*size);
            for(j = 0; j < size; j ++) {
                proc_world[i][j].type = empty;
                proc_world[i][j].count = 0;
                proc_world[i][j].breeding_period = 0;
                proc_world[i][j].starvation_period = 0;
                proc_world[i][j].breed = 0;
                for(z=0; z < 5; z++)
                    world_global[i][j].conflicts[z]=NULL;
            }
        }

        for(i = start_line; i < rowsAux+start_line; i++) {
            MPI_Recv(proc_world[i], sizeof(struct world)*size, MPI_BYTE, source, mtype, MPI_COMM_WORLD, &status);
        }
    }


#ifdef VERBOSE
//	start = clock();
#endif

    /* Comum a todos os processos */
    MPI_Bcast(&w_breeding, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&s_breeding, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&w_starvation, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&gen_num, 1, MPI_INT, 0, MPI_COMM_WORLD);




#ifdef MPIVERBOSE
//	printf("Leitura: %lf\n", MPI_Wtime() - secs);
//	secs =  MPI_Wtime();
#endif

    /* Generate */
    MPI_Status	*statuses[2];
    MPI_Request *request[2];
    struct world *worldaux1, *worldaux2;

    //worldaux1 = (struct world*) malloc(sizeof(struct world)*size);
    //worldaux2 = (struct world*) malloc(sizeof(struct world)*size);

    while(gen_num != 0) {

        if(rank == 1) {
            for(i = 0; i < size ; i++) {
                proc_world[rowsAux][i].type = empty;
                proc_world[rowsAux][i].count = 0;
                proc_world[rowsAux][i].breeding_period = 0;
                proc_world[rowsAux][i].starvation_period = 0;
                proc_world[rowsAux][i].breed = 0;
                for(z=0; z < 5; z++)
                    world_global[i][j].conflicts[z]=NULL;
            }
        } else if(rank == MASTER) {
            for(i = 0; i < size ; i++) {
                proc_world[0][i].type = empty;
                proc_world[0][i].count = 0;
                proc_world[0][i].breeding_period = 0;
                proc_world[0][i].starvation_period = 0;
                proc_world[0][i].breed = 0;
                for(z=0; z < 5; z++)
                    world_global[i][j].conflicts[z]=NULL;
            }
        } else {
            for(i = 0; i < size ; i++) {
                proc_world[0][i].type = empty;
                proc_world[0][i].count = 0;
                proc_world[0][i].breeding_period = 0;
                proc_world[0][i].starvation_period = 0;
                proc_world[0][i].breed = 0;
                for(z=0; z < 5; z++)
                    world_global[i][j].conflicts[z]=NULL;
                proc_world[rowsAux][i].type = empty;
                proc_world[rowsAux][i].count = 0;
                proc_world[rowsAux][i].breeding_period = 0;
                proc_world[rowsAux][i].starvation_period = 0;
                proc_world[rowsAux][i].breed = 0;
                for(z=0; z < 5; z++)
                    world_global[i][j].conflicts[z]=NULL;
            }
        }

        for(i = (rank==1? 0 : 1); i< (rank==1 ? rowsAux : rowsAux+1) ; i++) {
            for(j=0; j<size; j++) {
                computeCell(i, j, s_breeding, w_breeding, w_starvation, size, rowsAux+aditional, proc_world, rank);
            }
        }


        /*Enviar a  linha de coisas estranhas para o(s) processo(s) da fronteira */
        if(rank == 1) {
            MPI_Irecv(worldaux1, sizeof(struct world)*size, MPI_BYTE, rank+1, 2, MPI_COMM_WORLD, request[0]);
            MPI_Send(proc_world[rowsAux], sizeof(struct world)*size, MPI_BYTE, (rank+1)%n_processes, rank, MPI_COMM_WORLD);
            MPI_Wait(request[0], statuses[0]);

            /* Juntar aos conflictos*/
            for(i=0; i<size; i++) {
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count] = (conflict*)malloc(sizeof(struct conflicts));
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count]->type = worldaux1[i].type;
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count]->breeding_period = worldaux1[i].breeding_period;
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count]->starvation_period = worldaux1[i].starvation_period;
                proc_world[rowsAux][i].count += 1;
            }
        } else if(rank == MASTER) {
            MPI_Irecv(worldaux1, sizeof(struct world)*size, MPI_BYTE, n_processes-1, n_processes-1, MPI_COMM_WORLD, request[0]);
            MPI_Send(proc_world[averow], sizeof(struct world)*size, MPI_BYTE, n_processes-1, rank, MPI_COMM_WORLD);
            MPI_Wait(request[0], statuses[0]);

            for(i=0; i<size; i++) {
                proc_world[0][i].conflicts[proc_world[0][i].count] = (conflict*)malloc(sizeof(struct conflicts));
                proc_world[0][i].conflicts[proc_world[0][i].count]->type = worldaux1[i].type;
                proc_world[0][i].conflicts[proc_world[0][i].count]->breeding_period = worldaux1[i].breeding_period;
                proc_world[0][i].conflicts[proc_world[0][i].count]->starvation_period = worldaux1[i].starvation_period;
                proc_world[0][i].count += 1;
            }
        } else {
            MPI_Irecv(worldaux1, sizeof(struct world)*size, MPI_BYTE, rank+1%n_processes, rank+1%n_processes, MPI_COMM_WORLD, request[0]);
            MPI_Irecv(worldaux2, sizeof(struct world)*size, MPI_BYTE, rank-1%n_processes, rank-1%n_processes, MPI_COMM_WORLD, request[1]);
            MPI_Send(proc_world[rowsAux], sizeof(struct world)*size, MPI_BYTE, (rank+1)%n_processes, rank, MPI_COMM_WORLD);
            MPI_Send(proc_world[rowsAux], sizeof(struct world)*size, MPI_BYTE, (rank-1)%n_processes, rank, MPI_COMM_WORLD);
            MPI_Wait(request[0], statuses[0]);
            MPI_Wait(request[1], statuses[1]);

            for(i=0; i<size; i++) {
                proc_world[0][i].conflicts[proc_world[0][i].count] = (conflict*)malloc(sizeof(struct conflicts));
                proc_world[0][i].conflicts[proc_world[0][i].count]->type = worldaux1[i].type;
                proc_world[0][i].conflicts[proc_world[0][i].count]->breeding_period = worldaux1[i].breeding_period;
                proc_world[0][i].conflicts[proc_world[0][i].count]->starvation_period = worldaux1[i].starvation_period;
                proc_world[0][i].count += 1;
            }

            for(i=0; i<size; i++) {
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count] = (conflict*)malloc(sizeof(struct conflicts));
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count]->type = worldaux1[i].type;
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count]->breeding_period = worldaux1[i].breeding_period;
                proc_world[rowsAux][i].conflicts[proc_world[rowsAux][i].count]->starvation_period = worldaux1[i].starvation_period;
                proc_world[rowsAux][i].count += 1;
            }
        }

        /* fix do pequeno mundo do processo */
        fixWorld(size, w_starvation, w_breeding, rowsAux, proc_world, rank);

        gen_num--;
    }


    /* Receber tudo no master */

#ifdef VERBOSE
    end = clock();
    printf("Elapsed Time : %lf\n", (double)(end-start) / CLOCKS_PER_SEC);
#endif

    MPI_Finalize();

    /* Output */
    //printWorldFormatted(size);

    return 0;
}
コード例 #26
0
ファイル: init.c プロジェクト: MLton/mlton
int GC_init (GC_state s, int argc, char **argv) {
  char *worldFile;
  int res;

  assert (s->alignment >= GC_MODEL_MINALIGN);
  assert (isAligned (sizeof (struct GC_stack), s->alignment));
  // While the following asserts are manifestly true,
  // they check the asserts in sizeofThread and sizeofWeak.
  assert (sizeofThread (s) == sizeofThread (s));
  assert (sizeofWeak (s) == sizeofWeak (s));

  s->amInGC = TRUE;
  s->amOriginal = TRUE;
  s->atomicState = 0;
  s->callFromCHandlerThread = BOGUS_OBJPTR;
  s->controls.fixedHeap = 0;
  s->controls.maxHeap = 0;
  s->controls.mayLoadWorld = TRUE;
  s->controls.mayPageHeap = FALSE;
  s->controls.mayProcessAtMLton = TRUE;
  s->controls.messages = FALSE;
  s->controls.oldGenSequenceSize = 0x100000;
  s->controls.ratios.copy = 4.0f;
  s->controls.ratios.copyGenerational = 4.0f;
  s->controls.ratios.grow = 8.0f;
  s->controls.ratios.hashCons = 0.0f;
  s->controls.ratios.live = 8.0f;
  s->controls.ratios.markCompact = 1.04f;
  s->controls.ratios.markCompactGenerational = 8.0f;
  s->controls.ratios.nursery = 10.0f;
  s->controls.ratios.ramSlop = 0.5f;
  s->controls.ratios.stackCurrentGrow = 2.0f;
  s->controls.ratios.stackCurrentMaxReserved = 32.0f;
  s->controls.ratios.stackCurrentPermitReserved = 4.0f;
  s->controls.ratios.stackCurrentShrink = 0.5f;
  s->controls.ratios.stackMaxReserved = 8.0f;
  s->controls.ratios.stackShrink = 0.5f;
  s->controls.summary = FALSE;
  s->controls.summaryFile = stderr;
  s->cumulativeStatistics.bytesAllocated = 0;
  s->cumulativeStatistics.bytesCopied = 0;
  s->cumulativeStatistics.bytesCopiedMinor = 0;
  s->cumulativeStatistics.bytesHashConsed = 0;
  s->cumulativeStatistics.bytesMarkCompacted = 0;
  s->cumulativeStatistics.bytesScannedMinor = 0;
  s->cumulativeStatistics.maxBytesLive = 0;
  s->cumulativeStatistics.maxHeapSize = 0;
  s->cumulativeStatistics.maxPauseTime = 0;
  s->cumulativeStatistics.maxStackSize = 0;
  s->cumulativeStatistics.numCardsMarked = 0;
  s->cumulativeStatistics.numCopyingGCs = 0;
  s->cumulativeStatistics.numHashConsGCs = 0;
  s->cumulativeStatistics.numMarkCompactGCs = 0;
  s->cumulativeStatistics.numMinorGCs = 0;
  rusageZero (&s->cumulativeStatistics.ru_gc);
  rusageZero (&s->cumulativeStatistics.ru_gcCopying);
  rusageZero (&s->cumulativeStatistics.ru_gcMarkCompact);
  rusageZero (&s->cumulativeStatistics.ru_gcMinor);
  s->currentThread = BOGUS_OBJPTR;
  s->hashConsDuringGC = FALSE;
  initHeap (s, &s->heap);
  s->lastMajorStatistics.bytesHashConsed = 0;
  s->lastMajorStatistics.bytesLive = 0;
  s->lastMajorStatistics.kind = GC_COPYING;
  s->lastMajorStatistics.numMinorGCs = 0;
  s->savedThread = BOGUS_OBJPTR;
  initHeap (s, &s->secondaryHeap);
  s->signalHandlerThread = BOGUS_OBJPTR;
  s->signalsInfo.amInSignalHandler = FALSE;
  s->signalsInfo.gcSignalHandled = FALSE;
  s->signalsInfo.gcSignalPending = FALSE;
  s->signalsInfo.signalIsPending = FALSE;
  sigemptyset (&s->signalsInfo.signalsHandled);
  sigemptyset (&s->signalsInfo.signalsPending);
  s->sysvals.pageSize = GC_pageSize ();
  s->sysvals.physMem = GC_physMem ();
  s->weaks = NULL;
  s->saveWorldStatus = true;

  initIntInf (s);
  initSignalStack (s);
  worldFile = NULL;

  unless (isAligned (s->sysvals.pageSize, CARD_SIZE))
    die ("Page size must be a multiple of card size.");
  processAtMLton (s, 0, s->atMLtonsLength, s->atMLtons, &worldFile);
  res = processAtMLton (s, 1, argc, argv, &worldFile);
  if (s->controls.fixedHeap > 0 and s->controls.maxHeap > 0)
    die ("Cannot use both fixed-heap and max-heap.");
  unless (s->controls.ratios.markCompact <= s->controls.ratios.copy
          and s->controls.ratios.copy <= s->controls.ratios.live)
    die ("Ratios must satisfy mark-compact-ratio <= copy-ratio <= live-ratio.");
  unless (s->controls.ratios.stackCurrentPermitReserved
          <= s->controls.ratios.stackCurrentMaxReserved)
    die ("Ratios must satisfy stack-current-permit-reserved <= stack-current-max-reserved.");
  /* We align s->sysvals.ram by s->sysvals.pageSize so that we can
   * test whether or not we we are using mark-compact by comparing
   * heap size to ram size.  If we didn't round, the size might be
   * slightly off.
   */
  uintmax_t ram;
  ram = alignMax ((uintmax_t)(s->controls.ratios.ramSlop * (double)(s->sysvals.physMem)),
                  (uintmax_t)(s->sysvals.pageSize));
  ram = min (ram, alignMaxDown((uintmax_t)SIZE_MAX, (uintmax_t)(s->sysvals.pageSize)));
  s->sysvals.ram = (size_t)ram;
  if (DEBUG or DEBUG_RESIZING or s->controls.messages)
    fprintf (stderr, "[GC: Found %s bytes of RAM; using %s bytes (%.1f%% of RAM).]\n",
             uintmaxToCommaString(s->sysvals.physMem),
             uintmaxToCommaString(s->sysvals.ram),
             100.0 * ((double)ram / (double)(s->sysvals.physMem)));
  if (DEBUG_SOURCES or DEBUG_PROFILE) {
    uint32_t i;
    for (i = 0; i < s->sourceMaps.frameSourcesLength; i++) {
      uint32_t j;
      uint32_t *sourceSeq;
      fprintf (stderr, "%"PRIu32"\n", i);
      sourceSeq = s->sourceMaps.sourceSeqs[s->sourceMaps.frameSources[i]];
      for (j = 1; j <= sourceSeq[0]; j++)
        fprintf (stderr, "\t%s\n",
                 s->sourceMaps.sourceNames[
                 s->sourceMaps.sources[sourceSeq[j]].sourceNameIndex
                 ]);
    }
  }
  /* Initialize profiling.  This must occur after processing
   * command-line arguments, because those may just be doing a
   * show-sources, in which case we don't want to initialize the
   * atExit.
   */
  initProfiling (s);
  if (s->amOriginal) {
    initWorld (s);
    /* The mutator stack invariant doesn't hold,
     * because the mutator has yet to run.
     */
    assert (invariantForMutator (s, TRUE, FALSE));
  } else {
    loadWorldFromFileName (s, worldFile);
    if (s->profiling.isOn and s->profiling.stack)
      foreachStackFrame (s, enterFrameForProfiling);
    assert (invariantForMutator (s, TRUE, TRUE));
  }
  s->amInGC = FALSE;
  return res;
}
コード例 #27
0
int main(int argc, char **argv){

	int i, j;	
	int x, y, size;
	int w_breeding, s_breeding, w_starvation, gen_num;
	char type_code;
	FILE * input_file;
	
	if(argc <= 5){
		printf("ERROR: Expected 5 arguments provided %d.\n", argc);
		printf("Expected:\n./wolves-squirrels-serial <InputFile> <WolfBreedingPeriod> <SquirrelBreedingPeriod> <WolfStarvationPerior> <Generations>\n");	
		return -1;
    }
	omp_set_num_threads(4);
	w_breeding = atoi(argv[2]);
	s_breeding = atoi(argv[3]);
	w_starvation = atoi(argv[4]);
	gen_num = atoi(argv[5]);
	
	input_file = fopen(argv[1], "r");
	if(input_file == NULL){
		printf("ERROR: A valid input file is expected. %s is not a valid file.\n", argv[1]);	
		return -1;
	}
		
	fscanf(input_file, "%d", &size);

	initWorld(size);

	while(fscanf(input_file, "%d %d %c", &x, &y, &type_code) != EOF){
		world[x][y].type = type_code;
		if(world[x][y].type == wolf){
			world[x][y].breeding_period = w_breeding;
			world[x][y].starvation_period = w_starvation;
		} else if(world[x][y].type == squirrel){
			world[x][y].breeding_period = s_breeding;
		}
	}
	
	fclose(input_file);

#ifdef VERBOSE
	start = omp_get_wtime();
#endif	

	/* Generate */
	while(gen_num != 0){
#pragma omp parallel sections
{
	#pragma omp section
	{
		/* 1st sub-generation - RED */
		#pragma omp parallel for private(i, j) schedule(guided, size/8)
		for(i=0; i<size; i++){
			for(j = i%2 == 0 ? 0 : 1 ; j<size; j+=2){
				computeCell(i, j, s_breeding, w_breeding, w_starvation, size);
			}		
		}
	}
		
	#pragma omp section
	{
		/* 2nd sub-generation */
		#pragma omp parallel for private(i, j) schedule(guided, size/8)
		for(i=0; i<size; i++){
			for(j = i%2 == 0 ? 1 : 0 ; j<size; j+=2){
				computeCell(i, j, s_breeding, w_breeding, w_starvation, size);
			}
		}
	}
}
		fixWorld(size, w_starvation, w_breeding);

		gen_num--;
	}

#ifdef VERBOSE
	end = omp_get_wtime();
	printf("Elapsed time: %lf\n", end-start); 
#endif
	
	/* Output */
	printWorldFormatted(size);
			
	return 0;
}
コード例 #28
0
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
	//////////////////////////////
	// 1. super init first
	if ( !CCLayer::init() )
	{
		return false;
	}
	mbirdstr.push_back("birdblue");
	mbirdstr.push_back("birdred");
	mbirdstr.push_back("birdyellow");
	mbirdclolor=rand()%100%3;
//	EFFECT_PLAY(true,MUSIC_SWOOSHING);
	//播放背景音乐
	// CocosDenshion::SimpleAudioEngine::sharedEngine()->playBackgroundMusic(MUSIC_JUMP, true);
	////////////////////////////////////////////////////
	// 下面添加创建自己的Sprite的代码
	////////////////////////////////////////////////////

	mScreenSize = CCDirector::sharedDirector()->getWinSize();
	mFPS=CCDirector::sharedDirector()->getAnimationInterval();


	mfac=CCDirector::sharedDirector()->getContentScaleFactor();
	mfax = 320.f/mScreenSize.width;
	//gBardis = 5.f*gUpVelocity/mfac;
	gBardis = mScreenSize.height*2.f/9.0f-5;
	//m_addbartime=mScreenSize.width*mFPS*mfax*1.f/2.f/MOVESPEED-10;
	//m_addbartime=3;
	initWorld();	
	for (int i = 0; i<GBACKGROUNDNUM; i++)
	{
		addBackGround(i);
	}
	int imaxgroundnum=1;
	for (int i = 0; i<imaxgroundnum; i++)
	{
		imaxgroundnum=addGround(i);
	}
	m_ilastground=imaxgroundnum-1;
	CCLOG("m_pLastGround->boundingBox() first x:%f,:%f  ", (m_pGroundVec[m_ilastground])->boundingBox().getMaxX(),
		(m_pGroundVec[m_ilastground])->boundingBox().size.width);
	addStart();
	addTop();
	//addRate();
	//addFlappyBird();

	addBird();
	addScore();
	addGameOver();

	m_pScore->setVisible(false);
	m_pGameOver->setVisible(false);
	this->goReady();
	addBarContainer();

	setTouchEnabled(true);
	myflag=0;
	m_istatus=GETREADY;
	m_bhitbar=false;
	//scheduleOnce(schedule_selector(HelloWorld::startGame), 1);
	this->scheduleUpdate();
	//创建动画
	initAction();
	myangle=0.f;
	return true;
}