Jump to content
  • Advertisement


  • Content Count

  • Joined

  • Last visited

Community Reputation

122 Neutral

About beermann

  • Rank
  1. I understand the application of the time delta for constant movement, but what about tile-based games where an object is moving between locations on a grid? We're creating a visual programming environment where users can create casual games and multimedia applications. There are several ways for users to make objects move. One is by adding a value to the position, as would happen on a grid. How do you take into account the keyboard rate without correlating it to the game loop in this situation? We've also noticed issues with multiple keys as well. The most basic one is when you're holding down the arrow key to move and then hit the spacebar to fire. You lose key press events for the arrow key. But, as mentioned, if you're just keeping track of which keys are up and down I think it should work, since supposedly you still get the keyReleased event (but you might not... what then?). P.S. http://beta.sharendipity.com just went up if anyone wants to check it out.
  2. It would actually be really easy to create to separate applications, one that does scoring as you move up through the levels, and one that just allows you to pick the level and play for fun without scoring. For this particular one I wanted to do scoring though. One of the fundamental aspects of our platform is that we provide the ability for users to modify applications and save their own versions as well, so ideally someone would do that themselves if they wanted to. Also, I played the gaia online puzzle, but it didn't look like there was any scoring. It said that I won gold but I played as a guest so I couldn't see how much. It was kind of annoying that you couldn't maximize the puzzle window as well...
  3. That's much better. Here's the new version: http://beta.sharendipity.com/assets/957/. I might bump the constant down a bit but it works great. Is this a pretty standard way of accomplishing this?
  4. I'm creating a simple sliding puzzle game that uses the Flickr Interestingness feed for content. The game starts with a 2x3 puzzle, then it gets a new picture and does a 3x3 puzzle, then 3x4, etc. My problem is in determining how to calculate the score for a particular level. I can't use the minimum time as a direct scoring metric because there are multiple levels, so I'd like to have scores that are inversely related to the time it takes to complete a level. My first thought is to do something like this: (level_difficulty / level_time) * constant = level_score e.g. level 1's' difficulty is 1, level 2's difficulty is 2. If you took 10 seconds to solve the puzzle for each level, you would have (1/10)*constant or (2/10)*constant for each level. The constant is essentially the maximum amount of time allowed for a level. I've currently implemented this using naive values where the current level equals the difficulty, and the constant is 1000. One problem with this is that the potential score decreases _very_ fast which can be a bit disheartening. In addition, you have an increase in maximum score that is equal to the constant for each level. It's likely that this should go up faster. Questions: Are there other methods for doing this type of scoring that's based on an inverse of the measured value? Should the level_difficulty increase linearly or exponentially for each level? Should the constant increase? Demo available here: http://beta.sharendipity.com/assets/947/ (disclaimer: I work at Sharendipity and am currently creating example content for our users). Also, please ignore the current user interface and any issues with usability in the game (e.g. I realize that having random photos makes certain levels difficult). I'm just trying to figure out the scoring right now. Many Thanks, Dale Edit: Made link live.
  5. We've run into some similar issues. One of the problems is that games based on constant keyboard input will behave differently based on the user's system setting for the keyboard repeat rate. In general, actions can't just fire every time you get keyboard input. Instead, you might need to fire your own events at the beginning of the game loop. Using Java's KeyListeners, you can gather information about what happens between frames, and then use your own listening architecture to handle the events. This provides a more constant experience for the end users. Without it, one user might be able to move much faster than another in a simple situation such as (if (keyboard.x) player.x += 1).
  6. beermann

    Designing a Scripting Interface

    Thanks for the feedback. I've thought about just exposing our data structure classes directly, which is fine for vector, matrix, etc. as you mentioned. I wouldn't want to go as far as returning our entities or entity components though, which are sort of a mix between data and program. Those will need to be wrapped. One other thought though is if you're returning your internal interfaces, they can't really change too frequently. If they do then those changes are reflected back to the script author. Wrapping our internal vectors allows us to provide a more stable interface to the script authors in this respect. If we need to change the script interface, it's a lot easier to mark something as deprecated this way. This is also important because our platform emphasizes sharing of assets between users so changes to the script interface don't only affect the author, but affect all consumers of the author's script as well. As far as how much of the platform we want to expose, currently it's mainly just raw data. We don't expect people to be writing custom entity components for example (although in the future, I would hope someone was this ambitious).
  7. We are using the Rhino javascript engine to extend functionality in our platform. We restrict access to specific classes through the scripts and I'm going back and forth with the design of the public interface that script authors will use for access to some of our core objects. For example, we want to provide our implementation of a vector interface to script authors. I have a VectorFactory that authors can use to create them, but there are some fundamental questions of how to implement it. Do I provide a Singleton where they have to call VectorFactory.getInstance() to access it, or do I just provide static calls in VectorFactory? The only benefit I can see of using a singleton is that it allows us to publish an interface that the factory implements. If, for some reason, someone wanted to write their own implementation of the factory, they could now do so. Does this even matter in the case of a factory? For any returned objects, I would certainly expect them to implement a public interface. In addition, I believe that I want to wrap all of our core objects so that they aren't actually ever visible to the end user. Thus, we have two interfaces, a public scripting interface, and an internal interface that is called from the script interface. I'm unsure of whether or not this is the best tactic however. Does anyone have information on best practices in script interface design (books, blogs, articles, anything...)? Many thanks.
  8. beermann

    Help with water shader

    I don't use Cg either, but this might help: http://developer.download.nvidia.com/shaderlibrary/webpages/cgfx_shaders.html#Ocean
  9. beermann

    Growing/Shrinking in games

    JellyCar does something similar. I think it takes the route where it limits the time that you can be big. As mentioned, it also uses the mechanic as a way to solve puzzles. Kinda cool that it's one of the first games being released through the XNA community arcade as well. JellyCar video:
  10. beermann

    Flash game viability

    We've been struggling with this a lot ourselves. We're building a development environment for casual games and media applications. Currently, it's implemented as a Java applet but the problem you have there is adoption rates (approx. half of what you'd get with Flash). The Three Rings guys have given some great presentations about this topic. Here are two: http://samskivert.com/work/2007/gdc/ooo_gdc_2007.pdf (slides 27/28) http://www.samskivert.com/work/2007/agc/web_client_dev.pdf. At GDC this year Daniel James also mentioned that they had some regrets about moving to Flash for Whirled (which certainly has a large codebase). So far we've stuck with Java but it's really hard to give up half of your potential users. We're still evaluating moving to Flash. -Dale http://www.sharendipity.com
  11. beermann

    Character creation/customization as gameplay

    There are a lot of games that start you off with a generic character. YPP was already mentioned, but others in the MMO genre are Entropia Universe and Second Life. In both EU and SL users are creating the actual clothing as well. In EU, it's part of the game, in SL it's so that they can sell it. These MMOs make money off of the fact that you're buying stuff though, so they have incentives to make you look generic. In the case where your gear reflects your earned status, it still provides incentive for your to continue playing the game, which itself is just a different monetization strategy. In addition, the dress-up genre itself is growing a lot, where the whole point is that you start with a generic character, with games like IMVU (more focused on chatting with people) and Jojo's Fashion Show. I saw a panel at GDC where are a speaker from Lifetime Television was talking about how successful these games have been for their audience as well. They have an entire section for dress-up games. I haven't really answered your question about the story/setting where it makes sense to look generic I guess. Someone mentioned the character as a peasant. Fable takes this approach, and your looks change as you progress through the game. Another option could be a similar outsider scenario, as an alien or member of a different culture that is trying to assimilate and rise through the ranks of the new culture (which apparently holds incredible stake in its members fashion).
  12. OpenGL anti-aliasing is kind of a pain. OrangyTang mentioned using GL_POLYGON_SMOOTH_HINT, but that's deprecated due to rendering artifacts. Full-screen anti-aliasing is the preferred method in OpenGL, but it can be really slow. Here's a post from another forum about the artifacts: http://objectmix.com/graphics/136634-artifacts-when-using-antialiased-2d-polygons.html If you're using JOGL for OpenGL, you can setup full-screen anti aliasing using: GLCapabilities.setSampleBuffers(true); GLCapabilities.setNumSamples(X); // where X is the number of samples per pixel
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!