人物行走碰撞测试码

最新推荐文章于 2025-05-01 23:18:15 发布
最新推荐文章于 2025-05-01 23:18:15 发布
阅读量203 收藏
点赞数
分类专栏： 鬼火引擎 Irrlicht 文章标签： 操作系统

使用的IDE：CodeBlocks 10.05
Irrlicht版本：1.8
操作系统：win7

 

项目结构：
Irrlicht test world-player-war
---Sources
   --src
     ----Faerie.cpp
     ----World.cpp
     ----main.cpp
----Headers
   --include
     ----EventReceiver.h
     ----Faerie.h
     ----World.h

 

#include "../include/World.h"
#include "../include/Faerie.h"
class World world;
class Faerie faerie1;
class Faerie faerie2;
int main(int argc, char* argv[])
{
    cEventReceiver eventReceiver;
    // 初始化世界
    world.Init();

    // 准备地图等场景
    world.Prepare();

    // 初始化要加载的精灵
    faerie1.Initialize(world.device,world.mapSelector,1);
    faerie2.Initialize(world.device,world.mapSelector,2);
    // 传入事务接收器
    world.device->setEventReceiver(&eventReceiver);

    // 主程序执行启动
    while(world.device->run() && (eventReceiver.Keys[KEY_ESCAPE] == false))
    {
        world.MainLoop(faerie1.faerieNode,&eventReceiver);
        faerie1.OnAnima(&eventReceiver);
    }
    world.Finish();

    return 0;
}

 

#ifndef WORLD_H
#include <irrlicht.h>
#include <sys/time.h>
#include <iostream>
#define WORLD_H


using namespace irr;
#include "EventReceiver.h"
using namespace core;
using namespace scene;
using namespace video;
using namespace io;

enum
{
	// I use this ISceneNode ID to indicate a scene node that is
	// not pickable by getSceneNodeAndCollisionPointFromRay()
	ID_IsNotPickable = 0,

	// I use this flag in ISceneNode IDs to indicate that the
	// scene node can be picked by ray selection.
	IDFlag_IsPickable = 1 << 0,
	//IDFlag_IsPickable = 0,

	// I use this flag in ISceneNode IDs to indicate that the
	// scene node can be highlighted.  In this example, the
	// homonids can be highlighted, but the level mesh can't.
	IDFlag_IsHighlightable = 1 << 1
	//IDFlag_IsHighlightable = 1
};

class World
{
public:
    World();
    virtual ~World();

     // 创建鼠标接收结构
    struct SMouseState
    {
        bool LeftButtonDown;
        SMouseState() : LeftButtonDown(false) { }
    } MouseState;

    const SMouseState & GetMouseState(void) const
    {
        return MouseState;
    }

    struct SParticleImpact
	{
		u32 when;
		core::vector3df pos;
		core::vector3df outVector;
	};
    //游戏主函数
    void Init();
	void Prepare();
	void MainLoop(IAnimatedMeshSceneNode* mainNode,cEventReceiver* eventReceiver);
	void Render();
	void Finish();

	// Irrlicht  vars
	IVideoDriver* driver;
	ISceneManager* smgr;
	//IGUIEnvironment* guienv;
	IrrlichtDevice *device;
	gui::IGUIEnvironment* gui;

    scene::ICameraSceneNode* fps_camera;
    scene::IParticleSystemSceneNode* ps;
    scene::ITriangleSelector* mapSelector;
    scene::ITriangleSelector* cubeSelector;
    scene::IParticleSystemSceneNode* campFire;
    scene::ITerrainSceneNode* terrain;
    scene::ISceneCollisionManager* collMan;
    scene::ISceneNode * selectedSceneNode;
    scene::IBillboardSceneNode * bill;

    scene::IParticleEmitter* em ;

    core::array<SParticleImpact> Impacts;
    core::stringw str;
protected:
private:
    void Play();
    void Shoot(core::vector3df start);
    void CreateParticleImpacts();
    bool hasEmitter;


    f32 speed;//3.f
    f32 camera_round;


    vector3df pFaerie;
    vector3df pCamera;
    core::line3d<f32> ray;
    core::vector3df intersection;

};

#endif // WORLD_H

  

#include "../include/World.h"
#include "../include/EventReceiver.h"

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;

World::World():
    hasEmitter(true)
{
    //ctor
}

World::~World()
{
    //dtor
}

