Saravanan666/pypi-org huggingface dataset:
Package: gamedetector
GameDetectorDetect games, get Steam info, profit. This program allows you to select a folder on your system (probably in your game library), that contains a game. It looks in the game folder for files that can identify what game it is, get a SteamAppIdfor said game, and find a reasonable list ofEXEfiles that could possibly be the game executable.The purpose of this application is so that it can be used in a much larger application, an automatic game manager for data hoarders. I'll let you know more about this as I develop it, but believe me, it'll be super rad.DisclaimerDoes not circumvent DRMDoes not encourage the use of pirated softwareUses publicly available APIs provided by Steam or othersMakes a reasonable attempt to respect ratelimitsCaches responses to save bandwidth and API loadDoes not download or upload game data to any serverFeaturesVery fast (reading from compressed archives is limited by 7-zip)Folder support7-zip archive supportGOG game supportSteam game supportDRM-free games supportCompatibilityCurrently, only Windows 10/11 are officially supported, but Debian/Linux support is planned in the future.
The project usespathlibso handling different paths should be trivial, its just not tested.
The only known dependency issue ispywin32, and there's already a stub for the single function using it for Linux systems to continue using the library.InstallingInstallPython 3.10+Clone the repository and install dependency manager (pipenv)gitclonehttps://github.com/Aareon/GameDetectorcdGameDetector
py-mpipinstallpipenv
pipenvinstallAfter installing dependencies, and given that their were no errors in doing so, run the application.cdGameDetector
py./gamedetector/game_detect.pyWhat to expect after running directlyAfter executing the program, you will be prompted to select a folder (game folder). The program will then attempt to detect what game it is based on things like folder name, as well as checking known files that are commonly available in many distributions of games. It will tell you the name of the game detected, the version, the Steam AppId (if available on Steam), as well as a game description.This program isn't super useful to regular users, but it will be extremely handy to have as a library for other applications.Usage as a libraryfrompathlibimportPathfromgamedetector.game_detectimportdetect_folder,detect_7z,NonSteamGame,SteamGame,NoGameException,SteamApiExceptiongame_path=detect_folder(Path("some path to a game"))# will return either NonSteamGame, or SteamGame if AppId is foundgame_7z_path=detect_7z(Path("path to 7z file containing game"))# will return same as aboveReporting bugsPlease seethe Issues page. Please include the full output from the program.LicenseMIT (free as in free beer, free to redistribute with credit, free to use commercially with credit)
Package: game-development
<div align="center">
  <img src="https://github.com/MKM12345/game_development/raw/main/logo.png">
</div>
<a style="display:inline;" href="#"><img src="https://img.shields.io/badge/Python- >= 2.7 -blue?style=plastic.svg" alt="python versions" /></a>
<a style="display:inline;" href="#"><img src="https://img.shields.io/badge/pypi package- 1.0.6 -4DC71F?style=plastic.svg" alt="pypi version" /></a>
<a style="display:inline;" href="#"><img src="https://img.shields.io/badge/first timer-friendly-4DC71F?style=plastic.svg" alt="first timer friendly" /></a>
<a style="display:inline;" href="https://github.com/MKM12345/game_development/labels/game_development-idea"><img src="https://img.shields.io/github/issues-raw/MKM12345/game_development/game_development-idea?color=4DC71F&label=game_development%20ideas" alt "game_development ideas" /></a>
<a style="display:inline;" href="#"><img src="https://img.shields.io/badge/tests- all passing -4DC71F?style=plastic.svg" alt="game_development ideas" /></a>

<h1>game_development v1.0.6</h1>
A game development library for Python with <em>a lot</em> of assorted functions to simplify both 2D and 3D game development tasks in Pygame and Panda3D while combining their power to create awesome games.

### GitHub Page: https://github.com/MKM12345/game_development

## How to install
Install with pip in your terminal, making sure Python is added to PATH:
$ pip install game_development

Alternatively, you can use the git URL to do the same.
$ pip install "git+https://github.com/MKM12345/game_development.git@pip-install#egg=game_development"

### What can it do?
As an open-source library, it offers a wide range of simple functions to make writing game code in both Pygame and Panda3D easier and quicker. A complete list of all game_development functions that are available can be found here.

### Support game_development
game_development is full of contributions from the community! We're beginner-friendly here, so read the contributing guidelines and give us your best game_development functions 😃!

