A Basic Game ArchitectureThe follow

A Basic Game Architecture

The following diagram represents a game architecture.

In the schema above you see the Android OS running on the Phone and everything on top of that.
The input is the touch-screen in our case but it can be a physical keyboard if the phone has one, the microphone, the camera, the accelerometers or even the GPS receiver if equipped. The framework exposes the events when touching the screen.
The User Input
In our game this is the event generated by touching the screen in one of the 2 defined control areas.Our game engine monitors the onTouch event and at every touch we record the coordinates. If the coordinates are inside our defined control areas on the screen we will instruct the game engine to take action. For example if the touch occurs in the circle designated to move our guy the engine gets notified and our guy is instructed to move.If the weapon controller circle is touched the equipped weapon will be instructed to fire its bullets. All this translates to changing the actors’ states that are affected by our gestures aka input.


Game Logic
The game logic module is responsible for changing the states of the actors in the game. By actors I mean every object that has a state. Our hero, droids, terrain, bullets, laser beams etc. For example we touch the upper half of the hero control area like in the drawing and this translates to: calculate the movement speed of our guy according to the position of our movement controller (our finger).

In the image above the light green circle represents our finger touching the control area. The User Input module notifies the Game Engine (Game Logic) and also provides the coordinates. dx and dy are the distances in pixels relative to the controller circle centre. The game engine calculates the new speed it has to set for our hero and the direction he will move. If dx is positive that means he will go right and if dy is positive he will also move upward.
Audio

This module will produce sounds considering the current state. As almost every actor/object will produce sounds in their different states and because the devices we’ll run our game on are limited to just a few channels (that means briefly how many sounds can the device play at once) it has to decide which sounds to play. For example the droid posing the biggest threat to our hero will be heard as we want to draw attention to it and of course we will need to reserve a channel for the awesome shooting sound of our weapon as it is much fun listening to our blaster singing. So this is the audio in a nutshell.

Graphics
This is the module responsible for rendering the game state onto the display. This can be as simple as drawing directly onto the canvas obtained from the view or having a separate graphics buffer drawn into and then passed to the view which can be a custom view or an OpenGL view.
We measure the rendering in FPS which stands for frames per second. If we have 30FPS that means that we display 30 images every second. For a mobile device 30 FPS is great so we will aim for that.
The only thing you want to know now that the higher the FPS the smoother the animation. Just imagine someone walking and close your eyes for exactly one second. After opening your eyes you will see the person in the position after one second. This is a 2FPS. Watch them walk but keeping your eyes open and you’ll see a fluid motion. This is guaranteed to be a minimum of 30FPS but it is likely to be more, depending on your eyes. If you have awesome receptors in pristine condition this could be 80-100 or more.
Output
The output is the result of both sound and image and maybe vibration if we decide to produce some.

A Basic Game Loop
Following the series so far you we have an understanding of the game architecture. Even if just briefly but we know that we need to take input in some form, update the internal state of the game and finally render it to the screen and also produce some sounds and/or vibrations. Now, we are going to discuss and implement the basic game loop.

We handle input, update the state of our internal objects and render the current state. The Update and Render are grouped logically. They are tied together and tend to be executed one after the other.
Anything in Android happens inside an Activity. The Activity will create a View. The View is where everything happens. It is where the touch takes place and the resulting image gets displayed. Think of the Activity as a table that holds a sheet of paper (the View) enabling us to draw something. We will use our pencil to draw something onto the paper. That will be our touch and the actual chemistry happens on the paper so the result of our interaction with the View produces an image. The same is with Activity and View. Something like the following diagram:

The game loop is the heartbeat of every game. We used a very rudimentary one so far without any control over how fast or slow we update our game state and which frames to render.
To recapitulate, the most rudimentary game loop is a while loop that keeps executing some instructions until we signal it to finish, usually by setting a variable called running to false

The above code runs blindly without a care for timing and resources. If you have a fast device then it will run very fast and if you have a slow one it will run slower.
The updateGameState() updates the state of every object in the game and the displayGameState() renders the objects into an image which is displayed onto the screen.

There are two things we should consider here: FPS and UPS.
FPS – Frames per Second – the number of times displayGameState() is being called per second.
UPS – Update per Second – the number of times updateGameState() is being called per second.
Ideally the update and render methods will be called the same number of times per second (preferably not less than 20-25 times per second). 25 FPS is usually enough on a phone so us humans won’t notice the animation being sluggish.

For example if we target 25 FPS then it means we have to call the displayGameState() method every 40ms (1000 / 25 = 40ms, 1000ms = 1s). We need to bear in mind that updateGameState() is also called before the display method and for us to reach 25 FPS, we have to make sure that the update – display sequence executes in exactly 40ms. If it takes less than 40ms, then we have a higher FPS. If it takes more than that, then we have a slower running game.
Let’s see some examples to understand the FPS better.
The following diagram shows exactly 1 FPS. It takes the update – render cycle exactly one second to execute. This means that you will see the image on the screen change once every second.

1 Frame per Second

The following diagram shows 10FPS. An update – render cycle takes 100ms. This means every tenth of a second the image changes.

10 FPS
But the above scenario means that the update-render cycle executes in 1/10 of a second EVERY time. That is an assumption and we can’t control the actual times on cycle executes, or can we? What happens if we have 200 enemies and every enemy is shooting at us? We need to update the state of each enemy and the states of their bullets and check for collisions in one single update. It’s different when we have just 2 enemies. The times will clearly differ. The same applies to the render method. Rendering 200 firing droids will clearly take more time than rendering only 2.
So what are the scenarios? We could have an update-render cycle that finishes in less than 100ms (1/10 of a second), finishes in exactly 100ms or finishes in more than that. On a powerful hardware it will be faster than on a weaker one. Let’s see the diagrams.
The cycle finishes before the desired timeframe so we have a small amount of free time before running the next cycle.

Frame with time to spare
The following diagram shows a cycle which falls behind. That means that the time it takes for a update-render cycle to finish is greater than the desired one. If it takes 12ms that means we are 2ms behind (still considering the 10FPS). This can mount up and every cycle we loose time and the game will run slowly.

