C++ GameScene类代码示例

void MapLayer::GoNextStage(int x, int y){
    if(doorCount>10)
        return;
    
    GameScene * par = nullptr;
    
    for(DoorInfo info : doorList){
        if(info.x == x && info.y == y){
            UserDefault::getInstance()->setIntegerForKey("jejeHP", JeJe::GetInstance()->GetHP());
            UserDefault::getInstance()->setBoolForKey("blueKey", JeJe::GetInstance()->HasBlue());
            UserDefault::getInstance()->setBoolForKey("purpleKey", JeJe::GetInstance()->HasPurple());
            UserDefault::getInstance()->setBoolForKey("redKey", JeJe::GetInstance()->HasRed());
            
//            CreatureLayer::GetInstance()->WriteData();
            WriteData();
            
            int stageKind = UserDefault::getInstance()->getIntegerForKey("stageKind");
            int stageIdentity = UserDefault::getInstance()->getIntegerForKey("stageIdentity");
            UserDefault::getInstance()->setIntegerForKey("fromStageKind", stageKind);
            UserDefault::getInstance()->setIntegerForKey("fromStageIdentity", stageIdentity);
            UserDefault::getInstance()->setIntegerForKey("stageKind", info.toKind);
            UserDefault::getInstance()->setIntegerForKey("stageIdentity", info.toIdentity);
            UserDefault::getInstance()->setIntegerForKey("doorNumber", info.number);
            par = (GameScene*)(CreatureLayer::GetInstance()->getParent());
            break;
        }
    }
    if(par)
        par->Reload();
}

int main(int argc, char **argv) {
	srand(time(NULL));
	std::cout << "VECTOR 2048 game\n";
	int cell_size = 80;
	int padding = 15;
	int wsize = cell_size * 4 + 5 * padding;

	GameWindow *window = new GameWindow("2048", wsize, wsize+40, false);
	Camera *camera = new Camera(window->painter());
	GameScene *scene = new GameScene(camera);

	BackgroundLayer * background = new BackgroundLayer(Color(143, 116, 45));
	scene->addEntity(background);

	Board * board = new Board(cell_size, padding);

	scene->addEntity(board);
	scene->addKeyListener(board);

	scene->gameLoop(10);

	delete scene;
	delete window;

	return 0;
}

void ToyLayer::handIn(ToyType type)
{
	static auto deskTopPos = Vec2(230,360);
	auto toyPos = _koala->getPosition()+Vec2(50,-20);
	auto toy = _toies.at(type);
	toy->setPosition(toyPos);
	toy->setVisible(true);
	auto move = MoveTo::create(toyPos.distance(deskTopPos)/300.0f,deskTopPos);
	auto rotate = RotateBy::create(toyPos.distance(deskTopPos)/300.0f,720);
	auto action = toy->runAction(rotate);
	action->setTag(106);
	toy->runAction(Sequence::create(move,CallFunc::create([=](){

		toy->stopAllActions();
		toy->setRotation(0);
		SimpleAudioEngine::getInstance()->stopBackgroundMusic(false);

		GameScene *gameScene = (GameScene*)this->getParent();
		int count = gameScene->getStaticLayer()->getBuyer()->getBuyedToies().size();

		auto secen = PlayToyScene::create(type);
		secen->setToyCount(count);
		Director::getInstance()->pushScene(TransitionFade::create(1.5,secen));
	}),NULL));
}

vector2d<int> Unit::availableTile(Entity* target) {
	GameScene* scene = (GameScene*) (Game::getInstance().currentScene);
	vector2d<int> tile(-1, -1);
	vector<vector2d<int>>* candidates;

	candidates = target->getSurroundingTiles();
	for(int i = 0; i < candidates->size(); i++) {
		if(scene->getEntity(candidates->at(i).X, candidates->at(i).Y) ) {
			candidates->erase(candidates->begin() + i);
			i--;
		}		
	}
	
	float lowest = FLT_MAX;
	for(int i = 0; i < candidates->size(); i++) {
		float distance = candidates->at(i).getDistanceFrom(vector2d<int>(tileX, tileY) );
		if(distance < lowest ) {
			tile = candidates->at(i);
			lowest = distance;
		}
	}

	delete candidates;
	return tile;
}

