Choosing a system “tick” should be

Choosing a system “tick” should be done with care. If
it happens too often, then system cannot keep up. If it
does not happen often enough, then the program has poor
response. This program uses a system “tick” that occurs 20
times per second.
The line below sets up the function Tick as an interval,
and the parameter 50 means that it will run every 50 mil-
liseconds. Assigning it to the variable intFn allows us to
deactivate the interval later. This line is adapted from an
example given in reference [4].
intFn = self.setInterval("Tick()", 50);
Though this interval is not deactivated, the program does
use, and later deactivate, another interval function for checking
to see if everything is ready. When the web-page loads,
a “splash screen” appears with basic instructions on game
play. There are many files to load, and some of them can be
quite large. For example, the graphic containing the tiles is
over 102 KB, the default maze’s XML file is over 130 KB,
and the game engine file is 170 KB. So an interval function
checks to see if everything is ready, and instructs the user
to press a key to start. The program then deactivates that
interval function, and sets up the Tick function, as shown
above.
While exhaustive runs have not been done, running the
program on an Apple Macintosh with a Intel Core 2 Duo
processor at 2.16 GHz, using FireFox as the web-browser,
produces an average time of under 2 ms for the Tick function.
For one sample run of this game, the Tick function
was called 5541 times, for a total time of 8426 ms, and an
average 1.52 ms per call. The best time is 0 ms (too small to
register), and the worst time is 21 ms. Since the computer
calls the Tick function every 50 ms, the worst case is not a
problem.
Data storage is done in the eXtensible Markup Language
(XML). JavaScript supports reading and parsing XML files.
While more verbose than a “flat-file” containing only the
data, and thus producing larger files, it is standard, flexible,
and self-documenting. It is possible to change it with a text
editor, though using a program to edit it ensures that it will
be correctly formatted. A missing less-than or greater-than
sign can cause a non-obvious problem.
For now, the weapons must be defined in the XML file in
the same order as shown in the tiles. In the future, including
a tile number with object’s XML definition would allow this
weapons to be in any order.
The basic structure of the data file contain the dimensions
of the world (how many rooms), the dimensions of
each “room” (how many rows and columns of tiles), where
the player starts (both the room number and the X and
Y coordinates within the room), the definition of the player
object, definitions of projectile objects (rock, arrow, large arrow,
etc.), definitions of weapon objects (in order, according
to their tile), the definition of a room (an array of integers,
each corresponding to a tile), a boolean flag for whether the
room is “dark” (whether the contents are visible upon entry,
or if the player’s character must come close to reveal tiles),
and definitions of monster objects (up to 10 per room). This
repeats for next room, starting with the room definition.
The game engine relies on the data files to be populated
correctly. A bad data file may result in unexpected game
play. For example, the rooms “wrap around” if the player
is allowed to go off screen. Normally, if the player exits a
room, say by going north, the next room that appears is the
one defined by the (roomRow-1, roomColumn). These map to
an array index of tile data. If roomRow - 1 is negative, the
game engine automatically corrects this to MAXroomRow - 1,
the room in the last row of that column. In other words, if
the room data does not present obstacles to keep the player
from going off the edge, the game engine will simply wrap
the location around to the opposite side.

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