Overdue Frame
The first situation is the desired one. This gives us some free time to do something before we kick off the next cycle. We don’t need to do anything so we just tell the game loop to go to sleep for the remaining time period and wake up when the next cycle is due. If we won’t do this the game will run quicker than intended. By introducing the sleep time we achieved constant frame rate.
The second situation (I skipped the ideal one as it almost never happens) when the loop is behind, requires a different approach.
To achieve constant speed in a game we need to update the state of our objects when required. Imagine a droid approaching you at a constant speed. You know if it travelled half the screen in one second, so it will take another second to reach the other side of the screen. To calculate the position accurately we need to know either the time delta since the last postion, and the current speed of the droid, or we update the position (status) of the droid at constant intervals. I will choose the second one as playing with deltas in the game update can be tricky. To achieve a constant game speed we will have to skip displaying frames. Game speed is NOT FPS!
Examine the following diagram. It is a scenario in which the update-render cycle takes longer than the desired time so we have to catch up. To do that we will skip the rendering of this frame and will do another update so the game speed won’t be affected. We’ll do a normal cycle in the next frame with even some time to give to the CPU to rest.

Constant Game Speed with Variable FPS
The above scenario has many variations. You can imagine the game update taking more than one full frame. In this case we can do nothing to keep the game speed constant and the game will run slower. We might have to skip multiple renderings to keep the speed consta

ผลลัพธ์ (ไทย) 1:

