Esempio n. 1
0
void Ball::move()
{
	//stop();
	m_moving=true;
	runMoveAction();
}
Esempio n. 2
0
void Monster_UI::resetWay()
{
	sprite->stopAllActions();
	runMoveAction();
	isDone = true;
}
Esempio n. 3
0
bool TeachLayer::init(const cocos2d::Vec2 &stencilWorldPos, FingerDirection fingerDirection)
{
    if (!Layer::init())
    {
        return false;
    }
    
    _stencilPosition = stencilWorldPos;
    _fingerDirection = fingerDirection;
    
    Size winSize = Director::getInstance()->getWinSize();
    
    // bind touch event
    auto touchListener = EventListenerTouchOneByOne::create();
    touchListener->setSwallowTouches(true);
    // bind touch event
    touchListener->onTouchBegan = CC_CALLBACK_2(TeachLayer::onTouchBegan, this);
    touchListener->onTouchEnded = CC_CALLBACK_2(TeachLayer::onTouchEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener, this);
    
    // 裁剪图层
    auto pClip = ClippingNode::create();
    // 设置反相
    pClip->setInverted(true);
    
    // 蒙版
    auto colorLayer = LayerColor::create(Color4B(0, 0, 0, 180));
    pClip->addChild(colorLayer);
    
    // 模板初始化
    _stencilNode = DrawNode::create();
    // 绘制圆形区域
    float fRadius = 55.0f; // 圆的半径
    const int nCount = 100; // 圆形其实可以看做正多边形,我们这里用正100边型来模拟园
    const float coef = 2.0f * (float)M_PI / nCount; // 计算每两个相邻顶点与中心的夹角
    Vec2 circle[nCount]; // 顶点数组
    for(int i = 0;i < nCount; i++)
    {
        float rads = i*coef;//弧度
        circle[i].x = fRadius * cosf(rads); // 对应顶点的x
        circle[i].y = fRadius * sinf(rads); // 对应顶点的y
    }
    // 绘制这个多边形!
    _stencilNode->drawPolygon(circle, nCount, Color4F::GREEN, 0, Color4F::GREEN);
    
    _stencilNode->setPosition(winSize.width * 0.5, winSize.height * 0.5);
    // 设模板
    pClip->setStencil(_stencilNode);
    addChild(pClip);
    
    _stencilButton = SpriteButton::create("guide_circle.png", CC_CALLBACK_1(TeachLayer::stencilTouchCallBack, this));
    _stencilButton->setOpacity(0);
    _stencilButton->setPosition(winSize.width * 0.5, winSize.height * 0.5);
    addChild(_stencilButton);
    
    _fingerSprite = Sprite::createWithSpriteFrameName("finger_1.png");
    addChild(_fingerSprite);
    
    _fingerEffSprite = Sprite::createWithSpriteFrameName("finger_2.png");
    addChild(_fingerEffSprite);
    
    setStencilPosition(_stencilPosition);
    
    runMoveAction();
    
    return true;
}
Esempio n. 4
0
void TeachLayer::setFingerDirection(FingerDirection fingerDirection)
{
    Point stencilBtnPos = _stencilButton->getPosition();
    Size fingerSpriteSize = _fingerSprite->getContentSize();
    switch (fingerDirection)
    {
        case FingerDirection::Down:
        {
            _fingerMoveRangeX = 0;
            _fingerMoveRangeY = -DEFAULT_FINGER_MOVE_RANGE_Y;
            _fingerSprite->setFlippedY(false);
            _fingerEffSprite->setFlippedY(false);
            _fingerSprite->setPosition(stencilBtnPos.x,
                                       stencilBtnPos.y + fingerSpriteSize.height);
            break;
        }
        case FingerDirection::Up:
        {
            _fingerMoveRangeX = 0;
            _fingerMoveRangeY = DEFAULT_FINGER_MOVE_RANGE_Y;
            _fingerSprite->setFlippedY(true);
            _fingerEffSprite->setFlippedY(true);
            _fingerSprite->setPosition(stencilBtnPos.x,
                                       stencilBtnPos.y - fingerSpriteSize.height);
            break;
        }
        case FingerDirection::LeftDown:
        {
            _fingerMoveRangeX = DEFAULT_FINGER_MOVE_RANGE_X;
            _fingerMoveRangeY = -DEFAULT_FINGER_MOVE_RANGE_Y;
            _fingerSprite->setFlippedY(false);
            _fingerEffSprite->setFlippedY(false);
            _fingerSprite->setRotation(-45.0f);
            _fingerSprite->setPosition(stencilBtnPos.x - fingerSpriteSize.width * 0.75,
                                       stencilBtnPos.y + fingerSpriteSize.height * 0.75);
            break;
        }
        case FingerDirection::LeftUp:
        {
            _fingerMoveRangeX = DEFAULT_FINGER_MOVE_RANGE_X;
            _fingerMoveRangeY = DEFAULT_FINGER_MOVE_RANGE_Y;
            _fingerSprite->setFlippedY(true);
            _fingerEffSprite->setFlippedY(true);
            _fingerSprite->setRotation(45.0f);
            _fingerSprite->setPosition(stencilBtnPos.x - fingerSpriteSize.width * 0.75,
                                       stencilBtnPos.y - fingerSpriteSize.height * 0.75);
            break;
        }
        case FingerDirection::Left:
        {
            _fingerMoveRangeX = DEFAULT_FINGER_MOVE_RANGE_X;
            _fingerMoveRangeY = 0;
            _fingerSprite->setFlippedY(false);
            _fingerEffSprite->setFlippedY(false);
            _fingerSprite->setRotation(-90.0f);
            _fingerSprite->setPosition(stencilBtnPos.x - fingerSpriteSize.width,
                                       stencilBtnPos.y);
            break;
        }
        case FingerDirection::Right:
        {
            _fingerMoveRangeX = -DEFAULT_FINGER_MOVE_RANGE_X;
            _fingerMoveRangeY = 0;
            _fingerSprite->setFlippedY(false);
            _fingerEffSprite->setFlippedY(false);
            _fingerSprite->setRotation(90.0f);
            _fingerSprite->setPosition(stencilBtnPos.x + fingerSpriteSize.width,
                                       stencilBtnPos.y);
            break;
        }
        case FingerDirection::RightDown:
        {
            _fingerMoveRangeX = -DEFAULT_FINGER_MOVE_RANGE_X;
            _fingerMoveRangeY = -DEFAULT_FINGER_MOVE_RANGE_Y;
            _fingerSprite->setFlippedY(false);
            _fingerEffSprite->setFlippedY(false);
            _fingerSprite->setRotation(45.0f);
            _fingerSprite->setPosition(stencilBtnPos.x + fingerSpriteSize.width * 0.75,
                                       stencilBtnPos.y + fingerSpriteSize.height * 0.75);
            break;
        }
        case FingerDirection::RightUp:
        {
            _fingerMoveRangeX = -DEFAULT_FINGER_MOVE_RANGE_X;
            _fingerMoveRangeY = DEFAULT_FINGER_MOVE_RANGE_Y;
            _fingerSprite->setFlippedY(true);
            _fingerEffSprite->setFlippedY(true);
            _fingerSprite->setRotation(-45.0f);
            _fingerSprite->setPosition(stencilBtnPos.x + fingerSpriteSize.width * 0.75,
                                       stencilBtnPos.y - fingerSpriteSize.height * 0.75);
            break;
        }
        default:
            break;
    }
    _fingerEffSprite->setRotation(_fingerSprite->getRotation());
    _fingerEffSprite->setPosition(_fingerSprite->getPosition());
    
    runMoveAction();
}
Esempio n. 5
0
void RogueScene::touchEventExec(cocos2d::Point touchPoint)
{
    auto pMapLayer = (TMXTiledMap*)getChildByTag(kTiledMapTag);
    // マップ移動分を考慮
    MapIndex touchPointMapIndex = touchPointToIndex(touchPoint - pMapLayer->getPosition());
    CCLOG("onTouchBegan touchPointMapIndex x = %d y = %d", touchPointMapIndex.x, touchPointMapIndex.y);
    
    // 画面外判定
    if (isMapLayerOver(touchPointMapIndex))
    {
        // タッチ判定とみなさない
        return;
    }
    // タッチした位置が有効なIndexか判定
    MapIndex addMoveIndex = checkTouchEventIndex(touchPointMapIndex);
    if (addMoveIndex.x == 0 && addMoveIndex.y == 0)
    {
        // タッチ判定とみなさない
        return;
    }
    
    // キャラの向きを変更
    auto pActorSprite = getPlayerActorSprite(1);
    pActorSprite->runMoveAction(addMoveIndex);
    
    // 敵をタッチした
    auto pEnemyMapItem = m_mapManager.getActorMapItem(&touchPointMapIndex);
    if (pEnemyMapItem->mapDataType == MapDataType::ENEMY)
    {
        auto pPlayerDto = pActorSprite->getActorDto();
        auto pEnemyDto = getEnemyActorSprite(pEnemyMapItem->seqNo)->getActorDto();
        
        int damage = BattleLogic::exec(pPlayerDto, pEnemyDto);
        
        // 攻撃イベント
        logMessage("%sの攻撃: %sに%dのダメージ", pPlayerDto->name.c_str(), pEnemyDto->name.c_str(), damage);
    }
    else
    {
        // 障害物判定
        if (isTiledMapColisionLayer(touchPointMapIndex))
        {
            // TODO: ぶつかるSE再生
            logMessage("壁ドーン");
        }
        else
        {
            changeGameStatus(GameStatus::PLAYER_ACTION);
            
            // アイテムに重なったときの拾う処理
            auto pTouchPointMapItem = m_mapManager.getMapItem(&touchPointMapIndex);
            if (pTouchPointMapItem->mapDataType == MapDataType::MAP_ITEM)
            {
                // ドロップアイテムを拾う
                auto pDropMapItem = (DropMapItem*) pTouchPointMapItem;
                
                // TODO: 拾うSE再生
                
                // itemを取得
                auto pDropItemLayer = getChildByTag(RogueScene::kTiledMapTag)->getChildByTag(RogueScene::TiledMapTag::kTiledMapDropItemBaseTag);
                auto pDropItemSprite = (DropItemSprite*) pDropItemLayer->getChildByTag(RogueScene::TiledMapTag::kTiledMapDropItemBaseTag + pDropMapItem->seqNo);
                
                // メッセージログ
                auto pDropItemDto = pDropItemSprite->getDropItemDto();
                logMessage("%sを拾った。", pDropItemDto->name.c_str());
                
                // イベントリに追加する
                getItemWindowLayer()->addItemList(pDropItemDto);
                
                // mapManagerから消す
                m_mapManager.removeMapItem(pDropMapItem);
                
                // ミニマップを更新
                auto pMiniMapLayer = getChildByTag(kMiniMapTag);
                pMiniMapLayer->removeChildByTag(pDropItemSprite->getTag());
                
                // Map上からremoveする
                pDropItemLayer->removeChild(pDropItemSprite);
            }
            
            // 移動処理
            moveMap(addMoveIndex, pActorSprite->getActorMapItem()->seqNo, pActorSprite->getActorMapItem()->mapDataType, CallFunc::create([this](void) {
                changeGameStatus(GameStatus::ENEMY_TURN);
            }));
            
            // コールバックまでgameStatusを更新はしない
            return;
        }
    }
    
    // TODO: 会話
        // 会話イベント
    
    // ターン終了
    changeGameStatus(GameStatus::ENEMY_TURN);
}
Esempio n. 6
0
void RogueScene::enemyTurn()
{
    // モンスターの数だけ繰り返す
    std::list<ActorMapItem> enemyList = m_mapManager.findEnemyMapItem();
    for (ActorMapItem enemyMapItem : enemyList)
    {
        // ランダムでとどまるか移動するかきめる
        int rand = GetRandom(2, 2);
        if (rand == 1)
        {
            auto pEnemySprite = getEnemyActorSprite(enemyMapItem.seqNo);
            pEnemySprite->getActorMapItem()->moveDone = true;
            
            // とどまる
            logMessage("様子を見ている seqNo = %d", enemyMapItem.seqNo);
        }
        else if (rand == 2)
        {
            // プレイヤーに向かって移動 or プレイヤーに攻撃
            auto pPlayerActorSprite = getPlayerActorSprite(1);
            
            // プレイヤーの周辺で最もコストが低い箇所へ移動
            auto playerMapIndex = pPlayerActorSprite->getActorMapItem()->mapIndex;
            std::list<MapIndex> searchMapIndexList;
            searchMapIndexList.clear();
            
            // 右
            MapIndex searchMapIndex = playerMapIndex;
            searchMapIndex.x += 1;
            searchMapIndex.y += 0;
            searchMapIndex.moveDictType = MoveDirectionType::MOVE_LEFT;
            searchMapIndexList.push_back(searchMapIndex);
            // 左
            searchMapIndex = playerMapIndex;
            searchMapIndex.x += -1;
            searchMapIndex.y += 0;
            searchMapIndex.moveDictType = MoveDirectionType::MOVE_RIGHT;
            searchMapIndexList.push_back(searchMapIndex);
            // 上
            searchMapIndex = playerMapIndex;
            searchMapIndex.x += 0;
            searchMapIndex.y += 1;
            searchMapIndex.moveDictType = MoveDirectionType::MOVE_DOWN;
            searchMapIndexList.push_back(searchMapIndex);
            // 下
            searchMapIndex = playerMapIndex;
            searchMapIndex.x += 0;
            searchMapIndex.y += -1;
            searchMapIndex.moveDictType = MoveDirectionType::MOVE_UP;
            searchMapIndexList.push_back(searchMapIndex);
            
            // そもそもプレイヤーが隣接しているかチェック
            bool isPlayerAttack = false;
            {
                for (MapIndex mapIndex : searchMapIndexList)
                {
                    if (MAP_INDEX_DIFF(enemyMapItem.mapIndex, mapIndex))
                    {
                        isPlayerAttack = true;
                    }
                }
            }
            
            MapIndex moveMapIndex = enemyMapItem.mapIndex;
            if (isPlayerAttack)
            {
                // 攻撃
                moveMapIndex =pPlayerActorSprite->getActorMapItem()->mapIndex;
            }
            else
            {
                // 移動可能な経路情報を設定
                m_mapManager.createActorFindDist(enemyMapItem.mapIndex, enemyMapItem.moveDist);
                
                // 最も移動コストがかからない場所を抽出
                MapItem targetMoveDistMapItem = m_mapManager.searchTargetMapItem(searchMapIndexList);
                
                // 移動リスト作成
                if (targetMoveDistMapItem.mapDataType == MapDataType::MOVE_DIST)
                {
                    std::list<MapIndex> moveList = m_mapManager.createMovePointList(&targetMoveDistMapItem.mapIndex,
                                                                                    &enemyMapItem);
                    std::list<MapIndex>::iterator it = moveList.begin();
                    it++;
                    moveMapIndex = *it; // 2件目を取得(1件目は自分なので)
                    it = moveList.end();
                }
            }
            
            // 移動有無関係なく向きは変える
            auto pEnemySprite = getEnemyActorSprite(enemyMapItem.seqNo);
            MapIndex addMoveIndex = {
                moveMapIndex.x - pEnemySprite->getActorMapItem()->mapIndex.x,
                moveMapIndex.y - pEnemySprite->getActorMapItem()->mapIndex.y,
                m_mapManager.checkMoveDirectionType(moveMapIndex, pEnemySprite->getActorMapItem()->mapIndex)
            };
            pEnemySprite->runMoveAction(addMoveIndex);
            // 行動前にする
            pEnemySprite->getActorMapItem()->moveDone = false;
            pEnemySprite->getActorMapItem()->attackDone = false;
            
            if (isMapLayerOver(moveMapIndex))
            {
                CCLOG("移動不可 seqNo = %d (%d, %d)", enemyMapItem.seqNo, moveMapIndex.x, moveMapIndex.y);
                pEnemySprite->getActorMapItem()->moveDone = true;
            }
            else if (isTiledMapColisionLayer(moveMapIndex))
            {
                logMessage("壁ドーン seqNo = %d (%d, %d)", enemyMapItem.seqNo, moveMapIndex.x, moveMapIndex.y);
                pEnemySprite->getActorMapItem()->moveDone = true;
            }
            else if (m_mapManager.getActorMapItem(&moveMapIndex)->mapDataType == MapDataType::ENEMY)
            {
                if (MAP_INDEX_DIFF(enemyMapItem.mapIndex, moveMapIndex))
                {
                    //logMessage("待機 seqNo = %d (%d, %d)");
                }
                else
                {
                    logMessage("敵ドーン seqNo = %d (%d, %d)", enemyMapItem.seqNo, moveMapIndex.x, moveMapIndex.y);
                }
                pEnemySprite->getActorMapItem()->moveDone = true;
            }
            else if (m_mapManager.getActorMapItem(&moveMapIndex)->mapDataType == MapDataType::PLAYER)
            {
                auto pPlayerDto = pPlayerActorSprite->getActorDto();
                auto pEnemyDto = pEnemySprite->getActorDto();
                
                int damage = BattleLogic::exec(pEnemyDto, pPlayerDto);
                
                // 攻撃イベント
                logMessage("%sの攻撃: %sに%dダメージ", pEnemyDto->name.c_str(), pPlayerDto->name.c_str(), damage);
                
                pEnemySprite->getActorMapItem()->attackDone = true;
            }
            else
            {
                // 移動中のステータスへ
                changeGameStatus(GameStatus::ENEMY_ACTION);
                // 移動開始
                moveMap(addMoveIndex, enemyMapItem.seqNo, enemyMapItem.mapDataType, CallFuncN::create([this, pEnemySprite](Object* pObj) {

                    // 移動終わり次のモンスターへいきたいところ
                    // listをメンバ変数で持っちゃえばいけるか?
                    auto pEnemySprite = static_cast<ActorSprite*>(pObj);
                    pEnemySprite->getActorMapItem()->moveDone = true;
                    
                    bool isTurnEnd = true;
                    std::list<ActorMapItem> enemyList = m_mapManager.findEnemyMapItem();
                    for (ActorMapItem enemyMapItem : enemyList)
                    {
                        auto pEnemySprite = getEnemyActorSprite(enemyMapItem.seqNo);
                        auto pEnemyMapItem = pEnemySprite->getActorMapItem();
                        if (!pEnemyMapItem->moveDone && !pEnemyMapItem->attackDone)
                        {
                            isTurnEnd = false;
                            break;
                        }
                    }
                    if (isTurnEnd)
                    {
                        changeGameStatus(GameStatus::PLAYER_TURN);
                    }
                    else
                    {
                        changeGameStatus(GameStatus::ENEMY_TURN);
                    }
                }));
            }
        }
    }
    // 留まった時とかはここでターン終了
    if (m_gameStatus != GameStatus::ENEMY_ACTION)
    {
        changeGameStatus(GameStatus::PLAYER_TURN);
    }
    bool isTurnEnd = true;
    for (ActorMapItem enemyMapItem : enemyList)
    {
        auto pEnemySprite = getEnemyActorSprite(enemyMapItem.seqNo);
        auto pEnemyMapItem = pEnemySprite->getActorMapItem();
        if (!pEnemyMapItem->moveDone && !pEnemyMapItem->attackDone)
        {
            isTurnEnd = false;
            break;
        }
    }
}