Amit’s Game Programming Information

1995–2024

FAQ

  1. How do I get started? [1] (for everyone)
  2. 10 Mostly Easy Steps To Become An Indie Dev [2]
  3. How do I make games? [3] (for programmers)
  4. How can I write my own (more complex) game? [4]
  5. How much fun is game programming? [5]
  6. What do I need to learn once I know how to program? [6]
  7. What do I do after school? [7]
  8. How do I actually finish a game? [8]

What’s on this page? I’m interested in producing complexity out of simple parts. This page contains bookmarks that I collected while working on games since 1990; I did not write most of the content linked from here. As a result the set of links here reflects the types of things I needed to know: only a few specific topics (not everything related to game programming), general ideas instead of platform-specific information (graphics, sound, compilers), and ideas and designs instead of source code (I find it easier to go from an idea to code than from code to an idea). Other sites, like Gamedev Tuts+ [9], Gamedev.net [10], and Gamasutra [11], cover lots more topics than mine does.

Shortest Paths #

Determining how to move around on a map is an interesting problem. There are many different approaches, ranging from simple (walk forward until you hit something) to the complex (path finding algorithms with heuristics). These are pages about pathfinding in general, with some bias towards A*:

These pages are about specific techniques for pathfinding [18] and object movement [19]:

A*

A* is a variant of Dijkstra’s Algorithm and Breadth First Search. It’s a fairly popular choice for pathfinding. It can handle varying terrain costs well, and it seems to be faster than most graph searching algorithms. However, it’s only one piece of a pathfinding solution. Map design and map representation [42] come before A*. Grids are easy to work with but not always the best approach. Formations, path following, movement, path recovery, and animation come after A*. Many games don’t need A* at all: it deals with discrete steps, not with continuous movement; it works on graphs [43] and does not take full advantage of spatial coherence (i.e., a map location is very similar to its neighbors) or temporal coherence (e.g., if we already found a path a few seconds ago, it’s likely if we try again the path we find will be similar); and if the game world is changing quickly it’s not worth planning very far ahead. A* is a good tool but it’s not the only one to look at.

Code and Demos

The link to my A* code is to the second version [1998], with bug fixes, optimizations, and parameterization for different heuristics and cost functions. The first version of my code is available on Steve Woodcock’s pages [54], and it may be easier to read and understand.

Artificial Intelligence #

Many times I play a game and wish that the computer opponents were written better. Sometimes the computer player is given different rules; other times it has the same rules but gets more money (or other resources) than you. The result is that the game doesn’t seem balanced: it’s just too obvious that the computer is not playing well, and that the game is brain vs. brawn rather than brain vs. brain. At the same time I don’t want AI that’s too good; if it were, then it’d always beat me and I’d be frustrated!

What techniques are useful in game AI?

  • Guide to AI architectures [55]: ad-hoc, state machines, behavior trees, utility functions, planners, neural networks
  • The Total Beginner’s Guide to Game AI [56]: ad-hoc, decision trees, scripting, events, state machines, behavior trees, utility functions, steering, pathfinding, planning, learning, knowledge representation
  • Finite State Machines [57] can be used to express how an AI agent changes from one behavior to another. There are states and transitions between states. For more complex behaviors, see Subsumption Architecture [58], Hierarchical Finite State Machines [59], State Charts [60], and Behavior Trees [61].
  • Behavior Trees: breaking the cycle of misuse [62] describes when to use and not use behavior trees
  • Utility-Based AI [63] is useful when several factors need to be taken into account to make a decision; also see this article [64].
  • Map Analysis analyzes and annotates a game map to provide information for later decision-making. They go by several names, including Heat Maps, Influence Maps [65], Terrain Reasoning, and Using Potential Fields [66].
  • Pathfinding and Movement are used to move an agent in a game world. Pathfinding algorithms are used for the high level planning; reactive movement algorithms are used between the waypoints marked by the pathfinding algorithm.
  • Planning Systems [67] search over possible futures to pick one that is best. Typically possible futures are represented as a graph, with nodes as futures and edges as actions.
  • Reinforcement Learning [68] is a type of Machine Learning that makes decisions in a game world and then observes their outcomes to learn which decisions lead to better outcomes. It’s used instead of planning when you don’t already know what outcome an action will lead to. For a more comprehensive resource, see this book [69] by Sutton and Barto.
  • Probabilistic Graphical Models [70] combines node-and-edges graphs with statistics. Bayesian networks, Markov random fields, hidden Markov models, and Kalman filters can be used with PGMs.
  • Neural Networks [71] are function approximators. Given a set of x and f(x) where function f is unknown, you can build a neural network approximating f. There are also other ways to approximate functions [72]: curve fitting, chebyshev approximation, fourier series.
  • Genetic Algorithms are parameter optimizers. Given a known function f(), you want to find x such that f(x) is maximized (or minimized). There are also other ways to optimize parameters: simulated annealing, hill climbing, swarm intelligence. Typically all of these approaches pick one or more x, evaluate f(x), and then improve the choice of x.

