Example #1
0
void Drop::stopWave()
{
	if (waveAction)
		stopAction(waveAction);
	setScale(1);
}
Example #2
0
void ColleageLayer::initframe()
{
	Size size = Director::getInstance()->getVisibleSize();

	//±³¾°
	auto background = Sprite::create("ui/background_2.jpg");
	background->setScale(1.26f);
	background->setPosition(size.width/2, 760);
	this->addChild(background);

	//¼¼ÄÜѧԺ±³¾°
	auto listbase = Sprite::create("ui/collegebase.jpg");
	listbase->setScale(1.3f);
	listbase->setPosition(size.width/2, 400);
	this->addChild(listbase);

	//µ×²¿±³¾°
	auto bottom_list = Sprite::createWithSpriteFrameName("bottom_list.jpg");
	bottom_list->setPosition(size.width/2, bottom_list->getContentSize().height/2);
	this->addChild(bottom_list);

	//¶¥²¿ÎÄ×ֵı³¾°
	auto middletitlebase = Sprite::createWithSpriteFrameName("middletitlebase.png");
	middletitlebase->setPosition(size.width/2, 700);
	this->addChild(middletitlebase);

	//Îı¾ºÏ³É
	auto titletext = Sprite::createWithSpriteFrameName("titlename_college.png");
	titletext->setPosition(size.width/2, 690);
	this->addChild(titletext);

	//¶¥²¿·µ»Ø°´Å¥
	auto button_left_normal = Sprite::createWithSpriteFrameName("button_left_0.png");
	auto button_left_pressed = Sprite::createWithSpriteFrameName("button_left_1.png");
	auto button_left_disable = Sprite::createWithSpriteFrameName("button_left_2.png");
	auto menuItem = MenuItemSprite::create(button_left_normal, button_left_pressed, button_left_disable);
	menuItem->setCallback([](Ref* pSender){
		log("return");
		NotificationCenter::getInstance()->postNotification("ReturnToMain");
	});

	auto text_return = Sprite::createWithSpriteFrameName("text_return.png");
	text_return->setPosition(button_left_normal->getContentSize().width/2 - 15, button_left_normal->getContentSize().height/2);
	menuItem->addChild(text_return);

	auto menu_left = Menu::create(menuItem, NULL);
	menu_left->setPosition(menuItem->getContentSize().width/2 - 10, 687);
	this->addChild(menu_left);


	//¶¥²¿°ïÖú°´Å¥
	auto button_right_normal = Sprite::createWithSpriteFrameName("button_help_0.png");
	auto button_right_pressed = Sprite::createWithSpriteFrameName("button_help_1.png");
	auto button_right_disable = Sprite::createWithSpriteFrameName("button_help_0.png");
	auto button_right_menuItem = MenuItemSprite::create(button_right_normal, button_right_pressed, button_right_disable);
	button_right_menuItem->setCallback(CC_CALLBACK_1(ColleageLayer::menu_help_callback, this));
	auto menu_right = Menu::create(button_right_menuItem, NULL);
	menu_right->setPosition(size.width - button_right_menuItem->getContentSize().width /2 + 20, 687);
	this->addChild(menu_right);

	//ÖØÖð´Å¥
	auto button_reset_normal = Sprite::createWithSpriteFrameName("button_little_0.png");
	auto button_reset_pressed = Sprite::createWithSpriteFrameName("button_little_1.png");
	auto button_reset_disable = Sprite::createWithSpriteFrameName("button_little_2.png");
	reset_Item = MenuItemSprite::create(button_reset_normal, button_reset_pressed, button_reset_disable);
	reset_Item->setScale(0.8f);

	auto text_reset = Sprite::createWithSpriteFrameName("text_reset.png");
	text_reset->setPosition(button_reset_normal->getContentSize().width/2 - 15, button_reset_normal->getContentSize().height/2);
	reset_Item->addChild(text_reset);

	reset_Item->setCallback(CC_CALLBACK_1(ColleageLayer::menu_reset_callback, this));
	auto menu_reset = Menu::create(reset_Item, NULL);
	menu_reset->setPosition(size.width / 2 - 150, 193);
	this->addChild(menu_reset);

	//ѧϰ°´Å¥
	auto button_learn_normal = Sprite::createWithSpriteFrameName("button_little_0.png");
	auto button_learn_pressed = Sprite::createWithSpriteFrameName("button_little_1.png");
	auto button_learn_disable = Sprite::createWithSpriteFrameName("button_little_2.png");
	learn_Item = MenuItemSprite::create(button_learn_normal, button_learn_pressed, button_learn_disable);
	learn_Item->setScale(0.8f);
	learn_Item->setEnabled(false);

	auto text_learn = Sprite::createWithSpriteFrameName("text_learn.png");
	text_learn->setPosition(button_learn_normal->getContentSize().width/2 - 15, button_learn_normal->getContentSize().height/2);
	learn_Item->addChild(text_learn);

	learn_Item->setCallback(CC_CALLBACK_1(ColleageLayer::menu_learn_callback, this));
	auto menu_learn = Menu::create(learn_Item, NULL);
	menu_learn->setPosition(size.width / 2 + 150, 193);
	this->addChild(menu_learn);
}
Example #3
0
//-----------------------------------------------------------------------
void Node::setScale(Real x, Real y, Real z)
{
    setScale(Vector3(x, y, z));
}
Example #4
0
void GameScene::onEnter()
{
	Scene::onEnter();
	auto& winSize = Director::getInstance()->getWinSize();
	auto& contentRect = Game::getContentRect();
	string fontName = "DolceVita.ttf";
	int x1 = contentRect.origin.x + wallThickness;
	int x2 = x1 + contentRect.size.width - wallThickness * 2;
	int y1 = contentRect.origin.y + wallThickness;
	int y2 = y1 + contentRect.size.height - wallThickness * 2;

	// Music
	SimpleAudioEngine::getInstance()->playBackgroundMusic("Song.mp3", true);

	// Stretched big background
	auto bg2 = LayerColor::create(Color4B(208, 204, 202, 255));
	bg2->setScale(2);
	this->addChild(bg2, -1);

	// Actual background
	auto bg = LayerColor::create(Color4B(218, 214, 212, 255), contentRect.size.width, contentRect.size.height);
	bg->setPosition(contentRect.origin);
	this->addChild(bg, 0);

	// Labels
	stringstream ss;
	ss << "Score: " << score;
	scoreLabel = Label::createWithTTF(ss.str().c_str(), fontName, 45);
	scoreLabel->setAnchorPoint(Vec2(0, 1));
	scoreLabel->setPosition(x1 + labelPadding, y2 - labelPadding);
	scoreLabel->setColor(Color3B(128, 128, 128));
	this->addChild(scoreLabel, 1);

	auto sceneLabel = Label::createWithTTF("Game Scene", fontName, 200);
	sceneLabel->setColor(Color3B(128, 128, 128));
	sceneLabel->setPosition(Game::centralize(0, 228));
	this->addChild(sceneLabel, 1);
	sceneLabel->runAction(Sequence::create(
		FadeOut::create(5),
		RemoveSelf::create(),
		nullptr
	));

	// Touch listners
	auto dispatcher = Director::getInstance()->getEventDispatcher();
	auto listener = EventListenerTouchAllAtOnce::create();
	listener->onTouchesBegan = [this] (const vector<Touch*>& touches, Event* event) {this->touchHandler("began", touches, event);};
	dispatcher->addEventListenerWithSceneGraphPriority(listener, this);

	// Start physics
	space = cpSpaceNew();
	space->gravity = cpv(0, gravity);

	// Walls
	createPhysicsBox(x1, y1, x2, contentRect.origin.y, 0.9, 0, collisionTypeWall); // bottom
	createPhysicsBox(x1, y2, x2, y2 + wallThickness, 0.9, 0, collisionTypeWall); // top
	createPhysicsBox(contentRect.origin.x, contentRect.origin.y, x1, y2 + wallThickness, 0.9, 0, collisionTypeWall); // left
	createPhysicsBox(x2, contentRect.origin.y, x2 + wallThickness, y2 + wallThickness, 0.9, 0, collisionTypeWall); // right

	// Ball
	ball = Sprite::create("Ball.png");
	createPhysicsSprite(ball, Vec2(winSize.width * 0.5f, winSize.height * 0.5f), 1.0f, 0.0f, collisionTypeBall);
	this->addChild(ball, 1);

	// Collision handler
	cpSpaceAddCollisionHandler(space, collisionTypeBall, collisionTypeWall, nullptr, nullptr, nullptr, GameScene::onCollision, nullptr);

	// Update
	this->scheduleUpdate();
}
Example #5
0
bool HomeScene::init(){
    if (!Scene::init()){
        return false;
    }

    SimpleAudioEngine::getInstance()->preloadEffect(Audio::RESTART_AUDIO.c_str());
    SimpleAudioEngine::getInstance()->preloadEffect(Audio::DIG_AUDIO.c_str());
    SimpleAudioEngine::getInstance()->preloadEffect(Audio::MINE1_AUDIO.c_str());
    SimpleAudioEngine::getInstance()->preloadEffect(Audio::BUTTON.c_str());
    SimpleAudioEngine::getInstance()->preloadEffect(Audio::FAIL_AUDIO.c_str());
    SimpleAudioEngine::getInstance()->preloadEffect(Audio::CRASH_AUDIO.c_str());


    Sprite *BG = Sprite::create("background.jpg");
    BG->setPosition(VISIZE.width / 2, VISIZE.height / 2);
    BG->setScaleX(VISIZE.width / BG->getContentSize().width);
    BG->setScaleY(VISIZE.height / BG->getContentSize().height);
    this->addChild(BG,0);

    c2 = Sprite::create("cloud2.png");
    c2->setPosition(VISIZE.width * 0.2, VISIZE.height * 0.4);
    c2->setScale(VISIZE.width / c2->getContentSize().width);
    this->addChild(c2,2);

    Sprite *star = Sprite::create("Brick.jpg");
    star->setPosition(VISIZE.width / 2, VISIZE.height / 2);
    star->setScaleX(VISIZE.width / star->getContentSize().width);
    star->setScaleY(VISIZE.height / star->getContentSize().height);
    this->addChild(star,3);


    dig_logo = Sprite::create("dig_logo.png");

    dig_logo->setPosition(VISIZE.width/2,VISIZE.height*0.6);
    dig_logo->setScale(VISIZE.width/dig_logo->getBoundingBox().size.width);
    this->addChild(dig_logo,4);


    auto playMenu = Sprite::create("pl.png");
    playMenu->runAction(MoveBy::create(0.5,Point(0,-playMenu->getBoundingBox().size.height/2)));
    playMenu->setPosition(dig_logo->getContentSize().width/2,dig_logo->getContentSize().height/2);
    dig_logo->addChild(playMenu);

    auto listenner = EventListenerTouchOneByOne::create();

    listenner->onTouchBegan = [=](Touch* touch,Event* event){

        if(playMenu->getBoundingBox().containsPoint(playMenu->getParent()->convertToNodeSpace(touch->getLocation()))){
            playMenu->setScale(playMenu->getScale()*1.2);
            isOut = false;
            log("ok");
            return true;
        }
        return false;
    };

    listenner->onTouchMoved = [=](Touch* touch,Event* event){
        if(playMenu->getBoundingBox().containsPoint(playMenu->convertToNodeSpace(touch->getLocation()))){
            isOut = true;
        }
        else{
            isOut = false;
        }
    };

    listenner->onTouchEnded = [=](Touch* touch,Event* event){
        if(!isOut){
            int beforeReplpace = 0.5;
            playMenu->setScale(playMenu->getScale()/1.2);
            dig_logo->runAction(EaseBackOut::create(MoveTo::create(beforeReplpace,Point(VISIZE.width/2,VISIZE.height*1.5))));
            playMenu->runAction(Sequence::create(EaseBackOut::create(MoveBy::create(beforeReplpace,Point(0,0))),
            CallFunc::create([=](){

                //this->runAction(RuduceVolume::create(0.3));
                Director::getInstance()->replaceScene(TransitionSlideInB::create(0.3,DigScene::createScene()));

            }), nullptr));


        }
    };


    playMenu->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listenner,dig_logo);



    return true;
}
Example #6
0
void SceneGraphComponent::executeEvent(GameEvent *event)
{
	switch (event->id())
	{
	case GameEvent::E_SET_TRANSFORMATION:
		setTransformation(static_cast<const float*>(event->data()));
		break;
	case GameEvent::E_TRANSFORMATION:
		memcpy(static_cast<float*>(event->data()), m_transformation, sizeof(float) * 16);
		break;
	case GameEvent::E_SET_TRANSLATION:
		{
			Vec3f* translation = static_cast<Vec3f*>(event->data());
			m_transformation[12] = translation->x;
			m_transformation[13] = translation->y;
			m_transformation[14] = translation->z;
			sendTransformation();
		}
		break;
	case GameEvent::E_SET_SCALE:
		setScale(static_cast<Vec3f*>(event->data()));
		break;
	case GameEvent::E_MESH_DATA:
		getMeshData(static_cast<MeshData*>(event->data()));
		break;
	case GameEvent::E_TRANSLATE_LOCAL:
		translateLocal(static_cast<Vec3f*>(event->data()));
		break;
	case GameEvent::E_TRANSLATE_GLOBAL:
		translateGlobal(static_cast<Vec3f*>(event->data()));
		break;
	case GameEvent::E_ROTATE_LOCAL:
		rotate(static_cast<Vec3f*>(event->data()));
		break;
	case GameEvent::E_SET_ROTATION:
		setRotation(static_cast<Vec3f*>(event->data()));
		break;
	case GameEvent::E_ATTACH:
		attach(static_cast<Attach*>(event->data()));
		break;	
	case GameEvent::E_SET_NODE_PARENT:
		setParentNode(static_cast<Attach*>(event->data()));
		break;
	case GameEvent::E_MORPH_TARGET:
		if (m_hordeID > 0)
		{
			h3dSetModelMorpher(m_hordeID, static_cast<MorphTarget*>(event->data())->Name, static_cast<MorphTarget*>(event->data())->Value);
			h3dUpdateModel(m_hordeID, H3DModelUpdateFlags::Geometry );		
		}
		break;
	case GameEvent::E_ACTIVATE_CAM:
		if (m_hordeID > 0 && h3dGetNodeType(m_hordeID) == H3DNodeTypes::Camera)
			SceneGraphManager::instance()->setActiveCam( m_hordeID );
		break;
	case GameEvent::E_SET_ANIM_FRAME:
		{
			if (m_hordeID > 0)
			{
				const SetAnimFrame* const data = static_cast<SetAnimFrame*>(event->data());			
				h3dSetModelAnimParams(m_hordeID, data->Stage, data->Time, data->Weight);	
				h3dUpdateModel(m_hordeID, H3DModelUpdateFlags::Animation | H3DModelUpdateFlags::Geometry );		
			}
		}
		break;
	case GameEvent::E_SET_ENABLED:
		setEnabled(*static_cast<bool*>(event->data()));
		break;
	case GameEvent::E_GET_VISIBILITY:
		{
			bool* visible = static_cast<bool*>(event->data());
			if (visible)
				*visible = getVisibility();
		}
		break;
	case GameEvent::E_GET_PROJECTION_MATRIX:
		{
			float* mat = static_cast<float*>(event->data());
			SceneGraphManager::instance()->getCameraProjectionMatrix(mat);
		}
		break;
	case GameEvent::E_GET_ACTIVE_CAM:
		if (SceneGraphManager::instance()->getActiveCam() == m_hordeID)
		{
			unsigned int* id = static_cast<unsigned int*>(event->data());
			if (id)
				*id = m_owner->worldId();
		}
		break;
	case GameEvent::E_GET_SCENEGRAPH_ID:
		{
			int* id = static_cast<int*>(event->data());
			if (id)
				*id = m_hordeID;
		}
		break;
	}
}
Example #7
0
bool SelectTowerLayer::init()
{
	if (!Layer::init())
	{
		return false;
	}
	 
	// show the position for tower
	auto towerPos = Sprite::create("towerPos.png");
	towerPos->setScale(0.7);
	//towerPos->setAnchorPoint(Vec2::ZERO);
	this->addChild(towerPos);

	menu = Menu::create();

	//according to Towers  to create equal num menuItems and the Sprite
	auto instance = GameManager::getInstance();
	int nums = instance->towerSelectVector.size();

	int currmoney = dynamic_cast<UiLayer*>(GameManager::getInstance()->getUiLayer())->getcurmoney();
	
	for (int i = 0; i < nums; i++)
	{
		int tower_count = instance->towerSelectVector.at(i);
		MenuItemImage* towerItem = MenuItemImage::create(StringUtils::format("startUI/tower__%02d.png", tower_count), StringUtils::format("startUI/tower__%02d.png", tower_count), StringUtils::format("startUI/tower__%02dunabled.png", tower_count), [=](Ref*)
		{			
			log("You select the %d", tower_count);
			//to assign the choose value when touch the menuItem
			addTower(tower_count);
			//clear up the contents
			 
			//this->removeAllChildrenWithCleanup(true);
			Layer::removeFromParent();
		});
		//judge this gold 
		switch (tower_count)
		{
		case 1:
			if (currmoney < TOWERONECOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 2:
			if (currmoney < TOWERTWOCOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 3:
			if (currmoney < TOWERTHREECOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 4:
			if (currmoney < TOWERFORECOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 5:
			if (currmoney < TOWERFIVECOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 6:
			if (currmoney < TOWERSIXCOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 7:
			if (currmoney < TOWERSEVENCOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		case 8:
			if (currmoney < TOWEREIGHTCOST)
			{
				towerItem->setEnabled(false);
			}
			break;
		default:
			break;
		}
		
		int pos_x = i * 64;
		int pos_y = +64 * (i / 3 + 0);

		pos_x = pos_x - 3 * 64 * ((i / 3 + 0));

		towerItem->setPosition(pos_x, pos_y);
		menu->addChild(towerItem);
	}
	menu->setAnchorPoint(Vec2::ZERO);
	menu->setPosition(Vec2(-towerPos->getContentSize().width / 3 * 2, towerPos->getContentSize().height / 3 * 2));
 	this->addChild(menu);

	return true;
}
Example #8
0
int QDeclarativeParentChange::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDeclarativeStateOperation::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;

#ifndef QT_NO_PROPERTIES
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0:
            *reinterpret_cast< QDeclarativeItem**>(_v) = object();
            break;
        case 1:
            *reinterpret_cast< QDeclarativeItem**>(_v) = parent();
            break;
        case 2:
            *reinterpret_cast< QDeclarativeScriptString*>(_v) = x();
            break;
        case 3:
            *reinterpret_cast< QDeclarativeScriptString*>(_v) = y();
            break;
        case 4:
            *reinterpret_cast< QDeclarativeScriptString*>(_v) = width();
            break;
        case 5:
            *reinterpret_cast< QDeclarativeScriptString*>(_v) = height();
            break;
        case 6:
            *reinterpret_cast< QDeclarativeScriptString*>(_v) = scale();
            break;
        case 7:
            *reinterpret_cast< QDeclarativeScriptString*>(_v) = rotation();
            break;
        }
        _id -= 8;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0:
            setObject(*reinterpret_cast< QDeclarativeItem**>(_v));
            break;
        case 1:
            setParent(*reinterpret_cast< QDeclarativeItem**>(_v));
            break;
        case 2:
            setX(*reinterpret_cast< QDeclarativeScriptString*>(_v));
            break;
        case 3:
            setY(*reinterpret_cast< QDeclarativeScriptString*>(_v));
            break;
        case 4:
            setWidth(*reinterpret_cast< QDeclarativeScriptString*>(_v));
            break;
        case 5:
            setHeight(*reinterpret_cast< QDeclarativeScriptString*>(_v));
            break;
        case 6:
            setScale(*reinterpret_cast< QDeclarativeScriptString*>(_v));
            break;
        case 7:
            setRotation(*reinterpret_cast< QDeclarativeScriptString*>(_v));
            break;
        }
        _id -= 8;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 8;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
Example #9
0
 /**
  * Sets plot scale back to the defaults.
  *
  */
 void ScatterPlotWindow::resetScale(){
   setScale(QwtPlot::xBottom, p_MinOne, p_MaxOne);
   setScale(QwtPlot::yLeft, p_MinTwo, p_MaxTwo);
 }
Example #10
0
void FightLayer::initCard(){
    
    auto fightBackground = Sprite::create("textures/IMG_Background/fight_background.png");
    auto cs = fightBackground->getContentSize();
    
    _bgSize = cs;
    _nFight = LayerColor::create(Color4B(255,0,0,0),cs.width,cs.height);
    _nFight->setAnchorPoint(Point(0.5,0));

    _animalNode = Node::create();
    
    auto p = VisibleRect::topRight()-Point(cs.width,cs.height);
    _nFight->setPosition(p.x/2,p.y/2);
    _animalNode->setPosition(Point(cs.width/2,cs.height/2)+Point(p.x/2,p.y/2));
    
    addChild(_nFight);
    addChild(_animalNode);
    
    auto node = Node::create();
    node->setPosition(cs.width/2,cs.height/2);
    node->addChild(fightBackground);
    _nFight->addChild(node);

    for(auto id=0;id<_myVec.size();id++){
        
        auto myCard = _myVec.at(id);
        auto scale = myCard->getScaleX();
        node->addChild(myCard);
        auto myAn = myCard->getAnimal()->getThisLayer();
        
        auto dcp = myCard->getPosition();
        auto dp = myAn->getPosition();
        auto np = dcp + Point(0, dp.y*scale);
        
        auto nd = Node::create();
        myAn->setScale(scale);
        myAn->setPosition(myAn->getPosition().x,0);
        nd->addChild(myAn);
        
        updatePoint(nd, np);
        _animalNode->addChild(nd);
    }
    
    for(auto ic = 0;ic<_monsterVec.size();ic++){
        
        auto msCard = _monsterVec.at(ic);
        auto cScale = msCard->getScaleX();
        node->addChild(msCard);
        auto msAn = msCard->getAnimal()->getThisLayer();
        
        auto cDcp = msCard->getPosition();
        auto cDp = msAn->getPosition();
        auto dNp = cDcp+Point(0,cDp.y*cScale);
        
        auto cNd = Node::create();
        msAn->setScale(cScale);
        msAn->setPosition(msAn->getPositionX(),0);
        cNd->addChild(msAn);
        
        updatePoint(cNd, dNp);
        _animalNode->addChild(cNd);
    }
}
Example #11
0
void Level20::restart() {
    BaseLevel::restart();

#define MOVE_BY_X 192

    auto r1 = Target::create();
    r1->setPosition(E::originX, E::originY + 420);
    r1->setRotation(45);
    r1->initBody();
    this->addChild(r1);
    r1->initProtector(192 - 32);
    r1->runAction(RepeatForever::create(Sequence::create(MoveBy::create(0.5f, Vec2(MOVE_BY_X, 0)), DelayTime::create(1.0f), MoveBy::create(0.5f, Vec2(-MOVE_BY_X, 0)), nullptr)));

    auto r2 = Target::create();
    r2->setPosition(E::originX + DESIGNED_WIDTH, E::originY + 420);
    r2->setRotation(-45);
    r2->initBody();
    this->addChild(r2);
    r2->initProtector(192 - 32);
    r2->runAction(RepeatForever::create(Sequence::create(MoveBy::create(0.5f, Vec2(-MOVE_BY_X, 0)), DelayTime::create(1.0f), MoveBy::create(0.5f, Vec2(MOVE_BY_X, 0)), nullptr)));

    auto ring1 = Ring::create();
    ring1->setPosition(E::originX + DESIGNED_WIDTH / 2 - 80, E::originY + 128 + 64);
    ring1->setScale(0.15);
    ring1->initBody();
    this->addChild(ring1);

    auto ring2 = Ring::create();
    ring2->setPosition(E::originX + DESIGNED_WIDTH / 2 + 80, E::originY + 128 + 64);
    ring2->setScale(0.15);
    ring2->initBody();
    this->addChild(ring2);

    auto b1 = Brick::create(192, 24);
    b1->setRotation(45);
    b1->setPosition(E::originX + DESIGNED_WIDTH / 2 - 192 + 32, E::originY + 96 );
    b1->initBody();
    this->addChild(b1);
    auto b12 = Brick::create(192, 16, E::P.C800);
    b12->setRotation(45);
    b12->setPosition(E::originX + DESIGNED_WIDTH / 2 - 192 + 32 + 16, E::originY + 96 + 8);
    b12->initBody();
    this->addChild(b12);

    auto b2 = Brick::create(192, 24);
    b2->setRotation(-45);
    b2->setPosition(E::originX + DESIGNED_WIDTH / 2 - 192 + 32 + 128, E::originY + 96 );
    b2->initBody();
    this->addChild(b2);
    auto b22 = Brick::create(192, 16, E::P.C800);
    b22->setRotation(-45);
    b22->setPosition(E::originX + DESIGNED_WIDTH / 2 - 192 + 32 - 16 + 128, E::originY + 96 + 8);
    b22->initBody();
    this->addChild(b22);

    auto diamond1 = Diamond::create();
    diamond1->setScale(0.9f);
    diamond1->setRotation(30);
    diamond1->setPosition(E::originX - 128, E::originY + 256 + 64);
    diamond1->initBody();
    this->addChild(diamond1);

    auto diamond2 = Diamond::create();
    diamond2->setScale(0.9f);
    diamond2->setRotation(-30);
    diamond2->setPosition(E::originX + DESIGNED_WIDTH + 128, E::originY + 256 + 64);
    diamond2->initBody();
    this->addChild(diamond2);

}
Example #12
0
void CModel::setScale(float x,float y,float z)
{
	temp_vec3.Set(x,y,z);
	setScale(temp_vec3);
}
void QFormulatorEditWidget::keyPressEvent( QKeyEvent *e )
{
	switch( e->key() )
	{
    case Qt::Key_Up:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMoveUp();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftUp();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftUp();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlUp();
        return;
    case Qt::Key_Down:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMoveDown();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftDown();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftDown();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlDown();
        return;
    case Qt::Key_Left:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMoveLeft();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftLeft();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftLeft();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlLeft();
        return;
    case Qt::Key_Right:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMoveRight();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftRight();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftRight();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlRight();
        return;
	case Qt::Key_Home:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMoveHome();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftHome();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftHome();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlHome();
        return;
	case Qt::Key_End:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMoveEnd();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftEnd();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftEnd();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlEnd();
		break;
	case Qt::Key_PageUp:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMovePageUp();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftPageUp();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftPageUp();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlPageUp();
        return;
	case Qt::Key_PageDown:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
			OnMovePageDown();
		else if( (e->modifiers() & Qt::ControlModifier) && (e->modifiers() & Qt::ShiftModifier) )
			OnMoveCtrlShiftPageDown();
		else if( e->modifiers() & Qt::ShiftModifier )
			OnMoveShiftPageDown();
		else if( e->modifiers() & Qt::ControlModifier )
			OnMoveCtrlPageDown();
        return;
	case Qt::Key_Backspace:
		if( e->modifiers() == Qt::NoModifier )
			BackSpace();
        return;
	case Qt::Key_Delete:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier )
			Delete();
        return;
    case Qt::Key_Return:
		if( e->modifiers() == Qt::NoModifier || e->modifiers() == Qt::KeypadModifier  )
		{
			rootNode()->MoveReturn();
			updateViewDocument();
			//cbFireEvent( FORMULIB_CALLBACK_ENTER, NULL, NULL );
		}
        return;
    case Qt::Key_Escape:
		if( e->modifiers() == Qt::NoModifier )
		{
			rootNode()->Escape();
			updateFormulatorWidget();
		}
        return;
	default:
		break;
	}

	if( e->matches( QKeySequence::Copy ) )
	{
		editCopy();
		return;
	}
	else if( e->matches( QKeySequence::Cut ) )
	{
		editCut();
		return;
	}
	else if( e->matches( QKeySequence::Paste ) )
	{
		editPaste();
		return;
	}
	if( e->matches( QKeySequence::Delete ) )
	{
		Delete();
		return;
	}
	else if( e->matches( QKeySequence::Undo ) )
	{
		editUndo();
		return;
	}
	else if( e->matches( QKeySequence::Redo ) )
	{
		editRedo();
		return;
	}
	else if( e->matches( QKeySequence::SelectAll ) )
	{
		editSelectAll();
	}
	else if( e->matches( QKeySequence::ZoomIn ) )
	{
		double value = qMin( scale() + DEFAULT_VIEWSCALE_STEP, DEFAULT_VIEWSCALE_MAX );
		setScale( value );
	}
	else if( e->matches( QKeySequence::ZoomOut ) )
	{
		double value = qMax( scale() - DEFAULT_VIEWSCALE_STEP, DEFAULT_VIEWSCALE_MIN );
		setScale( value );
	}
	else if( e->text().length() > 0 )
	{
		for( long i = 0; i < e->text().length(); i++ )
			rootNode()->Char( e->text().at( i ).unicode(), undoRedo() );
		updateViewDocument();
		//cbFireEvent( FORMULIB_CALLBACK_CHAR, nChar, NULL );
	}

	QFormulatorWidget::keyPressEvent( e );
}
Example #14
0
void Level01::setBG()
{
	m_worldMap = Node::create();

	if (UserDefault::getInstance()->getBoolForKey("light"))
	{
		m_collision = m_visibleSize.width*0.3;
	}
	else
	{
		m_collision = -m_visibleSize.width*0.7;
	}

	Sprite* bg[3];

	for (int i = 0; i < 3; i++)
	{
		bg[i] = Sprite::create("img/background.png");

		// position the sprite on the center of the screen
		bg[i]->setScale(m_visibleSize.width / m_visibleSize.height);
		bg[i]->setPosition(Point((m_visibleSize.width) * i+1, m_visibleSize.height / 2));

		// add the sprite as a child to this layer
		m_worldMap->addChild(bg[i]);
	}

	createObjectOnFloor(bg[1]->getBoundingBox().getMidX()- 200, "img/chair.png");
	createObjectOnFloor(bg[1]->getBoundingBox().getMidX(), "img/chair.png");
	createObjectOnFloor(bg[1]->getBoundingBox().getMidX(), "img/table.png");
	createObjectOnFloor(bg[0]->getBoundingBox().getMidX(), "img/chair.png");

	auto drawing2 = Sprite::create("img/drawing01.png");
	drawing2->setScale(2);
	drawing2->setPosition(Vec2(m_visibleSize.width * 1.3, m_visibleSize.height / 1.4));
	//m_worldMap->addChild(drawing2);

	//m_doorList[2] = createDoor(m_visibleSize.width * 2.7);
	m_doorList[0] = createDoor(convertToNodeSpace(sprite->getPosition()).x);
	//m_doorList[1] = createDoor(m_visibleSize.width * 3.4);

	auto sadman  = Sprite::create("img/sadman01.png");
	sadman->setScale(1.8);
	sadman->setPosition(Vec2(m_visibleSize.width * 1.2 + 55, m_floorPoint + sadman->getBoundingBox().getMaxY()));
	m_worldMap->addChild(sadman);
	if (UserDefault::getInstance()->getBoolForKey("light"))
	{
		sadman->setVisible(true);
	}
	else
	{
		sadman->setVisible(false);
	}

	auto sadmanAnim = Animation::create();
	sadmanAnim->addSpriteFrameWithFileName("img/sadman01.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman01.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman02.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman01.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman02.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman03.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman02.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman03.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman02.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman03.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman02.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman03.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman04.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman04.png");
	sadmanAnim->addSpriteFrameWithFileName("img/sadman04.png");
	sadmanAnim->setLoops(-1);
	sadmanAnim->setDelayPerUnit(0.3f);
	sadmanAnim->setRestoreOriginalFrame(true);

	auto sadmanAnimate = Animate::create(sadmanAnim);
	sadman->runAction(RepeatForever::create(sadmanAnimate));

	m_doorList[1] = sadman;

	this->addChild(m_worldMap);
}
Example #15
0
// -----------------------------------------------------------------------------
// Static function to check if an archive has sufficient texture related
// entries, and if not, prompts the user to either create or import them.
// Returns true if the entries exist, false otherwise
// -----------------------------------------------------------------------------
bool TextureXEditor::setupTextureEntries(Archive* archive)
{
	using Format = TextureXList::Format;

	// Check any archive was given
	if (!archive)
		return false;

	// Search archive for any ZDoom TEXTURES entries
	Archive::SearchOptions options;
	options.match_type = EntryType::fromId("zdtextures");
	auto entry_tx      = archive->findFirst(options); // Find any TEXTURES entry

	// If it's found, we're done
	if (entry_tx)
		return true;


	// Search archive for any texture-related entries
	options.match_type = EntryType::fromId("texturex");
	entry_tx           = archive->findFirst(options); // Find any TEXTUREx entry
	options.match_type = EntryType::fromId("pnames");
	auto entry_pnames  = archive->findFirst(options); // Find any PNAMES entry

	// If both exist, we're done
	if (entry_tx && entry_pnames)
		return true;

	// Todo: accept entry_tx without pnames if the textures are in Jaguar mode

	// If no TEXTUREx entry exists
	if (!entry_tx)
	{
		// No TEXTUREx entries found, so ask if the user wishes to create one
		wxMessageDialog dlg(
			nullptr,
			"The archive does not contain any texture definitions (TEXTURE1/2 or TEXTURES). "
			"Do you wish to create or import a texture definition list?",
			"No Texture Definitions Found",
			wxYES_NO);

		if (dlg.ShowModal() == wxID_YES)
		{
			CreateTextureXDialog ctxd(nullptr);

			while (true)
			{
				// Check if cancelled
				if (ctxd.ShowModal() == wxID_CANCEL)
					return false;

				if (ctxd.createNewSelected())
				{
					// User selected to create a new TEXTUREx list
					ArchiveEntry* texturex = nullptr;

					// Doom or Strife TEXTUREx
					if (ctxd.getSelectedFormat() == Format::Normal || ctxd.getSelectedFormat() == Format::Strife11)
					{
						// Create texture list
						TextureXList txlist;
						txlist.setFormat(ctxd.getSelectedFormat());

						// Create patch table
						PatchTable ptt;

						// Create dummy patch
						auto dpatch = App::archiveManager().programResourceArchive()->entryAtPath("s3dummy.lmp");
						archive->addEntry(dpatch, "patches", true);
						ptt.addPatch("S3DUMMY");

						// Create dummy texture
						auto dummytex = std::make_unique<CTexture>();
						dummytex->setName("S3DUMMY");
						dummytex->addPatch("S3DUMMY", 0, 0);
						dummytex->setWidth(128);
						dummytex->setHeight(128);
						dummytex->setScale({ 0., 0. });

						// Add dummy texture to list
						// (this serves two purposes - supplies the special 'invalid' texture by default,
						//   and allows the texturex format to be detected)
						txlist.addTexture(std::move(dummytex));

						// Add empty PNAMES entry to archive
						entry_pnames = archive->addNewEntry("PNAMES");
						ptt.writePNAMES(entry_pnames);
						entry_pnames->setType(EntryType::fromId("pnames"));
						entry_pnames->setExtensionByType();

						// Add empty TEXTURE1 entry to archive
						texturex = archive->addNewEntry("TEXTURE1");
						txlist.writeTEXTUREXData(texturex, ptt);
						texturex->setType(EntryType::fromId("texturex"));
						texturex->setExtensionByType();
					}
					else if (ctxd.getSelectedFormat() == Format::Textures)
					{
						// Create texture list
						TextureXList txlist;
						txlist.setFormat(Format::Textures);

						// Add empty TEXTURES entry to archive
						texturex = archive->addNewEntry("TEXTURES");
						texturex->setType(EntryType::fromId("zdtextures"));
						texturex->setExtensionByType();

						return false;
					}

					if (!texturex)
						return false;
				}
				else
				{
					// User selected to import texture definitions from the base resource archive
					auto bra = App::archiveManager().baseResourceArchive();

					if (!bra)
					{
						wxMessageBox(
							"No Base Resource Archive is opened, please select/open one", "Error", wxICON_ERROR);
						continue;
					}

					// Find all relevant entries in the base resource archive
					Archive::SearchOptions opt;
					opt.match_type     = EntryType::fromId("texturex");
					auto import_tx     = bra->findAll(opt); // Find all TEXTUREx entries
					opt.match_type     = EntryType::fromId("pnames");
					auto import_pnames = bra->findLast(opt); // Find last PNAMES entry

					// Check enough entries exist
					if (import_tx.empty() || !import_pnames)
					{
						wxMessageBox(
							"The selected Base Resource Archive does not contain "
							"sufficient texture definition entries",
							"Error",
							wxICON_ERROR);
						continue;
					}

					// Copy TEXTUREx entries over to current archive
					for (auto& a : import_tx)
					{
						auto texturex = archive->addEntry(a, "global", true);
						texturex->setType(EntryType::fromId("texturex"));
						texturex->setExtensionByType();
					}

					// Copy PNAMES entry over to current archive
					entry_pnames = archive->addEntry(import_pnames, "global", true);
					entry_pnames->setType(EntryType::fromId("pnames"));
					entry_pnames->setExtensionByType();
				}

				break;
			}

			return true;
		}

		// 'No' clicked
		return false;
	}
	else // TEXTUREx entry exists
	{
		// TODO: Probably a better idea here to get the user to select an archive to import the patch table from
		// If no PNAMES entry was found, search resource archives
		if (!entry_pnames)
		{
			Archive::SearchOptions opt;
			opt.match_type = EntryType::fromId("pnames");
			entry_pnames   = App::archiveManager().findResourceEntry(opt, archive);
		}

		// If no PNAMES entry is found at all, show an error and abort
		// TODO: ask user to select appropriate base resource archive
		if (!entry_pnames)
		{
			wxMessageBox("PNAMES entry not found!", wxMessageBoxCaptionStr, wxICON_ERROR);
			return false;
		}

		return true;
	}

	return false;
}
Example #16
0
void AirspeedIndicator::setMaxValue(float mv) {
    maxValue = mv;
    setScale(180, 0, 180+330, maxValue);
}
Example #17
0
bool WatchtowerView::init(int buildId)
{
    if (!PopupBaseView::init()) {
        return false;
    }
    setIsHDPanel(true);
    CCLoadSprite::doResourceByCommonIndex(8, true,true);
    CCLoadSprite::doResourceByCommonIndex(500, true,true);
    setCleanFunction([](){
        CCLoadSprite::doResourceByCommonIndex(8, false,true);
        CCLoadSprite::doResourceByCommonIndex(500, false,true);
    });
    auto tbg = CCLoadSprite::loadResource("technology_09.png");
    auto tBatchNode = CCSpriteBatchNode::createWithTexture(tbg->getTexture());
    int maxHight = CCDirector::sharedDirector()->getWinSize().height;
    int curHight = -500;
    while (curHight<maxHight) {
        auto bg = CCLoadSprite::createSprite("technology_09.png");
        bg->setAnchorPoint(ccp(0, 1));
        bg->setPosition(ccp(0, curHight));
        curHight += bg->getContentSize().height;
        tBatchNode->addChild(bg);
        if (CCCommonUtils::isIosAndroidPad())
        {
            bg->setScale(2.4f);
        }
    }
    this->addChild(tBatchNode);
    m_buildId = buildId;
    auto tmpCCB = CCBLoadFile("WatchtowerView",this,this);
    this->setContentSize(tmpCCB->getContentSize());
    
    setTitleName(_lang("102160").c_str());
    m_callCount = 10;
    m_tabView = NULL;
    m_buildBG->setVisible(false);
    if (!CCCommonUtils::isIosAndroidPad()) {
        int oldBgHeight = m_buildBG->getContentSize().height;
        changeBGHeight(m_buildBG);
        int newBgHeight = m_buildBG->getContentSize().height;
        int extH = getExtendHeight();
        int addHeight = newBgHeight - oldBgHeight;
        int oldWidth = m_infoList->getContentSize().width;
        int oldHeight = m_infoList->getContentSize().height;
        //    m_infoList->setPositionY(m_infoList->getPositionY()-addHeight);
        m_infoList->setContentSize(CCSizeMake(oldWidth, oldHeight+extH));
        m_bottomNode->setPositionY(m_bottomNode->getPositionY() - extH);
        
        bool flag = false;
        if (ActivityController::getInstance()->aActivityInfo.activityST<=0 || ActivityController::getInstance()->aActivityInfo.siegeET<=0 ||ActivityController::getInstance()->aActivityInfo.round==0) {
            MonsterSiegeActivityInfoCommand* cmd = new MonsterSiegeActivityInfoCommand();
            cmd->setCallback(CCCallFuncO::create(this, callfuncO_selector(WatchtowerView::getInfoCallBack), NULL));
            cmd->sendAndRelease();
        }else{
            double prevTime = GlobalData::shared()->getWorldTime() - ActivityController::getInstance()->aActivityInfo.activityST;
            double gapTime = ActivityController::getInstance()->aActivityInfo.activityET - GlobalData::shared()->getWorldTime() ;
            double gapEnd = ActivityController::getInstance()->aActivityInfo.siegeET - GlobalData::shared()->getWorldTime();
            flag = ActivityController::getInstance()->aActivityInfo.activityST>0 && gapEnd>0 && gapTime>0 && prevTime>=0 && GlobalData::shared()->playerInfo.isInAlliance();
        }
        if(flag){
            showMonsterInfo();
        }
    }
    m_tabView = CCMultiColTableView::create(this, m_infoList->getContentSize());
    m_tabView->setDirection(kCCScrollViewDirectionVertical);
    m_tabView->setVerticalFillOrder(kCCTableViewFillTopDown);
    m_tabView->setMultiColTableViewDelegate(this);
    m_tabView->setTouchPriority(Touch_Popup);
    m_infoList->addChild(m_tabView);
    
    m_msgLabel->setString(_lang("108647"));
    
    FunBuildInfo& m_info = FunBuildController::getInstance()->getFunbuildById(m_buildId);
    
    string title = _lang(m_info.name)+" "+_lang_1("102272", CC_ITOA(m_info.level));
    if(FunBuildController::getInstance()->checkOpenUpstar(m_info.type)
       && FunBuildController::getInstance()->building_Miracle_open){
        if(m_info.starNum >= 1){
            title = _lang(m_info.name) +" "+ _lang("160001");
            title.append(" ");
            title.append(CC_ITOA(m_info.starNum));
        }
    }
    setTitleName(title.c_str());
    CCCommonUtils::setButtonTitle(m_ignoreBtn, _lang("139500").c_str());
    if (EnemyInfoController::getInstance()->m_enemyInfos.size() > 0) {
        m_bottomNode->setVisible(true);
    }
    else
        m_bottomNode->setVisible(false);
    updateInfo(NULL);
    
    return true;
}
	/// Set bias at far clip distance (linear model only)
	DistAtten& farBias(T v){ mFarBias=v; return setScale(); }
Example #19
0
void TableSelect::initTable(Size visibleSize,Vec2 origin){
    //layout left
    auto backgroundLeft = M9Path::create("tab_one.9.png",Size(visibleSize.width*0.2f,visibleSize.height*0.75f));
    backgroundLeft->setPosition(origin.x,origin.y+ visibleSize.height/2-backgroundLeft->getContentSize().height/2);
    this->addChild(backgroundLeft);
    
    auto hoatdong = MLabel::create("Hoạt động",32);
    hoatdong->setPosition(Vec2(origin.x+backgroundLeft->getContentSize().width/2-hoatdong->getContentSize().width/2,
                                backgroundLeft->getPosition().y+backgroundLeft->getContentSize().height
                                -1.8f*hoatdong->getContentSize().height));
    this->addChild(hoatdong);
    
    Layout* layoutLeft = Layout::create();
    layoutLeft->setContentSize(Size(backgroundLeft->getWidth()-30,backgroundLeft->getHeight()*5/6));
    layoutLeft->setPosition(Vec2(origin.x+15,origin.y+visibleSize.height*0.125f));
    this->addChild(layoutLeft);
    
    auto lv1 = ListView::create();
    //auto testxxx = MText::create("This is a notification xxxxxx!",15);
    //lv1->setItemModel(testxxx);
    for(int i=0;i<20;i++){
        auto testxxx = MText::create("This is a notification xxxxxx!,nothing.don't look at me!please!",15);
        testxxx->ignoreContentAdaptWithSize(false);
        testxxx->setContentSize(Size(layoutLeft->getContentSize().width,testxxx->getHeight()*2));
        lv1->pushBackCustomItem(testxxx);
    }
    
    lv1->setItemsMargin(10);
    //lv1->setBounceEnabled(true);
    lv1->setGravity(ListView::Gravity::LEFT);
    lv1->setContentSize(layoutLeft->getContentSize());
    //lv1->setPosition(layoutLeft->getPosition());
    lv1->setScrollBarEnabled(false);
    layoutLeft->addChild(lv1);
    
    //==========================Layout Right
    
    
    auto backgroundRight = M9Path::create("tab_two.9.png",Size(visibleSize.width*0.8f,visibleSize.height*0.75f));
    backgroundRight->setPosition(origin.x+visibleSize.width*0.2f,
                                 origin.y+visibleSize.height/2-backgroundRight->getHeight()/2);
    this->addChild(backgroundRight);
    
    auto ban_so = MLabel::create("Bàn số ▿",32);
    ban_so->setPosition(Vec2(origin.x-ban_so->getWidth()/2 + visibleSize.width*0.32f,
                              hoatdong->getPosition().y));
    this->addChild(ban_so);
    
    auto tien_cuoc = MLabel::create("Tiền cược ▿",32);
    tien_cuoc->setPosition(Vec2(origin.x-tien_cuoc->getWidth()/2 + visibleSize.width*0.55f,
                                 hoatdong->getPosition().y));
    this->addChild(tien_cuoc);
    
    auto trang_thai = MLabel::create("Trạng thái ▿",32);
    trang_thai->setPosition(Vec2(origin.x-trang_thai->getWidth()/2 + visibleSize.width*0.76f,
                                  hoatdong->getPosition().y));
    this->addChild(trang_thai);
    
    auto khoa = MLabel::create("Khóa ▿",32);
    khoa->setPosition(Vec2(origin.x-khoa->getWidth()/2 + visibleSize.width*0.945f,
                            hoatdong->getPosition().y));
    this->addChild(khoa);
    
    
    Layout* layoutRight = Layout::create();
    layoutRight->setContentSize(Size(backgroundRight->getWidth()-30,backgroundRight->getHeight()*5/6));
    layoutRight->setPosition(Vec2(origin.x+15+backgroundLeft->getWidth(),origin.y+visibleSize.height*0.125f));
    this->addChild(layoutRight);
    
    auto lvRight = ListView::create();
    //auto model = Button::create();
    //lvRight->setItemModel(model);
    
    for (int i=0; i<20; i++)
    {
        auto bkg_item = Sprite::create("bgr_list_item.png");
        auto number_table = MLabel::create("6",30);
        auto money = MLabel::create("1000 xu",30);
        auto status = MLabel::create("xxx",30);
        
        auto lock = Sprite::create("ic_lock.png");
        auto custom_item = Layout::create();
        
        custom_item->setContentSize(Size(layoutRight->getContentSize().width,lock->getContentSize().height*2));
        
        bkg_item->setScale(layoutRight->getContentSize().width/bkg_item->getContentSize().width,
                           lock->getContentSize().height*2/bkg_item->getContentSize().height);
        bkg_item->setPosition(layoutRight->getContentSize().width/2,custom_item->getContentSize().height/2);
        
        number_table->setPosition(Vec2(number_table->getContentSize().width/2+backgroundRight->getContentSize().width/8,
                                       custom_item->getContentSize().height / 2.0f-number_table->getContentSize().height/2));
        money->setPosition(Vec2(money->getContentSize().width/2+backgroundRight->getContentSize().width*2.5f/8,
                                custom_item->getContentSize().height / 2.0f-money->getContentSize().height/2));
        status->setPosition(Vec2(status->getContentSize().width/2+backgroundRight->getContentSize().width*5/8,
                                 custom_item->getContentSize().height / 2.0f-status->getContentSize().height/2));
        lock->setPosition(Vec2(lock->getContentSize().width/2+backgroundRight->getContentSize().width*7/8,
                               custom_item->getContentSize().height / 2.0f));
        
        custom_item->addChild(bkg_item);
        custom_item->addChild(number_table);
        custom_item->addChild(money);
        custom_item->addChild(status);
        custom_item->addChild(lock);
        lvRight->pushBackCustomItem(custom_item);
    }
    lvRight->setItemsMargin(15);
    lvRight->setBounceEnabled(true);
    lvRight->setGravity(ListView::Gravity::LEFT);
    lvRight->setContentSize(layoutRight->getContentSize());
    layoutRight->addChild(lvRight);
    
    //======
    
    

}
	/// @param[in] nearClip		Distance below which amplitude is clamped to 1
	/// @param[in] farClip		Distance at which amplitude reaches its minimum
	/// @param[in] law			Distance to attenuation factor law
	/// @param[in] farBias		Bias at far clip distance (linear model only)
	DistAtten(
		T nearClip = T(0.1), T farClip = T(20),
		AttenuationLaw law = ATTEN_INVERSE, T farBias = T(0)
	)
	:	mNear(nearClip), mFar(farClip), mFarBias(farBias), mLaw(law)
	{	setScale(); }
Example #21
0
bool CPanel::init()
{   
    Layer::init();    
   
    
    Size visibleSize = Director::getInstance()->getVisibleSize();
    Point origin = Director::getInstance()->getVisibleOrigin();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("khh/HWYJ.plist", "khh/HWYJ.png");

    //--------------------------------------------------------

    TUIParm t_panelbg[] = 
    { 
        { "IMG_ditu2.png",          Point(.5f, 0),   Point(visibleSize.width / 2 , 30 ), 0x10001 },      
        { "IMG_huweixinxi.png",     Point(.5f, .5f), Point(visibleSize.width / 2, visibleSize.height / 2 + 30), 0x10005 },     
        { "TMG_huweitujian.png",    Point(0.5f, .5f),Point(visibleSize.width / 2, visibleSize.height / 2 + 230), 0x10009}
    };

    int uiSize = sizeof(t_panelbg) / sizeof(TUIParm);
    for (int i = 0; i < uiSize; i++)
    {
        addUIElement(t_panelbg[i]);
    }

    //----------------------------------------

    auto pBigIcon = Sprite::createWithSpriteFrameName("IMG_xshouling1.png");
    pBigIcon->setPosition(Point(visibleSize.width / 2 - 150, visibleSize.height / 2));
    pBigIcon->setScale(1.5f);
    addChild(pBigIcon);       
   
    //-----------------------------------------------

    Sprite* pButton1 = Sprite::createWithSpriteFrameName("IMG_fanhui.png");
    Sprite* pButton2 = Sprite::createWithSpriteFrameName("IMG_fanhui3.png");
    Sprite* pButton3 = Sprite::createWithSpriteFrameName("IMG_fanhui3.png");

    //---------------------------------------------------
    //FIXME ´¥ÃþʼþÎÊÌâ
//     auto listener1 = EventListenerTouchOneByOne::create();
// 
//     listener1->setSwallowTouches(true);
//     listener1->onTouchBegan = [](Touch* touch, Event* event){
//         auto target = static_cast<Sprite*>(event->getCurrentTarget());
//         Director::getInstance()->end();
//         return true;
//     }; 
//     _eventDispatcher->addEventListenerWithSceneGraphPriority(listener1, pButton1); 

    //---------------------------------------------------------------------

    auto closeItem = MenuItemSprite::create(
        pButton1,
        pButton2,
        pButton3,
        CC_CALLBACK_1(CPanel::menuCloseCallback, this)       
        );
    closeItem->setPosition(Point(50, visibleSize.height / 2 + 240));


    auto menu = Menu::create(closeItem, NULL);
    menu->setPosition(Point::ZERO);
    addChild(menu, 1);

    //---------------------------------------------------

       
    int listSx = 120, listSy = 100, inval = 20;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            auto pSpriteIcon = Sprite::createWithSpriteFrameName("IMG_xshouling1.png");
            auto pSpriteItem = Sprite::createWithSpriteFrameName("IMG_xxbj.png");

            int listiconW = pSpriteIcon->getContentSize().width;
            int listiconH = pSpriteIcon->getContentSize().height;
            int x = listSx + (listiconW + inval) * j;
            int y = listSy + (listiconH + inval) * i;

            // pSpriteItem->setScale(0.8f);

            CUIElement* pElement = CUIElement::create();
            pElement->setIcon(pSpriteIcon);
            pElement->setLab(pSpriteItem);
            pElement->setScale(0.8f);
            pElement->setPosition(Point(x, y));           

            menu->addChild(pElement);
        }
    }
  

    log("CPanel init");
    return true;
}
	/// Set attenuation law
	DistAtten& law(AttenuationLaw v){ mLaw=v; return setScale(); }
Example #23
0
void WagonSelect::createUI()
{
    auto bk =  Sprite::create("wagonselect_bk.png");
    if(g_visibleRect.visibleWidth>960)
    {
        bk->setScaleX(g_visibleRect.visibleWidth/960);
    }
    bk->setAnchorPoint(Point::ANCHOR_MIDDLE);
    bk->setPosition(g_visibleRect.center);
    this->addChild(bk);
    
    _wagon_bk = Sprite::create("wagon_bk.png");
    if(g_visibleRect.visibleWidth>960)
    {
        _wagon_bk->setScaleX(g_visibleRect.visibleWidth/960);
    }
    _wagon_bk->setAnchorPoint(Point::ANCHOR_MIDDLE_LEFT);
    _wagon_bk->setPosition(Point(130,280));
    this->addChild(_wagon_bk,1);
    
    //boy or girl
    _boy_memuitem = MenuItemImage::create("boy_0.png","boy_1.png",
                                                  CC_CALLBACK_1(WagonSelect::boy_selected_callback, this));
    _boy_memuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _boy_memuitem->setPosition(Point(60,g_visibleRect.visibleHeight/2+60));
    _boy_memuitem->selected();
    
    _girl_memuitem = MenuItemImage::create("girl_0.png","girl_1.png",
                                                 CC_CALLBACK_1(WagonSelect::girl_selected_callback, this));
    _girl_memuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _girl_memuitem->setPosition(Point(60,g_visibleRect.visibleHeight/2-60));
    
    auto menu = Menu::create(_boy_memuitem, _girl_memuitem, nullptr);
    menu->setPosition(Point::ZERO);
    this->addChild(menu,1);
    
    //
    MenuItemImage* ready_menu;
    if (_turntype == FIRST_TURN) {
        ready_menu = MenuItemImage::create("btn_ready_1.png","btn_ready_2.png",CC_CALLBACK_1(WagonSelect::ready_callback, this));
    }
    else if(_turntype == SECOND_TURN) {
        ready_menu = MenuItemImage::create("btn_start_1.png","btn_start_2.png",CC_CALLBACK_1(WagonSelect::ready_callback, this));
    }
    ready_menu->setPosition(Point(g_visibleRect.visibleWidth-120, g_visibleRect.visibleHeight-60));
    auto menu_ready = Menu::create(ready_menu, nullptr);
    menu_ready->setPosition(Point::ZERO);
    this->addChild(menu_ready,1);
    
    //
    _wagon1_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon1_selected_callback, this));
    _wagon1_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon1_menuitem->setPosition(Point(120,g_visibleRect.visibleHeight/2-80));
    _wagon1_menuitem->selected();
    
    _wagon2_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon2_selected_callback, this));
    _wagon2_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon2_menuitem->setPosition(Point(310,g_visibleRect.visibleHeight/2-80));
    
    _wagon3_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon3_selected_callback, this));
    _wagon3_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon3_menuitem->setPosition(Point(500,g_visibleRect.visibleHeight/2-80));
    
    _wagon4_menuitem = MenuItemImage::create("wagon_item_0.png","wagon_item_1.png",
                                                 CC_CALLBACK_1(WagonSelect::wagon4_selected_callback, this));
    _wagon4_menuitem->setAnchorPoint(Point::ANCHOR_MIDDLE);
    _wagon4_menuitem->setPosition(Point(690,g_visibleRect.visibleHeight/2-80));
    
    auto menu_wagon = Menu::create(_wagon1_menuitem, _wagon2_menuitem, _wagon3_menuitem, _wagon4_menuitem, nullptr);
    menu_wagon->setPosition(Point::ZERO);
    _wagon_bk->addChild(menu_wagon,1);
    
    //
    auto wagon1 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("cnm_idle01.png"));
    wagon1->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.cnm_idle)));
    wagon1->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon1->setPosition(Point(120,g_visibleRect.visibleHeight/2-10));
    wagon1->setScale(1.3f);
    _wagon_bk->addChild(wagon1, 2);
    
    auto wagon2 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("tankidle01.png"));
    wagon2->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.tank_idle)));
    wagon2->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon2->setPosition(Point(310,g_visibleRect.visibleHeight/2-15));
    wagon2->setScale(1.3f);
    _wagon_bk->addChild(wagon2, 3);
    
    auto wagon3 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("rockidle01.png"));
    wagon3->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.rock_idle)));
    wagon3->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon3->setPosition(Point(500,g_visibleRect.visibleHeight/2));
    wagon3->setScale(1.3f);
    _wagon_bk->addChild(wagon3, 3);
    
    auto wagon4_1 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("mechidle01.png"));
    wagon4_1->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.mech_idle)));
    wagon4_1->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon4_1->setPosition(Point(700,g_visibleRect.visibleHeight/2-5));
    wagon4_1->setScale(1.3f);
    _wagon_bk->addChild(wagon4_1, 2);
    
    auto wagon4_2 = Sprite::createWithSpriteFrame(SpriteFrameCache::getInstance()->getSpriteFrameByName("mechgunidle01.png"));
    wagon4_2->runAction(RepeatForever::create(g_gameConfig.getAnimate(g_gameAnimation.mechgun_idle)));
    wagon4_2->setAnchorPoint(Point::ANCHOR_MIDDLE);
    wagon4_2->setPosition(Point(700,g_visibleRect.visibleHeight/2-20));
    wagon4_2->setScale(1.3f);
    _wagon_bk->addChild(wagon4_2, 3);

    //dude
    auto offsetPoint1 = Point(30.0f, 55.0f);
    _dude1 = Sprite::create("boy.png");
    _dude1->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude1->setPosition(wagon1->getPosition() + offsetPoint1);
    _dude1->setScale(1.3f);
    _wagon_bk->addChild(_dude1,2);

    auto offsetPoint2 = Point(20.0f, 65.0f);
    _dude2 = Sprite::create("boy.png");
    _dude2->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude2->setPosition(wagon2->getPosition() + offsetPoint2);
    _dude2->setScale(1.3f);
    _wagon_bk->addChild(_dude2,2);
    
    auto offsetPoint3 = Point(30.0f, 50.0f);
    _dude3 = Sprite::create("boy.png");
    _dude3->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude3->setPosition(wagon3->getPosition() + offsetPoint3);
    _dude3->setScale(1.3f);
    _wagon_bk->addChild(_dude3,2);
    
    auto offsetPoint4 = Point(10.0f, 55.0f);
    _dude4 = Sprite::create("boy.png");
    _dude4->setAnchorPoint(Point(Point::ANCHOR_MIDDLE));
    _dude4->setPosition(wagon4_1->getPosition() + offsetPoint4);
    _dude4->setScale(1.3f);
    _wagon_bk->addChild(_dude4,2);
    
    //shawdow
    auto shawdow1 = Sprite::create("shawdow.png");
    shawdow1->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow1->setPosition(Point(120,g_visibleRect.visibleHeight/2-70));
    shawdow1->setOpacity(200);
    _wagon_bk->addChild(shawdow1,2);

    auto shawdow2 = Sprite::create("shawdow.png");
    shawdow2->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow2->setPosition(Point(310,g_visibleRect.visibleHeight/2-70));
    shawdow2->setOpacity(200);
    _wagon_bk->addChild(shawdow2,2);

    auto shawdow3 = Sprite::create("shawdow.png");
    shawdow3->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow3->setPosition(Point(500,g_visibleRect.visibleHeight/2-70));
    shawdow3->setOpacity(200);
    _wagon_bk->addChild(shawdow3,2);

    auto shawdow4 = Sprite::create("shawdow.png");
    shawdow4->setAnchorPoint(Point::ANCHOR_MIDDLE);
    shawdow4->setPosition(Point(690,g_visibleRect.visibleHeight/2-70));
    shawdow4->setOpacity(200);
    _wagon_bk->addChild(shawdow4,2);

    // params
    initWagonParams();
    
    // name
    TTFConfig horseyTTFConfig;
    horseyTTFConfig.outlineSize = 3;
    horseyTTFConfig.fontSize = 30;
    horseyTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto horseyLabel = Label::createWithTTF(horseyTTFConfig, "HORSEY", TextHAlignment::CENTER, 20);
    horseyLabel->setPosition(120,g_visibleRect.visibleHeight/2-110);
    //horseyLabel->setSpacing(-5);
    horseyLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    horseyLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(horseyLabel,2);
    
    TTFConfig tankTTFConfig;
    tankTTFConfig.outlineSize = 3;
    tankTTFConfig.fontSize = 30;
    tankTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto tankLabel = Label::createWithTTF(horseyTTFConfig, "TANK", TextHAlignment::CENTER, 20);
    tankLabel->setPosition(310,g_visibleRect.visibleHeight/2-110);
    //tankLabel->setSpacing(-5);
    tankLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    tankLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(tankLabel,2);
    
    TTFConfig rockTTFConfig;
    rockTTFConfig.outlineSize = 3;
    rockTTFConfig.fontSize = 30;
    rockTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto rockLabel = Label::createWithTTF(horseyTTFConfig, "ROCK", TextHAlignment::CENTER, 20);
    rockLabel->setPosition(500,g_visibleRect.visibleHeight/2-110);
    //rockLabel->setSpacing(-5);
    rockLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    rockLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(rockLabel,2);
    
    TTFConfig mechTTFConfig;
    mechTTFConfig.outlineSize = 3;
    mechTTFConfig.fontSize = 30;
    mechTTFConfig.fontFilePath = "fonts/britanic bold.ttf";
    auto mechLabel = Label::createWithTTF(horseyTTFConfig, "MECH", TextHAlignment::CENTER, 20);
    mechLabel->setPosition(690,g_visibleRect.visibleHeight/2-110);
    //mechLabel->setSpacing(-5);
    mechLabel->setAnchorPoint(Point::ANCHOR_MIDDLE);
    mechLabel->enableOutline(Color4B::BLACK);
    _wagon_bk->addChild(mechLabel,2);
    
    // flash
    flash = Sprite::create("wagon_flash.png");
    flash->setAnchorPoint(Point::ANCHOR_MIDDLE);
    flash->setPosition(Point(120,g_visibleRect.visibleHeight/2-80));
    flash->runAction(RepeatForever::create(Blink::create(1,1)));
    _wagon_bk->addChild(flash,3);
    
    auto returnMenuListener = EventListenerCustom::create("returntoMenu", CC_CALLBACK_0(WagonSelect::returntoMenu, this));
    _eventDispatcher->addEventListenerWithSceneGraphPriority(returnMenuListener, this);
    
    auto wagonselectshowpopwindowlistener = EventListenerCustom::create("wagonselectshowpopwindowlistener", CC_CALLBACK_0(WagonSelect::showConnectingPopWindow, this));
    _eventDispatcher->addEventListenerWithSceneGraphPriority(wagonselectshowpopwindowlistener, this);
}
	/// Set near clip distance
	DistAtten& nearClip(T v){ mNear=v; return setScale(); }
    void DebugActor::doUpdate(const UpdateState& us)
    {
        static int fps = 0;
        ++_frames;
        if (_frames > 50)
        {
            timeMS this_time = getTimeMS();
            if (this_time != _startTime)
            {
                fps = int(((float)_frames / (this_time - _startTime)) * 1000);
            }
            _startTime = this_time;
            _frames = 0;
        }

        std::stringstream s;
        s << "fps=" << fps << std::endl;



#ifdef __S3E__
        int mem_used = -1;
        int mem_free = -1;

        mem_used = s3eMemoryGetInt(S3E_MEMORY_USED);
        mem_free = s3eMemoryGetInt(S3E_MEMORY_FREE);

        s << "mfree=" << mem_free << " mem=" << mem_used << std::endl;
#endif



#ifdef OXYGINE_DEBUG_TRACE_LEAKS
        s << "objects=" << (int)ObjectBase::__getCreatedObjects().size() << std::endl;
#endif
#ifdef OXYGINE_TRACE_VIDEO_STATS
        s << "batches=" << _videoStats.batches << " triangles=" << _videoStats.triangles << std::endl;
#endif
        s << "update=" << getStage()->_statUpdate << "ms ";
        s << "render=" << getStage()->_statRender << "ms ";
        s << "textures=" << NativeTexture::created << " ";
        s << "\nlisteners=" << getStage()->getListenersCount() << "";

        if (!_debugText.empty())
        {
            s << "\n";
            s << _debugText;
        }
        _debugText = "";

        _text->setText(s.str());


        setHeight(_text->getTextRect().size.y + _text->getY() + 3);
        _bg->setSize(getSize());


        float scale = getScaleX();
        Vector2 parentSize = getParent()->getSize();
        Vector2 realSize = getSize() * scale;

        setX(0);
        setY(0);

        switch (_corner)
        {
            case 1:
                setX(parentSize.x - realSize.x);
                setY(0);
                break;
            case 2:
                setPosition(parentSize - realSize);
                break;
            case 3:
                setX(0);
                setY(parentSize.y - realSize.y);
                break;
        }

        setScale(1.0f / getStage()->getScaleX());
    }
	/// Set far clip distance
	DistAtten& farClip(T v){ mFar=v; return setScale(); }
