├── .dockerignore
├── .github
├── ISSUE_TEMPLATE
│ └── add-game-template.md
├── languages.yml
└── workflows
│ ├── main.yml
│ ├── pr_check.py
│ ├── pr_check.yml
│ ├── pr_comment.py
│ └── pr_comment.yml
├── .gitignore
├── .yamllint.yml
├── CHECKS
├── Dockerfile
├── LICENSE
├── Makefile
├── README.md
├── _ext.py
├── feed.xml
├── game.html
├── games
├── 0.yaml
├── a.yaml
├── b.yaml
├── c.yaml
├── d.yaml
├── e.yaml
├── f.yaml
├── g.yaml
├── h.yaml
├── i.yaml
├── j.yaml
├── k.yaml
├── l.yaml
├── m.yaml
├── n.yaml
├── o.yaml
├── p.yaml
├── q.yaml
├── r.yaml
├── s.yaml
├── t.yaml
├── u.yaml
├── v.yaml
├── w.yaml
├── x.yaml
├── y.yaml
└── z.yaml
├── index.html
├── originals
├── 0scumm.yaml
├── a.yaml
├── b.yaml
├── c.yaml
├── d.yaml
├── e.yaml
├── f.yaml
├── g.yaml
├── h.yaml
├── i.yaml
├── j.yaml
├── k.yaml
├── l.yaml
├── m.yaml
├── n.yaml
├── o.yaml
├── p.yaml
├── q.yaml
├── r.yaml
├── s.yaml
├── t.yaml
├── u.yaml
├── v.yaml
├── w.yaml
├── x.yaml
├── y.yaml
└── z.yaml
├── poetry.lock
├── pyproject.toml
├── render.py
├── schema
├── games.yaml
└── originals.yaml
├── scripts
├── awesome_game_remakes.py
├── check_links.py
├── hacktoberfest.py
├── scrape_good_scummvm_games.py
├── scrape_osgl_inspirations.py
├── top_frameworks.py
├── update-development-status.py
└── utils.py
├── static
├── black.png
├── dark-theme.js
├── main.css
└── main.js
├── templates
├── common.html
├── forms
│ ├── form_group.jinja2
│ ├── page.jinja2
│ ├── static
│ │ ├── main.js
│ │ └── tagsinput
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── package.json
│ │ │ ├── tagsinput.css
│ │ │ └── tagsinput.js
│ └── types
│ │ ├── any.jinja2
│ │ ├── date.jinja2
│ │ ├── int.jinja2
│ │ ├── map.jinja2
│ │ ├── seq.jinja2
│ │ ├── str.jinja2
│ │ └── text.jinja2
├── games.html
├── tags.html
└── video.html
└── vhost.conf
/.dockerignore:
--------------------------------------------------------------------------------
1 | .git
2 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/add-game-template.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Add game template
3 | about: Add a new game
4 | title: Add [game name]
5 | labels: game-addition
6 | assignees: ''
7 |
8 | ---
9 |
10 |
20 |
--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
1 | name: Build and Deploy
2 | on: [push, pull_request, pull_request_target]
3 | jobs:
4 | yamllint:
5 | runs-on: ubuntu-latest
6 | steps:
7 | - name: Checkout
8 | uses: actions/checkout@master
9 |
10 | - name: Yamllint
11 | uses: ibiqlik/action-yamllint@v3
12 | with:
13 | file_or_dir: games/*.yaml originals/*.yaml schema/*.yaml
14 | env:
15 | GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
16 |
17 | build:
18 | runs-on: ubuntu-latest
19 | steps:
20 | - name: Checkout
21 | uses: actions/checkout@master
22 |
23 | - name: Install poetry
24 | uses: abatilo/actions-poetry@v4.0.0
25 |
26 | - name: Setup Python
27 | uses: actions/setup-python@v4
28 | with:
29 | python-version: '3.12'
30 | cache: 'poetry'
31 |
32 | - name: Build
33 | run: |
34 | make ci
35 | test 6000 -lt $(cat _build/index.html | wc -l)
36 | env:
37 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
38 |
39 | - name: Minify
40 | run: make min
41 |
42 | - uses: actions/upload-pages-artifact@v3
43 | with:
44 | path: _build
45 |
46 | deploy:
47 | runs-on: ubuntu-latest
48 | needs: build
49 | if: github.ref == 'refs/heads/master'
50 | permissions:
51 | pages: write
52 | id-token: write
53 | environment:
54 | name: github-pages
55 | url: ${{ steps.deployment.outputs.page_url }}
56 | steps:
57 | - name: Deploy to GitHub Pages
58 | id: deployment
59 | uses: actions/deploy-pages@v4
60 |
--------------------------------------------------------------------------------
/.github/workflows/pr_check.py:
--------------------------------------------------------------------------------
1 | import json
2 | import os
3 | import re
4 | from pathlib import Path
5 |
6 | import yaml
7 | from github import Github, GithubException
8 | from thefuzz import process
9 |
10 | GITHUB_TOKEN = os.environ["GITHUB_TOKEN"]
11 | GITHUB_REPOSITORY = os.environ["GITHUB_REPOSITORY"]
12 | PR_NUMBER = int(os.environ["PR_NUMBER"])
13 | GH_PATH = Path(__file__).parent.parent
14 | # https://github.com/github-linguist/linguist/blob/main/lib/linguist/languages.yml
15 | GH_LANGUAGES = set(yaml.safe_load(open(GH_PATH / "languages.yml")).keys()) | {"Delphi"}
16 | KNOWN_FRAMEWORKS = [
17 | '.NET',
18 | 'Adobe AIR',
19 | 'Adventure Game Studio',
20 | 'Allegro',
21 | 'angular',
22 | 'Avalonia',
23 | 'BackBone.js',
24 | 'bgfx',
25 | 'Box2D',
26 | 'Bullet3',
27 | 'Carbon',
28 | 'Castle Game Engine',
29 | 'CreateJS',
30 | 'Cocos2d',
31 | 'Construct',
32 | 'Construct2',
33 | 'Crystal Space',
34 | 'Cube 2 Engine',
35 | 'Daemon Engine',
36 | 'DirectX',
37 | 'DIV Games Studio',
38 | 'Duality',
39 | 'Ebitengine',
40 | 'EntityX',
41 | 'EnTT',
42 | 'Flash',
43 | 'Fyne',
44 | 'FMOD',
45 | 'FNA',
46 | 'GameMaker Studio',
47 | 'GameSprockets',
48 | 'gLib2D',
49 | 'Godot',
50 | 'Graphics32',
51 | 'GTK',
52 | 'HaxeFlixel',
53 | 'Impact',
54 | 'Inform',
55 | 'Irrlicht',
56 | 'JavaFX',
57 | 'JMonkeyEngine',
58 | 'jQuery',
59 | 'Kylix',
60 | 'Laravel',
61 | 'Lazarus',
62 | 'libGDX',
63 | 'libretro',
64 | 'LÖVE',
65 | 'LowRes NX',
66 | 'Luanti',
67 | 'LWJGL',
68 | 'macroquad',
69 | 'melonJS',
70 | 'Mono',
71 | 'MonoGame',
72 | 'ncurses',
73 | 'NeoAxis Engine',
74 | 'Netty.io',
75 | 'nya-engine',
76 | 'OGRE',
77 | 'Open Dynamics Engine',
78 | 'OpenAL',
79 | 'OpenFL',
80 | 'OpenGL',
81 | 'OpenRA',
82 | 'OpenSceneGraph',
83 | 'OpenTK',
84 | 'OpenXR',
85 | 'osu!framework',
86 | 'Oxygine',
87 | 'Panda3D',
88 | 'PandaJS',
89 | 'Phaser',
90 | 'PICO-8',
91 | 'Piston',
92 | 'PixiJS',
93 | 'pygame',
94 | 'QB64',
95 | 'Qt',
96 | 'raylib',
97 | 'React',
98 | 'Redux',
99 | 'rot.js',
100 | 'Rx.js',
101 | 'SDL',
102 | 'SDL2',
103 | 'SDL3',
104 | 'SDL.NET',
105 | 'Sea3D',
106 | 'SFML',
107 | 'Slick2D',
108 | 'Solarus',
109 | 'Source SDK',
110 | 'Spring RTS Engine',
111 | 'Starling',
112 | 'Swing',
113 | 'SWT',
114 | 'three.js',
115 | 'TGUI',
116 | 'TIC-80',
117 | 'Torque 3D',
118 | 'Tween.js',
119 | 'Unity',
120 | 'Unreal Engine 5',
121 | 'VDrift Engine',
122 | 'Vue.js',
123 | 'Vulkan',
124 | 'WebGL',
125 | 'wxWidgets',
126 | 'XNA'
127 | ]
128 | FRAMEWORK_LANGUAGES = {
129 | "SDL2": {"C++", "C"},
130 | "SDL": {"C++", "C"},
131 | "SDL.NET": {"C#"},
132 | "OpenGL": {"C++", "C"},
133 | "Unity": {"C#"},
134 | "SFML": {"C++"},
135 | "libGDX": {"Java", "Kotlin"},
136 | "Qt": {"C++"},
137 | "Allegro": {"C++", "C"},
138 | "pygame": {"Python"},
139 | "OGRE": {"C++"},
140 | "Fyne": {"Go"},
141 | }
142 | MIN_FUZZ_SCORE = 95
143 | unknown_languages = False
144 | unknown_frameworks = False
145 |
146 | g = Github(GITHUB_TOKEN)
147 | repo = g.get_repo(GITHUB_REPOSITORY)
148 | pr = repo.get_pull(PR_NUMBER)
149 | print("PR", pr.url)
150 | output = {
151 | "content": "Hey there! Thanks for contributing a PR to osgameclones! 🎉",
152 | "labels": set(label.name for label in pr.labels),
153 | "pr": PR_NUMBER,
154 | }
155 |
156 | # Get game changes
157 | files = pr.get_files()
158 | changed_files = [str(file) for file in files]
159 | print("Changed files", changed_files)
160 |
161 |
162 | def load_games_file(filename: str, sha: str):
163 | try:
164 | contents = repo.get_contents(filename, sha)
165 | except GithubException as e:
166 | print("Cannot get file at", filename, e)
167 | return {}
168 | file = contents.decoded_content.decode()
169 | parsed = yaml.safe_load(file)
170 | return {game["name"]: game for game in parsed}
171 |
172 |
173 | def added_checks(game):
174 | if match := re.search(r"github.com/([^/]+)/", game.get("repo", "")):
175 | author = match[1]
176 | yield f"💌 Hey @{author}, we're adding your game to osgameclones!"
177 |
178 |
179 | def common_checks(game):
180 | yield from check_has_added(game)
181 | yield from check_not_same_repo_and_url(game)
182 | yield from check_has_images_or_videos(game)
183 | yield from check_language_known(game)
184 | yield from check_framework_known(game)
185 | yield from check_framework_language(game)
186 | yield from check_repo_google_code(game)
187 |
188 |
189 | def check_has_added(game):
190 | if "added" not in game:
191 | yield f"📅 {game['name']} has no added date"
192 |
193 |
194 | def check_not_same_repo_and_url(game):
195 | if game.get("url") == game.get("repo"):
196 | yield f"👯 {game['name']}'s url and repo are the same - " \
197 | "please use repo for the development project page (such as GitHub) " \
198 | "and url as the public-facing page, if any"
199 |
200 |
201 | def check_has_images_or_videos(game):
202 | if not game.get("images") and not game.get("video"):
203 | yield f"🖼 {game['name']} has no images or videos. " \
204 | "Please help improve the entry by finding some!"
205 |
206 |
207 | def check_language_known(game):
208 | if u := {lang for lang in game.get("langs", []) if lang not in GH_LANGUAGES}:
209 | yield f"🔢 {game['name']} has unknown language{'s'[:len(u)^1]} \"{', '.join(u)}\". " \
210 | "Please check for spelling errors."
211 | for ul in u:
212 | choice, score = process.extractOne(ul, GH_LANGUAGES)
213 | print("Fuzz match language", ul, "->", choice, ":", score)
214 | if score >= MIN_FUZZ_SCORE:
215 | yield f"- Suggested fix: {ul} -> **{choice}**"
216 | global unknown_languages
217 | unknown_languages = True
218 |
219 |
220 | def check_framework_known(game):
221 | if not (frameworks := game.get("frameworks")):
222 | return
223 | if u := [f for f in frameworks if f not in KNOWN_FRAMEWORKS]:
224 | yield f"🌇 {game['name']} has unknown framework{'s'[:len(u)^1]} \"{', '.join(u)}\". " \
225 | "Please check for spelling errors."
226 | for uf in u:
227 | choice, score = process.extractOne(uf, KNOWN_FRAMEWORKS)
228 | print("Fuzz match framework", uf, "->", choice, ":", score)
229 | if score >= MIN_FUZZ_SCORE:
230 | yield f"- Suggested fix: {uf} -> **{choice}**"
231 | global unknown_frameworks
232 | unknown_frameworks = True
233 |
234 |
235 | def check_framework_language(game):
236 | if not (frameworks := game.get("frameworks")):
237 | return
238 | for framework in frameworks:
239 | if not (framework_langs := FRAMEWORK_LANGUAGES.get(framework, set())):
240 | continue
241 | if not set(game.get("langs", [])) & framework_langs:
242 | yield f"🏗 {game['name']} uses \"{framework}\" as a framework, " \
243 | f"but doesn't have {', '.join(framework_langs)} in its languages."
244 |
245 |
246 | def check_repo_google_code(game):
247 | if "code.google" in game.get("repo", ""):
248 | yield f"⚰️ {game['name']}'s repo is Google Code, a dead service. " \
249 | "Please check if there is an updated repo elsewhere."
250 |
251 |
252 | # Scan files for changes
253 | games_added = set()
254 | games_changed = set()
255 | games_removed = set()
256 | has_py = False
257 | has_js = False
258 | check_messages = []
259 | for file in files:
260 | if file.filename.endswith(".py"):
261 | has_py = True
262 | elif file.filename.endswith(".js"):
263 | has_js = True
264 | elif re.match(r"^games/\w+\.yaml$", file.filename):
265 | print("Game file changed", file)
266 | old_games = load_games_file(file.filename, pr.base.sha)
267 | new_games = load_games_file(file.filename, pr.head.sha)
268 |
269 | for game in old_games:
270 | if game not in new_games:
271 | games_removed.add(game)
272 | for game in new_games:
273 | if game not in old_games:
274 | games_added.add(game)
275 | for message in added_checks(new_games[game]):
276 | check_messages.append(message)
277 | for message in common_checks(new_games[game]):
278 | check_messages.append(message)
279 | for game in old_games:
280 | if game in new_games:
281 | if old_games[game] != new_games[game]:
282 | games_changed.add(game)
283 | for message in common_checks(new_games[game]):
284 | check_messages.append(message)
285 |
286 | # Update comment based on changed games and checks
287 | if games_added:
288 | output["content"] += f"\nGame{'s'[:len(games_added) ^ 1]} added: {', '.join(games_added)} 🎊"
289 | if games_changed:
290 | output["content"] += f"\nGame{'s'[:len(games_changed) ^ 1]} updated: {', '.join(games_changed)} 👏"
291 | if games_removed:
292 | output["content"] += f"\nGame{'s'[:len(games_removed) ^ 1]} removed: {', '.join(games_removed)} 😿"
293 | if check_messages:
294 | output["content"] += "\n### Issues found\n- " + "\n- ".join(check_messages)
295 | if unknown_languages:
296 | output["content"] += "\n### Known Languages\n" + ", ".join(sorted(GH_LANGUAGES, key=str.casefold))
297 | if unknown_frameworks:
298 | output["content"] += "\n### Known Frameworks\n" + ", ".join(sorted(KNOWN_FRAMEWORKS, key=str.casefold))
299 |
300 | # Update issue labels
301 | if has_py:
302 | output["labels"].add("python")
303 | if has_js:
304 | output["labels"].add("javascript")
305 | if games_added:
306 | output["labels"].add("game-addition")
307 | if games_changed or games_removed:
308 | output["labels"].add("game-correction")
309 |
310 | # Update GitHub PR
311 | path = Path("./pr/output.json")
312 | path.parent.mkdir(exist_ok=True, parents=True)
313 | output["labels"] = list(output["labels"])
314 | path.write_text(json.dumps(output))
315 |
316 | """
317 | Ideas for more PR suggestions
318 | - Scrape repo and url and look for screenshot candidates
319 | - Scrape github repo to find
320 | - matching license
321 | - dev status
322 | - releases feed
323 | - languages
324 | - Make suggested changes in PR
325 | """
--------------------------------------------------------------------------------
/.github/workflows/pr_check.yml:
--------------------------------------------------------------------------------
1 | name: Check PR for common problems
2 | on:
3 | pull_request:
4 | jobs:
5 | pr_check:
6 | runs-on: ubuntu-latest
7 | steps:
8 | - name: Checkout
9 | uses: actions/checkout@master
10 |
11 | - name: Install poetry
12 | uses: abatilo/actions-poetry@v4.0.0
13 |
14 | - name: Setup Python
15 | uses: actions/setup-python@v4
16 | with:
17 | python-version: '3.12'
18 | cache: 'poetry'
19 |
20 | - name: PR Check
21 | run: |
22 | poetry install --no-root --with dev
23 | poetry run python .github/workflows/pr_check.py
24 | env:
25 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
26 | GITHUB_REPOSITORY: ${{ github.repository }}
27 | PR_NUMBER: ${{ github.event.pull_request.number }}
28 |
29 | - uses: actions/upload-artifact@v4
30 | with:
31 | name: pr
32 | path: pr/
--------------------------------------------------------------------------------
/.github/workflows/pr_comment.py:
--------------------------------------------------------------------------------
1 | import json
2 | import os
3 | import sys
4 | import zipfile
5 | from pathlib import Path
6 |
7 | import httpx
8 | from github import Github, GithubException
9 | from github.Artifact import Artifact
10 |
11 | GITHUB_TOKEN = os.environ["GITHUB_TOKEN"]
12 | GITHUB_REPOSITORY = os.environ["GITHUB_REPOSITORY"]
13 | RUN_ID = int(os.environ["RUN_ID"])
14 | GITHUB_BOT_LOGIN = "github-actions[bot]"
15 |
16 | g = Github(GITHUB_TOKEN)
17 | repo = g.get_repo(GITHUB_REPOSITORY)
18 |
19 | # Download artifact
20 | run = repo.get_workflow_run(RUN_ID)
21 | print("Run", run)
22 | artifacts = run.get_artifacts()
23 | artifact: Artifact
24 | for a in artifacts:
25 | print("Artifact", a)
26 | if a.name == "pr":
27 | artifact = a
28 | break
29 | else:
30 | print("Could not find pr artifact")
31 | sys.exit(1)
32 | resp = httpx.get(
33 | artifact.archive_download_url, headers={"Authorization": f"Bearer {GITHUB_TOKEN}"}, follow_redirects=True)
34 | if not resp.is_success:
35 | print("Download request failed", resp)
36 | sys.exit(1)
37 | with(open("out.zip", "wb")) as f:
38 | f.write(resp.content)
39 | with zipfile.ZipFile("out.zip", "r") as zip_ref:
40 | zip_ref.extractall(".")
41 |
42 | # Get PR content
43 | output = json.loads(Path("output.json").read_text())
44 | print("Comment content", output)
45 | pr = repo.get_pull(output["pr"])
46 | print("PR", pr.url)
47 | output["labels"] = set(output["labels"])
48 |
49 | # Update GitHub PR
50 | for c in pr.get_issue_comments():
51 | print("checking comment", c.user.login)
52 | if c.user.login == GITHUB_BOT_LOGIN:
53 | print("found bot comment", c.body)
54 | comment = c
55 | if comment.body != output["content"]:
56 | comment.edit(output["content"])
57 | break
58 | else:
59 | print("bot comment not found")
60 | try:
61 | comment = pr.create_issue_comment(output["content"])
62 | except GithubException as e:
63 | print("cannot create issue comment - possibly a non-standard PR", e)
64 |
65 | # Update labels
66 | if output["labels"] != set(label.name for label in pr.labels):
67 | print("Updating labels from", pr.labels, "to", output["labels"])
68 | pr.set_labels(*output["labels"])
--------------------------------------------------------------------------------
/.github/workflows/pr_comment.yml:
--------------------------------------------------------------------------------
1 | name: Comment on the pull request
2 | on:
3 | workflow_run:
4 | workflows: [Check PR for common problems]
5 | types:
6 | - completed
7 | jobs:
8 | upload:
9 | runs-on: ubuntu-latest
10 | if: >
11 | github.event.workflow_run.event == 'pull_request' &&
12 | github.event.workflow_run.conclusion == 'success'
13 | steps:
14 | - name: Checkout
15 | uses: actions/checkout@master
16 |
17 | - name: Install poetry
18 | uses: abatilo/actions-poetry@v4.0.0
19 |
20 | - name: Setup Python
21 | uses: actions/setup-python@v4
22 | with:
23 | python-version: '3.12'
24 | cache: 'poetry'
25 |
26 | - name: PR comment
27 | run: |
28 | poetry install --no-root --with dev
29 | poetry run python .github/workflows/pr_comment.py
30 | env:
31 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
32 | GITHUB_REPOSITORY: ${{ github.repository }}
33 | RUN_ID: ${{ github.event.workflow_run.id }}
34 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | _build/
2 | .env/
3 | .venv/
4 | .vs/
5 | node_modules/
6 | *.pyc
7 |
--------------------------------------------------------------------------------
/.yamllint.yml:
--------------------------------------------------------------------------------
1 | rules:
2 | key-duplicates: {}
3 | indentation:
4 | spaces: 2
5 | indent-sequences: false
6 | level: error
7 |
--------------------------------------------------------------------------------
/CHECKS:
--------------------------------------------------------------------------------
1 | /index.html Open Source Game Clones
2 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM alpine AS builder
2 |
3 | RUN mkdir /src /app
4 | WORKDIR /src
5 | COPY . /src/
6 | COPY CHECKS /app/CHECKS
7 |
8 | RUN apk add --no-cache curl make gcc musl-dev libffi-dev python3 python3-dev
9 | RUN env
10 | RUN curl -sSL https://install.python-poetry.org | POETRY_HOME=/etc/poetry python3 -
11 |
12 | ENV PATH /etc/poetry/bin/:$PATH
13 |
14 | RUN poetry install
15 | RUN make run
16 |
17 | FROM nginx:1.27.4-alpine
18 |
19 | COPY --from=builder /src/_build /www
20 | COPY vhost.conf /etc/nginx/conf.d/default.conf
21 | COPY CHECKS /app/CHECKS
22 | EXPOSE 80
23 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Code
2 | ----
3 |
4 | Copyright (c) 2011-2016 Vsevolod Solovyov, Alexander Solovyov, and other
5 | contributors under the terms of MIT License.
6 |
7 | https://opensource.org/licenses/MIT
8 |
9 |
10 | Content
11 | -------
12 |
13 | Copyright (c) 2011-2016 Vsevolod Solovyov, Alexander Solovyov, and other
14 | contributors under the terms of Creative Commons Attribution 4.0 License.
15 |
16 | https://creativecommons.org/licenses/by/4.0/
17 |
18 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | PORT=80
2 |
3 | run:
4 | poetry run python render.py
5 |
6 | min:
7 | poetry run htmlmin _build/index.html _build/index.html
8 |
9 | poetry:
10 | pipx install poetry
11 |
12 | poetry-install:
13 | poetry install --no-root
14 |
15 | prod: poetry poetry-install run min
16 | ci: poetry-install run
17 |
18 | docker-build:
19 | docker build -t opengaming/osgameclones .
20 |
21 | docker-run:
22 | -docker rm -f osgameclones-site
23 | docker run -d -p${PORT}:80 --name osgameclones-site opengaming/osgameclones
24 |
25 | .PHONY:
26 | run prod docker-build docker-run
27 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Open Source Game Clones
2 |
3 | [](https://github.com/opengaming/osgameclones/actions/workflows/main.yml)
4 |
5 | This is the source of [https://osgameclones.com](https://osgameclones.com).
6 | Feel free to add new games or improve information about those already in the database
7 | by submitting a pull request or opening an issue.
8 |
9 | ## Games database
10 |
11 | All of the games and their references to the original games are stored in YAML files under
12 | [`games`][games] and [`originals`][originals]. All information is inside, and you should
13 | more or less understand what's going on by reading it. Sorting is alphabetical, with the
14 | exception of ScummVM, just because it's so many games at once.
15 |
16 | ## Add a clone / remake of a game
17 |
18 | Fill in the [game form][game_form] presented when you create
19 | a new issue. Even better if you edit the files in the [`games`][games] directory directly. Your
20 | changes will be submitted as a pull request. All games are validated against the rules
21 | in the [`schema/games.yaml`][schema_games] validation file.
22 |
23 | ## Add a reference to the original game
24 |
25 | Fill in the [add original form][original_form].
26 | All the games listed need an original game they re-implement or clone. If there is no
27 | existing game entry in [`originals`][originals] directory you can create a new entry
28 | for it by following the following format. All originals are validated against the rules
29 | in the [`schema/originals.yaml`][schema_originals] validation file.
30 |
31 | ## Contributing
32 |
33 | ### Pre-requisites
34 |
35 | * [poetry][poetry]
36 |
37 |
38 | ### Install
39 |
40 | Clone this repository and run inside the directory:
41 |
42 | ```
43 | poetry install
44 | ```
45 | ### Building
46 |
47 | Simply run the following to build the project into the `_build` directory.
48 |
49 | ```
50 | make
51 | ```
52 |
53 | ### Running the server with Docker
54 |
55 | You must first build a Docker image
56 |
57 | ```bash
58 | make docker-build
59 | ```
60 |
61 | After building the docker image, run the server with Docker
62 |
63 | ```bash
64 | make docker-run
65 | ```
66 |
67 | The server will be available at http://localhost:80, you can choose the port with the **PORT** variable.
68 |
69 | ```bash
70 | # The server will be available at http://localhost:3000
71 | make docker-run PORT=3000
72 | ```
73 |
74 | ## License
75 |
76 | See [LICENSE][license]
77 |
78 | [games]: games/
79 | [originals]: originals/
80 | [schema_games]: schema/games.yaml
81 | [schema_originals]: schema/originals.yaml
82 | [game_form]: https://osgameclones.com/add_game.html
83 | [original_form]: https://osgameclones.com/add_original.html
84 | [license]: LICENSE
85 |
86 | [python]: https://www.python.org
87 | [poetry]: https://python-poetry.org/
88 |
--------------------------------------------------------------------------------
/feed.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | Open Source Game Clones: New/Updated Games
4 | Games entries that have been added or updated in the last 30 days
5 | {{ updated.strftime('%Y-%m-%dT%H:%M:%SZ') }}
7 | https://osgameclones.com/
8 |
13 | {{ game.name | e }}
14 |
15 | OSGC
16 |
17 | https://osgameclones.com/game/{{ game.name | slugify }}
18 | {{ game.updated.strftime('%Y-%m-%dT%H:%M:%SZ') }}
20 | {{ game.type }} of {{ ', '.join(names) | e }} {{ game.info | e }}
21 |
22 | {%- endfor %}
23 |
24 |
--------------------------------------------------------------------------------
/game.html:
--------------------------------------------------------------------------------
1 | {%- import 'templates/common.html' as common with context %}
2 | {%- import 'templates/games.html' as games with context %}
3 |
4 | {# TODO: pass keywords #}
5 | {{- common.head(title, None, description) }}
6 | {{ common.nav() }}
7 |
8 |
9 |
13 |
14 |
15 | {{ games.render(game, true) }}
16 |
17 |
18 |
8 | Open Source Game Clones
9 |
10 |
11 | This site tries to gather open-source
12 | or source-available
13 | remakes of great old games in one place. If you think that
14 | something is missing from the list - please go to
15 | our GitHub
16 | repository and create an issue or even a pull request!
17 |
18 |
19 | Since all these projects are open-source you can help them and make this
20 | world a better place. Or at least you can play something to appreciate the
21 | effort people put in them.
22 |
23 |
24 | Similar resources:
25 |
26 |
33 |
34 | A Remake is a game where the executable and sometimes the assets as well are remade open source. Some of these games aren't exact remakes but evolution of original ones, which were eventually open sourced.
35 | Clone is a game which is very similar to or heavily inspired by a game or series.
37 | Official project is the official source code release for a game that was formerly closed-source, maintained by the original creators and has minimal changes.
39 | Similar game is one which has similar gameplay but is not a clone.
41 | Tool is not a game, but something that assists in playing or modding the game, such as a high resolution patch, or resource extractor.
43 |
44 |
45 |
46 |
47 |
48 | New and updated games
49 |
51 |
52 | {% for names, meta, clone in site.new_games.values() %}
53 | {{ games.render_clone(names, meta, clone, true, false) }}
54 | {% endfor %}
55 |
56 |
59 |
64 |
65 | {% for game in site.games %}
66 | {{ games.render(game, false) }}
67 | {% endfor %}
68 |
69 |
70 |
{md}
")
33 | urls = set()
34 | for link in doc.xpath("//a"):
35 | url = link.attrib["href"]
36 | for pat in BLACKLIST_PATTERNS:
37 | if pat.match(url):
38 | break
39 | else:
40 | urls.add(url)
41 | # Find URLs and repos from OSGC
42 | osgc_urls = set()
43 | for game in games():
44 | if repo := game.get("repo", ""):
45 | osgc_urls.add(repo)
46 | if url := game.get("repo", ""):
47 | osgc_urls.add(url)
48 | # Print URLS that OSGC doesn't have
49 | for url in urls - osgc_urls:
50 | print(url)
51 |
52 | if __name__ == "__main__":
53 | asyncio.run(main())
54 |
--------------------------------------------------------------------------------
/scripts/check_links.py:
--------------------------------------------------------------------------------
1 | """
2 | Check game URLs and repos for broken links
3 | """
4 | import asyncio
5 | import httpx
6 |
7 | from scripts.utils import games
8 |
9 |
10 | async def check_link(q):
11 | while True:
12 | game, url = await q.get()
13 | resp = httpx.get(url)
14 | if not resp.is_success:
15 | print(f"{url} returned {resp.status_code} ({game['name']})")
16 | q.task_done()
17 |
18 |
19 | async def main():
20 | q = asyncio.Queue()
21 | # start workers
22 | worker_tasks = []
23 | for i in range(10):
24 | task = asyncio.create_task(check_link(q))
25 | worker_tasks.append(task)
26 | # add urls to queue
27 | for game in games():
28 | print(f"Checking {game['name']}...")
29 | if "repo" in game:
30 | await q.put((game, game["repo"]))
31 | if "url" in game:
32 | await q.put((game, game["url"]))
33 | for img in game.get("images", []):
34 | await q.put((game, img))
35 | # TODO: check videos
36 | # wait for tasks to complete
37 | print("Waiting for workers...")
38 | await q.join()
39 | # stop workers
40 | for task in worker_tasks:
41 | task.cancel()
42 | await asyncio.gather(*worker_tasks, return_exceptions=True)
43 |
44 |
45 | if __name__ == "__main__":
46 | asyncio.run(main())
47 |
--------------------------------------------------------------------------------
/scripts/hacktoberfest.py:
--------------------------------------------------------------------------------
1 | """
2 | This script finds repos participating in hacktoberfest:
3 | - Hosted on GitHub or gitlab
4 | - Includes the "hacktoberfest" topic
5 |
6 | To run, install from pip:
7 | - pygithub
8 | - python-gitlab
9 |
10 | Add environment variables:
11 | - GH_TOKEN (see https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token#creating-a-token)
12 | - with public_repo permission
13 | - GL_TOKEN (see https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-personal-access-token)
14 | - with read_api scope
15 | """
16 | import os
17 | import re
18 |
19 | from github import Github, GithubException
20 | from gitlab import Gitlab, GitlabHttpError, GitlabGetError
21 |
22 | from scripts.utils import games
23 |
24 | GH_REGEX = re.compile(r"https://github.com/([^/]+)/([^/]+)")
25 | GL_REGEX = re.compile(r"https://gitlab.com/([^/]+/[^/]+)")
26 |
27 |
28 | def main():
29 | gh = Github(os.environ["GH_TOKEN"])
30 | gl = Gitlab("https://gitlab.com", private_token=os.environ["GL_TOKEN"])
31 | hacktober_games = {}
32 | for game in games():
33 | repo_url = game.get("repo", "")
34 | if not repo_url:
35 | continue
36 | match = re.match(GH_REGEX, repo_url)
37 | if match:
38 | owner, repo = match.groups()
39 | try:
40 | gh_repo = gh.get_repo(f"{owner}/{repo}")
41 | except GithubException as e:
42 | print(f"Error getting GitHub repo info for {owner}/{repo}: {e}")
43 | continue
44 | topics = gh_repo.get_topics()
45 | if "hacktoberfest" in topics:
46 | game["platform"] = "github"
47 | game["stars"] = gh_repo.stargazers_count
48 | hacktober_games[game["name"]] = game
49 | else:
50 | match = re.match(GL_REGEX, repo_url)
51 | if match:
52 | project_namespace = match.groups()[0]
53 | try:
54 | project = gl.projects.get(project_namespace)
55 | except (GitlabHttpError, GitlabGetError) as e:
56 | print(f"Error getting Gitlab repo info for {project_namespace}: {e}")
57 | continue
58 | if "hacktoberfest" in project.topics:
59 | game["platform"] = "gitlab"
60 | game["stars"] = project.star_count
61 | hacktober_games[game["name"]] = game
62 | for name, game in hacktober_games.items():
63 | stars_badge = f""
64 | langs = ", ".join(f"`{lang}`" for lang in game.get('langs', []))
65 | frameworks = ", ".join(f"`{fw}`" for fw in game.get('frameworks', []))
66 | print(f"- [**{name}** {stars_badge}]({game['repo']}): ({game.get('development', '')} {game.get('status', '')} {langs} {frameworks})")
67 |
68 |
69 | if __name__ == "__main__":
70 | main()
71 |
--------------------------------------------------------------------------------
/scripts/scrape_good_scummvm_games.py:
--------------------------------------------------------------------------------
1 | """
2 | Scrape ScummVM supported games at good or excellent level, and create YAML clone templates
3 |
4 | Uses libraries:
5 | - beautifulsoup4
6 | - httpx
7 | - tenacity
8 | """
9 | import re
10 | from pathlib import Path
11 | from typing import Container, Optional
12 |
13 | import httpx
14 | import yaml
15 | from bs4 import BeautifulSoup
16 | from tenacity import stop_after_attempt, retry, wait_exponential
17 | from utils import originals
18 |
19 | SCUMMVM_LIST = "https://www.scummvm.org/compatibility/"
20 | SCUMMVM_BASE_URL = "https://www.scummvm.org"
21 | SUPPORT_LEVELS = {"Good", "Excellent"}
22 | PLATFORM_ALIASES = {
23 | "Apple IIgs": "Apple II",
24 | "Atari ST": "Atari",
25 | "Macintosh": "Classic Mac OS",
26 | "Sega CD": "Genesis",
27 | "Steam": "Windows",
28 | "Tandy Color Computer 3": "CoCo",
29 | }
30 | # These games are not games or compilations/demos that shouldn't have their own game entries
31 | BLACKLIST = {
32 | "Inside the Chest",
33 | "King's Questions",
34 | "Passport to Adventure (Indiana Jones and the Last Crusade, The Secret of Monkey Island, Loom)",
35 | "Mission Supernova 1",
36 | "Mission Supernova 2"
37 | }
38 |
39 |
40 | def main():
41 | # Get list of OSGC originals
42 | osgc_originals = set()
43 | for original in originals():
44 | osgc_originals.add(original["name"])
45 | for name in original.get("names", []):
46 | osgc_originals.add(name)
47 |
48 | # Get platforms
49 | platforms = yaml.safe_load(open(Path("schema") / "originals.yaml", encoding="utf-8"))["schema;platforms"]["enum"]
50 |
51 | # Get list of games
52 | resp = httpx.get(SCUMMVM_LIST)
53 | content = resp.text
54 | soup = BeautifulSoup(content, "html.parser")
55 | game_links = {}
56 | for td_name, td_support_level in zip(soup.find_all("td", class_="gameFullName"), soup.find_all("td", class_="gameSupportLevel")):
57 | # Filter out those that aren't good enough
58 | if td_support_level.text not in SUPPORT_LEVELS:
59 | continue
60 | name = td_name.text.strip()
61 | # Filter out engines
62 | if name.endswith(" games"):
63 | continue
64 | # Filter out blacklist
65 | if name in BLACKLIST:
66 | continue
67 | # Use name in parens if present
68 | if match := re.match(r".+ \((.+)\)", name):
69 | name = match.group(1)
70 | game_links[name] = SCUMMVM_BASE_URL + td_name.a.attrs["href"]
71 |
72 | # Generate originals list
73 | origs = list(game_links)
74 |
75 | # Filter out those we already have (match case-insensitive)
76 | def game_is_in_original(game: str) -> bool:
77 | if game in osgc_originals:
78 | return True
79 | # Try case-insensitive
80 | if game.lower() in {o.lower() for o in osgc_originals}:
81 | return True
82 | # Try using the name before or after the colon
83 | if (match := re.match(r"(.+):(.+)", game)) and (match.group(1).strip() in osgc_originals or match.group(2).strip() in osgc_originals):
84 | return True
85 | # Try matching without certain punctuation
86 | if game.replace("!", "") in {o.replace("!", "") for o in osgc_originals}:
87 | return True
88 | return False
89 | missing_originals = {original for original in origs if not game_is_in_original(original)}
90 | print("ScummVM originals:")
91 | for original in sorted(missing_originals):
92 | print(f"- {original}")
93 |
94 | for original in missing_originals:
95 | if game_info := scrape_game_info(game_links[original], platforms):
96 | print(yaml.dump(game_info))
97 |
98 |
99 | @retry(stop=stop_after_attempt(10), wait=wait_exponential(multiplier=1, min=2, max=10))
100 | def scrape_game_info(link: str, platforms: Container[str]) -> Optional[dict]:
101 | # Go to game subpage
102 | resp = httpx.get(link)
103 | content = resp.text
104 | soup = BeautifulSoup(content, "html.parser")
105 |
106 | # Don't add games that aren't clones
107 | if soup.find("a", string="ScummVM Freeware Games"):
108 | return None
109 |
110 | # Generate game entry, with name
111 | game = {
112 | "name": soup.find("td", class_="gameFullName").text,
113 | "external": {},
114 | "platforms": [],
115 | "meta": {
116 | "genres": [],
117 | "themes": [],
118 | }
119 | }
120 | # Add Supported Platforms
121 | supported_platforms_title = soup.find("h3", string="Supported Platforms")
122 | if supported_platforms_lis := supported_platforms_title.find_next_sibling("ul"):
123 | for li in supported_platforms_lis.find_all("li"):
124 | platform = li.text.strip()
125 | platform = PLATFORM_ALIASES.get(platform, platform)
126 | if platform not in platforms:
127 | print(f"{platform=} unknown")
128 | elif platform not in game["platforms"]:
129 | game["platforms"].append(platform)
130 |
131 | # Find links
132 | if wikipedia_link := soup.find("a", string="Wikipedia"):
133 | game["external"]["wikipedia"] = wikipedia_name(wikipedia_link.attrs["href"])
134 | if mobygames_link := soup.find("a", string="MobyGames"):
135 | game["external"]["website"] = mobygames_link.attrs["href"]
136 | if not wikipedia_link and not mobygames_link:
137 | # Use ScummVM wiki as fallback
138 | if scummvm_link := soup.find("a", string="ScummVM Wiki"):
139 | game["external"]["website"] = scummvm_link.attrs["href"]
140 | else:
141 | print(f"Cannot find link for {game['name']}")
142 |
143 | return game
144 |
145 |
146 | def wikipedia_name(link: str) -> str:
147 | """
148 | >>> wikipedia_name("https://en.wikipedia.org/wiki/Operation_Stealth")
149 | 'Operation Stealth'
150 | """
151 | return link.split("/")[-1].replace("_", " ")
152 |
153 |
154 | if __name__ == "__main__":
155 | main()
156 |
--------------------------------------------------------------------------------
/scripts/scrape_osgl_inspirations.py:
--------------------------------------------------------------------------------
1 | import re
2 |
3 | import httpx
4 | from mistletoe import Document
5 | from mistletoe.block_token import Heading, List
6 | from scripts.utils import games, originals
7 |
8 | INSPIRATION_PATTERN = re.compile(r"(.+) \[\d+\]")
9 | INSPIRED_PATTERN = re.compile(r"Inspired entries: (.+)")
10 | # OSGL name to OSGC alias
11 | ALIASES = {
12 | "Alone in the Dark series": "Alone in the Dark",
13 | "Anno (series)": "Anno series",
14 | "Anno 1404": "Anno series",
15 | "BioWare's Aurora engine": "Neverwinter Nights",
16 | "Blake Stone: Aliens of Gold": "Blake Stone: Planet Strike",
17 | "Blasteroids": "Asteroids",
18 | "Caesar 3": "Caesar III",
19 | "Civilization series": "Civilization",
20 | "Company of Heroes: Opposing Fronts": "Company of Heroes",
21 | "Company of Heroes: Tales of Valor": "Company of Heroes",
22 | "CrossFire 1981": "Crossfire",
23 | "CrossUO": "CrossUO: Ultima Online",
24 | "Final Fantasy series": "Final Fantasy",
25 | "Krush Kill 'n' Destroy": "Krush, Kill 'n' Destroy",
26 | "Marathon 2: Durandal": "Marathon 2",
27 | "Microprose Falcon 4.0 Combat Simulator": "Falcon",
28 | "Panzer General 2": "Panzer General",
29 | "Quake II": "Quake 2",
30 | "Quake III Arena": "Quake 3",
31 | "QUakeWorld": "Quake",
32 | "Runescape Classic": "RuneScape Classic",
33 | "S.T.A.L.K.E.R: Call of Pripyat": "S.T.A.L.K.E.R.: Call of Pripyat",
34 | "Settlers": "The Settlers",
35 | "Shobon Action": "Syobon Action",
36 | "Simon Says": "Simon",
37 | "Sonic the Hedgehog series": "Sonic the Hedgehog",
38 | "Super Methane Brothers for Wii and GameCube": "Super Methane Brothers (homebrew edition)",
39 | "Super Pang": "Pang",
40 | "The Incredible Machine series": "The Incredible Machine",
41 | "Ultima series": "Ultima",
42 | "Ultima Underworld 1": "Ultima Underworld",
43 | "Warcraft": "Warcraft: Orcs & Humans",
44 | "World of Might and Magic": "OpenEnroth",
45 | "Worms": "Worms Series",
46 | "X-COM: Enemy Unknown": "X-COM: UFO Defense",
47 | }
48 | # Games that aren't games, aren't interesting enough or weren't closed source
49 | BLACKLIST = {
50 | "Angband",
51 | "arithmetic",
52 | "Black Shades",
53 | "Blob Wars Attrition",
54 | "Blobby Volley",
55 | "Brogue",
56 | "Cards Against Humanity",
57 | "Catan",
58 | "Chromium B.S.U.",
59 | "CorsixTH",
60 | "Cube",
61 | "Cube 2: Sauerbraten",
62 | "CUBE engine",
63 | "Daimonin",
64 | "Dragon Wars",
65 | "DragonBall",
66 | "Dungeon Crawl Stone Soup",
67 | "Elite Command",
68 | "Emerald Mine", # clone of Boulder Dash
69 | "Eternal Lands",
70 | "Falcon's Eye",
71 | "Final Fantasy series", # not specific enough
72 | "Flixel",
73 | "FooBillard",
74 | "GalaxyMage",
75 | "Game of Life", # ambiguous, combines >1 game
76 | "GearHead",
77 | "GL-117",
78 | "Kobold's Quest",
79 | "Konquest",
80 | "LBreakout",
81 | "Linley's Dungeon Crawl",
82 | "Liquid War",
83 | "LÖVE",
84 | "Metroidvania",
85 | "Noiz2",
86 | "NScripter",
87 | "OGRE",
88 | "Open Dune",
89 | "RARS",
90 | "Red Eclipse",
91 | "Revenge Of The Cats: Ethernet",
92 | "sfxr",
93 | "Teeworlds",
94 | "The Clans",
95 | "The Mana World",
96 | "Tower defense",
97 | "Transball",
98 | "TuxMath",
99 | "Tux Racer",
100 | "Urho3D",
101 | "Vavoom",
102 | "Volleyball",
103 | "Webhangman",
104 | "XKobo",
105 | "XRay engine",
106 | "Xtank",
107 | }
108 | # Valid clones but we don't want to add it to OSGC unless we really have to
109 | BLACKLIST_CLONES = {
110 | "Colonization too", # halted long ago, status unknown
111 | "CommonDrops", # halted, unknown status
112 | "DOOM-iOS", # Superseded by DOOM-iOS2
113 | "Slot-Racers", # 404, inactive
114 | "Story of a Lost Sky", # halted, unclear how good/playable it is
115 | }
116 |
117 |
118 | def main():
119 | resp = httpx.get("https://raw.githubusercontent.com/Trilarion/opensourcegames/master/inspirations.md")
120 | doc = Document(resp.text)
121 | # Only look at level 2 headings
122 | children = [child for child in doc.children if not isinstance(child, Heading) or child.level == 2]
123 | inspiration = None
124 | osgl_games = {}
125 | for child in children:
126 | if isinstance(child, Heading):
127 | inspiration = INSPIRATION_PATTERN.match(child.children[0].content).group(1)
128 | else:
129 | assert isinstance(child, List)
130 | for subchild in child.children:
131 | text = subchild.children[0].children[0].content
132 | if matches := INSPIRED_PATTERN.match(text):
133 | inspireds = matches.group(1).split(", ")
134 | osgl_games[inspiration] = inspireds
135 | # Find games and clones from OSGC
136 | osgc_originals = set()
137 | for original in originals():
138 | osgc_originals.add(original["name"])
139 | for name in original.get("names", []):
140 | osgc_originals.add(name)
141 | osgc_games = {game["name"] for game in games()}
142 | osgl_inspireds = {
143 | inspired
144 | for inspireds in osgl_games.values()
145 | for inspired in inspireds
146 | }
147 | for game in osgl_games:
148 | if game in BLACKLIST:
149 | continue
150 | # Exclude games that are open source clones to begin with
151 | if game in osgc_games and game not in osgc_originals:
152 | continue
153 | # Exclude transitive inspirations - we only want the originals
154 | if game in osgl_inspireds:
155 | continue
156 | alias = ALIASES.get(game)
157 | if game not in osgc_originals and (not alias or alias not in osgc_originals):
158 | print(f"Missing original: {game}")
159 | for inspired in osgl_inspireds:
160 | if inspired in BLACKLIST_CLONES:
161 | continue
162 | if inspired not in osgc_games:
163 | print(f"Missing clone: {inspired}")
164 |
165 |
166 | if __name__ == "__main__":
167 | main()
168 |
--------------------------------------------------------------------------------
/scripts/top_frameworks.py:
--------------------------------------------------------------------------------
1 | from collections import Counter, defaultdict
2 |
3 | from scripts.utils import games
4 |
5 | import pandas as pd
6 |
7 |
8 | def main():
9 | c = Counter()
10 | framework_langs = defaultdict(Counter)
11 | for game in games():
12 | for framework in game.get("frameworks", []):
13 | c[framework] += 1
14 | for lang in game.get("langs", []):
15 | framework_langs[framework][lang] += 1
16 | most_common = c.most_common(10)
17 | rows = []
18 | for framework, count in most_common:
19 | framework_lang_counts = framework_langs[framework].most_common(5)
20 | row = {"framework": framework, "total": count}
21 | for i, lang in enumerate(framework_lang_counts):
22 | row[f"lang{i+1}"] = lang
23 | rows.append(row)
24 | df = pd.DataFrame(rows)
25 | print(df)
26 |
27 |
28 | if __name__ == "__main__":
29 | main()
30 |
--------------------------------------------------------------------------------
/scripts/update-development-status.py:
--------------------------------------------------------------------------------
1 | """
2 | This script updates games development status
3 |
4 | To run, install from pip:
5 | - pygithub
6 | - python-gitlab
7 |
8 | Add environment variables:
9 | - GH_TOKEN
10 | - https://github.com/settings/tokens?type=beta
11 | - (see https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token#creating-a-token)
12 | - GL_TOKEN
13 | - https://gitlab.com/-/user_settings/personal_access_tokens
14 | - (see https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-personal-access-token)
15 | - With read_api scope
16 | """
17 | import os
18 | import re
19 | from typing import Optional
20 |
21 | import yaml
22 |
23 | import feedparser
24 |
25 | from pathlib import Path
26 | from datetime import datetime, timedelta
27 | from github import Github, GithubException
28 | from gitlab import Gitlab
29 | from time import mktime
30 |
31 | GL_HOST = 'https://gitlab.com'
32 | SF_HOST = 'https://sourceforge.net'
33 |
34 | GH_REGEX = re.compile(r'https://github.com/([^/]+)/([^/]+)')
35 | GL_REGEX = re.compile(GL_HOST + r'/([^/]+/[^/]+)')
36 | SF_REGEX = re.compile(SF_HOST + r"/projects/([^/]+)")
37 |
38 | GH_DT_FMT = "%a, %d %b %Y %H:%M:%S %Z"
39 |
40 |
41 | def main():
42 | gh = Github(os.environ["GH_TOKEN"])
43 | gl = Gitlab(GL_HOST, private_token=os.environ["GL_TOKEN"])
44 |
45 | for filename in Path('games').iterdir():
46 | if not filename.is_file() or filename.suffix != '.yaml':
47 | continue
48 |
49 | games = yaml.safe_load(open(filename, encoding='utf-8'))
50 | for game in games:
51 | if 'added' not in game:
52 | print(f"{game['name']} has no added field")
53 | continue
54 |
55 | repo_url = game.get('repo', '')
56 |
57 | if len(repo_url) == 0 or game.get('development', '') == 'complete':
58 | continue
59 |
60 | if (latest_commit_date := get_latest_commit_date(repo_url, gh, gl)) is None:
61 | continue
62 |
63 | diff = datetime.now() - latest_commit_date
64 |
65 | status_original = game.get("development", "unknown")
66 | if diff < timedelta(weeks=1):
67 | game['development'] = 'very active'
68 | elif diff < timedelta(weeks=4):
69 | game['development'] = 'active'
70 | elif diff < timedelta(days=365):
71 | game['development'] = 'sporadic'
72 | else:
73 | game['development'] = 'halted'
74 | if status_original != game["development"]:
75 | print(f"{game['name']} status should be {game['development']} ({status_original=})")
76 |
77 | # yaml.dump(games, open(filename, 'w', encoding='utf-8'), sort_keys=False)
78 | # print(filename, 'has been updated')
79 |
80 |
81 | def is_github_repo(repo):
82 | return repo.startswith('https://github.')
83 |
84 |
85 | def is_gitlab_repo(repo):
86 | return repo.startswith(GL_HOST)
87 |
88 |
89 | def is_sourceforge_repo(repo):
90 | return repo.startswith(SF_HOST)
91 |
92 |
93 | def get_latest_commit_date(repo_url, gh, gl):
94 | if is_github_repo(repo_url):
95 | return get_latest_commit_date_for_github(gh, repo_url)
96 | elif is_gitlab_repo(repo_url):
97 | return get_latest_commit_date_for_gitlab(gl, repo_url)
98 | elif is_sourceforge_repo(repo_url):
99 | return get_latest_commit_date_for_sourceforge(repo_url)
100 |
101 | print('The', repo_url, 'repository could not be updated')
102 |
103 |
104 | def get_latest_commit_date_for_github(gh, repo_url):
105 | match = re.match(GH_REGEX, repo_url)
106 | if not match:
107 | return
108 |
109 | owner, repo = match.groups()
110 | try:
111 | gh_repo = gh.get_repo(f"{owner}/{repo}")
112 | branches = list(gh_repo.get_branches())
113 | commit_dates = {datetime.strptime(branch.commit.last_modified, GH_DT_FMT) for branch in branches if branch.commit.last_modified}
114 | except GithubException as e:
115 | print(f'Error getting repo info for {owner}/{repo}: {e}')
116 | return
117 | return max(commit_dates) if commit_dates else None
118 |
119 |
120 | def get_latest_commit_date_for_gitlab(gl, repo_url):
121 | match = re.match(GL_REGEX, repo_url)
122 |
123 | if not match:
124 | return
125 |
126 | project_namespace = match.groups()[0]
127 | project = gl.projects.get(project_namespace)
128 |
129 | branches = project.branches.list(get_all=True)
130 | created_dates = {branch.commit["created_at"] for branch in branches}
131 | last_commit = max(created_dates)
132 |
133 | return datetime.strptime(
134 | ''.join(last_commit.rsplit(':', 1)),
135 | '%Y-%m-%dT%H:%M:%S.%f%z'
136 | ).replace(tzinfo=None)
137 |
138 |
139 | def get_latest_commit_date_for_sourceforge(repo_url: str) -> Optional[datetime]:
140 | if not (match := re.match(SF_REGEX, repo_url)):
141 | return
142 |
143 | project_name = match.groups()[0]
144 | feed = feedparser.parse(f"https://sourceforge.net/p/{project_name}/activity/feed.rss")
145 | for entry in feed.entries:
146 | # Only look for commits
147 | if " committed " not in entry["title"]:
148 | continue
149 | return datetime.fromtimestamp(mktime(entry["published_parsed"]))
150 | return None
151 |
152 |
153 | if __name__ == "__main__":
154 | main()
155 |
--------------------------------------------------------------------------------
/scripts/utils.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 | from typing import Iterable
3 |
4 | import yaml
5 |
6 | PROJECT_ROOT_PATH = Path(__file__).parent.parent.resolve()
7 |
8 |
9 | def originals() -> Iterable[dict]:
10 | for p in (PROJECT_ROOT_PATH / "originals").iterdir():
11 | if p.is_file() and p.suffix == ".yaml":
12 | originals = yaml.safe_load(open(p, encoding="utf-8"))
13 | for original in originals:
14 | yield original
15 |
16 |
17 | def games() -> Iterable[dict]:
18 | for p in (PROJECT_ROOT_PATH / "games").iterdir():
19 | if p.is_file() and p.suffix == ".yaml":
20 | games = yaml.safe_load(open(p, encoding="utf-8"))
21 | for game in games:
22 | yield game
23 |
--------------------------------------------------------------------------------
/static/black.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/opengaming/osgameclones/88920b52b93d2af11dcd474b3614c9eecf5df27e/static/black.png
--------------------------------------------------------------------------------
/static/dark-theme.js:
--------------------------------------------------------------------------------
1 | const DARK_THEME_CLASS = 'dark-theme';
2 | const LIGHT_THEME_CLASS = 'light-theme';
3 | const THEME_KEY = 'theme';
4 |
5 | function setDarkTheme() {
6 | document.body.classList.remove(LIGHT_THEME_CLASS);
7 | document.body.classList.add(DARK_THEME_CLASS);
8 | }
9 |
10 | function setLightTheme() {
11 | document.body.classList.remove(DARK_THEME_CLASS);
12 | document.body.classList.add(LIGHT_THEME_CLASS);
13 | }
14 |
15 | function toggleDarkTheme() {
16 | if (document.body.classList.contains(DARK_THEME_CLASS)) {
17 | setLightTheme();
18 | localStorage.setItem(THEME_KEY, 'light')
19 | } else {
20 | setDarkTheme();
21 | localStorage.setItem(THEME_KEY, 'dark')
22 | }
23 | }
24 |
25 | // enable dark theme as soon as possible so first paint is already dark mode
26 | (function () {
27 | window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
28 | if (localStorage.getItem(THEME_KEY) === null) {
29 | if (event.matches) {
30 | setDarkTheme();
31 | } else {
32 | setLightTheme();
33 | }
34 | }
35 | });
36 |
37 | if (localStorage.getItem(THEME_KEY) === 'dark') {
38 | setDarkTheme();
39 | } else if (localStorage.getItem(THEME_KEY) === 'light') {
40 | setLightTheme();
41 | } else if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
42 | setDarkTheme();
43 | } else {
44 | setLightTheme();
45 | }
46 | })();
47 |
48 | // handle theme button label and listener once DOM fully loaded
49 | window.addEventListener('DOMContentLoaded', function () {
50 | const isDarkTheme = document.body.classList.contains(DARK_THEME_CLASS)
51 | document.getElementById('dark-theme-button').addEventListener('click', toggleDarkTheme)
52 | })
53 |
--------------------------------------------------------------------------------
/templates/common.html:
--------------------------------------------------------------------------------
1 | {%- import 'templates/tags.html' as tags -%}
2 |
3 | {%- macro head(title, keywords, description) -%}
4 |
5 |
6 |
7 | {{ title|default('Open Source Game Clones', true) }}
22 |
23 |
24 |
25 |
26 |
27 | {%- endmacro -%}
28 |
29 |
30 | {%- macro footer() -%}
31 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 | {%- endmacro -%}
49 |
50 |
51 | {%- macro nav() -%}
52 |
53 |
54 |
55 |
56 |
57 |
58 | Languages
59 |
60 |
61 | {% for tag, tag_props in site.langs.items() %}
62 | {{ tags.render_tag('langs', tag, tag_props['tag_count']) }}
63 | {% endfor %}
64 |
65 |
67 |
68 |
69 | Genres
70 |
71 |
72 | {% for tag, tag_props in site.genres.items() %}
73 | {{ tags.render_tag('genres', tag, tag_props['tag_count']) }}
74 | {% endfor %}
75 |
76 |
78 |
79 |
80 | Subgenres
81 |
82 |
83 | {% for tag, tag_props in site.subgenres.items() %}
84 | {{ tags.render_tag('subgenres', tag, tag_props['tag_count']) }}
85 | {% endfor %}
86 |
87 |
89 |
90 |
91 | Themes
92 |
93 |
94 | {% for tag, tag_props in site.themes.items() %}
95 | {{ tags.render_tag('themes', tag, tag_props['tag_count']) }}
96 | {% endfor %}
97 |
98 |
100 |
101 |
102 | xxxx/yyyy games
103 |
104 |
105 |
106 |
107 |
110 |
111 | ........
113 |
114 |
116 | {%- endmacro -%}
117 |
--------------------------------------------------------------------------------
/templates/forms/form_group.jinja2:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/templates/forms/page.jinja2:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | {{ name|title }} form
10 |
11 |
12 |
81 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
147 |
148 |
149 |
--------------------------------------------------------------------------------
/templates/forms/static/main.js:
--------------------------------------------------------------------------------
1 | function submitForm() {
2 | var $form = $("form");
3 | if (validate($form)) {
4 | // https://github.com/marioizquierdo/jquery.serializeJSON
5 | var data = $form.serializeJSON({
6 | customTypes: {
7 | csv: function(str) {
8 | if (str === "") {
9 | return null;
10 | }
11 | return $.csv.toArray(str);
12 | },
13 | }
14 | });
15 | // Remove empty nodes
16 | data = trimObject(data);
17 | var dumped = jsyaml.safeDump(data, {
18 | noArrayIndent: true,
19 | });
20 | console.log(dumped);
21 | $('#add-game-yaml-body').val(dumped);
22 | $('#yaml-modal').modal();
23 | return false;
24 | } else {
25 | // Form is invalid; let the browser's built in validation show
26 | return true;
27 | }
28 | }
29 |
30 | function validate($form) {
31 | // Check required for multiple checkboxes
32 | var valid = true;
33 | $form.find('.checkbox-group-required').each(function(i, elem) {
34 | $(elem).find(':checkbox').removeAttr('required');
35 | if ($(elem).find(':checkbox:checked').length === 0) {
36 | // Set one of them to required to use the browser's own validation message
37 | $(elem).find(':checkbox').attr('required', 'required');
38 | valid = false;
39 | }
40 | });
41 | valid = valid && $form.get()[0].checkValidity();
42 | return valid;
43 | }
44 |
45 | function trimObject(o) {
46 | if (typeof o === 'object') {
47 | for (var a in o) {
48 | o[a] = trimObject(o[a]);
49 | if (!o[a] || (o[a].constructor === Object && Object.keys(o[a]).length === 0)) {
50 | delete o[a];
51 | }
52 | }
53 | } else if (Array.isArray(o)) {
54 | o = o.map(function(e) {
55 | return trimObject(e);
56 | });
57 | }
58 | return o;
59 | }
60 |
61 | function copy() {
62 | $("#add-game-yaml-body").select();
63 | document.execCommand("copy");
64 | }
65 |
66 | $("input.tagsinput").each(function() {
67 | $(this).tagsinput({
68 | allowDuplicates: this.hasAttribute("data-allow-duplicates")
69 | });
70 | });
71 |
72 | $("input.datepicker").datepicker({
73 | format: "yyyy-mm-dd",
74 | autoclose: true,
75 | todayBtn: "linked",
76 | todayHighlight: true
77 | });
78 |
--------------------------------------------------------------------------------
/templates/forms/static/tagsinput/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2017 James Nodws
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/templates/forms/static/tagsinput/README.md:
--------------------------------------------------------------------------------
1 | # Bootstrap Tags Input
2 | Bootstrap Tags Input is a jQuery plugin providing a Twitter Bootstrap user interface for managing tags.
3 |
4 |
5 | ## Usage
6 | Examples can be found [here](http://bootstrap-tagsinput.github.io/bootstrap-tagsinput/examples/).
7 |
8 | ## Features
9 | * Objects as tags
10 | * True multi value
11 | * Typeahead
12 | * Modified for Bootstrap 4 Alpha
13 |
14 | ## Unmantained code AS-IS
15 | If you need this plugin please fork and continue development, as I only needed it for a single project and will not continue further maintenance :)
16 |
--------------------------------------------------------------------------------
/templates/forms/static/tagsinput/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "bootstrap4-tagsinput",
3 | "title": "Bootstrap 4 Tagsinput",
4 | "description": "jQuery tags input plugin based on Twitter Bootstrap 4",
5 | "version": "4.1.2",
6 | "repository":
7 | {
8 | "type": "git",
9 | "url": "https://github.com/Nodws/bootstrap4-tagsinput.git"
10 | },
11 | "license": "MIT",
12 | "homepage": "https://github.com/Nodws/bootstrap4-tagsinput"
13 | }
14 |
--------------------------------------------------------------------------------
/templates/forms/static/tagsinput/tagsinput.css:
--------------------------------------------------------------------------------
1 | /*
2 | * bootstrap-tagsinput v0.8.0
3 | *
4 | */
5 |
6 | .bootstrap-tagsinput {
7 | border: 1px solid var(--bs-border-color);
8 | box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
9 | display: inline-block;
10 | padding: 4px 6px;
11 | color: #555;
12 | vertical-align: middle;
13 | border-radius: 4px;
14 | width: 100%;
15 | line-height: 22px;
16 | cursor: text;
17 | }
18 | .bootstrap-tagsinput input {
19 | border: none;
20 | box-shadow: none;
21 | outline: none;
22 | background-color: transparent;
23 | padding: 0 6px;
24 | margin: 0;
25 | width: 100%;
26 | max-width: inherit;
27 | }
28 | .bootstrap-tagsinput.form-control input::-moz-placeholder {
29 | color: #777;
30 | opacity: 1;
31 | }
32 | .bootstrap-tagsinput.form-control input:-ms-input-placeholder {
33 | color: #777;
34 | }
35 | .bootstrap-tagsinput.form-control input::-webkit-input-placeholder {
36 | color: #777;
37 | }
38 | .bootstrap-tagsinput input:focus {
39 | border: none;
40 | box-shadow: none;
41 | }
42 | .bootstrap-tagsinput .badge {
43 | margin: 2px 0;
44 | padding:5px 8px;
45 | }
46 | .bootstrap-tagsinput .badge [data-role="remove"] {
47 | margin-left: 8px;
48 | cursor: pointer;
49 | }
50 | .bootstrap-tagsinput .badge [data-role="remove"]:after {
51 | content: "×";
52 | padding: 0px 4px;
53 | background-color:rgba(0, 0, 0, 0.1);
54 | border-radius:50%;
55 | font-size:13px
56 | }
57 | .bootstrap-tagsinput .badge [data-role="remove"]:hover:after {
58 |
59 | background-color:rgba(0, 0, 0, 0.62);
60 | }
61 | .bootstrap-tagsinput .badge [data-role="remove"]:hover:active {
62 | box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
63 | }
64 |
65 | .tt-menu {
66 | position: absolute;
67 | top: 100%;
68 | left: 0;
69 | z-index: 1000;
70 | display: none;
71 | float: left;
72 | min-width: 160px;
73 | padding: 5px 0;
74 | margin: 2px 0 0;
75 | list-style: none;
76 | font-size: 14px;
77 | background-color: #ffffff;
78 | border: 1px solid #cccccc;
79 | border: 1px solid rgba(0, 0, 0, 0.15);
80 | border-radius: 4px;
81 | -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
82 | box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
83 | background-clip: padding-box;
84 | cursor: pointer;
85 | }
86 |
87 | .tt-suggestion {
88 | display: block;
89 | padding: 3px 20px;
90 | clear: both;
91 | font-weight: normal;
92 | line-height: 1.428571429;
93 | color: #333333;
94 | white-space: nowrap;
95 | }
96 |
97 | .tt-suggestion:hover,
98 | .tt-suggestion:focus {
99 | color: #ffffff;
100 | text-decoration: none;
101 | outline: 0;
102 | background-color: #428bca;
103 | }
104 |
--------------------------------------------------------------------------------
/templates/forms/types/any.jinja2:
--------------------------------------------------------------------------------
1 | {% extends "form_group.jinja2" %}
2 | {% block control %}
3 |
2 |
3 |
4 | {{ contents }}
5 |
6 |
13 | {% for s_value in sequence["enum"] %}
14 |
MAX_CHECKBOXES else "" }}">
15 | {{ s_value }}
23 |
24 | {% endfor %}
25 |
15 | {{ s_value }}
24 |
25 | {% endfor %}
26 | {% else %}
27 |
33 | {% for s_value in schema["enum"] %}
34 |
38 | {{ s_value }}
39 |
40 | {% endfor %}
41 |
42 | {% endif %}
43 | {% else %}
44 |
11 | {{ name }}
12 | {% if first %}
13 | {{ tags.render_tag_groups('genres', game.meta['genres']) }}
14 | {{ tags.render_tag_groups('subgenres', game.meta['subgenres']) }}
15 | {{ tags.render_tag_groups('themes', game.meta['themes']) }}
16 | {% if show_details %}
17 |
21 | {% endmacro %}
22 |
23 | {% macro show_id(name) -%}
24 | {{ name | lower | replace(' ', '-') }}
25 | {%- endmacro %}
26 |
27 | {% macro show_tags(game) -%}
28 | {%- if 'multiplayer' in game %}
29 | {{ game.tags.append('multiplayer') }}
30 | {% endif -%}
31 |
32 | {{ game.tags | join(' ') }}
33 | {%- endmacro %}
34 |
35 | {% macro show_keywords_names(names) -%}
36 | {% for n in names -%}
37 | {% if n is not string -%}
38 | {% for i in n -%}
39 | {{ i | normalize -}}{{ ' ' -}}
40 | {% endfor -%}
41 | {% else -%}
42 | {{ n | normalize -}}
43 | {% endif -%}
44 | {{ ' ' -}}
45 | {% endfor -%}
46 | {%- endmacro %}
47 |
48 | {% macro show_keywords(game, names, meta) -%}
49 | {{ game.name | normalize -}}{{ ' ' -}}
50 | {{ game.tags | join(' ') | normalize -}}{{ ' ' -}}
51 | {{ game.info | normalize -}}{{ ' ' -}}
52 |
53 | {%- if game.new %}
54 | {{ 'new updated added ' -}}
55 | {% endif %}
56 |
57 | {%- if 'multiplayer' in game -%}
58 | {{ 'multiplayer ' }}
59 | {%- endif -%}
60 |
61 | {{ show_keywords_names(names) }}
62 | {{ show_keywords_names(meta.names_ascii) }}
63 | {%- endmacro %}
64 |
65 | {% macro render_clone(names, meta, game, show_details, expand_gallery) %}
66 |
67 | {%- set show_gallery = show_details and ('images' in game or 'video' in game) -%}
68 |
86 | ▶
87 | {%- if 'url' in game -%}
88 | {{ game['name'] }} {{ game['name'] }}
91 | {%- endif %}
92 | {%- if game.new -%}
93 | NEW
94 | {%- elif game.is_updated -%}
95 | UPDATED
96 | {%- endif -%}
97 | {%- if 'feed' in game %}
98 | repo
103 | {%- if 'repoiconname' in game %}
104 |
108 | )
109 | {%- endif %}
110 | {{ tags.render_tag_groups('type', game['type'] | title) if show_details }}
111 | {{ tags.render_tag_groups('status', game['status'] | title) if game['type'] != 'tool' }}
112 | {{ tags.render_tag_groups('development', game['development'] | title) }}
113 | {{ tags.render_tag_groups('langs', game['langs']) }}
114 | {{ tags.render_tag_groups('frameworks', game['frameworks']) if show_details }}
115 | {{ tags.render_tag_groups('content', game['content'] | title) if show_details }}
116 | {{ tags.render_tag_groups('licenses', game['licenses']) }}
117 | {{ tags.render_tag_groups('multiplayer', game['multiplayer']) if 'multiplayer' in game and show_details }}
118 | {% if show_details %}
119 | {{ game['info'] }}
123 | {% endif %}
124 | {% if show_gallery %}
125 |
126 | {% if game['images'] | length > 0 -%}
127 |
130 | {% endif %}
131 |
148 | {% endif %}
149 |
150 |
155 | {% for name in game.names %}
156 | {{ render_name(name, game, loop.index0 == 0, show_details) }}
157 | {% endfor %}
158 |
159 | {% for clone in game.clones %}
160 | {{ render_clone(game.names, game.meta, clone, show_details, show_details) }}
161 | {% endfor %}
162 | {% endmacro %}
163 |
--------------------------------------------------------------------------------
/templates/tags.html:
--------------------------------------------------------------------------------
1 | {% macro render_tag(tag_class, tag_names, tag_props) %}
2 | {%- if tag_names -%}
3 | {%- if tag_names is string -%}
4 | {% set tag_names = [tag_names] %}
5 | {%- endif -%}
6 |
7 | {%- for tag_name in tag_names %}
8 | {%- set className = ["tag", tag_class.lower(), tag_name.lower().replace(' ', '-')] -%}
9 | {%- set dataName = tag_name.lower().replace(' ', '-') -%}
10 |
11 | {{- tag_name -}}
12 | {%- if tag_props -%}{{ tag_props }} {%- endif -%}
13 |
14 | {% endfor -%}
15 | {%- endif -%}
16 | {% endmacro %}
17 |
18 | {% macro render_tag_groups(tag_class, tag_names, tag_props) %}
19 | {%- if tag_names -%}
20 | {%- if tag_names is string -%}
21 | {% set tag_names = [tag_names] %}
22 | {%- endif -%}
23 |
24 | {{ tag_class }}:
25 | {%- for tag_name in tag_names %}
26 | {%- set className = ["tag", tag_class.lower(), tag_name.lower().replace(' ', '-')] -%}
27 | {%- set dataName = tag_name.lower().replace(' ', '-') -%}
28 |
30 | {{- tag_name -}}
31 | {%- if tag_props -%}{{ tag_props }} {%- endif -%}
32 |
33 | {% endfor -%}
34 |
35 | {%- endif -%}
36 | {% endmacro %}
37 |
--------------------------------------------------------------------------------
/templates/video.html:
--------------------------------------------------------------------------------
1 | {% macro render_video(game_name, video_url, img_url) -%}
2 |
7 |
9 | {%- endmacro %}
10 |
11 | {% macro render_youtube(game_name, youtube_id) -%}
12 | {{ render_video(game_name, 'https://www.youtube-nocookie.com/embed/%s?rel=0&showinfo=0' % youtube_id, 'https://img.youtube.com/vi/%s/0.jpg' % youtube_id) }}
13 | {%- endmacro %}
14 |
15 | {% macro render_vimeo(game_name, vimeo_id) -%}
16 | {{ render_video(game_name, 'https://player.vimeo.com/video/%s?title=0&byline=0&portrait=0' % vimeo_id, 'https://vumbnail.com/%s.jpg' % vimeo_id) }}
17 | {%- endmacro %}
18 |
19 | {%- macro render_moddb(game_name, moddb_id) -%}
20 | {{ render_video(game_name, 'https://www.moddb.com/media/iframe/%s' % moddb_id, '/static/black.png') }}
21 | {%- endmacro %}
22 |
23 | {%- macro render_indiedb(game_name, indiedb_id) -%}
24 | {{ render_video(game_name, 'https://www.indiedb.com/media/iframe/%s' % indiedb_id, '/static/black.png') }}
25 | {%- endmacro %}
26 |
--------------------------------------------------------------------------------
/vhost.conf:
--------------------------------------------------------------------------------
1 | server {
2 | listen 80;
3 | server_name osgameclones.com "";
4 | root /www;
5 | index index.html;
6 | }
7 |
--------------------------------------------------------------------------------