Jump to content

  • Log In with Google      Sign In   
  • Create Account


#ActualStoneMask

Posted 07 June 2013 - 02:57 PM

If you had used any other example besides pausing this would all be correct. If you change states to a pause state you lose all current game information and it is not possible to perfectly resume the game then.

 

I wondered about this; if you set a different class, the data in the last class would be lost. I've also read about the stack-of-states method. I remember it being a vector, which makes sense to me-- since the Gameplay state needs to start at the exact point it left off on, all its information would still be there in a component of a vector, just waiting to be switched to again after Pause is done.

 

 

And the scene manager will cull the objects, generate shadow maps, send objects to render queues, and perform overall high-level render management. Actual drawing later gets delegated to the objects themselves, not a render manager.

 

I assume these would be drawn to a backbuffer so the objects don't leave trails of themselves as they move, and the CSceneManager would have to have access to one so that it can draw the objects in order based on were they are in terms of their "depth" in the scene. So does the CSceneManager also have to consider the environment? In my case, bitmaps? Does the scene manager also handle game logic, or is it strictly for having the objects draw themselves? I can understand having the objects draw themselves-- a scene manager wouldn't know things like the flags an object has set for having certain animations. And since you say it would handle physics too, I assume that this is where the logic between objects happens? Not necessarily logic with input, but where objects interact in collisions and where they are drawn specifically-- you would call CGameState's Draw() which would call CSceneManager's Draw(), which would in turn have all the objects call their Draw()s.

 

Then you are not really ready, and they aren’t necessary for simple games. You can read about LUA for more information.

 

Not ready for what, exactly? To elaborate, the project I'm working on is a small 2D game my friend and I resolved to tackle over the summer, using C++ and DirectX. Not necessarily to make the most airtight and complete game, but one that forces us to learn new things and solve new problems-- we went into it not completely ready. But I like to ask questions in order to fill the gaps, because the learning experience and stuff. I will look into Lua. Is there a particular dialect you recommend?

 

Also, this just occurred to me, but is there a particular reason that you must pass a pointer to CGame to each function? Wouldn't it be more convenient to have the classes hold a constant member pointer that points to the CGame object at all times, or is there some vulnerability/is this considered bad practice?


#7StoneMask

Posted 07 June 2013 - 02:56 PM

If you had used any other example besides pausing this would all be correct. If you change states to a pause state you lose all current game information and it is not possible to perfectly resume the game then.

 

I wondered about this; if you set a different class, the data in the last class would be lost. I've also read about the stack-of-states method. I remember it being a vector, which makes sense to me-- since the Gameplay state needs to start at the exact point it left off on, all its information would still be there in a component of a vector, just waiting to be switched to again after Pause is done.

 

 

And the scene manager will cull the objects, generate shadow maps, send objects to render queues, and perform overall high-level render management. Actual drawing later gets delegated to the objects themselves, not a render manager.

 

I assume these would be drawn to a backbuffer so the objects don't leave trails of themselves as they move, and the CSceneManager would have to have access to one so that it can draw the objects in order based on were they are in terms of their "depth" in the scene. So does the CSceneManager also have to consider the environment? In my case, bitmaps? Does the scene manager also handle game logic, or is it strictly for having the objects draw themselves? I can understand having the objects draw themselves-- a scene manager wouldn't know things like the flags an object has set for having certain animations. And since you say it would handle physics too, I assume that this is where the logic between objects happens? Not necessarily logic with input, but where objects interact in collisions and where they are drawn specifically-- you would call CGameState's Draw() which would call CSceneManager's Draw(), which would in turn have all the objects call their Draw()s.

 

Then you are not really ready, and they aren’t necessary for simple games. You can read about LUA for more information.

 

Not ready for what, exactly? To elaborate, the project I'm working on is a small 2D game my friend and I resolved to tackle over the summer, using C++ and DirectX. Not necessarily to make the most airtight and complete game, but one that forces us to learn new things and solve new problems-- we went into it not completely ready. But I like to ask questions in order to fill the gaps, because the learning experience and stuff. I will look into Lua. Is there a particular dialect you recommend?

 

Also, this just occurred to me, but is there a particular reason that you must pass a pointer to CGame to each function? Wouldn't it be more convenient to have a class hold a constant member pointer that points to the CGame object at all times, or is there some vulnerability/is this considered bad practice?


#6StoneMask

Posted 07 June 2013 - 01:48 PM

If you had used any other example besides pausing this would all be correct. If you change states to a pause state you lose all current game information and it is not possible to perfectly resume the game then.

 

I wondered about this; if you set a different class, the data in the last class would be lost. I've also read about the stack-of-states method. I remember it being a vector, which makes sense to me-- since the Gameplay state needs to start at the exact point it left off on, all its information would still be there in a component of a vector, just waiting to be switched to again after Pause is done.

 

 

And the scene manager will cull the objects, generate shadow maps, send objects to render queues, and perform overall high-level render management. Actual drawing later gets delegated to the objects themselves, not a render manager.

 

I assume these would be drawn to a backbuffer so the objects don't leave trails of themselves as they move, and the CSceneManager would have to have access to one so that it can draw the objects in order based on were they are in terms of their "depth" in the scene. So does the CSceneManager also have to consider the environment? In my case, bitmaps? Does the scene manager also handle game logic, or is it strictly for having the objects draw themselves? I can understand having the objects draw themselves-- a scene manager wouldn't know things like the flags an object has set for having certain animations. And since you say it would handle physics too, I assume that this is where the logic between objects happens? Not necessarily logic with input, but where objects interact in collisions and where they are drawn specifically-- you would call CGameState's Draw() which would call CSceneManager's Draw(), which would in turn have all the objects call their Draw()s.

 

