实现超级玛丽上下左右运动

比眉伴天荒 2022-08-21 01:27 228阅读 0赞

### 用Cocos2dx实现超级玛丽，首先用帧循环定时器判断方向，再在类中实现运行以及判断是否能运动。 ###

## 方向控制 ##

void LayerGame::moveMario(float dt)
    {
    #ifdef WIN32
        short key;
    
        key = GetKeyState('F');
        if (key < 0) _marioDir = Common::RIGHT;
    
        key = GetKeyState('D');
        if (key < 0) _marioDir = Common::LEFT;
    
        key = GetKeyState('J');
        if (key < 0)_mario->jump();
    
    #endif
    
        if (_marioDir==Common::LEFT)
        {
            //CCLog("left\n");
            _marioDir=Common::NONE;
            _mario->moveLeft(dt);
    
        }else if(_marioDir==Common::RIGHT)
        {
            //CCLog("right\n");
            _marioDir=Common::NONE;
            _mario->moveRight(dt);
        }else
        {
            //CCLog("stop\n");
            _menuShow->setTexture(_textureDirNone);
            _mario->stop();
        }
    
        _mario->moveUp(dt);
        _mario->moveDown(dt);
    }

## 判断是否能向上，向左，向右，向下运动，利用碰撞检测 ##

bool Mario::canMoveLeft(float dt)
    {
        //judge if mario is out of the map
        CCRect rcMario=this->boundingBox();
        CCPoint ptMario=ccp(rcMario.getMinX(),rcMario.getMinY());
        CCTMXTiledMap *map=getMap();
        CCPoint ptMarioInWorld=map->convertToWorldSpace(ptMario);
        if (ptMarioInWorld.x-dt*_speed<0)   
        {
            return false;
        }
    
        //judge if partition by a wall
        CCPoint pt[3];
        pt[0] = ccp(rcMario.getMinX() - dt*_speed, rcMario.getMidY());
        pt[1] = ccp(rcMario.getMinX() - dt*_speed, rcMario.getMinY());
        pt[2] = ccp(rcMario.getMinX() - dt*_speed, rcMario.getMaxY());
    
        //transform position,change pt into tile and get gid to decide whether be stoped by wall
        for(int i=0;i<3;i++)
        {
            if (pt[i].y >= map->getContentSize().height)
                continue;
            CCPoint ptTile=Common::Point2Tile(map,pt[i]);
            //wall water pipe and floor
            static const char* layerName[3] = { "block", "pipe", "land" };
            for(int j=0;j<3;j++)
            {
                CCTMXLayer *layer=map->layerNamed(layerName[j]);
                int gid=layer->tileGIDAt(ptTile);
                if (gid!=0)
                {
                    return false;
                }
            }
    
        }
    
    
        return true;
    }
    bool Mario::canMoveRight(float dt)
    {
        CCRect rcMario = boundingBox();
        CCTMXTiledMap* map = getMap();
        CCPoint pt[3];
        pt[0] = ccp(rcMario.getMaxX() + dt*_speed, rcMario.getMidY());
        pt[1] = ccp(rcMario.getMaxX() + dt*_speed, rcMario.getMinY());
        pt[2] = ccp(rcMario.getMaxX() + dt*_speed, rcMario.getMaxY());
    
        // 坐标转换，将pt转化成地图格子坐标,然后获取gid，判断gid是不是被阻挡
        for (int i = 0; i < 3; ++i)
        {
            if (pt[i].y >= map->getContentSize().height)
                continue;
    
            CCPoint ptTile = Common::Point2Tile(map, pt[i]);
            // 水管、砖头，地板
            static const char* layerName[3] = { "block", "pipe", "land" };
            for (int j = 0; j < 3; ++j)
            {
                CCTMXLayer* layer = map->layerNamed(layerName[j]);
                int gid = layer->tileGIDAt(ptTile);
                if (gid != 0)
                {
                    return false;
                }
            }
        }
        return true;
    }
    bool Mario::canMoveDown(float dt)
    {
        CCRect rcMario = boundingBox();
        CCTMXTiledMap* map = getMap();
        CCPoint pt[3];
        //dt*_speedDown
        pt[0] = ccp(rcMario.getMidX(), rcMario.getMinY() - dt*_speedDown);
        pt[1] = ccp(rcMario.getMinX(), rcMario.getMinY() - dt*_speedDown);
        pt[2] = ccp(rcMario.getMaxX(), rcMario.getMinY() - dt*_speedDown);
    
        if (pt[0].y >= map->getContentSize().height)
            return true;
    
        // 坐标转换，将pt转化成地图格子坐标,然后获取gid，判断gid是不是被阻挡
        for (int i = 0; i < 3; ++i)
        {
            CCPoint ptTile = Common::Point2Tile(map, pt[i]);
            // 水管、砖头，地板
            static const char* layerName[3] = { "block", "pipe", "land" };
            for (int j = 0; j < 3; ++j)
            {
                CCTMXLayer* layer = map->layerNamed(layerName[j]);
                int gid = layer->tileGIDAt(ptTile);
                if (gid != 0)
                {
                    // 微调
                    CCPoint ptLB = Common::Tile2PointLB(map, ptTile+ccp(0, -1));
                    this->setPositionY(ptLB.y);
    
                    return false;
                }
            }
        }
    
        return true;
    }
    bool Mario::canMoveUp(float dt)
    {
        CCRect rcMario = boundingBox();
        CCTMXTiledMap* map = getMap();
        CCPoint pt[3];
        pt[0] = ccp(rcMario.getMidX(), rcMario.getMaxY() + dt*_speedUp);
        pt[1] = ccp(rcMario.getMinX(), rcMario.getMaxY() + dt*_speedUp);
        pt[2] = ccp(rcMario.getMaxX(), rcMario.getMaxY() + dt*_speedUp);
    
        if (pt[0].y >= map->getContentSize().height)
            return true;
    
        // 坐标转换，将pt转化成地图格子坐标,然后获取gid，判断gid是不是被阻挡
        for (int i = 0; i < 3; ++i)
        {
            CCPoint ptTile = Common::Point2Tile(map, pt[i]);
            // 水管、砖头，地板
            static const char* layerName[3] = { "block", "pipe", "land" };
            for (int j = 0; j < 3; ++j)
            {
                CCTMXLayer* layer = map->layerNamed(layerName[j]);
                int gid = layer->tileGIDAt(ptTile);
                if (gid != 0)
                {
                    // 微调
                    CCPoint ptLB = Common::Tile2PointLB(map, ptTile);
                    this->setPositionY(ptLB.y);
    
                    return false;
                }
            }
        }
    
        return true;
    }