สถาปัตยกรรมเป็นเกมพื้นฐานไดอะแกรมต่อไปนี้แสดงถึงสถาปัตยกรรมเกม ในแผนข้างต้น คุณเห็นระบบปฏิบัติการ Android ที่ทำงานบนโทรศัพท์และสิ่งด้านบนของที่มีการสัมผัสหน้าจอในกรณี แต่อาจจะมีแป้นพิมพ์กายภาพถ้าโทรศัพท์มีหนึ่ง ไมโครโฟน กล้อง การใช้หัว หรือแม้กระทั่งการรับ GPS ถ้า กรอบแสดงถึงเหตุการณ์เมื่อสัมผัสหน้าจอป้อนข้อมูลผู้ใช้ในเกมของเรา นี้มีเหตุการณ์ที่สร้างขึ้น โดยการสัมผัสหน้าจอในพื้นที่ควบคุมกำหนด 2เครื่องเกมของเราตรวจสอบเหตุการณ์ onTouch และสัมผัสทุกที่ เราบันทึกพิกัด ถ้าพิกัดที่อยู่ภายในพื้นที่ของเรากำหนดควบคุมบนหน้าจอ เราจะแนะนำเครื่องเกมดำเนินการ สำหรับตัวอย่างหากสัมผัสวงกลมที่กำหนดให้ย้ายคนของเราได้รับการแจ้งเตือนเครื่องยนต์และผู้ชายของเราแนะย้ายถ้าสัมผัสวงกลมควบคุมอาวุธ อาวุธพร้อมจะสั่งไฟสัญลักษณ์ของ ทั้งหมดนี้แปลเปลี่ยนอเมริกาของนักแสดงที่ได้รับผลกระทบ โดย aka เข้ารูปแบบลายเส้นของเราเกมลอจิกโมเกมลอจิกรับผิดชอบในการเปลี่ยนสถานะของตัวแสดงในเกม โดยนักแสดง ผมหมายถึง ทุกวัตถุที่มีสถานะ ของเราพระเอก droids ภูมิประเทศ สัญลักษณ์ เลเซอร์คานฯลฯ ตัวอย่าง ที่เราสัมผัสครึ่งบนของพื้นที่ควบคุมฮีโร่เช่นในรูปวาด และนี้แปล: คำนวณความเร็วในการเคลื่อนไหวของผู้ชายของเราตามตำแหน่งของการควบคุมการเคลื่อนไหวของเรา (ของเรานิ้ว) ในภาพด้านบนวงกลมสีเขียวอ่อนแทนนิ้วของเราสัมผัสบริเวณควบคุม โมดูลผู้ใช้ป้อนข้อมูลแจ้งเตือนเครื่องยนต์เกม (เกมตรรกะ) และยัง มีพิกัด dx และ dy มีระยะทางเซลเทียบศูนย์กลมควบคุม เครื่องเกมคำนวณความเร็วใหม่ที่มีการตั้งค่าสำหรับพระเอกของเราและทิศทางที่เขาจะย้าย ถ้า dx เป็นค่าบวกหมายความ ว่า เขาจะไปทางขวา และถ้า dy จะบวก เขาจะย้ายขึ้นเสียงโมดูลนี้จะผลิตเสียงพิจารณาสถานะปัจจุบัน เป็นเกือบทุกที่นักแสดงวัตถุจะผลิตเสียงในสถานะการต่างกัน และเนื่อง จากอุปกรณ์ที่เราจะรันเกมของเรามีจำกัดเพียงไม่กี่ช่อง (ที่หมายความ สั้น ๆ จำนวนเสียงสามารถอุปกรณ์เล่นครั้ง) จะมีการตัดสินใจซึ่งเสียงการเล่น เช่น droid วางตัวภัยคุกคามใหญ่ที่สุดพระเอกของเราจะได้ยินเสียงเราต้องการดึงความสนใจไป และแน่นอนเราจะต้องจองช่องสัญญาณสำหรับการกลัวยิงเสียงของอาวุธของเราก็สนุกมากฟังเพลง blaster ของเรา ดังนั้นในสั้นนี้เป็นเสียงกราฟิกโมชอบแสดงสถานะเกมบนจอแสดงผลอยู่ นี้จะเป็นแค่รูปวาดโดยตรงบนผืนผ้าใบที่ได้รับจากมุมมองหรือมีบัฟเฟอร์กราฟิกแยกต่างหากออกไปแล้ว ผ่านไปยังมุมมองซึ่งมุมมองกำหนดเองหรือมุมมองสินค้าเราวัดสีที่สองที่ถึงเฟรมต่อเฟรม/วินาที ถ้าเราได้ 30 เฟรมต่อวินาทีซึ่งหมายความว่า ให้ เราแสดงภาพ 30 วินาทีทุก สำหรับอุปกรณ์โมบาย 30 FPS ได้ดีดังนั้นเราจะมุ่งมั่นที่ สิ่งเดียวที่คุณต้องการทราบว่าตอนนี้ที่สูง FPS ภาพเคลื่อนไหวที่ราบเรียบ เพียงแค่จินตนาการคนเดิน และปิดตาเหมือนหนึ่งวินาที หลังจากเปิดตา คุณจะเห็นบุคคลในตำแหน่งหลังหนึ่งวินาที FPS ที่ 2 อยู่ นาฬิกาเดินแต่รักษาดวงตาของคุณเปิด และคุณจะเห็นการเคลื่อนไหวของเหลว นี้จะรับประกันได้ว่า อย่างน้อย 30 เฟรมต่อวินาที แต่ก็มีแนวโน้มจะเพิ่มมากขึ้น ขึ้นอยู่กับดวงตาของคุณ ถ้าคุณกลัว receptors ในสภาพที่เก่าแก่ ซึ่งอาจจะ 80-100 หรือมากกว่า ผลผลิตผลลัพธ์เป็นผลทั้งเสียง และภาพ และสั่นสะเทือนบางทีถ้าเราตัดสินใจในการผลิตบางวนเกมพื้นฐานต่อชุด จนเรามีความเข้าใจเกี่ยวกับสถาปัตยกรรมเกม แม้เพียงสั้น ๆ แต่เรารู้ว่า เราจำเป็นต้องใช้สำหรับการป้อนค่าในแบบฟอร์ม ปรับปรุงสถานะภายในของเกม และสุดท้าย แสดงหน้าจอ และยัง ผลิตบางเสียงหรือการสั่นสะเทือน ตอนนี้ เราจะไปพูดคุย และใช้ลูปเกมพื้นฐาน เราจัดการเข้า ปรับปรุงสถานะของวัตถุภายในของเรา และแสดงสถานะปัจจุบัน ปรับปรุงและสร้างภาพจะถูกจัดกลุ่มทางตรรกะ พวกเขาจะเกี่ยวพันกัน และมีแนวโน้มที่ จะดำเนินการหลังจากอื่น ๆอะไรใน Android เกิดขึ้นภายในกิจกรรม กิจกรรมที่จะสร้างมุมมอง ดูได้ที่ทุกอย่างเกิดขึ้น สัมผัสเกิดขึ้น และได้รับการแสดงภาพผลลัพธ์ที่ได้ คิดว่า กิจกรรมเป็นตารางที่เก็บกระดาษ (มุมมอง) ที่ทำให้เราบางสิ่งบางอย่าง เราจะใช้ดินสอของเราบางสิ่งบางอย่างลงบนกระดาษ ที่จะได้สัมผัสของเรา และเคมีจริงเกิดขึ้นบนกระดาษเพื่อให้ผลลัพธ์ของเราโต้ตอบกับมุมมองสร้างภาพ เหมือนเป็นกิจกรรมและมุมมอง บางสิ่งบางอย่างเช่นไดอะแกรมต่อไปนี้: วงการเกมของทุกเกมได้ เราใช้หนึ่ง rudimentary มากจนไม่ มีการควบคุมอย่างรวดเร็ว หรือช้าอย่างไรเราปรับปรุงสถานะของเกมและเฟรมที่แสดงRecapitulate ลูปเกม rudimentary มากที่สุดคือ ในขณะที่วนที่ช่วยดำเนินการบางคำแนะนำจนเราสัญญาณให้เสร็จสิ้น มักจะ โดยการตั้งค่าตัวแปรเรียกใช้เท็จ รหัสข้างต้นทำงานอย่างคนตาบอดโดยไม่ดูแลในเวลาและทรัพยากร ถ้าคุณมีอุปกรณ์อย่างรวดเร็ว แล้วมันจะวิ่งเร็วมาก และ ถ้าคุณมีหนึ่งช้าก็จะทำงานช้าลงUpdateGameState() การปรับปรุงสถานะของทุกวัตถุในเกม และ displayGameState() ทำให้วัตถุที่เป็นรูปภาพที่แสดงบนหน้าจอมีสองสิ่งที่เราควรพิจารณา: FPS และ UPSFPS – เฟรมต่อวินาที – จำนวนครั้งที่ถูกเรียกว่า displayGameState() ต่อวินาทีUPS – ปรับปรุงต่อวินาที – จำนวนครั้งที่ถูกเรียกว่า updateGameState() ต่อวินาทีห้องวิธีการปรับปรุงและสร้างภาพจะเรียกจำนวนครั้งต่อวินาที (ไม่ควรน้อยกว่า 20 - 25 ครั้งต่อวินาที) เดียวกัน 25 FPS พอโทรศัพท์ดังนั้นมนุษย์เราจะสังเกตเห็นการเคลื่อนไหวที่กำลังซบเซาตัวอย่างเช่นถ้าเรากำหนดเป้าหมาย 25 FPS แล้วหมายความว่า เราต้องเรียกวิธี displayGameState() 40ms ทุก (1000 / 25 = 40ms, 1000ms = 1s) เราต้องจำไว้ว่า updateGameState() ยังเรียกว่าวิธีการแสดง และ สำหรับเราถึง 25 FPS เราต้องแน่ใจว่า ปรับปรุง – แสดงลำดับดำเนินใน 40ms ตรง ถ้าใช้เวลาน้อยกว่า 40ms แล้วเราได้ FPS สูง ถ้าใช้มากกว่านั้น แล้วเรามีเกมทำงานช้าลงลองดูอย่างเข้าใจ FPS ดีกว่าไดอะแกรมต่อไปนี้แสดงว่า 1 FPS ใช้เวลาปรับปรุง – แสดงว่าหนึ่งสองรอบเพื่อดำเนินการ ซึ่งหมายความ ว่า คุณจะเห็นภาพบนหน้าจอเปลี่ยนกันทุกวินาที 1 เฟรมต่อวินาทีแผนภาพแสดง 10 เฟรมต่อวินาที ปรับปรุง – ใช้เวลา render รอบ 100ms ซึ่งหมายความว่า ทุกสิบวินาทีที่เปลี่ยนรูป 10 เฟรมต่อวินาทีแต่สถานการณ์ข้างต้นหมายความ ว่า วงจรปรับปรุงให้ผลลัพธ์การดำเนินการใน 1/10 ของเวลาพักสอง ที่จะรับตำแหน่งหน้าที่ และเราไม่สามารถควบคุมจริงเวลารอบดำเนินการ หรือเราสามารถ เกิดอะไรขึ้นถ้าเรามี 200 ศัตรูและศัตรูทุกยิงที่เรา เราจำเป็นต้องปรับปรุงสถานะของศัตรูแต่ละและสถานะของสัญลักษณ์ของพวกเขา และตรวจสอบไม่เกิดการชนในหนึ่งเดียวเด มันจะแตกต่างกันเมื่อเรามีศัตรูเพียง 2 เวลาจะแตกต่างกันอย่างชัดเจน เดียวกันใช้วิธีสร้างภาพ Droids ยิง 200 แสดงผลชัดเจนจะใช้เวลามากขึ้นกว่า 2 เท่าแสดงดังนั้น มีสถานการณ์อย่างไร เรามีรอบการปรับปรุงให้ผลลัพธ์ที่เสร็จสิ้นในน้อยกว่า 100ms (1/10 ของหนึ่งวินาที), เสร็จสิ้นในว่า 100ms หรือเสร็จสิ้นในมากกว่านั้นได้ ฮาร์ดแวร์ที่มีประสิทธิภาพ มันจะเร็วกว่าบนแข็งแกร่ง ลองดูไดอะแกรมรอบเสร็จสิ้นก่อนเวลาที่ระบุเพื่อให้เรามีเวลาว่างก่อนที่จะรันหน้าน้อย กรอบเวลาว่างแผนภาพแสดงวัฏจักรซึ่งอยู่เบื้องหลัง ซึ่งหมายความ ว่า เวลาใช้ในวงจรปรับปรุงให้ผลลัพธ์เสร็จสิ้นต้องมากกว่า ถ้าใช้ 12ms นั่นหมายความว่า เราเป็น 2ms หลัง (ยังคงพิจารณา 10 เฟรมต่อวินาที) นี้สามารถกำหนดค่า และทุกวงจรเราหลวมเวลาและเกมจะทำงานช้า เฟรมเลยสถานการณ์แรกคือ ต้อง นี้ทำให้เราเวลาจะทำอะไรก่อนเราทิปหน้าฟรี เราไม่ต้องทำอะไรเพื่อเราเพียงบอกลูปเกมไปสำหรับรอบระยะเวลาที่เหลือนอน และตื่นเมื่อครบกำหนดรอบถัดไป ถ้าเราไม่ทำ เกมจะทำงานเร็วกว่าไว้ โดยการแนะนำเวลานอน เราได้อัตราเฟรมคงสถานการณ์ที่สอง (ผมข้ามหนึ่งเหมาะเป็นมันเกือบจะไม่เกิดขึ้น) เมื่อลูปหลัง จำเป็นต้องใช้วิธีที่แตกต่างกันเราต้องการปรับปรุงสถานะของวัตถุของเราเมื่อต้องบรรลุความเร็วคงที่ในเกม จินตนาการ droid ที่ใกล้คุณที่ความเร็วคง คุณรู้ว่าถ้าจะเผื่อเวลาหน้าจอครึ่งในหนึ่งวินาที ดังนั้นมันจะใช้เวลาอีกสองถึงด้านอื่น ๆ ของหน้าจอ ในการคำนวณตำแหน่งได้อย่างถูกต้อง เราจำเป็นต้องรู้เดลต้าการเวลากที่ตำแหน่งสุดท้าย และความเร็วปัจจุบันของ droid หรือเราปรับปรุงตำแหน่ง (สถานะ) ของ droid ที่ในช่วงเวลาคง ฉันจะเลือกคนที่สองเป็นการเล่นกับ deltas ในการปรับปรุงเกมสามารถหากิน เพื่อให้ได้ความเร็วคงในเกม เราจะต้องข้ามเฟรมแสดง เกมความรวดเร็วไม่ใช่ FPSตรวจสอบแผนภาพต่อไปนี้ ซึ่งวงจรการปรับปรุงให้ผลลัพธ์ใช้เวลานานกว่าเวลาที่ระบุดังนั้นเราต้องทันสถานการณ์ได้ ไม่ว่า เราจะข้ามการแสดงผลของเฟรมนี้ และจะทำ อีกปรับปรุงเพื่อความเร็วในเกมจะไม่ได้รับผลกระทบ เราจะทำรอบปกติในเฟรมถัดไปแม้บางเวลาจะให้ CPU ที่เหลือ ความเร็วเกมคงที่กับตัวแปร FPSสถานการณ์ดังกล่าวมีหลายรูปแบบ คุณสามารถจินตนาการปรับปรุงเกมที่ถ่ายเต็มเฟรมมากกว่าหนึ่ง ในกรณีนี้ เราสามารถทำอะไรเพื่อให้คงความเร็วเกม และเกมจะทำงานช้าลง เราอาจต้องข้ามสิ่งจำลองหลายให้ consta ความเร็ว

