Exploring the open source 2048 game javascript examples I spent a lot of time over the past few days playing this game called 2048, which is a clone of a game called 1024, which appears to be a clone of the game Threes. I liked playing this 2048 game. And it took more time and strategy than I expected, but I beat it. To download 2048 free java game, we recommend you to select your phone model, and then our system will choose the most suitable game files. Downloading is very simple: select the desired file and click 'Java 2048 - free download', then select one of the ways you want to get the file. Page Information: Download 2048 Puzzle - Game game for mobiles - one of the best Java games! At PHONEKY Free Java Games Market, you can download mobile games for any phone absolutely free of charge. Nice graphics and addictive gameplay will keep you entertained for a very long time.

1. Download Game 2048 Cho Java Version
2. Download Game 2048 Cho Java Download

Tai game 2048 cho dien thoai 2730 mien phi moi nhat, tai game 2048 cho dien thoai 2730 crack cho dien thoai, download game mod full tai game 2048 cho dien thoai 2730 cho nokia asha, samsung galaxy, dt cam ung, android. Tai game 2048 cho dien thoai 2730 full man hinh. Man hinh 320x240 128x160 128x128 240x400 240x320 man hinh ngang, tai Game cho.

I have recently stumbled upon the game 2048. You merge similar tiles by moving them in any of the four directions to make 'bigger' tiles. After each move, a new tile appears at random empty position with a value of either 2 or 4. The game terminates when all the boxes are filled and there are no moves that can merge tiles, or you create a tile with a value of 2048.

One, I need to follow a well-defined strategy to reach the goal. So, I thought of writing a program for it.

My current algorithm:

What I am doing is at any point, I will try to merge the tiles with values 2 and 4, that is, I try to have 2 and 4 tiles, as minimum as possible. If I try it this way, all other tiles were automatically getting merged and the strategy seems good.

But, when I actually use this algorithm, I only get around 4000 points before the game terminates. Maximum points AFAIK is slightly more than 20,000 points which is way larger than my current score. Is there a better algorithm than the above?

14 Answers

I developed a 2048 AI using expectimax optimization, instead of the minimax search used by @ovolve's algorithm. The AI simply performs maximization over all possible moves, followed by expectation over all possible tile spawns (weighted by the probability of the tiles, i.e. 10% for a 4 and 90% for a 2). As far as I'm aware, it is not possible to prune expectimax optimization (except to remove branches that are exceedingly unlikely), and so the algorithm used is a carefully optimized brute force search.

Performance

The AI in its default configuration (max search depth of 8) takes anywhere from 10ms to 200ms to execute a move, depending on the complexity of the board position. In testing, the AI achieves an average move rate of 5-10 moves per second over the course of an entire game. If the search depth is limited to 6 moves, the AI can easily execute 20+ moves per second, which makes for some interesting watching.

To assess the score performance of the AI, I ran the AI 100 times (connected to the browser game via remote control). For each tile, here are the proportions of games in which that tile was achieved at least once:

The minimum score over all runs was 124024; the maximum score achieved was 794076. The median score is 387222. The AI never failed to obtain the 2048 tile (so it never lost the game even once in 100 games); in fact, it achieved the 8192 tile at least once in every run!

Here's the screenshot of the best run:

This game took 27830 moves over 96 minutes, or an average of 4.8 moves per second.

Implementation

My approach encodes the entire board (16 entries) as a single 64-bit integer (where tiles are the nybbles, i.e. 4-bit chunks). On a 64-bit machine, this enables the entire board to be passed around in a single machine register.

Bit shift operations are used to extract individual rows and columns. A single row or column is a 16-bit quantity, so a table of size 65536 can encode transformations which operate on a single row or column. For example, moves are implemented as 4 lookups into a precomputed 'move effect table' which describes how each move affects a single row or column (for example, the 'move right' table contains the entry '1122 -> 0023' describing how the row [2,2,4,4] becomes the row [0,0,4,8] when moved to the right).

Scoring is also done using table lookup. The tables contain heuristic scores computed on all possible rows/columns, and the resultant score for a board is simply the sum of the table values across each row and column.

This board representation, along with the table lookup approach for movement and scoring, allows the AI to search a huge number of game states in a short period of time (over 10,000,000 game states per second on one core of my mid-2011 laptop).