เลือกระบบ "ขีด" ควรจะทำกับการดูแล หากมันเกิดขึ้นบ่อยเกินไป แล้วระบบไม่ทัน ถ้ามันไม่เกิดขึ้นบ่อยพอ แล้วโปรแกรมได้ยากตอบสนอง โปรแกรมนี้ใช้ระบบ "ขีด" ที่เกิดขึ้น 20ครั้งต่อวินาทีตั้งค่าฟังก์ชันขีดบรรทัดด้านล่างเป็นช่วงและพารามิเตอร์ 50 หมายความ ว่า มันจะรันทุก 50 ล้าน-liseconds กำหนดให้ intFn ตัวแปรให้เราปิดช่วงเวลาในภายหลัง บรรทัดนี้จะปรับจากการตัวอย่างที่ใช้ในการอ้างอิง [4]intFn = self.setInterval("Tick() ", 50);แม้ว่าช่วงนี้ไม่ถูกปิดใช้งาน โปรแกรมไม่ใช้ และภายหลังการปิดใช้ งาน ฟังก์ชันช่วงอื่นสำหรับการตรวจสอบเมื่อต้องการดูถ้าทุกอย่างพร้อม เมื่อหน้าเว็บโหลด"หน้าจอสแปลช" ปรากฏขึ้นพร้อมคำแนะนำพื้นฐานเกี่ยวกับเกมเล่น มีแฟ้มมากโหลด และบางส่วนของพวกเขาได้ค่อนข้างใหญ่ ตัวอย่าง กราฟิกที่ประกอบด้วยกระเบื้องอยู่กว่า 102 KB แฟ้ม XML ของเขาวงกตเริ่มต้นมีกว่า 130 KBและไฟล์โปรแกรมเกม 170 KB ดังนั้นฟังก์ชันการช่วงตรวจสอบเพื่อดูถ้าทุกอย่างพร้อมแล้ว และแนะนำให้ผู้ใช้ให้กดแป้นใด ๆ เพื่อเริ่มต้น โปรแกรมแล้วหลาย ๆ ที่ช่วงฟังก์ชัน และการตั้งค่าฟังก์ชันขีด แสดงข้างต้นในขณะทำงานหมดแรงไม่ได้ ทำงานโปรแกรมบนการแอปเปิ้ลแมคอินทอด้วยเป็น Intel Core 2 Duoตัวประมวลผลที่ 2.16 GHz ใช้ FireFox เป็นเว็บเบราว์เซอร์ทำให้เกิดการเฉลี่ยเวลาต่ำกว่า 2 ms สำหรับฟังก์ชันขีดสำหรับการรันตัวอย่างหนึ่งของเกมนี้ ฟังก์ชันขีดเรียก 5541 ครั้ง เวลารวมของ 8426 ms และms 1.52 เฉลี่ยต่อโทร เวลาดีที่สุดคือ 0 ms (เล็กเกินกว่าจะลงทะเบียน), และเวลาเลวร้ายที่สุดคือ นางสาว 21 ตั้งแต่คอมพิวเตอร์เรียกขีดฟังก์ชัน ms ทุก 50 กรณีเลวร้ายที่สุดไม่มีปัญหาดำเนินการจัดเก็บข้อมูลใน eXtensible Markup Language(XML) สนับสนุน JavaScript อ่าน และแยกวิเคราะห์แฟ้ม XMLVerbose ยิ่งกว่า "แบนแฟ้ม" ที่ประกอบด้วยเฉพาะในขณะข้อมูล และการผลิตดังนั้น แฟ้มมีขนาดใหญ่ มีมาตรฐาน ยืดหยุ่นและเอกสารด้วยตนเอง จำเป็นต้องเปลี่ยน ด้วยข้อความแก้ไข แม้ว่า การใช้โปรแกรมเพื่อทำการแก้ไขให้แน่ใจว่า จะจะถูกจัดรูปแบบ ขาดน้อย-กว่า หรือมากกว่า-กว่าเครื่องอาจทำให้เกิดปัญหาไม่ชัดเจนสำหรับตอนนี้ อาวุธต้องกำหนดในแฟ้ม XML ในใบสั่งเดียวกันเป็นการแสดงในกระเบื้อง รวมทั้งในอนาคตไพ่หมายเลข มีข้อกำหนด XML ของวัตถุจะให้อาวุธที่อยู่ในลำดับใดโครงสร้างพื้นฐานของแฟ้มข้อมูลประกอบด้วยขนาดของโลก (กี่ห้อง), มิติของแต่ละ "ห้อง" (จำนวนแถวและคอลัมน์ของกระเบื้อง), ที่เริ่มเล่น (หมายเลขห้องและ X และY พิกัดภายในห้อง), ข้อกำหนดของโปรแกรมเล่นวัตถุ ข้อกำหนดของวัตถุ projectile (หิน ลูกศร ลูก ศรขนาดใหญ่etc.), ข้อกำหนดของวัตถุอาวุธ (ลำดับ ตามต้องการกระเบื้อง), นิยามของห้องพัก (อาร์เรย์ของจำนวนเต็มแต่ละที่สอดคล้องกับไพ่), ค่าสถานะบูลีว่ามี "สีดำ" (ไม่ว่าเนื้อหาจะปรากฏตามรายการหรือถ้าอักขระของเล่นต้องมาปิดเพื่อ เปิดเผยไพ่),และข้อกำหนดของวัตถุของมอนสเตอร์ (สูงถึง 10 ต่อห้อง) นี้ทำซ้ำในห้องถัดไป การเริ่มต้น ด้วยการกำหนดห้องเครื่องเกมอาศัยแฟ้มข้อมูลจะต้องมีเติมถูกต้อง แฟ้มข้อมูลไม่ถูกต้องอาจทำให้เกมที่ไม่คาดคิดเล่น ตัวอย่าง ห้อง "ตัดรอบๆ" ถ้าเล่นได้ไปปิดหน้าจอ โดยปกติ หากผู้เล่นออกเป็นห้อง พูดไปเหนือ ห้องถัดไปนั้นเป็นการหนึ่งกำหนด โดย (roomRow-1, roomColumn) เหล่านี้แมปไปดัชนีแถวลำดับของข้อมูลกระเบื้อง ถ้า roomRow - 1 เป็นค่าลบ การเครื่องเกมลงท้ายนี้จะ MAXroomRow - 1ห้องพักในแถวสุดท้ายของคอลัมน์ ในคำอื่น ๆ ถ้าข้อมูลห้องนำเสนออุปสรรคให้ผู้เล่นจากจะปิดขอบ เครื่องเกมจะแค่ตัดที่ตั้งสถานที่ฝั่งตรงข้าม

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

