เหล็ก มิงค์ เนื้อวัว กระดาษ 28 กรกฎาคม 2560 เวลา 17:03 น

เอ็นจิ้นเกม DIY ใน C ++ ส่วนที่ 1 (บทนำ)

• ซี++
• การวิเคราะห์และออกแบบระบบ
• การพัฒนาเกม

เครื่องยนต์เกม
เราออกแบบ เขียน คิด ใช้เหตุผล อ่าน และอื่นๆ อีกมากมาย
ความสนใจ: บทความมีไม้ค้ำยันเยอะมาก!

ขอให้เป็นวันที่ดีทุกคน ไม่นานมานี้ผมตัดสินใจเริ่มพัฒนาเอ็นจิ้นเกม 3 มิติเพราะว่า ข้อมูลที่มีโครงสร้างไม่มีอะไรมากเกี่ยวกับเรื่องนี้ ฉันตัดสินใจสร้างบทความชุดหนึ่งซึ่งฉันจะพยายามแสดงส่วนทางเทคนิคมากกว่าส่วนทางทฤษฎี

ตอนนี้ฉันจะก้าวออกจากหัวข้อและต้องการชี้แจงบางสิ่งทันที... ฉันไม่ใช่สถาปนิกซอฟต์แวร์หรือนักพัฒนาอาวุโสที่ดี ฉันอายุ 21 ปี เป็นนักพัฒนา C++ ระดับกลางตัวเล็กๆ ที่ทะเยอทะยาน ฉันสามารถทำผิดพลาดและเขียนเรื่องไร้สาระได้

มีเพียงซิธเท่านั้นที่ทำข้อตกลงได้เด็ดขาดโอบีวัน "เบน" เคโนบี

ดีใจที่ได้เห็นความคิดเห็นและข้อเสนอแนะในความคิดเห็น
บางทีด้วยสิ่งนี้ ฉันจะจบส่วนเกริ่นนำและลงมือทำธุรกิจกันดีกว่า

ส่วนที่ 1: บทนำ

ขั้นแรก คุณต้องเข้าใจว่าแก่นแท้ของเครื่องยนต์คืออะไร และเหตุใดคุณจึงควรเขียนมัน
อืม... นี่มันอะไรเนี่ย?!

เครื่องยนต์เกม

ศูนย์กลาง ส่วนประกอบซอฟต์แวร์คอมพิวเตอร์และวิดีโอเกมหรืออื่นๆ แอปพลิเคชันแบบโต้ตอบด้วยกราฟิกที่ประมวลผลแบบเรียลไทม์ โดยนำเสนอเทคโนโลยีหลัก ลดความซับซ้อนในการพัฒนา และมักจะทำให้เกมสามารถทำงานบนหลายแพลตฟอร์มได้ เช่น เกมคอนโซลและเดสก์ท็อป ระบบปฏิบัติการเช่น GNU/Linux, Mac OS X และ ไมโครซอฟต์ วินโดวส์.
ลิงค์วิกิ

- ดังนั้น... แค่เขียนสองสามคลาสยังไม่พอเหรอ?!

เอ็นจิ้นที่ดี (UE, Unity, Cocos2D) ประกอบด้วยคลาสสองสามร้อยคลาส ระบบย่อยหลายระบบ และผู้จัดการจำนวนมาก หากต้องการเจาะจงมากขึ้น:

• ระบบกราฟิก
• ระบบเสียง
• ระบบเครือข่าย
• ผู้จัดการกระบวนการ
• ตัวจัดการงาน
• ตัวจัดการวัตถุ
• ผู้จัดการฉาก

และอีกมากมาย...

แล้วเราควรทำอย่างไร? อย่างไร อะไร และที่ไหน?

สิ่งแรกและสำคัญที่สุดคือการแบ่ง งานใหญ่ให้เป็นชิ้นเล็กๆ และไปทีละขั้นตอน ก้าวเล็กๆ ที่ไม่แน่นอน เหมือนหอยทาก

ลำดับของบทความ:

แท็ก: เอ็นจิ้นเกม, gamedev, c ++, สถาปัตยกรรม,