The expectimax search itself is coded as a recursive search which alternates between 'expectation' steps (testing all possible tile spawn locations and values, and weighting their optimized scores by the probability of each possibility), and 'maximization' steps (testing all possible moves and selecting the one with the best score). The tree search terminates when it sees a previously-seen position (using a transposition table), when it reaches a predefined depth limit, or when it reaches a board state that is highly unlikely (e.g. it was reached by getting 6 '4' tiles in a row from the starting position). The typical search depth is 4-8 moves.

Heuristics

Several heuristics are used to direct the optimization algorithm towards favorable positions. The precise choice of heuristic has a huge effect on the performance of the algorithm. The various heuristics are weighted and combined into a positional score, which determines how 'good' a given board position is. The optimization search will then aim to maximize the average score of all possible board positions. The actual score, as shown by the game, is not used to calculate the board score, since it is too heavily weighted in favor of merging tiles (when delayed merging could produce a large benefit).

Initially, I used two very simple heuristics, granting 'bonuses' for open squares and for having large values on the edge. These heuristics performed pretty well, frequently achieving 16384 but never getting to 32768.

Petr Morávek (@xificurk) took my AI and added two new heuristics. The first heuristic was a penalty for having non-monotonic rows and columns which increased as the ranks increased, ensuring that non-monotonic rows of small numbers would not strongly affect the score, but non-monotonic rows of large numbers hurt the score substantially. The second heuristic counted the number of potential merges (adjacent equal values) in addition to open spaces. These two heuristics served to push the algorithm towards monotonic boards (which are easier to merge), and towards board positions with lots of merges (encouraging it to align merges where possible for greater effect).

Furthermore, Petr also optimized the heuristic weights using a 'meta-optimization' strategy (using an algorithm called CMA-ES), where the weights themselves were adjusted to obtain the highest possible average score.

The effect of these changes are extremely significant. The algorithm went from achieving the 16384 tile around 13% of the time to achieving it over 90% of the time, and the algorithm began to achieve 32768 over 1/3 of the time (whereas the old heuristics never once produced a 32768 tile).

I believe there's still room for improvement on the heuristics. This algorithm definitely isn't yet 'optimal', but I feel like it's getting pretty close.

That the AI achieves the 32768 tile in over a third of its games is a huge milestone; I will be surprised to hear if any human players have achieved 32768 on the official game (i.e. without using tools like savestates or undo). I think the 65536 tile is within reach!

You can try the AI for yourself. The code is available at https://github.com/nneonneo/2048-ai.

I'm the author of the AI program that others have mentioned in this thread. You can view the AI in action or read the source.

Currently, the program achieves about a 90% win rate running in javascript in the browser on my laptop given about 100 milliseconds of thinking time per move, so while not perfect (yet!) it performs pretty well.

Since the game is a discrete state space, perfect information, turn-based game like chess and checkers, I used the same methods that have been proven to work on those games, namely minimaxsearch with alpha-beta pruning. Since there is already a lot of info on that algorithm out there, I'll just talk about the two main heuristics that I use in the static evaluation function and which formalize many of the intuitions that other people have expressed here.

Monotonicity

This heuristic tries to ensure that the values of the tiles are all either increasing or decreasing along both the left/right and up/down directions. This heuristic alone captures the intuition that many others have mentioned, that higher valued tiles should be clustered in a corner. It will typically prevent smaller valued tiles from getting orphaned and will keep the board very organized, with smaller tiles cascading in and filling up into the larger tiles.

Here's a screenshot of a perfectly monotonic grid. I obtained this by running the algorithm with the eval function set to disregard the other heuristics and only consider monotonicity.

Smoothness

The above heuristic alone tends to create structures in which adjacent tiles are decreasing in value, but of course in order to merge, adjacent tiles need to be the same value. Therefore, the smoothness heuristic just measures the value difference between neighboring tiles, trying to minimize this count.

A commenter on Hacker News gave an interesting formalization of this idea in terms of graph theory.

Here's a screenshot of a perfectly smooth grid, courtesy of this excellent parody fork.

Free Tiles

And finally, there is a penalty for having too few free tiles, since options can quickly run out when the game board gets too cramped.

And that's it! Searching through the game space while optimizing these criteria yields remarkably good performance. One advantage to using a generalized approach like this rather than an explicitly coded move strategy is that the algorithm can often find interesting and unexpected solutions. If you watch it run, it will often make surprising but effective moves, like suddenly switching which wall or corner it's building up against.

Edit:

Here's a demonstration of the power of this approach. I uncapped the tile values (so it kept going after reaching 2048) and here is the best result after eight trials.

Yes, that's a 4096 alongside a 2048. =) That means it achieved the elusive 2048 tile three times on the same board.