การเลือกระบบ "ติ๊ก" ควรจะทำด้วยความระมัดระวัง
ถ้ามันเกิดขึ้นบ่อยเกินไปแล้วระบบไม่สามารถให้ทัน ถ้ามันไม่ได้เกิดขึ้นบ่อยมากพอแล้วโปรแกรมที่มีคนยากจนการตอบสนอง โปรแกรมนี้จะใช้ระบบ "เห็บ" ที่เกิดขึ้น 20 ครั้งต่อวินาที. บรรทัดด้านล่างตั้งค่าฟังก์ชั่น Tick เป็นช่วงเวลา, และพารามิเตอร์ 50 หมายความว่ามันจะทำงานทุก 50 mil- liseconds การกำหนดให้ intFn ตัวแปรช่วยให้เราสามารถยกเลิกการใช้งานในช่วงเวลาต่อมา บรรทัดนี้ดัดแปลงมาจากตัวอย่างที่ได้รับในการอ้างอิง [4]. intFn = self.setInterval ("Tick ()", 50); แม้ว่าช่วงนี้ไม่ได้ปิดการใช้งานโปรแกรมที่ไม่ใช้งานและปิดการใช้งานต่อมาอีกฟังก์ชั่นช่วงเวลาสำหรับการตรวจสอบเพื่อดูว่าทุกอย่างพร้อม เมื่อโหลดหน้าเว็บ, เป็น "หน้าจอ" จะปรากฏขึ้นพร้อมกับคำแนะนำพื้นฐานเกี่ยวกับเกมการเล่น มีไฟล์จำนวนมากในการโหลดเป็นและบางส่วนของพวกเขาอาจจะมีขนาดใหญ่มาก ยกตัวอย่างเช่นกราฟิกที่มีกระเบื้องที่มีมากกว่า 102 KB, ไฟล์ XML เขาวงกตเริ่มต้นของที่มีมากกว่า 130 KB, และไฟล์เกมเครื่องยนต์ 170 กิโลไบต์ ดังนั้นช่วงเวลาที่ฟังก์ชั่นการตรวจสอบเพื่อดูว่าทุกอย่างพร้อมและสั่งให้ผู้ใช้ที่จะกดปุ่มเพื่อเริ่มต้น โปรแกรมแล้วยกเลิกที่ฟังก์ชั่นช่วงเวลาและตั้งค่าฟังก์ชั่น Tick ดังที่แสดงข้างต้น. ในขณะที่วิ่งครบถ้วนสมบูรณ์ยังไม่ได้รับการกระทำที่ใช้โปรแกรมบนแอปเปิ้ลแมคอินทอชกับ Duo Intel Core 2 หน่วยประมวลผลที่ 2.16 GHz โดยใช้ FireFox เป็นเว็บ -browser, ผลิตเวลาเฉลี่ยของการอายุต่ำกว่า 2 มิลลิวินาทีสำหรับการทำงาน Tick ได้. สำหรับการทำงานตัวอย่างหนึ่งของเกมนี้ฟังก์ชั่นติ๊กถูกเรียกว่า 5541 ครั้งเป็นเวลารวมทั้งสิ้น 8,426 มิลลิวินาทีและเฉลี่ย1.52 มิลลิวินาทีต่อการโทร เวลาที่ดีที่สุดคือ 0 มิลลิวินาที (เล็กเกินไปที่จะลงทะเบียน) และเวลาที่เลวร้ายที่สุดคือ 21 มิลลิวินาที ตั้งแต่คอมพิวเตอร์เรียก Tick ทำงานทุก 50 มิลลิวินาทีกรณีที่เลวร้ายที่สุดคือไม่ได้เป็นปัญหาที่เกิดขึ้น. การจัดเก็บข้อมูลจะทำใน eXtensible Markup Language (XML) JavaScript สนับสนุนการอ่านและการแยกไฟล์ XML. ในขณะที่ละเอียดมากไปกว่า "แบนไฟล์" ที่มีเพียงข้อมูลและทำให้การผลิตไฟล์ขนาดใหญ่มันเป็นมาตรฐานที่มีความยืดหยุ่นและตนเองdocumenting มันเป็นไปได้ที่จะเปลี่ยนมันด้วยข้อความแก้ไขแต่ใช้โปรแกรมแก้ไขเพื่อให้แน่ใจว่ามันจะมีรูปแบบที่ถูกต้อง หายไปน้อยกว่าหรือมากกว่ากว่าสัญญาณที่สามารถก่อให้เกิดปัญหาที่ไม่ชัดเจน. สำหรับตอนนี้อาวุธจะต้องมีการกำหนดไว้ในไฟล์ XML ในลำดับเดียวกับที่ปรากฏในกระเบื้อง ในอนาคตรวมทั้งจำนวนกระเบื้องที่มีความหมาย XML ของวัตถุจะช่วยให้นี้อาวุธที่จะอยู่ในลำดับใดๆ . โครงสร้างพื้นฐานของแฟ้มข้อมูลมีขนาดของโลก (วิธีการหลายห้อง), ขนาดของแต่ละ"ห้อง" (วิธี หลายแถวและคอลัมน์ของกระเบื้อง) ซึ่งเริ่มเล่น(ทั้งจำนวนห้องพักและ X และY พิกัดภายในห้อง) ความหมายของผู้เล่นวัตถุนิยามของวัตถุกระสุนปืน(หินลูกศรลูกศรขนาดใหญ่ฯลฯ ) คำจำกัดความของอาวุธวัตถุ (ในการสั่งซื้อตามกระเบื้องของพวกเขา) ความหมายของห้อง (อาร์เรย์ของจำนวนเต็ม, แต่ละที่สอดคล้องกับกระเบื้อง) ธงบูลีนสำหรับว่าห้องพักคือ"ความมืด" (ไม่ว่าจะเป็นเนื้อหาที่จะมองเห็น เมื่อรายการหรือถ้าตัวละครของผู้เล่นที่จะต้องเข้ามาใกล้ที่จะเปิดเผยกระเบื้อง) และคำจำกัดความของวัตถุมอนสเตอร์ (ไม่เกิน 10 ต่อห้อง) นี้ซ้ำสำหรับห้องถัดไปเริ่มต้นด้วยคำนิยามห้องพัก. เครื่องยนต์เกมขึ้นอยู่กับไฟล์ข้อมูลที่จะมีประชากรได้อย่างถูกต้อง แฟ้มข้อมูลที่ไม่อาจส่งผลที่ไม่คาดคิดในเกมการเล่น ตัวอย่างเช่นห้องพัก "ห่อรอบ" ถ้าผู้เล่นที่ได้รับอนุญาตที่จะไปปิดหน้าจอ โดยปกติถ้าผู้เล่นออกจากห้องพูดโดยไปทางทิศเหนือห้องถัดไปที่ปรากฏเป็นหนึ่งที่กำหนดโดย(roomRow-1 roomColumn) แผนที่เหล่านี้เพื่อดัชนีอาเรย์ของข้อมูลกระเบื้อง หาก roomRow - 1 เป็นลบเกมเครื่องยนต์จะแก้ไขนี้เพื่อMAXroomRow - 1, ห้องพักในแถวสุดท้ายของคอลัมน์ว่า ในคำอื่น ๆ ถ้าข้อมูลห้องพักไม่ได้เป็นอุปสรรคในปัจจุบันเพื่อให้ผู้เล่นจากไปปิดขอบ, เครื่องยนต์เกมก็จะห่อสถานที่รอบ ๆ ฝั่งตรงข้าม

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

