Facebook Twitter Pinterest
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Sams Teach Yourself Game ... ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Gut | Details
Verkauft von Deal DE
Zustand: Gebraucht: Gut
Kommentar: Dieses Buch ist in gutem, sauberen Zustand. Seiten und Einband sind intakt.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Dieses Bild anzeigen

Sams Teach Yourself Game Programming in 24 Hours (Sams Teach Yourself...in 24 Hours) (Englisch) Taschenbuch – 18. Oktober 2002

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
"Bitte wiederholen"
EUR 27,61
EUR 24,34 EUR 3,19
7 neu ab EUR 24,34 17 gebraucht ab EUR 3,19
click to open popover

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.




Sams Teach Yourself Game Programming in 24 Hours demystifies game programming by providing clear, practical lessons using C/C++, the industry standard in game programming. The book focuses on the Windows API to construct games for the Windows platform and discusses game theory, including double-buffered graphics, sprite animation, and digitized sound effects and music. A fully functional game engine provides readers with the ability to create their own future games.

Über den Autor und weitere Mitwirkende

Michael Morrison is a writer, developer, toy inventor, and author of a variety of computer technology books and interactive Web-based courses. In addition to his primary profession as a writer and freelance nerd for hire, Michael is the creative lead at Stalefish Labs, an entertainment company he co-founded with his wife, Masheed. The first commercial debut for Stalefish Labs is a traditional social/trivia game called Tall Tales: The Game of Myths, Legends, and Creative One-Upmanship (http://www.talltalesgame.com/). When not glued to his computer, playing hockey, skateboarding, or watching movies with his wife, Michael enjoys hanging out by his koi pond. You can visit Michael on the Web at http://www.michaelmorrison.com/.


Es gibt noch keine Kundenrezensionen auf Amazon.de
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Stern

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 3.6 von 5 Sternen 22 Rezensionen
21 von 21 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Great introductory books 6. Januar 2004
Von Ein Kunde - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I have a passion about games. That's why I studied computer science, and I finally decided to dedicate all my free time to start learning how to program games. So I bought Teach yourself game programming in 24 hours by Michael Morrison. Let me tell you, I was surprisingly pleased, and didn't want the book to end.
To start with, this book is not for complete newbies into the C++ language but it shouldn't be. I hate a game book that spends half of its pages teaching you how to program C++. If I wanted that, I'd go back to school and take another C++ course. It also doesn't throw all the theory and math on you like some gaming books out there that are better left for writing a PHD thesis. No, this one is easy enough to follow but also assumes you already have working knowledge of C++. It digs into building a game engine from the ground up, and uses all that knowledge to build gradually more fun and interesting 2D games. It really opened my eyes to many little new tricks I can use to build my own games like the sprite manager and animation. If you guys can't compile the games, I think you still need to have better knowledge of C++ before you tackle this one. I had no problems compiling all the programs using Microsoft Visual C++ 6.0, and although there was a problem or two (due to the fact that the book was written in 2002 and some windows functions used in the book have changed since MSVC++ 6.0), I still found a way to fix them and get them to work. Now why didn't I give it the 5 shining stars then?
Well, first of all it is a 2D book, and it does not use DirectX. So we can use it to build primitive games, but come on, how many companies out there don't use DirectX. Like for example, there is no maximize button in all the windows the book creates, because then the different resolutions can mess up the game. That's where directx comes to your help. Also the sound libraries used are very primitive. PlaySound is not useful in mixing 2 sounds at the same time, and there were some games in the book that sounded weird because of that.
The other thing I didn't like about the book was how the text had lots of bugs in it. Like the text does not actually map one to one to the code on the CDs. But if you are not picky and a little alert, it's not a big deal. Anyway, a couple of emails to the publisher and a 2nd edition will fix that.
My final pet peave was that in so many cases, I was begging that the author would go in detail about the subject, but he would say, "this is too complex, but what I'm providing you is very good". I want some of that complex stuff too. Like I wanna know how a scrolling background works (Many adventure games use it like "Broken Sword"). My knowledge is not complete without it.
But overall, I think the book taught me many new things I didn't know, and although I won't be able to go write a commercial game out there by just reading this book, I can really put that knowledge with the knowledge from more advanced books to use.
I hope Michael Morrison will consider writing a DirectX book version of the Game Programming book, with 3D graphics, and the more "complex" stuff which were missed in this one. Even if the book costs double this one, I'll be the first to buy it.
27 von 30 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Sams Teach Yourself Game Programming In 24 Hours 10. Dezember 2002
Von daman - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Buy It! Why? This book teaches the fundamentals of game
programmiing - //minus the confusing direct x layer
Learning C++,Win32,SDK,API is quite a challenge for the
beginner and adding COM (+) Direct X is quite daunting
for absolutebeginners.
Michael outlines how to write simple games with source
code and all of the executables work,but you will have
to tweak them,if you want to add minutes to the
gameplay or add levels.
The reason I like this book was because it taught the
fundamentals of game programming. After studying this
text, if you want, you can then move on to algorithms,
data structures,3d-mathmatics and other game wizardry.
I highly recommend Sams Teach Yourself Game Programming
In 24 Hours.
If you're like me you read everything in the bookstore,
in the computer gaming section and end up purchasing
too many books.
Unfortunately, all books are not created equal. So, to
save you a little time and fustration, read the list
below for what I think are a few fundamental c++ and
game programming text currently on the market. I know
that "Stroudstrap" wrote C,C++ and parts of Unix, but
brilliant programmer does not always translate into
great author;(personal experience).
These are excellent books are for absolute beginners
and soon to be Gurus:
1. C++ How to Program (Fourth Edition)Author: Deitel
It's not a "fun read", but it covers all of the
fundamentals inside and out.
Do yourself a favor - Get it!
It covers everything. After reading this, you will not have a
need for Stroudstrap, (unless you want to "get fancy and show-
2. Programming Windows (Fifth Edition) Author: Charles Petzold
Fundamentals again. Teaches how to write code for a
window,how to write bitmaps to the screen,blitting,
color palattes...
Everyone has it,it's an easy read, get it.
Rector is o.k., but he's talking about programming
for windows apps and using MFC (isn't that a fried
chicken franchise somewhere)? skim and read through
it several times,you'll see what I mean. "Corporate
will never understand the creative"!
3.Tricks of The Game Programming Gurus (Second Edition)
Author: Andre LaMothe
After completing cs101,cs202,cs303 of the above listed texts;
this book should "in a perfect world" culminate your learning
while matriculating through the virtual world of game
Game Programming Gurus covers all of the information in the
previous titles, but it covers "real world code". If you have
dreams of becoming the next "Great Programmer", you will use
all of the information in this book. Much unlike many of the
corporate college courses you've probably completed.
"Not that (it)'s anything wrong with 4 years".
This book covers algorithms,2d,3d,direct x,gdi,COM,sound,...
After reading,then (studying), these four texts I think that you
will have confidence and ablity to accomplish anything!
Yes indeed,
you'll be able to exclaim,
with a complete and popular domain,
without sounding insane,
"Yes! I Got Game".
7 von 7 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen People want too much in this book 18. März 2005
Von Rusty Shackleford - Veröffentlicht auf Amazon.com
Format: Taschenbuch
When you boil this book down to its basics, it teaches basic windows programming in the context of creating simple 2d sprite based games that simulate 3d enviroments. It does not teach C++, nor should it. It does not teach DirectX, or openGL, nor should it, nor does it ever claim to. It does not teach poor programming practices, like writing an entire application in a single file, that is insanity.

It accomplishes its goals and does it in an interesting and fun manner, what more could you want in a primer?

I wish they would do away with the nonsense "learn X in 24 hours/1week/3 nanoseconds" titles and name them something more appropriate. No one can learn the windows API in 24 hours, no one can learn the C++ language in a week. It is fraudulent to even try and claim to. Most of the books in this series are pretty decent, although not for a serious CS student or professional programmer. They are however, decent books for lay people who can't or don't want to learn the ins and outs of computer systems, but like tinkering around with them and creating programs. They are also a decent,inexpensive way to learn material that would normally be taught in elective courses, although these books don't go far enough to become an expert, it is still a decent beginning.
6 von 6 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen You will learn game programming, kind of, but mostly Mike Morrison's game engine. 15. Januar 2007
Von W. Luongo - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I gave this book 2 stars, because it has some good points, mostly really bad points.

The good:

You will be able to make basic 2D sprite games in Windows using this book and the source code on the CD. It encourages you to learn basic techniques involved with the other aspects of game development (sound, music, etc). The book comes with several games that you can run right off the CD.

The bad:

This book doesn't really teach you much. In other Sam's Teach Yourself books, you learn each step of what you are doing, and you can put in the source code yourself. In this one, you merely read about PIECES of the source code, and are expected to run it off the disk. So basically, you are paying for a game engine, a bunch of source code examples, and a tutorial on using the game engine.

I would have enjoyed this book much more if it had spent time explaining exactly what the engine does and how to make it do it, not to mention how the code in your program interacts with the engine. It seems to me that this book is mostly for people who want to "cheat" and copy and paste the code to make their games, rather than understanding what they are doing and writing the code themselves. Since I was someone who wanted the latter, I was sorely disappointed.
8 von 9 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Good Starting Point 26. Juli 2005
Von G. Broner - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I have been writing games for a number of years now. While I have published a few "action" games for the AMIGA platform, my experience in the windows environment was more with "static games" such as board games and puzzles. Since I already had the experience with action games and Window programming - my reason for buying the book was to learn "how to do program games the right way" rather then just "how to program games".

For me - the book proves to be a very good book, but I think others will find it not as pleasant - I'll explain that later.

As with other SAMS "learn in 24 hours", there are 24 chapters, which theoretically should be completed in an hour each. I think that is an individual thing - in some areas that I felt knowledgeable in, I skimmed through a chapter in 10 minutes. Yet in some areas, I was fiddling with the example and the source code for hours.

There is also an accompanying CD containing a C++ compiler (Borlands C++ trail version), and source code for all the examples in the book. The installation procedure for the CD was painless - although from previous experiences with compilers - that is not always the case - and if you already have a compiler you might want to stick with it and install only the code examples.

The book starts with a short history of games, a quick introduction to window programming (windows and event handling) and continue to discuss the main driver of a game - the game engine. The book does very well to enhance the engine and add surrounding components: basic graphics (chapter 4), bitmaps (chapter 5), keyboard/mouse/joystick handling (chapters 6/7). It is at the end of chapter seven (the whole of chapter 8 actually) - that you get to write your first game, but not to worry - you get to do some coding well before that. The examples in the chapters leading to chapter 8 should prove intriguing enough for those who are serious about the subject of game programming.

From here on - most of the chapters are dedicated to the main visual aspects of the game - sprites and animations. The book teach how to create them, move them around, animate them, testing for collision, working the background and managing the whole lot (chapters 9-12, 17-22). There is a break for music (chapters 13-16) and some info about creating demos for your application and keeping high score (chapters 23-24) - all accompanied by good solid examples and full working games (about five of them).

The great thing about the book is that is does really teach you how to do it right. It clearly explains the ingredients, build them up logically and provide great code for tinkering. The pace is good and you don't find yourself falling asleep. The examples are relevant, and the source code is explained in the relevant chapter to the right level (not every little detail, but covering all the main points). The book also does not fall into the trap of going into 3D, DirectX or other open libraries - those are important for the serious game programmer, but are a different logical unit, better covered in a purposely written book. This book is to teach you about writing games in the correct manner and about making you WANT to learn more - and in that aspect, "it does what it says on the tin".

So where are the problems? Well - the book states in the introduction that they do expect you to have some background of C++ (true) but they don't expect you to have windows programming knowledge. I guess they were hoping to give the basics of window elements (the event handling routine and the windows creation - as well as the windows data types) in the first two chapters - and that is nonsense. The idea of event handling routine and window register is so fundamental to the way a windows environment concepts are being applied - that anyone not accustomed to SOME window programming will find themselves utterly confused and insecure after the second chapter. The other complaint has to do with the writer. Mr. Morrison is supposedly a competent writer - but when he feels that something is hard to explain - he basically tells you "not to worry about it, you'll get it as we go along" - extremely un-reassuring, and he does it quite a few times in the book. He also sometimes uses the complicated (although more robust) coding - which is important for good programming, but might be utterly confusing (for example, the bitmap class cover loading bitmaps from file, resource etc - using the loadimage command and analysing the bitmap structure, making it a hard read - while a simple loadbitmap and select object commands would have built a shorter, less robust but more reader friendly code) - Last, it must be noted that if you are using a different compiler, the source might need some adjustments - but generally, the more experienced user should find it straightforward.

Overall, I found the book a very good introduction to 2D game programming, and it did left me wanting to explore farther. I would recommend it to those who have some window programming under their belt, but are new to game programming. In that category - this is one of the better books around.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.