I became interested in the idea of an AI for this game containing no hard-coded intelligence (i.e no heuristics, scoring functions etc). The AI should 'know' only the game rules, and 'figure out' the game play. This is in contrast to most AIs (like the ones in this thread) where the game play is essentially brute force steered by a scoring function representing human understanding of the game.

AI Algorithm

I found a simple yet surprisingly good playing algorithm: To determine the next move for a given board, the AI plays the game in memory using random moves until the game is over. This is done several times while keeping track of the end game score. Then the average end score per starting move is calculated. The starting move with the highest average end score is chosen as the next move.

With just 100 runs (i.e in memory games) per move, the AI achieves the 2048 tile 80% of the times and the 4096 tile 50% of the times. Using 10000 runs gets the 2048 tile 100%, 70% for 4096 tile, and about 1% for the 8192 tile.

The best achieved score is shown here:

An interesting fact about this algorithm is that while the random-play games are unsurprisingly quite bad, choosing the best (or least bad) move leads to very good game play: A typical AI game can reach 70000 points and last 3000 moves, yet the in-memory random play games from any given position yield an average of 340 additional points in about 40 extra moves before dying. (You can see this for yourself by running the AI and opening the debug console.)

This graph illustrates this point: The blue line shows the board score after each move. The red line shows the algorithm's best random-run end game score from that position. In essence, the red values are 'pulling' the blue values upwards towards them, as they are the algorithm's best guess. It's interesting to see the red line is just a tiny bit above the blue line at each point, yet the blue line continues to increase more and more.

I find it quite surprising that the algorithm doesn't need to actually foresee good game play in order to chose the moves that produce it.

Searching later I found this algorithm might be classified as a Pure Monte Carlo Tree Search algorithm.

Implementation and Links

First I created a JavaScript version which can be seen in action here. This version can run 100's of runs in decent time. Open the console for extra info. (source)

Later, in order to play around some more I used @nneonneo highly optimized infrastructure and implemented my version in C++. This version allows for up to 100000 runs per move and even 1000000 if you have the patience. Building instructions provided. It runs in the console and also has a remote-control to play the web version.(source)

Results

Surprisingly, increasing the number of runs does not drastically improve the game play. There seems to be a limit to this strategy at around 80000 points with the 4096 tile and all the smaller ones, very close to the achieving the 8192 tile. Increasing the number of runs from 100 to 100000 increases the odds of getting to this score limit (from 5% to 40%) but not breaking through it.

Running 10000 runs with a temporary increase to 1000000 near critical positions managed to break this barrier less than 1% of the times achieving a max score of 129892 and the 8192 tile.

Improvements

After implementing this algorithm I tried many improvements including using the min or max scores, or a combination of min,max,and avg. I also tried using depth: Instead of trying K runs per move, I tried K moves per move list of a given length ('up,up,left' for example) and selecting the first move of the best scoring move list.

Later I implemented a scoring tree that took into account the conditional probability of being able to play a move after a given move list.

However, none of these ideas showed any real advantage over the simple first idea. I left the code for these ideas commented out in the C++ code.

I did add a 'Deep Search' mechanism that increased the run number temporarily to 1000000 when any of the runs managed to accidentally reach the next highest tile. This offered a time improvement.

I'd be interested to hear if anyone has other improvement ideas that maintain the domain-independence of the AI.

2048 Variants and Clones

Just for fun, I've also implemented the AI as a bookmarklet, hooking into the game's controls. This allows the AI to work with the original game and many of its variants.

This is possible due to domain-independent nature of the AI. Some of the variants are quite distinct, such as the Hexagonal clone.

EDIT: This is a naive algorithm, modelling human conscious thought process, and gets very weak results compared to AI that search all possibilities since it only looks one tile ahead. It was submitted early in the response timeline.

I have refined the algorithm and beaten the game! It may fail due to simple bad luck close to the end (you are forced to move down, which you should never do, and a tile appears where your highest should be. Just try to keep the top row filled, so moving left does not break the pattern), but basically you end up having a fixed part and a mobile part to play with. This is your objective:

This is the model I chose by default.

The chosen corner is arbitrary, you basically never press one key (the forbidden move), and if you do, you press the contrary again and try to fix it. For future tiles the model always expects the next random tile to be a 2 and appear on the opposite side to the current model (while the first row is incomplete, on the bottom right corner, once the first row is completed, on the bottom left corner).

Here goes the algorithm. Around 80% wins (it seems it is always possible to win with more 'professional' AI techniques, I am not sure about this, though.)

A few pointers on the missing steps. Here:

The model has changed due to the luck of being closer to the expected model. The model the AI is trying to achieve is

And the chain to get there has become:

The O represent forbidden spaces...

Download Game 2048 Cho Java Version

So it will press right, then right again, then (right or top depending on where the 4 has created) then will proceed to complete the chain until it gets:

So now the model and chain are back to:

Second pointer, it has had bad luck and its main spot has been taken. It is likely that it will fail, but it can still achieve it:

Here the model and chain is:

When it manages to reach the 128 it gains a whole row is gained again:

Download Game 2048 Cho Java Download

I copy here the content of a post on my blog

The solution I propose is very simple and easy to implement. Although, it has reached the score of 131040. Several benchmarks of the algorithm performances are presented.

Algorithm

Heuristic scoring algorithm

The assumption on which my algorithm is based is rather simple: if you want to achieve higher score, the board must be kept as tidy as possible. In particular, the optimal setup is given by a linear and monotonic decreasing order of the tile values.This intuition will give you also the upper bound for a tile value: where n is the number of tile on the board.

(There's a possibility to reach the 131072 tile if the 4-tile is randomly generated instead of the 2-tile when needed)

Two possible ways of organizing the board are shown in the following images:

To enforce the ordination of the tiles in a monotonic decreasing order, the score si computed as the sum of the linearized values on the board multiplied by the values of a geometric sequence with common ratio r<1 .

Several linear path could be evaluated at once, the final score will be the maximum score of any path.

Decision rule

The decision rule implemented is not quite smart, the code in Python is presented here:

An implementation of the minmax or the Expectiminimax will surely improve the algorithm. Obviously a moresophisticated decision rule will slow down the algorithm and it will require some time to be implemented.I will try a minimax implementation in the near future. (stay tuned)

Benchmark

• T1 - 121 tests - 8 different paths - r=0.125
• T2 - 122 tests - 8-different paths - r=0.25
• T3 - 132 tests - 8-different paths - r=0.5
• T4 - 211 tests - 2-different paths - r=0.125
• T5 - 274 tests - 2-different paths - r=0.25
• T6 - 211 tests - 2-different paths - r=0.5

In case of T2, four tests in ten generate the 4096 tile with an average score of 42000

Code

The code can be found on GiHub at the following link: https://github.com/Nicola17/term2048-AIIt is based on term2048 and it's written in Python. I will implement a more efficient version in C++ as soon as possible.

My attempt uses expectimax like other solutions above, but without bitboards. Nneonneo's solution can check 10millions of moves which is approximately a depth of 4 with 6 tiles left and 4 moves possible (2*6*4)⁴. In my case, this depth takes too long to explore, I adjust the depth of expectimax search according to the number of free tiles left:

The scores of the boards are computed with the weighted sum of the square of the number of free tiles and the dot product of the 2D grid with this:

which forces to organize tiles descendingly in a sort of snake from the top left tile.

code below or on github:

I am the author of a 2048 controller that scores better than any other program mentioned in this thread. An efficient implementation of the controller is available on github. In a separate repo there is also the code used for training the controller's state evaluation function. The training method is described in the paper.

The controller uses expectimax search with a state evaluation function learned from scratch (without human 2048 expertise) by a variant of temporal difference learning (a reinforcement learning technique). The state-value function uses an n-tuple network, which is basically a weighted linear function of patterns observed on the board. It involved more than 1 billion weights, in total.

Performance

At 1 moves/s: 609104 (100 games average)

At 10 moves/s: 589355 (300 games average)

At 3-ply (ca. 1500 moves/s): 511759 (1000 games average)

The tile statistics for 10 moves/s are as follows:

(The last line means having the given tiles at the same time on the board).

For 3-ply:

However, I have never observed it obtaining the 65536 tile.

I think I found an algorithm which works quite well, as I often reach scores over 10000, my personal best being around 16000. My solution does not aim at keeping biggest numbers in a corner, but to keep it in the top row.

Please see the code below:

There is already an AI implementation for this game here. Excerpt from README:

The algorithm is iterative deepening depth first alpha-beta search. The evaluation function tries to keep the rows and columns monotonic (either all decreasing or increasing) while minimizing the number of tiles on the grid.

There is also a discussion on Hacker News about this algorithm that you may find useful.

Algorithm

Evaluation

Evaluation Details

This is a constant, used as a base-line and for other uses like testing.

More spaces makes the state more flexible, we multiply by 128 (which is the median) since a grid filled with 128 faces is an optimal impossible state.

Here we evaluate faces that have the possibility to getting to merge, by evaluating them backwardly, tile 2 become of value 2048, while tile 2048 is evaluated 2.

In here we still need to check for stacked values, but in a lesser way that doesn't interrupt the flexibility parameters, so we have the sum of { x in [4,44] }.

A state is more flexible if it has more freedom of possible transitions.

This is a simplified check of the possibility of having merges within that state, without making a look-ahead.

Note: The constants can be tweaked..

This is not a direct answer to OP's question, this is more of the stuffs (experiments) I tried so far to solve the same problem and obtained some results and have some observations that I want to share, I am curious if we can have some further insights from this.

I just tried my minimax implementation with alpha-beta pruning with search-tree depth cutoff at 3 and 5. I was trying to solve the same problem for a 4x4 grid as a project assignment for the edX course ColumbiaX: CSMM.101x Artificial Intelligence (AI).

I applied convex combination (tried different heuristic weights) of couple of heuristic evaluation functions, mainly from intuition and from the ones discussed above:

1. Monotonicity
2. Free Space Available

In my case, the computer player is completely random, but still i assumed adversarial settings and implemented the AI player agent as the max player.

I have 4x4 grid for playing the game.

Observation:

If I assign too much weights to the first heuristic function or the second heuristic function, both the cases the scores the AI player gets are low. I played with many possible weight assignments to the heuristic functions and take a convex combination, but very rarely the AI player is able to score 2048. Most of the times it either stops at 1024 or 512.

I also tried the corner heuristic, but for some reason it makes the results worse, any intuition why?

Also, I tried to increase the search depth cut-off from 3 to 5 (I can't increase it more since searching that space exceeds allowed time even with pruning) and added one more heuristic that looks at the values of adjacent tiles and gives more points if they are merge-able, but still I am not able to get 2048.

I think it will be better to use Expectimax instead of minimax, but still I want to solve this problem with minimax only and obtain high scores such as 2048 or 4096. I am not sure whether I am missing anything.

Below animation shows the last few steps of the game played by the AI agent with the computer player:

Any insights will be really very helpful, thanks in advance. (This is the link of my blog post for the article: https://sandipanweb.wordpress.com/2017/03/06/using-minimax-with-alpha-beta-pruning-and-heuristic-evaluation-to-solve-2048-game-with-computer/ and the youtube video: https://www.youtube.com/watch?v=VnVFilfZ0r4)

The following animation shows the last few steps of the game played where the AI player agent could get 2048 scores, this time adding the absolute value heuristic too:

The following figures show the game tree explored by the player AI agent assuming the computer as adversary for just a single step:

I wrote a 2048 solver in Haskell, mainly because I'm learning this language right now.

My implementation of the game slightly differs from the actual game, in that a new tile is always a '2' (rather than 90% 2 and 10% 4). And that the new tile is not random, but always the first available one from the top left. This variant is also known as Det 2048.

As a consequence, this solver is deterministic.

I used an exhaustive algorithm that favours empty tiles. It performs pretty quickly for depth 1-4, but on depth 5 it gets rather slow at a around 1 second per move.

Below is the code implementing the solving algorithm. The grid is represented as a 16-length array of Integers. And scoring is done simply by counting the number of empty squares.

I thinks it's quite successful for its simplicity. The result it reaches when starting with an empty grid and solving at depth 5 is:

Source code can be found here: https://github.com/popovitsj/2048-haskell

This algorithm is not optimal for winning the game, but it is fairly optimal in terms of performance and amount of code needed:

Many of the other answers use AI with computationally expensive searching of possible futures, heuristics, learning and the such. These are impressive and probably the correct way forward, but I wish to contribute another idea.

Model the sort of strategy that good players of the game use.

For example:

Read the squares in the order shown above until the next squares value is greater than the current one. This presents the problem of trying to merge another tile of the same value into this square.

To resolve this problem, their are 2 ways to move that aren't left or worse up and examining both possibilities may immediately reveal more problems, this forms a list of dependancies, each problem requiring another problem to be solved first. I think I have this chain or in some cases tree of dependancies internally when deciding my next move, particularly when stuck.

Tile needs merging with neighbour but is too small: Merge another neighbour with this one.

Larger tile in the way: Increase the value of a smaller surrounding tile.

etc...

The whole approach will likely be more complicated than this but not much more complicated. It could be this mechanical in feel lacking scores, weights, neurones and deep searches of possibilities. The tree of possibilities rairly even needs to be big enough to need any branching at all.

protected by thefourtheyeMar 14 '14 at 16:34

Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).
Would you like to answer one of these unanswered questions instead?

Not the answer you're looking for? Browse other questions tagged algorithmlogicartificial-intelligence2048 or ask your own question.

This is a selected list of free/libre and open-source (FOSS) video games. Open-source video games are games assembled from and are themselves open-source software, including public domain games with public domain source code. This list includes games in which the game engine is open-source but the game content (media and levels, for example) may be under a different license.

Open engine and free content[edit]

The games in this table are developed under a free and open-source license with free content which allows reuse, modification and commercial redistribution of the whole game. Licenses can be a public domain, GPL license, BSD license, Creative Commons License, zlib license, MIT license, Artistic License and more (see the comparison of Free and open-source software and the Comparison of free and open-source software licenses).

Open-source games with own but non-free content[edit]

While the games in this table are developed under an open-source license, the reuse and modification of only the code is permitted. As some of the games' content (sound, graphics, video and other artwork) is proprietary or restricted in use, the whole games are non-free and restricted in reuse (depending on license). The motivation of a developer to keep the own content non-free while they open the source code is most often the protection of a game as sellable commercial product. Sometimes the motivation is the prevention of a commercialization of free product in future, e.g. when distributed under a CC NC license.

Open-source remakes with non-free content from the proprietary original[edit]

The video game remakes in this table were developed under an open-source license which allows usually the reuse, modification and commercial redistribution of the code. The required game content (artwork, data etc.) is taken from a proprietary and non-opened commercial game, so that the whole game is non-free. See also the Game engine recreation page.

Source-available games[edit]

Video games in this table are source-available, but are neither open-source software according to the OSI definition nor free software according to the Free Software Foundation. These games are released under a license with limited rights for the user, for example only the rights to read and modify the game's source for personal or educational purposes but no reuse rights beside the game's original context are granted. Typical licenses are the creative commons 'non-commercial' licenses (e.g. CC BY-NC-SA), MAME like licenses or several shared source licenses.

Proprietary developed games, later opened under varying licenses[edit]

For games which were originally developed proprietary as commercial closed source product, see also Category:Commercial video games with freely available source code.

See also[edit]

References[edit]

1. ^'0 A.D. Open Source Release'. wildfiregames.com.
2. ^April 1987: Ballerburg - Zwei Spieler, zwei Burgen und ein Berg dazwischen... on eckhardkruse.net 'Ich habe das Programm als Public Domain veröffentlicht' (in German)
3. ^source codeArchived 2016-03-01 at the Wayback Machine on candybox2.net
4. ^Play This Right Now: Candy Box 2 by Nate Ralph on PCworld.com (Oct 24, 2013)
5. ^Petitte, Omri (20 March 2014). 'Cart Life exits Steam, goes open source'. PC Gamer. Retrieved 21 March 2014.
6. ^cartlife_opensores.zip on the author's dropbox
7. ^'The 17th Annual Independent Games Festival'. igf.com.
8. ^cartlife_src
9. ^'Cataclysm: Dark Days Ahead - Dedicated Developer'. Kickstarter. 22 June 2013.
10. ^Jerz, D.G. 'Colossal Cave Adventure'. Seton Hill University. Retrieved 2007-09-07.
11. ^corewar on sourceforge
12. ^pMars-SDL on corewar.co.uk by Joonas Pihlaj (7 May 2003)
13. ^ftp://ftp.ifi.uio.no/pub/crossfire/historic^{[permanent dead link]}
14. ^'Re: CF: the begining(sic) of crossfire'. real-time.com. Archived from the original on 2007-04-04. Retrieved 2013-04-27.
15. ^Jason Rohrer (2011-10-17). 'DiamondTrust/ci/default/tree'. SourceForge. Retrieved 2013-05-22.
16. ^http://daid.github.io/EmptyEpsilon/
17. ^'Savannah Git Hosting - freedoom.git/blob - COPYING'. Git.savannah.gnu.org. Archived from the original on 2009-04-16. Retrieved 2009-04-04.
18. ^http://www.freedroid.org/
19. ^Infiniminer on github.com
20. ^'The KDE Games Open Source Project on Open Hub'. ohloh.net.
21. ^'KDE - KDE 1.0 Release Announcement'. kde.org.
22. ^'Lugaru HD'. Gitlab. Retrieved 14 January 2017.
23. ^'Micropolis Downloads'. donhopkins.com.
24. ^Simser, Bil (2008-01-10). 'SimCity Source Code Released to the Wild! Let the ports begin...' weblogs.asp.net/bsimser. Retrieved 2012-12-30. [...] releasing the original SimCity source code under the GNU General Public Library [...] EA requires that the GPL open-source version not use the same name as SimCity
25. ^Muilwijk, Robin (2017-02-21). 'Best open source games of 2015'. opensource.com. Retrieved 2012-02-21. [...]number one, Minetest, an open source alternative to Minecraft.
26. ^'free-moria'. Retrieved 2009-04-04.
27. ^Patterson, Blake (July 8, 2008). 'Neverball: A Free Alternative to Super Monkey Ball'. TouchArcade. Archived from the original on January 22, 2015. Retrieved February 25, 2015.
28. ^No Gravity (Classic) on sourceforge.net
29. ^'OpenRiichi'. Retrieved 19 August 2018.
30. ^Program, Open Space. 'Open Space Program - Open Space Program'. Open Space Program. Retrieved 2018-01-20.
31. ^https://github.com/itdelatrisu/opsu/blob/master/LICENSE.Missing or empty |title= (help)
32. ^Han, Jeffrey (2017-08-09), opsu! ~ an open-source osu! client, retrieved 2017-08-14
33. ^supportMyWork on hcsoftware.sourceforge.net 'I release all of the source code that I write as free software (free as in 'freedom') into the public domain' (accessed 2016)
34. ^Passage on itunes.apple.com
35. ^'All releases of PySol – Freecode'. freecode.com.
36. ^Clark, Dave (2000-10-29). 'Sopwith Code Support'. Retrieved 2006-12-01.
37. ^Clark, Dave. 'Sopwith – Source Code'. Dave Clark's Home Page. Archived from the original on 2012-02-06. Retrieved 2006-12-01.
38. ^'Star Ruler 2 is now Open Source!'. Retrieved 2018-01-09.
39. ^https://github.com/BlindMindStudios/StarRuler2-Source. Retrieved 2018-01-09.Missing or empty |title= (help)
40. ^'stepmania/stepmania'. GitHub.
41. ^'etterna/etterna'. GitHub.
42. ^CastleDoctrine on sourceforge.net
43. ^Castle Doctrine on store.steampowered.com
44. ^[tremulous] View of /trunk/COPYING
45. ^tf0_2.zip
46. ^doujin-classics-the-works-of-kenta-cho on ricedigital.co.uk
47. ^The Indie Shooter Roundtable: Mak, Cho, And Omega Fire At Will by Brandon Sheffield on Gamasutra.com
48. ^TUMIKI fighters on sourceforge.com
49. ^[1]
50. ^who is Kenta Cho?Archived 2016-03-26 at the Wayback Machine
51. ^[2] The sounds are licensed under the CC BY-NC-SA license. Shockbolt's graphics are licensed under a non-free license.
52. ^'[alienarena] Log of /trunk/docs/license.txt'. Svn.icculus.org. Retrieved 2010-07-13.
53. ^Developer InfoSource Code and License: [...] Our code is open-source, our content isn’t.
54. ^gravitybone-pandora on github.com
55. ^[3] 'For the most part H-Craft Championship sources are released under the zlib-license.'
56. ^[4]You are not allowed to modify or distribute the media files or use them in your own games. But you can still download the media files and they are free for personal use.
57. ^license.txt on hg.icculus.org/icculus/hge-unix
58. ^McLaughlin, Ryan (3 August 2011). 'Humble Indie Bundle Sells Lots, Windows Users Still Cheap'. Hot Hardware. Retrieved 3 August 2011.
59. ^HGE-comes-to-Mac-and-Linux-guest-post-from-Ryan-Gordon on wolfire.com (August 2011)
60. ^Ryan Gordon Ports HGE To Linux, Then Releases Code on Phoronix by Michael Larabel (August 07, 2011)
61. ^hge-unix on icculus.org 'August 7th, 2011: Source code released to the world!'
62. ^'Katawa Shoujo Forums • View topic - Please release Katawa Shoujo source code as free software'. renai.us.
63. ^narcissu.txt
64. ^narcissu on insani.org
65. ^'ppy/osu'. GitHub. Retrieved 2017-02-11.
66. ^'2016-08 dev meeting'. ppy blog. Retrieved 2017-02-11.
67. ^'demystifying open source osu!'. ppy blog. Retrieved 2017-02-11.
68. ^'Steel Storm Episode I'. blendernation.com.
69. ^'STEEL STORM EPISODE 1 LIMITED USER SOFTWARE LICENSE AGREEMENT'. steel-storm.com. Retrieved 2013-08-10. the Art Assets [...] are licensed under Attribution-NonCommercial-ShareAlike 3.0 Unported license. The Engine [...] licensed under GNU GPL v2 license.
70. ^COPYING-MEDIA on git.net-core.org/tome 'All the medias located in all the '/data/gfx' folders are granted to use with the Tales of Maj'Eyal game only. Please contact darkgod@te4.org for more informations.' (2016)
71. ^COPYING on git.net-core.org/tome (2016)
72. ^'Tales of May'Eyal on Steam'. Steam. Retrieved 26 December 2013.
73. ^'Release: Tales of Maj'Eyal and Ashes of Urh'Rok expansion'. GOG. 4 November 2014. Retrieved 5 November 2014.
74. ^'Announcing the release of TDM 2.05! | The Dark Mod'. www.thedarkmod.com. Retrieved 2017-05-30.
75. ^beersrc.zip - readme 'Do whatever your want' license
76. ^source code at studiotrophis.com
77. ^'Urban Terror News'. urbanterror.info.
78. ^'license.txt'. github.com.
79. ^Dominic Tarason (2018-04-27). 'Free Total Annihilation-like RTS Zero-K lands on Steam'. Rock, Paper, Shotgun.
80. ^Prophet. (2002-03-28). 'GameSpyDaily - Exult Interview'. Archived from the original on 2002-04-02. Retrieved 2008-05-29.
81. ^Megidish. (2005-01-12). 'Heart of The Alien - Redux'. Retrieved 2016-10-15.
82. ^OpenVE on github.com
83. ^'official page'. Archived from the original on 2018-01-18. Retrieved 2017-08-23.
84. ^LICENSE.txt on svn.outpostuniverse.org:8443
85. ^OutpostHD - An Outpost Redesign - OutpostHD (Formerly known as Outpost:MIA) on outpost2.net 'Currently I’m using the original Outpost graphics as created in the early 90’s. They are old and primitive with no support for transparency and are in an 8-bit color depth. I’ve been converting them to modern PNG formats and optimizing the sprite sheets for use in a modern graphics engine.' (September 27, 2015)
86. ^Lairworks Entertainment. 'What is OutpostHD?'.
87. ^Montoir. (2011-03-11). 'REminiscence'. Archived from the original on 2015-08-01. Retrieved 2015-08-13.
88. ^'About'. OpenXcom. Retrieved 2013-08-22.
89. ^OpenXCom renews the original OpenXCom renews the original UFO Defense as a valid option for terror by Phil Savage on PC Gamer (May 09, 2013)
90. ^You Wouldn’t Steal A Skyranger: X-Piratez Is An Outstanding Total Conversion Of UFO/X-COM by Sin Vega on Rock, Paper, Shotgun (March 30th, 2016)
91. ^AlienSwarmfork on github.com'readme: You may, free of charge, download and use the SDK to develop a modified Valve game running on the Source engine. You may distribute your modified Valve game in source and object code form, but only for free.'
92. ^resources on remar.se 'source code'
93. ^You can get it here.Archived 2016-04-01 at the Wayback Machine on thatgamecompany.com by Jenova Chen (Sep 21, 2009)
94. ^'Fix My Game: IWBTG Source Code Release'. Kayin.pyoko.org. Retrieved 2015-03-26.
95. ^DIYGamer: Recursive Romhackery – I Wanna Be The Guy Source Code Released (2011)
96. ^'IWBTG! - Downloads!'. Kayin.pyoko.org. Retrieved 2015-03-26.
97. ^Jump 'n BumpArchived 2014-06-06 at the Wayback Machine readme.txt JUMP 'N BUMP by Brainchild Design in 1998 Jump 'n Bump is e-mailware. That means you're supposed to send us an e-mail.
98. ^'Web Archive records of the earliest Noctis' homepage'. Archived from the original on 2000-04-25. Retrieved 2017-01-29.
99. ^license
100. ^copying github.com OpenNotrium
101. ^Prince of Persia source code
102. ^
103. ^pq on bitbucket.org
104. ^ ^abSpelunky User License v1.1b
105. ^Sarkar, Samit (2012-10-12). 'Spelunky unofficially patched with Mac OS X support'. polygon.com. Retrieved 2014-08-07. Spelunky [...] is now playable on Mac OS X, thanks to an unofficial patch from the game's community.
106. ^'Spelunky v1.3 (and Source) - Now for Mac OS X and Windows'. 2012-09-12. Retrieved 2012-10-05.

External links[edit]

• Open source games at Curlie