It's been long time since last post on the blog, many things changed. Started new project and helped out local group with game they are creating. As always I try to supplement videos which are more interesting then pictures :)



I've created simple random dungeon generator for the club game, heres some results.





I've also changed the game idea from strategy to puzzle block game. I wished to make something easier and I think block game would be easier to make. I am planning to implement some kind of multiplayer in it but first I need to get some basics down like animating blocks etc.


Here is some simple puzzle game logic: moving blocks, check for matching rows or columns and give points accordingly.

After long while I had some time to finally make something for the game. As i was planning before, I've implemented the group moving behaviour to the engine. Although it still needs fixes to be of good use, its still a good start

Here's video that I've recorded to demonstrate:

Today I've implemented character selecting (same way as in any rts game). Most interesting upgrade was to create raycast from cursor position rather then just directly raycasting from camera. I used the guide located in here: Mouse Picking with Ray Casting

Since I am using glm and glfw, my function looks like this:

glm::vec3 GraphicsMain::GetMouseRay(){
    // Get mouse position
    double xpos, ypos;
    glfwGetCursorPos(window, &xpos, &ypos);

    float x = (2.0f * xpos) / res_x - 1.0f;
    float y = 1.0f - (2.0f * ypos) / res_y;
    glm::vec3 tmp_vec3 = glm::vec3 (x, y, 1.f);

    glm::vec4 tmp_vec4 = glm::vec4 (tmp_vec3.x, tmp_vec3.y, -1.f, 1.f);
    tmp_vec4 = glm::inverse(ProjectionMatrix) * tmp_vec4;
    tmp_vec4 = glm::vec4 (tmp_vec4.x, tmp_vec4.y, -1.0, 0.0);
    tmp_vec4 = (glm::inverse(ViewMatrix) * tmp_vec4);
    tmp_vec4 = glm::normalize(tmp_vec4);

    tmp_vec3 = glm::vec3(tmp_vec4.x, tmp_vec4.y, tmp_vec4.z);

    return tmp_vec3;
}

After failing a ton of time with overlapping query in PhysX, I've decided to just roll simple check to get selection for models. I guess the check could be somehow more simple but this will do for now:

if(x_min <= models_list.at(i)->position.x &&
models_list.at(i)->position.x <= x_max &&
z_min <= models_list.at(i)->position.z &&
models_list.at(i)->position.z <= z_max)

I think next I should try implementing moving the group in formation, or at least in a way where all the models are not trying to move on to each other. But that will be implemented on the next post.

Models trying to move to same position, quite dumb result

Most of the code refactoring has been done. Next I'm planning on implementing select with sweep query and moving units of blocks in the same way as I've been moving the one block before.
I've also given access to the blog for my artist, who may post her concept art and sketches that we are planning on using in the game.

Time to fix some mess on code. In other words pack the experimented code to functions and classes. Currently there's way too much reused and reused code which I want to have neatly on functions and classes.

Cleaning it might take a while so new content will appear slower for now. After some cleaning Im planning on implementing some ideas:

• Raycast check if projectile/object passed other object but didnt collided
• Homing missile which tracks the target
• Breakable models (need another physx library)
• Selecting models with sweep query
• Some new sample models for scenery

I've also got one person working on some concept art, planning to check the results during the new year's day. I gave pretty free hands for the artist, as the only requirements given were "sci-fi laser pew pew" -type of design.

I've tried to record video of the current situation of project. Here's the result:

Finally I got the callbacks working correctly, now the bullets will pop up as sphere when they hit either one of the "players" or the ground.

Bullets blooming to sphere when they hit ground or player

I achieved this by nesting class of PxSimulationEventCallback on my physics engine class. And I implemented all of the event functions in there just for the future:

    class pCallBacks:public PxSimulationEventCallback{
        public:
        pCallBacks(void);
        ~pCallBacks(void);

        PxFilterFlags TestFilterShader(   
        PxFilterObjectAttributes attributes0, PxFilterData filterData0,
        PxFilterObjectAttributes attributes1, PxFilterData filterData1,
        PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize);

         void                        onConstraintBreak(PxConstraintInfo* constraints, PxU32 count);
         void                        onWake(PxActor** actors, PxU32 count);
         void                        onSleep(PxActor** actors, PxU32 count);
         void                        onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, PxU32 nbPairs);
         void                        onTrigger(PxTriggerPair* pairs, PxU32 count);
      };

    pCallBacks gCallbacks;

And then just set the callbacks on the init:

sceneDesc.simulationEventCallback = &gCallbacks;

The problem currently is that I need to make a new list for explosions and then remove these actors from the physics simulation (currentl the spheres bounce around instead of staying in one spot). Ill try to achieve that for the next post on the blog.