%{search_type} search results

• PHILOSOPHY AND METHODOLOGY: Taming the Beast: Managing Complexity in Game Build Pipelines. Game Streaming: A Planned Approach. Workflow Improvement via Automatic Asset Tracking. Continuous Integration for Games. Persistence Management of Asset Metadata and Tags. Real-Time Tool Communication. Robust File I/O. BUILDABLE TOOLS: Real-Time Constructive Solid Geometry. A COLLADA Toolbox. Shape-Preserving Terrain Decimation and Associated Tools. In-Game Audio Debugging Tools. Pragmatic XML Use in Tools. Low Coupling Command System. Object-Oriented Data. Improving Remote Perforce Usage. THIRD-PARTY TOOLS: Vector Displacement in the Sculpting Workflow. Optimizing a Task-Based Game Engine. Efficient Texture Creation with Genetica. Reducing Video Game Creation Effort with Eberos GML2D. YAML for C++: Applied Data-Driven Design. GPU Debugging and Profiling with NVIDIA Parallel Nsight. FBX Games Development Tools. Index.
• (source: Nielsen Book Data)

This book brings the insights of game professionals, DCC creators, hardware vendors, and current researchers together into a collection that focuses on the most underrepresented and critical part of game production: tools development. The first gems-type book dedicated to game tools, this volume focuses on practical, implementable tools for game de.
(source: Nielsen Book Data)

• 1. Introduction to Game Polish 2. The Essentials
• 3. Gameplay 4. Game Balancing 5. User Experience 6. In-Game Visuals 7. Audio 8. Writing 9. Coding Practices 10. Testing 11. Final Thoughts Appendix A: Space Bounce.
• (source: Nielsen Book Data)

Learn the things you need for a complete game, such as translations and tutorials, and improve the things you've already written to raise their standard to a professional level. This is a practical guide covering every discipline: art, music, writing, and code. In the case of the latter, code examples are included to demonstrate how to implement functionality to make the game shine. Polished Game Development acts as a comprehensive checklist of everything your game should, and should not, do, in order to be as good as it possibly can. It is more than just a book on theoretical game design principles. Explains the difference between a pet project, and a professional one. Covers how to test for the problems and bugs you don't know you'll have. Details simple, but effective, visual improvements that can be done with very little effort. Regardless of platform (web, mobile, or console), or language (C++, C#, JavaScript) there is a wealth of common (and specific) tips within these pages that will enable you to make the most professional games you can. What You Will Learn Learn what essential elements are often missed Stay on-brand, visually and verbally Use audio to enhance your game Improve game balance Test effectively Who This Book Is For Game developers looking for a guide and checklist on how to get their game finished to the highest possible standards. They will know how to write a game, and get it released, but not necessarily how to make it shine. They will be professional developers, indies, university students and graduates.
(source: Nielsen Book Data)

Die bekannten Design Patterns der Gang of Four im konkreten Einsatz für die Entwicklung von Games Zahlreiche weitere vom Autor entwickelte Patterns Sequenzierungs-, Verhaltens-, Entkopplungs- und Optimierungsmuster Für viele Spieleprogrammierer stellt die Finalisierung ihres Spiels die größte Herausforderung dar. Viele Projekte verlaufen im Sande, weil Programmierer der Komplexität des eigenen Codes nicht gewachsen sind. Die im Buch beschriebenen Design Patterns nehmen genau dieses Problem in Angriff. Der Autor blickt auf jahrelange Erfahrung in der Entwicklung von weltweit erfolgreichen Games zurück und stellt erprobte Patterns vor, mit deren Hilfe Sie Ihren Code entwirren und optimieren können. Die Patterns sind in Form unabhängiger Fallbeispiele organisiert, so dass Sie sich nur mit den für Sie relevanten zu befassen brauchen und das Buch auch hervorragend zum Nachschlagen verwenden können. Sie erfahren, wie man eine stabile Game Loop schreibt, wie Spielobjekte mithilfe von Komponenten organisiert werden können und wie man den CPU-Cache nutzt, um die Performance zu verbessern. Außerdem werden Sie sich damit beschäftigen, wie Skript-Engines funktionieren, wie Sie Ihren Code mittels Quadtrees und anderen räumlichen Aufteilungen optimieren und wie sich die klassischen Design Patterns in Spielen einsetzen lassen.

