Jump to content
  • Advertisement


  • Content count

  • Joined

  • Last visited

Community Reputation

4489 Excellent

1 Follower

About LorenzoGatti

  • Rank

Personal Information

  • Role
  • Interests

Recent Profile Visitors

23343 profile views
  1. LorenzoGatti

    How to react when people say my game looks like shit?

    As already suggested, you can try to extract more articulate criticism by asking nicely, but you need to be aware of the difference between useful opinions and merely respectful and meaningful ones. Many people are going to expect something different from what you are trying to do. For example, my opinion is that Your screenshots show more than decent "production values" (your models are too good, i.e. too expensive, if you are still at the stage of figuring out gameplay). On the other hand, what are cannons doing in a nice garden? Realistic graphics demand realistic settings; tower defense games are usually not very realistic. The low and close overhead camera promises to be very inappropriate for tower defense: the player needs to see the whole battlefield all the time, not one turret and one enemy. Seeing turrets well is (up to a point) unnecessary, but not occluding enemies is very important. Satisfactory handling of jumping cars probably needs a lot of effort and a better physics engine than you have the performance budget for. Is it all relevant advice? Am I really understanding what you are doing? Take criticism critically.
  2. LorenzoGatti

    Pixel rounding problem... (c++)

    Can you explain why are you using as counterproductive a drawing call as that gfx.picPartRel? A sane API should have parameters in pixel units: either 2 (screen position, possibly floating point) to render a whole sprite, or 6 (screen position and 4 integers) to cut an arbitrary rectangle out of a texture atlas. If the 4 gfx.picPartRel parameters between 0 and 1 are texture coordinates, can you use texture coordinates in pixel units instead? For example, OpenGL has the ARB_texture_rectangle extension for this purpose.
  3. LorenzoGatti

    Pixel rounding problem... (c++)

    The problem should be related to rounding different floating point values (progress and 1-progress multiplied by some constant distance or size in pixels) to integer values, and expecting them to be matched (e.g. constant sprite size); for some values of progress they can be off by one. In other words, the unavoidable jitter becomes more troublesome because it's out of sync between parts of your scene. A correct solution would round only one large floating point value, obtain a large integer, and add or subtract constant integers to that. This code simply replaces progress with another floating point variable rounded_progress in the same range and with the same problems. Despite the name rounded_progressI doesn't have an integer value and it cannot serve as a reference. Unfortunately, since gfx.picPartRel() takes floating point parameters in the [0,1] range, the rounding is likely to take place there rather than in your calling code.
  4. It is a false dichotomy not only because a game can be good on both fronts, but also because actually cutting edge graphics can bring depth and innovation. For example, sufficiently fluid animation of sufficiently realistic indoor scenes enabled the appearance of first person shooters, bridging the gap between 3D but somewhat iconic graphics at a slow pace (e.g. Eye of the Beholder) and visceral realtime interaction with "virtual reality" (e.g. Doom).
  5. Post your failing code, there are many different ways to get this sort of error and appropriate fixes vary. You need to look for any place in your code where std::vector iterators are used. You should be able to exclude a large portion of those calls because they can only happen before or after the failure. By the way, Visual Studio 9 is ancient. Can you use a contemporary compiler? Why do you care for Windows XP and Vista?
  6. LorenzoGatti


    You can probably use a two-level hierarchy: a strictly read-only and shareable font corresponding to the content of a font file and a text rendering style (size, but also stroke pattern, colour, OpenType features, character encoding, etc.) that references a font. The combination of font, style, a text string and probably some indication about the output (e.g. a pointer to an image buffer) would be the input of the metrics and text rendering routines. You only need to worry about font names if they are presented to a human user.
  7. Some of the reviewed techniques could be made to work better. Cyclic resource dependencies can be probably avoided by adding more resources and/or resource types: for example if two otherwise self-contained game levels have mutual references because the player can navigate from one to the other, you can instead have named "gates" in the levels, with no reference to the other side, and a separate level navigation graph resources that is loaded later and specifies which gates are connected. What you call resource proxies are not really proxies, because they stop being useful as soon as the referenced resource is available and they actually start behaving like a proxy. They are placeholders, and they should simply disappear after resource loading by replacing references to them with references to the actual resource. Sorting resources means sorting in which order they are loaded, not necessarily the layout of data files. You can invest on building and possibly storing an index of your data files. Maintaining a queue of resources that need to be loaded seems an easy enough job for a computer, you just need to specify dependencies in an easy to build resource index. You might be able to script resource unloading (when the player passes some point of no return, a certain set of resources won't be needed any more) and/or resource caching (when the player is busy in a limited environment and few immediately useful resources need to be loaded, load in advance some of the resources that might be needed later).
  8. In general, you should make the player entity not special (except for principled features, like connecting it to inputs and outputs) and assumed singletons one of an unspecified number of entities, components or other objects. The inventory screen should be able to render any character's inventory (maybe one day magic could allow the player to look into a monster's pockets); the enemy pathfinding system should reason about on a set of enemy characters within range (and be applicable to any group of hostiles and monster infighting situations); culling treasure rendering should ignore characters because centering the view on the player location is incidental and compare the location of the item with the extent of visible map regions.
  9. LorenzoGatti

    Check My Damage Types & Condition Balance

    I'm afraid this isn't an adequate description of what sort of game you are writing and of your design objectives. Reading between the lines of the damage types it appears to be a fantasy game ("Magic" and "Chaos" types, unnaturally instantaneous "Plague"); it seems to focus on combat between people (with bleeding, armour etc.); and it is likely to be realtime (there are durations in seconds). This amount of information is, by far, not enough to put your damage types in context and evaluate them. Examples: How are these special damage types used by the monsters, character types etc. that should be balanced against one another? For example, are Plague effects a rarely encountered almost unstoppable ability of very lethal monsters, a common ability everyone cares about being immune to, or something else? More generally, which damage types are supposed to be bad, mediocre, good, very good? Do they have commensurate direct and indirect costs? What is the time scale of combat? For instance, how much fails to be done during the 12 seconds of a Chaos attack, and how likely are the opponents to "chain" another Chaos attack during that time? Or, how likely is a character suffering from Plague to be killed in the 8 seconds before hit points come back? What are the other rules you refer to? For example, the difference between staggering, beng stunned, and knockdown, or the "spell shields". In general you should simply test your game: does it have exploitative, boring strategies? Are certain fights easier or harder than they should be? A sufficiently flexible implementation will allow you to modify your damage types (and weapons, spells, characters etc.) easily. Testing will bring to light actual problems instead of imaginary ones, and if you don't know how to solve them you'll be able to ask for help in meaningful ways (e.g suggesting additional effects of Piercing to make it more immediately lethal, not whether we like Piercing damage).
  10. Speaking of keyboards, the Italian layout has the backquote and tilde characters, among others, in the ALT-number keyboard attic: ideal for programmers.
  11. LorenzoGatti

    Core Game Loop & Core Mechanic Loop?

    Documenting a "game loop" involves strictly technical aspects like buffering and multithreading schemes, but also very game specific design decisions like the sequence of rendering and simulation steps, which are potentially important game design details. For example: In a realtime action game, if type A moving actors (e.g. guided missiles) chase type B moving actors (e.g. vehicles of some kind) do you give the respective AI (which decides the next turn's movement and steers the actor) the old or new position (before or after this turn's movement) of the enemy actors? Knowing the new positions is a significant advantage, which can drastically affect game balance. How long do you need "dead" entities after the specific simulation step (e.g. bullets vs combatants collision detection) in which you figure out they die? For example a part of their accompanying data might be required to compute score, and score can only bi computed after
  12. Library files are managed by Visual Studio during development, in write-only automatically managed folders, like a project's "bin" and "obj", and normally never seen by the users in the installed end product (they're presumably going to use shortcuts, not to open your folder and look for an executable). So why do you find them so ugly that you are willing to spend time and effort hiding them?
  13. If you think the convex hull of your points is too complex, you can always compute a convex enclosing volume that has a larger volume but less vertices, edges and faces. For example: an enclosing sphere a box, either axis-aligned (cheaper to compute) or oriented optimally (smaller volume) simplifications of the convex hull, such as adding points to make several existing vertices sink into the interior. What do you need an exact or approximate convex hull for? The costs affecting the volume vs. complexity tradeoff are hard to guess.
  14. There's a significant difference between Are you trying to extract an engine from your old games, to develop a new or improved engine for future use, or simply to find a good architecture for a new game? Sometimes you appear to have an established engine you want to improve, sometimes not. The indecision between a main loop that belongs in the engine or in the game logic is a particularly troubling instance of a problem you shouldn't have: either you use adopt an existing game engine that "owns" the main loop and lets you write callbacks etc.:to customize it, or you adopt some less opinionated framework (like the mentioned XNA or SFML) and you just write (or adapt from examples) a suitable main loop for your game that will be eventually refactored and decomposed into different modules and layers as its complexity increases.
  • Advertisement

Important Information

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

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!