ผลลัพธ์ (ไทย) 2:

เกมพื้นฐานสถาปัตยกรรมแผนภาพต่อไปนี้แสดงถึงสถาปัตยกรรมเกมในรูปแบบดังกล่าวข้างต้นที่คุณเห็น OS Android ที่ทำงานบนโทรศัพท์และทุกอย่างด้านบนของที่ใส่เป็นหน้าจอสัมผัสในกรณีของเรา แต่มันอาจเป็นแป้นพิมพ์กายภาพถ้า โทรศัพท์ที่มีหนึ่ง, ไมโครโฟน, กล้อง, accelerometers หรือแม้กระทั่งการรับสัญญาณจีพีเอสถ้าติดตั้ง กรอบ exposes เหตุการณ์ที่เกิดขึ้นเมื่อการสัมผัสหน้าจอผู้ใช้ป้อนในเกมของเรานี้เป็นเหตุการณ์ที่เกิดจากการสัมผัสหน้าจอในหนึ่งในการกำหนดกลไก 2 ควบคุมเกม areas.Our ตรวจสอบเหตุการณ์ ontouch และในทุกสัมผัสที่เราบันทึกพิกัด ถ้าพิกัดอยู่ในพื้นที่ควบคุมของเรากำหนดไว้บนหน้าจอที่เราจะสั่งให้เครื่องยนต์เกมที่จะดำเนินการ ตัวอย่างเช่นถ้าสัมผัสเกิดขึ้นในวงกลมที่กำหนดจะย้ายคนของเราเครื่องยนต์ที่ได้รับการแจ้งเตือนและผู้ชายของเราได้รับคำสั่งให้ move.If วงกลมควบคุมอาวุธสัมผัสอาวุธที่ติดตั้งจะได้รับคำแนะนำที่จะยิงกระสุนของ ทั้งหมดนี้หมายถึงการเปลี่ยนสถานะของนักแสดงที่ได้รับผลกระทบจากท่าทางของเราหรือที่รู้จักใส่เกมลอจิกโมดูลตรรกะเกมเป็นผู้รับผิดชอบสำหรับการเปลี่ยนสถานะของนักแสดงในเกม โดยนักแสดงที่ผมหมายถึงวัตถุที่มีรัฐทุก พระเอกหุ่นภูมิประเทศกระสุนลำแสงเลเซอร์ของเรา ฯลฯ ตัวอย่างเช่นที่เราสัมผัสครึ่งบนของพื้นที่ควบคุมฮีโร่เหมือนในการวาดภาพและแปลนี้ไปคำนวณความเร็วในการเคลื่อนที่ของคนเราตามตำแหน่งของตัวควบคุมการเคลื่อนไหวของเรา ( นิ้วมือของเรา) ในภาพด้านบนวงกลมสีเขียวอ่อนหมายถึงนิ้วมือของเราสัมผัสพื้นที่ควบคุม โมดูลที่ผู้ใช้ป้อนแจ้งเครื่องยนต์เกม (เกมลอจิก) และนอกจากนี้ยังมีพิกัด DX และดี้มีระยะทางในพิกเซลเมื่อเทียบกับศูนย์ควบคุมวงกลม เกมเครื่องยนต์คำนวณความเร็วใหม่ก็มีการตั้งค่าสำหรับพระเอกของเราและทิศทางที่เขาจะย้ายไป ถ้า DX เป็นบวกนั่นหมายความว่าเขาจะไปขวาและถ้าดี้เป็นบวกเขาก็จะย้ายไปขึ้นเครื่องเสียงโมดูลนี้จะผลิตเสียงที่พิจารณาสถานะปัจจุบัน เป็นเกือบทุกดารา / นักแสดงวัตถุจะผลิตเสียงในรัฐที่แตกต่างกันของพวกเขาและเนื่องจากอุปกรณ์ที่เราจะใช้ในเกมของเราจะถูก จำกัด ให้เพียงไม่กี่ช่องทาง (นั่นหมายความว่าสั้น ๆ ว่าหลายเสียงที่สามารถเล่นอุปกรณ์ในครั้งเดียว) ก็มีการตัดสินใจที่ เสียงที่จะเล่น ตัวอย่างเช่นหุ่นยนต์วางตัวเป็นภัยคุกคามที่ใหญ่ที่สุดในพระเอกของเราจะได้ยินในขณะที่เราต้องการที่จะดึงความสนใจไปและแน่นอนว่าเราจะต้องมีการสำรองช่องสำหรับเสียงในการถ่ายภาพที่น่ากลัวของอาวุธของเรามันคือความสนุกมากฟังร้องเพลงปืนของเรา . ดังนั้นนี่คือเสียงสั้นกราฟิกนี้โมดูลที่มีความรับผิดชอบสำหรับการแสดงผลรัฐเกมบนจอแสดงผล นี้สามารถจะเป็นง่ายๆเป็นภาพวาดโดยตรงลงบนผืนผ้าใบได้จากมุมมองหรือมีบัฟเฟอร์กราฟิกแยกต่างหากดึงเข้ามาในและส่งผ่านไปยังมุมมองซึ่งอาจจะเป็นมุมมองที่กำหนดเองหรือมุมมอง OpenGL แล้วเราวัดการแสดงผลในแนว FPS ซึ่งย่อมาจากเฟรม ต่อวินาที ถ้าเรามี 30 เฟรมซึ่งหมายความว่าเราจะแสดง 30 ภาพทุกวินาที สำหรับอุปกรณ์เคลื่อนที่ 30 FPS ที่ดีมากดังนั้นเราจะมีจุดมุ่งหมายเพื่อที่สิ่งเดียวที่คุณต้องการที่จะรู้ว่าตอนนี้ที่เรียบเนียนภาพเคลื่อนไหวที่สูงกว่า FPS แค่คิดคนเดินและปิดตาของคุณสำหรับสิ่งหนึ่งที่สอง หลังจากที่เปิดตาของคุณคุณจะเห็นคนที่อยู่ในตำแหน่งหลังที่สอง นี้เป็น 2fps ดูพวกเขาเดินไป แต่การรักษาดวงตาของคุณเปิดและคุณจะเห็นการเคลื่อนไหวของเหลว นี้รับประกันได้ว่าจะไม่ต่ำกว่า 30 เฟรม แต่ก็มีแนวโน้มที่จะขึ้นอยู่ในสายตาของคุณ หากคุณมีตัวรับที่น่ากลัวอยู่ในสภาพที่เก่าแก่นี้อาจจะ 80-100 หรือมากกว่าเอาท์พุทเอาท์พุทเป็นผลมาจากทั้งเสียงและภาพและการสั่นสะเทือนอาจจะถ้าเราตัดสินใจที่จะผลิตบางขั้นพื้นฐานเกมห่วงตามแบบเพื่อให้ห่างไกลคุณเรามี ความเข้าใจของสถาปัตยกรรมเกม แม้เพียงชั่วครู่ แต่เรารู้ว่าเราต้องการที่จะใช้ใส่ในบางรูปแบบการปรับปรุงสถานะภายในของเกมและในที่สุดก็ทำให้มันไปที่หน้าจอและยังผลิตเสียงบางและ / หรือการสั่นสะเทือน ตอนนี้เราจะไปพูดคุยและใช้ห่วงเกมขั้นพื้นฐานเราจัดการการป้อนข้อมูลอัปเดตสถานะของวัตถุภายในของเราและทำให้สถานะปัจจุบัน Update และ Render จะถูกจัดกลุ่มเหตุผล พวกเขามีการเชื่อมโยงเข้าด้วยกันและมีแนวโน้มที่จะดำเนินการอย่างใดอย่างหนึ่งหลังจากที่อื่น ๆอะไรใน Android ที่เกิดขึ้นภายในงาน กิจกรรมจะสร้างดู ดูเป็นที่ที่ทุกอย่างเกิดขึ้น มันเป็นที่ที่สัมผัสจะเกิดขึ้นและภาพที่เกิดได้รับการแสดง คิดเป็นตารางกิจกรรมที่ถือแผ่นกระดาษ (ดู) ทำให้เราสามารถวาดภาพอะไร เราจะใช้ดินสอของเราที่จะวาดอะไรบางอย่างลงบนกระดาษ ที่จะได้รับการสัมผัสของเราและทางเคมีที่เกิดขึ้นจริงที่เกิดขึ้นบนกระดาษเพื่อให้ผลของการทำงานร่วมกันของเรากับมุมมองสร้างภาพ เช่นเดียวกับกิจกรรมและดู สิ่งที่ต้องการแผนภาพต่อไปนี้วงเป็นเกมที่การเต้นของหัวใจของทุกเกม เราใช้พื้นฐานมากเพื่อให้ห่างไกลโดยไม่มีการควบคุมใด ๆ วิธีที่รวดเร็วหรือช้าเราปรับปรุงรัฐเกมของเราและที่เฟรมที่จะทำให้เพื่อย้ำห่วงเกมพื้นฐานที่สุดคือห่วงขณะที่ช่วยให้คำแนะนำการดำเนินงานบางส่วนจนกว่าเราจะส่งสัญญาณจนเสร็จสมบูรณ์ มักจะโดยการตั้งค่าตัวแปรที่เรียกว่าทำงานเป็นเท็จรหัสข้างต้นทำงานสุ่มสี่สุ่มห้าโดยไม่ต้องดูแลสำหรับระยะเวลาและทรัพยากร หากคุณมีอุปกรณ์อย่างรวดเร็วแล้วมันจะทำงานได้อย่างรวดเร็วมากและถ้าคุณมีหนึ่งช้าก็จะทำงานช้าลงupdateGameState () การปรับปรุงสถานะของวัตถุในเกมและ displayGameState (ทุก) ทำให้วัตถุที่เป็นภาพซึ่งเป็น ปรากฏบนหน้าจอมีสองสิ่งที่เราควรพิจารณาที่นี่คือ FPS และ UPS FPS - เฟรมต่อวินาที - จำนวนครั้งที่ displayGameState () จะถูกเรียกว่าต่อวินาทียูพีเอส - ปรับปรุงต่อวินาที - จำนวนครั้งที่ updateGameState () จะถูกเรียกว่าต่อวินาทีจะเป็นการดีที่การปรับปรุงและแสดงวิธีการจะถูกเรียกหมายเลขเดียวกันของครั้งต่อวินาที (ยิ่งไม่น้อยกว่า 20-25 ครั้งต่อวินาที) 25 FPS มักจะเพียงพอในโทรศัพท์เพื่อให้มนุษย์เราจะไม่เห็นภาพเคลื่อนไหวที่มีการชะลอตัวเช่นถ้าเรากำหนดเป้าหมาย 25 FPS แล้วมันหมายความว่าเราต้องเรียก displayGameState () วิธีการทุก 40ms (1000-1025 = 40ms, 1000ms = 1s) เราต้องจำไว้ว่า updateGameState () จะเรียกว่าก่อนที่จะวิธีการแสดงและสำหรับพวกเราที่จะไปถึง 25 FPS, เราจะต้องทำให้แน่ใจว่าการปรับปรุง - ลำดับการแสดงผลดำเนินการในตรง 40ms ถ้าจะใช้เวลาน้อยกว่า 40ms แล้วเรามี FPS ที่สูงขึ้น ถ้าจะใช้เวลามากขึ้นกว่าที่แล้วเรามีเกมวิ่งช้าลองมาดูตัวอย่างบางส่วนที่จะเข้าใจ FPS ที่ดีกว่าแผนภาพต่อไปนี้แสดงให้เห็นว่า 1 FPS มันต้องใช้การปรับปรุง - ทำให้วงจรตรงหนึ่งที่สองที่จะดำเนินการ ซึ่งหมายความว่าคุณจะเห็นภาพบนหน้าจอการเปลี่ยนแปลงทุกวินาที1 เฟรมต่อวินาทีแผนภาพต่อไปนี้แสดงให้เห็นถึง 10fps ปรับปรุง - ทำให้รอบใช้เวลา 100 มิลลิวินาที ซึ่งหมายความว่าหนึ่งในสิบของที่สองภาพที่เปลี่ยนแปลงทุก10 FPS แต่สถานการณ์ข้างต้นหมายความว่ารอบการปรับปรุงการแสดงผลดำเนินการใน 1/10 วินาทีทุกเวลา นั่นคือสมมติฐานและเราไม่สามารถควบคุมเวลาที่เกิดขึ้นจริงในการรันรอบหรือเราสามารถ? จะเกิดอะไรขึ้นถ้าเรามี 200 ศัตรูและศัตรูทุกคนจะยิงเรา? เราจำเป็นต้องปรับปรุงสถานะของศัตรูแต่ละรัฐและกระสุนของพวกเขาและตรวจสอบการชนกันในการปรับปรุงเดียว มันเป็นเรื่องที่แตกต่างกันเมื่อเรามีเพียง 2 ศัตรู ครั้งจะแตกต่างกันอย่างเห็นได้ชัด เช่นเดียวกับวิธีการทำให้ การแสดงผล 200 หุ่นยิงอย่างชัดเจนจะใช้เวลามากขึ้นกว่าการแสดงผลเพียง 2 ดังนั้นสิ่งที่เป็นสถานการณ์หรือไม่ เราจะได้มีรอบการปรับปรุงการแสดงผลที่เสร็จสิ้นในเวลาน้อยกว่า 100 มิลลิวินาที (1/10 ของวินาที) เสร็จสิ้นในตรง 100ms หรือเสร็จสิ้นในกว่าที่ บนฮาร์ดแวร์ที่มีประสิทธิภาพมันจะเร็วกว่าที่หนึ่งที่อ่อนแอ ลองมาดูแผนภาพวงจรเสร็จสิ้นก่อนที่จะมีระยะเวลาที่ต้องการเพื่อให้เรามีจำนวนน้อยเวลาว่างก่อนที่จะใช้รอบต่อกรอบเวลาว่างแผนภาพต่อไปนี้แสดงให้เห็นวงจรซึ่งตกอยู่ข้างหลัง นั่นหมายความว่าเวลาที่ใช้สำหรับรอบการปรับปรุงการแสดงผลจะเสร็จสิ้นมากกว่าหนึ่งที่ต้องการ ถ้าจะใช้เวลา 12ms นั่นหมายความว่าเรามี 2 มิลลิวินาทีหลัง (ยังคงพิจารณา 10fps) นี้สามารถบินขึ้นและทุกรอบที่เราสูญเสียเวลาและเกมจะทำงานช้าเกินกำหนดกรอบสถานการณ์แรกคือหนึ่งที่ต้องการ นี้จะช่วยให้เรามีเวลาว่างที่จะทำอะไรบางอย่างก่อนที่เราจะเริ่มเปิดฉากในรอบถัดไป เราไม่จำเป็นต้องทำอะไรเพื่อให้เราเพียงแค่บอกห่วงเกมที่จะไปนอนสำหรับช่วงเวลาที่เหลืออยู่และตื่นขึ้นมาในขณะที่รอบต่อไปคือเนื่องจาก ถ้าเราจะไม่ทำเกมนี้จะทำงานได้เร็วกว่าที่ตั้งใจไว้ โดยการแนะนำเวลานอนเราประสบความสำเร็จอัตราเฟรมคงที่สถานการณ์ที่สอง (ฉันข้ามหนึ่งเหมาะเป็นมันแทบจะไม่เคยเกิดขึ้น) เมื่อห่วงอยู่ข้างหลังต้องใช้วิธีการที่แตกต่างกันเพื่อให้บรรลุความเร็วคงที่ในเกมที่เราจำเป็นต้องปรับปรุงสภาพ ของวัตถุของเราเมื่อจำเป็น ลองนึกภาพหุ่นยนต์ใกล้คุณที่ความเร็วคงที่ คุณจะรู้ว่าถ้ามันจะเดินทางไปครึ่งหน้าจอในหนึ่งวินาทีจึงจะใช้เวลาอีกสองที่จะไปถึงด้านอื่น ๆ ของหน้าจอ ในการคำนวณตำแหน่งที่ถูกต้องเราต้องรู้ทั้งเดลต้าเวลาตั้งแต่ตำแหน่งของที่ผ่านมาและปัจจุบันความเร็วของหุ่นยนต์หรือเราอัปเดตสถานะ (สถานะ) ของหุ่นยนต์ในช่วงเวลาคงที่ ผมจะเลือกคนที่สองเป็นเล่นกับสันดอนในการปรับปรุงเกมสามารถหากิน เพื่อให้บรรลุความเร็วของเกมอย่างต่อเนื่องเราจะต้องข้ามเฟรมแสดง ความเร็วของเกมไม่ FPS! ตรวจสอบแผนภาพต่อไปนี้ มันเป็นสถานการณ์ที่วงจรการปรับปรุงทำให้ใช้เวลานานกว่าเวลาที่ต้องการเพื่อให้เรามีที่จะจับขึ้น จะทำอย่างไรที่เราจะข้ามไปแสดงผลของกรอบนี้และจะทำปรับปรุงอื่นดังนั้นความเร็วเกมจะไม่ได้รับผลกระทบ เราจะทำรอบปกติในกรอบถัดไปที่มีแม้กระทั่งเวลาที่จะให้กับ CPU ที่เหลือเกมความเร็วคงที่กับตัวแปร FPS สถานการณ์ข้างต้นมีหลายรูปแบบ คุณสามารถจินตนาการการปรับปรุงเกมการมากกว่าหนึ่งแบบเต็มกรอบ ในกรณีนี้เราไม่สามารถทำอะไรที่จะทำให้ความเร็วของเกมอย่างต่อเนื่องและเกมจะทำงานช้าลง เราอาจจะมีที่จะข้ามเค้าหลายเพื่อให้ consta ความเร็ว

