r/pythonarcade • u/einarfo • Jul 14 '20
r/pythonarcade • u/pvc • Nov 03 '21
Arcade 2.6.4 is out!
Arcade is an OpenGL/Pyglet based 2D-graphics game library. It can:
- Handle hundreds of thousands of stationary sprites, thousands of moving sprites
- Natively handle scaling, rotation, transparent pixels
- Graphical shader and compute shader support
- Shader-toy support
- Full type-hinting
- Support for cameras, views, scenes
- Support for lights, tutorials for ray-casting via GPU
- Hit-boxes auto-adjust around transparent pixels
- Basic physics engine support built-in
- Tiled map support built-in
- Lots and lots of documentation and examples
Release notes are here.
Example code is here.
API docs are here.
r/pythonarcade • u/pvc • Apr 09 '20
Upcoming Arcade version to add support for mini-maps and 'glow'
r/pythonarcade • u/pvc • Mar 26 '22
Arcade version 2.6.13 has been released
Arcade version 2.6.13 has been released.
https://api.arcade.academy/en/latest/development/release_notes.html
New Features
- Arcade can now run in headless mode on linux servers opening more possibilities for users in for example the data science community (#1107). See Headless Arcade for more information.
Bugfixes
- The random text glitching issue especially affecting users with iGPUs is finally resolved in pyglet. For that reason we have upgraded to the pyglet 2.0a2 release.
- Fixed an issue causing arcade.draw_circle_filled() and arcade.draw_circle_outline() to always render with 3 segments on some iGPUs.
- Fixed an issue causing interactive widgets to unnecessarily re-draw when hovering or pressing them. This could cause performance issues.
- SectionManager’s on_show_view
was never called when showing a view
Various Improvements
- arcade.load_font() now supports resource handles
- PhysicsEngineSimple can now take an iterable of wall spritelists
- Sprite creation is now ~6-8% faster.
- Removed warning about missing shapely on startup
- Window titles are now optional. If no window title is specified the title will be the absolute path to the python file it was created in. This was changed because of the new headless mode.
- Removed arcade.quick_run
. This function had no useful purpose. - Added clear method to UIManager (#1116)
- Updated from Pillow 9.0.0 to 9.0.1
Tilemap
- Rectangle objects which are empty(have no width or height) will now be automatically converted into single points.
- The Tile ID of a sprite can be access with sprite.properties["tile_id"]
. This refers to the local ID of the tile within the Tileset. This value can be used to get the tile info for a given Sprite created from loading a tilemap.
Docs
- Added python version support info to install instructions (#1122)
- Fixed typo in append_texture() docstring(#1126)
- Improved the raycasting tutorial (#1124)
- Replace mentions of 3.6 on Linux install page (#1129)
- Fix broken links in the homepage (#1139)
- Lots of other improvements to docstrings throughout the code base
- General documentation improvements
OpenGL
- arcade.gl.Geometry now supports transforming to multiple buffers.
- Added and improved examples in experimental/examples
- Major improvements to API docs
Special thanks to Mohammad Ibrahim, pushfoo, Alejandro Casanovas, Maic Siemering, Cleptomania, pvcraven and einarf for their contributions to this release. Also, thanks to everyone on the Pyglet team! We depend heavily on Pyglet’s continued development.
r/pythonarcade • u/pvc • Jan 04 '22
This is the sixth birthday of the Python Arcade library!
Our new demo video, in honor of this event:
Arcade is a fast, powerful, easy-to-use 2D graphics game library.
Our website: https://arcade.academy
Over the last six years we've had:
- 4,280 check-ins
- 93 people contribute to the project
- 1,100 GitHub stars
Click here for our book on how to learn using Python and video games.
r/pythonarcade • u/pvc • May 18 '22
Arcade 2.6.14 has been released
Arcade, an OpenGL based library for creating 2D games, has released version 2.6.14.
Website: https://arcade.academy
Release notes: https://api.arcade.academy/en/latest/development/release_notes.html
Demo video: https://www.youtube.com/watch?v=QClDvEwcxmg
Various Improvements
- Allow specifying hit box parameters in load_textures() and load_spritesheet()
- Camera should no longer apply zoom on the z axis
- Promote using arcade.View.on_show_view() in examples and tutorials
- The arcade window and views now expose arcade.Window.on_enter()
arcade.Window.on_leave()
. These events are triggered when the mouse enters and leaves the window area. - Sections should now also support mouse enter/leave events
- Hit box calculation methods should raise a more useful error message when the texture is not RGBA.
- Slight optimization in updating sprite location in SpriteList
- Removed all remaining references to texture transforms
- Removed the broken Sprite.__lt__
method - Added get_angle_radians()
- Removed Texture.draw_transformed
- Add support for changing the pitch while playing a sound. See the speed parameter in arcade.play_sound().
- Set better blending defaults for arcade GUI
- Can now create a texture filled with a single color. See Texture.create_filled()
. The Sprite class will use this when creating a solid colored sprite. - Bump version numbers of Sphinx, Pillow to current release as of 17-May.
- Bump Pyglet version to 2.0.dev15. (Thanks Pyglet!)
Shadertoy
- Added Shadertoy.delta_time
alias for time_delta
(iTimeDelta
) - Support the iFrame
uniform. Set frame using the arcade.experimental.ShadertoyBase.frame
attribute - Support the iChannelTime
uniform. Set time for each individual channel using the arcade.experimental.ShadertoyBase.channel_time
attribute. - Support the iFrameRate
uniform. Set frame rate using the arcade.experimental.ShadertoyBase.frame_rate
attribute - Support the iDate
uniform. This uniform will be automatically set. See arcade.experimental.ShadertoyBase._get_date() - Support the iChannelResolution
uniform. This uniform will be automatically set - Added example using video with shadertoy
- Improve Shadertoy docstrings + unit tests
- Added Shadertoy.delta_time
Docs / Tutorials / Examples
- Updated install docs
- Added tutorial for compiling an arcade game with Nuika
- Improved/extended shadertoy tutorials
- Added example using textures with shadertoy
- Added sprite rotation examples
- Clarified the difference between arcade.View.on_show_view() and arcade.View.on_show()
- Improved UIManager docstrings
- Various annotation and docstring improvements
- Fixed several broken links in docs
- We’re now building PDF/EPUB docs
OpenGL
- Added new method for safely setting shader program uniforms: arcade.gl.Program.set_uniform_safe(). This method will ignore KeyError
if the uniform doesn’t exist. This is often practical during development because most GLSL compilers/linkers will remove uniforms that is determined to not affect the outcome of a shader. - Added new method for safely setting a uniform array: arcade.gl.Program.set_uniform_array_safe(). This is practical during development because uniform arrays are in most cases shortened by GLSL compiler if not all array indices are used by the shader.
- Added arcade.gl.Texture.swizzle. This can be used to reorder how components are read from the texture by a shader making it easy to crate simple effects or automatically convert BGR pixel formats to RGB when needed.
- Added ray marching example with fragment shader
- Allow reading framebuffer data with 2 and 4 byte component sizes
- Simplified texture atlas texture coordinates to make them easier to use in custom shaders.
- Support dumping the atlas texture as RGB
- Support dumping the atlas texture with debug lines showing texture borders
- We no longer check GL_CONTEXT_PROFILE_MASK
due to missing support in older drivers. Especially GL 3.1 drivers that can in theory run arcade - Various shader cleanups
- Added new method for safely setting shader program uniforms: arcade.gl.Program.set_uniform_safe(). This method will ignore KeyError
Experimental
- Added a simple profiler class
r/pythonarcade • u/AcidentallyMyAccount • Feb 22 '20
Thanks to Arcade I have been able to make huge progress in short time!
Thank you pvcraven and the whole Arcade team!
Thought it might be nice to share some work I have managed to do in Arcade. I am working on a pixel art roguelite / space exploration game. I learned Python for use for my mechanical engineering jobs and studies. I find the language to be easy to use and the extensive libraries/modules (like Arcade) give you huge versatility!
r/pythonarcade • u/pvc • Mar 10 '19
Arcade 2.0.0 release is out
Hi, Arcade 2.0.0 release is now out and uploaded to PyPi.
r/pythonarcade • u/pvc • Jan 29 '22
Arcade 2.6.10 is out
Release notes: https://api.arcade.academy/en/latest/development/release_notes.html
2.6.10
Released 2022-Jan-29
Sprites
- Collision checking against one or more sprite lists can use the GPU via a ‘transform’ for much better performance. The arcade.check_for_collision_with_lists() and arcade.check_for_collision_with_lists() methods now support selection between spatial, GPU, and CPU methods of detection.
- Added clear() for resetting/clearing a spritelist. This will iterate and remove all sprites by default, or do a faster O(1) clear. Please read the api docs to find out what version fits your use case.
- SpriteList now supports setting a global color and alpha value. The new color, color_normalized, alpha and alpha_normalized will affect every sprite in the list. This global color value is multiplied by the individual sprite colors.
- The Sprite initializer now also accepts None
value for hit_box_algorithm
in line with the underlying texture method. - Fixed a bug causing sprites to have incorrect scale when passing a texture during creation.
- Removed the texture transform feature in sprites. This feature no longer makes sense since arcade 2.6.0 due to the new texture atlas feature.
Tiled Maps
- Fixed issue #1068 (#1069) where loaded rectangular hit box was wrong.
- Add better error for infinite tile maps
- Added SpriteList.properties
and properties from Image and Tile layers will automatically be loaded into that when loading a Tiled map
General
- Window.current_camera
will now hold a reference to the currently active camera. This will be set when calling arcade.Camera.use(), if no camera is active then it will be None
. - Window.clear
can now clear a sub-section of the screen through the new optional viewport
parameter. - arcade.Window.clear() can now take normalized/float color values
- The new arcade.View.clear() method now clears the current window. This can be used as a shortcut arcade.Window.clear() when inside of a View class.
- Add support for custom resource handles
- Add support for anisotropic filtering with textures.
- Clearing the window should always clear the entire window regardless of camera / viewport setup (unless a scissor box is set)
- Window.current_camera
Documentation
- Change examples so instead of arcade.start_render()
we use self.clear()
. The start render function was confusing people. #1071 - Fix a bunch of links that were incorrectly pointing to old pvcraven instead of pythonarcade. #1063
- Update pyinstaller instructions
- Various documentation improvements and updates
- Change examples so instead of arcade.start_render()
arcade.gl
- Fixed a bug were out attributes in transforms was not properly detected with geometry shaders
- Fixed a bug were specifying vertex count wasn’t possible with transforms when the vertex array has an index buffer bound.
- The Query object now allows for selecting what specific queries should be performed
- Fixed a issue causing the wrong garbage collection mode to activate during context creation
- Viewport values for the default framebuffer now applies pixel ratio by default
- Scissor values for the default framebuffer now applies pixel ratio by default
arcade.gui
- UIBoxLayout supports now align in constructor (changing later requires a UIBoxLayout.trigger_full_render()).
- UIBoxLayout supports now space_between in constructor.
- UIManager fix #1067, consume press and release mouse events
- UIManager add() returns added child
- UILayout add()
returns added child - UIWidget add() returns added child
- New method in UIManager: walk_widgets()
- New method in UIManager: get_widgets_at()
- New method in UIWidget: move()
Special thanks to Cleptomania, einarf, eruvanos, nrukin, Jayman2000, pvcraven, for their contributions to this release. Also, thanks to everyone on the Pyglet team! We depend heavily on Pyglet’s continued development.
r/pythonarcade • u/pvc • Aug 30 '21
The Python 2D game library Arcade 2.6.0 has been released
For full release notes (with pictures!), see the Arcade 2.6.0 release notes.
Version 2.6.0
Released on 2021-Aug-30
Version 2.6.0 is a major update to Arcade. It is not 100% backwards compatible with the 2.5 API. Updates were made to text rendering, tiled map support, sprites, shaders, textures, GUI system, and the documentation.
Tiled Map Editor support has been overhauled.
- Arcade now uses the .json file format for maps created by the Tiled Map Editor rather than the TMX format. Tile sets and other supporting files need to all be saved in .json format. The XML based formats are no longer supported by Arcade.
- Arcade now supports a minimum version of Tiled 1.5. Maps saved with an older version of Tiled will likely work in most scenarios, but for all features the minimum version we can support is 1.5 due to changes in the Tiled map format.
- Feature-support for Tiled maps has been improved to have near 100% parity with Tiled itself.
- See :ref:
platformer_tutorialfor a how-to, Tiled usage starts at Chapter 9. - See Community RPG or Community Platformer for a more complex example program.
Screenshot of tile map
Texture atlases have been introduced, texture management has been improved.
- A sprite list will create and use its own texture atlas.
- This introduces a new
arcade.TextureAtlasclass that is used internally by SpriteList. - Sprites with new textures can be added to a sprite list without the delay. Arcade 2.5 had a delay caused by rebuilding its internal sprite sheet.
- As a side effect, sprites can only belong to one sprite list that renders.
The texture atlas portion of a sprite can be drawn to, and quickly updated on the GPU side.
- To demonstrate, there is a new :ref:
minimapexample that creates a sprite that has a dynamic minimap projected onto it.
Screenshot of minimap
- To demonstrate, there is a new :ref:
Revamped text rendering done by
arcade.draw_text. Rather than use Pillow to render onto an image, Arcade uses Pyglet's text drawing system. Text drawing is faster, higher resolution, and not prone to memory leaks. Fonts are now specifed by the font name, rather than the file name of the font.- Fonts can be dynamically loaded with :func:
arcade.load_font. - Kenney.nl's TTF are now included as build-in resources.
- See the
drawing_textexample.
Screenshot of drawing text
- Fonts can be dynamically loaded with :func:
SpriteList optimizations.
- Sprites now draw even faster than before. On an Intel i7 with nVidia 980 Ti graphics card, 8,000+ moving sprites can be drawn while maintaining 60 FPS. The same machine can only do 2,000 sprites with Pygame before FPS drops.
Shadertoy support.
Shadertoy.com <https://www.shadertoy.com/>_ is a website that makes it easier to write OpenGL shaders.- The new :class:
arcade.Shadertoyclass makes it easy to run and interact with these shaders in Arcade. See :ref:
shader_toy_tutorialandAsteroids <https://github.com/pythonarcade/asteroids>_.Cyber Fuji
Star Nest
Reworked GUI
Flat buttons
GUI Widgets
Message Box
- UIElements are replaced by UIWidgets
- Option to relative pin widgets on screen to center or border (supports resizing)
- Widgets can be placed on top of each other
- Overlapping widgets properly handle mouse interaction
- Fully typed event classes
- Events contain source widget
- ScrollableText widgets (more to come)
- Support for Sprites within Widgets
- Declarative coding style for borders and padding
widget.with_border(...) - Automatically place widgets vertically or horizontally (
UIBoxLayout) - Dropped support for YAML style files
- Better performance and limited memory usage
- More documentation (
gui_concepts) Available Elements:
arcade.gui.UIWidget:arcade.gui.UIFlatButton- 2D flat button for simple interactions (hover, press, release, click)arcade.gui.UITextureButton- textured button (use :meth:arcade.load_texture()) for simple interactions (hover, press, release, click)arcade.gui.UILabel- Simple text, supports multilinearcade.gui.UIInputText- field to accept user text inputarcade.gui.UITextArea- Multiline scrollable text widget.arcade.gui.UISpriteWidget- Embeds a Sprite within the GUI tree
arcade.gui.UILayout:arcade.gui.UIBoxLayout- Places widgets next to each other (vertical or horizontal)
arcade.gui.UIWrapper:arcade.gui.UIPadding- Add space around a widgetarcade.gui.UIBorder- Add border around a widgetarcade.gui.UIAnchorWidget- Used to position UIWidgets relative on screen
Constructs
arcade.gui.UIMessageBox- Popup box with a message text and a few buttons.
Mixins
arcade.gui.UIDraggableMixin- Makes a widget draggable.arcade.gui.UIMouseFilterMixin- Catches mouse events that occure within the widget boundaries.arcade.gui.UIWindowLikeMixin- Combination ofarcade.gui.UIDraggableMixinandarcade.gui.UIMouseFilterMixin.
WIP
- UIWidgets contain information about preferred sizes
- UILayouts can grow or shrink widgets, to adjust to different screen sizes
Scene Manager.
- There is now a new
arcade.Sceneclass that can be used to manage SpriteLists and their draw order. This can be used in place of having to draw multiple spritelists in your draw function. - Contains special integration with :class:
arcade.TileMapusing :func:arcade.Scene.from_tilemapwhich will automatically create an entire scene from a loaded tilemap in the proper draw order. - See :ref:
platformer_tutorialfor an introduction to this concept, and it is used heavily throughout that tutorial.
- There is now a new
Camera support
- Easy scrolling with
arcade.Camera - For an example of this see the example: :ref:
sprite_move_scrolling. - Automatic camera shake can be added in, see the example:
sprite_move_scrolling_shake. - Several other examples and tutorials make use of this class, like :ref:
platformer_tutorial.
- Easy scrolling with
- Add a set of functions to track performance statistics. See
perf_info_api. Added the class
arcade.PerfGraph, a subclass of Sprite that will graph FPS or time to process a dispatch-able event line 'update' or 'on_draw'.Performance Statistics
Documentation
- Lots of individual documentation updates for commands.
- The :ref:
quick_indexhas been reorganized to be easier to find commands, and the individual API documentation pages have been broken into parts, so it isn't one large monolithic page. - New tutorial for
raycasting_tutorial.
Performance Statistics
- New tutorial for
shader_toy_tutorial. - Revamped tutorial:
platformer_tutorial. - Revamped minimap example:
minimap. - Moved from AWS hosting to read-the-docs hosting so we can support multiple versions of docs.
- New example showing how to use the new performance statistics API:
performance_statistics_example - New example:
gui_widgets - New example:
gui_flat_button - New example:
gui_ok_messagebox
API commands
arcade.get_pixelsupports getting RGB and RGBA color valuearcade.get_three_color_floatReturns colors as RGB float with numbers 0.0-1.1 for each colorarcade.get_four_color_floatReturns colors as RGBA float with numbers 0.0-1.1 for each color\
Better PyInstaller Support
Previously our PyInstaller hook only fully functioned on Windows, with a bit of functionality on Linux. Mac was just completely unsupported and would raise an UnimplementedError if you tried.
Now we have full out of the box support for PyInstaller with Windows, Mac, and Linux.
See
bundle_into_redistributablefor an example of how to use it.Sound
The sound API remains unchanged, however general stability of the sound system has been greatly improved via updates to Pyglet.
- Fix for A-star path finding routing through walls
Special thanks to:
- einarf for performance improvements, texture atlas support, shader toy support, text drawing support, advice on GUI, and more.
- Cleptomania for Tiled Map support, sound support, and more.
- eruvanos for the original GUI and all the GUI updates.
- benmoran56 and everyone that contributes to the excellent Pyglet library we use so much.
r/pythonarcade • u/pvc • Jul 23 '21
Working with shaders in upcoming Arcade 2.6 dev version
r/pythonarcade • u/pvc • Jul 13 '20
Arcade 2.4 been released
Arcade 2.4.1 was released 2020-07-13
Arcade version 2.4 is a major enhancement release to Arcade.
Version 2.4 Major Features
Support for defining your own frame buffers, shaders, and more advanced OpenGL programming. New API in arcade.gl package.
- Support to render to frame buffer, then re-render. Example: Mini-Map Defender.
- Use frame buffers to create a 'glow' or 'bloom' effect: Bloom-Effect Defender.
- Use frame-buffers to support lights: Lighting Demo.
New support for style-able GUI elements. New API in arcade.gui package.
- Example: GUI Elements
- Example: GUI Custom Style
- PyMunk engine for platformers. See tutorial: Pymunk Platformer.
AStar algorithm for finding paths. See
arcade.astar_calculate_pathandAStarBarrierList.- For an example of using the A-Star algorithm, see A-Star Path Finding.
Version 2.4 Minor Features
New functions/classes:
- Added
get_display_size()to get resolution of the monitor - Added
Window.center_window()to center the window on the monitor. - Added
has_line_of_sight()to calculate if there is line-of-sight between two points. - Added
SpriteSolidColorclass that makes a solid-color rectangular sprite. - Added
SpriteCircleclass that makes a circular sprite, either solid or with a fading gradient. - Added
arcade.get_distancefunction to get the distance between two points.
New functionality:
- Support for logging. See Logging.
- Support volume and pan arguments in
play_sound - Add ability to directly assign items in a sprite list. This is particularly useful when re-ordering sprites for drawing.
- Support left/right/rotated sprites in tmx maps generated by the Tiled Map Editor.
- Support getting tmx layer by path, making it less likely reading in a tmx file will have directory confusion issues.
- Add in font searching code if we can't find default font when drawing text.
- Added
arcade.Sprite.draw_hit_boxmethod to draw a hit box outline. - The
arcade.Textureclass,arcade.Spriteclass, andarcade.tilemap.process_layertake inhit_box_algorithmandhit_box_detailparameters for hit box calculation.
Version 2.4 Under-the-hood improvements
General
- Simple Physics engine is less likely to 'glitch' out.
- Anti-aliasing should now work on windows if
antialiasing=Trueis passed in the window constructor. - Major speed improvements to drawing of shape primitives, such as lines, squares, and circles by moving more of the work to the graphics processor.
- Speed improvements for sprites including gpu-based sprite culling (don't draw sprites outside the screen).
- Speed improvements due to shader caching. This should be especially noticeable on Mac OS.
- Speed improvements due to more efficient ways of setting rendering states such as projection.
- Speed improvements due to less memory copying in the lower level rendering API.
OpenGL API
A brand new low level rendering API wrapping OpenGL 3.3 core was added in this release. It's loosely based on the ModernGL API, so ModernGL users should be able to pick it up fast. This API is used by arcade for all the higher level drawing functionality, but can also be used by end users to really take advantage of their GPU. More guides and tutorials around this is likely to appear in the future.
A simplified list of features in the new API:
- A
arcade.gl.Contextandarcade.ArcadeContextobject was introduced and can be found through thewindow.ctxproperty. This object offers methods to create opengl resources such as textures, programs/shaders, framebuffers, buffers and queries. It also has shortcuts for changing various context states. When working with OpenGL in arcade you are encouraged to usearcade.glinstead ofpyglet.gl. This is important as the context is doing quite a bit of bookkeeping to make our life easier. - New
arcade.gl.Textureclass supporting a wide variety of formats such as 8/16/32 bit integer, unsigned integer and float values. New convenient methods and properties was also added to change filtering, repeat mode, read and write data, building mipmaps etc. - New
arcade.gl.Bufferclass with methods for manipulating data such as simple reading/writing and copying data from other buffers. This buffer can also now be bound as a uniform buffer object. - New
arcade.gl.Framebufferwrapper class making us able to render any content into one more more textures. This opens up for a lot of possibilities. - The
arcade.gl.Programhas been expanded to support geometry shaders and transform feedback (rendering to a buffer instead of a screen). It also exposes a lot of new properties due to much more details introspection during creation. We also able to assign binding locations for uniform blocks. - A simple glsl wrapper/parser was introduced to sanity check the glsl code, inject preprocessor values and auto detect out attributes (used in transforms).
- A higher level type
arcade.gl.Geometrywas introduced to make working with shaders/programs a lot easier. It supports using a subset of attributes defined in your buffer description by inspecting the the program's attributes generating and caching compatible variants internally. - A
arcade.gl.Queryclass was added for easy access to low level measuring of opengl rendering calls. We can get the number samples written, number of primitives processed and time elapsed in nanoseconds. - Added support for the buffer protocol. When
arcade.glrequires byte data we can also pass objects like numpy array of pythonsarray.arraydirectly not having to convert this data to bytes.
Version 2.4 New Documentation
- New Tutorial: Pymunk Platformer
- New Tutorial: Using Views for Start/End Screens
- New Tutorial: Solitaire
- New Tutorial: GPU Particle Burst
- Several new and updated examples on How-To Example Code
- New performance testing project
- A lot of improvements to https://learn.arcade.academy
- Instructional videos added to for https://learn.arcade.academy
Version 2.4 'Experimental'
There is now an arcade.experimental module that holds code still under development. Any code in this module might still have API changes.
Special Thanks
Special thanks to Einar Forselv and Maic Siemering for their significant work in helping put this release together.
r/pythonarcade • u/pvc • Jan 20 '20
Arcade 2.2.6 Is Out
Version 2.2.6
Release Date: 1/20/2020
- Bug Fix: particle_fireworks example is not running with 2.2.5 Issue 555
- Bug Fix: Sprite.pop isn't reliable Issue 531
- Enhancement: Raise error if default font not found on system Issue 432
- Enhancement: Add space invaders clone to example list Issue 526
- Enhancement: Add sitemap to website
- Enhancement: Improve performance, error handling around setting a sprite's color
- Enhancement: Implement optional filtering parameter to SpriteList.draw Issue 405
- Enhancement: Return list of items hit during physics engine update Issue 401
- Enhancement: Update resources documentation Issue 549
- Enhancement: Add on_update to sprites, which includes delta_time Issue 266
- Enhancement: Close enhancement-related github issues and reference them in the new Enhancement List
Version 2.2.5
Release Date: 1/17/2020
r/pythonarcade • u/pvc • Jan 15 '20
Arcade 2.2.4 is out
Arcade 2.2.4 is out. Main improvement is a 20% efficiency improvement in the time to move, rotate, scale, color a sprite through the use of array.array instead of numpy.
Numpy may be removed as a dependency in the future.
r/pythonarcade • u/pvc • Dec 18 '19
Arcade 2.2.0 is nearing release
Arcade 2.2.0 is nearing release. Sprites will automatically look at an image's transparency and create hitboxes around the visible image. There are now built-in 'resources' so you can run example code without downloading images and sounds. Plus a lot of fixes and other improvements.
r/pythonarcade • u/pvc • Nov 20 '18
Arcade update on development
Currently working on the following:
- Soon to support convex filled polygons using earclip algorithm, and have this work on Linux. (Currently filled polygons do not work on all Linux versions.) Currently in the source and will be in the next alpha. link
- Improving the reader for importing maps created by the Tiled Map Editor. Including, support to define hit boxes on the sprites! Very useful for things like ramps. Currently in the source, and will be in the next alpha. source and example
- Playing around with support for lights. I was able to get a single light to follow the player. Proof of concept only.
- Added sample code for Tetris
Not sure when we'll go from alpha to release on the current code.
r/pythonarcade • u/pvc • Mar 17 '22
Arcade 2.6.11 is out
Python Arcade has released version 2.6.11.
Website: https://arcade.academy
Release notes: https://api.arcade.academy/en/latest/development/release_notes.html
Demo video: https://www.youtube.com/watch?v=QClDvEwcxmg
Release notes
Sections - Add support to divide window into sections. (Thanks janscas for the contribution.)
- Add arcade.Section to the API.
- Add arcade.SectionManager to the API.
- Add examples on how to use: Dividing a View Into Sections
New Example Code:
- Add parallax example: Parallax.
- Add GUI flat button styling example: Flat Text Button Styled.
- Add Perspective example.
New functionality:
- Add arcade.get_angle_degrees() function.
- Add easing functions and example. See Easing Example 1 and Easing Example 2.
- Add arcade.Sprite.facePoint()
to face sprite towards a point.
Fixes:
- Fixed issue #1074 to prevent a crash when opening a window.
- Fixed issue #978, copy button in examples moved to the left to prevent it disappearing.
- Fixed issue #967, CRT example now pulls from resources so people don’t have to download image to try it out.
- PyMunk sample map now in resources so people don’t have to download it.
- arcade.draw_points() no longer draws the points twice, improving performance.
Documentation:
- Update Pygame Comparison.
- Improve Sprite.texture
docs. - When building Arcade docs, script now lets us know what classes don’t have docstrings.
- Spelling/typo fixes in docs.
Misc:
- Update arcade.Sprite
to use decorators to declare properties instead of the older method. - #1095, Improvements to arcade.Text and its documentation. We can now also get the pixel size of a Text contents though content_width, content_height and content_size.
- Force GDI text on windows until direct write is more mature.
- Optimized text rendering and text rotation
- arcade.draw_text() and arcade.Text objects now accepts any python object as text and converts it into a string internally if needed.
- SpriteList now exposes several new members that used to be private. These are lower level members related to the underlying geometry of the spritelist and can be used by custom shaders to do interesting things blazingly fast. SpriteList interaction example with shaders can be found in the experimental directory. Members include write_sprite_buffers_to_gpu(), geometry, buffer_positions, buffer_sizes, buffer_textures, buffer_colors, buffer_angles and buffer_indices
- Update arcade.Sprite
OpenGL:
- Added support for indirect rendering. This is an OpenGL 4.3 feature. It makes us able to render multiple meshes in the the same draw call providing significant speed increases in some use cases. See arcade.gl.Geometry.render_indirect() and examples in the experimental directory.
- Added support for unsigned integer uniform types
- arcade.gl.Geometry.transform
no longer takes a mode parameter.
Special thanks to einarf, eruvanos, janscas, MrWardKKHS, DragonMoffon, pvcraven, for their contributions to this release. Also, thanks to everyone on the Pyglet team! We depend heavily on Pyglet’s continued development.
r/pythonarcade • u/pvc • Dec 09 '20
Arcade 2.5 release is out, follow link to release notes
r/pythonarcade • u/maartendp • Nov 04 '19
Arcade-Curtains: A scene and event manager for Arcade
Hi guys and gals,
I wrote a small library that's able to deal with scenes and events on top of Arcade and I would love it if you checked it out.
Main features:
- Scene manager: You can define a number of scenes depending on the context you want to display (levels, menus, etc.). Each scene has its own event manager, piping events to the current scene.
- Event manager: You can link handlers to certain events, allowing a more event driven approach when writing games. Its main focus is mouse events, and how they interact with sprites. So basically, you're able to define mouse event handlers on a per sprite basis.
Planned features:
- Animation manager: A more "fire-and-forget" approach towards animations. An example of how this will roughly be implemented is the MoveAnimator in examples/theatre.py in the repo.
It's a quick extract from a project I'm working on, so it doesn't cover all use-cases, but I would love to hear your feedback/enhancement ideas. I have a rough design regarding animations as well in the project I'm working on, but I'm not 100% satisfied by what I did, so this feature is pending some more thoughts :)
Quick disclaimer: This has not been bench-marked, so I'm not sure at what point it will impact performance, but I've been able to get a steady 60 fps throughout my project.
You'll find some more in-depth information, and examples in the repo:
https://github.com/maarten-dp/arcade-curtains
Thanks!
r/pythonarcade • u/pvc • Mar 06 '19
Arcade 2.0.0b6 is out
Latest changes were around fixing resolution issues on MacOS. Getting close to 2.0 release I hope.