### View the site
Recently, game_development's website launched at https://MKM12345.github.io/game_development-the-site/, feel free to report bugs or give feature requests, using the web-issue label. Or, take a look at the discussion.

### License
game_development is licensed under the MIT LICENSE.
Package: gamee
GameeExperimental Gamee hackA package that allows to score as much as you want in gamee. WARNING: Do not abuse. You might get suspended or permanent ban.Installation:>>>python3-mpipinstallgameeUsage:>>>fromgameeimportGamee>>># score = Gamee.hack(score, time, gameurl)>>>score=Gamee.hack(123,500,https://....)>>>print(score)Warning: do not abuse as you might get banned from gamee.Try to use ginuene time it would take to play in seconds
Package: gamefaqs-py
GameFaqsPY========GameFaqsPY is a python package useful to retrieve and manage game data from the GameFAQS website.  The package is written in pure python and provides the following game information:* Title* Description* Platform* Release Date* Companies* ESRB Rating* Metascore* User Rating (/5)* Difficulty* Length (hr)* Unlockables* Cheat CodesInstallation------------GameFaqsPY is conveniently available via pip:::pip install gamefaqs-pyor installable via ``git clone`` and ``setup.py``::git clone https://github.com/ryantonini/gamefaqs-pysudo python setup.py installThe application now supports database access.  The new access system runs queries with speed and efficiency.  To use the database system, run the following script upon installation:::python /path/to/run_load.pyThe script will create a SQLite database file in the current working directory containing data loaded from http://www.gamefaqs.com/.NOTE: Currently, the database contains minimal game support.  Updates are pending.Usage-----A code example:.. code:: pythonfrom gamefaqs import accessgf_access = access.GameFaqs()first_game = gf_access.search_game("Metal Gear Solid: Peace Walker")[0]first_game.summary()gf_access.update(first_game, info=["general", "rating"])print first_game["esrb"]print first_game["metascore"]first_company = gf_access.search_company("Microsoft")[0]first_company.summary()gf_access.update(first_company)print first_company["name"]print first_company["games"]License-------GNU General Public License Version 3.  See LICENSE for more details.
Package: game-generators
Game GeneratorsGame Generators (gage) is a package for efficiently generating games for research and experimentation. It is loosely based
onGAMUT. Its main features are:Efficiently generate batches of games from a wide range of available game structures that can be used for deep learning purposes.Sample random utility functions of widely used classes, such as concave functions, monotonically increasing/decreasing functions and more.In-depth documentation that provides references to the literature.Extensive test suite to verify the correctness of the generated games.InstallationFor now, Gage is only available for installation from source. To install, clone the repository and pip install the necessary packages.QuickstartTo start generating games, simply import the package and use the game generator that you desire. For example, to generate a batch of 10 Bach-Stravinsky games, use the following code:importgagebatch_size=10payoff_matrices=gage.nfg.bach_stravinsky(batch_size)# Or alternativelypayoff_matrices=gage.generate_game("bach_stravinsky",batch_size)To see all available game generators, see thedocumentationor checkgage.available_games.FormatEvery game is returned with separate payoff tensors per player. For example, when generating a batch of 10 games with 2  players and 3 actions per player, we return a (10, 2, 3, 3) tensor where the first dimension contains the batch, the second dimension contains a payoff tensor for an individual player, and the remainder is the joint action dimension.It is common in game theoretic research to present joint payoff tensors. We provide a function to convert the separate payoff tensors to a joint payoff tensor. This function is calledto_joint_payoffand is available in
theutils.transformsmodule. In the example above, it would return a (10, 3, 3, 2) tensor.ContributingWe are building a suite of game generators that can be used in modern game theoretic research. If you are working in
this area and want to get involved, contributions are very welcome! For major changes, please open an issue first to
discuss what you would like to change.CitationIf you use GAGE in your research, please use the following BibTeX entry:@misc{ropke2023gage,
  author = {Willem Röpke},
  title = {Gage: Game Generators},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/wilrop/mo-game-theory}},
}LicenseThis project is licensed under the terms of the MIT license.
Package: gamegridp
GameGridPGameGridP ist eine in Python programmierte 2D-Grafikengine die für Bildungszwecke gedacht ist.Viele Konzepte wurden vonJGameGrid_
bzw.Greenfootübernommen. Im Gegensatz zu Greenfoot bietet
gamegridp keine grafische Benutzeroberfläche.EigenschaftenGameGridP unterstützt sowohl Pixel-basierte Spiele als auch Spiele mit
quadratischen Zellen (z.B. Rouge-Likes)Einfaches Erstellen von AnimationenMusik und SoundeffekteIntegrierte Konsole für AusgabenEinfaches Erstellen von GUI-Elementen und PopupsEinfache DatenbankanbindungOpen SourceGithub:https://github.com/asbl/gamegridpDokumentation:https://gamegridp.it-teaching.de
Package: gamegym
Game GymA game theory framework providing a collection of games, common API and a several game-theoretic algorithms.The goal of the projectis to provide tools for buildng complex games (e.g. board games, with partial information or simultaneous moves), computation of approximate strateges and creating artificial intelligence for such games, and to be a base for robust value learning experiments.Under active development, looking for ideas and contributors!OverviewAlgorithms:Outcome sampling MCCFR Nash equilibrium computationExact best response and exploitabilityApproximate best response and exploitablitySparse SGD value learning (with values linear in known features)Plotting strategy development (see plots forMatching Pennies,Rock-Paper-Scissors,Goofspiel(4))Games:General matrix games (normal form games), Rock-paper-scissors, Matching pennies, Prisoner's dilemma, ...Goofspiel (GOPS)One-card poker, Dice-pokerGame interfaceFor an exploration of API in Rust, seeGTCogs.To implement game you define one class derived fromgamegym.Gamewith the following interface:classMyRockPaperScissor(PartialInformationGame):ACTIONS=("rock","paper","scissors")def__init__(self):# Set thenumber of players and all game actionssuper().__init__(2,self.ACTIONS)definitial_state(self)->StateInfo:# Return node information, here player 0 is active and has all actions.# Note that in this simple game we do not use any game state.returnStateInfo.new_player(state=None,player=0,actions=self.ACTIONS)defupdate_state(self,situation:Situation,action)->StateInfo:# Return the node information after playing `action` in `situation`.iflen(situation.history)==0:returnStateInfo.new_player(state=None,player=1,actions=self.ACTIONS)p1payoff=1.0# TODO: compute from `situation`, e.g. from `situation.history`returnStateInfo.new_terminal(state=None,payoff=(x,-x))# Create game instancegame=MyRockPaperScissor()# Initial situations1=game.start()# Play some actionss2=game.play(s1,"rock")s3=s2.play("paper")# alias for game.play(s2, "paper")# See game resultasserts3.is_terminal()asserts3.payoff==(-1.0,1.0)The available base classes arePerfectInformationGameandPartialInformationGame(with specialised subclassesObservationSequenceGame,SimultaneousGameandMatrixGame- which would be a better fit for Rock-Paper-Scissors).The main auxiliary structs common to all games areStateInfothat contains the information
about the game node itself, andSituationwhich additionally contains game history,
accumulated payoffs, the game itself etc.Game stateis any structure the game uses to keep track of the actual game state, e.g. cards in all hands, game board state, map, ... This is not generally visible to players in partial information game, anyobservationsare passed withobservations=(p0_obs, p1_obs, public_obs)toStateInfo.
Package: game-hero
Game HeroThe project developed covers a story game based on turn based combat, where the game hero encounters a wild beast in the forest. Game character's stats are taken into consideration on each turn, whilst the game herop also possesses some additional skills to help him in battle.The storyOnce upon a time there was a great hero, called Orderus, with some strengths and weaknesses, as all heroes have.
After battling all kinds of monsters for more than a hundred years, Orderus now has the following stats:Health: 70 - 100Strength: 70 - 80Defence: 45 â€“ 55Speed: 40 â€“ 50Luck: 10% - 30% (0% means no luck, 100% lucky all the time).Also, he possesses 2 skills:Rapid strike: Strike twice while itâ€™s his turn to attack; thereâ€™s a 10% chance heâ€™ll use this skill every time he attacksMagic shield: Takes only half of the usual damage when an enemy attacks; thereâ€™s a 20% change heâ€™ll use this skill every time he defends.GameplayAs Orderus walks the ever-green forests of the Game, he encounters some wild beasts, with the
following properties:Health: 60 - 90Strength: 60 - 90Defence: 40 â€“ 60Speed: 40 â€“ 60Luck: 25% - 40%The game simulates a battle between Orderus and a wild beast. On every battle, Orderus and the beast are initialized with random properties, within their ranges.The first attack is done by the player with the higher speed. If both players have the same speed, than the attack is carried on by the player with the highest luck.
After an attack, the players switch roles: the attacker now defends and the defender now attacks.The damage done by the attacker is calculated with the following formula:
~Damage = Attacker strength â€“ Defender defenceThe damage is subtracted from the defenderâ€™s health. An attacker can miss their hit and do no  damage if the defender gets lucky that turn.  Orderusâ€™ skills occur randomly, based on their chance on each turn.Game overThe game ends when one of the players remain without health or the number of turns reaches 20.
The application outputs the results for each turn: what happened, which skills were used (if any), the damage done, defenderâ€™s health left.
Additionally, a winner may be declared if we have a winner before the maximum number of rounds is reached.
Package: gameit
Getting Started with PygamerPygamer is an opinionated way to build with Pygame that makes developers' lives easier and building games more fun!Pygamer makes developing python games withPygamequick, modular, maintainable, and scalable. You can load a game window in a matter of seconds, build a simple game in a matter of minutes, and then spend as much time as you want to scale your game as far as you like. And it will be easily maintainable, debuggable, and variable. This is due to the central ideas behind the Pygamer system for Pygame.Centrals ideas behind PygamerAll Games have objects, players, and menusAll objects react to events in specific ways (handlers)All games and objects need to update and draw on each framePlayers need to have their own objects that are coupled to their player instanceMenus should not affect gameplay until active, at which point they should immediately take over the game loopThe current running Game or Menu should receive and delegate all events to the proper handlersStart a game with PygamerCheck out ourexamplesfor an introduction on how to create games.
Package: gamejoltapi
Game Jolt API for PythonThis module is a single threaded Python wrapper for theGame Jolt APIrunning through HTTP requests.
It contains all Game Jolt API endpoints and aims to simplify its use where it's possible.InstallingThis module is available on thePython Package Index.
To install it on your Python distribution, simply run on the console:pipinstallgamejoltapiOr if you want to download it manually, just download the latestgamejoltapi.pyfrom the source code repository.See the reference documentation here
Package: gamelib
gamelibThis is a library I've been working on for writing 3d applications in python. You'll need to know at least a little bit about writing shaders in glsl to be effective with this library, though I do plan to include default implementations in the future.PrerequisitesThis package requires support for OpenGL 3.3 or later and currently supports python >= 3.8.
If building from source some compiler will be required dependent on your platform.InstallationOptionally create a virtual environment:Linux:python3-mvenvvenv
.venv/bin/activateWindows:python3 -m venv venv
venv\Scripts\activateInstall with pip:pipinstallgamelibUsageDetailed usage documentation can be found in the modules themselves, to get started you should import gamelib and init must be called before doing anything involving the window or OpenGL context, so it's recommended to call at the entry point to your application.importgamelibgamelib.init()Update should be called on a loop to not hang the application.whilegamelib.is_running():gamelib.update()To avoid hanging the main loop while executing a long running task, you can use the internal schedules.defmy_long_running_function():time.sleep(1)gamelib.threaded_schedule.once(my_long_running_function,-1)As mentioned above, see the modules for further documentation, or refer to example applications linked below.Running the test suiteTo run the tests you'll first need to get the source and install both the requirements and requirements-dev dependencies.gitclonehttps://github.com/peffjepin/gamelib.gitcdgamelib
python3-mpipinstall-rrequirements-dev.txt
python3-mpipinstall-rrequirements.txtThen to run the tests simply:pytestFor testing against different python versions you can run tox. The tox environment is set up to skip tests that require an opengl context.toxFor a coverage report:pytest--cov=gamelib--cov-report=htmlExample Applicationsgamelib-chess
Package: gamelibgames
-= Languages =-EnglishEspañolHello!This repository is meant to be used to develop simple games on theGameliblibrary (byDiego Essaya).
As such, don't expect anything great. It's certainly a great way to kill off some time, though.The games currently developing[Nothing yet, I'm afraid!]The games already completedOr the ones that already are in the stage of v1.0.0 release or up.Picross - v1.1.0PlayingLosingCreating New GameMinesweeper - v1.0.0PlayingMines ExplodingStarting AnewHola!Este repositorio está pensado para utilizarse para el desarrollo de juegos simples haciendo uso de la libreríaGamelib(porDiego Essaya).
Por lo tanto, no esperes nada muy complejo. Aunque es una manera magnífica de matar el tiempo.Los juegos actualmente en desarrollo[¡Aún nada, me temo!]Los juegos ya completadosO aquellos que ya estén en fase v1.0.0 o superior.Picross (Nonograma) - v1.1.0JugandoPerdiendoCreando Nueva PartidaMinesweeper (Buscaminas) - v1.0.0JugandoMinas ExplotandoEmpezando de Nuevo
Package: game-machine
# Game MachineGame Machine is a sprite based 2D game development tool that wraps PyGame. It
is part of This Machine Kills Zombies, a project developing coding tutorials
aimed at Keystage 3/4 pupils (age 11 - 14).Game Machine is intended to create a very low learning barrier to getting
working games. It is not intened as a replacement for PyGame.Game Machine is currently very much in development, and is likely to undergo
significant changes to how it works. There is currently no public documentation
or API. It is not currently recommended to be
used other than by those involved in the This Machine Kills Zombies Project.The stable release will be 1.0 and above, and an API will be published with
the stable release.
Package: gameoflifeemulator
The Game of life EmulatorThe Game of Life, also known simply as Life, is a cellular automaton devised by the British
mathematician John Horton Conway in 1970. It is a zero-player game, meaning that
its evolution is determined by its initial state, requiring no further input.
One interacts with the Game of Life by creating an initial configuration
and observing how it evolves. It is Turing complete and can simulate
a universal constructor or any other Turing machine.More information on wikipedia:https://en.wikipedia.org/wiki/Conway%27s_Game_of_LifeThis emulator is created by parsa shahmaleki.
(c) 2020 parsa shahmalekiparsampsh@gmail.comLicensed Under GPL-v3Cli Usage:
python3 -m gameoflife --option1=value --option2=value ...Code Usage:
gol = GameOfLife(option1=value, option2=value...)
gol.start()Options:
you can customize the emulator using this options`width`         width of the world. default: width of the terminal
`height`        hegith of the world. default: height of the terminal
`live_char`     symbol of the live cell. default: `+`
`dead_char`     symbol of the dead cell. default: ` `
`sleep_time`    sleep time between world frames(secounds). default: `0.05`
`border_char`   the world border chars. default: `#`
`title`         a title of the head of the world. default: `Conway's Game of life`
`random_har`    how much initialized live cells. every more means harder. default: `3`Cli Example:
gameoflife --width=100 --height=40 --live_char='@' --sleep_time=0.2 --title='my gameoflife'Code Example:
GameOfLife(width=100, live_char='@' sleep_time=0.2, title="something").start()
Package: gameoflife-lam
project-python
Project 1 - Game of lifeGame of life is a cellular automaton devised by John Conway in 70's:http://en.wikipedia.org/wiki/Conway's_Game_of_LifeThe game consists of two dimensional orthogonal grid of cells. Cells are in two possible states, alive or dead. Each cell interacts with its eight neighbours, and at each time step the following transitions occur:Any live cell with fewer than two live neighbours dies, as if caused by underpopulation
Any live cell with more than three live neighbours dies, as if by overcrowding
Any live cell with two or three live neighbours lives on to the next generation
Any dead cell with exactly three live neighbours becomes a live cell
The initial pattern constitutes the seed of the system, and the system is left to evolve according to rules. Deaths and births happen simultaneously.In a git repository implement the Game of Life using Numpy. Try first 32x32 square grid and cross-shaped initial pattern:Try also other grids and initial patterns (e.g. random pattern). Try to avoid for loops. For visualization you ca use Matplotlib: import matplotlib.pyplot as plt plt.imshow(array)Make a pip package out of it including dependencies. Add CI using Travis, testing installation from pip and running one game of 1000 iterations checking that it matches a pre known pattern.
Package: game-of-life-MUGOH
game-of-lifeGame of lifeimplementation in the python standard library and numpySetup1. Install the PackageClonegit clone https://github.com/hogum/game-of-lifeInstallpython3 setup.py install2. Install using pippip install game-of-life-MUGOH==0.0.11TestingRunpytestPlaying the Gameexample

from game_of_life import play

if __name__ == '__main__':
    play()