//初始化world
void World::Init()
{
    //初始化参数
    camera_round = -28.f;

    core::dimension2d<u32> resolution ( 800, 600 );
    device = createDevice(EDT_OPENGL,
                          resolution, 32, false, true, false);
    device->setWindowCaption(L"World!");

    driver = device->getVideoDriver();
    smgr = device->getSceneManager();
    collMan = smgr->getSceneCollisionManager();
    gui = device->getGUIEnvironment();
    //生成摄像机
    fps_camera = smgr->addCameraSceneNodeFPS();
    fps_camera->setScale(vector3df(0.1f,0.1f,0.1f));
    fps_camera->setPosition(vector3df(5210.f,1000.f,3110.f));
    fps_camera->setRotation(vector3df(0.f,180.f,0.f));
    device->getCursorControl()->setVisible(false);

}
//准备
void World::Prepare()
{
    //加载地图
    IAnimatedMesh* mesh = smgr->getMesh("../../media/room.3ds");

    smgr->getMeshManipulator()->makePlanarTextureMapping(mesh->getMesh(0), 0.004f);
    ISceneNode* node = 0;

    scene::IAnimatedMeshSceneNode* animModel = smgr->addAnimatedMeshSceneNode(mesh);
    node = animModel;
    node->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(node->isDebugDataVisible()^scene::EDS_MESH_WIRE_OVERLAY));
    node->setMaterialFlag(EMF_LIGHTING, false);
    //创建选择器，附加到场景上
    mapSelector = smgr->createOctreeTriangleSelector(mesh,node);
    node->setTriangleSelector(mapSelector);

    node->setMaterialTexture(0, driver->getTexture("../../media/wall.jpg"));
    node->getMaterial(0).SpecularColor.set(0,0,0,0);
    node->setMaterialFlag(EMF_FOG_ENABLE, false);

    mesh = smgr->addHillPlaneMesh( "waterMesh",
                                   dimension2d<f32>(30,30),
                                   dimension2d<u32>(30,30), 0, 0,
                                   dimension2d<f32>(0,0),
                                   dimension2d<f32>(10,10));


    node = smgr->addWaterSurfaceSceneNode(mesh->getMesh(0), 3.0f, 300.0f, 30.0f);
    node->setPosition(vector3df(0,9,0));

    node->setMaterialTexture(0, driver->getTexture("../../media/stones.jpg"));
    node->setMaterialTexture(1, driver->getTexture("../../media/water.jpg"));

    node->setMaterialType(EMT_REFLECTION_2_LAYER);
    //node->setMaterialFlag(EMF_FOG_ENABLE, true);
    node->setDebugDataVisible(scene::EDS_OFF);
    node->setMaterialFlag(EMF_LIGHTING, false);
    //ISceneNode* terrain = smgr->addMeshSceneNode(smgr->getMesh("../../media/Irr2013123.irr"));
    //加载场景
    IMesh* cubeMesh = smgr->getMesh("../../media/data/smallcube.3ds");
    ISceneNode* cubeNode = smgr->addMeshSceneNode(cubeMesh);
    cubeNode->setMaterialTexture(0, driver->getTexture("../../media/data/crate.jpg"));
    cubeNode->setPosition(vector3df(140,100,40));
    //cubeNode->setScale(vector3df(3,3,2));
    cubeNode->setMaterialFlag(video::EMF_LIGHTING, false);
    cubeNode->setName("cube");
    smgr->addTextSceneNode(gui->getBuiltInFont(),
                           L"Cube-1",
                           video::SColor(100,255,255,255),	cubeNode);

    // Add the billboard.
    bill = smgr->addBillboardSceneNode();
    bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
    bill->setMaterialTexture(0, driver->getTexture("../../media/fireball.bmp"));