In choosing a technique for AI in your games, keep it as simple as possible; read this [73]. If you know the answer, put the answer into the program. If you know how to compute the answer, put the algorithm for computing it into the program. Only if you don’t know the answer, and don’t even know how to compute the answer, should you resort to complex techniques that can learn how to find the answer. These complex techniques can come at a high price, in terms of programming time, game performance, difficulty of debugging, and lack of control.

I’ve also collected links to other game AI articles; these aren’t organized:

Computer AI is most commonly used to implement opponents for the player. However it can also be used to implement the world (for example, all the businesses in Railroad Tycoon), assistants to the player (for example, the automatic city management in Civilization), or computer players that are not necessarily opponents (for example, non-player characters in role-playing games).

Game Design #

A lot of what is hard about writing a game is getting the design right. What makes a game fun? Game design is an art, not a science. It’s not just the rules of the game but the way in which you interact with the game.

Tile Based Games #

I love tile grid based games because tiles can produce a lot of complexity from simple parts [139]. There are several topics that come up with tile based games. The data structures are typically variants of 2 dimensional arrays. The display transforms an array of tile data into top-down (2D), isometric (2.5D) views, or full 3D views. There are also side views but I don’t cover that here. The algorithms on grids allow you to implement gameplay elements ranging from line of sight to evaluating where enemies are likely to be. Tiles also work well with procedural world building algorithms, such as the ones in Diablo, Civilization, and Dwarf Fortress.

Data structures

The basic tile structures do not depend on whether your display is 2D, 2.5D, or 3D. These articles are about how to store your data.

Displaying Tiles

A 2D tile grid can be displayed in various ways. The most straightforward is top-down or side-view, but these days it’s more common to see isometric or 3D views. Note that most "isometric" views in games aren’t true isometric, but dimetric [144].

Algorithms

Building Worlds

Although procedural map generation can be applied to non-grid worlds, it’s most often used with grids. Viewed at a single point in time, generated game maps are rarely as nice as hand-crafted worlds. However, they have three advantages: (1) lower cost per world if there are many worlds to be made, (2) more replay value because the next time through the world is different, and (3) potential for the world evolving while the game progresses.

Hexagonal Grids #

Many war games use hexagonal grids instead of square grids. Squares share an edge with four neighbors but also touch another four neighbors at just one point. This often complicates movement along grids because diagonal movements are hard to weight properly with integer movement values. You either have four directions or eight directions with squares, but with hexagons, you have a compromise—six directions. Hexagons don’t touch any neighbor at only a point; they have a small perimeter-to-area ratio; and they just look neat. Unfortunately, in our square pixel world of computers, hexagons are harder to use, so I’ve collected some articles that may help you turn common square-grid algorithms into hex-grid algorithms.

Object Oriented Programming #

I have found object oriented programming to be useful for user interfaces, operating systems, and games. At the same time, it’s commonly believed that object-oriented programming is the best way to program (especially back in the 1990s, when I started this page), but there are lots of situations where other approaches work much better. Since most of my readers are familiar with object oriented programming, the links I collect here are mostly about alternatives to the usual approaches. There is no one best approach. Learn many.

Adventure Games #

Adventure games often have good puzzle and story structures. When I started this page in the 1990s, I was especially interested in MUDs and interactive fiction. TADS [213] was the tool to use, or maybe Inform [214]. Since then, there have been lots more tools, such as Curveship [215], Hugo [216], Inklewriter [217], Twine [218], ChoiceScript [219], Squiffy [220], Ren’Py [221], Quest [222], ADRIFT [223], and Ink [224] I never did work on an interactive fiction project, so I don’t have a great set of links. Check out the Interactive Fiction Wiki [225] for more.

Scripting Languages #

I usually recommend putting general rules ("find a path from here to there") in source code and specific rules ("if sensor 9 triggers in corridor 3, make guard 18 find a path to sensor 9") in data files. However some things fall in between and are hard to express purely as data. That’s where scripting languages come in.

Scripting languages give you a way to write a lot of non-speed-critical code with comparatively little effort. You can design the language to specifically deal with your game, so the amount of work you have to do is less than for a general purpose language. Also, you can write the compiler to optimize for different things (like size instead of speed), allow more features (like dynamic patching at run-time), and even user customization (for enthusiastic users!).

As much as I love scripting languages, my recommendation is to put as much as possible into plain data files (no code) that are processed by your game. If you really need a general purpose language, use Lua. Only make your own scripting language if it’s a small game specific language. For example, a game specific script for a play might look like this:

 Amit [to Steve]: Hello, friend!
 Steve [nods to Bryan]: Welcome to CGDC.
 [Amit exits left.]

Note that it’s very high level: it doesn’t specify exactly how Amit speaks or how Steve nods or even the timing. For this to work, you need to have some assumptions about how people behave, and that makes the language specific to the system you are setting up. In this particular language, the use of brackets marks actions and the colon marks speech. In another language brackets might mark optional parameters and colons mark sections. The more general purpose your language, the fewer assumptions you can make, so it becomes more verbose. For example, the conversation might look like this:

 Amit.turns_towards(Steve);
 Amit.walks_within(3);
 Amit.says_to(Steve, "Hello, friend!");
 Amit.waits(1);
 Steve.turns_towards(Bryan);
 Steve.walks_within(5);
 Steve.nods_to(Bryan);
 Steve.waits(1);
 Steve.says_to(Bryan, "Welcome to CGDC.");
 Amit.waits(3);
 Amit.face_direction(DIR_LEFT);
 Amit.exits();

