• Content count

  • Joined

  • Last visited

Community Reputation

4442 Excellent

About LorenzoGatti

  • Rank

Personal Information

  • Interests

Recent Profile Visitors

19256 profile views
  1. As you already figured out, the only smart thing you can do with pixel art is sticking to integer scales and nearest neighbour interpolation. Of course, if scaling down is an option it isn't pixel art. Simplified art for low resolutions is a good idea (in the extreme cases in which it's needed), but deformed art to match a different aspect ratio is not: one variant would be canonical and the others would be wrong and ugly. Showing a larger or smaller view of the playfield (e.g. seeing or not the top of the 3x3 block cluster in the top right first picture) depending on screen size is totally unacceptable for gameplay reasons; stretching graphics is fair but it looks bad beyond very mild aspect ratio changes; only letterboxing, or more generally surrounding a standard size view with inert decorative elements is a good option to adapt to different screen sizes. A standard 1920x1200 view on a 3840x2400 TV can be scaled up to 2x2 blocks of pixels without quality issues: it's going to look less pixelated than displayed without scaling on a 1920x1200 monitor that is half the size but three times closer.
  2. You might want to refine random link weights with some variations and additions, for example: The length of the stay of the travellers before leaving could be modelled (with some easily integrated PDF); apart from in-fiction marketing utility for your airlines you'd be able to compute how many transient visitors are on each planet, and consider their transition from and to permanent residence. Different statistics for different traveler types, who correspond to different transport types: rich people in first class go to luxury vacation planets and stay for weekends or several weeks, white collars make mostly quick business class visits to economically developed locations, forced labor travels one-way to mining penal colonies, aquatic aliens travel in special water-filled pool ships between a handful of ocean planets, and so on. Statistics can vary temporarily and seasonally: for example tourists or pilgrims attending some ceremony are going to arrive just before it starts and leave just after it ends, wherever they come from, or there could be large flows of refugees leaving some place (steadily increasing if there's an ongoing ecological collapse, sudden after a war or coup, etc.)
  3. Your ideas about a superhero action-adventure game

    You are looking for puzzles that can be solved by doing fantastic and unrealistic things. This is not at all the same thing as puzzles fit for a superhero story; your puzzle-solving character is weird but not heroic. Forget about the "superhero experience": the game you describe is humorous and on the spectrum between quirky and very silly, and its characters should be too. Leave "superhero style" to action games.
  4. Question about C++ , C# and Java

    Focusing on objective requirements and constraints instead of tastes should be more productive. Are you writing a portable application, a Windows-only one or a Linux-only one? The choice of GUI frameworks depends on their availability. Do you need (or prefer) a desktop GUI, or a somewhat interactive web application? There's little overlap of suitable technologies. Not clear from your post: did you learn real C++ or C++/CLI? If the latter, why didn't you just learn C# instead? Are you restricted to .Net technology? Would you be comfortable and productive with Java or Python? If not, the respective very good and very portable GUI frameworks are not an option.
  5. Assets that need to look good only once or twice, in specific conditions, are probably cheaper than assets that need to look good in many possible situations. More generally, if you know you are making a huge game, you can design for reusability, getting more hours of more repetitive content for a similar cost (doing less level design work vs. doing it more efficiently). For example, a short RPG could invest in a comprehensive scripting system that allows level designers to tweak and control NPC behaviour in each set-piece encounter, while a long RPG could invest in robust physical/combat simulation and agent AI systems that allow designers to throw any creature into any environment and ensure the resulting encounter is automatically well-behaved.
  6. I'd consider setting a "near future global wargame where factions are fighting for control of towns and cities on a world map" on an extraterrestrial planet. Benefits would include: Random generation of maps, places, and other interesting stuff. It's not Earth, it can be an arbitrarily different planet each game for replayability. Interesting artifacts, technology, lifeforms etc. with the excuse of aliens. There might also be a sci-fi angle of representing the social and cultural impact of alien stuff on near-future people. Avoiding assumptions, player knowledge and emotional baggage related to real places, factions and history. There could be many plot excuses to fight for a remote planet. For example: Aliens came to invade Earth; governments and scoundrels stole their FTL ships and went looking for habitable planets; there were so few that they became disputed between enemy colonies. Aliens came to invade Earth and deported everybody very, very far. War arises naturally from the degraded society of penal colony planets. Aliens came to invade Earth; we rushed to their homeworld and conquered it; after victory the great coalition faded away quickly but fearsome alien weapons didn't. WW3 erupts, some nation (where are Nazi mad scientists when you need them?) uses experimental stargates to colonize another planet, and following them is inevitable.
  7. Relation of fleet and army in a space 4X

    War might also evolve toward low collateral damage and negligible destruction because inhabitable planets are extremely valuable. It only takes a little bit of rules enforcement (e.g. an overly powerful civilization or faction of arbiters or an empire or federation embracing all warring factions) to make destroyed planets and genocidal wars a non-issue. If letting a damaged enemy ship fall on the underlying planet is an unacceptable hazard, if nobody uses anything more harmful than small firearms with non-polluting bullets, if leaving behind arrows or bullet cases is a war crime, conquering or defending a planet becomes a very labor-intensive activity both in the air and on the ground, with fair battles and prudent engagement rules.
  8. Card Game - Play Mat Space

    I suggest simplifying drastically the small version of the card images: no text, larger illustration and larger title. Words, icons and numbers should be as large, or almost as large, as their counterparts in the full-size card, which is presumably readable enough, or omitted completely. As important as card text might be, players can easily read it by hovering the mouse on a card miniature. Privileging the elements (name and picture) that make cards recognizable reduces player frustration, reduces mistakes, and allows familiarity with cards to gradually reduce lookups of the full card text.
  9. Pathfinding Eikonal vs Grass Fire Algorithm

    No, the eikonal equation defines what is a shortest path. "Traversing the areas" is what algorithms that compute solutions of the eikonal equation, i.e. shortest paths, need to do somehow. In the case of chapter 23 of Game AI Pro: Maintaining a list of active wavefront cells looks definitely like a "brushfire" algorithm. Are you confusing this basic building block of multiple source/single destination grid-based pathfinding with the full pathfinding solution described in the book (tile-based architecture, portals, caching, LOS special case, specific flags and data structures, etc.)?
  10. Just separate rigorously an enum type for the parts of your bitfield and some unsigned integer type for the values. Only the latter type has operations. typedef uint8_t videoFlagsValue; enum class videoFlag:uint8_t{ useWindow=1<<0, useOpenGL=1<<1 } public bool isset(const videoFlagsValue v, const videoFlag f){ return v && static_cast<uint8_t>(f) } public void set( videoFlagsValue & v, const videoFlag f){ v=v || static_cast<uint8_t>(f) } public void unset( videoFlagsValue & v, const videoFlag f){ v=v && (! static_cast<uint8_t>(f)) } static void openGlWindowFix(videoFlagsValue & initFlags) { if (isset(initFlags ,videoFlag::useOpenGL)) { set(initFlags,videoFlag::useWindow); } } int main(int argc, char **args) { videoFlagsValue initFlags=0; set(initFlags,videoFlag::useOpenGL); openGlWindowFix(initFlags); .... return 0; } It can be improved with a class to tie everything together (maybe a template that can be used as a base class) and a constructor from a std::initializer_list<videoFlag>.
  11. Backing up GitHub Repos

    Your local git repository and the git repository you host on GitHub act as a backup of each other by design. If GitHub closes down, is hacked etc. clone your local repository on some other hosting service; if your computer passes away, check out the GitHub repository on any number of replacement computers. No commands fancier than clone, checkout, push and pull are involved. For further redundancy you need three or more copies of your repository (in addition to your own local one and the GitHub one), which could be a traditional backup of your computer (including your local repository directory, and if possible the whole working directory for completeness and convenience); restore by simply overwriting files other contributors, each refreshing their working copy on their respective computers from the same "central" repository other hosting services, with you and other contributors pushing the same changes to each shared repository For greater reliability you need automation. For example, a periodic task running on a internet facing server with its own git repository can pull changes from the GitHub repository and possibly push them to another public git hosting service.
  12. What's important, from a design point of view, is making the whole system (file format, writer, reader) oblivious to pointer size. You shouldn't have the 32 bit version and the 64 bit version, but a single implementation that compiles correctly and behaves identically on all platforms. Offsets are measured in bytes and represented as 32 bits in the file because the file is limited to 2 or 4 GB and file content is unaligned (two assumptions that in some cases could be changed to allow smaller offsets), not because pointers are 32 bits. Pointer arithmetic in code needs to convert a 32 bit integer, (i.e. int32_t) to a ptrdiff_t and vice versa, at worst using type traits from the standard library (numeric_limits<ptrdiff_t> from <limits>) to check for overflow.
  13. Font weights and thickness classification (in Freetype)

    Narrow and Condensed are widths, not weights: they are traditional adjectives for variant font families that have a smaller character width than the normal font and a similar design. Wider designs are usually called Expanded, Extended or Wide For example typical Windows fonts include Arial (main design) and Arial Narrow, and Arial Narrow has the same set of weights as Arial, e.g. Arial Narrow Bold that looks like a narrower Arial Bold. If you use FreeType, why do you bother with matching a different API? What use do you have for descriptions of the font weight, except to report in some debug log or end-user report interesting details, found in the font file, of the fonts you are using? None of this data has any relevance to using the font to render characters. In case you are letting the users select fonts interactively, you can conservatively group them by name heuristics, without trying to guess and sort weights and widths.
  14. A space empire lends itself very naturally to a feudal hierarchy: central government, star systems (almost isolated from each other), planets and asteroids in a star system, separate colonies or nations on the same planet. As Polama suggests, federal bureaucracies are the natural "enemy" of feudal power, and they are supposed to be on the emperor's side; however, they might be defeated or intimidated or subverted. To avoid civil war, the feudal powers could be purposefully crushed by difficult tasks (e.g. defend your piece of the frontier from aliens) and competing for limited resources rather than directly conflicting with each other. Also, the purpose of the emperor should be to remain in power and make the empire prosper, not necessarily to replace an explicit and healthy feudal organization with secret influences and plots to control bureaucratic organizations. Depending on how the empire forms, the "nobles" might be: recently appointed by the emperor, and possibly temporary (e.g. a military governor) leaders (or more impersonal governments) of politically united planets or systems that join a federation and retain autonomy, also, leaders of megacorps, crime syndicates, political parties etc. various organizations that have (or once had) the resources to have a space fleet and "own" the particular planets they explored/conquered/colonized (maybe recently, maybe a long time ago) inflated from small-scale origins (e.g. the brother-in-law of the first emperor became viceroy of an important planet, and centuries later his family is wealthier than many alien empires; two or three Earth nations, the only ones with space colonization programs, have expanded to fill tens of planets each while the others merely provide exotic foreign tourists)
  15. Browser game - Flash vs Js, questions

    The Flash browser plugin is usually updated to fix bugs that can be exploited by merely accessing hostile objects; it's an outstanding security risk, far worse than more properly sandboxed Javascript. PHP, on the other hand, helps putting your servers at risk: assuming hackers will attack you with malicious HTTP requests in any case, the bad design choices and the plentiful bugs in PHP and many accompanying libraries make their attempts more likely to find something useful. Avoid PHP. Not a real question. Iavascript with WebGL is more likely than Flash to be efficiently rendered and to make good use of hardware acceleration, but look out for bad surprises (particularly with libraries that offer Flash-like entities and scene graphs).