//	bill->setMaterialTexture();
    bill->setMaterialFlag(video::EMF_LIGHTING, false);
    bill->setMaterialFlag(video::EMF_ZBUFFER, false);
    bill->setSize(core::dimension2d<f32>(20.0f, 20.0f));
    bill->setID(ID_IsNotPickable); // This ensures that we don't accidentally ray-pick it
    //cubeNode->;
    //调试物理碰撞检测网格
    //cubeNode->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(cubeNode->isDebugDataVisible()^scene::EDS_MESH_WIRE_OVERLAY));

    cubeSelector = 0;
    cubeSelector = smgr->createTriangleSelector(cubeMesh,cubeNode);
    cubeNode->setTriangleSelector(cubeSelector);
    //selector->drop(); // We're done with this selector, so drop it now.


    // some lights
    /*video::SLight l;
    scene::ILightSceneNode *light = smgr->addLightSceneNode(gamescene,core::vector3df(50,50,50),video::SColorf(1,1,1,1.f),1000);
    l = light->getLightData();
    l.Type = video::ELT_POINT;
    l.AmbientColor = video::SColorf(.35,.35,.35);
    l.SpecularColor = video::SColorf(.7,.7,.5);
    l.DiffuseColor = video::SColorf(1,1,1);
    l.CastShadows = true;

    light->setLightData( l );*/


    //node = smgr->addOctreeSceneNode(mesh,0,0);
    //node->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(node->isDebugDataVisible()^scene::EDS_MESH_WIRE_OVERLAY));
    //创建地图选择器，附加到地图场景上


    //创建精灵碰撞响应动画
    scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
                                          mapSelector, cubeNode, cubeNode->getBoundingBox().MaxEdge,
                                          core::vector3df(0,-10,0),
                                          core::vector3df(0,0,0));

    cubeNode->addAnimator(anim);
    anim->drop();
    anim = 0;

    //创建粒子节点
    campFire = smgr->addParticleSystemSceneNode(false);
    campFire->setPosition(core::vector3df(100,120,600));
    campFire->setScale(core::vector3df(2,2,2));
    //创建粒子发生器（盒子）
    em = campFire->createBoxEmitter(
             core::aabbox3d<f32>(-7,0,-7,7,1,7),// emitter size
             core::vector3df(0.0f,0.06f,0.0f),  // initial direction
             80,100,                            // min and max emit rate
             video::SColor(1,255,255,255),      // darkest color
             video::SColor(1,255,255,255),      // brightest color
             800,2000,10,					// min and max age, angle
             dimension2df(10.f,10.f),		// min size
             dimension2df(20.f,20.f)        // max size
         );

    em->setMinStartSize(core::dimension2d<f32>(20.0f, 10.0f));
    em->setMaxStartSize(core::dimension2d<f32>(20.0f, 10.0f));
    campFire->setEmitter(em);
    em->drop();
    em = 0;
    //附加粒子效果
    scene::IParticleAffector* paf = campFire->createFadeOutParticleAffector();
    campFire->addAffector(paf);
    paf->drop();
    //设定粒子相关属性
    campFire->setMaterialFlag(video::EMF_LIGHTING, false);
    campFire->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
    campFire->setMaterialTexture(0, driver->getTexture("../../media/fireball.bmp"));
    campFire->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);


}
//主循环
void World::MainLoop(IAnimatedMeshSceneNode* mainNode,cEventReceiver* eventReceiver)
{

    pCamera= vector3df(mainNode->getPosition().X+sin(PI*fps_camera->getRotation().Y/180)*camera_round,
                       mainNode->getPosition().Y+20.f,
                       mainNode->getPosition().Z+cos(PI*fps_camera->getRotation().Y/180)*camera_round);
    fps_camera->setPosition(pCamera);

    str = L"Irrlicht Engine - Walker example [";
        str += driver->getName();
        str += "] ";
        str += "P:";
        str += fps_camera->getRotation().X;
        str += ",";
        str += fps_camera->getRotation().Y;
        str += ",";
        str += fps_camera->getRotation().Z;
        str += "|";
        str += mainNode->getPosition().X;
        str += ",";
        str += mainNode->getPosition().Y;
        str += ",";
        str += mainNode->getPosition().Z;
        device->setWindowCaption(str.c_str());
    /*if(fps_camera->getRotation().X<=6)
    {
        fps_camera->setRotation(vector3df(6,fps_camera->getRotation().Y,0));
    }
    if(72<=fps_camera->getRotation().X)
    {
        fps_camera->setRotation(vector3df(72,fps_camera->getRotation().Y,0));
    }*/
    ray.start = fps_camera->getPosition();
    ray.end = ray.start +  (fps_camera->getTarget()- ray.start).normalize() * 1000.0f;
    core::triangle3df hitTriangle;
    Play();
    selectedSceneNode = collMan->getSceneNodeAndCollisionPointFromRay(
                            ray,
                            intersection, // This will be the position of the collision
                            hitTriangle, // This will be the triangle hit in the collision
                            IDFlag_IsPickable, // This ensures that only nodes that we have
                            // set up to be pickable are considered
                            0); // Check the entire scene (this is actually the implicit default)
    if(selectedSceneNode)
    {
        bill->setPosition(ray.end);
        bill->setRotation(core::vector3df(fps_camera->getRotation().X,fps_camera->getRotation().Y,fps_camera->getRotation().Z));
        driver->setTransform(video::ETS_WORLD, core::matrix4());
        //driver->setMaterial(material);
        driver->draw3DTriangle(hitTriangle, video::SColor(0,255,0,0));
        //selectedSceneNode->setVisible(false);
        std::cout<<selectedSceneNode->getName()<<std::endl;
        std::cout<<selectedSceneNode->getPosition().X<<","<<selectedSceneNode->getPosition().Y<<","<<selectedSceneNode->getPosition().Z<<std::endl;
        //std::cout<<intersection.X<<","<<intersection.Y<<","<<intersection.Z<<std::endl;
        //std::cout<<hitTriangle.pointA<<","<<hitTriangle.pointB<<","<<hitTriangle.pointC<<std::endl;
        if(strcmp(selectedSceneNode->getName(),"cube")==0)
        {
            //selectedSceneNode->setPosition(mainNode->getPosition());
            std::cout<<"---------------stop-------------"<<std::endl;
            eventReceiver->Move=false;
            //mainNode->setMD2Animation(EMAT_STAND);
        }
        else
        {
            eventReceiver->Move=true;
        }

        if(eventReceiver->GetMouseState().LeftButtonDown)
        {
            std::cout<<"--------------------war-----------------------"<<std::endl;
            selectedSceneNode->setPosition(selectedSceneNode->getPosition()+1);
        }
        else
        {

        }
    }
    CreateParticleImpacts();

    Render();

}
//渲染
void World::Render()
{
    if (device->isWindowActive())
    {

        driver->beginScene(true, true, SColor(255,100,101,140));
        smgr->drawAll();
        driver->endScene();
        /*str = L"Irrlicht Engine - Walker example [";
        str += driver->getName();
        str += "] ";
        str += "P:";
        str += fps_camera->getRotation().X;
        str += ",";
        str += fps_camera->getRotation().Y;
        str += ",";
        str += fps_camera->getRotation().Z;
        device->setWindowCaption(str.c_str());*/
    }
}
//结束
void World::Finish()
{
    device->drop();
}