Example #27
0
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    ///////////////////////////////////////////////////////////////
    //                 Get Default Color
    // sqlite setting
    sqlite3 *pdb = OpenDatabase();
    int result;
    std::string dbPath;
    
    // create table
    result = sqlite3_exec(pdb, "create table if not exists colorsetting(idx integer primary key autoincrement, default_color int)", nullptr, nullptr, nullptr);
    if(result != SQLITE_OK){
        log("craete table failed");
    }
    
    // get default color
    char *errMsg;
    std::string select_query = "select default_color from colorsetting limit 1";
    sqlite3_stmt* statement;
    if (sqlite3_prepare(pdb, select_query.c_str(), -1, &statement, nullptr) == SQLITE_OK) {
        if (sqlite3_step(statement) == SQLITE_ROW) {
            g_defaultcolor = sqlite3_column_int(statement, 0);
        }else{
            // if no row
            // set default color
            std::string insert_query = "insert into colorsetting (default_color) values (1)";
            sqlite3_exec(pdb, insert_query.c_str(), nullptr, nullptr, &errMsg);
        }
    }else{
        // if select failed
        // set default color
        std::string insert_query = "insert into colorsetting (default_color) values (1)";
        sqlite3_exec(pdb, insert_query.c_str(), nullptr, nullptr, &errMsg);
    }
    sqlite3_finalize(statement);
    sqlite3_close(pdb);
    
    auto initColor3b = colorTable[g_defaultcolor].color;
    auto initColor4b = Color4B(initColor3b);
    //              End get Default Color
    //////////////////////////////
    
    
    
    
    
    
    //////////////////////////////
    // 1. super init first