เลือกระบบ " ติ๊ก " ที่ควรกระทำด้วยความระมัดระวัง ถ้า
มันเกิดขึ้นบ่อยเกินไป แล้วระบบไม่สามารถให้ขึ้น ถ้ามัน
ไม่เกิดขึ้นบ่อยมากพอแล้วโปรแกรมมีการตอบสนองไม่ดี

โปรแกรมนี้ใช้ระบบ " ติ๊ก " ที่เกิดขึ้น

20 ครั้งต่อวินาที บรรทัดด้านล่างตั้งค่าฟังก์ชันติ๊กเป็นช่วงเวลา
และพารามิเตอร์ 50 หมายความว่ามันจะวิ่งทุกๆ 50 มิล -
liseconds .กำหนดให้ตัวแปร intfn ช่วยให้เรา

ปิดช่วงทีหลัง บรรทัดนี้ถูกดัดแปลงจาก
ตัวอย่างให้อ้างอิง [ 4 ] .
intfn = ตนเอง setinterval ( " tick() " , 50 ) ;
ถึงแม้ว่าช่วงเวลานี้จะไม่ใช้โปรแกรมจะ
ใช้และต่อมาปิดฟังก์ชันการตรวจสอบ
ช่วงเวลาอื่นดู ถ้าทุกอย่างพร้อม เมื่อหน้าเว็บโหลด
" หน้าจอ " ปรากฏขึ้นพร้อมกับคำแนะนำพื้นฐานในการเล่นเกม