void World::Play()
{


    //鼠标事件
    if(GetMouseState().LeftButtonDown)
    {
        std::cout<<"click mouse"<<std::endl;
        Shoot(pFaerie);
    }

}

void World::Shoot(core::vector3df start)
{
    scene::ISceneManager* sm = device->getSceneManager();
    scene::ICameraSceneNode* camera = sm->getActiveCamera();

    if (!camera )
        return;

    SParticleImpact imp;
    imp.when = 0;

    // get line of camera

    //core::vector3df start = faerieNode->getPosition();
    core::vector3df end = (camera->getTarget() - start);
    end.normalize();
    start += end*8.0f;
    end = start + (end * camera->getFarValue());

    core::triangle3df triangle;

    core::line3d<f32> line(start, end);

    // get intersection point with map
    scene::ISceneNode* hitNode;
    if (sm->getSceneCollisionManager()->getCollisionPoint(
                line, mapSelector, end, triangle, hitNode))
    {
        // collides with wall
        core::vector3df out = triangle.getNormal();
        out.setLength(0.03f);

        imp.when = 1;
        imp.outVector = out;
        imp.pos = end;
    }
    else
    {
        // doesnt collide with wall
        //core::vector3df start = faerieNode->getPosition();
        core::vector3df end = (camera->getTarget() - start);
        end.normalize();
        start += end*8.0f;
        end = start + (end * camera->getFarValue());
    }

    // create fire ball
    scene::ISceneNode* node = 0;
    node = sm->addBillboardSceneNode(0,
                                     core::dimension2d<f32>(25,25), start);

    node->setMaterialFlag(video::EMF_LIGHTING, false);
    node->setMaterialTexture(0, device->getVideoDriver()->getTexture("../../media/fireball.bmp"));
    node->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);

    f32 length = (f32)(end - start).getLength();
    const f32 speed = 0.2f;
    u32 time = (u32)(length / speed);

    scene::ISceneNodeAnimator* anim = 0;

    // set flight line

    anim = sm->createFlyStraightAnimator(start, end, time);
    node->addAnimator(anim);
    anim->drop();

    anim = sm->createDeleteAnimator(time);
    node->addAnimator(anim);
    anim->drop();

    if (imp.when)
    {
        // create impact note
        imp.when = device->getTimer()->getTime() + (time - 100);
        Impacts.push_back(imp);
    }

}

