Metadata-Version: 2.1
Name: pycge
Version: 0.1.1
Summary: A retro colored game engine for python.
Home-page: https://github.com/havbon/python-colored-game-engine
Author: Håvard Bønes
Author-email: haavard.bones@gmail.com
License: UNKNOWN
Description: # PyCGE
        
        pycge - or python colored game engine - is a 2d game engine made in python.
        
        ## Why pycge?
        
        pycge is a game engine that uses colors and run perfectly in your terminal. This can be used by developers that need a more interactive system. Pycge can also be used as a menu system.
        
        # DOCS
        ## installation
        
        pycge will be available at [pip](https://pip.pypa.io/en/stable/)
        
        # usage
        
        first, let's create an empty game:
        ```
        import pycge.pycge as pcg
        
        dimention = [10, 10]
        
        game = pcg.Game(dimention)
        game.start()
        ```
        feel free to experiment with variables and values.
        
        Now let's add a character.
        This is achieved by adding two things:
        a layer and an actor.
        
        a layer is a plane with the same dimention as the game board, if two actors with hitbox disabled collide on the same layer one will be overwritten, therefore it is important to have every actor that might collide on seperate layers.
        a good layer system would be:
        - background layer (a layer of static actors that you know wont be moved)
        - player layer (a layer with the player which can roam around freely and interact with other actors on different layers)
        - opponent layer (this layer can be used to hold other actors that necessarily wont be controlled by the player)
        
        For now let's just keep it to one layer,
        let's call it the player layer.
        ```
        playerLayer = pcg.Layer(dimention)
        game.addLayer(playerLayer, 5)
        ```
        dimention is the variable we defined above containing the dimentions for the game board.
        
        5 is the index of the layer. A layer with higher index will be prioritized over another layer with lower index. Since we only have one layer this value isn't important for now
        
        
        if you run your pycge game now you wont notice any difference, that's because you can't see empty layers.
        so let's add something to the layer
        let's add a player.
        
        ```
        player = pcg.Actor("blue")
        player.place(4, 5, playerLayer)
        ```
        The first line defines an actor.
        the argument defines the color of the player. Here's a list of valid colors:
        - grey
        - red
        - green
        - yellow
        - blue
        - magenta
        - cyan
        - white
        
        line #2 places the actor on x=4, y=5 and the layer is playerLayer.
        
        If you now run our game you will see our blue player on the screen. But you can't control the player.
        
        So let's map keys to make our player move.
        
        First of all we need two more imports
        ```
        import pycge.key as key
        import pycge.examples as examples
        ```
        
        the top import is a library that handles key structures
        the bottom import contains examples (that is fully replacable) such as a class that moves the character up.
        
        ```
        keyMapping = key.KeyStruct()
        
        keyMapping.add("w", examples.up, player)
        keyMapping.add("a", examples.left, player)
        keyMapping.add("s", examples.down, player)
        keyMapping.add("d", examples.right, player)
        ```
        - the first argument is a str of one letter which is the key activating this function
        - the second argument is a class returning a list of new x and y pos for this function. (if you are going to create your own class you have to have a var called self.val which is a list of two elements; x and y)
        - the third and final argument is deciding what actor it should bind with that key.
        
        We are not done yet.
        All we need to do now is to tell the game to use this structure.
        This is easy, modify the `game.start()` to something like this:
        `game.start(keyMapping)`
        
        That should be it!
        if you have followed the tutorial correctly should have a movable character which you can color and a background you can resize.
        
        full code:
        ```
        import pycge.pycge as pcg
        import pycge.key as key
        import pycge.examples as examples
        
        dimention = [10, 10]
        
        game = pcg.Game(dimention)
        
        playerLayer = pcg.Layer(dimention)
        game.addLayer(playerLayer, 5)
        
        player = pcg.Actor("blue")
        player.place(4, 5, playerLayer)
        
        keyMapping = key.KeyStruct()
        
        keyMapping.add("w", examples.up, player)
        keyMapping.add("a", examples.left, player)
        keyMapping.add("s", examples.down, player)
        keyMapping.add("d", examples.right, player)
        
        game.start(keyMapping)
        ```
        
        ### examples
        
        [racing cars example](https://pastebin.com/De39SY6a)
        
        # LICENSE
        
        remember to read the license:
        "LICENSE"
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Development Status :: 4 - Beta
Requires-Python: >=3.7
Description-Content-Type: text/markdown