ผลลัพธ์ (ไทย) 3:

พื้นฐานสถาปัตยกรรมเกม

แผนภาพต่อไปนี้แสดงถึงสถาปัตยกรรมเกม

ใน Schema ข้างต้นคุณจะเห็น OS Android ทำงานบนโทรศัพท์มือถือและทุกอย่างที่อยู่บน เป็นหน้าจอสัมผัส
นำเข้าในกรณีของเรา แต่มันสามารถเป็นแป้นพิมพ์กายภาพ ถ้าโทรศัพท์มี ไมโครโฟน กล้อง โดย accelerometers หรือแม้แต่ตัวรับสัญญาณ GPS ถ้าพร้อมกรอบแสดงเหตุการณ์เมื่อสัมผัสหน้าจอ ผู้ใช้ป้อนข้อมูล

ในเกมของเรา นี้เป็นเหตุการณ์ที่สร้างขึ้นโดยการสัมผัสหน้าจอที่ 2 กำหนดพื้นที่ควบคุม เครื่องยนต์เกมของเราตรวจสอบ ontouch เหตุการณ์ และในทุกสัมผัสเราบันทึกพิกัด ถ้าพิกัดภายในของเรากำหนดควบคุมพื้นที่บนหน้าจอเราก็จะสั่งให้เครื่องยนต์เกมเพื่อดำเนินการตัวอย่างเช่นถ้าสัมผัสเกิดขึ้นในวงเขตย้ายคนของเราเครื่องยนต์ได้รับแจ้งและคนของเราถูกสั่งให้ย้าย ถ้าอาวุธควบคุมเวทย์ได้ติดตั้งอาวุธจะถูกสั่งให้ยิงกระสุนของมัน ทั้งหมดนี้แปลเปลี่ยนนักแสดง ' ระบุว่า ได้รับผลกระทบ โดยการป้อนข้อมูลหรือท่าทางของเรา