void World::CreateParticleImpacts()
{
    u32 now = device->getTimer()->getTime();
    scene::ISceneManager* sm = device->getSceneManager();

    for (s32 i=0; i<(s32)Impacts.size(); ++i)
        if (now > Impacts[i].when)
        {
            // create smoke particle system
            scene::IParticleSystemSceneNode* pas = 0;

            pas = sm->addParticleSystemSceneNode(false, 0, -1, Impacts[i].pos);

            pas->setParticleSize(core::dimension2d<f32>(10.0f, 10.0f));

            scene::IParticleEmitter* em = pas->createBoxEmitter(
                                              core::aabbox3d<f32>(-5,-5,-5,5,5,5),
                                              Impacts[i].outVector, 20,40, video::SColor(50,255,255,255),video::SColor(50,255,255,255),
                                              1200,1600, 20);

            pas->setEmitter(em);
            em->drop();

            scene::IParticleAffector* paf = campFire->createFadeOutParticleAffector();
            pas->addAffector(paf);
            paf->drop();

            pas->setMaterialFlag(video::EMF_LIGHTING, false);
            pas->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
            pas->setMaterialTexture(0, device->getVideoDriver()->getTexture("../../media/smoke.bmp"));
            pas->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);

            scene::ISceneNodeAnimator* anim = sm->createDeleteAnimator(2000);
            pas->addAnimator(anim);
            anim->drop();

            // delete entry
            Impacts.erase(i);
            i--;
        }
}

 

#ifndef FAERIE_H
#define FAERIE_H
#include <irrlicht.h>
#include "World.h"

using namespace irr;
#include "EventReceiver.h"
using namespace core;
//using namespace scene;
//using namespace video;
//using namespace io;

class Faerie
{
public:
    Faerie();
    void Initialize(IrrlichtDevice *device,scene::ITriangleSelector* mapSelector,s32 n);
    //void setSelector(scene::ITriangleSelector* mapSelector);
    virtual ~Faerie();
    void OnAnima(cEventReceiver* eventReceiver);
    scene::IAnimatedMeshSceneNode* faerieNode;
protected:
private:

    void Move();
    void Turn_face(bool leftOrRight );

    f32 speed;//3.f
    vector3df pFaerie;
    bool turn_back;
    bool status;
    f32 lasttick;
    f32 pX;// 0.f;
    f32 pZ;// 0.f;
    f32 pR;// 0.f;

    IrrlichtDevice *f_device;
};

#endif // FAERIE_H

 

#ifndef CEVENTRECEIVER_H
#define CEVENTRECEIVER_H


class cEventReceiver : public IEventReceiver
{
public:

    cEventReceiver()
    {
        for (int i=0; i<KEY_KEY_CODES_COUNT; i++)
        {
            Keys[i] = false;
            KeysTemp[i] = false;
        }

        mouseX=mouseY=mouseDeltaX=mouseDeltaY=0;
        Move = true;
    }

    // 创建鼠标接收结构
    struct SMouseState
    {
        bool LeftButtonDown;
        SMouseState() : LeftButtonDown(false) { }
    } MouseState;

    const SMouseState & GetMouseState(void) const
    {
        return MouseState;
    }

    ~cEventReceiver() {}

    virtual bool OnEvent(const SEvent& event)
    {
        if (event.EventType==irr::EET_KEY_INPUT_EVENT)
        {
            Keys[event.KeyInput.Key] = false;
            Keys[event.KeyInput.Key] = event.KeyInput.PressedDown;
            return true;
        }

        if (event.EventType==irr::EET_MOUSE_INPUT_EVENT)
        {

            /*mouseX = event.MouseInput.X;
            mouseY = event.MouseInput.Y;
            mouseDeltaX = event.MouseInput.X - mouseX;
            mouseDeltaY = event.MouseInput.Y - mouseY;

            std::cout<<mouseDeltaX<<std::endl;
            return true;*/
        }
        if (event.EventType == irr::EET_MOUSE_INPUT_EVENT)
        {
            switch(event.MouseInput.Event)
            {
            case EMIE_LMOUSE_PRESSED_DOWN:
                MouseState.LeftButtonDown = true;

                break;
            case EMIE_LMOUSE_LEFT_UP:
                MouseState.LeftButtonDown = false;

                break;
            case EMIE_RMOUSE_PRESSED_DOWN:

                break;
            case EMIE_MOUSE_WHEEL:
                if(event.MouseInput.Wheel < 0 )
                {

                }
                else if(event.MouseInput.Wheel > 0 )
                {
                }
                break;
            case EMIE_MOUSE_MOVED:
                break;
            default:
                break;
            }
        }
        return false;
    }


