void Guitar::PlaceNote(double t, int s, int f)
{
if(f < 0 || f > 24)
return;
Node* n = new Node;
Sprite* spr = new Sprite(snote);
n->addChild(spr);
Node* num = new Node;
num->addChild(new Label(tnote[f]));
num->setPosition(vec(0,-0.35f));
num->setScale(vec(0.7f, 0.7f));
n->addChild(num);
n->setPosition(bstring[s]);
n->setScale(vec(0.4f, 0.4f));
float brightness = 0.7f;
float dark = 0.1f;
switch(s)
{
case 0:
spr->setColor(vec(brightness, dark, dark, 1));
break;
case 1:
spr->setColor(vec(brightness, brightness, dark, 1));
break;
case 2:
spr->setColor(vec(dark, brightness, dark, 1));
break;
case 3:
spr->setColor(vec(dark, brightness, brightness, 1));
break;
case 4:
spr->setColor(vec(dark, dark, brightness, 1));
break;
case 5:
spr->setColor(vec(brightness, dark, brightness, 1));
break;
}
Fret* fr = new Fret;
fr->hit = false;
fr->s = s;
fr->f = f;
fr->t = t;
n->setUserData(fr);
fr->m = spr;
chart->addChild(n);
}
void MapEditer::OnMouseScroll(EventMouse* event)
{
Vector<Node*>& children = m_layer->getChildren();
for (int i = 0; i < children.size(); i++)
{
Node* child = children.at(i);
if (child->getBoundingBox().containsPoint(Vec2(event->getCursorX(), event->getCursorY())))
{
if ((float)event->getScrollY() < 0)
child->setScale(child->getScale() * 1.1f);
else
child->setScale(child->getScale() * 0.9f);
break;
}
}
}
void ColleageLayer::initcard()
{
Node* card = Node::create();
//¿¨ÅÆ¿ò
auto frame = Sprite::createWithSpriteFrameName("bigcard_frame_class2.png");
frame->setScale(1.1f);
card->addChild(frame);
//¿¨ÅÆÄÚÈÝ
auto card_content =Sprite::createWithSpriteFrameName("bigcard_0351.png");
card_content->setPosition(0, -10);
card->addChild(card_content);
//Ñ«ÕÂ
auto occupation = Sprite::createWithSpriteFrameName("icon_occupation_base4.png");
occupation->setPosition(23, -25);
occupation->setScale(1.3f);
card->addChild(occupation);
auto occupation_warrior_before = Sprite::createWithSpriteFrameName("icon_occupation_mage_button.png");
occupation_warrior_before->setScale(1.6f);
occupation_warrior_before->setPosition(73, -88);
card->addChild(occupation_warrior_before);
card->setScale(0.85f);
card->setPosition(123, 517);
this->addChild(card);
}
void GameMenu::onEnter(){
Layer::onEnter();
//入场动作
Size size = CCDirector::getInstance()->getWinSize();
Node* mainmenu = this->getChildByTag(3);
mainmenu->setScale(0);
mainmenu->runAction(Sequence::create(ScaleTo::create(0.5,1),CallFunc::create(CC_CALLBACK_0(GameMenu::menuEnter, this)),NULL));
}
void TerrainSample::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
{
if (evt == Touch::TOUCH_PRESS)
{
// If the FPS region is touched, toggle vsync (if platform supports it)
if (x >= 65 && x < 300 && y >= 18 && y <= 48)
{
_vsync = !_vsync;
setVsync(_vsync);
}
else if (_mode != MODE_LOOK)
{
// Ray sample
Ray pickRay;
_scene->getActiveCamera()->pickRay(Rectangle (0, 0, getWidth(), getHeight()), x, y, &pickRay);
PhysicsController::HitResult hitResult;
TerrainHitFilter hitFilter(_terrain);
if (Game::getInstance()->getPhysicsController()->rayTest(pickRay, 1000000, &hitResult, &hitFilter) && hitResult.object == _terrain->getNode()->getCollisionObject())
{
Node* clone = NULL;
PhysicsCollisionShape::Definition rbShape;
switch (_mode)
{
case MODE_DROP_SPHERE:
{
clone = _sphere->clone();
rbShape = PhysicsCollisionShape::sphere();
}
break;
case MODE_DROP_BOX:
{
clone = _box->clone();
rbShape = PhysicsCollisionShape::box();
}
break;
}
if (clone)
{
clone->setScale(10,10,10);
clone->setTranslation(hitResult.point.x, hitResult.point.y + 50, hitResult.point.z);
PhysicsRigidBody::Parameters rbParams(1);
clone->setCollisionObject(PhysicsCollisionObject::RIGID_BODY, rbShape, &rbParams);
_scene->addNode(clone);
clone->release();
_shapes.push_back(clone);
_mode = MODE_LOOK;
setMessage(NULL);
}
}
}
}
}
void Battle::playActionOver(cocostudio::Armature *armature, cocostudio::MovementEventType type, const char *name) {
if (armature == m_pReadygo) {
if (type == COMPLETE) {
removeChild(armature);
m_pReadygo = NULL;
unmask();
BIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);
g_pEventEngine->BundlerCall(BUND_ID_PLANE_FIRE, this, sizeof(this));
}
}
if (armature == m_pBossIn) {
if (type == COMPLETE) {
removeChild(armature);
m_pBossIn = NULL;
unmask();
const BossConfig * pconfig = g_pGameConfig->getBossConfig(m_pConfig->boss);
m_pBoss = Boss::create(pconfig);
addChild(m_pBoss, GRADE_ENEMY);
if (m_pConfig->boss != "chisezhilang") {
m_pBoss->setScale(g_pGameConfig->scaleEleMin);
} else {
m_pBoss->setScale(g_pGameConfig->scaleEleMin * 1.5);
}
m_pBoss->setPosition(Vec2(pconfig->pos.x * g_pGameConfig->scaleEleX, pconfig->pos.y * g_pGameConfig->scaleEleY));
m_pBoss->setRotation(pconfig->rotate);
ActionInterval * action = MoveBy::create(2, Vec2(0, -500 * g_pGameConfig->scaleEleY));
m_pBoss->runAction(Sequence::create(action, CallFuncN::create(this, callfuncN_selector(Battle::playbossAi)), NULL));
}
}
if (armature == m_pMissionVictory) {
if (type == COMPLETE) {
Node * icon = g_pGameConfig->getIcon(m_equip.model, m_equip.type);
icon->setPosition(Vec2(-200, -275));
icon->setScale(g_pGameConfig->scaleEleMin * 5);
m_pMissionVictory->addChild(icon, GRADE_UI);
icon->setOpacity(0);
ActionInterval * scale = ScaleTo::create(.5f, g_pGameConfig->scaleEleMin * 1.5);
ActionInterval * fadein = FadeIn::create(.5f);
icon->runAction(Spawn::create(scale, fadein, NULL));
UNBIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);
scheduleOnce(schedule_selector(Battle::returnMission), 2.0f);
}
}
if (armature == m_pMissionFaild) {
if (type == COMPLETE) {
UNBIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);
scheduleOnce(schedule_selector(Battle::returnMission), 2.0f);
}
}
}
// real item
void RealItem::Setup()
{
Node* num = new Node;
vlabel = new Label("arial", ": ", alignLeft);
vlabel->setColor(vec(1,1,1));
num->addChild(vlabel);
num->setPosition(vec(6, 0));
num->setScale(vec(0.5,0.5));
addChild(num);
}
// TestActionTimelineBlendFuncFrame
void TestActionTimelineBlendFuncFrame::onEnter()
{
ActionTimelineBaseTest::onEnter();
Node* node = CSLoader::createNode("ActionTimeline/skeletonBlendFuncFrame.csb");
ActionTimeline* action = CSLoader::createTimeline("ActionTimeline/skeletonBlendFuncFrame.csb");
node->runAction(action);
node->setScale(0.2f);
node->setPosition(VisibleRect::center());
this->addChild(node);
action->gotoFrameAndPlay(0);
}
void Item::Setup()
{
Node* header = new Node;
label = new Label("arial", name, alignLeft);
if(enabled) label->setColor(vec(1,1,1));
else label->setColor(vec(0.5,0.5,0.5));
header->addChild(label);
header->setPosition(vec(0, 0));
header->setScale(vec(0.5,0.5));
addChild(header);
}
Node *GameState::createTarget(int x, int y)
{
Node *node = new Node;
node->setMeshList(m_targetMesh);
node->setScale(glm::vec3{0.02f});
node->setPosition(gridCoordinatesToWorld(x, y) + kTargetAxisOffset);
node->setLight(&m_targetLight);
m_mazeNode->addChild(node);
m_targetNode = node;
return node;
}
void GameObjectManager::addUnit(const char* filename, const char* name, GameObjectConstructorProc constructor)
{
if (filename != NULL)
{
AutoRef<Scene> scene = Scene::load(filename)->Auto();
Node* root = Node::create("root");
root->setTag("dynamic");
Node* child = scene->getFirstNode();
Node* childNext;
while (child != NULL)
{
childNext = child->getNextSibling();
root->addChild(child);
child = childNext;
}
root->setScale(CHARACTER_SCALE, CHARACTER_SCALE, CHARACTER_SCALE);
scene->addNode(root);
root = root->clone();
Node* node = root->getFirstChild();
while (node)
{
Animation* animation = node->getAnimation("animations");
if (!animation)
{
animation = node->getAnimation(NULL);
}
if (animation)
{
std::string scenePath = Scene::getGPBPath(filename);
int pos = scenePath.find_last_of('.');
if (pos > 2)
{
std::string animationPath = scenePath.substr(0, pos);
animationPath.append(".animation");
animation->createClips(animationPath.c_str());
}
}
node = node->getNextSibling();
}
if (!_store)
{
_store = Scene::create("store")->Auto();
}
_store->addNode(root);
_units[name] = GameUnit(root, constructor);
}
else
{
_units[name] = GameUnit(NULL, constructor);
}
}
EffectButton::EffectButton(unsigned int id, Rect imageRect, Texture2D *texture)
: _id(id), _textWidth(40), _textHeight(40), _imageScale(0.8f), _label(1)
{
_width = 0;
_height = 0;
Node *effectButton = new Node();
Sprite *effectButtonImage = Sprite::createWithTexture(
texture,
imageRect
);
effectButtonImage->setAnchorPoint(ccp(0,0));
_effectCounter = LabelTTF::create(
std::to_string(_label).c_str(),
"Helvetica",
32,
CCSizeMake(_textWidth, _textHeight),
kTextAlignmentRight
);
_effectCounterStroke = LabelTTF::create(
std::to_string(_label).c_str(),
"Helvetica",
36,
CCSizeMake(_textWidth, _textHeight),
kTextAlignmentRight
);
_effectCounter->setPosition( ccp(
effectButtonImage->getContentSize().width - _textWidth/1.3,
_textHeight/2
)
);
_effectCounterStroke->setPosition( ccp(
effectButtonImage->getContentSize().width - _textWidth/1.3 - 2,
_textHeight/2 - 1
)
);
_effectCounterStroke->setColor( ccc3(0,0,0) );
effectButton->setScale(_imageScale);
effectButton->addChild(effectButtonImage, 1);
effectButton->addChild(_effectCounterStroke, 2);
effectButton->addChild(_effectCounter, 3);
_effectCounterStroke->setVisible(false);
_effectCounter->setVisible(false);
_width = effectButtonImage->getContentSize().width;
_height = effectButtonImage->getContentSize().height;
_button = effectButton;
}
void CircleMenu::update(float dt)
{
if (m_isMouseDown){
m_vx = (m_nowPoint.x - m_prePoint.x) * m_mouseMove;
if (m_vx > m_maxVx){
m_vx = m_maxVx;
}
if (m_vx < -m_maxVx){
m_vx = -m_maxVx;
}
m_prePoint = m_nowPoint;
}
else{
m_vx *= m_easing;
if (abs(m_vx) < 0.5) m_vx = 0;
}
Vector<Node*> vet = this->getChildren();
int length = vet.size();
for (int i = 0; i < length; i++)
{
Node* node = vet.at(i);
float *angel = static_cast<float*>(node->getUserData());
(*angel) += m_vx;
float angelValue = (*angel);
if (angelValue > 360){
angelValue -= 360;
}
else if (angelValue < -360){
angelValue += 360;
}
Size size = this->getContentSize();
node->setScale(0.3f + ((m_itemScaleA + m_itemScaleB * sin(CC_DEGREES_TO_RADIANS(angelValue)) / length) * 0.05f));
node->setPositionX(size.width / 2 - cos(CC_DEGREES_TO_RADIANS(angelValue)) * size.width / 2);
node->setPositionY(size.height / 2);
}
sort(vet.begin(), vet.end(), CircleMenu::sortOnDepth);
for (int i = length-1; i >=0; i--)
{
Node *pChild = vet.at(i);
float opacity = i == length - 1 ? 1 : m_noFocusOpacity;
pChild->setOpacity((GLubyte)255 * opacity);
pChild->setLocalZOrder(i);
}
}
// TestActionTimeline
void TestActionTimeline::onEnter()
{
ActionTimelineBaseTest::onEnter();
Data data = FileUtils::getInstance()->getDataFromFile("ActionTimeline/DemoPlayer.csb");
Node* node = CSLoader::createNode(data);
ActionTimeline* action = CSLoader::createTimeline(data, "ActionTimeline/DemoPlayer.csb");
node->runAction(action);
action->gotoFrameAndPlay(0);
node->setScale(0.2f);
node->setPosition(VisibleRect::center());
addChild(node);
}
void Guitar::PlaceBeat(double t)
{
Node* n = new Node;
Sprite* spr = new Sprite(sbeat);
n->addChild(spr);
n->setPosition(vec(bridgepos, bridgeheight));
n->setScale(vec(2,2));
Fret* fr = new Fret;
fr->t = t;
n->setUserData(fr);
beats->addChild(n);
}
void MyQGLWidget::wheelEvent(QWheelEvent* event)
{
if (event->orientation() == Qt::Vertical)
{
float step = (float)event->delta() / 3500.f;
Node* root = Director::sharedDirector()->getRunningScene();
if (root)
{
float scale = root->getScale();
scale += step;
scale = MIN(scale, 10);
scale = MAX(scale, .2);
root->setScale(scale);
}
}
}
//TestTimelineNodeLoadedCallback
void TestTimelineNodeLoadedCallback::onEnter()
{
ActionTimelineBaseTest::onEnter();
Node* node = CSLoader::createNode("ActionTimeline/DemoPlayer.csb", CC_CALLBACK_1(TestTimelineNodeLoadedCallback::nodeLoadedCallback,
this));
ActionTimeline* action = CSLoader::createTimeline("ActionTimeline/DemoPlayer.csb");
node->runAction(action);
action->gotoFrameAndPlay(0);
// ActionTimelineNode* node = CSLoader::createActionTimelineNode("ActionTimeline/DemoPlayer.csb", 0, 40, true);
node->setScale(0.2f);
node->setPosition(VisibleRect::center());
addChild(node);
}
// TestTimelineAnimationList
void TestTimelineAnimationList::onEnter()
{
ActionTimelineBaseTest::onEnter();
Node* node = CSLoader::createNode("ActionTimeline/DemoPlayer.csb");
ActionTimeline* action = CSLoader::createTimeline("ActionTimeline/DemoPlayer.csb");
cocostudio::timeline::AnimationInfo standinfo("stand", 0, 40);
cocostudio::timeline::AnimationInfo walkinfo("walk", 41, 81);
action->addAnimationInfo(standinfo);
action->addAnimationInfo(walkinfo);
node->runAction(action);
action->play("walk", true);
node->setScale(0.2f);
node->setPosition(150,100);
addChild(node);
}
// number item
void NumberItem::Setup()
{
if(vstrings)
{
int i=0;
while(vstrings[i].length()) i++;
maximum = max(0, i-1);
}
Node* num = new Node;
vlabel = new Label("arial", ": ", alignLeft);
vlabel->setColor(vec(1,1,1));
num->addChild(vlabel);
num->setPosition(vec(6, 0));
num->setScale(vec(0.5,0.5));
addChild(num);
}
// TestTimelinePerformance
void TestTimelinePerformance::onEnter()
{
ActionTimelineBaseTest::onEnter();
for (int i = 0; i< 100; i++)
{
Node* node = CSLoader::createNode("ActionTimeline/DemoPlayer.csb");
ActionTimeline* action = CSLoader::createTimeline("ActionTimeline/DemoPlayer.csb");
node->runAction(action);
action->gotoFrameAndPlay(41);
// ActionTimelineNode* node = CSLoader::createActionTimelineNode("ActionTimeline/DemoPlayer.csb", 41, 81, true);
node->setScale(0.1f);
node->setPosition(i*2,100);
addChild(node);
}
}
// TestFrameEvent
void TestTimelineFrameEvent::onEnter()
{
ActionTimelineBaseTest::onEnter();
Node* node = CSLoader::createNode("ActionTimeline/DemoPlayer.csb");
ActionTimeline* action = CSLoader::createTimeline("ActionTimeline/DemoPlayer.csb");
node->runAction(action);
action->gotoFrameAndPlay(0);
/*
ActionTimelineNode* node = CSLoader::createActionTimelineNode("ActionTimeline/DemoPlayer.csb", 0, 40, true);
ActionTimeline* action = node->getActionTimeline();
*/
node->setScale(0.2f);
node->setPosition(150,100);
addChild(node);
action->setFrameEventCallFunc(CC_CALLBACK_1(TestTimelineFrameEvent::onFrameEvent, this));
}
void loadNiNode(Niflib::NiAVObjectRef node, RefMap& refmap) {
//make a new node
Node *result = refmap.getNode(node);
//load data
result->setName(node->GetName());
result->setPosition(NifToGlmVec3(node->GetLocalTranslation()));
result->setRotation(NifToGlmQuat(node->GetLocalRotation().AsQuaternion()));
result->setScale(glm::vec3(node->GetLocalScale(),node->GetLocalScale(),node->GetLocalScale()));
for (Niflib::NiExtraDataRef& extradata: node->GetExtraData()) {
if (extradata->GetType().IsSameType(Niflib::NiStringExtraData::TYPE)) {
Niflib::NiStringExtraDataRef strdata = Niflib::DynamicCast<Niflib::NiStringExtraData>(
extradata);
if (strdata->GetData() == "NCO") {
refmap.hasCollision = false;
}
}
}
if (node->GetType().IsSameType(Niflib::NiTriShape::TYPE)) {
Niflib::NiTriShapeRef temp = Niflib::DynamicCast<Niflib::NiTriShape>(node);
Niflib::NiTriShapeDataRef tempdata = Niflib::DynamicCast<Niflib::NiTriShapeData>(temp->GetData());
loadNiTriShapeData(temp, tempdata, refmap);
}
else if (node->GetType().IsSameType(Niflib::RootCollisionNode::TYPE)) {
refmap.collisionnode = Niflib::DynamicCast<Niflib::RootCollisionNode>(node);
}
result->isVisible = node->GetVisibility();
//attach this node to its parent
Niflib::NiNodeRef parent = node->GetParent();
if (parent) {
Node *parnode = refmap.getNode(parent);
parnode->addChild(result);
}
refmap.currentModel->addNamedNode(node->GetName(), result);
}
void SelectiveScroll::drawSpriteUpdate() {
Size s = Director::getInstance()->getWinSize();
Vector<Node *> sprites = _container->getChildren();
for(int i = 0; i < sprites.size(); i++) {
Node * sprite = sprites.at(i);
int sprite_offset_x = fabs(s.width / 2 - (sprite->getPosition().x + sprite->getContentSize().width / 2 + _container->getPosition().x + this->getPosition().x));
if(sprite_offset_x > sprite->getContentSize().width) sprite_offset_x = sprite->getContentSize().width;
float scale = 0.5 * (float)sprite_offset_x / (float)sprite->getContentSize().width;
sprite->setScale(1 - scale);
if(i != 0) {
Node *temp = sprites.at(i - 1);
sprite->setPosition(Vec2(temp->getPosition().x + temp->getContentSize().width * temp->getScale() + 20, 0));
}
}
}
void Menu::Setup()
{
current = new Node;
Node* header = new Node;
Label* l = new Label("arial", name, alignCenter);
l->setColor(vec(1,1,0));
header->addChild(l);
header->setPosition(vec(0, 3));
header->setScale(vec(1,1));
current->addChild(header);
// add cursor
if(cursor == NULL)
{
cursor = new Node;
cursor->addChild(new Sprite(new Texture("pick")));
cursor->setCenter(vec(0.6f,0));
}
addChild(current);
cursorOffset = -0.1;
}
void Actor::setScale( Ogre::Real sx, Ogre::Real sy, Ogre::Real sz )
{
Node* node = getControlledObject()->getMovableObject()->getParentNode();
if( node )
{
Vector3 vec = Vector3(sx,sy,sz);
node->setScale( vec );
// Falls es sich um ein Mesh handelt ...
if( getControlledObject()->isMeshObject() )
{
MeshObject* meshObj = dynamic_cast<MeshObject*>( getControlledObject() );
// ... und größer/kleiner als normal skaliert wird ...
if( vec != Vector3(1,1,1) )
// ... müssen die Normalen neu berechnet werden.
meshObj->getEntity()->setNormaliseNormals( true );
else
meshObj->getEntity()->setNormaliseNormals( false );
}
}
}
// TestActionTimeline
void TestChangePlaySection::onEnter()
{
ActionTimelineBaseTest::onEnter();
Node* node = CSLoader::createNode("ActionTimeline/DemoPlayer.csb");
action = CSLoader::createTimeline("ActionTimeline/DemoPlayer.csb");
node->runAction(action);
action->gotoFrameAndPlay(41);
/*
ActionTimelineNode* node = CSLoader::createActionTimelineNode("ActionTimeline/DemoPlayer.csb", 41, 81, true);
action = node->getActionTimeline();
*/
node->setScale(0.2f);
node->setPosition(VisibleRect::center());
// add touch event listener
auto listener = EventListenerTouchAllAtOnce::create();
listener->onTouchesEnded = CC_CALLBACK_2(TestChangePlaySection::onTouchesEnded, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
addChild(node);
}
//點擊後特效
void GameScene::createBomb(ClippingNode *target, int point)
{
_score+=point;
_touchArray[target->getTag()] = false;
Node * nBomb = Node::create();
Vec2 pos = target->getPosition();
nBomb->setPosition(pos.x + 50, pos.y + 100);
nBomb->setScale(_scale);
this->addChild(nBomb, 30);
Sprite *sBomb = Sprite::createWithSpriteFrameName("download_bomb.png");
nBomb->addChild(sBomb);
Sprite *sScore = Sprite::createWithSpriteFrameName(__String::createWithFormat("download_word_%d.png",point)->getCString());
nBomb->addChild(sScore);
auto curveMove = Show::create();
FiniteTimeAction* hideAction = Hide::create();
ActionInterval* delay = Sequence::create(curveMove, DelayTime::create(0.3), hideAction, NULL);
nBomb->runAction(delay);
}
void Guitar::MakeGuitar()
{
Node* neck = new Node;
neck->addChild(new Sprite(new Texture("neck")));
neck->setScale(vec(4,4));
Node* head = new Node;
head->addChild(new Sprite(new Texture("head")));
head->setScale(vec(4,4));
head->setPosition(vec(-9, 0));
Node* nut = new Node;
nut->addChild(new Sprite(new Texture("nut")));
nut->setPosition(vec(nutpos, neckpos));
nut->setScale(vec(2, 2));
body = new Node;
body->addChild(new Sprite(new Texture("body")));
body->setPosition(vec(11.5f, -0.02));
body->setScale(vec(16,16));
chart = new Node;
beats = new Node;
addChild(body);
addChild(neck);
addChild(head);
addChild(beats);
addChild(nut);
Node* s = new Node;
strings[0] = new LineSprite(new Texture("bstring.tga"));
s->addChild(strings[0]);
nstring[0] = vec(nutpos - 0.05f, neckpos - neckspace * 2.5f);
bstring[0] = vec(bridgepos, bridgeheight - bridgespace * 2.5f);
s->setPosition(nstring[0]);
strings[0]->setThickness(0.08);
strings[0]->setLine(bstring[0] - nstring[0]);
LineSprite* nstr = new LineSprite(new Texture("bstring.tga"));
nstr->setThickness(0.08);
nstr->setLine(vec(-1.9, -0.04));
s->addChild(nstr);
addChild(s);
s = new Node;
strings[1] = new LineSprite(new Texture("bstring.tga"));
s->addChild(strings[1]);
nstring[1] = vec(nutpos - 0.05f, neckpos - neckspace * 1.5f);
bstring[1] = vec(bridgepos, bridgeheight - bridgespace * 1.5f);
s->setPosition(nstring[1]);
strings[1]->setThickness(0.06);
strings[1]->setLine(bstring[1] - nstring[1]);
nstr = new LineSprite(new Texture("bstring.tga"));
nstr->setThickness(0.06);
nstr->setLine(vec(-2.9, -0.26));
s->addChild(nstr);
addChild(s);
s = new Node;
strings[2] = new LineSprite(new Texture("bstring.tga"));
s->addChild(strings[2]);
nstring[2] = vec(nutpos - 0.05f, neckpos - neckspace * 0.5f);
bstring[2] = vec(bridgepos, bridgeheight - bridgespace * 0.5f);
s->setPosition(nstring[2]);
strings[2]->setThickness(0.05);
strings[2]->setLine(bstring[2] - nstring[2]);
nstr = new LineSprite(new Texture("bstring.tga"));
nstr->setThickness(0.05);
nstr->setLine(vec(-3.9, -0.54));
s->addChild(nstr);
addChild(s);
s = new Node;
strings[3] = new LineSprite(new Texture("tstring.tga"));
s->addChild(strings[3]);
nstring[3] = vec(nutpos - 0.05f, neckpos + neckspace * 0.5f);
bstring[3] = vec(bridgepos, bridgeheight + bridgespace * 0.5f);
s->setPosition(nstring[3]);
strings[3]->setThickness(0.04);
strings[3]->setLine(bstring[3] - nstring[3]);
nstr = new LineSprite(new Texture("tstring.tga"));
nstr->setThickness(0.04);
nstr->setLine(vec(-3.9, 0.54));
s->addChild(nstr);
addChild(s);
s = new Node;
strings[4] = new LineSprite(new Texture("tstring.tga"));
s->addChild(strings[4]);
nstring[4] = vec(nutpos - 0.05f, neckpos + neckspace * 1.5f);
bstring[4] = vec(bridgepos, bridgeheight + bridgespace * 1.5f);
s->setPosition(nstring[4]);
strings[4]->setThickness(0.03);
strings[4]->setLine(bstring[4] - nstring[4]);
nstr = new LineSprite(new Texture("tstring.tga"));
nstr->setThickness(0.03);
nstr->setLine(vec(-2.9, 0.26));
s->addChild(nstr);
addChild(s);
s = new Node;
strings[5] = new LineSprite(new Texture("tstring.tga"));
s->addChild(strings[5]);
nstring[5] = vec(nutpos - 0.05f, neckpos + neckspace * 2.5f);
bstring[5] = vec(bridgepos, bridgeheight + bridgespace * 2.5f);
s->setPosition(nstring[5]);
strings[5]->setThickness(0.02);
strings[5]->setLine(bstring[5] - nstring[5]);
nstr = new LineSprite(new Texture("tstring.tga"));
nstr->setThickness(0.02);
nstr->setLine(vec(-1.9, 0.04));
s->addChild(nstr);
addChild(s);
addChild(chart);
setCenter(vec(3,0,0));
}
void Guitar::update(float timeDelta)
{
Node::update(timeDelta);
if(!running)
return;
if(stopped && timeDelta < 0.2)
return;
float d2 = 0;
double cdelta;
if(speed != 0)
{
d2 = timeDelta * speed;
realtime += d2;
cdelta = d2 * spacing;
}
else
{
if(stopped)
{
cdelta = 0;
//current = stopped;
}
else
{
d2 = timeDelta;
realtime += d2;
cdelta = d2 * spacing;
}
}
current += cdelta;
if(!playing && realtime > backdelay)
{
if(speed == 1)
playing = !Audio::playMusic();
else if(d2 > 0)
Audio::advanceMusic(d2);
}
if(!stopped)
{
// place beat lines
while(bar != tab->b.end() && current + offset > count3)
{
if(bar->end > repcount)
{
repcount++;
bar = repb;
col = repc;
}
count3 += 240 / tempo * spacing;
bar++;
if(bar->tempo != -1)
tempo = bar->tempo;
if(bar->begin)
{
repb = bar;
repc = col;
repcount = 0;
}
if(bar == tab->b.end())
{
finished = true;
}
}
while(col != tab->c.end() && current + offset > count2)
{
PlaceBeat(count2);
count2 += 60 / tempo * spacing;
}
// place new notes
while(col != tab->c.end() && current + offset > count)
{
for(int s=0; s<6; s++)
{
if(col->a[s] != -1)
{
PlaceNote(count, s, col->a[s]);
if(col->e[s] & EFFECT_BEND)
{
double dur = col->l * 240 / tempo * spacing;
double t = 0.0;
for(int i=0; i<col->bend.size(); i++)
{
t += col->bend[i].x / 60.0;
PlaceNote(count + dur * t, s,
col->a[s] + col->bend[i].y/50);
}
}
break;
}
}
if(col->flags & FLAG_DOT)
count += 1.5f * col->l * 240 / tempo * spacing;
else
count += col->l * 240 / tempo * spacing;
col++;
}
}
// update positions
list<Fret> frets;
for(Renderable* r = chart->children; r; r=r->next)
{
Node* note = (Node*)r;
Fret* fr = static_cast<Fret*>(note->getUserData());
float x = fr->t - current;
vec pos = note->getPosition();
pos.x = x;
vec str = bstring[fr->s] - nstring[fr->s];
pos.y = (nstring[fr->s] + (str * ((x - nstring[fr->s].x)/str.x))).y;
note->setPosition(pos);
if(!scorer && pos.x < nutpos)
{
chart->removeChild(note); // autoplay
}
else if(pos.x < nutpos - tolerance)
{
if(fr)
frets.push_back(*fr);
float a = 1 + (pos.x - nutpos - tolerance) / 0.75f;
if(a <= 0)
chart->removeChild(note);
else
fr->m->setColor(vec(0.5f, 0.5f, 0.5f, 1));
}
}
for(Renderable* r = beats->children; r; r=r->next)
{
Node* beat = (Node*)r;
Fret* fr = static_cast<Fret*>(beat->getUserData());
float x = fr->t - current;
vec pos = beat->getPosition();
vec scal = beat->getScale(); // in progress
pos.x = x;
scal.y = scal.y - cdelta * neckscale;
beat->setPosition(pos);
beat->setScale(scal);
if(pos.x < nutpos)
{
beats->removeChild(beat);
if(!playing || !scorer)
Audio::tick();
}
}
/*
// note reached
if(scorer)
{
if(frets.size() > 0)
{
scorer->Test(frets);
}
if(scorer->HasResults())
{
if(speed == 0)
stopped = current;
list<Fret> f;
f = scorer->GetResult();
list<Fret>::iterator fi = f.begin();
for(fi = f.begin(); fi != f.end(); fi++)
{
if(!fi->hit)
{
combo = 0;
multiplier = 1;
}
else
{
chart->removeChild(fi->m);
if(multiplier < 4)
{
combo++;
if(combo > 8)
{
multiplier++;
if(multiplier < 4)
combo = 0;
}
}
if(stopped)
frets.clear();
stopped = 0;
score += 10 * speed * multiplier * f.size();
}
}
}
*/
// update score text
/*std::ostringstream s;
s << "Score: " << score << "\n"
<< "Multiplier: " << multiplier << "X ";
for(int i=0; i< 8; i++)
{
if(i<combo)
s << "+";
else
s << "-";
}
s << "\nNote: " << scorer->lastnote << " Volume: " << Audio::readVol();
scoreText->setText(s.str());*/
//}
}
void Karillin::changeState(artemis::Entity &e){
StateComponent* state = (StateComponent*)e.getComponent<StateComponent>();
CharacterInfoComponent* characterInfo = (CharacterInfoComponent*)e.getComponent<CharacterInfoComponent>();
SkeletonComponent* characterSkeleton = (SkeletonComponent*)e.getComponent<SkeletonComponent>();
if (state->state == R::CharacterState::ATTACK){
PosComponent* position = (PosComponent*)e.getComponent<PosComponent>();
AttackComponent* attackComponent = new AttackComponent();
attackComponent->whoAttack = ((CharacterTypeComponent*)e.getComponent<CharacterTypeComponent>())->type;
attackComponent->type = state->attack;
attackComponent->powerOfAttack = characterInfo->NORMAL_SKILL_POWER;
if (state->attack == R::Attack::KARILLIN_BEAT1){
actionBeat1(e, state->direction);
attackComponent->minX = position->x - 40;
attackComponent->maxX = position->x + 40;
attackComponent->minY = position->y - 80;
attackComponent->maxY = position->y + 80;
}
else if (state->attack == R::Attack::KARILLIN_BEAT2){
actionBeat2(e, state->direction);
attackComponent->minX = position->x - 60;
attackComponent->maxX = position->x + 60;
attackComponent->minY = position->y - 80;
attackComponent->maxY = position->y + 80;
}
else if (state->attack == R::Attack::KARILLIN_BEAT3){
actionBeat3(e, state->direction);
attackComponent->minX = position->x - 60;
attackComponent->maxX = position->x + 60;
attackComponent->minY = position->y - 40;
attackComponent->maxY = position->y + 140;
}
else if (state->attack == R::Attack::KARILLIN_PUNCH1){
actionPunch1(e, state->direction);
Node* node = RenderLayer::getInstance()->createGameNode();
node->setPosition(Vec2(position->x, position->y));
node->setScale(.2f);
KameKameHa* kame = new KameKameHa(node,R::CharacterType::KARILLIN);
kame->setTarget("goku");
kame->powerOfAttack = characterInfo->SPECIAL_SKILL_POWER;
kame->direction = (characterSkeleton->node->getScaleX() < 0) ? -1 : 1;
artemis::Entity &entity = EntityUtils::getInstance()->getWorld()->createEntity();
entity.addComponent(new SkillComponent(kame));
entity.refresh();
entity.setGroup("enemyattack");
characterInfo->power -= 40;
return;
}
else if (state->attack == R::Attack::KARILLIN_PUNCH2){
actionPunch2(e, state->direction);
attackComponent->minX = position->x - 80;
attackComponent->maxX = position->x + 80;
attackComponent->minY = position->y - 120;
attackComponent->maxY = position->y + 120;
}
else if (state->attack == R::Attack::KARILLIN_KICK1){
actionKick1(e, state->direction);
attackComponent->minX = position->x - 30;
attackComponent->maxX = position->x + 30;
attackComponent->minY = position->y - 30;
attackComponent->maxY = position->y + 30;
}
else if (state->attack == R::Attack::KARILLIN_KICK2){
actionKick2(e, state->direction);
attackComponent->minX = position->x - 30;
attackComponent->maxX = position->x + 30;
attackComponent->minY = position->y - 40;
attackComponent->maxY = position->y + 60;
}
else if (state->attack == R::Attack::KARILLIN_KICK3){
actionKick3(e, state->direction);
attackComponent->minX = position->x - 30;
attackComponent->maxX = position->x + 30;
attackComponent->minY = position->y - 40;
attackComponent->maxY = position->y + 60;
}
if (R::Constants::soundEnable){
CocosDenshion::SimpleAudioEngine::getInstance()->setEffectsVolume(R::Constants::soundVolumn);
CocosDenshion::SimpleAudioEngine::getInstance()->playEffect(R::Constants::ENEMY_ATTACK, false, 1, 0, 1);
}
EntityUtils::getInstance()->createAttackEntity(e, attackComponent);
state->state == R::CharacterState::STAND;
}
else if (state->state == R::CharacterState::DEFENSE){
EntityUtils::getInstance()->removeGroup("enemyattack");
if (R::Constants::soundEnable){
CocosDenshion::SimpleAudioEngine::getInstance()->setEffectsVolume(R::Constants::soundVolumn);
CocosDenshion::SimpleAudioEngine::getInstance()->playEffect(R::Constants::PUNCH, false, 1, 0, 1);
}
if (state->defense == R::Defense::TRUNG_DON) actionTrungDon(e, state->direction);
if (state->defense == R::Defense::TRUNG_DON_NGA) actionTrungDonNga(e, state->direction);
}
else if (state->state == R::CharacterState::WIN){ actionVictory(e); }
else if (state->state == R::CharacterState::DIE){
EntityUtils::getInstance()->removeGroup("enemyattack");
if (R::Constants::soundEnable){
CocosDenshion::SimpleAudioEngine::getInstance()->setEffectsVolume(R::Constants::soundVolumn);
CocosDenshion::SimpleAudioEngine::getInstance()->playEffect(R::Constants::ENEMY_DEATH, false, 1, 0, 1);
}
actionDie(e, state->direction); }
else if (state->state == R::CharacterState::START){ actionStart(e, state->direction); }
else if (state->state == R::CharacterState::STAND){ actionStand(e); }
else if (state->state == R::CharacterState::STAND_UP){ actionStandUp(e); }
else if (state->state == R::CharacterState::LEFT){ actionMove(e, R::Direction::LEFT); }
else if (state->state == R::CharacterState::RIGHT){ actionMove(e, R::Direction::RIGHT); }
else if (state->state == R::CharacterState::WALK_RIGHT){ actionMoveOn(e, R::Direction::RIGHT); }
else if (state->state == R::CharacterState::WALK_LEFT){ actionMoveOn(e, R::Direction::LEFT); }
else if (state->state == R::CharacterState::JUMP){ actionJump1(e, R::Direction::AUTO); }
}
