Jump to content

  • Log In with Google      Sign In   
  • Create Account

Ashaman73

Member Since 10 Nov 2006
Offline Last Active Dec 16 2014 03:06 AM

#5193588 Suggestions for simulating ambient light

Posted by Ashaman73 on 19 November 2014 - 05:59 AM

Look for GI (global illumination) approaches. There are some really cool ways to do them (eg. cone voxel tracing), but they are really expensive. Most common for the last generation (PS3/XBOX360) were light probes/spherical harmonics (eg cube map lookup) or texture baked solutions. 

 

Epic (unreal engine) and crytek have some impressive demos about the more advanced stuff, take a look at their publications/demonstrations/videos. An other good start is the gdc vault.




#5193386 Need advice on rendering terrain and/or overall look

Posted by Ashaman73 on 17 November 2014 - 11:47 PM

Yep, seems like texture tiles, hand painted. Take a look at the small, isolated grass-patch on the road to the left and how it is repeated along the road. You can even see it after the r-turn.




#5193385 view frustum culling particle effects?

Posted by Ashaman73 on 17 November 2014 - 11:40 PM

Here are some hints:

1. Don't cull single particles, if you have enqueued a particle just let the gpu render them, the gpu will cull it on its own.

2. Cull particle emitters, so stop emitting particles once they are out of view

3. When a particle emitter is in view again, don't just restart it , but simulate the last X seconds too (save the last stop time), so that the effects dont plop-in.




#5193210 So Many Texture Units!

Posted by Ashaman73 on 17 November 2014 - 02:49 AM

I'm not a hardware expert, but you need to distinquish between hardware texture units and opengl texture units. A very simple view would be, that the hardware texture units get assigned to GPU processes. If your shader eg needs one texture unit and you have 192 available, then 192 pixels could be processed concurrently. If your shader needs 64 texture units, then only 3 pixels could be processed concurrently.

 

This is a very hi-level/abstract view of how hardware might work, but if your GPU has a lot of resources available, most likely the driver will use this resources and divides them up to increase the performance.




#5193209 Java - Maximum Recommended Threads At One Time ?

Posted by Ashaman73 on 17 November 2014 - 02:08 AM

I once did a performance test, 1 thread per event vs worker pool (in java). The 1 thread per event approach collapsed really quickly (OS dependent), resulting in just OS overhead for several 1000 threads. Best solution was a worker approach.

 


In my humble opinion, the only purpose of threads in ("real time interactive") video games is to enable you to utilize extra CPU cores.

Thought this hold true for most gaming devices (PC/console), the number of worker can be increased if your event processing communicates with other laggy components (other computers, DB, disk ). Eg in a server backend connected to a database server scenario, workers will idle most of the time during db queries/updates. In this case your application would greatly benefit from additional workers/threads.

 

How many per threads per core depends on the workload, db connection etc, best to test it out.




#5192823 Moba creep(NPC) AI entries? Industry standards? Wave (non)-determinism

Posted by Ashaman73 on 14 November 2014 - 04:54 AM

Considering that a moba has an extremly well defined environment (enclosed area, almost no dynamic obstacles, well designed path, predefined path, predefined number of minions etc), I would bet, that all the pathfinding magic is really low-level compared to other games (aka take some naive, standard AI pathfinding approaches and you will be very close to the real implementation).

 

 

 


- how do minion prioritize aggro scan under "calls for help" from other minions (tricky)

Take a look at all the lol guide websites, they have enough information about the behavior of the minions, including priority .

 

 


- what is(are) the frequency in Hz of the (different) AI cycle(s)

Unknown, maybe 10-20 h

 

 


- what path-finding method is used waypoints/grid/navmesh/motion planning

Does it really matter ?

 

 


- if path-finding is multithreaded, what frequency/how long are the minion path requests

Due to the age of the game, the low requirements, I would bet, that it is not multithreaded at all (Dota, the first moba, was build with the warcraft engine, a very old engine !).

 

 


- are there long/short path requests