เกมตรรกะเกมตรรกะโมดูลจะรับผิดชอบเปลี่ยนสถานะของผู้แสดงในเกม โดยนักแสดงที่ฉันหมายถึงทุกวัตถุที่มีรัฐ ฮีโร่ , Droids , ภูมิประเทศ , กระสุนแสงเลเซอร์ เป็นต้น ตัวอย่างเช่น เราสัมผัสครึ่งบนของพื้นที่ควบคุมฮีโร่เหมือนในรูปวาดและนี้แปลว่า :คำนวณความเร็วในการเคลื่อนที่ของคนของเราตามตำแหน่งของตัวควบคุมการเคลื่อนไหวของเรา ( นิ้ว ) .

ในรูปข้างบนวงกลมสีเขียวอ่อนแทนนิ้วเราสัมผัสควบคุมพื้นที่ ผู้ใช้ใส่โมดูลแจ้งเครื่องยนต์เกม ( เกมตรรกะ ) และยังมีพิกัด DX และดี้มีระยะทางในพิกเซลเมื่อเทียบกับตัวควบคุมวงกลมกลางเครื่องยนต์เกมคำนวณใหม่ความเร็วมันต้องตั้งค่าสำหรับพระเอกของเรา และทิศทางที่เขาจะย้าย ถ้า DX เป็นบวก หมายความว่า เขาจะไปทางขวา และถ้าดี้เป็นบวก เขาจะยังขยับขึ้น