//    if ( !LayerColor::initWithColor(Color4B(106,208,17,255)))
    if ( !LayerColor::initWithColor(initColor4b))
    {
        return false;
    }
 
    /////////////////////////////
    // 2. add a menu item with "X" image, which is clicked to quit the program
    //    you may modify it.

    // add a "close" icon to exit the progress. it's an autorelease object
//    auto closeItem = MenuItemImage::create(
//                                           "CloseNormal.png",
//                                           "CloseSelected.png",
//                                           CC_CALLBACK_1(HelloWorld::menuCloseCallback, this));
//    
//	closeItem->setPosition(Vec2(origin.x + visibleSize.width - closeItem->getContentSize().width/2 ,
//                                origin.y + closeItem->getContentSize().height/2));

//    auto nextscene = MenuItemFont::create("NEXT", CC_CALLBACK_1(HelloWorld::goFrameSelect,this));
//    nextscene->setPosition(Vec2(100,100));
    
    // create menu, it's an autorelease object
//    auto menu = Menu::create(nextscene, NULL);
//    menu->setPosition(Vec2::ZERO);
//    this->addChild(menu, 1);
    
    /////////////////////////////
    // 3. add your codes below...

    // add a label shows "Hello World"
    // create and initialize a label
    
//    auto label = Label::createWithTTF("FLIPICKER", "fonts/GROTESKIA OBLIQUE.otf", 24);
//    
//    // position the label on the center of the screen
//    label->setPosition(Vec2(origin.x + visibleSize.width/2,
//                            origin.y + visibleSize.height - label->getContentSize().height));
//    
//    // add the label as a child to this layer
//    this->addChild(label, 1);
    
    // size factor
    visibleSize = Director::getInstance()->getVisibleSize();
    origin = Director::getInstance()->getVisibleOrigin();
    r = float(visibleSize.height / 640 > visibleSize.width / 1136 ? visibleSize.width / 1136 : visibleSize.height / 640);
    if(menuscale * r >= 2.0f){
        path = "res/retina/";
        menuscale = menuscale / 2;
    }

    // add "HelloWorld" splash screen"
    auto sprite = Sprite::create(path+"00splash_logo.png");
    
    auto baseScale = 1.5;
    sprite->setScale(r * baseScale, r * baseScale);

    // position the sprite on the center of the screen
    sprite->setPosition(Vec2(visibleSize.width/2 + origin.x, visibleSize.height*55/100 + origin.y));

    // add the sprite as a child to this layer
    this->addChild(sprite, 0);
    
    auto job = CC_SCHEDULE_SELECTOR(HelloWorld::goFrameSelect);
    this->scheduleOnce(job, 1.0f);
    
    return true;
}
Example #28
0
void TimeSig::styleChanged()
      {
      if (scaleStyle == PropertyFlags::STYLED)
            setScale(score()->styleV(StyleIdx::timesigScale).toSizeF());
      Element::styleChanged();
      }
PositionComponent::PositionComponent(glm::vec3 n_pos, glm::vec4 n_rot, glm::vec3 n_sca)
{
    setPosition(n_pos);
    setRotation(n_rot);
    setScale(n_sca);
}
Example #30
0
void ImageView::setScale(double s){
	setScale(s, s);
}