มีหลายไฟล์ที่จะโหลดและบางส่วนของพวกเขาสามารถ
ค่อนข้างใหญ่ ตัวอย่างเช่น กราฟิกที่มีกระเบื้อง
กว่า 102 KB , เริ่มต้นของแฟ้ม XML เป็นเขาวงกต 130 kb
และไฟล์เกมเครื่องยนต์ 170 KB ดังนั้นฟังก์ชัน
ช่วงตรวจสอบเพื่อดูว่าทุกอย่างพร้อมแล้ว และสั่งให้ผู้ใช้
กดคีย์เริ่มต้นโปรแกรมแล้วปิดที่
ช่วงการทำงานและตั้งค่าฟังก์ชั่นติ๊กดัง

ตอนหมดแรงวิ่งข้างบน ไม่ได้ทำ วิ่ง
โปรแกรมบน Macintosh แอปเปิ้ลกับ Intel Core 2 Duo processor
ที่ 2.16 GHz ใช้ Firefox เป็นเว็บเบราเซอร์
ผลิตเวลาเฉลี่ยของการภายใต้ 2 นางสาวสำหรับฟังก์ชันติ๊ก .
สำหรับเรียกใช้ตัวอย่างหนึ่งของเกมนี้ ฟังก์ชันติ๊ก
ถูกเรียกว่าเอเซียครั้ง เป็นระยะเวลารวมของ 8426 MS และ MS
เฉลี่ย 1.52 ต่อโทร ช่วงเวลาที่ดีที่สุดคือ 0 MS ( เล็กเกินไป

ลงทะเบียน ) , และเวลาที่เลวร้ายที่สุดคือ 21 คุณเนื่องจากคอมพิวเตอร์
เรียกฟังก์ชันติ๊กทุก 50 นางสาว กรณีเลวร้ายที่สุดคือไม่ได้