void Player::Hurt(float amount)
{
	if (amount > 0)
	{
		SimpleAudioEngine::sharedEngine()->playEffect("sounds/hurt.wav");
	}

	GameScene* father = (GameScene*)this->getParent();

	m_currentBloodValue -= amount;

	if (m_currentBloodValue <= 0)
		m_currentBloodValue = 0;
	else if (m_currentBloodValue >= Player_TotalBloodValue)
		m_currentBloodValue = Player_TotalBloodValue;
		
	father->UpdateBloodValue(m_currentBloodValue*1.0/Player_TotalBloodValue);

	if(m_currentBloodValue <= 0)
	{
		Die();
	}
	else
	{
		
	}

	
	

	if(amount == 1)
	{

	}
}

// Start of user code methods
void LoadingScene::render()
{
    VBOScene::render();
    if(thread == NULL)
    {
        thread = new std::thread (initWorld);
        mutex->lock();
    }
    if(mutex->try_lock())
    {
        GameScene* gameScene = new GameScene(Engine::getInstance()->getPlayer());
        gameScene->init();
        
        Engine* engine = Engine::getInstance();
        
        
        gameScene->getDoubleBuffer()->getVertexBuffer()->bind();
        gameScene->getDoubleBuffer()->getIndiceBuffer()->bind();
        
        engine->setScene(gameScene);
        engine->getPlayer()->setFalling(true);
        
        glfwSetInputMode(engine->getWindow(), GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
        
        engine->refresh();

        gameScene->updateIndices();
        
        mutex->unlock();
    }
}

void Unit::moveTo(int desX, int desY)
{
	if(hasMoved) return;
	if(desX == tileX && desY == tileY) return;

	GameScene* scene = (GameScene*)Game::getInstance().currentScene;
	vector<vector2d<int>>* newPath = scene->findPath(vector2d<s32>(tileX, tileY), vector2d<s32>(desX, desY) );
	if(!newPath) return;
	while(newPath->size() > maxDistance) {
		newPath->erase(newPath->begin());
	}

	while(newPath->size() > 0) {
		path.push_back( newPath->at(newPath->size()-1) );
		newPath->pop_back();
	}
	delete newPath;

	
	((GameScene*)scene)->tilesystem.tiles[tileX][tileY]->setEntity(NULL);
	tileX = path[path.size()-1].X;
	tileY = path[path.size()-1].Y;
	((GameScene*)scene)->tilesystem.tiles[tileX][tileY]->setEntity(this);
	hasMoved = true;
}

void TileSprite::addSwammSprite(bool bTumble)
{
	GameScene * gameScene = GameScene::getInstance();
	SwammSprite * pSprite = nullptr;
	int nMarioLevel = GameScene::getInstance()->getMario()->getMarioLevel();
	if (nMarioLevel >= 2)
		pSprite = SwammSprite::createWithSpriteFrameName("object/flower.png", gameScene->getWorld());
	else
		pSprite = SwammSprite::createWithSpriteFrameName("object/swamm.png", gameScene->getWorld());

	b2Fixture * fixture = gameScene->getGameWorld()->CreatePolygonBody(pSprite, getPosition(), b2_dynamicBody);

	b2Filter filter;
	filter.categoryBits = 0x0000;
	filter.maskBits = 0x0080;
	fixture->SetFilterData(filter);
	fixture->SetFriction(0.0f);
	pSprite->getBody()->SetFixedRotation(true);	//禁用旋转
	pSprite->EnableGravity(false);

	pSprite->setCameraMask(2);
	GameScene::getInstance()->getMapLayer()->getTileMap()->addChild(pSprite, 5, GSTag_Swamm);

	//执行动作
	pSprite->runAction(Sequence::create(
		MoveBy::create(0.4f, Vec2(0, bTumble ? -70.0f : 70.0f)),
		CCCallFunc::create(CC_CALLBACK_0(SwammSprite::beginAction, pSprite,
		(nMarioLevel >= 2) ? SwammType_Flower : SwammType_Swamm)),
		nullptr));
}

	static int objectsWithTag(lua_State* L)
	{
		GameScene* scene = checkarg<GameScene*>(L, 1);
		const char* tag = checkarg<const char*>(L, 2);

		// Get list
		auto objList = scene->findObjectsByTag(tag);

		lua_pushcfunction(L, objectIterator);

		// Create Iterator Pair
		if (objList) 
		{
#ifdef ITERATOR_USE_USERDATA
			void* iterData = lua_newuserdata(L, sizeof(ObjectIterPair));

	#ifdef XIHAD_MLD_NEW_OBJECT
			// Enable __gc function when Auto-reference-counting enabled
			Metatable::forType<ObjectIterPair>(L);
			lua_setmetatable(L, -2);
	#endif

			new (iterData) ObjectIterPair(*objList);
#else
			lua_pushlightuserdata(L, new ObjectIterPair(*objList));
#endif
		}
		else
		{
			lua_pushlightuserdata(L, 0);
		}
		
		lua_pushnil(L);
		return 3;
	}

void GeneticAlgorithmProfile1::BeforeDeployment(cocos2d::Layer& _sc)
{
    GameScene* gs = (GameScene*) &_sc;
    
    if( this->gaThreadData->GetNonGARounds() > 0 && this->gaThreadData->IsGaEnabled() == false)
    {
        int tc = pthread_create(&threadsGA[0], NULL, &GeneticAlgorithmProfile1::Algorithm, this->gaThreadData);
        //wait until need simulating is enabled
        while(!this->gaThreadData->IsGaInitialized() && this->gaThreadData->GetNonGARounds() > 0)
        {
            sleep(1); // wait for ga initialisation
        }
    }
    
    if( this->gaThreadData->IsGaEnabled() == true)
    {
        while(!this->gaThreadData->IsSimulating() && this->gaThreadData->GetNonGARounds() > 0)
        {
            sleep(1); // wait for start simulation to start
        }
        
        if(this->gaThreadData->IsGaEnabled() == true)
        {
            this->BackUpState(_sc);
            gs->GetGUI()->SetGameAlert2("DEPLOYMENT GA SIMULATING : PLEASE WAIT!!!");
            gs->simulationMode = true;
        }
    }
    
}

void 		Bomberman::loadGame() {
	GameScene *ptr;
  	char  *cfile;
  	std::string tmp;

  	cfile = BUtils::openFileDialog("Please choose your saved game");
  	if (cfile) {
  		tmp = cfile;
  		std::ifstream filestream(cfile, std::ifstream::in);
  		if (filestream && BUtils::checkMd5(tmp)) {
			if (this->_scenes[GAME])
				delete this->_scenes[GAME];
			ptr = new GameScene(this, this->_keyController, this->_camera);
			ptr->loadGame(tmp);
			this->_scenes[GAME] = ptr;
			this->_scenes[GAME]->initialize();
			this->setScene(GAME);

  		} else {
  			BUtils::runDialog(GTK_MESSAGE_ERROR, "The map file cannot be opened or is invalid.");
  		}
  	} else {
  		BUtils::runDialog(GTK_MESSAGE_WARNING, "You haven't chosen a file.");
  	}
}

// プログラムは WinMain から始まります
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	GameScene* mGameScene;		//ゲームシーンの作成 こいつが画面を見ている
	mGameScene = new GameScene;	//インスタンス生成 GameSceneのコンストラクタでタイトルシーンをを入れている
	
	SetGraphMode(640, 480, 16);	//画面の解像度
	ChangeWindowMode(TRUE);
	if (DxLib_Init() == -1)		// ＤＸライブラリ初期化処理
	{
		return -1;			// エラーが起きたら直ちに終了
	}
	// 描画先画面を裏画面にセット
	SetDrawScreen(DX_SCREEN_BACK);
	// ループ
	while (ProcessMessage() == 0 && CheckHitKey(KEY_INPUT_ESCAPE) == 0)
	{
		// 画面を初期化する
		ClearDrawScreen();

		//画面動作処理
		mGameScene->Update();

		//画面描画処理
		mGameScene->Draw();

		// 裏画面の内容を表画面に反映させる
		ScreenFlip();
	}
	DxLib_End();				// ＤＸライブラリ使用の終了処理
	return 0;				// ソフトの終了 
}