.
เสียงโมดูลนี้จะผลิตเสียงพิจารณาสถานะปัจจุบันเป็นเกือบทุกนักแสดง / วัตถุจะผลิตเสียงในรัฐต่าง ๆ ของพวกเขา และเนื่องจากอุปกรณ์ที่เราจะใช้เกมของเราจะ จำกัด อยู่เพียงไม่กี่ช่อง ( แปลว่า สั้นกี่เสียงสามารถอุปกรณ์เล่นครั้งเดียว ) ได้ตัดสินใจที่เสียงเล่นตัวอย่างเช่น Droid วางตัวภัยคุกคามที่ใหญ่ที่สุดเพื่อฮีโร่ของเราจะได้ยินในขณะที่เราต้องการที่จะดึงความสนใจไป และแน่นอนว่าเราจะต้องจองช่องทางเสียงน่ากลัวยิงอาวุธของเรามันสนุกฟัง Blaster ร้องเพลงของเรา นี่เป็นเสียงสั้น กราฟิก


นี้เป็นโมดูลที่รับผิดชอบแสดงเกมสถานะบนจอแสดงผลนี้สามารถเป็นง่ายๆเป็นภาพวาดโดยตรงลงบนผืนผ้าใบที่ได้รับจากมุมมองหรือมีบัฟเฟอร์กราฟิกแยกวาดเป็นแล้วส่งผ่านไปยังมุมมองซึ่งสามารถเป็นมุมมองหรือมุมมอง OpenGL .
เราวัดการแสดงผลในเฟรม ซึ่งย่อมาจาก เฟรมต่อวินาที ถ้าเรามีการหมายความว่าเราแสดงภาพทุกๆ 30 วินาทีสำหรับอุปกรณ์เคลื่อนที่ 30 fps เป็นที่ดีดังนั้นเราจึงมุ่งมั่นที่
สิ่งเดียวที่คุณต้องการรู้ตอนนี้สูงกว่า FPS เรียบภาพเคลื่อนไหว แค่คิดว่าคนเดินและหลับตา แค่หนึ่งวินาที หลังจากที่เปิดตาของคุณ คุณจะเห็นคนที่อยู่ในตำแหน่งหลังหนึ่งวินาที นี้เป็น 2fps . ดูพวกเขาเดิน แต่การรักษาดวงตาของคุณเปิดและคุณจะเห็นการเคลื่อนที่ของของไหลนี้จะรับประกันจะเป็นขั้นต่ำของการ แต่มันก็น่าจะมากขึ้น ทั้งนี้ขึ้นอยู่กับดวงตาของคุณ หากคุณมีตัวรับที่น่ากลัวอยู่ในสภาพเดิมได้ 80-100 หรือมากกว่า