ปัญหา จัดเก็บข้อมูลจะทำใน
extensible Markup Language ( XML ) JavaScript รองรับการอ่านและวิเคราะห์แฟ้ม XML .
ในขณะที่มีมากกว่า " แฟ้มแบน " ที่มีเฉพาะ
ข้อมูล และจึง ผลิตแฟ้ม ขนาดใหญ่ มันเป็นมาตรฐานที่ยืดหยุ่น
และตนเองถ่ายอยู่นะ มันเป็นไปได้ที่จะเปลี่ยนมันด้วยข้อความ
บรรณาธิการ แม้ว่าการใช้โปรแกรมแก้ไขเพื่อให้แน่ใจว่า มันจะ
ถูกจัดรูปแบบอย่างถูกต้อง หายไปน้อยกว่าหรือมากกว่าสัญลักษณ์สามารถทำให้ไม่ชัด

สำหรับตอนนี้ ปัญหาอาวุธจะต้องกำหนดในแฟ้ม XML ใน
ใบสั่งเดียวกันดังที่แสดงในกระเบื้อง ในอนาคต , รวมทั้ง
จำนวนกระเบื้องกับวัตถุนิยามของ XML จะอนุญาต
อาวุธอยู่ในใบสั่งใด ๆ .
พื้นฐาน โครงสร้างของแฟ้มข้อมูลที่ประกอบด้วยมิติ
ของโลก ( กี่ห้อง ) ขนาดของ
แต่ละ " ห้อง " ( วิธีการหลายแถวและคอลัมน์ของกระเบื้อง ) ที่
ผู้เล่นเริ่มต้น ( ทั้งเบอร์ห้องและ x และ y พิกัด
ภายในห้อง ) , ความหมายของผู้เล่น
วัตถุ ความหมายของวัตถุ กระสุนปืน ( หิน , ลูกศร , ลูกศร ,
ฯลฯ ขนาดใหญ่ ) นิยามของวัตถุอาวุธ ( เพื่อตาม
กับกระเบื้องของพวกเขา ) , ความละเอียดของห้อง ( อาร์เรย์ของจำนวนเต็ม
แต่ละสอดคล้องกับกระเบื้อง ) , ตรรกะธงว่า
ห้อง " มืด " ( ไม่ว่าเนื้อหาจะปรากฏบนรายการ ,
หรือถ้าตัวละครของผู้เล่นจะต้องเข้าใกล้เปิดเผยกระเบื้อง )
และคำจำกัดความของวัตถุประหลาด ( ไม่เกิน 10 คนต่อห้อง ) นี้
ซ้ำในห้องถัดไป เริ่มจากห้องนิยาม .
เครื่องยนต์เกมต้องอาศัยแฟ้มข้อมูลมีประชากร
ได้อย่างถูกต้อง ข้อมูลที่ไม่ถูกต้องอาจส่งผลในการเล่นเกม
ที่ไม่คาดคิด ตัวอย่างเช่นห้อง " ห่อ " หากผู้เล่น
อนุญาตไปออกจอ ปกติถ้าผู้เล่นออกจากห้อง A
พูดโดยไปทิศเหนือ ห้องถัดไปที่ปรากฏเป็น
หนึ่งที่กำหนดโดย ( roomrow-1 roomcolumn , ) แผนที่เหล่านี้

เป็นดัชนีอาร์เรย์ของข้อมูลกระเบื้อง ถ้า roomrow - 1 เป็นลบ
เครื่องยนต์เกมแก้ไขโดยอัตโนมัติเพื่อ maxroomrow - 1
ห้องในแถวสุดท้ายของคอลัมน์ ในคำอื่น ๆถ้า