Kivy Blueprints.

Vasilkov, Mark.
Olton Birmingham : Packt Publishing, Limited, 2015.
1 online resource (311 pages)

Location Notes Your Loan Policy


Android (Electronic resource).
Android (Electronic resource) -- Programming.
Computer games.
Electronic books.
This book is intended for programmers who are comfortable with the Python language and who want to build desktop and mobile applications with rich GUI in Python with minimal hassle. Knowledge of Kivy is not strictly required-every aspect of the framework is described when it's first used.
Kivy Blueprints
Table of Contents
Kivy Blueprints
About the Author
About the Reviewers
Support files, eBooks, discount offers, and more
Why subscribe?
Free access for Packt account holders
Write once, run anywhere
What this book covers
Setting up the working environment
A note on Python
Installing and running Kivy
Note on coding
Hello, Kivy
Who this book is for
Reader feedback
Customer support
Downloading the example code
Downloading the color images of this book
1. Building a Clock App
The starting point
Modern UI
Design inspiration
Loading custom fonts
Formatting text
Changing the background color
Making the clock tick
Updating the time on the screen
Binding widgets using properties
Layout basics
Finalizing the layout
Reducing repetition
Named classes
Styling buttons
9-patch scaling
Using 9-patch images
Counting time
Formatting the time for stopwatch
Computing values
Putting a stopwatch in place
Stopwatch controls
2. Building a Paint App
Setting the stage
Fine-tuning the looks
Visual appearance
Window size
Mouse cursor
Multitouch emulation
Drawing touches
A very short introduction to the canvas
Displaying touches on the screen
Clearing the screen
Passing events
Clearing the canvas
Connecting the dots
The color palette
Subclassing the buttons
Taking away the ability to deselect
Overriding the standard behavior
Coloring buttons
A new kind of button
Defining the palette
Setting the line thickness
Changing the line width
3. Sound Recorder for Android
Writing platform-dependent code
Introducing Pyjnius.
Emulating Android
Metro UI
The buttons
The grid structure
Visual attributes
Scalable vector icons
Icon fonts
Rationale for using icon fonts
Using the icon font in Kivy
Testing on Android
Using the native API
Loading Java classes
Looking up the storage path
Reading logs from the device
Recording sound
Major caveat - permissions
Playing sound
Deleting files
4. Kivy Networking
Writing the chat server
The protocol definition
The server source code
The principle of operation
Testing the server
Screen manager
Customizing the animation
Login screen layout
Chatroom screen layout
Overscroll modes
Bringing the app online
Building a simple Python client
Kivy integration with Twisted
ChatClient and ChatClientFactory
UI integration
Application logic of the client
Cross-application interoperability
Enhancements and eye candy
Escaping the special syntax
What's next
5. Making a Remote Desktop App
The server
The Flask web server
Advanced server functionality - taking screenshots
Emulating clicks
JavaScript client
Endless loop of screenshots
Passing clicks to host
Kivy Remote Desktop app
The login form
The remote desktop screen
Loop of screenshots in Kivy
Sending clicks
What's next
6. Making the 2048 Game
About the game
Gameplay concepts and overview
Randomness, or lack thereof
The 2048 project outline
What makes 2048 a good choice of project?
Simplicity as a feature
Creating the 2048 board
Going through cells
Rendering empty cells
Board data structure
Variable naming
Calling reset()
Testing passability
Making tiles
Tile initialization
Resizing tiles
Implementing the game logic
Moving tiles.
Controlling the iteration sequence
Implementing the move() method
Binding touch controls
Combining tiles
Adding more tiles
Synchronizing turns
Game over
The winning condition
The loss condition
Where to go from here
7. Writing a Flappy Bird Clone
Project overview
Creating an animated background
Loading tileable textures
The Background widget
Animating the background
Making pipes
An overview of the pipe properties
Setting texture coordinates
Implementing pipes
Spawning pipes
Moving and recycling pipes
Introducing Kivy Bird
Revised application flow
Accepting user input
Learning to fly straight down
Remaining in flight
Rotating the bird
Collision detection
Game over
Producing sound effects
Kivy sound playback
Adding sound to the Kivy Bird game
8. Introducing Shaders
Unscientific introduction to OpenGL
Concepts and parallelism
Performance gains, or lack thereof
Improving performance
Taking a closer look at GLSL
Using custom shaders in Kivy
Building the geometry
Illustrating the Indices
Writing GLSL
Storage classes and types
Basic shaders
Procedural coloring
Colorful vertices
Texture mapping
Making the Starfield app
Application structure
Data structures and initializers
Advancing the scene
Writing a corresponding GLSL
9. Making a Shoot-Em-Up Game
Limitations of the project
Texture atlases at a glance
Creating an atlas
Atlas structure
Using Kivy atlases in an easy way
Ad hoc usage of atlases with GLSL
Data structure for UV mapping
Writing an atlas loader
Rendering sprites from atlas
Designing a reusable particle system
Class hierarchy
The PSWidget renderer class
The Particle class
Writing the game
Implementing stars.
Making a spaceship
Creating a trail of fire
Making bullets
Implementing enemies
Collision detection
Finishing touches
A. The Python Ecosystem
Description based on publisher supplied metadata and other sources.
Local notes:
Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2021. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.
Other format:
Print version: Vasilkov, Mark Kivy Blueprints