    s32 mouseDeltaX;
    s32 mouseDeltaY;

    bool Keys[KEY_KEY_CODES_COUNT];
    bool KeysTemp[KEY_KEY_CODES_COUNT];
    bool Move;

    s32 mouseX;
    s32 mouseY;

private:

};


#endif // EVENTRECEIVER_H

 

#include "../include/Faerie.h"
#include "../include/EventReceiver.h"
#include <irrlicht.h>
Faerie::Faerie()
{
    //ctor
}

Faerie::~Faerie()
{
    //dtor
}

void Faerie::Initialize(IrrlichtDevice *device,scene::ITriangleSelector* mapSelector,s32 n)
{
    //初始化参数
    status = true;
    speed = 3.f;

    if(!device)
        return;
    f_device = device;
    //场景加入精灵
    scene::IAnimatedMesh* mesh;
    ISceneManager* smgr = f_device->getSceneManager();
    mesh = smgr->getMesh("../../media/sydney.md2");
    faerieNode = smgr->addAnimatedMeshSceneNode(mesh);

    smgr->addTextSceneNode(device->getGUIEnvironment()->getBuiltInFont(),
			L"sydney.md2",
			video::SColor(255,255,255,255),	faerieNode);
    //角色坐标设定
    faerieNode->setPosition(vector3df(-40,150,40));
    faerieNode->setScale(vector3df(1,1,1));
    IVideoDriver* driver = f_device->getVideoDriver();
    pFaerie = faerieNode->getPosition();
    faerieNode->setMaterialTexture(0,driver->getTexture("../../media/sydney.BMP"));

    //调试物理碰撞检测网格
    //faerieNode->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(faerieNode->isDebugDataVisible()^scene::EDS_MESH_WIRE_OVERLAY));
    faerieNode->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)(faerieNode->isDebugDataVisible()^scene::EDS_BBOX));
    //faerieNode->setAnimationSpeed(13);
    //faerieNode->setMD2Animation(EMAT_STAND);
    //faerieNode->setMD2Animation(EMAT_STAND);
    //faerieNode->setScale(vector3df(4.8f,4.8f,4.8f));
    if(n!=1)
    {
        faerieNode->setName((core::stringw)n+"sydney");
    }

    faerieNode->setMaterialFlag(video::EMF_LIGHTING, false);

    scene::ITriangleSelector* selector = 0;
    selector = smgr->createTriangleSelector(faerieNode);
	faerieNode->setTriangleSelector(selector);
	selector->drop(); // We're done with this selector, so drop it now.

    //创建精灵碰撞响应动画
    scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
                                          mapSelector, faerieNode, faerieNode->getBoundingBox().MaxEdge,
                                          core::vector3df(0,-10,0),
                                          core::vector3df(0,-7,0));

    faerieNode->addAnimator(anim);
    anim->drop();
    anim = 0;


}


void Faerie::OnAnima(cEventReceiver* eventReceiver)
{
    //std::cout<<faerieNode->getPosition().X<<","<<faerieNode->getPosition().Y<<","<<faerieNode->getPosition().Z<<std::endl;
    if(eventReceiver->Keys[KEY_KEY_W])
    {

        if(status)
        {
            status = false;
            faerieNode->setMD2Animation(EMAT_RUN);
        }
        if(eventReceiver->Move)
        {
            Move();
        }


    }
    else
    {
        status = true;
        faerieNode->setMD2Animation(EMAT_STAND);
    }

    if(eventReceiver->Keys[KEY_KEY_A])
    {
        if (f_device->getTimer()->getTime() > lasttick + 10)
        {
            lasttick = f_device->getTimer()->getTime();
            Turn_face(true);
        }

    }

    if(eventReceiver->Keys[KEY_KEY_D])
    {
        if (f_device->getTimer()->getTime() > lasttick + 10)
        {
            lasttick = f_device->getTimer()->getTime();
            Turn_face(false);
        }

    }

    if(eventReceiver->GetMouseState().LeftButtonDown)
    {
        std::cout<<"--------------------war-----------------------"<<std::endl;
        faerieNode->setMD2Animation(EMAT_ATTACK);
    }else
    {

    }
    /*if(eventReceiver->mouseDeltaX>0)
    {
        Turn_face(true);
    }
    else if(eventReceiver->mouseDeltaX<0)
    {
        Turn_face(false);
    }*/


}