void PanelLayer::pause(cocos2d::CCObject* pSender)
{
	PersonalAudioEngine::sharedEngine()->playEffect(STATIC_DATA_STRING("click_button"));
	this->getChildByTag(MENUTAG)->setVisible(false);
	GameScene* gameScene = (GameScene*)this->getParent();
	gameScene->pause();
}

void LevelTrigger::Update(float deltaTime) {
	if(CollidesWith("player")) {
		GameScene* scene = (GameScene*)Scene;

		int roomX = scene->CurrentLevel->CurrentRoomX;
		int roomY = scene->CurrentLevel->CurrentRoomY;

		if(roomX == 7 && roomY == 7) {
			scene->SwitchLevel("room 1");
			return;
		}

		if(roomX == 4 && roomY == 6) {
			scene->SwitchLevel("boss");
			return;
		}

		if(roomX == 6 && roomY == 6) {
			scene->SwitchLevel("shopkeeper");
			return;
		}


		scene->SwitchLevel("random");
	}
}

void Unit::addDistanceTiles(int x, int y, int distance) {
	Game* game = &Game::getInstance();
	GameScene* scene = (GameScene*)game->currentScene;

	if(distance < 0) return;
	if(x < 0 || x > MAPSIZE-1) {
		return;
	}
	if(y < 0 || y > MAPSIZE-1) {
		return;
	}

	if(!scene->tilesystem.tiles[x][y]->walkable) {
		return;
	}

	Entity* entity = scene->getEntity(x,y);
	if( entity != NULL && entity != this ) {
		return;
	}

	bool alreadyThere = false;
	for(int i = 0; i < distanceTiles.size(); i++) {
		if(distanceTiles.at(i)->getPosition().X == x*10 
			&& distanceTiles.at(i)->getPosition().Z == y*10) {
				alreadyThere = true;
		}
	}

	bool inAttackRange = false;
	for(int i = 0; i < scene->entities.size(); i++) {
		if(scene->entities.at(i)->player == 0) continue;
		if(scene->entities.at(i)->inAttackRange(x, y, attackDistance) ) {
			inAttackRange = true;
		}
	}

	if(!inAttackRange && hasMoved) return;

	if(!alreadyThere) {
		IAnimatedMesh* model = game->sceneManager->getMesh("res/tileDistance.3ds");
		ISceneNode* node = game->sceneManager->addMeshSceneNode(model);
		node->setMaterialFlag(EMF_LIGHTING, false);
		node->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
		if(inAttackRange) {
			node->setMaterialTexture( 0, game->videoDriver->getTexture("res/tileDistanceRed.png") );
		} else {
			node->setMaterialTexture( 0, game->videoDriver->getTexture("res/tileDistanceBlue.png") );
		}
		node->setPosition(vector3d<f32>(x*10, 0, y*10) );
		node->setID(0);
		distanceTiles.push_back(node);
	}

	addDistanceTiles(x-1, y, distance-1);
	addDistanceTiles(x+1, y, distance-1);
	addDistanceTiles(x, y-1, distance-1);
	addDistanceTiles(x, y+1, distance-1);
}