### 运行实现 ###

void Mario::moveLeft(float dt)
    {
        if (_dirRun!=Common::LEFT)
        {
            _dirRun=Common::LEFT;
            _dirFace=Common::LEFT;
            updateStatus();
        }
        if (!canMoveLeft(dt))
            return;
        Common::moveNode(this,ccp(-dt*_speed,0));
    
        //scroll map
        CCNode *map=this->getParent();
        CCPoint ptWorld=map->convertToWorldSpace(this->getPosition());
        if (ptWorld.x<winSize.width/2&&map->getPositionX()<0)
        {
            Common::moveNode(map,ccp(dt*_speed,0));
        }
    }
    
    void Mario::moveRight(float dt)
    {
        if (_dirRun!=Common::RIGHT)
        {
            _dirRun=Common::RIGHT;
            _dirFace=Common::RIGHT;
            updateStatus();
        }
        if (!canMoveRight(dt))
            return;
        Common::moveNode(this,ccp(dt*_speed,0));
    
        //scroll map
        CCNode *map=this->getParent();
        CCPoint ptWorld=map->convertToWorldSpace(this->getPosition());
        if (ptWorld.x>winSize.width/2)
        {
            Common::moveNode(map,ccp(-dt*_speed,0));
        }
    }
    
    void Mario::moveUp(float dt)
    {
        if (_speedUp<=0)
        {
    
            return;
        }
        if (!canMoveUp(dt))
        {
            // 反弹效果
            _speedDown = _speedUp;
            _speedUp = 0; // 不继续上升了
            return;
        }
    
        Common::moveNode(this,ccp(0,dt*_speedUp));
        _speedUp-=_speedAcc;
        //_speedDown=_speedUp;
    }
    void Mario::moveDown(float dt)
    {
        if(_speedUp<=0)
        {
    
        if (canMoveDown(dt))
        {
            if (_bFly==false)
            {
                _bFly=true;
                updateStatus();
            }
            Common::moveNode(this,ccp(0,-dt*_speedDown));
            _speedDown+=_speedAcc;
        }
        else
        {
            if (_bFly)
            {
    
                _bFly = false;
                _speedDown = _speedAcc;
                updateStatus();
            }
    
        }
        }
    
    }
    
    void Mario::stop()
    {
        if (_dirRun!=Common::NONE)
        {
            _dirRun=Common::NONE;
            updateStatus();
        }
    }
    void Mario::jump()
    {
        static int i=0;
        CCLog("speed%d=%d",++i,_speedUp);
        if (_bFly)
            return;
        _speedUp=300;
        _bFly=true;
        updateStatus();
    }

### 运行状态机，控制运行时的动画 ###

void Mario::updateStatus()
    {
        stopAllActions();
        if (_bFly)
        {
            if (_dirFace==Common::LEFT)
            {
                setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName("SmallJumpLeft"));
            }else if(_dirFace==Common::RIGHT)
            {
                setDisplayFrame(CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName("SmallJumpRight"));
            }
            return;
        }
    
        if (_dirRun==Common::LEFT)
        {
            this->runAction(CCRepeatForever::create(CCAnimate::create(CCAnimationCache::sharedAnimationCache()->animationByName("SmallWalkLeft"))));
    
        }else if (_dirRun==Common::RIGHT)
        {
            this->runAction(CCRepeatForever::create(CCAnimate::create(CCAnimationCache::sharedAnimationCache()->animationByName("SmallWalkRight"))));
        }else
        {
            if (_dirFace==Common::LEFT)
            {
                this->setDisplayFrameWithAnimationName("SmallWalkLeft",0);
            }else if(_dirFace==Common::RIGHT)
            {
                this->setDisplayFrameWithAnimationName("SmallWalkRight",0);
            }
        }
    }

注：在实现这个功能的时候，由于把等于写成赋值，发生了许多灵异的错误，要小心啊，等于与赋值。

### 运行结果 ###

![结果][20160309205311994]

[20160309205311994]: /images/20220731/1263bb1a82794ecba39929076bd53d8f.png