Then you are not really ready, and they aren’t necessary for simple games. You can read about LUA for more information.

 

Not ready for what, exactly? To elaborate, the project I'm working on is a small 2D game my friend and I resolved to tackle over the summer, using C++ and DirectX. Not necessarily to make the most airtight and complete game, but one that forces us to learn new things and solve new problems-- we went into it not completely ready. But I like to ask questions in order to fill the gaps, because the learning experience and stuff. I will look into Lua. Is there a particular dialect you recommend?


#5StoneMask

Posted 07 June 2013 - 12:46 PM

If you had used any other example besides pausing this would all be correct. If you change states to a pause state you lose all current game information and it is not possible to perfectly resume the game then.

 

I wondered about this; if you set a different class, the data in the last class would be lost. I've also read about the stack-of-states method. I remember it being a vector, which makes sense to me-- since the Gameplay state needs to start at the exact point it left off on, all its information would still be there in a component of a vector, just waiting to be switched to again after Pause is done.

 

 

And the scene manager will cull the objects, generate shadow maps, send objects to render queues, and perform overall high-level render management. Actual drawing later gets delegated to the objects themselves, not a render manager.

 

I assume these would be drawn to a backbuffer so the objects don't leave trails of themselves as they move, and the CSceneManager would have to have access to one so that it can draw the objects in order based on were they are in terms of their "depth" in the scene. So does the CSceneManager also have to consider the environment? In my case, bitmaps? Does the scene manager also handle game logic, or is it strictly for having the objects draw themselves? I can understand having the objects draw themselves-- a scene manager wouldn't know things like the flags an object has set for having certain animations. And since you say it would handle physics too, I assume that this is where the logic between objects happens? Not necessarily logic with input, but where objects interact and where they are drawn specifically-- you would call CGameState's Draw() which would call CSceneManager's Draw(), which would in turn have all the objects call their Draw()s.

 

 

Then you are not really ready, and they aren’t necessary for simple games. You can read about LUA for more information.

 

Not ready for what, exactly? To elaborate, the project I'm working on is a small 2D game my friend and I resolved to tackle over the summer, using C++ and DirectX. Not necessarily to make the most airtight and complete game, but one that forces us to learn new things and solve new problems-- we went into it not completely ready. But I like to ask questions in order to fill the gaps, because the learning experience and stuff. I will look into Lua. Is there a particular dialect you recommend?


#4StoneMask

Posted 07 June 2013 - 12:00 PM

If you had used any other example besides pausing this would all be correct. If you change states to a pause state you lose all current game information and it is not possible to perfectly resume the game then.

 

I wondered about this; if you set a different class, the data in the last class would be lost. I've also read about the stack-of-states method. I remember it being a vector, which makes sense to me-- since the Gameplay state needs to start at the exact point it left off on, all its information would still be tere in a component of a vector, just waiting to be switched to again after Pause is done.

 

 

And the scene manager will cull the objects, generate shadow maps, send objects to render queues, and perform overall high-level render management. Actual drawing later gets delegated to the objects themselves, not a render manager.

 

I assume these would be drawn to a backbuffer so the objects don't leave trails of themselves as they move, and the CSceneManager would have to have access to one so that it can draw the objects in order based on were they are in terms of their "depth" in the scene. So does the CSceneManager also have to consider the environment? In my case, bitmaps? Does the scene manager also handle game logic, or is it strictly for having the objects draw themselves? I can understand having the objects draw themselves-- a scene manager wouldn't know things like the flags an object has set for having certain animations. And since you say it would handle physics too, I assume that this is where the logic between objects happens? Not necessarily logic with input, but where objects interact and where they are drawn specifically-- you would call CGameState's Draw() which would call CSceneManager's Draw(), which would in turn have all the objects call their Draw()s.

 

 

Then you are not really ready, and they aren’t necessary for simple games. You can read about LUA for more information.

 

Not ready for what, exactly? To elaborate, the project I'm working on is a small 2D game my friend and I resolved to tackle over the summer, using C++ and DirectX. Not necessarily to make the most airtight and complete game, but one that forces us to learn new things and solve new problems-- we went into it not completely ready. But I like to ask questions in order to fill the gaps, because the learning experience and stuff. I will look into Lua. Is there a particular dialect you recommend?


#3StoneMask

Posted 07 June 2013 - 11:19 AM

If you had used any other example besides pausing this would all be correct. If you change states to a pause state you lose all current game information and it is not possible to perfectly resume the game then.

 

I wondered about this; if you set a different class, the data in the last class would be lost. I've also read about the stack-of-states method. I remember it being a vector, which makes sense to me-- since the Gameplay state needs to start at the exact point it left off on, all its information would still be tere in a component of a vector, just waiting to be switched to again after Pause is done.

 

 

And the scene manager will cull the objects, generate shadow maps, send objects to render queues, and perform overall high-level render management. Actual drawing later gets delegated to the objects themselves, not a render manager.

 

I assume these would be drawn to a backbuffer so the objects don't leave trails of themselves as they move, and the CSceneManaer would have to have access to one so that it can draw the objects in order based on were they are in terms of their "depth" in the scene. So does the CSceneManager also have to consider the environment? In my case, bitmaps? Does the scene manager also handle game logic, or is it strictly for having the objects draw themselves?

 

 

Then you are not really ready, and they aren’t necessary for simple games. You can read about LUA for more information.

 

Not ready for what, exactly? To elaborate, the project I'm working on is a small 2D game my friend and I resolved to tackle over the summer, using C++ and DirectX. Not necessarily to make the most airtight and complete game, but one that forces us to learn new things and solve new problems-- we went into it not completely ready. But I like to ask questions in order to fill the gaps, because the learning experience and stuff. I will look into Lua. Is there a particular dialect you recommend?


PARTNERS