void Faerie::Move()
{
    pFaerie = faerieNode->getPosition();
    pX = cos(faerieNode->getRotation().Y*PI/180)*speed;
    pZ = -sin(faerieNode->getRotation().Y*PI/180)*speed;
    faerieNode->setPosition(vector3df(pFaerie.X+pX,faerieNode->getPosition().Y,pFaerie.Z+pZ));

}

//转向
void Faerie::Turn_face(bool leftOrRight)
{
    pR = faerieNode->getRotation().Y;
    if(leftOrRight)
    {
        pR -=6;
        if(pR<0) pR = 360 + pR;
    }
    else
    {
        pR +=6;
        if(pR>360) pR = pR - 360;
    }
    faerieNode->setRotation(vector3df(faerieNode->getRotation().X,
                                      pR,faerieNode->getRotation().Z));

}

 

【纯JAVA语言做RPG游戏】3.地图碰撞检测和角色行走的实现
u013166799的专栏
10-31 3277
额⊙▽⊙... 上次做好了游戏的基本界面，地图也能成功的显示出来了，不过前面的游戏还没有实现角色与地图的碰撞检测，也就是说角色可以在地图上到处跑，无视那些树啊，石头什么的，这次的第一件事就是要检测角色与地图上物体的碰撞......再加上前面程序的玩家角色是用一个小球替代的，太丑了，这次换成一个动态的小LOLI，让它能够在地图上跑动起来 (╯▔▽▔)╯.....   首先，对上次的一些BU...
碰撞测试代码c语言,JavaScript碰撞检测原理及其实现代码
weixin_39907762的博客
05-18 922
本文实例为大家分享了JavaScript实现碰撞检测原的具体代码，供大家参考，具体内容如下1.模拟碰撞简单模拟碰撞过程,用一个可以拖拽的div2去尝试碰撞一个固定的div1(均用绝对定位)2.碰撞检测原理如图所示:使得div分别有4个距离属性( L(left),T(top),R(right),B(bottom) ).对于div1来说,画出一个九宫格,div2在除中心以为的8个格子任意移动都不会发送...
Python 超级玛丽代码实现(2):人物行走和碰撞检测
marble_xu的博客
08-23 9407
python 超级玛丽代码实现（2）：人物行走和碰撞判断人物行走碰撞判断 人物行走 游戏中的马里奥有几个状态，站立不动，向左或向右走，向上跳，向下蹲。 碰撞判断 使用pygame的精灵类 ...
java游戏开发碰撞,【纯JAVA语言做RPG游戏】3.map碰撞检测和角色行走的实现
weixin_39628160的博客
03-13 383
额⊙▽⊙...上次做好了游戏的基本界面，地图也能成功的显示出来了，不过前面的游戏还没有实现角色与地图的碰撞检测，也就是说角色可以在地图上到处跑，无视那些树啊，石头什么的，这次的第一件事就是要检测角色与地图上物体的碰撞......再加上前面程序的玩家角色是用一个小球替代的，太丑了，这次换成一个动态的小LOLI，让它能够在地图上跑动起来 (╯▔▽▔)╯.....首先，对上次的一些BUG进行改进：上次说...
android碰撞测试与SurfaceView
huangleijay的专栏
11-25 764
package game.project; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Color; import andr
three.js碰撞检测
weixin_52047574的博客
08-17 413
在Raycaster的intersectObjects方法中，如果遇到复杂且没有后代、单一的物体，这个运算会非常慢，因为据查资料这个方法会遍历有可能相交的物体（主要是Mesh）的每一个面，所以将这个复杂且单一的物体拆分会好一点，不会卡了。我估计是因为拆分之后没可能相交的部分早早就不参与运算了，所以减少了运算量。具体是不是这样还有待查证。主要是利用Raycaster来进行光线检测，检测光线射中的物体的距离是否小于规定距离，小于的话就视为要碰撞。
MMO碰撞检测，战斗，地图行走以及寻路问题
janker5的博客
10-18 3881
1. 碰撞检测 碰撞应该在服务端做，否则客户端就可以作弊了，但是服务端没有场景的几何信息，怎么做碰撞呢，方法是使用一张碰撞图，可以由美术生成，把接受碰撞的物体绘制成黑色，其他地方绘制成白色，对于边界和通道可以由美工在上面手动刷。 碰撞图生成之后，当客户端请求行走的时候，根据当前x, z位置和下一个x, z位置，可以计算出在碰撞图中的相应坐标，然后判断它们之间是否有黑色的像素，进而判断出是否会碰...
游戏场景测试
x_xingduo_2315的博客
06-17 2880
游戏场景在百度百科中的定义是游戏中的环境、建筑、机械、道具等。游戏场景通常可以理解为根据策划的要求还原出游戏中的建筑物、树木、天空、道路等可用元素（包含武器道具等）。游戏场景的测试不仅仅要测试上述部分，还包括了程序、用户体验等其他方面的问题。 在拿到了正式美术资源之后，首先关心的就是场景的寻路和碰撞问题。寻路是游戏中人可以行走的区域，碰撞是场景中得物体所占的空间。对于这2个问题，不同的游戏有着不同的处理方式。 有的是服务端有一份数据，客户端生成一份数据，然后2份数据进行对比就可以很方便的找出不一样的地方.
手机游戏人物与地图的碰撞
kbest的专栏
01-06 904
最近在做J2ME平台的坦克大战游戏做到地图和坦克的碰撞我采用的是状态机检测坦克方向，和在当前方向的坦克地图的碰撞下面是当坦克朝上的源代码其他三个方向和它类似 private void heroUpCheck() {//像上的碰撞检测  if(ifcolInt == true && ifrowInt == true)//坦克正好在地图的整数行列上，由于地图块是16*16而我定
VB开发安卓程序-4控制人物行走
04-22
在VB中开发安卓应用后，必须在实际设备或模拟器上进行调试和测试，确保人物行走功能在各种Android设备上都能正常工作。这包括兼容性测试、性能测试和用户体验测试。 7. **资源管理**： 游戏角色的图像资源需要...
45度角地图人物行走寻路
04-15
它可能包含了人物行走动画的展示，以及寻路算法的测试用例。开发者可以在这个测试环境中调试和优化寻路逻辑，确保人物在地图上的移动符合预期。 源码分析是理解这一技术的关键，通过查看PlayerTest的源代码，我们...
人物行走碰撞检测源码工具介绍
在计算机图形学和游戏开发领域，人物行走碰撞测试码是用于检测人物在虚拟世界中移动时与环境及其他对象之间可能发生碰撞的代码段。这通常涉及到以下几个方面： 1. 碰撞检测：这是人物行走碰撞测试码的核心功能，...
CMake管理外部依赖的模块
最新发布
我的博客
05-01 756
是“轻量级依赖管理”，适合简单集成。是“重型构建工具”，适合完全控制外部项目流程。根据依赖项的性质（是否需要编译、是否需修改代码）和项目需求（是否需要隔离构建环境）选择合适工具。
用Java模拟打字：深入解析 java.awt.Robot 的键盘控制艺术
码觉客的博客
04-28 2685
通过，我们可以实现强大的键盘自动化功能。对于简单的字符（英文字母、数字、基础标点等），可以通过模拟单个按键的按下和释放（可能需要配合 Shift 等修饰键）来实现，这需要建立字符到键码的映射并注意按键时序和延迟。对于复杂字符、中文或长文本，由于Robot不理解输入法逻辑，最可靠和常用的方法是将文本复制到系统剪贴板，然后模拟按下系统的粘贴快捷键。无论使用哪种方法，理解Robot的工作原理（模拟物理按键），处理好窗口焦点，并加入适当的延迟，是确保模拟输入成功的关键。虽然Robot。
Linux 服务管理两种方式service和systemctl
lza20001103的博客
04-29 2039
Linux 服务管理两种方式service和systemctl
Linux Shell 重定向与管道符号（＞, ＞＞, |）的实现机制
imhikaru的专栏
05-01 629
重定向目标 | 标准输出 → 文件 | 标准输出 → 文件末尾 | 命令输出 → 管道写端，命令输入 ← 管道读端 || 用途 | 输出重定向到文件（覆盖原内容） | 输出追加到文件末尾 | 将前一命令的输出作为后一命令的输入 || 项目 || 系统调用 |
make nmake编译
qq_25194681的博客
04-29 279
make和nmake是两种广泛使用的构建自动化工具，主要用于管理软件项目的编译和链接过程。
Ubuntu平台使用aarch64-Linux交叉编译opencv库并移植RK3588S边缘端
没有余地 EliasJie
04-30 593
Ubuntu平台使用aarch64-Linux交叉编译opencv库并移植ARM边缘端
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值