That’s a program, not a script. See the difference? The script is high level, and specifies what you want to be done, while the program is low level, and specifies exactly how to do it. It’s not a great deal harder to interpret the first syntax than the second. You already have a programming language (C, C++, Pascal, Basic, etc.). You don’t need another! (Unless your goal is simply to allow run-time flexibility, which can be done with dynamically loaded libraries, or by using an existing language like Lua.)

Try to think differently. If you’re going to go through all the effort of making a scripting language, don’t make it look just like C. Think about using an event-based structure. For example, have commands like "when X happens, do Y." Think about having many things happen at once. Amit doesn’t have to stop just because Steve is saying something. Think about different styles of programming, like rule based, functional, imperative, logic, and object-oriented. Think about alternate rules of logic, like fuzzy logic (truth isn’t certain) or linear logic (one truth can turn into another, making the first false). Make the language take advantage of the structure of your game, and you may find it much easier to build parts of your game world. Otherwise you’re paying a high implementation and integration price without gaining the benefit of a second language.

Economics #

Economics is the study of human choices when it comes to managing resources (money, time, happiness, raw materials, goods, and so on). In many strategy games, economics is an important aspect of the design. Balancing the resources of your world can be a fun part of the game. Economics is also important in multi-player game dynamics: you want to reward people for making money, yet you don’t want them to have so much power that new players cannot have fun. One thing I want to explore is how location influences economics. In high school economics, businesses compete by price. Whichever business sells for less will win. But if transportation cost is a factor, then both businesses can coexist, and the player has to make interesting decisions about where to place new facilities [258] to balance all the variables (availability of labor, transportation cost of raw materials, transportation cost of product, tax rates, zoning laws, etc.).

It’s hard to come up with rules for economics in an online virtual world when the underlying costs are so different. In the physical world, "objects" take resources to build, but they typically do not use resources to keep (if you don’t use them), and you typically do not get those resources back when you throw the object away. Therefore our real world economy is based on buying things. In the virtual world, the "objects" take a small amount of memory and if you destroy the object, you get the memory back. At the same time, the very existence of a virtual object costs CPU time, which cannot be recovered. Therefore the virtual world economy might be based on renting things. If your world’s economy reflects the underlying costs, a diamond ring may "cost" as much as a bucket of sand. Although this reflects real costs of running your server, and therefore would discourage players from overloading it, it may not make sense for your game.

In addition to the economics of objects, you have to consider the economics of living in the world. In the physical world, mere existence of a person has a cost; in the virtual world, existence is cheap. Since a player may not be "logged on" all the time, it’s hard to come up with fair rules for the cost of existence without penalizing either players who play a lot (your core audience) or players who can’t log on much (who are likely to leave if penalized for not being there all the time). If you require someone to work for a living, the casual players may not be able to compete, and may leave.

This page and other pages I have written are Copyright © 2019 Amit Patel.

If I have a link to one of your pages or to a saved copy of something you posted to a public newsgroup, and you would prefer that I remove the link, please send me email.

I say no to exchanging links, advertising, or web rings.

Email me redblobgames@gmail.com, or comment here:

Links

  1. [1]: https://www.sloperama.com/advice/idea.htm
  2. [2]: http://www.galaxykate.com/blog/devsteps.html
  3. [3]: https://web.archive.org/web/20051104034215/https://www.lupinegames.com/articles/path_to_dev.html
  4. [4]: https://www.flipcode.com/archives/Building_A_Game_On_Your_Own.shtml
  5. [5]: https://web.archive.org/web/20160828221240/http:/www.gamedev.net:80/page/resources/_/business/should-working-in-games-be-more-fun-r866
  6. [6]: https://gamesfromwithin.com/so-you-want-to-be-a-game-programmer
  7. [7]: https://web.archive.org/web/20140824023345/http://www.binarycreativity.com/2006/10/09/so-you-want-to-be-a-game-programmer-how-to-get-out-of-college-and-into-games
  8. [8]: https://makegames.tumblr.com/post/1136623767/finishing-a-game
  9. [9]: https://gamedevelopment.tutsplus.com/
  10. [10]: https://www.gamedev.net/
  11. [11]: https://www.gamedeveloper.com
  12. [12]: https://www.redblobgames.com/pathfinding/a-star/introduction.html
  13. [13]: http://www.gamasutra.com/blogs/MatthewKlingensmith/20130907/199787/Overview_of_Motion_Planning.php
  14. [14]: http://theory.stanford.edu/~amitp/GameProgramming/
  15. [15]: https://web.archive.org/web/20160624142247/http://home1.stofanet.dk/breese/aaai99.html
  16. [16]: https://www.red3d.com/cwr/games/
  17. [17]: https://web.archive.org/web/20160208080111/http://www.red3d.com/breese/navigation.html
  18. [18]: https://www3.cs.stonybrook.edu/~algorith/files/shortest-path.shtml
  19. [19]: https://www.cs.stonybrook.edu/~algorith/files/motion-planning.shtml
  20. [20]: https://www.red3d.com/cwr/steer/Obstacle.html
  21. [21]: https://www.red3d.com/cwr/steer/
  22. [22]: https://www.red3d.com/cwr/steer/gdc99/
  23. [23]: https://www.redblobgames.com/pathfinding/tower-defense/
  24. [24]: https://andrewfray.wordpress.com/2013/02/20/steering-behaviours-are-doing-it-wrong/
  25. [25]: https://web.archive.org/web/20160311191000/http://www.logos.t.u-tokyo.ac.jp/~franck/research_sum.htm
  26. [26]: https://www.google.com/search?q=terrain+analysis+realtime+strategy+games+pottinger
  27. [27]: https://www.gamedeveloper.com/programming/group-pathfinding-movement-in-rts-style-games
  28. [28]: https://archive.gamedev.net/archive/reference/programming/features/motionplanning/
  29. [29]: http://www.gamasutra.com/view/feature/3313/coordinated_unit_movement.php?print=1
  30. [30]: http://www.gamasutra.com/view/feature/3314/coordinated_unit_movement.php?print=1
  31. [31]: http://ww38.mgrenier.me/2011/06/pathfinding-concept-the-basics/
  32. [32]: http://webdocs.cs.ualberta.ca/~games/pathfind/publications/cig2005.pdf
  33. [33]: http://webdocs.cs.ualberta.ca/~games/pathfind/
  34. [34]: https://www.davidsilver.uk/wp-content/uploads/2020/03/coop-path-AIWisdom.pdf
  35. [35]: https://web.archive.org/web/20170718161132/https://ai-depot.com/Tutorial/PathFinding.html
  36. [36]: https://web.archive.org/web/20180318091114/http://ai-depot.com/BotNavigation/Path.html
  37. [37]: https://web.archive.org/web/20180324230622/http://ai-depot.com/BotNavigation/Obstacle-Introduction.html
  38. [38]: https://playtechs.blogspot.com/2007/05/pathfinding-in-space.html
  39. [39]: https://playtechs.blogspot.com/2007/05/pathfinding-in-space-part-2.html
  40. [40]: https://playtechs.blogspot.com/2007/05/pathfinding-in-space-part-3.html
  41. [41]: https://web.archive.org/web/20131211020126/http://aisandbox.com/tutorial/flanking
  42. [42]: http://theory.stanford.edu/~amitp/GameProgramming/MapRepresentations.html
  43. [43]: https://mathworld.wolfram.com/Graph.html
  44. [44]: https://www.gabrielgambetta.com/generic-search.html
  45. [45]: https://web.archive.org/web/20110716210236/http://www.ai-blog.net/archives/000152.html
  46. [46]: https://web.archive.org/web/*/http://www.policyalmanac.org/games/twoTiered.htm
  47. [47]: https://web.archive.org/web/*/http://www.policyalmanac.org/games/binaryHeaps.htm
  48. [48]: https://www.cs.auckland.ac.nz/~burkhard/Reports/2003_SS_DanielWichmann2.pdf
  49. [49]: https://groups.google.com/g/comp.ai.games/c/Ym8A2uwf1nw
  50. [50]: https://web.archive.org/web/*/http://www.policyalmanac.org/games/aStarTutorial.htm
  51. [51]: http://www.ccg.leeds.ac.uk/people/j.macgill/xaStar/
  52. [52]: https://labs.zeh.com.br/blog/?p=8
  53. [53]: http://aima.cs.berkeley.edu/python/search.html
  54. [54]: https://web.archive.org/web/20080125034409/https://www.gameai.com/software.html
  55. [55]: https://web.archive.org/web/20210413050357/https://intrinsicalgorithm.com/IAonAI/2012/11/ai-architectures-a-culinary-guide-gdmag-article/
  56. [56]: https://www.gamedev.net/articles/programming/artificial-intelligence/the-total-beginners-guide-to-game-ai-r4942/
  57. [57]: https://web.archive.org/web/20090624033449/http://aigamedev.com/open/article/fsm-reusable/
  58. [58]: https://en.wikipedia.org/wiki/Subsumption_architecture#Overview
  59. [59]: https://web.archive.org/web/20090624033505/http://aigamedev.com/open/article/hfsm-gist/
  60. [60]: https://web.archive.org/web/20200307091036/https://www.mathworks.com/discovery/state-chart.html
  61. [61]: https://web.archive.org/web/20120113110719/http://aigamedev.com/open/article/bt-overview/
  62. [62]: https://takinginitiative.wordpress.com/2020/01/07/behavior-trees-breaking-the-cycle-of-misuse/
  63. [63]: https://web.archive.org/web/20170718040104/https://intrinsicalgorithm.com/IAonAI/2011/12/getting-more-behavior-out-of-numbers-gdmag-article/
  64. [64]: https://alastaira.wordpress.com/2013/01/25/at-a-glance-functions-for-modelling-utility-based-game-ai/
  65. [65]: https://www.gamedev.net/articles/programming/artificial-intelligence/the-core-mechanics-of-influence-mapping-r2799
  66. [66]: https://web.archive.org/web/20090809134128/http://aigamedev.com/open/tutorials/potential-fields/
  67. [67]: https://web.archive.org/web/20130325081354/http://aigamedev.com/open/review/planning-in-games/
  68. [68]: https://web.archive.org/web/20200205194041/http://reinforcementlearning.ai-depot.com/Intro.html
  69. [69]: http://www.incompleteideas.net/sutton/book/the-book.html
  70. [70]: https://en.wikipedia.org/wiki/Graphical_model
  71. [71]: https://natureofcode.com/book/chapter-10-neural-networks/
  72. [72]: https://en.wikipedia.org/wiki/Approximation_theory
  73. [73]: https://web.archive.org/web/20120424015356/http://www.ai-blog.net/archives/000178.html
  74. [74]: http://julian.togelius.com/Yannakakis2014Panorama.pdf
  75. [75]: http://www.ai-center.com/publications/nareyek-acmqueue04.pdf
  76. [76]: http://www.aiwisdom.com/byresource_aiwisdom.html
  77. [77]: http://www.gameaipro.com/
  78. [78]: http://blog.wolfire.com/2010/01/An-Introduction-to-AI-in-Games-from-Phil-Carlisle
  79. [79]: https://web.archive.org/web/20020206002519/https://www.lupinegames.com/articles/prac_ai.html
  80. [80]: https://web.archive.org/web/20051121235331/https://www.lupinegames.com/articles/prac_ai_2.html
  81. [81]: https://web.archive.org/web/20090211181617/http://www.ai-blog.net/archives/000104.html
  82. [82]: https://gameschoolgems.blogspot.com/2009/12/influence-maps-i.html
  83. [83]: https://gameschoolgems.blogspot.de/2010/03/influence-maps-ii-practical.html
  84. [84]: https://web.archive.org/web/20081211020150/https://www.design.wrong.net/2008/05/18/ai-and-the-single-player-game/
  85. [85]: https://web.archive.org/web/20051230162856/http://www.cgf-ai.com/docs/gdc2001_paper.pdf
  86. [86]: http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf
  87. [87]: https://web.archive.org/web/20140215014519/https://home.swipnet.se/dungeondweller/development/dev00055.htm
  88. [88]: http://robert.zubek.net/publications/Needs-based-AI-draft.pdf
  89. [89]: https://web.archive.org/web/20050512032318/http://www.cgf-ai.com/docs/straatman_remco_killzone_ai.pdf
  90. [90]: https://web.archive.org/web/20120407212109/http://altdevblogaday.com/2011/02/24/introduction-to-behavior-trees
  91. [91]: https://roguelikedeveloper.blogspot.com/2007/11/unangband-monster-ai-part-six.html
  92. [92]: https://web.archive.org/web/20030627145005/http://www.cgf-ai.com/docs/grenadehandling.pdf
  93. [93]: http://www.gamasutra.com/view/feature/134566/the_secrets_of_enemy_ai_in_.php
  94. [94]: https://web.archive.org/web/https://www.lggwg.com/wolff/aicg99/dobson-forbus.html
  95. [95]: https://users.cs.northwestern.edu/~forbus/c95-gd/lectures/The_Sims_Under_the_Hood_files/v3_slide0088.htm
  96. [96]: https://www.scribd.com/lists/4050497/The-Sims
  97. [97]: https://web.archive.org/web/20091219203340/http://aigamedev.com/open/interviews/stalker-alife/
  98. [98]: https://web.archive.org/web/20080102112756/https://www.gameai.com/blackandwhite.html
  99. [99]: http://www.gamasutra.com/view/feature/2438/how_to_prototype_a_game_in_under_7_.php
  100. [100]: https://lostgarden.home.blog/2012/07/01/building-tight-game-systems-of-cause-and-effect/
  101. [101]: http://www.gamasutra.com/view/feature/1839/too_many_clicks_unitbased_.php
  102. [102]: http://www.gamasutra.com/view/feature/1524/
  103. [103]: https://archive.gamedev.net/archive/reference/design/features/balance/
  104. [104]: https://mu.ranter.net/theory/
  105. [105]: https://sinisterdesign.net/against-the-cult-of-simplicity/
  106. [106]: http://www.lostgarden.com/2005/06/confessions-of-horrible-game-player.html
  107. [107]: https://www.whatgamesare.com/2011/11/currencies-and-other-numbers-game-design.html
  108. [108]: https://web.archive.org/web/20160709114301/https://trac.bookofhook.com/bookofhook/trac.cgi/wiki/DesignOfOnlineEconomies1
  109. [109]: https://web.archive.org/web/20160709114301/https://trac.bookofhook.com/bookofhook/trac.cgi/wiki/DesignOfOnlineEconomies2
  110. [110]: https://web.archive.org/web/20160709114301/https://trac.bookofhook.com/bookofhook/trac.cgi/wiki/DesignOfOnlineEconomies3
  111. [111]: https://web.archive.org/web/20051127004229/https://bookofhook.com/Article/GameDesign/TheDesignofOnlineEconomie-4.html
  112. [112]: https://web.archive.org/web/20040826082339/https://www.lupinegames.com/articles/essgames.htm
  113. [113]: https://archive.gamedev.net/archive/reference/articles/article1661.html
  114. [114]: http://www.lostgarden.com/2006/10/persistent-myths-about-game-design.html
  115. [115]: https://prospect.org/environment/seductions-sim-policy-simulation-game/
  116. [116]: https://gamestudies.org/0102/pearce/
  117. [117]: http://www.art.net/~hopkins/Don/simcity/WillWright.html
  118. [118]: http://www.designer-notes.com/game-developer-column-3-game-economics/
  119. [119]: https://www.rpglibrary.org/articles/storytelling/36plots.php
  120. [120]: http://www.lostgarden.com/2007/02/one-billion-buttons-please-should-we.html
  121. [121]: https://web.archive.org/web/https://www.design.wrong.net/2008/05/22/positive-and-negative-feedback/
  122. [122]: https://terranova.blogs.com/terra_nova/2004/11/believability.html
  123. [123]: https://web.archive.org/web/20041206231754/https://www.lupinegames.com/articles/progvexp.html
  124. [124]: http://tleaves.com/weblog/archives/000228.html
  125. [125]: http://www.shamusyoung.com/twentysidedtale/?p=984
  126. [126]: http://www.lostgarden.com/2012/04/loops-and-arcs.html
  127. [127]: https://www.ign.com/articles/2005/01/13/the-future-of-game-design-pt-1
  128. [128]: http://www.lostgarden.com/2007/04/spacecute-challenge-2-extending-verbs.html
  129. [129]: http://www.lostgarden.com/2012/12/understanding-randomness-in-terms-of.html
  130. [130]: http://home.insightbb.com/~chilliedog/Htm/ultima_7_part_2.htm
  131. [131]: https://web.archive.org/web/20121108192123/http://people.duke.edu/~tlove/simcity.htm
  132. [132]: http://www.lostgarden.com/2005/08/why-you-should-share-your-game-designs.html
  133. [133]: https://web.archive.org/web/https://www.lupinegames.com/articles/focus_gameplay.html
  134. [134]: https://web.archive.org/web/20090619090351/https://gamethink.net/Provide-a-good-legible-and-clear.html
  135. [135]: http://www.designersnotebook.com/Design_Resources/No_Twinkie_Database/no_twinkie_database.htm
  136. [136]: https://www.redblobgames.com/articles/probability/damage-rolls.html
  137. [137]: http://www.gamasutra.com/view/feature/175950/the_fundamental_pillars_of_a_.php
  138. [138]: http://www.gamasutra.com/view/feature/134715/the_user_interface_continuum_a_.php?print=1
  139. [139]: https://www.projecthorseshoe.com/reports/featured/ph18r7.htm
  140. [140]: http://www.gamedev.net/articles/programming/general-and-gameplay-programming/tile-based-games-faq-version-12-r728
  141. [141]: http://www-cs-students.stanford.edu/~amitp/game-programming/grids/
  142. [142]: https://archive.gamedev.net/archive/reference/programming/features/arttilebase/
  143. [143]: http://gamearchitect.net/Articles/StreamingBestiary.html
  144. [144]: https://en.wikipedia.org/wiki/Isometric_graphics_in_video_games
  145. [145]: http://www.significant-bits.com/a-laymans-guide-to-projection-in-videogames/
  146. [146]: https://gamedevelopment.tutsplus.com/tutorials/creating-isometric-worlds-a-primer-for-game-developers--gamedev-6511
  147. [147]: https://www.compuphase.com/axometr.htm
  148. [148]: https://web.archive.org/web/20040408231742/https://www.lupinegames.com/articles/isoeng4u.htm
  149. [149]: https://shaunlebron.github.io/IsometricBlocks/
  150. [150]: https://web.archive.org/web/https://trac.bookofhook.com/bookofhook/trac.cgi/wiki/OverviewOfIsometricEngineDevelopment
  151. [151]: https://clintbellanger.net/articles/isometric_math/
  152. [152]: https://web.archive.org/web/20090221192459/https://sc.tri-bit.com/Implementing_Iso_and_Iso_Hex_Grids_on_Tiled_Systems
  153. [153]: https://web.archive.org/web/20110926181642/https://www.wildbunny.co.uk/blog/2011/03/27/isometric-coordinate-systems-the-modern-way/
  154. [154]: https://bannalia.blogspot.com/2008/02/filmation-math.html
  155. [155]: https://andrewrussell.net/2016/06/how-2-5d-sorting-works-in-river-city-ransom-underground/
  156. [156]: https://playtechs.blogspot.com/2007/04/tileset-design-tip.html
  157. [157]: http://www.pathofexile.com/forum/view-thread/55091
  158. [158]: https://web.archive.org/web/20150214064910/https://higherorderfun.com/blog/2012/05/20/the-guide-to-implementing-2d-platformers/
  159. [159]: https://pikuma.com/blog/isometric-projection-in-games
  160. [160]: https://web.archive.org/web/20090211043627/https://sc.tri-bit.com/Computing_LOS_for_Large_Areas
  161. [161]: https://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_1_code
  162. [162]: https://playtechs.blogspot.com/2007/03/raytracing-on-grid.html
  163. [163]: http://www.metanetsoftware.com/technique/tutorialB.html
  164. [164]: https://playtechs.blogspot.com/2007/03/2d-portal-visibility-part-1.html
  165. [165]: https://playtechs.blogspot.com/2007/03/2d-portal-visibility-part-2.html
  166. [166]: http://www.gamedev.net/articles/programming/graphics/walls-and-shadows-in-2d-r2711
  167. [167]: https://www.roguebasin.com/index.php?title=Restrictive_Precise_Angle_Shadowcasting
  168. [168]: https://pages.cs.wisc.edu/~schenney/research/replication/flowtiles/
  169. [169]: https://web.archive.org/web/20110501225637/http://aigamedev.com/open/tutorials/occupancy-grid-prototype/
  170. [170]: https://blog.runevision.com/2015/08/procedural-world-potentials-simulation.html
  171. [171]: https://blog.unity.com/2015/01/07/a-primer-on-repeatable-random-numbers/
  172. [172]: https://www.gamedeveloper.com/gcg-status-update/?page=1
  173. [173]: https://roguelikedeveloper.blogspot.com/2007/11/unangband-dungeon-generation-part-five.html
  174. [174]: http://pcg.wikidot.com/pcg-games:unangband
  175. [175]: https://web.archive.org/web/20111110164304/http://www.saltgames.com/2009/procedural-progression/
  176. [176]: http://www.pixelenvy.ca/wa/river.html
  177. [177]: https://archive.gamedev.net/archive/reference/programming/features/randomriver/
  178. [178]: https://web.archive.org/web/20131025132021/http://kuoi.org/~kamikaze/GameDesign/art07_rogue_dungeon.php
  179. [179]: http://weblog.jamisbuck.org/2011/2/7/maze-generation-algorithm-recap
  180. [180]: http://accidentalnoise.sourceforge.net/minecraftworlds.html
  181. [181]: https://www.roguebasin.com/index.php?title=Irregular_Shaped_Rooms
  182. [182]: https://www.squidi.net/three/entry.php?id=167
  183. [183]: https://dungeonmaker.sourceforge.net/DM2_Manual/manual3.html
  184. [184]: https://dungeonmaker.sourceforge.net/DM2_Manual/
  185. [185]: https://web.archive.org/web/20071222090735/https://www.geocities.com/Area51/6902/terrain.html
  186. [186]: http://pcg.wikidot.com/category-pcg-algorithms
  187. [187]: https://procworld.blogspot.com/2010/12/simulating-large-virtual-worlds.html
  188. [188]: https://www.boristhebrave.com/2021/08/30/arc-consistency-explained/
  189. [189]: https://www.boristhebrave.com/2020/04/13/wave-function-collapse-explained/
  190. [190]: https://www.redblobgames.com/grids/hexagons/
  191. [191]: http://www-cs-students.stanford.edu/~amitp/game-programming/grids/
  192. [192]: https://web.archive.org/web/20090205120106/https://sc.tri-bit.com/Hex_Grids
  193. [193]: https://www.gamedev.net/articles/programming/general-and-gameplay-programming/coordinates-in-hexagon-based-tile-maps-r1800
  194. [194]: https://playtechs.blogspot.com/2007/04/hex-grids.html
  195. [195]: https://web.archive.org/web/20210723200526/http://3dmdesign.com/development/hexmap-coordinates-the-easy-way
  196. [196]: https://web.archive.org/web/20161024224848/http://gdreflections.com/2011/02/hexagonal-grid-math.html
  197. [197]: https://gamedev.stackexchange.com/questions/20742/how-can-i-implement-hexagonal-tilemap-picking-in-xna
  198. [198]: http://www.sable.mcgill.ca/~clump/Hex/HGAT.html
  199. [199]: http://cell-auto.com/neighbourhood/
  200. [200]: https://gamesfromwithin.com/data-oriented-design
  201. [201]: https://gamesfromwithin.com/data-oriented-design-now-and-in-the-future
  202. [202]: https://github.com/SanderMertens/ecs-faq
  203. [203]: https://ajmmertens.medium.com/why-it-is-time-to-start-thinking-of-games-as-databases-e7971da33ac3
  204. [204]: http://gameprogrammingpatterns.com/data-locality.html
  205. [205]: https://www.gamedev.net/articles/programming/general-and-gameplay-programming/understanding-component-entity-systems-r3013
  206. [206]: https://bitsquid.blogspot.com/2014/10/building-data-oriented-entity-system.html
  207. [207]: https://t-machine.org/index.php/2007/09/03/entity-systems-are-the-future-of-mmog-development-part-1/
  208. [208]: http://entity-systems.wikidot.com/es-approaches
  209. [209]: https://gist.github.com/LearnCocos2D/77f0ced228292676689f
  210. [210]: https://www.richardlord.net/blog/ecs/what-is-an-entity-framework.html
  211. [211]: https://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/
  212. [212]: https://blog.molecular-matters.com/2013/02/22/adventures-in-data-oriented-design-part-2-hierarchical-data/
  213. [213]: http://www.tads.org/if.htm
  214. [214]: http://inform-fiction.org/
  215. [215]: https://web.archive.org/web/20160306211235/http://curveship.com/
  216. [216]: https://www.ifwiki.org/Hugo
  217. [217]: https://www.inklestudios.com/inklewriter/
  218. [218]: http://twinery.org/
  219. [219]: https://www.choiceofgames.com/make-your-own-games/choicescript-intro/
  220. [220]: http://textadventures.co.uk/squiffy
  221. [221]: https://www.renpy.org/
  222. [222]: http://textadventures.co.uk/quest
  223. [223]: https://www.adrift.co/
  224. [224]: https://www.inklestudios.com/ink/
  225. [225]: http://ifwiki.org/index.php/Main_Page
  226. [226]: https://wiki.c2.com/?InteractiveFictionPatterns
  227. [227]: https://garethrees.org/2004/12/01/ocarina-of-time/
  228. [228]: http://gram.cs.mcgill.ca/papers/verbrugge-02-structure.pdf
  229. [229]: https://web.archive.org/web/20100731072020/https://www.io.com/~sjohn/plots.htm
  230. [230]: https://www.raphkoster.com/games/laws-of-online-world-design/the-laws-of-online-world-design/
  231. [231]: https://web.archive.org/web/20010708011701/https://www.lupinegames.com/articles/linegame.htm
  232. [232]: http://www.raphkoster.com/gaming/textvgraf.shtml
  233. [233]: http://www.gamasutra.com/view/feature/1815/modeling_opinion_flow_in_humans_.php
  234. [234]: https://web.archive.org/web/20200325094656/http://www.doggysoft.co.uk/inform/write/prose.html
  235. [235]: https://github.com/rant-lang/rant
  236. [236]: http://www.costik.com/nowords2002.pdf
  237. [237]: https://web.archive.org/web/20051214165618/https://www.bookofhook.com/Article/GameDevelopment/TheSecretLifeofGameScript.html
  238. [238]: http://norvig.com/lispy.html
  239. [239]: http://craftinginterpreters.com/
  240. [240]: https://eblong.com/zarf/essays/rule-based-if/
  241. [241]: http://steve-yegge.blogspot.com/2008/10/universal-design-pattern.html
  242. [242]: http://gameprogrammingpatterns.com/bytecode.html
  243. [243]: https://kalogirou.net/2005/08/10/multithreaded-game-scripting-with-stackless-python/
  244. [244]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_1_Overview.shtml
  245. [245]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_2_The_Lexical_Analyzer.shtml
  246. [246]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_3_The_Parser.shtml
  247. [247]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_4_The_Symbol_Table_Syntax_Tree.shtml
  248. [248]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_5_The_Semantic_Checker_Intermediate_Code_Generator.shtml
  249. [249]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_6_Optimization.shtml
  250. [250]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_7_The_Virtual_Machine.shtml
  251. [251]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_8_Executable_Code.shtml
  252. [252]: https://flipcode.com/archives/Implementing_A_Scripting_Engine-Part_9_Advanced_Subjects.shtml
  253. [253]: https://web.archive.org/web/20121001002150/http://www.worldforge.org/project/newsletters/November2001/NPC_Scripting
  254. [254]: https://www.raphkoster.com/games/snippets/scripting-languages-in-diku-muds/
  255. [255]: https://web.archive.org/web/https://lgdc.sunsite.dk/articles/3.html
  256. [256]: https://www.oreilly.com/radar/
  257. [257]: https://kalogirou.net/2005/08/10/multithreaded-game-scripting-with-stackless-python/
  258. [258]: http://www.cs.sunysb.edu/~algorith/files/voronoi-diagrams.shtml
  259. [259]: http://www.raphkoster.com/gaming/gamevworld.shtml
  260. [260]: https://www.raphkoster.com/games/snippets/economies-in-a-virtual-setting/
  261. [261]: http://ai-depot.com/Articles/46/Economics.html
  262. [262]: https://web.archive.org/web/20100729044139/http://www.io.com/~sjohn/demog.htm
  263. [263]: https://ravenswing59.blogspot.com/2013/10/medieval-demographics-done-right.html
  264. [264]: https://ravenswing59.blogspot.com/2013/10/medieval-demographics-done-right-pt-ii.html
  265. [265]: https://web.archive.org/web/20200128102110/http://mu.ranter.net/design-theory/food-basis/everything-starts-with-grainhttp://mu.ranter.net/design-theory/food-basis/everything-starts-with-grain
  266. [266]: https://www.ibiblio.org/london/agriculture/general/1/msg00070.html
  267. [267]: https://archive.gamedev.net/archive/reference/articles/article251.html
  268. [268]: https://web.archive.org/web/20130218201707/http://www.s.kth.se/sigra/widelands-economy-documents/transport-system.html
  269. [269]: https://web.archive.org/web/20130811150817/http://www.burningsea.com/pages/page.php?pageKey=news/article&article_id=10253
View the discussion thread.

AltStyle によって変換されたページ (->オリジナル) /