Most likely they will always calculate the whole path (which shouldn't be too long).

 

 

 


- what is collision system structure? how are this latter and path-finding dealing with each other?

Lol will need only a flat 2d collision system, each minion/avatar represented by a circle. Minions will follow the path (tracking the next waypoing?), using (simple) physics and steering behavior (flock, avoidance, follow).

 

If you want to find out more, try to play the game in singleplayer/bot mode and try to observe the behavior of the minions (drag them apart, drag them to obstancle etc.).

 

PS:

lua scripted will be only the hi-level AI, all the real demanding stuff will be most likly written as part of the engine (pathfinding, steering behavior)  and will be called by the script.




#5192587 rendering to multiple textures - output seems wrong after movement

Posted by Ashaman73 on 12 November 2014 - 11:38 PM


As you can see, it's as if the buffer is not being cleared, but glClear() is being called every frame with the mask set to the depth and color bits

Do you clear all render targets ?

 

The bug seems to be in the way you render your game and not in the shader. Could you show some rendering code too.




#5192227 using technology as magic

Posted by Ashaman73 on 11 November 2014 - 01:37 AM

From a gameplay view it is a little bit dangerous. You have two resources (hp/stamina), one describes typically your health, the other the options you have to execute some actions (most actions are available if you have full stamina/mana, less when the stamina/mana decreases).

 

If you combine both resources, you made it a lot more complex, complexity which demands a lot more of concentration of the player. Eg. the avatar is low on health and stamina, you concentrate on a combat situtation and fires off a magicblast, suddendly the avatar is dead, because you drained all your stamina and all, or atleast almost all, of your health. This kind of situtation would be very frustrating.

 

Many people like to plan and it is easier to plan an action if the rules aren't too complex. A very simple, yet effective planing is, to hit the magic-blast button all the time, it will fire off once you have enough stamina, thought on a very low leve,  it is still some kind of planing.

 

If you combine complexity (think of chess) with fast reaction times (think of realtime combat), then you will have a very low frustration threshold. Remember that many people play games to relax, to have some fun and don't play it to feel exhausted like after a 1vs1 SC2 ranked match.




#5192226 [rate this] MMORPG game concept

Posted by Ashaman73 on 11 November 2014 - 01:25 AM

There's not a lot of flesh on your concept yet. Your core concept seems to be a master-minion relationshipment. The master (dragon, necromancer, alien) has control over one or more minions (humans, zombies). So, do you play the master or do you play the minion or both ?

 

Most tradional MMO(RPG) have an avatar, which the player shapes, get bound to. This could get somewhat difficulty if you only have an exchangable minion most of the time. Think about pet-based classes in MMORPGs (wow -hunter, guild wars necro etc.), do you ever feel linked to the pet ?

 

It depends on how you implement the relationship. Eg in overlord you control the master and minions, in more traditional RTS games you most often only control the minions, so I don't really see in which direction your game/gameplay is going.

 

But the basic idea about a master-minion relationshipment sounds quite interesting.




#5192221 [SOLVED] Quaternion from direction not accurate

Posted by Ashaman73 on 10 November 2014 - 11:51 PM

A 3x3 orthonormal matrix (eg a look-at matrix) and a (unit) quaternion describe a rotation around an axis, whereas a direction is just a vector (axis) without rotation. To get it working , you need enough information to reconstruct the rotation around an axis. At least you need an additional rotation angle around the axis or you need to reconstruct the angle from the given vectors.




#5191634 Academic resources on game design theory?

Posted by Ashaman73 on 07 November 2014 - 03:43 AM


I might be biased towards working with clear definitions though. For instance from what I've read so far, there is no clear distinction between the terms "open-world" and "sandbox".

I think, that you will have a hard time getting clear definition of terms like "open-world" and "sandbox" or any other hip term game developer put on their boxes to appeal more people . Nevertheless, I would start at GDC vault, filter for game design related topics, then look out for source references. This way you might get an overview of academic resources.




#5191621 Novice C++ programmer, looking for ways to create art for game and such

Posted by Ashaman73 on 06 November 2014 - 11:54 PM

Hi Nicholas,

 

if you want to do some game related art, then you should focus on a single game art direction first. Either 3d art, because it is still the most common art direction in (non casual) game development , or 2d art, which is still used very often in casual/indie projects.

 

Art skills can be subdivided in tool knowledge and art specific skills, much like coding (you need to learn a language and you need to learn about certain algorithm, methods, paradigm etc.).

 

2d art:

If you go for 2d art you can use photoshop ($$), gimp(free) or any other useful paint tool.

Primary skills are drawing and painting.

 

3d art:

If you go for the 3d art , you should look at blender (free). 3d art is much more extensive. Skills you can learn:

- modelling

- sculpting

- rigging

- animating

- texturing (->painting)

 

You best start with modelling, because it is the core element of 3d game related art. Everything else is optional.

 

Be patient, art, much like coding, needs a lot practise and don't get confused by others who say, that other tools , like maya/max etc. are better. They will not magically improve your skills (a bad workman blames his tools...), it will just speed up your workflow when you are limited by other tools. But this will most likely take some time wink.png




#5191504 is this possible to increase polycounts locally?

Posted by Ashaman73 on 06 November 2014 - 06:08 AM


and unusable for game.

The typical workflow is:

- Sculp hi-res model (eg in zbrush,blender,sculptris), here the number of polys is really irrelevant for games .

- Model (re-topo) low-poly version in modelling tool (3ds,maya,blender), this is where the number of polys count.

- Bake normal,ao etc maps from hi-poly to low-poly version (eg using xnormal,blender).

 

PS: I don't know zbrush, but most sculp-tools will have an option to dynamically increase the number of polys locally.




#5191472 Rate the code of my game!

Posted by Ashaman73 on 06 November 2014 - 02:31 AM

Hmm...looks cool and quite complete, congratz smile.png Only watched the video, but it seems to be really a finished game..

 


It crashed often, that's why I could not record it to the finish point.

I dont review your code, but this is something you need to work on. Whenever you encounter a crash, stop development immediatly, try to reproduce and try to understand the cause. The latter is the most important part of development, always track the cause of an error, understand it, fix it, continue development (it is really sad how many developers put a try/catch clause around a null pointer exception angry.png ).




#5191099 Having problems with z values and render to depth buffer

Posted by Ashaman73 on 04 November 2014 - 07:19 AM

The z-buffer is not linear. You can get the linear depth by not transforming the pixel into the projection space:

vec3 tmp       = cameraMatrix *  position;
dist = tmp.z / far_clipping_plane_distance;






PARTNERS