• Introduction
• Essential 3D Review
• Review C# language
• Unity Components (Work in as we go?
• Common Mathematics and Physics Used in 3D:
• Essential 3D Paradigms
• Artificial Intelligence
• 2D Look in a 3D Engine.
• (source: Nielsen Book Data)

The independent developer has ascended, and the new business model demands agility. You have to be able to work on all aspects of game creation, and your team's game will publish directly to platforms like Android, iPhone, and Facebook. You'll use Unity, the hottest game engine out there, to do it. In order to earn your place on the elite development team, you must master both sides of the development coin: art and programming. Holistic Game Development with Unity is an authoritative guide to creating games in Unity. Taking you through game design, programming, and art, Penny de Byl uses a holistic approach to equip you with the multidisciplinary skills you need for the independent games industry. With this book, you will master essential digital art and design principles while learning the programming skills necessary to build interactivity into your games. The tutorials will put these skills into action. The companion website offers: source code for completed projects from the book, art assets, instructional videos, a forum, author blog and lesson plans and challenge questions for professors. Examines art and programming in unison-the only one-stop shop for individual developers and small teams looking to tackle both tasks.
(source: Nielsen Book Data)

• Getting Started Overview The Development Environment What Is DirectX? Why C++? Naming Conventions Game Engine Tips and Tools
• Windows Programming Fundamentals Windows Programming Fundamentals "Hello World" Windows Style Device Context Keyboard Input with Windows API Using a Mutex to Prevent Multiple Instances Multitasking in Windows
• Introduction to DirectX Introduction to DirectX Initializing DirectX Creating a Device Clearing a Display Buffer Page Flipping A Clean Exit The Graphics Class Our First DirectX Program Fullscreen or Windowed Debug vs. Retail DLLs Determining Device Capabilities
• The Game Engine The Game Engine, Part 1 The Game Class The Input Class The Spacewar Class
• Sprites and Animation Obtaining Game Graphics The Graphics Pipeline Drawing with Transparency The TextureManager Class The Image Class Game Engine Simple Animation
• Collisions and Entities Vectors Collisions The Entity Class Physics for 2D Games
• Sound Obtaining Audio Files Creating Audio Files Using XACT Adding Audio to the Game Engine Adding Sound to the Game Adjusting Audio Playback
• Text Sprite Text Creating Custom Fonts Text Class Details DirectX Text TextDX Class Details Adding an FPS Display Adding a Console Console Class Incorporating the Console into the Game Engine
• Enhanced Appearance Bitmap Scrolling Painter's Algorithm Parallax Scrolling Shadows and Reflections Message Dialog Input Dialog Windows Dialogs in Fullscreen DirectX Applications Dashboard
• Tiled Games Why Tiled? Creating a Tile Set Creating Levels Displaying the Tiles Orthogonal Projection Oblique Projection Isometric Projection Isometric Terrain Elevation Layers
• Building a Complete Game Evolutionary Prototyping Project Management Design Document Prototype Textures Spacewar Tasks Spacewar v1.0 Saving and Loading
• Network Programming Network Overview The Net Class Initialize the Network Creating a Server Creating a Client Get the Local IP Address Sending Receiving Closing a Socket Get Error Client/Server Chat Client/Server Spacewar Spacewar Server Spacewar Client
• The Journey
• Index
• Questions and Exercises appear at the end of each chapter.
• (source: Nielsen Book Data)

A First Course in Game Programming Most of today's commercial games are written in C++ and are created using a game engine. Addressing both of these key elements, Programming 2D Games provides a complete, up-to-date introduction to game programming. All of the code in the book was carefully crafted using C++. As game programming techniques are introduced, students learn how to incorporate them into their own game engine and discover how to use the game engine to create a complete game. Enables Students to Create 2D Games The text covers sprites, animation, collision detection, sound, text display, game dashboards, special graphic effects, tiled games, and network programming. It systematically explains how to program DirectX applications and emphasizes proper software engineering techniques. Every topic is explained theoretically and with working code examples. The example programs for each chapter are available at www.programming2dgames.com.
(source: Nielsen Book Data)

• The following gives a high-level table of contents. Starred chapters will change significantly from the current edition, with changes noted.
• Chapter 1: Vectors and Points
• This chapter covers basic linear algebra topics such as vectors, points, lines and planes. Most changes will be in presentation, not in topic.
• Chapter 2: Matrices and Linear Transformations
• This continues the linear algebra discussion and discusses the mathematical methods for changing the concepts presented in Chapter 1. Most modifications will be in presentation, not in topic.
• *Chapter 3: Affine Transformations
• This completes the algebra discussion and covers basic graphics transformations such as translation, rotation and scale. Most changes will be in presentation, not in topic, although there will be a small section added on skinning.
• Chapter 4: Real-World Computer Number Representation
• This chapter covers the problems of representing the infinite space of numbers in a finite computer. Most modifications will be in presentation, not in topic.
• Chapter 5: Viewing and Projection
• This chapter begins the graphics topics with a discussion of building virtual cameras. Most modifications will be in presentation, not in topic.
• *Chapter 6: Lighting and Color
• This new chapter collates the color topics from the original Chapter 6 and the non-shading aspects of the original Chapter 7. To be presented here are the more abstract notions of color, normals to a surface, direction to a light, and how a lit color value is generated without any reference to triangles or interpolation.
• *Chapter 7: Geometry, Shading and Texturing
• As with the previous chapter, this one will take mostly material from the original chapters 6 and 7, and some from Chapter 8. The chapter will conclude with a brief discussion of hardware vertex and pixel shaders, but as this is not a graphics book per se it will only be at an introductory level.
• *Chapter 8: Rasterization and Antialiasing
• The final graphics chapter will now focus on sampling the continuous functions discussed in the previous two so that they can be represented on discrete hardware. Both rasterization and texturing will lead into a discussion of antialiasing and solving the problems for both processes: mip-mapping, multi-sampling, and other approaches.
• *Chapter 9: Animation of Position
• The previous version of this chapter focused on curves, and the new one will be no exception. However, rather than attempting to be a general curve discussion it will focus more on the particular curve types that are most often used in an interactive application for animating cameras and object position.
• -- *Chapter 10: Animation of Orientation
• As with the previous chapter, this one will be retargeted to focus mainly on animation issues. There will also be more material dedicated to approximating slerp, as there have been a number of publications and debate on this topic since the original publication of the book.
• Chapter 11: Intersection Testing
• This chapter covers basic bounding object tests and some topics in collision detection and culling. There will be few changes.
• *Chapter 12: Physical Simulation
• The general structure of this one will remain the same with only a few additions and expansions of existing topics based on the author's participation in the Physics for Game Programmers GDC tutorial. First, symplectic Euler and its stability properties will be discussed. Secondly, more attention will be given to generating inertial tensors for triangle soups. Finally, simple constraints will be presented.
• *Chapter 13: Random Numbers
• This chapter was originally planned for the first edition and was requested by a number of reviewers. It will cover basic probability, three methods for generating pseudo-random numbers on a digital computer, and some applications of random numbers: Artificial intelligence routines, simulating die rolls and card draws, Perlin noise for procedural textures, and finally some basic presentation of stochastic sampling for anti-aliasing

Essential Mathematics for Games and Interactive Applications, 2nd edition presents the core mathematics necessary for sophisticated 3D graphics and interactive physical simulations. The book begins with linear algebra and matrix multiplication and expands on this foundation to cover such topics as color and lighting, interpolation, animation and basic game physics. Essential Mathematics focuses on the issues of 3D game development important to programmers and includes optimization guidance throughout. The new edition Windows code will now use Visual Studio.NET. There will also be DirectX support provided, along with OpenGL - due to its cross-platform nature. Programmers will find more concrete examples included in this edition, as well as additional information on tuning, optimization and robustness. The book has a companion CD-ROM with exercises and a test bank for the academic secondary market, and for main market: code examples built around a shared code base, including a math library covering all the topics presented in the book, a core vector/matrix math engine, and libraries to support basic 3D rendering and interaction. --Simple game engine with math, rendering, and input libraries on the CD-ROM, so that game developers can immediately start applying the techniques they learn in a basic codebase. --Exercises on the CD-ROM for educators to use for course material --Code samples shown throughout the book for real-world application

• Introduction. I. GAMEPLAY PROGRAMMING. 1. A Chronology of Game Programming.
• Phase I: Before Spacewar. Phase II: Spacewar to Atari. Phase III: Game Consoles and Personal Computers. Phase IV: Shakedown and Consolidation. Phase V: The Advent of the Game Engine. Phase VI: The Handheld Revolution. Phase VII: The Cellular Phenomenon. Phase VIII: Multiplayer Games. In Closing. 2. Game Architecture.
• Real-Time Software. The Game Logic Section. The Presentation Section. The Programming Process. In Closing. 3. Data Structures and Algorithms.
• Types, Structures, and Classes. Data Structures. The Standard Template Library. In Closing. 4. Design Patterns.
• Design Patterns Defined. Some Useful Programming Patterns. Usability Patterns. In Closing. 5. User Input.
• The Keyboard. Mouse. Joysticks. Hardware Abstraction. Force Feedback. In Closing. 6. Fundamental AI Technologies.
• Context. Structure of an AI System. Specific Technologies. In Closing. 7. Action-Oriented AI.
• On Action Games. Choreographed AIs. Object Tracking. Chasing. Evasion. Patrolling. Hiding and Taking Cover. Shooting. Putting It All Together. In Closing. 8. Tactical AI.
• Tactical Thinking Explained. Military Analysis: Influence Maps. Representing Tactics. In Closing. 9. Scripting.
• Building a Scripting Language. Embedded Languages. Socket-Based Scripting. In Closing. 10. Network Programming.
• How the Internet Really Works. The Programmer's Perspective: Sockets. Clients. A Simple TCP Server. Multiclient Servers. UDP Servers. Preventing Socket Blocks. Designing Client-Server Games. Massively Multiplayer Games. In Closing. II. ENGINE PROGRAMMING. 11. 2D Game Programming.
• On Older Hardware. Data Structures for 2D Games. Mapping Matrices. 2D Game Algorithms. Special Effects. In Closing. 12. 3D Pipeline Overview.
• A First Look. Fundamental Data Types. Geometry Formats. A Generic Graphics Pipeline. In Closing. 13. Indoors Rendering.
• General Analysis. Occluder-Based Algorithms. Binary Space Partition Algorithms. Portal Rendering. Hierarchical Occlusion Maps. Hybrid Approaches. Hardware-Assisted Occlusion Tests. In Closing. 14. Outdoors Algorithms.
• Overview. Data Structures for Outdoors Rendering. Geomipmapping. ROAM. Chunked LODs. A GPU-Centric Approach. Outdoors Scene Graphs. In Closing. 15. Character Animation.
• Analysis. Explicit Versus Implicit Methods. Explicit Animation Techniques. Implicit Animation Overview. Prop Handling. A Note on Vehicles. Limb Slicing. Facial Animation. Inverse Kinematics. Blending Forward and Inverse Kinematics. In Closing. 16. Cinematography.
• First-Person Shooters. Handling Inertia. Flight Simulators and Quaternions. Third-Person Cameras. Cinematic Cameras: Camera Styles. Cinematic Cameras: Placement Algorithms. Agent-Based Approaches. In Closing. 17. Shading.
• Real-World Illumination. Light Mapping. The BRDF. Nonphotorealistic Rendering. In Closing. 18. Texture Mapping.
• Types of Textures. Tiling and Decals. Filtering. Mipmapping. Texture Optimization. Multipass Techniques. Multitexture. Texture Arithmetic and Combination. Detail Textures. Environment Mapping. Bump Mapping. Gloss Mapping. In Closing. 19. Particle Systems.
• Anatomy of a Particle System. The Particle Data Structure. Some Notes on Architecture. Speed-Up Techniques. In Closing. 20. Organic Rendering.
• Nature and Complexity. Trees. Grass. Clouds. Oceans. In Closing. 21. Procedural Techniques.
• Procedural Manifesto. Renderman. Real-Time Shading Languages. Types of Shaders. Texture Mapping. Particle Systems. Animation. Special Effects. In Closing. 22. Geometrical Algorithms.
• Point Inclusion Tests. Ray Intersection Tests. Moving Tests. Point Versus Triangle Set Collision (BSP-Based). Mesh Versus Mesh (Sweep and Prune Approach). Computing a Convex Hull. Triangle Reduction. In Closing. III. APPENDICES. Appendix A: Performance Tuning.
• Analysis Techniques. Analysis Tools. General Optimization Techniques. Application. Efficient Data Transfer. Tuning the Geometry Pipeline. Tuning the Rasterizer Stage. Other Optimization Tools. In Closing. Appendix B: OpenGL.
• Philosophy. Basic Syntax. Immediate Mode Rendering. Transformations. Camera Model. Lighting. Texturing. Working in RGBA Mode. Display Lists. Vertex Arrays. OpenGL Extensions. Efficiency Considerations. Geometric Representation. In Closing. Appendix C: Direct3D.
• History. Booting Direct3D. Handling Geometry. Indexed Primitives. User Pointer Primitives. Efficient Geometry Delivery. Flexible Vertex Formats. Matrices, Cameras, and Transforms. Working with Texture Maps. Lighting. Render States. The Extension Library. Animation Helpers. In Closing. Appendix D: Some Math Involved.
• Distances. Trigonometry. Vector Math. Matrices. Appendix E: Further Reading.
• Part 1. Chronology Of Game Programming. Part 2. Game Architecture. Part 3. Data Structures and Algorithms. Part 4. Design Patterns. Part 5. User Input. Parts 6, 7I, and 8: Fundamental AI Technologies, Action-Oriented AI, and. Tactical AI. Part 9. Scripting. Part 10. Network Programming. Part 11. 2D Programming. Part 12. 3D Pipeline Overview. Part 13. Indoors Rendering. Part 14. Outdoors Algorithms. Part 15. Character Animation. Part 16. Inematography. Part 17. Shading. Part 18. Texture Mapping. Part 19. Particle Systems. Part 20. Organic Rendering. Part 21. Procedural Techniques. Part 22. Geometrical Algorithms. Appendix A: Performance Tuning. Appendix B: OpenGL. Appendix C: Direct3D. Appendix D: Some Math Involved. Index.
• (source: Nielsen Book Data)

To even try to keep pace with the rapid evolution of game development, you need a strong foundation in core programming techniques-not a hefty volume on one narrow topic or one that devotes itself to API-specific implementations. Finally, there's a guide that delivers! As a professor at the Spanish university that offered that country's first master's degree in video game creation, author Daniel Sanchez-Crespo recognizes that there's a core programming curriculum every game designer should be well versed in-and he's outlined it in these pages! By focusing on time-tested coding techniques-and providing code samples that use C++, and the OpenGL and DirectX APIs-Daniel has produced a guide whose shelf life will extend long beyond the latest industry trend. Code design, data structures, design patterns, AI, scripting engines, 3D pipelines, texture mapping, and more: They're all covered here-in clear, coherent fashion and with a focus on the essentials that will have you referring back to this volume for years to come.
(source: Nielsen Book Data)

• Chapter 1: Introduction Chapter Goal: How to approach this book
• Chapter 2: Setting Up Our Development Environment Chapter Goal: Getting started * Checking out Github and switching to the start branch * A simple hello world inside of our setup
• Sub - Topics:
• 1. Where to start
• 1. Setting up Node.js and Git
• 2. The main ingredient
• 3. Our Frontend architecture
• 4. Our general architecture
• Chapter 3: Orchastrating Our Domain Model Chapter Goal: Have a concise model to work with.
• Sub - Topics:
• 1. The building blocks
• 2. Creating our first model
• 3. The player model
• 4. The Keyboard model
• 5. Putting it all together
• 6. Creating our directories
• 7. Directories construction tactics
• Chapter 4: Implementing Our Game Domain Models Chapter Goal: Introduction to phaser and implementing our models
• Sub - Topics:
• 1.
• About Phaser
• 2.
• Talking about Phaser...
• 3.
• The Player model
• 4.
• Phaser Arcade Physics
• 5.
• The Game Model
• 6.
• The Keyboard model
• Chapter 5: Seeing It in Action! Chapter Goal: Alpha version of the game
• Sub - Topics:
• 1.
• Hooking it all up together
• Chapter 6: Projectiles! Chapter Goal: Allow the gunships to fire!
• Sub - Topics:
• 1.
• Making it to the big screen
• 2.
• Overlap
• 3.
• Gimme the gun!
• 4.
• More on Overlap
• 5.
• Updating the keyboard with fire!
• 6.
• The HUD
• Chapter 7: Hooking Up Our Server Chapter Goal: The backend of things
• Sub - Topics:
• 1.
• On to the server side of things
• 2.
• Models and events
• 3.
• Setting up our static file server
• 4.
• Socket connection
• 5.
• Back to the client
• 6.
• Marvellous explosions!
• Chapter 8: The World Should Remember Your Name Chapter Goal: Authentication
• Sub - Topics:
• 1.
• Login
• Chapter 9: Bonus! Chapter Goal: Cleaning up
• Sub - Topics:
• 1.
• Refactoring & Asteroids
• 2.
• Adding more features
• 3.
• Some more refactoring
• 4.
• Asteroids!
• Chapter 10: Further reading and discovery Chapter Goal: Where to go from here
• Sub - Topics:
• Other Phaser resources.
• (source: Nielsen Book Data)

Create a fully working multiplayer game from scratch using TypeScript, Socket.IO, and the community edition of Phaser.js. You will achieve amazing feats in the browser without having to install any software. This book teaches you how to use the Phaser game engine APIs to tap into physics, and how to utilize HUD information and fire lasers. Let's Build a Multiplayer Phaser Game dives into the details to show you how to create a multiplayer game from beginning to end. Once you have finished this book, you will be well versed in creating not only a game, but also an application that you can extend with new functionality to enjoy with your friends. What You'll Learn Discover the ins and outs of Socket.IO for real-time web communication Use TypeScript to allow your project to be typed and self-documenting See how gaming mechanics work to make a game entertaining Get a deeper understanding of how to structure your working directory and your code Scale what you have created Who This Book Is For Developers who want to know how to create and structure a complex online game.
(source: Nielsen Book Data)

Utilize proven solutions to solve common problems in game development About This Book * Untangle your game development workflow, make cleaner code, and create structurally solid games * Implement key programming patterns that will enable you to make efficient AI and remove duplication * Optimize your game using memory management techniques Who This Book Is For If you are a game developer who wants to solve commonly-encountered issues or have some way to communicate to other developers in a standardized format, then this book is for you. Knowledge of basic game programming principles and C++ programming is assumed. What You Will Learn * Learn what design patterns are and why you would want to use them * Reduce the maintenance burden with well-tested, cleaner code * Employ the singleton pattern effectively to reduce your compiler workload * Use the factory pattern to help you create different objects with the same creation logic and reduce coding time * Improve game performance with Object Pools * Allow game play to interact with physics or graphics in an abstract way * Refractor your code to remove common code smells In Detail You've learned how to program, and you've probably created some simple games at some point, but now you want to build larger projects and find out how to resolve your problems. So instead of a coder, you might now want to think like a game developer or software engineer. To organize your code well, you need certain tools to do so, and that's what this book is all about. You will learn techniques to code quickly and correctly, while ensuring your code is modular and easily understandable. To begin, we will start with the core game programming patterns, but not the usual way. We will take the use case strategy with this book. We will take an AAA standard game and show you the hurdles at multiple stages of development. Similarly, various use cases are used to showcase other patterns such as the adapter pattern, prototype pattern, flyweight pattern, and observer pattern. Lastly, we'll go over some tips and tricks on how to refactor your code to remove common code smells and make it easier for others to work with you. By the end of the book you will be proficient in using the most popular and frequently used patterns with the best practices. Style and approach This book takes a step-by-step real-life case studies approach. Every pattern is first explained using a bottleneck. We will show you a problem in your everyday workflow, and then introduce you to the pattern, and show you how the pattern will resolve the situation.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Authors; About the Reviewer; www.PacktPub.com; Table of Contents; Preface; Chapter 1: Introduction to GameMaker: Studio; Chapter 2: Your First Game
• Escape the Dungeon; Chapter 3: Introducing the GameMaker Language; Chapter 4: Fun with Infinity and Gravity
• An Endless Platformer; Chapter 5: Saving and Loading Data; Chapter 6: A Multiplayer Sidescrolling Platformer; Chapter 7: Programming a Scrolling Shooter; Chapter 8: Introducing the GameMaker: Studio Physics Engine; Chapter 9: Wrapping Up; Index; Choosing your version.

• The GameMaker: Studio interfaceAn example project; Summary; Creating your Escape the Dungeon game; Summary; Remaking Escape the Dungeon in the GML; Summary; Creating an endless platformer; Summary; Putting in a scoring system; Customizable controls; Summary; Sprite animation; Making your scrolling platformer scroll; Client/server multiplayer networking; Integrating Xbox gamepad support; Summary; Creating the main ship; Creating the enemies; Programming a Boss AI; Particles; Summary; A physics game; The physics engine in a regular game; Summary; Debugging; Helpful information on GameMaker.

• Death and enemiesRandom spawning; Menus and textboxes; Review questions; Quick drills; Saving and loading a highscore; Saving control configurations; Review questions; Quick drills; Spritesheet importing; Programming the movement; Networking terminology; Printing the server's IP address and port on a screen; Creating the actual server; The client in your client/server system; Legacy gamepad support; Modern gamepad support; Review questions; Quick drills; Parenting in objects; Random enemy spawning; Review questions; Quick drills; Review questions; Quick drills; Compile-time errors.

• Runtime errorsThe GameMaker: Studio debugger; Debugging functions; Quirks of the GameMaker Language; Unexplained resources; Export modules; Review questions; Quick drills; The sprite; The object; Making your enemies move; Damaging the player; Making the player shoot; Making the enemies shoot; Backgrounds; Sounds; Understanding the four events; Starting to code your player object; Random seeds; Displaying health and lives; Invincibility; 2D arrays; Menus; Textboxes; INI file encryption; Our Asynchronous Networking event.

Master the development of 2D games by learning to use the powerful GameMaker Language and tools provided by the GameMaker: Studio workspace and engine! About This Book * Rapidly develop games using the powerful yet easy easy-to to-use GameMaker: Studio engine * Comprehensive: This is a comprehensive guide to help you learn and implement GameMaker's features. * Go through step-by-step tutorials to design and develop unique games Who This Book Is For If you have at least some basic programming experience of JavaScript or any other C-like languages, then this book will be great for you. No experience beyond that is assumed. If you have no game development experience and are looking for a hobby, are an experienced game developer looking to master some advanced features, or fit anywhere in that spectrum, then you will find GameMaker: Studio and this book to be very useful in helping you create exciting games. What You Will Learn * Understand the GameMaker: Studio interface and tools to quickly create the various assets used in your games * Translate some of the GameMaker: Studio drag and drop functions to the GameMaker language * Create games with random elements for exciting gameplay * Use the basic GameMaker file I/O and encryption systems * Utilize the GameMaker networking functions to create multiplayer games * Give AI routines to your enemies to make challenging gameplay * Create particle systems to give your game exciting graphics * Understand the various debugging techniques available in GameMaker: Studio In Detail This book is excellent resource for developers with any level of experience of GameMaker. At the start, we'll provide an overview of the basic use of GameMaker: Studio, and show you how to set up a basic game where you handle input and collisions in a top-down perspective game. We continue on to showcase its more advanced features via six different example projects. The first example game demonstrates platforming with file I/O, followed by animation, views, and multiplayer networking. The next game illustrates AI and particle systems, while the final one will get you started with the built-in Box2D physics engine. By the end of this book, you have mastered lots of powerful techniques that can be utilized in various 2D games. Style and approach A This step-by-step guide that follows and with details ons different topics throughout the creation of various examples.
(source: Nielsen Book Data)

• Indie Game Development: The Best Job in the World!
• Chapter 1: Development Tools and Resources
• Chapter 2: Self-Publishing
• Chapter 3: QA, Localizations & Age Ratings
• Chapter 4: PR & Reaching Out to the Press
• Chapter 5: Marketing
• Chapter 6: Advertising
• Chapter 7: Websites, Forums & Source Control
• Chapter 8: Funding
• Chapter 9: Tax, Legal & Other Odds and Ends.
• (source: Nielsen Book Data)

The indie game developer's complete guide to running a studio. The climate for the games industry has never been hotter, and this is only set to continue as the marketplace for tablets, consoles and phones grow. Seemingly every day there is a story of how a successful app or game has earned thousands of downloads and revenue. As the market size increases, so does the number of people developing and looking to develop their own app or game to publish. The Indie Game Developer Handbook covers every aspect of running a game development studio-from the initial creation of the game through to completion, release and beyond. Accessible and complete guide to many aspects of running a game development studio from funding and development through QA, publishing, marketing, and more. Provides a useful knowledge base and help to support the learning process of running an indie development studio in an honest, approachable and easy to understand way. Case studies, interviews from other studies and industry professionals grant an first-hand look into the world of indie game development.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Author; Acknowledgments; About the Reviewers; www.PacktPub.com; Table of Contents; Preface;
• Chapter 1: Overview; Getting assets; Collection of sites; Welcome to 2D; The new 2D mode; Sprites; Sprite Renderer; Sprite Editor; Spritesheets; Texture atlases; Sprite meshes; The Box2D physics system; The new animation Dope Sheet; Other Unity 4.3 improvements; Improved Mecanim performance; The Windows Phone API improvements and Windows 8.1 support; Dynamic Nav Mesh (Pro version only); Editor updates; MonoDevelop 4.01; Movie textures; Summary.

• Chapter 2: Building a CharacterGetting your project started
• the right way; Structure; Object naming; Understanding components; Accessing components using a shortcut; A better way to use components
• referencing; An even better way; Creating the project; Classes; The object-orientated design; The game structure; The common game object; More later; Planning behaviors; Behaviors for the common game object; Behaviors for the player''s character; Introducing the Unity sprite system; Importing sprites; Texture type
• sprite; Sprite Mode
• single/multiple; Packing tag; Pixels to units.

• The Sprite Editor buttonSprite Editor; Sprite splitter (slicer); View controls; Sprite region manipulation; Putting it together; Importing our main character; The hero; Controlling the hero; Going further; Summary;
• Chapter 3: Getting Animated; Sprite animation; Animation components; Animation controllers; Animation clips; The Animator component; Setting up animation controllers; Setting up animation clips; Manual animation clip creation; Automatic animation clip creation; Animator Dope Sheet; Dope/curve view; Putting it together; Setting up the animation controller.

• Adding your first animation clip (idle)Adding another animation clip (run); Connecting animation states; Accessing controllers from a script; Extra credit; Getting curvy; Going further; Summary;
• Chapter 4: The Game World; Backgrounds and layers; To slice or not to slice; The town background; The town buildings; The extra scenery; Building the scene; Adding the town background; Sprite sorting layers; Sprite sorting order; Updating the scene Sorting Layers; Working with the camera; Comparing Update, FixedUpdate, and LateUpdate; The perils of resolution; A better FollowCamera script.

• Transitioning and boundsTowns with borders; Journeying onwards; Planning for the larger picture; Backgrounds and active elements; Parallaxing; Foreground objects; Shaders and 2D; Going further; Summary; Chapter 5: NPCs and Interactions; Considering an RPG; Advanced programming techniques; Singletons and managers; The manager approach
• using empty game objects; The singleton approach
• using the C♯ singleton pattern; Communicating between game objects; Delegates; The configurable method pattern; The delegation pattern; Compound delegates; Events; Messaging; A better way.

If you have C# knowledge but now want to become truly confident in creating fully functional 2D RPG games with Unity, then this book will show you everything you need to know.
(source: Nielsen Book Data)

"FPS (first-person shooter) games are one of today's most popular game genres. In this hands-on course, you'll learn to use the Unity game engine to build an FPS game all the way from nothing to a complete game. Designed for learners with a core understanding of the Unity game engine (familiarity with the Inspector, know how to get around scene view, etc.), this video teaches you the skills you need to create your own FPS games."--Resource description page.

"The course takes you through the complete process of building a narrative game using nothing but Unity, some open source dialogue software, some free art and music from open source locations, and your own smarts. The course works best for those with a very basic understanding of the Unity game engine interface and C# programming."--Resource description page.

• Introduction
• Chapter 1: Editor Cheats
• Chapter 2: Asset & Importing Cheats
• Chapter 3: Scene, Component and GameObject Cheats
• Chapter 4: Animation and Time
• Chapter 5: Persistence and Accessibility
• Chapter 6: Cameras, Rendering and Lighting
• Chapter 7: Coding & MonoDevelop Tricks
• Chapter 8: Performance and Optimization
• Chapter 9: Physics, Collisions and Path-Finding
• Chapter 10: Debugging and Building
• Index.
• (source: Nielsen Book Data)

Looking to become more efficient using Unity? How to Cheat in Unity 5 takes a no-nonsense approach to help you achieve fast and effective results with Unity 5. Geared towards the intermediate user, HTC in Unity 5 provides content beyond what an introductory book offers, and allows you to work more quickly and powerfully in Unity. Packed full with easy-to-follow methods to get the most from Unity, this book explores time-saving features for interface customization and scene management, along with productivity-enhancing ways to work with rendering and optimization. In addition, this book features a companion website at www.alanthorn.net, where you can download the book's companion files and also watch bonus tutorial video content. Learn bite-sized tips and tricks for effective Unity workflows Become a more powerful Unity user through interface customization Enhance your productivity with rendering tricks, better scene organization and more Better understand Unity asset and import workflows Learn techniques to save you time and money during development.
(source: Nielsen Book Data)

• Overview of networked games
• The internet
• Berkeley sockets
• Object serialization
• Object replication
• Network topologies and sample games
• Latency, jitter, and reliability
• Improved latency handling
• Scalability
• Security
• Real-world engines
• Gamer services
• Cloud hosting dedicated servers.

• Introducing Computer Games and Software Engineering Kendra M.L. Cooper and Walt Scacchi THE POTENTIAL FOR GAMES IN SOFTWARE ENGINEERING EDUCATION Use of Game Development in Computer Science and Software Engineering Education Alf Inge Wang and Bian Wu Model-Driven Engineering of Serious Educational Games: Integrating Learning Objectives for Subject-Specific Topics and Transferable Skills Kendra M.L. Cooper and Shaun Longstreet A Gameful Approach to Teaching Software Design and Software Testing Swapneel Sheth, Jonathan Bell, and Gail Kaiser Educational Software Engineering: Where Software Engineering, Education, and Gaming Meet Tao Xie, Nikolai Tillmann, Jonathan de Halleux, and Judith Bishop Adaptive Serious Games Barbara Reichart, Damir Ismailovic, Dennis Pagano, and Bernd Brugge CONDUCTING FUNDAMENTAL SOFTWARE ENGINEERING RESEARCH WITH COMPUTER GAMES RESTful Client-Server Architecture: A Scalable Architecture for Massively Multiuser Online Environments Thomas Debeauvais, Arthur Valadares, and Cristina V. Lopes Software Engineering Challenges of Multiplayer Outdoor Smart Phone Games Robert J. Hall Understanding User Behavior at Three Scales: The AGoogleADay Story Daniel M. Russell Modular Reuse of AI Behaviors for Digital Games Christopher Dragert, J rg Kienzle, and Clark Verbrugge Repurposing Game Play Mechanics as a Technique for Designing Game-Based Virtual Worlds Walt Scacchi Emerging Research Challenges in Computer Games and Software Engineering Walt Scacchi and Kendra M.L. Cooper.
• (source: Nielsen Book Data)

Computer games represent a significant software application domain for innovative research in software engineering techniques and technologies. Game developers, whether focusing on entertainment-market opportunities or game-based applications in non-entertainment domains, thus share a common interest with software engineers and developers on how to best engineer game software. Featuring contributions from leading experts in software engineering, the book provides a comprehensive introduction to computer game software development that includes its history as well as emerging research on the interaction between these two traditionally distinct fields. An ideal reference for software engineers, developers, and researchers, this book explores game programming and development from a software engineering perspective. It introduces the latest research in computer game software engineering (CGSE) and covers topics such as HALO (Highly Addictive, sociaLly Optimized) software engineering, multi-player outdoor smartphone games, gamifying sports software, and artificial intelligence in games. The book explores the use of games in software engineering education extensively. It also covers game software requirements engineering, game software architecture and design approaches, game software testing and usability assessment, game development frameworks and reusability techniques, and game scalability infrastructure, including support for mobile devices and web-based services.
(source: Nielsen Book Data)

• 1. Welcome to Android Gaming
• 2. Gaming Tricks for Phones or Tablets
• 3. More Gaming Tricks with OpenGL and JNI
• 4. Efficient Graphics and Portability with OpenGL ES 2.0
• 5. 3D Shooters for Doom
• 6. 3D Shooters for Quake
• 7. 3D Shooters for Quake II
• 8. Fun With Bluetooth Controllers
• 9. Designing and Porting to Android TV
• 10. Deployment and Compilation Tips
• 11. Discovering Android Wear.
• (source: Nielsen Book Data)

Combining actionable, real-world source code with graphics, Pro Android Games, Third Edition shows you how to build more sophisticated and addictive Android game apps with minimum effort. Harness the power of the latest Android 5.0 SDK to bring countless legendary, action-packed PC games to the Android platform. With actionable real-world source code, this one of a kind book shows you how to build more sophisticated and addictive Android game apps, by leveraging the power of the recent advancements found in the new Android 5.0 software development kit as well as those you've counted on in earlier releases. Multi-touch code gives these games and their players dynamic input and exchange ability, for a more realistic arcade game experience. Faster and better performance offers Android game players a more seamless, fun arcade experience like never before. There is also improved native C/C++ integration with Android's NDK as well, which makes coding, compiling, and converting both productive and efficient with gains in app performance. Pro Android Games, Third Edition features the following improvements: Updates to the latest version of the Android SDK, NDK, plus the latest Android Studio and Eclipse IDEs Greater focus on tablets, ever changing device resolutions, and hardware specs Native game development and hardware accelerated graphics Bigger and better real world engines, such as Quake I and II plus an oldie from the previous edition: Doom Coverage of the new Android TV SDK APIs, UI, UX, multi-touch and multi-tasking features available with the Android 5.0 release Advanced techniques for improving your game playing experience including better multi-tasking, improved performance optimization, battery management and more A "Quake 3D"-like game app case study You'll definitely have fun, and perhaps you'll even make some money. Enjoy! In the last few years, Android has progressed with the debut of better fonts, new User Interface and Experience (UI/UX) APIs, tablet considerations, multi-touch capabilities, multi-tasking, faster performance, improved battery management techniques, and now the new Android TV SDK Apps for the Android game app developer repertoire.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Author; About the Reviewers; www.PacktPub.com; Table of Contents; Preface;
• Chapter 1: Getting Started with SFML; Creating windows; VideoMode; Style; ContextSettings; Disabling the mouse cursor; The game loop; Event handling; Window related events; Keyboard related events; Mouse related events; Joystick related events; Using events; Shape rendering and transformations; The render frame; Shape drawing; Shape transformation; Controlling shapes; Summary;
• Chapter 2: Loading and Using Textures; Loading textures; Images versus textures; Creating images

• Creating texturesRendering shapes with textures; What is a sprite?; Shapes versus sprites; Transformables and drawables; Final facts on sprites; Managing resources; Summary;
• Chapter 3: Animating Sprites; Capturing time; sf::Time and sf::Clock; Animating sprites; The setup; Building an animator; Using the animator; Multiple animations; Summary;
• Chapter 4: Manipulating a 2D Camera; What is a camera?; When should we use a camera?; How does SFML implement a camera?; Manipulating cameras with sf::View; Rotating and scaling a view; Viewports; Mapping coordinates; What is OpenGL?

• Should you use OpenGL?Using OpenGL inside SFML; OpenGL in multiple windows; Summary; Chapter 5: Exploring a World of Sound and Text; Audio module
• overview; Sound versus music; Audio in action; The sf::Sound class; Introducing AssetManager 2.0; sf::Music and sf::SoundStream; sf::SoundSource and audio in 3D; Common audio features; Audio in 3D; Setting up the listener; Audio sources; Summarizing audio features; Getting started with sf::Text; AssetManager 3.0; Summary; Chapter 6: Rendering Special Effects with Shaders; sf::RenderTarget and sf::RenderWindow; Rendering directly to a texture

• Shader programmingWhat is a shader?; Loading shaders; AssetManager 4.0; Using shaders; Setting shader uniforms; sf::Shader and OpenGL; Combining it all together; Setting up RenderTexture; Summary; Chapter 7: Building Multiplayer Games; Understanding networking; Networking in games; Transport layer
• TCP versus UDP; TCP in SFML; UDP in SFML; Non-blocking sockets; Exchanging packets; Constructing a packet; Putting it all into practice; Summary; Index

If you are an enthusiast who is not new to the field of game development but want to exercise the countless features of SFML and build 2D games with minimal effort, this is the book for you.
(source: Nielsen Book Data)

• Table of Contents; DirectX 11.1 Game Programming; DirectX 11.1 Game Programming; Credits; About the Author; About the Reviewers; www.PacktPub.com; Support files, eBooks, discount offers and more; Why Subscribe?; Free Access for Packt account holders; Preface; What this book covers; What you need for this book; Conventions; Reader feedback; Customer support; Downloading the example code; Errata; Piracy; Questions;
• 1. Say Hello to DirectX 11.1; The need for DirectX 11.1; Why should we target Windows 8?; The prerequisites; Introduction to C++/CX; Lifetime management; What is a ref class?

• InheritanceDelegates and events; Metro Style apps; Setting up your first project; Building your first Metro app; Working with game time; Initializing the device; Connecting to a swap chain; The render target and depth stencil views; Summary;
• 2. Getting Started with HLSL; An introduction to HLSL; New features of HLSL; Compiling and linking to shaders; Buffers in Direct3D; Constant buffers; Vertex buffers; Index buffers; Textures; Rendering primitives; Direct2D 1.1; Summary;
• 3. Rendering a 3D Scene; Displaying the performance data; A short introduction to FPS; Asynchronous loading.

• Introduction to tasksAsynchronous resource loading; Getting started with the Model Editor; Loading a model from the .cmo format; Rendering a model; The input devices we'll need; Keyboard; Pointer; Xbox 360 controllers; Turn on the camera; Base camera; First person camera; Third person camera; Composing XAML and Direct3D; Summary;
• 4. Tessellation; Hardware tessellation; The most popular usage of hardware tessellation; Basic tessellation; The Hull Shader stage; The Domain Shader stage; Tessellating a quad; Displacement mapping using tessellation; The normal mapping technique.

• The displacement mapping techniqueDirectX graphics diagnostics; Capturing the frame; The Graphics Experiment window; Investigating a missing object; Disabling graphics diagnostics; Summary;
• 5. Multithreading; C++ AMP; Compute Shader; C++ AMP versus Compute Shader; Post-processing; Implementing post-processing using C++ AMP; Implementing post-processing using Compute Shader; Summary; Index.

Written in step-by-step tutorial format, we will explore the creation of 3D applications and games through the development of a Windows 8 metro style game. DirectX 11.1 Game Programming Written for developers with knowledge of C++ essentails and 3D mathematics who would want to create metro style game on the Windows 8 platform.
(source: Nielsen Book Data)