ผลผลผลิตคือผลทั้งเสียงและภาพอาจจะสั่น ถ้าเราตัดสินใจที่จะ ผลิต บาง ห่วงเกม


พื้นฐานดังต่อไปนี้ชุดเพื่อให้ห่างไกลคุณมีความเข้าใจในสถาปัตยกรรมของเกมแล้วแม้ว่าสั้น ๆ เพียงแต่เรารู้ว่าเราต้องการที่จะใส่ในบางรูปแบบ ปรับปรุงสภาพภายในของเกมและในที่สุดให้กับหน้าจอและผลิตเสียงและ / หรือการสั่นสะเทือน ตอนนี้ เรากำลังจะหารือเกี่ยวกับการใช้ ห่วงเกมขั้นพื้นฐาน

เราจัดการข้อมูลอัปเดตสถานะของวัตถุภายในของเราและแสดงสถานะปัจจุบัน ปรับปรุงและให้มีการจัดกลุ่มตรรกะ .พวกเขาถูกผูกไว้ด้วยกันและมีแนวโน้มที่จะดำเนินการหนึ่งหลังจากที่อื่น ๆ .
อะไรใน Android เกิดขึ้นภายในกิจกรรม กิจกรรมจะสร้างมุมมอง เป็นวิวที่ทุกอย่างเกิดขึ้น มันเป็นที่ที่สัมผัสใช้เวลาสถานที่และภาพที่เกิดจะแสดง คิดถึงกิจกรรมที่เป็นตารางที่ถือแผ่นกระดาษ ( มุมมอง ) ช่วยให้เราสามารถวาดอะไรบางอย่างเราจะใช้ดินสอของเรา วาดรูปบนกระดาษ ที่จะสัมผัสและเคมีจริงเกิดขึ้นบนกระดาษดังนั้นผลของปฏิสัมพันธ์ของเรากับมุมมองสร้างภาพ เดียวกันกับดูกิจกรรมและ บางอย่าง เช่น แผนภาพต่อไปนี้ :

ห่วงเกมเป็นหัวใจของทุกเกมเราใช้มากเป็นพื้นฐานหนึ่งเพื่อให้ห่างไกล โดยไม่ต้องควบคุมว่าช้าหรือเร็ว เราอัพเดทสถานะเกมของเรา และเฟรมที่แสดง .
สรุปแล้วเกมที่เป็นพื้นฐานที่สุด ห่วงคือ ในขณะที่วงที่ช่วยดำเนินการขั้นตอนจนกว่าจะสัญญาณมันเสร็จ ปกติ โดยการตั้งค่าตัวแปรที่เรียกว่าเท็จ

วิ่ง โค้ดด้านบนจะสุ่มสี่สุ่มห้า โดยไม่สนใจเวลา และทรัพยากร