Coder Social home page Coder Social logo

tuxemon's Introduction

Tuxemon

Tuxemon is a free, open source monster-fighting RPG. It's in constant development and improving all the time! Contributors of all skill and level are welcome to join.

Build Status Documentation Status

screenshot

Features

  • Game data is all json, easy to modify and extend
  • Game maps are created using the Tiled Map Editor
  • Simple game script to write the story
  • Dialogs, interactions on map, npc scripting
  • Localized in several languages
  • Seamless keyboard, mouse, and gamepad input
  • Animated maps
  • Lots of documentation
  • Python code can be modified without a compiler
  • CLI interface for live game debugging
  • Runs on Windows, Linux, OS X, and some support on Android
  • 183 monsters with sprites
  • 98 techniques to use in battle
  • 221 NPC sprites
  • 18 items

Installation

If you want to try the game, it's recommended to download and try the development branch first. The master branch should be stable, but is often out of date.

Windows Source

Requires Python 3.9+ and git.

Install the latest version of Python 3 from here and the latest version of Git from here

Run:

git clone https://github.com/Tuxemon/Tuxemon.git
cd Tuxemon
py -3 -m pip install -U -r requirements.txt
py -3 run_tuxemon.py

Windows Binary

NOTICE: Windows binaries currently do not work (see #1229)

In the meantime please use the windows source instructions above to run Tuxemon directly from source.

Flatpak

Check the web page for a complete explanation.

Before installing Tuxemon, make sure you have all the Flatpak requirements installed.

Command line install:

flatpak install flathub org.tuxemon.Tuxemon
flatpak run org.tuxemon.Tuxemon

Using Discover (Graphical Software Manager)

  1. Install Discover using your system's package manager.
  2. Once installed, open Discover and search for 'Tuxemon', select the Tuxemon entry and press install.

Flatpak Nightly Builds

  1. Download Tuxemon.flatpak file from the Release Latest Build (Development) Section.
  2. Using your terminal, navigate to the directory where the Tuxemon.flatpak file was downloaded to.
  3. Run the following commands:
flatpak install Tuxemon.flatpak

flatpak run org.tuxemon.Tuxemon

Depending on your desktop environment, you may also be able to launch via your start menu.

Debian/Ubuntu with virtual environment

This is the recommended way to run because it will not modify the system.

sudo apt install git python3-venv
git clone https://github.com/Tuxemon/Tuxemon.git
python3 -m venv venv
source venv/bin/activate
cd Tuxemon
python3 -m pip install -U -r requirements.txt
python3 run_tuxemon.py

Debian/Ubuntu

Not recommended because it will change system-installed packages

sudo apt install python3 python3-pygame python3-pip python3-imaging git
git clone https://github.com/Tuxemon/Tuxemon.git
cd Tuxemon
sudo pip3 install -U -r requirements.txt
python3 run_tuxemon.py

Debian/Ubuntu optional rumble support

sudo apt install build-essential
git clone https://github.com/zear/libShake.git
cd libShake/
make BACKEND=LINUX; sudo make install BACKEND=LINUX

Fedora Linux

sudo dnf install SDL*-devel freetype-devel libjpeg-devel portmidi-devel python3-devel virtualenv venv
git clone https://github.com/Tuxemon/Tuxemon.git
python3 -m venv venv
source venv/bin/activate
cd Tuxemon
python3 -m pip install -U -r requirements.txt
python3 run_tuxemon.py

Arch Linux

An AUR package is availible however manual installation is reccomended.

sudo pacman -S python python-pip python-pillow python-pygame python-pydantic git
git clone https://github.com/Tuxemon/Tuxemon.git
cd Tuxemon
python -m pip install -U -r requirements.txt
python run_tuxemon.py

Smartphones

Android builds are highly experimental. You will have to build Tuxemon yourself using the script located in the buildconfig folder. After this you will need to manually install the mods folder via the following instructions. Connect your device to your computer and make a folder called "Tuxemon" in "Internal Storage", then copy the mods folder. Tuxemon will also need file system permissions, which you can set in your phones settings.

Caveat Emptor

Mac OS X (Yosemite)

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew tap Homebrew/python
brew update
brew install python
brew install sdl sdl_image sdl_ttf portmidi git
brew install sdl_mixer --with-libvorbis
sudo pip install git+https://github.com/pygame/pygame.git
sudo pip install -U -r requirements.txt
git clone https://github.com/Tuxemon/Tuxemon.git
ulimit -n 10000; python run_tuxemon.py

Controls

Game Controls
You can also set inputs in the options menu or config file
  • Arrow Keys - Movement
  • Enter - Select/activate
  • ESC - Menu/Cancel
  • Shift - Sprint
Debugging

You can enable dev_tools by changing dev_tools to True in the tuxemon.cfg file:

[game]
dev_tools = True

These keyboard shortcuts are available with dev tools enabled

  • r - Reload the map tiles
  • n - No clip
Map Editor

Use Tiled map editor: https://www.mapeditor.org/

CLI Interface

The CLI interface is a very convenient way to debug and develop your maps. After you enable the CLI interface, you can use the terminal to enter commands. You could, for example, give your self potions to battle, or add a monster directly to your party. It's also possible to change game variables directly. In fact, any action or condition that is usable in the map can be used with the CLI interface.

Setting up

You can enable cli by changing cli_enabled to True in the tuxemon.cfg file:

[game]
cli_enabled = True

Commands

  • help [command_name] — Lists all commands, or specific information on a command.
  • action <action_name> [params] — Execute EventAction. Uses same syntax as the map script.
  • test <condition_name> [params] — Test EventCondition. Uses same systax as the map script.
  • random_encounter — Sets you in a wild tuxemon battle, similar to walking in tall grass.
  • trainer_battle <npc_slug> — Sets you in a trainer battle with specified npc.
  • quit — Quits the game.
  • whereami — Prints out the map filename
  • shell — Starts the Python shell, that you can use to modify the game directly. For advanced users.

CLI Examples

Get Commands

> help
Available Options
=================
action  help  quit  random_encounter  shell  test  trainer_battle  whereami

Enter 'help [command]' for more info.

Get help on an action

> help action teleport

    Teleport the player to a particular map and tile coordinates.

    Script usage:
        .. code-block::

            teleport <map_name>,<x>,<y>

    Script parameters:
        map_name: Name of the map to teleport to.
        x: X coordinate of the map to teleport to.
        y: Y coordinate of the map to teleport to.

Test and give an item

> test has_item player,potion
False
> action add_item potion,1
> test has_item player,potion
True

NOTE! The CLI interface is new and the error messages are not very helpful. In general, you should be using the commands when the game is playing, and you are on the world map.

Check out the scripting reference for all the available actions and conditions for use with action and test!

Building

There are many scripts for various builds in the buildconfig folder. These are meant to be run from the project root directory, for example, to build the portable pypy build:

[user@localhost Tuxemon]$ buildconfig/build_pypy_portable_linux.sh

There will be a new directory called build, which will have the package if everything was successful.

WARNING! The build scripts are designed to be run in a dedicated VM. They will add and remove packages and could leave your OS in a bad state. You should not use them on your personal computer. Use in a vm or container.

License

With the exception of the lib folder which may have its own license, all code in this project is licenced under the GPLv3.

GPL v3+

Copyright (C) 2014-2024 William Edwards [email protected], Benjamin Bean [email protected]

This software is distributed under the GNU General Public Licence as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. See the file LICENSE for the conditions under which this software is made available. Tuxemon also contains code from other sources.

External links

tuxemon's People

Contributors

airon90 avatar andymender avatar bitcraft avatar ceo-of-insecurity avatar chillycider avatar clonewayx avatar dtdannen avatar dulsi avatar freshreplicant avatar grimmys avatar hugopghost avatar jaskrendix avatar kerizane avatar magmaus3 avatar mirceakitsune avatar murmele avatar neonflames avatar novialriptide avatar pastaq avatar presstabstart avatar qiangong2 avatar rubberduck9999 avatar sandythelizard avatar sanglorian avatar shadowapex avatar superman2k5 avatar treetrnk avatar vnmabus avatar weblate avatar xirsoi avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

tuxemon's Issues

Game crashes on Startup

Ran the game from command-line, got this:

D:\Games\Tuxemon>tuxemon.exe
D:\Games\Tuxemon\tuxemon.cfg
2015-11-04 15:27:26,828 - core.components.plugin - DEBUG - Plugin folder: D:/Gam
es/Tuxemon/core/components/event/conditions
Traceback (most recent call last):
File "C:\Python27\lib\site-packages\cx_Freeze\initscripts\Console.py", line 27
, in
File "tuxemon.py", line 49, in
File "C:\Users\William\git\Tuxemon\tuxemon\core\main.py", line 53, in main
File "C:\Users\William\git\Tuxemon\tuxemon\core\tools.py", line 134, in init
__
File "C:\Users\William\git\Tuxemon\tuxemon\core\components\event__init
.py",
line 63, in init
File "C:\Users\William\git\Tuxemon\tuxemon\core\components\plugin.py", line 11
7, in load_directory
File "C:\Users\William\git\Tuxemon\tuxemon\core\components\plugin.py", line 75
, in collectPlugins
UnboundLocalError: local variable 'module_path' referenced before assignment
Exception TypeError: "'NoneType' object is not callable" in <function _removeHan
dlerRef at 0x0240ABB0> ignored

Event System should use "Condition" and "Action" objects instead of lists.

Right now all actions and conditions are passed as a simple list with the condition/action's parameters. This unfortunately makes it a little hard to read when looking at an event function.

Here's an example of the way actions are currently passed:

Current System

def transition_teleport(self, game, action):
    parameters = action[1].split(",")
    mapname = parameters[0]
    position_x = parameters[1]
    position_y = parameters[2]
    transition_time = parameters[3]

A better way to handle this would be to create Action and Condition objects that will automatically split up our parameters and provide a simple and easy way to access them.

Better System

def transition_teleport(self, game, action):
    mapname = action.params[0]
    position_x = action.params[1]
    position_y = action.params[2]
    transition_time = action.params[3]

Implement variability in creature catching system.

Currently when using a capture device, the capture rate is 100% (including on non-random battles). The creature catching system should have some variability so there is a chance that catching a creature will fail, or, in the case of fighting another NPC, creature catching will always fail.

Reusable state transition animations

How do you all feel about being able to reuse state transitions? I'm thinking a few basic types plus complex ones would reduce complexity. Instead of coding them in the state, you would push a transition onto the state stack along with the next state:

Control.push_state("FADE_OUT_TRANSITION", duration=2.0, color=(0,0,0))
Control.push_state("START")
Control.push_state("FADE_IN_TRANSITION", duration=2.0, color=(0,0,0))

States already have a reference to the Control, so they could push the transitions themselves if that is wanted.

Testing

How is Tuxemon tested? Are there unit tests, or some sort of integration test suite?

Implement Battle Animations

We need to implement the following battle animations:

  • Technique animations
  • Monster hit animations
  • Monster attack animations

Memory use

I'd like to talk about Tuxemon and memory use here, if anyone is interested in discussing it. I've worked on another pygame collab project called "Py Roller's Casino", and that project used the same state framework (its often mentioned on reddit). I'm going to keep the details out of it, but I worked hard to clean up that project because it used way too much memory. While I cannot say conclusively now, I wonder if the Tuxemon dev team wanted to consider making changes to lower memory use? Is it an issue? I realize some people don't care about how much memory is used, so I'm fine if the devs are fine with it as-is.

Anyway, in general, the aforementioned game template uses a lot of memory in the following ways:

  • loading all images, sounds, etc at startup (as opposed to when needed)
  • loading all game states at startup, never releasing them
  • making a spider-web of references to game objects...making it impossible to GC things

I could be getting ahead of myself here....if it has been fixed here, then just close the issue. In the pyroller project, I overhauled the state system so that states are loaded on-demand, and any game objects, etc can be safely GC'd. I also helped develop a state 'plugin' system, so states can be added or removed without modifying code. Just drop in the .py file. There is still the issue of images, sounds, etc residing in memory, but that can be addressed later.

Here's a link to the project I mentioned:
https://github.com/iminurnamez/pyroller

on startup: UnboundLocalError: local variable 'module_path' referenced before assignment

When trying to start tuxemon with the latest git-version this happens:

Traceback (most recent call last):
  File "./tuxemon.py", line 64, in <module>
    main()
  File "/usr/share/Tuxemon/core/main.py", line 45, in main
    control = PygameControl(prepare.ORIGINAL_CAPTION)
  File "/usr/share/Tuxemon/core/control.py", line 81, in __init__
    self.event_engine = event.EventEngine()
  File "/usr/share/Tuxemon/core/components/event/__init__.py", line 54, in __init__
    condition_plugins = plugin.load_directory(prepare.BASEDIR + "core/components/event/conditions")
  File "/usr/share/Tuxemon/core/components/plugin.py", line 117, in load_directory
    manager.collectPlugins()
  File "/usr/share/Tuxemon/core/components/plugin.py", line 75, in collectPlugins
    logger.debug("Module path: " + module_path)
UnboundLocalError: local variable 'module_path' referenced before assignment
root /usr/share/Tuxemon #  python --version
Python 3.5.1
root /usr/share/Tuxemon #  uname -a
Linux archlinux 4.2.5-1-ARCH #1 SMP PREEMPT Tue Oct 27 08:13:28 CET 2015 x86_64 GNU/Linux

Implement Creature Storage System

We need a system that will store creatures when the player's party limit has been reached. The system should also allow the player to deposit and withdraw existing creatures.

[GCW0] Networking does not work on the GCW-Zero

Currently Tuxemon depends on the netifaces library in order to discover the local IP address for hosting a multiplayer game. Since this library is not a pure python implementation, work needs to be done to cross-compile the library for the GCW0's MIPS cpu. Currently changes are in place to disable networking if the netifaces library is unavailable.

In order to resolve this issue, we'll need to do one of the following:

  • Create a procedure to cross-compile netifaces for MIPS for the GCW0 build of Tuxemon.
  • Write a pure-python implementation of netifaces functionality that is compatible with all platforms.

Implement customizable NPCs

Right now all character sprites are static graphics with no real ability to customize your character or other NPCs. To better create a unique main character as well as a diverse number of NPCs, we should implement a way to customize sprites via a system of overlaying clothes and accessories onto a set of template characters.

To do this, we could use a set of template characters, such as Calis' template below, and have sets of animated clothing/accessories that we will draw over the template sprites:

Here is an example using this same concept applied by makrohn's Universal LPC Spritesheet:

Create a "dialog_chain" action.

Right now chaining dialogs is not easy to use. We should create a dialog chain event that lets you easily create multiple dialogs in a row.

Add Tuxemon to F-Droid

F-Droid is an installable catalogue of FOSS (Free and Open Source Software) applications for the Android platform.
AFAIK Tuxemon is released under GPL3 so it is candidate to be added on F-Droid database.
You can follow the instructions on how to submit your app here.
If #67 is approved you should edit README.md in order to add the following code in the section "Smartphone" with the correct Tuxemon ID on F-Droid database

[![Get it on F-Droid](https://guardianproject.info/wp-content/uploads/2014/07/logo-fdroid.png)](https://f-droid.org/repository/browse/?fdid=AddHereTuxemonID)

Implement language files for all in-game text

Currently all in-game menus and text are hard-coded in English. This can make it hard to implemented non-English translations of the game. To remedy this, a language file system should be implemented to make it easier for non-English translations of the game.

Concurrently running States

As multiplayer/networking was broken with the new state system, I'd like to open discussion for running concurrently operating states. This would allow for multiplayer to work, and could help simplify menus and such, if that is going to be addressed in the future.

This isn't a regression into the old way of everything running at once, but it will allow for situations where things could run concurrently. Here's my idea, please fill in comments about API names and such:

  • The state at the top of the stack receives input from the player
  • States that are still running in the background can be updated and/or rendered, but get no input
  • States will have an attribute that lets them know if they are in focus or not
  • Rendering will occur from end of the stack to the front, so that they are layered in a natural way

I'd also like to propose changing the following methods' signatures in the State from:

def update(screen, keys, current_time, time_delta):
    ...

def draw():
   ...

to the following:

def update(keys, time_delta):
    ...

def draw(surface):
   ...

Rationale being that it is better to separate draws and updates at the API level. Current time is rarely used and doesn't need to be passed each time. This will also simplify drawing for multiple concurrent states. The keys argument should stay as it would be a big change, as opposed to incremental. Eventually though, it would be nice to move into it's own method (imo).

Thoughts?

Won't run on Ubuntu 15.04

I installed both .deb packages and got this:
liam@liam-mate:~$ tuxemon
/usr/games/tuxemon: line 2: cd: /usr/share/tuxemon: Permission denied
python: can't open file 'tuxemon.py': [Errno 2] No such file or directory

I went to the folder, and it didn't give me permissions, it only gave "colord" permissions.

Simplification of screen areas

I've noticed a trend for code like this:

monster_menu = MonsterMenu(game)
monster_menu.size_x = 200
monster_menu.size_y = 100
monster_menu.pos_x = 500
monster_menu.pos_y = 500

This is the exact format for pygame Rects. I feel that it would greatly simplify defining areas of the screen by using Rects as it is more compact and gives useful functions, like quickly finding the center point, checking overlapping areas, ect.

monster_menu = MonsterMenu(game)
monster_menu.rect = Rect(500, 500, 200, 100)

I'd like to convert over this type of code to Rects as I come about it, unless anyone objects.

Conditional collision zones

Currently you can block areas off completely or not at all. I am working making enter and exit properties for collision zones so that you can specify that a tile is blocked unless entering from one or more directions, or exiting from one or more directions. So you could set a tile as a collision field, and then give it the property "enter" with the value "up left". That then would allow entry to the tile from above and left. This will make it possible to implement the ability to jump over ledges with the properties enter: up and exit: down if it is a south-facing ledge.

Implement map pre-loading for non-transition maps.

Currently all maps are loaded on-demand, meaning they will be loaded from disk every time a teleport to a new map occurs. This causes a jarring stutter when switching between maps without a transition, which is needed to tie multiple maps together to give the illusion of a single cohesive world.

To resolve this issue, we should pre-load all maps from "teleport" events asynchronously from disk so we can simply switch to them when a teleport occurs. In addition, we should keep a "previous" and "next" map loaded, to make it seamless to switch back and forth between two maps.

Screen Scaling

Wow, prepare.SCALE.

In general, I think its pretty annoying to deal with screen scaling and I'd like to open a discussion on how to simplify everything.

I have a couple ideas how to handle this. Generally, when I want that retro pixelated look, I will render/draw everything to a tiny surface, then scale up the surface to the screen size each update. Benefits are that one pixel is one pixel, no need to multiply surface sizes, sprites, etc by the scaling factor.

With Tuxemon, there is a hybrid approach: most elements on the screen are chunky pixels, but the map and sprite animations live in native pixel resolution. Its actually a neat approach and looks great, although purists may not like it (look at shovel knight, for instance).

Anyway, here are a couple suggestions that I have. Eventually, I'd love to make drawing less cumbersome by removing all the manual scaling going on.

Draw everything, map, ui, etc to small surface., then scale it to screen res
  • Most simple for programmers
  • Less smooth movement/animation than using native resolution
  • All loaded images are loaded at small native (gameboy?) resolution
  • Overall, highest memory savings
  • Noticeable performance improvements on all systems
Scale UI elements, draw map at native resolution
  • Overall, less memory consumed
  • Could give small boost in performance
  • Easier to code for. Just code in coordinates native to each state.
Make some transform functions that will scale, position, etc automatically
  • No remarkable difference in performance or memory use
  • Somewhat easier for developer to use

On some platforms where performance is an issue, the first approach may make it faster, since the scaling operation will update the entire screen and scale at once, essentially a scale + blit with quick C code. The first two options will be easier to implement after the state refactor, since I've decoupled drawing from updating, and that i'm removing references to the screen where possible.

Anyway, just food for thought.

Tuxemon have the same hp when created regardless of level

It looks like on monster creation hp is not affected regardless of level. So if you set a monsters base hp to 50, and then generate a random battle with that monster at level 30 and then at level 4 they will both only have 50 hp. I noticed that there is an hp_modifier attribute in the json db files though. Is there already a plan for how it will be implemented, or was it just put in there to return to at some point in the future? I'd be happy to implement it, I just want to make sure I'm doing it in the way that was intended.

Implement Smarter Combat AI

Right now we have a basic AI that just selects the first technique its active creature has. We need to create various levels of AI that make better decisions.

Error on startup

Game crash at startup running on Debian (Jessie 8.2) and Python 2.7.9.

I got the following message:
Traceback (most recent call last):
File "tuxemon.py", line 49, in
main()
File "/home/tomas/tuxemonTest/Tuxemon-master/tuxemon/core/main.py", line 56, in main
"WORLD": world.World(run_it),
File "/home/tomas/tuxemonTest/Tuxemon-master/tuxemon/core/states/world.py", line 101, in init
self.current_map.loadfile(self.tile_size)
File "/home/tomas/tuxemonTest/Tuxemon-master/tuxemon/core/components/map.py", line 308, in loadfile
for x in range(0, self.data.width):
TypeError: range() integer end argument expected, got float.

When changing row 309 to "for x in range(0, int(self.data.width)):" I got a similar error but for row 312
When changing row 312 to "for y in range(0, int(self.data.height)):" , it works

Implement template system for events.

Right now there are manual checks being done on a few events that let you use game variables in your events. One such example is with the dialog action:

dialog ${{name}}: Hey there!

We should implement a lightweight template system or use an existing template system like jinja2 or mako. Doing this will make the event system much more powerful and allow map creators to do stuff like use conditional statements and have access to game variables like the player's inventory, party count, etc.

Implement Functional Saving/Loading

Right now there is some basic functionality in place for saving, but not for loading. We need to ensure we save all needed variables and write a system to load those variables from a save file.

Implement a submenu and visual animation when sorting monsters.

Currently manual sorting can be done, but there is no submenu or visual indication of how to sort your monsters. We should include a submenu when clicking on a Tuxemon out of combat that allows you to sort, as well as an animation to show which monster is selected to move.

[Android] Networking does not work on Android

Currently Tuxemon depends on the netifaces library in order to discover the local IP address for hosting a multiplayer game. Since this library is not a pure python implementation, work needs to be done to cross-compile the library for the Android's ARM cpu. Currently changes are in place to disable networking if the netifaces library is unavailable.

In order to resolve this issue, we'll need to do one of the following:

  • Create a procedure to cross-compile netifaces for ARM for the Android builds of Tuxemon.
  • Write a pure-python implementation of netifaces functionality that is compatible with all platforms.

Implement creature breeding/fusion system

The preliminary graphical code has been implemented in core.components.fusion, but we will need to add this as a game mechanic. Players will be able to breed two creatures together that will create a new creature with sprite parts, stats, types, and moves from its parents.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.