เมื่อไม่นานมานี้ เราได้พูดถึงหัวข้อการสร้างเกมคอมพิวเตอร์และพูดคุยเกี่ยวกับเอนจิ้น 3D ฟรีที่มีเอกลักษณ์เฉพาะตัวที่เขียนมา เดลฟี - GLScene(เอาเครื่อง จากซีดี/ดีวีดีของเรา - หัวข้อของการสร้างเกมคอมพิวเตอร์สามมิติเต็มรูปแบบนั้นน่าสนใจสำหรับคุณมาก ซึ่งสามารถตัดสินได้จากจำนวนจดหมายที่ได้รับ อย่างไรก็ตาม เราตัดสินใจว่าการพูดคุยเกี่ยวกับการเขียนโปรแกรมเครื่องยนต์นั้นยากเกินไป ตั้งแต่นั้นมา ระดับของคุณก็เพิ่มขึ้นอย่างเห็นได้ชัด (ซึ่งสามารถตัดสินได้จากจดหมายและกิจกรรมในฟอรัมนิตยสาร) คุณจึงเข้าใจประเด็นการเขียนโปรแกรมมากขึ้น โดยเฉพาะหลังจากการตีพิมพ์ซีรีส์เรื่องนี้” ห้องเตรียมอาหารของโปรแกรมเมอร์”.
ด้วยปัญหานี้ เราจึงเริ่มเผยแพร่ชุดบทความซึ่งเราจะดูรายละเอียดเกี่ยวกับขั้นตอนต่างๆ ของการสร้างเกม 3 มิติ คุณจะพัฒนาทักษะการเขียนโปรแกรมของคุณและอย่างที่พวกเขาพูดกันว่า มองเบื้องหลังม่านแห่งความลับที่แยกนักพัฒนาเกมที่จริงจังออกจากมนุษย์ธรรมดา
เอ็นจิ้นของเกมใด ๆ ประกอบด้วยบล็อคการสร้างจำนวนมากและมักจะเป็นอิสระ: การควบคุมการชน แบบจำลองทางกายภาพ, อินเตอร์เฟซเกมเมนูหลัก ระดับการโหลด และอื่นๆ อีกมากมาย มีอิฐเฉพาะซึ่งจำเป็นสำหรับประเภทเดียวเท่านั้น ตัวอย่างเช่น โมดูลสภาพอากาศมีความสำคัญและจำเป็นในเครื่องจำลองการบินหรือการเดินเรือ แต่ในกลยุทธ์แบบเรียลไทม์นั้นถือเป็นเรื่องรองหรือไม่จำเป็นเลย และในเครื่องจำลองฟุตบอลก็ไม่จำเป็นต้องมีโมดูลกระสุนปืน แต่มีอิฐหลายสิบก้อนอยู่ในทุกเกม ในบทความชุดนี้ เราจะพูดถึงแต่ละบล็อคส่วนประกอบเหล่านี้ แสดงให้เห็นว่าพวกมันถูกนำไปใช้อย่างไร และจะเชื่อมโยงกับบล็อคอื่นๆ ได้อย่างไร เมื่อสิ้นสุดรอบ คุณจะสามารถใช้ตัวต่อเหล่านี้เพื่อสร้างเกมคอมพิวเตอร์ของคุณเองในระดับที่ค่อนข้างสูงได้

คุณกำลังทำอะไรที่นี่?
สำหรับผู้ที่พลาดบทความก่อนหน้าของฉันบางส่วน (หรือทั้งหมด) ฉันจะตอบทุกคำถามที่คุณอาจมี ขอแนะนำทางเทคนิคเล็กๆ น้อยๆ
ทำไมต้องเดลฟี?สภาพแวดล้อมการพัฒนาและภาษาการเขียนโปรแกรมนี้ วัตถุปาสคาลยืดหยุ่นเพียงพอที่จะสร้างความสมบูรณ์ เกมสามมิติเกือบทุกประเภทที่มีกราฟิกที่ทันสมัย หลายคนอาจแย้งว่ามาตรฐานโดยพฤตินัยสำหรับการพัฒนาเกมคอมพิวเตอร์คือ เอ็มเอสวีซี++หรือตามสื่ออื่นๆ ซี++- แต่มาตรฐานดังกล่าวก็มักจะเกิดขึ้นโดยธรรมชาติ อย่าสับสนระหว่างสองแนวคิด - ภาษาและสภาพแวดล้อมการพัฒนา
C++ มีประสิทธิภาพมากกว่า Object Pascal อย่างแน่นอน แต่ก็มีระดับสูงน้อยกว่าเช่นกันนั่นคือยากกว่าหลายเท่า C++ ไม่เหมาะสำหรับผู้เริ่มต้น Object Pascal ไม่เพียงแต่เรียบง่าย แต่ยังมีความยืดหยุ่นเพียงพอที่จะใช้ในการพัฒนาเกมคอมพิวเตอร์สมัยใหม่ที่เต็มเปี่ยม ตอนนี้เกี่ยวกับวันพุธ คุณไม่สามารถพูดได้อย่างเด็ดขาดที่นี่ สภาพแวดล้อมการพัฒนา- เรื่องของรสนิยมและนิสัยของโปรแกรมเมอร์แต่ละคน ฉันจะแบ่งปันความคิดเห็นของฉันเกี่ยวกับเรื่องนี้ MSVC++ สร้างได้มากกว่าเล็กน้อย รหัสด่วนกว่าเดลฟี ที่จริงแล้วนี่คือจุดสิ้นสุดของข้อดี (ฉันขอย้ำในความคิดเห็นส่วนตัวและไม่มีผลผูกพัน) เดลฟีสำคัญกว่า - ความเร็วสูงการรวบรวม (เร็วกว่า MSVC++ หลายสิบเท่า) คุณภาพสูงเครื่องมือแก้ไขจุดบกพร่อง (ในกรณีส่วนใหญ่ Delphi จะระบุบรรทัดของโค้ดที่มีข้อผิดพลาดอย่างชัดเจน ในขณะที่ MSVC++ สามารถระบุบรรทัดที่อยู่ห่างจากหน้าที่คุณกำลังมองหาหลายหน้า) และ ส่วนต่อประสานที่ใช้งานง่าย.
ทำไมต้อง GLScene?ฉันเคยเห็นและลองใช้เอนจิ้น 3D ฟรีมากมาย แต่ฉันก็เลือกอันนี้ ข้อได้เปรียบที่สำคัญที่สุดคือ GLScene ได้รับการปรับปรุงอย่างต่อเนื่อง นักพัฒนาไม่ได้ยุติมันและมีแนวโน้มว่าจะไม่มีวันทำเช่นนั้น เครื่องยนต์มีการพัฒนาอย่างต่อเนื่องและดูดซับความก้าวหน้าทางเทคนิคล่าสุดทั้งหมด นี่เป็นเอ็นจิ้นฟรีเดียวที่ฉันรู้จักซึ่งพวกเขาจะไม่มีวันพูดว่า "ล้าสมัย" ผู้ที่ชื่นชอบหลายร้อยคนที่ทำงานกับ "เครื่องยนต์" อย่างต่อเนื่องจะไม่ยอมให้ทำเช่นนี้ ตามตัวอย่าง: การรองรับเชเดอร์แรกสุดปรากฏในเครื่องยนต์เพียงไม่กี่เดือนหลังจากนั้น เอ็นวิเดียได้ออกเอกสารที่เกี่ยวข้อง เครื่องมือ.
ข้อดีอีกประการหนึ่ง: GLScene มาพร้อมกับแหล่งข้อมูลที่ครบถ้วน สำหรับผู้เริ่มต้น ความจริงข้อนี้อาจไม่มีประโยชน์เลย แม้ว่ามันจะคุ้มค่ามากที่จะทำความคุ้นเคยกับซอร์สโค้ดที่เขียนโดยมืออาชีพ แต่โปรแกรมเมอร์ที่มีประสบการณ์รู้สึกถึงความหมายหลักของคำเหล่านี้: ท้ายที่สุดแล้วพวกเขาจะสามารถออกแบบเอ็นจิ้นใหม่ได้ตามต้องการที่จะ เงื่อนไขเดียวตามใบอนุญาต MPL คือการเปลี่ยนแปลงใดๆ ในซอร์สโค้ดจะต้องพร้อมสำหรับผู้ประสานงานโครงการ (ปัจจุบันผู้ประสานงานคือ เอริค เกรนจ์- จะเกิดอะไรขึ้นถ้ารหัสของคุณมีประโยชน์กับคนอื่น!
แม้ว่าตัวอย่างโค้ดทั้งหมดที่จะให้ในบทความชุดนี้จะเขียนด้วยภาษา Delphi โดยใช้ GLScene แต่จะเป็นประโยชน์สำหรับผู้ที่เขียนโปรแกรมในภาษาอื่นและกับไลบรารีกราฟิกอื่น ๆ หลังจากทั้งหมด หลักการทั่วไปการสร้างเอ็นจิ้นกราฟิกไม่ได้ขึ้นอยู่กับอย่างใดอย่างหนึ่ง เอาล่ะ...เรามาเริ่มกันเลย

ทำไมคุณถึงต้องมีเครื่องยนต์ 3 มิติ?
เพื่อนๆมือใหม่ ตั้งสมาธิไว้! บางทีสิ่งที่ฉันพูดตอนนี้อาจไม่ชัดเจนนักในครั้งแรก อย่าลืมอ่านซ้ำและทำความเข้าใจ: นี่เป็นหนึ่งในหลักการพื้นฐานของการเขียนโปรแกรมโดยทั่วไปและการพัฒนาระบบที่ซับซ้อน (และเกมคือ ระบบที่ซับซ้อน) โดยเฉพาะ ลองนึกภาพเกมง่ายๆ เช่น ปิงปอง โปรแกรมเมอร์เขียนมันอย่างบริสุทธิ์ OpenGLซอร์สโค้ดจะมีความยาวประมาณ 200 บรรทัด อะไรคือเอ็นจิ้น และโค้ดหลักของเกมจะเป็นอย่างไร? พูดไม่ได้ทันที... แต่ถ้าคุณลองคิดดูการแบ่งเครื่องยนต์และรหัสหลักแบบนี้ก็ไม่จำเป็นเลย
ทีนี้ลองจินตนาการว่าเราต้องการสร้างแอคชั่นสามมิติที่จริงจังไม่มากก็น้อย (โค้ดหลายหมื่นบรรทัด) และเราจะเขียนโปรแกรมในลักษณะเดียวกับที่เราเล่นปิงปองแบบเดียวกัน แล้วอีกไม่นานเราก็จะสับสน! ใช่รหัสนี้จะอย่างรวดเร็ว จะไม่มีอะไรฟุ่มเฟือย แต่... ไม่ใช่ว่าโปรแกรมเมอร์ทุกคนจะสามารถทำมันให้เสร็จได้จนจบ และข้อผิดพลาดในโค้ดที่หนาแน่นเช่นนี้การค้นหาคือนรกอันบริสุทธิ์ ซึ่งหมายความว่าจะต้องมีการจัดเรียงอย่างใด วิธีที่ง่ายที่สุดในการทำเช่นนี้คือด้วย เน้นระดับของนามธรรม.
ระดับนามธรรมเป็นหนึ่งในแนวคิดที่สำคัญที่สุด การเขียนโปรแกรมแบบโมดูลาร์- ลองนึกภาพว่าคุณเป็นช่างก่อสร้างและจำเป็นต้องสร้างบ้าน คุณดำเนินการโดยใช้อิฐ: หยิบอิฐ วางไว้บนผนังที่กำลังก่อสร้าง ปูด้วยปูน หยิบอิฐก้อนต่อไป... อิฐคือระดับนามธรรมของคุณ ลองจินตนาการว่าคุณเป็นนักพัฒนา และคุณต้องสร้างเขตย่อย คุณบอกช่างก่อสร้างว่าจะสร้างบ้านที่ไหน บ้านไหนให้รื้อถอน บ้านคือระดับนามธรรมของคุณ คงจะแปลกถ้าคุณบอกช่างก่อสร้างว่าควรวางอิฐชิ้นไหน คุณพูดว่า: นี่คือที่บ้านจะอยู่ ผู้สร้างจะดูแลข้อกังวลอื่นๆ ทั้งหมด ตอนนี้ลองจินตนาการว่าคุณเป็นนายกเทศมนตรีของเมือง และคุณต้องมอบหมายงานให้กับกลุ่มนักพัฒนา เพื่อมอบที่อยู่อาศัยใหม่มากมายให้กับเมืองภายในปีนี้ ไม่น่าเป็นไปได้ที่คุณจะวางแผนเป็นการส่วนตัวว่าบ้านหลังไหนควรยืนอยู่ นี่คืองานของนักพัฒนา ระดับสิ่งที่เป็นนามธรรมของนายกเทศมนตรีคือปริมาณสต็อกที่อยู่อาศัยซึ่งสามารถเพิ่มขึ้นหรือลดลงได้ แต่จะทำสำเร็จได้อย่างไรก็เป็นอีกเรื่องหนึ่ง โดยทั่วไปแล้ว ในระดับนามธรรมนี้ ไม่สำคัญว่าบ้านจะสร้างจากอะไร ไม่ว่าจะเป็นอิฐหรืองาแมมมอธ และนายกเทศมนตรีก็ไม่สามารถมีได้” วางอิฐ” แม้ว่าคำสั่งใด ๆ ของเขาจะนำไปสู่สิ่งนี้ผ่านนามธรรมหลายระดับ
ในรูปแบบที่ซับซ้อนไม่มากก็น้อย โปรแกรมคอมพิวเตอร์หรือเกม - สิ่งเดียวกัน นามธรรมแต่ละระดับมีหน้าที่รับผิดชอบในส่วนของงาน โดยอาศัยความสามารถที่มากกว่านั้น ระดับต่ำ- แต่ละระดับของสิ่งที่เป็นนามธรรมมีให้อินเทอร์เฟซที่สะดวกในระดับที่สูงขึ้นสำหรับการทำงานกับวัตถุ ในเกมคอมพิวเตอร์ ระดับล่างนามธรรมคือ ภาษาการเขียนโปรแกรม (แม้ว่าในความเป็นจริงคุณสามารถเจาะลึกลงไปถึงฮาร์ดแวร์ได้) ต่อไปเป็นคำสั่งต่างๆ OpenGL API(ถ้าเราเขียนโปรแกรมด้วย) ในระดับนี้เราสามารถออกคำสั่งเช่น “ วาดรูปหลายเหลี่ยม" และ " สลับส่วนที่มองเห็นและเงาของบัฟเฟอร์วิดีโอ- จากนั้น - ทีมงาน GLScene- ในระดับนี้เราสามารถออกคำสั่งได้เช่น “ สร้างลูกบาศก์”, “ดาวน์โหลดโมเดลในรูปแบบ 3ds" และ " ใช้พื้นผิวดังกล่าวกับโมเดล- และนี่คือสิ่งต่อไป - เครื่องยนต์เกม- และสุดท้ายคือโค้ดเกมที่สามารถให้คำสั่งกับเอ็นจิ้นเกมได้เช่น “ ระดับการโหลด”, “ยิงตัวละครแบบนั้นด้วยอาวุธแบบนั้น" และ " แสดงวิดีโอแนะนำ- ตามหลักการแล้ว แต่ละระดับของนามธรรมจะใช้เฉพาะคำสั่งของระดับก่อนหน้าเท่านั้น สิ่งนี้ไม่สามารถทำได้เสมอไป แต่เราต้องมุ่งมั่นเพื่อสิ่งนี้ เนื่องจากในกรณีนี้โค้ดจะรวดเร็ว สะดวก และอ่านง่าย

การสร้างวัตถุแบบไดนามิก
เรามองไปที่การจัดวางแนวตั้งของเกมคอมพิวเตอร์ แต่นามธรรมแต่ละระดับสามารถแบ่งออกเป็นบล็อกความหมาย - โมดูล การแบ่งส่วนนี้เป็นทางเลือกและจะเป็นแบบมีเงื่อนไขเสมอ เพียงแต่ตั้งโปรแกรมด้วยวิธีนี้ง่ายกว่า วันนี้เราจะวิเคราะห์ Building Block เล็กๆ แต่สำคัญมาก - การสร้างแบบไดนามิกวัตถุซึ่งมีอยู่ในทุกเกมโดยไม่มีข้อยกเว้น
สมมติว่าคุณกำลังสร้างโมดูลอาวุธและต้องการเขียนโปรแกรมการระเบิดปืนกล ทุกอย่างจะเรียบร้อยดี แต่คุณจะรู้ได้อย่างไรว่าผู้เล่นสามารถยิงกระสุนได้กี่นัดในเกมทั้งหมด? คุณสามารถสร้างออบเจ็กต์ใดๆ โดยใช้ตัวแก้ไขออบเจ็กต์ใน GLScene IDE ได้ก็ต่อเมื่อคุณทราบอย่างชัดเจนว่าคุณต้องการออบเจ็กต์จำนวนเท่าใดและแบบใด ในกรณีส่วนใหญ่สิ่งนี้เป็นสิ่งที่ยอมรับไม่ได้ ตัวอย่างเช่น คุณมี 20 ระดับในเกมของคุณ แต่ละระดับจะมีชุดของวัตถุของตัวเอง ดังนั้นเราควรสร้างวัตถุทั้งหมดในทุกระดับก่อนเริ่มเกมหรือไม่? การดำเนินการนี้จะใช้เวลานานและจะใช้หน่วยความจำจำนวนมาก ทางออกเดียวเท่านั้น- สร้างวัตถุโดยตรงระหว่างเกมแบบไดนามิก ใน GLScene การสร้างวัตถุใดๆ แบบไดนามิกประกอบด้วยสองขั้นตอน - การสร้างอินสแตนซ์ของคลาสของวัตถุนี้และการกำหนดคุณสมบัติที่จำเป็นให้กับวัตถุนั้น มาดูตัวอย่างการระเบิดของปืนกลที่กล่าวไปแล้วและสร้างกระสุนแบบไดนามิก สมมติว่ากระสุนของเราจะเป็นทรงกลมอุตสาหกรรม คลาสที่รับผิดชอบทรงกลมใน GLScene คือ ทีจีแอลสเฟียร์- ดูเหมือนว่าใคร ๆ ก็สามารถเขียนได้ดังนี้:
Sphere:=TGLSphere.สร้าง
อย่างไรก็ตาม คำสั่งจะไม่ทำงาน เนื่องจากแต่ละอ็อบเจ็กต์ใน GLScene จำเป็นต้องลงทะเบียนในคิวอ็อบเจ็กต์ นอกจากนี้ ไม่สามารถสร้างออบเจ็กต์ใน "โมฆะ" ได้ แต่จะต้องเชื่อมโยงกับออบเจ็กต์ระดับสูงกว่าบางรายการ ออบเจ็กต์รากระดับสูงสุดคือ glscene1.Objects (หากออบเจ็กต์คอมโพเนนต์ TGLScene ของคุณเรียกว่า glscene1) ตัวเลือกที่ถูกต้อง:
ทรงกลม:=TGLSphere (glscene1.Objects.AddNewChild(TGLSphere))
มาดูบรรทัดนี้ทีละชิ้น ที่วัตถุราก glscene1.วัตถุเราเรียกวิธีการนี้ เพิ่มNewChildซึ่งจะเพิ่มออบเจ็กต์ของคลาสที่ระบุในพารามิเตอร์ให้กับรูท (in ในกรณีนี้นี่คือทรงกลม -ทีจีแอลสเฟียร์- สิ่งนี้เป็นไปได้เช่นกัน: ไม่ใช่การส่งผ่านวัตถุ แต่ส่งคลาสทั้งหมดเป็นพารามิเตอร์ไปยังโพรซีเดอร์ เหตุใดคุณจึงต้องแปลงประเภทก่อนมอบหมายงาน ทีจีแอลสเฟียร์- ประเด็นก็คือวิธีการ เพิ่มNewChildไม่ว่าคุณจะส่งผ่านอะไรไปเป็นพารามิเตอร์ ก็จะส่งคืนอ็อบเจ็กต์ของคลาส TGLBaseSceneObject- สิ่งนี้ไม่เหมาะกับเรา ดังนั้นเราจึงแปลงประเภทเป็น TGLSphere ออบเจ็กต์ผลลัพธ์ถูกกำหนดให้กับตัวแปร Sphere ตอนนี้ เมื่อใช้ตัวแปรนี้ เราสามารถตั้งค่าพูลของเราได้ พารามิเตอร์ที่แตกต่างกันเช่น ตำแหน่งในช่องว่าง:
ทรงกลมตำแหน่งX:=
ทรงกลมตำแหน่ง Y:=
ทรงกลมตำแหน่ง Z:=
หรือสี:
Sphere.Material.FrontProperties.Diffuse=
เราได้พูดคุยถึงการสร้างโมเดลแบบไดนามิก และตอนนี้เรามาพูดถึงการทำลายแบบไดนามิกของพวกมันแล้ว ในความเป็นจริง กระสุนนัดหนึ่งชนกำแพง คน หรือบินออกไปในระยะไกลสีน้ำเงิน จากนี้ไปก็ไม่จำเป็นอีกต่อไป ถ้าเราปล่อยไว้แบบนั้น มันก็จะกินพื้นที่ความทรงจำบางส่วน เมื่อพิจารณาว่าคนตั้งแคมป์โดยเฉลี่ยยิงไปกี่นัดก่อนที่จะค้นพบหลุมของเขา เรามีหน่วยความจำคอมพิวเตอร์ไม่เพียงพอที่จะเก็บกระสุนได้มากขนาดนั้น ดังนั้นวัตถุในเกมใด ๆ ที่ไม่จำเป็นจะต้องถูกทำลายทันที คนเดียวเท่านั้น วิธีที่ถูกต้องการทำเช่นนี้คือการเรียกวิธีการ ฟรี, ตัวอย่างเช่น:
ทรงกลมฟรี
มักจำเป็นต้องตรวจสอบว่ามีวัตถุอยู่หรือถูกทำลายไปแล้วหรือไม่ ในการทำเช่นนี้ เราจะเปรียบเทียบวัตถุกับศูนย์คงที่สากล - ไม่มี, ตัวอย่างเช่น:
ถ้าสเฟียร์<>ไม่มีเลย
เริ่ม
(ทรงกลมยังไม่ถูกทำลาย ดังนั้นเราจึงทำสิ่งที่มีประโยชน์ที่นี่)
จบ
หรือเราเรียกฟังก์ชัน มอบหมายแล้วซึ่งทำสิ่งเดียวกัน และที่นี่หลุมพรางขนาดยักษ์อย่างหนึ่งกำลังรอคุณอยู่ซึ่งโปรแกรมเมอร์ทุกคนต้องเผชิญไม่ช้าก็เร็ว หากคุณปล่อยวัตถุโดยใช้วิธีการ ฟรีซึ่งไม่ได้รับประกันว่าตัวแปรอ็อบเจ็กต์จะเท่ากับ ไม่มี- นั่นคือภายใต้สถานการณ์บางอย่างในตัวอย่างข้างต้น แม้ว่าทรงกลมจะถูกทำลายไปก็ตาม ก็จะเป็นไปตามเงื่อนไข หากคุณอยู่ในสภาพหลังจากตรวจสอบเพื่อจัดการบริเวณนี้แล้ว (และสิ่งนี้มักเกิดขึ้นเกือบทุกครั้ง) ก็จะเกิดขึ้น ข้อผิดพลาดร้ายแรงซึ่งอาจส่งผลให้เกมล่มได้ เพื่อให้แน่ใจว่าวัตถุที่ปล่อยกลายเป็นศูนย์ ให้ใช้ขั้นตอนพิเศษ ฟรีแอนด์ไม่มี, ตัวอย่างเช่น:
ฟรีแอนด์ไม่มี(ทรงกลม)
ตอนนี้คุณสามารถมั่นใจได้ว่าคุณจะไม่สามารถเข้าถึงวัตถุที่ไม่มีอยู่อีกต่อไป ขั้นตอนที่อธิบายไว้สำหรับการสร้างและทำลายวัตถุสามารถนำไปใช้กับวัตถุ GLScene ใดก็ได้

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

การโจมตีของโคลน
ขอให้เรามีป่าใหญ่ที่มีต้นไม้เหมือนกันหลายต้นหรือหลายต้นหลายต้น ประเภทต่างๆ- ตัวอย่างนี้คล้ายกับตัวอย่างก่อนหน้านี้ มีเพียงเราไม่ได้สร้างหรือทำลายสิ่งใด ๆ ที่นี่ - ในระดับนี้จะมีต้นไม้อยู่เสมอ จะมีปัญหาในการโหลดระดับ การสร้างต้นไม้จำนวนมากจะใช้เวลานาน แต่พวกเขาก็เหมือนกันหมด! นั่นคือเราโหลดจากฮาร์ดไดรฟ์ซ้ำแล้วซ้ำอีกและสร้างสำเนาของสิ่งเดียวกันในหน่วยความจำ โหลดแล้ว มาเล่นกันเถอะ ก่อนที่จะสร้างต้นไม้แต่ละต้น จะต้องดำเนินการตามขั้นตอนการเตรียมการ ต้นไม้แต่ละต้นจะเหมือนกัน แต่เราจะเรียกพวกเขาอีกครั้ง จำนวนมากคูณจำนวนต้นไม้! มันกลับกลายเป็นว่าสิ้นเปลือง และต้องสงวนหน่วยความจำสำหรับต้นไม้แต่ละต้นไว้ และการประมวลผลแต่ละต้นต้องใช้เวลา
การโหลดต้นไม้ต้นเดียวคงจะดี และเมื่อคุณต้องการแสดงต้นไม้ที่เหลือบนหน้าจอ เพียงแค่แสดงไลบรารีกราฟิกว่าจะรับข้อมูลที่จำเป็นจากที่ใด เป็นการประหยัดทรัพยากรจริงๆ FPS เพิ่มขึ้นจริงๆ! ต้นไม้ "ปลอม" ดังกล่าว (และไม่ใช่แค่ต้นไม้เท่านั้น - อะไรก็ได้) ซึ่งเท่านั้น ข้อมูลส่วนตัว(ตำแหน่งในอวกาศ, มุมการหมุน) และข้อมูลเดียวกันจะถูกเก็บไว้เพียงครั้งเดียวเรียกว่า วัตถุพร็อกซี.
ใน GLScene มีคลาสพิเศษสำหรับการสร้างวัตถุพร็อกซี - TGLProxyObject- มันใช้งานง่ายมาก ขั้นแรก เราสร้างออบเจ็กต์ต้นทาง นั่นคือ ต้นไม้ต้นเดียว ตัวอย่างเช่น:
ต้นไม้:=TGLFreeFrom(glscene1.objects.AddNewChild(TGLFreeFrom));
//โหลด รุ่นของมัน:
Tree.LoadFromFile('Tree.3ds');
// โหลดพื้นผิว:
Tree.Material.Texture.Disabled:=false;
Tree.Material.Texture.Image,LoadFromFile('tree.jpg');
//ตอนนี้มาสร้างต้นไม้โคลนสิบต้นในที่สุ่ม:
สำหรับ i:=1 ถึง 10 จะเริ่มต้น
//สร้างวัตถุพรอกซีอื่น
พร็อกซี:=TGLProxyObject(glscene1.objects.AddNewChild(TGLProxyObject));
ด้วยพรอกซีจะเริ่มต้น
//เขียนแผนผังตัวอย่างของเราไปยังคุณสมบัติ MasterObject
MasterObject:=ต้นไม้;
//แสดงว่าควรสืบทอดเฉพาะโครงสร้างของวัตถุเท่านั้น
ตัวเลือกพร็อกซี:=;
//การวางแนวของต้นไม้ในอวกาศจะต้องไม่เปลี่ยนแปลง
ทิศทาง:= ต้นไม้ทิศทาง;
ขึ้น:= Tree.Up;
//แต่เรากำหนดตำแหน่งแบบสุ่ม
ตำแหน่ง.X:=สุ่ม(100);
ตำแหน่ง Y:=สุ่ม(100);
//และหมุนต้นไม้เป็นมุมสุ่มเพื่อให้ดูดีขึ้น
RollAngle:=สุ่ม(360);
จบ;
จบ;
ตอนนี้เรามีต้นไม้หลายสิบต้นในราคาต้นเดียว โปรดทราบว่าหากเราเปลี่ยนออบเจ็กต์ดั้งเดิมในทางใดทางหนึ่ง การเปลี่ยนแปลงนี้จะส่งผลต่อออบเจ็กต์โคลนทั้งหมดทันที

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

เครื่องมือเว็บไซต์ที่ต้องทำด้วยตัวเอง ตัวเลือกที่หนึ่ง: หากคุณไม่มีฐานข้อมูล...

จนถึงจุดหนึ่งผู้สร้างเว็บไซต์ทุกคนสังเกตเห็นทันทีว่าเขาไม่ได้มีส่วนร่วมในการเตรียมวัสดุใหม่สำหรับเว็บไซต์ของเขาอีกต่อไป แต่ทำในสิ่งที่ซ้ำซากและเป็นกิจวัตร: เขาเลือกเมนูและแทนที่มัน ฉันบันทึกไว้ที่นั่นและอัปเดตมัน ที่นี่ - คัดลอก ที่นั่น - วาง จากนั้นบันทึกและอัปโหลดทั้งหมดนี้ “ไม่หรอก” ผู้ดูแลเว็บคิด “สิ่งนี้ไม่สามารถเกิดขึ้นได้อีกต่อไป! แต่จะทำอย่างไร? และคุณต้องสร้างกลไกสำหรับไซต์...

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

โดยปกติแล้วกลไกจะเรียกว่าชุดของสคริปต์และโปรแกรมโดยยึดตามการดูแลรักษาเว็บไซต์ ใช้งานอยู่ และได้รับการอัปเดต กลไกสามารถเป็นได้ทั้งสคริปต์ PHP แบบธรรมดาและบทความที่จัดเก็บไว้ใน ไฟล์ข้อความรูปแบบบางอย่างและความซับซ้อนที่ซับซ้อน ซอฟต์แวร์ร่วมกับฐานข้อมูล (MySQL, Oracle ฯลฯ) และบริการเว็บที่เขียนด้วย Java

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

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

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

ฟังก์ชั่นการอ่านไฟล์ใน PHP

... $strings = file("myfolder/myfile.txt"); $first_string = $สตริง; ...

มาสร้างฐานข้อมูลแบบโฮมเมดของเราเองกันเถอะ ประการแรกเราจำเป็นต้องมีฟังก์ชันต่อไปนี้: ฟังก์ชันหนึ่งสำหรับอ่านเนื้อหาของหน้า (เช่น ข้อความในบทความ) จาก ไฟล์ภายนอก- การโหลดข้อมูล ฟังก์ชั่นสำหรับการโหลดเทมเพลตจากไฟล์ - นั่นคือการโหลดการออกแบบ (การออกแบบ)

ฟังก์ชั่น loadTemplate($path) /* ฟังก์ชั่นโหลดเทมเพลตตามเส้นทางที่ระบุ และส่งคืนเป็นสตริง เช่น สำหรับการประมวลผลด้วยฟังก์ชัน parceTemplate() */ { $template = fopen($path, "r") or print("ไม่สามารถโหลดไฟล์ template [".$path."]"); ถ้า ($แม่แบบ) ส่งคืน fread ($ เทมเพลต, ขนาดไฟล์ ($ path)); อื่น กลับเท็จ; Fclose($แม่แบบ); } ฟังก์ชั่น parceTemplate($template, $params_values) /* ฟังก์ชั่นแยกวิเคราะห์รูปแบบที่ระบุ แทนที่ชื่อของพารามิเตอร์ที่ทำหน้าที่เป็นดัชนี อาร์เรย์ $params_values ​​​​พร้อมค่า */ { ในขณะที่ (รายการ($param, $value) = แต่ละอัน($params_values)) { $template = str_replace("¤(".$param.")¤", $value, $template); } กลับ $แม่แบบ; } ฟังก์ชั่น readArticle($path) /* ฟังก์ชั่นอ่าน ไฟล์ที่ระบุและกลับมา เนื้อหาในรูปแบบของอาร์เรย์ของส่วนบทความ คั่นด้วยโครงสร้าง ¤(ชื่อชิ้นส่วน)¤ */ { $article = fopen($path, "r") or print("ไม่สามารถโหลดไฟล์บทความ [".$path."]"); ถ้า ($บทความ) { $astring = fread($บทความ, ขนาดไฟล์($path)); $result = split("[¤](1)[(](1)([ a-z_-]*)[)](1)[¤](1)", $astring); $result = eregi_replace("[ ,]*([ - ](1))[, ]*", " - ", $result); $result = ชื่อฐาน($path); ส่งคืนผลลัพธ์ $; } อื่น { กลับเท็จ; } }

ที่ไหนสักแห่งที่นี่เราควรขันแผ่นหินแกรนิตที่มีข้อความว่า "การแสดงออกเป็นประจำจากแฟน ๆ ที่กตัญญู" เนื่องจากหากไม่มีสิ่งที่มีประโยชน์นี้ การสร้างฟังก์ชันข้างต้นเป็นเรื่องยากมาก มาดูกันว่านิพจน์เหล่านี้มีโครงสร้างอย่างไร

ไม่มีประโยชน์ที่จะเขียนเกี่ยวกับสิ่งเดียวกันหลายครั้ง ดังนั้นฉันจะอ้างอิงหนึ่งในบทความเกี่ยวกับนิพจน์ทั่วไป (ที่มา: http://sitemaker.ru/):

การแสดงออกปกติ

ประวัติเล็กน้อย.

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

ตั้งแต่นั้นมา นิพจน์ทั่วไปได้ผ่านการวนซ้ำหลายครั้ง และมาตรฐานปัจจุบันได้รับการดูแลโดย ISO (องค์การระหว่างประเทศเพื่อการมาตรฐาน) และกำหนดโดย Open Group ซึ่งเป็นความพยายามร่วมกันขององค์กรด้านเทคนิคที่ไม่หวังผลกำไรต่างๆ (2)

การจับคู่ตัวละคร

ความยาก การแสดงออกปกติคือสิ่งที่คุณต้องการค้นหาหรือสิ่งที่ควรจับคู่ หากไม่มีแนวคิดนี้ RE จะไม่มีประโยชน์ แต่ละนิพจน์จะมีคำสั่งเกี่ยวกับสิ่งที่ต้องค้นหา:

การจับคู่อักขระในนิพจน์ทั่วไป

ผู้ดำเนินการ	คำอธิบาย	ตัวอย่าง	ผลลัพธ์
.	ตรงกับอักขระตัวใดตัวหนึ่ง	.อ๊อด	จะตรงกับ "ford", "lord", "2ord" ฯลฯ ในไฟล์ Sample.txt
	จับคู่อักขระตัวเดียวใดๆ ที่อยู่ในวงเล็บเหลี่ยม	ลำดับ	จะจับคู่เฉพาะ "cord", "nord" และ "gord" เท่านั้น
[^]	จับคู่อักขระเดี่ยวใดๆ ที่ไม่อยู่ในวงเล็บเหลี่ยม	[^cn]อ๊อด	จะจับคู่ "lord", "2ord" ฯลฯ แต่ไม่ใช่ "cord" หรือ "nord"
	ตรงกับตัวอักษรใด ๆ	ลำดับ	จะจับคู่ "aord", "bord", "Aord", "Bord" ฯลฯ
[^0-9]	จับคู่ที่ไม่ใช่ตัวเลขในช่วง 0-9	[^0-9]ลำดับ	จะจับคู่ "Aord", "aord" ฯลฯ แต่ไม่ใช่ "2ord" ฯลฯ

ตัวดำเนินการการทำซ้ำ

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

ทำซ้ำตัวดำเนินการในนิพจน์ทั่วไป

ผู้ดำเนินการ	คำอธิบาย	ตัวอย่าง	ผลลัพธ์
?	จับคู่อักขระเฉพาะหนึ่งครั้งหากมีอยู่	?เอิร์ด	จะตรงกับ "berd", "herd" ฯลฯ และ "เอิร์ด"
*	จับคู่อักขระเฉพาะหลายครั้งหากมีอยู่	ไม่มี*ถ	จะจับคู่ "nerd", "nrd", "nard" ฯลฯ
+	จับคู่อักขระเฉพาะอย่างน้อยหนึ่งครั้ง	[n]+เอิร์ด	จะจับคู่ "เนิร์ด" "เนิร์ด" ฯลฯ แต่ไม่ใช่ "เนิร์ด"
(น)	จับคู่อักขระเฉพาะ n ครั้ง	(2)เอิร์ด	จะจับคู่ "cherd", "blerd" ฯลฯ แต่ไม่จับคู่ "nerd", "erd", "buzzerd" ฯลฯ
(น,)	จับคู่อักขระเฉพาะอย่างน้อย n ครั้ง	.(2,)เอ่อ	จะจับคู่ "cherd" และ "buzzerd" แต่ไม่ใช่ "nerd"
(ไม่มี,ไม่มี)	จับคู่อักขระเฉพาะอย่างน้อย n ครั้ง แต่ไม่เกิน N ครั้ง	n[e](1,2)ถ	จะจับคู่ "เนิร์ด" และ "เนียร์"

จุดยึดจะอธิบายตำแหน่งที่จะจับคู่รูปแบบ สิ่งเหล่านี้มีประโยชน์เมื่อคุณกำลังมองหาชุดสตริงทั่วไป

จุดยึดนิพจน์ทั่วไป

ผู้ดำเนินการ	คำอธิบาย	ตัวอย่าง	ผลลัพธ์
^	จับคู่จุดเริ่มต้นของสตริง	ereg_replace("^/", "บลา")	แทรก "blah" ที่จุดเริ่มต้นของบรรทัด
$	จับคู่ส่วนท้ายของสตริง	ereg_replace("$/", "blah")	แทรก "blah" ที่ท้ายบรรทัด
\<	ตรงกับจุดเริ่มต้นของคำ	ereg_replace("\<", "blah")	แทรก "blah" ที่จุดเริ่มต้นของคำ
		\	ตรงกับ "blahfield" ฯลฯ
\>	จับคู่ส่วนท้ายของคำ	ereg_replace("\>", "บลา")	แทรก "blah" ที่ส่วนท้ายของคำ
		\>บลา	ตรงกับ "soupblah" ฯลฯ
\ข	จับคู่จุดเริ่มต้นหรือจุดสิ้นสุดของคำ	\บลา	จับคู่ "blahcake" และ "countblah"
\บี	จับคู่ตรงกลางคำ	\บลา	สอดคล้องกับ "sublahper" ฯลฯ

(ท้ายคำพูดแหล่งที่มาของคำอธิบาย: http://sitemaker.ru/)

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

สัญลักษณ์ ¤( และ )¤ ใช้เพื่อแยกส่วนต่างๆ ออกจากกัน ชื่อของส่วนนี้ไม่มีความหมายและสามารถเป็นชุดอักขระใดก็ได้จากตัวอักษรภาษาอังกฤษ ช่องว่าง ขีดล่าง หรือยัติภังค์

ในการแสดงรายการบทความ จะใช้การวนซ้ำเพื่อวนซ้ำไฟล์ทั้งหมดจาก ไดเรกทอรีที่ต้องการ- หากเขาเจอไฟล์ *.art เขาจะเพิ่มมันลงในอาร์เรย์ทันทีเพื่อเฉลิมฉลอง ขึ้นอยู่กับ พารามิเตอร์ที่ระบุเขาสามารถเพิ่มชื่อของไฟล์นี้หรือชื่อบทความที่มีอยู่หรือลิงก์สำเร็จรูปไปยังบทความนี้ได้ทันที

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

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

ประเภทมอเตอร์

เครื่องยนต์แบบโฮมเมดสามารถมีได้หลายรูปแบบ ในหมู่พวกเขา:

• ตัวเลือกที่มีแม่เหล็กถาวร
• โมเดลซิงโครนัสแบบรวม
• มอเตอร์แปรผัน

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

อีกทางเลือกหนึ่งคือสเต็ปเปอร์มอเตอร์สองเฟส อุปกรณ์มีการออกแบบที่เรียบง่าย สามารถม้วนได้ 2 แบบ และติดตั้งได้ง่ายในตำแหน่งที่ต้องการ

การปรับเปลี่ยนแบบผูกขาด

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

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

ตัวเลือกไบโพลาร์

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

อะนาล็อกสามเฟสที่มีความเชี่ยวชาญเฉพาะทางก็กำลังถูกสร้างขึ้นเช่นกัน ใช้ในการออกแบบเครื่องจักร CNC เช่นเดียวกับในคอมพิวเตอร์และเครื่องพิมพ์ในรถยนต์บางรุ่น

การออกแบบและหลักการทำงาน

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

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

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

การเชื่อมต่อ

การเชื่อมต่อมอเตอร์ขนาดเล็กที่ทำเองนั้นดำเนินการตามรูปแบบที่กำหนด ความสนใจหลักคือจำนวนสายไดรฟ์ตลอดจนวัตถุประสงค์ของอุปกรณ์ สเต็ปเปอร์มอเตอร์สามารถติดตั้งสายไฟ 4, 5, 6 หรือ 8 เส้นได้ การดัดแปลงที่มีองค์ประกอบการเดินสายสี่องค์ประกอบสามารถใช้ได้เฉพาะกับอุปกรณ์ไบโพลาร์เท่านั้น การพันเฟสใดๆ ก็ตามจะมีสายไฟสองเส้น เพื่อกำหนดความยาวการเชื่อมต่อที่ต้องการ โหมดทีละขั้นตอนขอแนะนำให้ใช้มิเตอร์ปกติซึ่งช่วยให้คุณสามารถตั้งค่าพารามิเตอร์ที่ต้องการได้อย่างแม่นยำ

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

ด้วยมือของคุณเองเหรอ?

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

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

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

ขั้นตอนสุดท้าย

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

พารามิเตอร์แผนทางเทคนิค

เครื่องยนต์ขนาดเล็กที่ต้องทำด้วยตัวเองอาจมีลักษณะที่แตกต่างกันขึ้นอยู่กับคุณสมบัติการออกแบบ ด้านล่างนี้คือพารามิเตอร์ของการแก้ไขขั้นตอนยอดนิยม:

1. SD-1 - มีขั้นละ 15 องศา มี 4 เฟส และแรงบิด 40 Nt
2. DSh-0.04 A - ขั้นตอนคือ 22.5 องศา, จำนวนเฟส - 4, ความเร็ว - 100 Nt
3. DSHI-200 - 1.8 องศา; 4 เฟส; แรงบิด 0.25 นิวตัน
4. DSh-6 - 18/4/2300 (ค่าถูกระบุโดยการเปรียบเทียบกับพารามิเตอร์ก่อนหน้า)

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

ทำเครื่องยนต์สันดาปภายในแบบโฮมเมด

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

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

เพลาข้อเหวี่ยงประกอบขึ้นจากแหวนรองหนาพร้อมรูคู่หนึ่ง ต้องกดเพลาลงในหนึ่งในนั้น และใช้ซ็อกเก็ตด้านนอกสุดอันที่สองเพื่อยึดแกนกับก้านสูบ การดำเนินการยังดำเนินการโดยใช้วิธีการกด

งานขั้นสุดท้ายในการประกอบเครื่องยนต์ดีเซลแบบโฮมเมด

ด้านล่างนี้เป็นขั้นตอนการประกอบคอยล์จุดระเบิด:

• มีการใช้ชิ้นส่วนจากรถยนต์หรือรถจักรยานยนต์
• มีการติดตั้งหัวเทียนที่เหมาะสม
• มีการติดตั้งลูกถ้วยยึดด้วยอีพ็อกซี่

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

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

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

วัสดุและเครื่องมือที่ใช้

รายการวัสดุ:
- ;
- ;
- สวิตช์;
- ช่องเสียบสำหรับเชื่อมต่อแหล่งจ่ายไฟ
- สายไฟ;
- ท่อพีวีซี ปลั๊ก และอะแดปเตอร์ (กรวย)
- แหล่งจ่ายไฟ 12V/6A;
- เทปกาวสองหน้า
- ข้อต่อสำหรับเครื่องยนต์ 775

รายการเครื่องมือ:
- หัวแร้ง;
- ไขควง;
- เลื่อยโลหะสำหรับโลหะ
- คีม

กระบวนการผลิตเดรเมล:

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

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

ตอนนี้คุณต้องติดตั้งสวิตช์และขั้วต่อแทน เพียงดันเข้าไปในช่อง พวกเขาควรจะล็อคอย่างแน่นหนาหากรูมีเส้นผ่านศูนย์กลางที่เหมาะสม

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

ขั้นตอนที่สี่ การบัดกรีสายไฟ
บัดกรีสายไฟทั้งหมดตามที่ผู้เขียนทำ กำลังของเครื่องยนต์มาจากช่องจ่ายไฟเข้าไปในช่องว่างผ่านสวิตช์ ในที่สุดเราก็ประกอบเคสแล้วลองเปิดอุปกรณ์ เครื่องยนต์กำลังทำงานอยู่หรือไม่? ทุกอย่างเรียบร้อยดี! เดินหน้าต่อไป

ขั้นตอนที่ห้า การเชื่อมต่อ
เพลาแบบยืดหยุ่นนั้นเชื่อมต่อได้ง่ายมาก ก่อนอื่นคุณต้องติดคัปปลิ้งเข้ากับเพลามอเตอร์ ยึดด้วยสกรูและประแจหกเหลี่ยม วางชิ้น PVC รูปทรงกรวยไว้บนแกน และยึดสายเคเบิลจัตุรมุขเข้ากับข้อต่อให้แน่น วางส่วนที่เป็นรูปกรวยไว้บนตัวเสื้อ และดันส่วนด้านนอกของเพลาเข้าไปด้านในตัวเสื้อ

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