ebook img

Python, Pygame, and Raspberry Pi Game Development PDF

395 Pages·2019·5.85 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Python, Pygame, and Raspberry Pi Game Development

Python, PyGame, and Raspberry Pi Game Development Second Edition — Sloan Kelly Python, PyGame, and Raspberry Pi Game Development Second Edition Sloan Kelly Python, PyGame, and Raspberry Pi Game Development Sloan Kelly Niagara Falls, ON, Canada ISBN-13 (pbk): 978-1-4842-4532-3 ISBN-13 (electronic): 978-1-4842-4533-0 https://doi.org/10.1007/978-1-4842-4533-0 Copyright © 2019 by Sloan Kelly This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Managing Director, Apress Media LLC: Welmoed Spahr Acquisitions Editor: Spandana Chatterjee Development Editor: James Markham Coordinating Editor: Divya Modi Cover designed by eStudioCalamar Cover image designed by Freepik (www.freepik.com) Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected], or visit http://www.apress.com/ rights-permissions. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/978-1-4842-4532-3. For more detailed information, please visit http://www.apress.com/source-code. Printed on acid-free paper For Annamarie Table of Contents About the Author ������������������������������������������������������������������������������xvii About the Technical Reviewer �����������������������������������������������������������xix Acknowledgments �����������������������������������������������������������������������������xxi Introduction �������������������������������������������������������������������������������������xxiii Chapter 1: What Is a Programming Language? ������������������������������������1 What Does a Computer Program Do? �������������������������������������������������������������������2 Conclusion ������������������������������������������������������������������������������������������������������������3 Chapter 2: What Is Python? ������������������������������������������������������������������5 Programming Styles ����������������������������������������������������������������������������������������������5 Object-Oriented �����������������������������������������������������������������������������������������������������7 Functional �������������������������������������������������������������������������������������������������������������8 What Is Pygame? ��������������������������������������������������������������������������������������������������8 Conclusion ������������������������������������������������������������������������������������������������������������9 Chapter 3: Introducing Python ������������������������������������������������������������11 The Terminal Window ������������������������������������������������������������������������������������������11 Running the Python Interpreter ���������������������������������������������������������������������������12 Python Is Interpreted �������������������������������������������������������������������������������������������13 Python As a Calculator ����������������������������������������������������������������������������������������13 Keywords ������������������������������������������������������������������������������������������������������������16 Printing����������������������������������������������������������������������������������������������������������������17 String Formatting ������������������������������������������������������������������������������������������19 v TTaabbllee ooff CCoonnTTeennTTss Variables �������������������������������������������������������������������������������������������������������������22 Naming Variables �������������������������������������������������������������������������������������������22 Python As a Calculator, Part II �����������������������������������������������������������������������������23 Arithmetic Operators �������������������������������������������������������������������������������������26 Data Types �����������������������������������������������������������������������������������������������������27 Numeric Types �����������������������������������������������������������������������������������������������27 String Formatting Again���������������������������������������������������������������������������������29 Conclusion ����������������������������������������������������������������������������������������������������������31 Chapter 4: Breaking Free from the Interpreter �����������������������������������33 What Is IDLE? ������������������������������������������������������������������������������������������������������33 Starting IDLE �������������������������������������������������������������������������������������������������������33 Starting a New File ���������������������������������������������������������������������������������������������34 Hello, World! ��������������������������������������������������������������������������������������������������������36 Running from the Command Line ������������������������������������������������������������������36 Running from Inside IDLE ������������������������������������������������������������������������������38 Conclusion ����������������������������������������������������������������������������������������������������������39 Chapter 5: Making Decisions ��������������������������������������������������������������41 A Note About Blocks ��������������������������������������������������������������������������������������������44 Testing for Equality ���������������������������������������������������������������������������������������������45 Using Boolean Logic ��������������������������������������������������������������������������������������������50 And ����������������������������������������������������������������������������������������������������������������50 Or �������������������������������������������������������������������������������������������������������������������51 Not �����������������������������������������������������������������������������������������������������������������52 Nesting Ifs �����������������������������������������������������������������������������������������������������������52 A Note on Switch�������������������������������������������������������������������������������������������������54 Conclusion ����������������������������������������������������������������������������������������������������������54 vi TTaabbllee ooff CCoonnTTeennTTss Chapter 6: Making the Raspberry Pi Repeat Itself �����������������������������55 The for Loop ��������������������������������������������������������������������������������������������������������55 The range() Function �������������������������������������������������������������������������������������57 While Loops ���������������������������������������������������������������������������������������������������������58 Counting ��������������������������������������������������������������������������������������������������������58 Sentinel ���������������������������������������������������������������������������������������������������������60 Conditional �����������������������������������������������������������������������������������������������������62 Conclusion ����������������������������������������������������������������������������������������������������������62 Chapter 7: Containers �������������������������������������������������������������������������63 Container Nomenclature �������������������������������������������������������������������������������������63 Tuples ������������������������������������������������������������������������������������������������������������������64 Removing Elements from a Tuple ������������������������������������������������������������������64 Changing Element Values ������������������������������������������������������������������������������65 Tuples in Printing �������������������������������������������������������������������������������������������66 Deconstructing Tuples �����������������������������������������������������������������������������������67 Lists ��������������������������������������������������������������������������������������������������������������������67 List Creation ��������������������������������������������������������������������������������������������������68 Adding Values to the List �������������������������������������������������������������������������������68 Removing Values from a List �������������������������������������������������������������������������69 Doctor’s Waiting Room Program ��������������������������������������������������������������������70 Dictionaries ���������������������������������������������������������������������������������������������������������73 Iterating Through Dictionaries �����������������������������������������������������������������������74 Adding New Items to Dictionaries �����������������������������������������������������������������74 Removing Entries from a Dictionary ��������������������������������������������������������������74 Conclusion ����������������������������������������������������������������������������������������������������������75 vii TTaabbllee ooff CCoonnTTeennTTss Chapter 8: Putting It Together: Tic-Tac-Toe ����������������������������������������77 The Rules ������������������������������������������������������������������������������������������������������������77 Program Layout ���������������������������������������������������������������������������������������������������79 Variables �������������������������������������������������������������������������������������������������������������79 The Game ������������������������������������������������������������������������������������������������������������80 Save and Run ������������������������������������������������������������������������������������������������������85 Conclusion ����������������������������������������������������������������������������������������������������������85 Chapter 9: Basic Introduction to PyGame �������������������������������������������87 Importing the PyGame Framework ���������������������������������������������������������������������87 Initializing PyGame ����������������������������������������������������������������������������������������������88 The Main Loop ����������������������������������������������������������������������������������������������������89 Images and Surfaces ������������������������������������������������������������������������������������������92 Creating Images ��������������������������������������������������������������������������������������������������93 Loading Images ���������������������������������������������������������������������������������������������������93 Drawing Images ��������������������������������������������������������������������������������������������������94 Screen Coordinates and Resolution ��������������������������������������������������������������������94 Sprite Sheets ������������������������������������������������������������������������������������������������������95 Full Listing�����������������������������������������������������������������������������������������������������������97 Conclusion ����������������������������������������������������������������������������������������������������������97 Chapter 10: Designing Your Game ������������������������������������������������������99 Initial Concept �����������������������������������������������������������������������������������������������������99 Prototyping ��������������������������������������������������������������������������������������������������100 Functional Specification������������������������������������������������������������������������������������101 Weapon Firing����������������������������������������������������������������������������������������������101 Program Design ������������������������������������������������������������������������������������������������101 Coding ���������������������������������������������������������������������������������������������������������������102 viii TTaabbllee ooff CCoonnTTeennTTss Testing���������������������������������������������������������������������������������������������������������������104 Iteration �������������������������������������������������������������������������������������������������������������105 Conclusion ��������������������������������������������������������������������������������������������������������105 Chapter 11: Game Project: Bricks ����������������������������������������������������107 The Main Framework ����������������������������������������������������������������������������������������108 Images ��������������������������������������������������������������������������������������������������������������109 Moving the Bat ��������������������������������������������������������������������������������������������������110 Bat Initialization �������������������������������������������������������������������������������������������111 Drawing the Bat �������������������������������������������������������������������������������������������112 Moving the Bat ��������������������������������������������������������������������������������������������112 Moving the Ball �������������������������������������������������������������������������������������������������114 Ball Initialization ������������������������������������������������������������������������������������������114 Ball Movement ���������������������������������������������������������������������������������������������115 Bat and Ball Collision �����������������������������������������������������������������������������������118 Serving the Ball �������������������������������������������������������������������������������������������120 Brick Wall ����������������������������������������������������������������������������������������������������������121 Brick and Ball Collision ��������������������������������������������������������������������������������122 Out of Bounds ����������������������������������������������������������������������������������������������124 Conclusion ��������������������������������������������������������������������������������������������������������125 Chapter 12: User-Defined Functions �������������������������������������������������127 What Is a Function? ������������������������������������������������������������������������������������������127 Format of a Function �����������������������������������������������������������������������������������������127 Functions as a Menial Task/Mnemonic Device �������������������������������������������������128 Sending Parameters �����������������������������������������������������������������������������������������129 Default Argument Values �����������������������������������������������������������������������������������131 Named Parameters ��������������������������������������������������������������������������������������132 ix TTaabbllee ooff CCoonnTTeennTTss Returning Values �����������������������������������������������������������������������������������������������133 Returning Tuples ������������������������������������������������������������������������������������������134 Accessing Global Variables �������������������������������������������������������������������������������135 Real-World Example of a Function ��������������������������������������������������������������������136 Conclusion ��������������������������������������������������������������������������������������������������������139 Chapter 13: File Input and Output �����������������������������������������������������141 Reading a File from Disk �����������������������������������������������������������������������������������141 Writing Data to a File ����������������������������������������������������������������������������������������143 Reading and Writing Containers to a File ����������������������������������������������������������144 Writing Your Own Serializer �������������������������������������������������������������������������145 Writing Your Own Deserializer ���������������������������������������������������������������������147 JSON �����������������������������������������������������������������������������������������������������������������148 JSON Serialization ���������������������������������������������������������������������������������������148 JSON Deserializer ����������������������������������������������������������������������������������������149 Handling Errors �������������������������������������������������������������������������������������������������150 Conclusion ��������������������������������������������������������������������������������������������������������151 Chapter 14: Introducing Object-Oriented Programming �������������������153 Classes and Objects ������������������������������������������������������������������������������������������154 Encapsulation ���������������������������������������������������������������������������������������������������154 Abstraction ��������������������������������������������������������������������������������������������������������155 Inheritance ��������������������������������������������������������������������������������������������������������155 Polymorphism ���������������������������������������������������������������������������������������������������155 Why Should You Use OOP? ��������������������������������������������������������������������������������156 Data Hiding ��������������������������������������������������������������������������������������������������156 Reusable ������������������������������������������������������������������������������������������������������156 Easier to Code and Test Separately �������������������������������������������������������������156 x

Description:
Expand your basic knowledge of Python and use PyGame to create fast-paced video games with great graphics and sounds. This second edition shows how you can integrate electronic components with your games using the build-in general purpose input/output (GPIO) pins and some Python code to create two n
See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.