DevOps C++ ಮತ್ತು "ಕಿಚನ್ ವಾರ್ಸ್", ಅಥವಾ ನಾನು ಹೇಗೆ ತಿನ್ನುವಾಗ ಆಟಗಳನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಿದೆ

"ನನಗೆ ಏನೂ ತಿಳಿದಿಲ್ಲ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ" ಸಾಕ್ರಟೀಸ್

ಯಾರಿಗೆ: ಎಲ್ಲಾ ಡೆವಲಪರ್‌ಗಳ ಮೇಲೆ ಉಗುಳುವ ಮತ್ತು ಅವರ ಆಟಗಳನ್ನು ಆಡಲು ಬಯಸುವ ಐಟಿ ಜನರಿಗೆ!

ಯಾವುದರ ಬಗ್ಗೆ: ನಿಮಗೆ ಅಗತ್ಯವಿದ್ದರೆ C/C++ ನಲ್ಲಿ ಆಟಗಳನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸುವುದು ಹೇಗೆ!

ನೀವು ಇದನ್ನು ಏಕೆ ಓದಬೇಕು: ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಯು ನನ್ನ ಪರಿಣತಿಯ ಕ್ಷೇತ್ರವಲ್ಲ, ಆದರೆ ನಾನು ಪ್ರತಿ ವಾರ ಕೋಡ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ. ಏಕೆಂದರೆ ನಾನು ಆಟಗಳನ್ನು ಪ್ರೀತಿಸುತ್ತೇನೆ!

ನಮಸ್ಕಾರ ನನ್ನ ಹೆಸರು ಆಂಡ್ರೆ ಗ್ರಾಂಕಿನ್, ನಾನು Luxoft ನಲ್ಲಿ DevOps ಆಗಿದ್ದೇನೆ. ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿ ನನ್ನ ವಿಶೇಷತೆ ಅಲ್ಲ, ಆದರೆ ನಾನು ಪ್ರತಿ ವಾರ ಕೋಡ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ. ಏಕೆಂದರೆ ನಾನು ಆಟಗಳನ್ನು ಪ್ರೀತಿಸುತ್ತೇನೆ!

ಕಂಪ್ಯೂಟರ್ ಗೇಮಿಂಗ್ ಉದ್ಯಮವು ದೊಡ್ಡದಾಗಿದೆ, ಇಂದು ಚಲನಚಿತ್ರೋದ್ಯಮಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆ ಎಂದು ವದಂತಿಗಳಿವೆ. ಆಧುನಿಕ ಮಾನದಂಡಗಳು, ಸಂಕೀರ್ಣ ಮತ್ತು ಮೂಲಭೂತ ಅಭಿವೃದ್ಧಿ ವಿಧಾನಗಳ ಮೂಲಕ ಕಂಪ್ಯೂಟರ್‌ಗಳ ಉದಯದಿಂದಲೂ ಆಟಗಳನ್ನು ಬರೆಯಲಾಗಿದೆ. ಕಾಲಾನಂತರದಲ್ಲಿ, ಈಗಾಗಲೇ ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲಾದ ಗ್ರಾಫಿಕ್ಸ್, ಭೌತಶಾಸ್ತ್ರ ಮತ್ತು ಧ್ವನಿಯೊಂದಿಗೆ ಆಟದ ಎಂಜಿನ್ಗಳು ಕಾಣಿಸಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿದವು. ಆಟದ ಅಭಿವೃದ್ಧಿಯತ್ತ ಗಮನಹರಿಸಲು ಅವರು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತಾರೆ ಮತ್ತು ಅದರ ಅಡಿಪಾಯದ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ. ಆದರೆ ಅವರೊಂದಿಗೆ, ಇಂಜಿನ್ಗಳೊಂದಿಗೆ, ಅಭಿವರ್ಧಕರು "ಕುರುಡು" ಮತ್ತು ಅವನತಿಗೆ ಹೋಗುತ್ತಾರೆ. ಆಟಗಳ ಉತ್ಪಾದನೆಯನ್ನು ಕನ್ವೇಯರ್ ಬೆಲ್ಟ್ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ. ಮತ್ತು ಉತ್ಪನ್ನಗಳ ಪ್ರಮಾಣವು ಅದರ ಗುಣಮಟ್ಟಕ್ಕಿಂತ ಮೇಲುಗೈ ಸಾಧಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಅದೇ ಸಮಯದಲ್ಲಿ, ಇತರ ಜನರ ಆಟಗಳನ್ನು ಆಡುವಾಗ, ಇತರ ಜನರು ಬಂದ ಸ್ಥಳಗಳು, ಕಥಾವಸ್ತು, ಪಾತ್ರಗಳು, ಆಟದ ಯಂತ್ರಶಾಸ್ತ್ರದಿಂದ ನಾವು ನಿರಂತರವಾಗಿ ಸೀಮಿತವಾಗಿರುತ್ತೇವೆ. ಹಾಗಾಗಿ ನಾನು ಅದನ್ನು ಅರಿತುಕೊಂಡೆ ...

... ನನಗೆ ಮಾತ್ರ ಒಳಪಟ್ಟು ನನ್ನದೇ ಆದ ಪ್ರಪಂಚಗಳನ್ನು ಸೃಷ್ಟಿಸುವ ಸಮಯ ಬಂದಿದೆ. ನಾನು ತಂದೆ, ಮಗ ಮತ್ತು ಪವಿತ್ರ ಆತ್ಮವಾಗಿರುವ ಜಗತ್ತುಗಳು!

ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ಆಟದ ಎಂಜಿನ್ ಮತ್ತು ಅದರ ಮೇಲೆ ಆಟವನ್ನು ಬರೆಯುವ ಮೂಲಕ, ನಿಮ್ಮ ಕಣ್ಣುಗಳನ್ನು ತೆರೆಯಲು, ಕಿಟಕಿಗಳನ್ನು ಒರೆಸಲು ಮತ್ತು ನಿಮ್ಮ ಕ್ಯಾಬಿನ್ ಅನ್ನು ಪಂಪ್ ಮಾಡಲು, ಹೆಚ್ಚು ಅನುಭವಿ ಮತ್ತು ಅವಿಭಾಜ್ಯ ಪ್ರೋಗ್ರಾಮರ್ ಆಗಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂದು ನಾನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ನಂಬುತ್ತೇನೆ.

ಈ ಲೇಖನದಲ್ಲಿ ನಾನು C/C++ ನಲ್ಲಿ ಸಣ್ಣ ಆಟಗಳನ್ನು ಹೇಗೆ ಬರೆಯಲು ಪ್ರಾರಂಭಿಸಿದೆ, ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯು ಹೇಗಿದೆ ಮತ್ತು ಬಿಡುವಿಲ್ಲದ ವಾತಾವರಣದಲ್ಲಿ ಹವ್ಯಾಸಕ್ಕಾಗಿ ನಾನು ಎಲ್ಲಿ ಸಮಯವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇನೆ ಎಂದು ಹೇಳಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ. ಇದು ವ್ಯಕ್ತಿನಿಷ್ಠವಾಗಿದೆ ಮತ್ತು ವೈಯಕ್ತಿಕ ಪ್ರಾರಂಭದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಅಜ್ಞಾನ ಮತ್ತು ನಂಬಿಕೆಯ ಬಗ್ಗೆ ವಸ್ತು, ಈ ಸಮಯದಲ್ಲಿ ಪ್ರಪಂಚದ ನನ್ನ ವೈಯಕ್ತಿಕ ಚಿತ್ರದ ಬಗ್ಗೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, "ನಿಮ್ಮ ವೈಯಕ್ತಿಕ ಮೆದುಳಿಗೆ ಆಡಳಿತವು ಜವಾಬ್ದಾರನಾಗಿರುವುದಿಲ್ಲ!"

ಅಭ್ಯಾಸ

"ಅಭ್ಯಾಸವಿಲ್ಲದ ಜ್ಞಾನವು ನಿಷ್ಪ್ರಯೋಜಕವಾಗಿದೆ, ಜ್ಞಾನವಿಲ್ಲದ ಅಭ್ಯಾಸವು ಅಪಾಯಕಾರಿ." ಕನ್ಫ್ಯೂಷಿಯಸ್

ನನ್ನ ನೋಟ್ಬುಕ್ ನನ್ನ ಜೀವನ!

ಆದ್ದರಿಂದ, ಪ್ರಾಯೋಗಿಕವಾಗಿ, ನನಗೆ ಎಲ್ಲವೂ ನೋಟ್ಪಾಡ್ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಎಂದು ನಾನು ಹೇಳಬಹುದು. ನಾನು ಅಲ್ಲಿ ನನ್ನ ದೈನಂದಿನ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುವುದು ಮಾತ್ರವಲ್ಲದೆ, ನಾನು ರೇಖಾಚಿತ್ರ, ಪ್ರೋಗ್ರಾಂ, ವಿನ್ಯಾಸ ಫ್ಲೋಚಾರ್ಟ್ ಮತ್ತು ಗಣಿತ ಸೇರಿದಂತೆ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತೇನೆ. ಯಾವಾಗಲೂ ನೋಟ್‌ಪ್ಯಾಡ್ ಬಳಸಿ ಮತ್ತು ಪೆನ್ಸಿಲ್‌ನಲ್ಲಿ ಮಾತ್ರ ಬರೆಯಿರಿ. ಇದು ಶುದ್ಧ, ಅನುಕೂಲಕರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ, IMHO.

ನನ್ನ (ಈಗಾಗಲೇ ತುಂಬಿದೆ) ನೋಟ್‌ಬುಕ್. ಅವನು ಕಾಣುವ ರೀತಿ ಇದು. ಇದು ದೈನಂದಿನ ಕಾರ್ಯಗಳು, ಕಲ್ಪನೆಗಳು, ರೇಖಾಚಿತ್ರಗಳು, ರೇಖಾಚಿತ್ರಗಳು, ಪರಿಹಾರಗಳು, ಕಪ್ಪು ಬುಕ್ಕೀಪಿಂಗ್, ಕೋಡ್ ಮತ್ತು ಮುಂತಾದವುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ

ಈ ಹಂತದಲ್ಲಿ, ನಾನು ಮೂರು ಯೋಜನೆಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೆ (ಇದು "ಅಂತಿಮತೆ" ಯ ನನ್ನ ತಿಳುವಳಿಕೆಯಲ್ಲಿದೆ, ಏಕೆಂದರೆ ಯಾವುದೇ ಉತ್ಪನ್ನವನ್ನು ತುಲನಾತ್ಮಕವಾಗಿ ಅಂತ್ಯವಿಲ್ಲದೆ ಅಭಿವೃದ್ಧಿಪಡಿಸಬಹುದು).

• ಯೋಜನೆ 0: ಇದು ಯುನಿಟಿ ಗೇಮ್ ಎಂಜಿನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು C# ನಲ್ಲಿ ಬರೆಯಲಾದ 3D ಆರ್ಕಿಟೆಕ್ಟ್ ಡೆಮೊ ದೃಶ್ಯವಾಗಿದೆ. MacOS ಮತ್ತು Windows ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗಾಗಿ.
• ಆಟ 1: ವಿಂಡೋಸ್‌ಗಾಗಿ ಕನ್ಸೋಲ್ ಗೇಮ್ ಸಿಂಪಲ್ ಸ್ನೇಕ್ (ಎಲ್ಲರಿಗೂ "ಸ್ನೇಕ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ). ಸಿ ಯಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ.
• ಆಟ 2: ಕನ್ಸೋಲ್ ಗೇಮ್ ಕ್ರೇಜಿ ಟ್ಯಾಂಕ್ಸ್ (ಎಲ್ಲರಿಗೂ "ಟ್ಯಾಂಕ್ಸ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ), C++ ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ (ತರಗತಿಗಳನ್ನು ಬಳಸಿ) ಮತ್ತು ವಿಂಡೋಸ್‌ಗಾಗಿ.

ಪ್ರಾಜೆಕ್ಟ್ 0. ಆರ್ಕಿಟೆಕ್ಟ್ ಡೆಮೊ

• ವೇದಿಕೆ: ವಿಂಡೋಸ್ (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• ಭಾಷೆ: C#
• ಆಟದ ಎಂಜಿನ್: ಯೂನಿಟಿ
• ಸ್ಫೂರ್ತಿ: ಡ್ಯಾರಿನ್ ಲೀಲ್
• ಭಂಡಾರ: GitHub

3D ದೃಶ್ಯ ವಾಸ್ತುಶಿಲ್ಪಿ ಡೆಮೊ

ಮೊದಲ ಯೋಜನೆಯನ್ನು C/C++ ನಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿಲ್ಲ, ಆದರೆ C# ನಲ್ಲಿ ಯೂನಿಟಿ ಗೇಮ್ ಎಂಜಿನ್ ಬಳಸಿ. ಈ ಎಂಜಿನ್ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಬೇಡಿಕೆಯಿಲ್ಲ ಅನ್ರಿಯಲ್ ಇಂಜಿನ್, ಮತ್ತು ಅನುಸ್ಥಾಪಿಸಲು ಮತ್ತು ಬಳಸಲು ಸುಲಭವಾಗಿದೆ. ನಾನು ಇತರ ಎಂಜಿನ್ಗಳನ್ನು ಪರಿಗಣಿಸಲಿಲ್ಲ.

ನನಗೆ ಏಕತೆಯ ಗುರಿಯು ಕೆಲವು ರೀತಿಯ ಆಟವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು ಅಲ್ಲ. ನಾನು ಕೆಲವು ರೀತಿಯ ಪಾತ್ರದೊಂದಿಗೆ 3D ದೃಶ್ಯವನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೇನೆ. ಅವನು, ಅಥವಾ ಬದಲಿಗೆ ಅವಳು (ನಾನು ಪ್ರೀತಿಸುತ್ತಿದ್ದ ಹುಡುಗಿಯನ್ನು ನಾನು ಮಾಡೆಲ್ ಮಾಡಿದ್ದೇನೆ =) ಅವನ ಸುತ್ತಲಿನ ಪ್ರಪಂಚದೊಂದಿಗೆ ಚಲಿಸಬೇಕು ಮತ್ತು ಸಂವಹನ ನಡೆಸಬೇಕು. ಏಕತೆ ಎಂದರೇನು, ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆ ಏನು ಮತ್ತು ಏನನ್ನಾದರೂ ರಚಿಸಲು ಎಷ್ಟು ಪ್ರಯತ್ನ ಬೇಕು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮಾತ್ರ ಮುಖ್ಯವಾಗಿತ್ತು. ಆರ್ಕಿಟೆಕ್ಟ್ ಡೆಮೊ ಯೋಜನೆಯು ಹುಟ್ಟಿದ್ದು ಹೀಗೆ (ಈ ಹೆಸರನ್ನು ಬಹುತೇಕ ಬುಲ್‌ಶಿಟ್‌ನಿಂದ ಕಂಡುಹಿಡಿಯಲಾಗಿದೆ). ಪ್ರೋಗ್ರಾಮಿಂಗ್, ಮಾಡೆಲಿಂಗ್, ಅನಿಮೇಷನ್, ಟೆಕ್ಸ್ಚರಿಂಗ್ ನನಗೆ ಬಹುಶಃ ಎರಡು ತಿಂಗಳ ದೈನಂದಿನ ಕೆಲಸವನ್ನು ತೆಗೆದುಕೊಂಡಿತು.

ನಾನು YouTube ನಲ್ಲಿ 3D ಮಾದರಿಗಳನ್ನು ರಚಿಸುವ ಕುರಿತು ಟ್ಯುಟೋರಿಯಲ್ ವೀಡಿಯೊಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿದೆ ಬ್ಲೆಂಡರ್. ಬ್ಲೆಂಡರ್ 3D ಮಾಡೆಲಿಂಗ್‌ಗೆ (ಮತ್ತು ಹೆಚ್ಚು) ಉತ್ತಮ ಉಚಿತ ಸಾಧನವಾಗಿದ್ದು ಅದು ಅನುಸ್ಥಾಪನೆಯ ಅಗತ್ಯವಿಲ್ಲ. ಮತ್ತು ಇಲ್ಲಿ ಒಂದು ಆಘಾತ ನನಗೆ ಕಾಯುತ್ತಿದೆ ... ಮಾಡೆಲಿಂಗ್, ಅನಿಮೇಷನ್, ಟೆಕ್ಸ್ಚರಿಂಗ್ ನೀವು ಪುಸ್ತಕಗಳನ್ನು ಬರೆಯಬಹುದಾದ ದೊಡ್ಡ ಪ್ರತ್ಯೇಕ ವಿಷಯಗಳಾಗಿವೆ ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ. ಇದು ಪಾತ್ರಗಳಿಗೆ ವಿಶೇಷವಾಗಿ ಸತ್ಯವಾಗಿದೆ. ಬೆರಳುಗಳು, ಹಲ್ಲುಗಳು, ಕಣ್ಣುಗಳು ಮತ್ತು ದೇಹದ ಇತರ ಭಾಗಗಳನ್ನು ರೂಪಿಸಲು, ನಿಮಗೆ ಅಂಗರಚನಾಶಾಸ್ತ್ರದ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ. ಮುಖದ ಸ್ನಾಯುಗಳು ಹೇಗೆ ರಚನೆಯಾಗುತ್ತವೆ? ಜನರು ಹೇಗೆ ಚಲಿಸುತ್ತಾರೆ? ನಾನು ಪ್ರತಿ ತೋಳು, ಕಾಲು, ಬೆರಳು, ಬೆರಳುಗಳ ಫ್ಯಾಲ್ಯಾಂಕ್ಸ್ನಲ್ಲಿ ಮೂಳೆಗಳನ್ನು "ಸೇರಿಸಬೇಕಾಗಿತ್ತು"!

ಅನಿಮೇಶನ್ ನೈಸರ್ಗಿಕವಾಗಿ ಕಾಣುವಂತೆ ಕಾಲರ್‌ಬೋನ್‌ಗಳು ಮತ್ತು ಹೆಚ್ಚುವರಿ ಲಿವರ್ ಮೂಳೆಗಳನ್ನು ಮಾದರಿ ಮಾಡಿ. ಅಂತಹ ಪಾಠಗಳ ನಂತರ, ಅನಿಮೇಟೆಡ್ ಚಲನಚಿತ್ರಗಳ ರಚನೆಕಾರರು ಕೇವಲ 30 ಸೆಕೆಂಡುಗಳ ವೀಡಿಯೊವನ್ನು ರಚಿಸಲು ಎಷ್ಟು ಕೆಲಸ ಮಾಡುತ್ತಾರೆ ಎಂಬುದನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೀರಿ. ಆದರೆ 3D ಚಿತ್ರಗಳು ಗಂಟೆಗಳ ಕಾಲ ಉಳಿಯುತ್ತವೆ! ತದನಂತರ ನಾವು ಚಿತ್ರಮಂದಿರಗಳನ್ನು ಬಿಟ್ಟು ಈ ರೀತಿಯಾಗಿ ಹೇಳುತ್ತೇವೆ: “ಅದೊಂದು ಕೆಟ್ಟ ಕಾರ್ಟೂನ್/ಚಲನಚಿತ್ರ! ಅವರು ಉತ್ತಮವಾಗಿ ಮಾಡಬಹುದಿತ್ತು..." ಮೂರ್ಖರು!

ಮತ್ತು ಈ ಯೋಜನೆಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ಇನ್ನೊಂದು ವಿಷಯ. ಅದು ಬದಲಾದಂತೆ, ನನಗೆ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಭಾಗವೆಂದರೆ ಗಣಿತಶಾಸ್ತ್ರ. ನೀವು ದೃಶ್ಯವನ್ನು ರನ್ ಮಾಡಿದರೆ (ಪ್ರಾಜೆಕ್ಟ್ ವಿವರಣೆಯಲ್ಲಿನ ರೆಪೊಸಿಟರಿಗೆ ಲಿಂಕ್), ಕ್ಯಾಮೆರಾ ಹುಡುಗಿಯ ಪಾತ್ರದ ಸುತ್ತಲೂ ಗೋಳದಲ್ಲಿ ತಿರುಗುವುದನ್ನು ನೀವು ಗಮನಿಸಬಹುದು. ಕ್ಯಾಮೆರಾದ ಅಂತಹ ತಿರುಗುವಿಕೆಯನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು, ನಾನು ಮೊದಲು ವೃತ್ತದ (2D) ಸ್ಥಾನದ ಬಿಂದುವಿನ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕಾಗಿತ್ತು, ಮತ್ತು ನಂತರ ಗೋಳದ ಮೇಲೆ (3D). ತಮಾಷೆಯೆಂದರೆ ನಾನು ಶಾಲೆಯಲ್ಲಿ ಗಣಿತವನ್ನು ದ್ವೇಷಿಸುತ್ತಿದ್ದೆ ಮತ್ತು ಅದನ್ನು ಸಿ-ಮೈನಸ್‌ನೊಂದಿಗೆ ತಿಳಿದಿದ್ದೆ. ಭಾಗಶಃ, ಬಹುಶಃ, ಏಕೆಂದರೆ ಶಾಲೆಯಲ್ಲಿ ಈ ಗಣಿತವನ್ನು ಜೀವನದಲ್ಲಿ ಹೇಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅವರು ನಿಮಗೆ ವಿವರಿಸುವುದಿಲ್ಲ. ಆದರೆ ನೀವು ನಿಮ್ಮ ಗುರಿ, ನಿಮ್ಮ ಕನಸುಗಳ ಗೀಳನ್ನು ಹೊಂದಿರುವಾಗ ನಿಮ್ಮ ಮನಸ್ಸು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ ಮತ್ತು ತೆರೆದುಕೊಳ್ಳುತ್ತದೆ! ಮತ್ತು ನೀವು ಕಷ್ಟಕರವಾದ ಕಾರ್ಯಗಳನ್ನು ಅತ್ಯಾಕರ್ಷಕ ಸಾಹಸವೆಂದು ಗ್ರಹಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ. ತದನಂತರ ನೀವು ಯೋಚಿಸುತ್ತೀರಿ: "ಸರಿ, ನಿಮ್ಮ *ಮೆಚ್ಚಿನ* ಗಣಿತಜ್ಞರು ಈ ಸೂತ್ರಗಳನ್ನು ಎಲ್ಲಿ ಅನ್ವಯಿಸಬಹುದು ಎಂದು ನಿಮಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಹೇಳಲು ಏಕೆ ಸಾಧ್ಯವಿಲ್ಲ?"

ವೃತ್ತದ ಮೇಲೆ ಮತ್ತು ಗೋಳದ ಮೇಲೆ ಬಿಂದುವಿನ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸೂತ್ರಗಳ ಲೆಕ್ಕಾಚಾರ (ನನ್ನ ನೋಟ್‌ಬುಕ್‌ನಿಂದ)

ಆಟ 1. ಸರಳ ಹಾವು

• ವೇದಿಕೆ: ವಿಂಡೋಸ್ (ವಿಂಡೋಸ್ 7, 10 ನಲ್ಲಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆ)
• ಭಾಷೆ: ನಾನು ಅದನ್ನು ಶುದ್ಧ ಸಿ ಯಲ್ಲಿ ಬರೆದಿದ್ದೇನೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ
• ಆಟದ ಎಂಜಿನ್: ವಿಂಡೋಸ್ ಕನ್ಸೋಲ್
• ಸ್ಫೂರ್ತಿ: javidx9
• ಭಂಡಾರ: GitHub

ಸರಳ ಹಾವಿನ ಆಟ

3D ದೃಶ್ಯವು ಆಟವಲ್ಲ. ಇದರ ಜೊತೆಗೆ, 3D ವಸ್ತುಗಳನ್ನು (ವಿಶೇಷವಾಗಿ ಪಾತ್ರಗಳು) ಮಾಡೆಲಿಂಗ್ ಮತ್ತು ಅನಿಮೇಟ್ ಮಾಡುವುದು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಕಷ್ಟಕರವಾಗಿದೆ. ಯೂನಿಟಿಯೊಂದಿಗೆ ಆಟವಾಡಿದ ನಂತರ, ನಾನು ಮೂಲಭೂತ ವಿಷಯಗಳಿಂದ ಮುಂದುವರಿಯಬೇಕು ಅಥವಾ ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂಬ ಅರಿವು ನನಗೆ ಬಂದಿತು. ಆಟಗಳ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸರಳ ಮತ್ತು ವೇಗವಾದ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಜಾಗತಿಕ.

ಯಾವುದು ಸರಳ ಮತ್ತು ತ್ವರಿತ? ಅದು ಸರಿ, ಕನ್ಸೋಲ್ ಮತ್ತು 2D. ಹೆಚ್ಚು ನಿಖರವಾಗಿ, ಕನ್ಸೋಲ್ ಮತ್ತು ಚಿಹ್ನೆಗಳು ಸಹ. ಮತ್ತೆ ನಾನು ಇಂಟರ್ನೆಟ್ನಲ್ಲಿ ಸ್ಫೂರ್ತಿಗಾಗಿ ಹುಡುಕುತ್ತಿದ್ದೆ (ಸಾಮಾನ್ಯವಾಗಿ, ಇಂಟರ್ನೆಟ್ XNUMX ನೇ ಶತಮಾನದ ಅತ್ಯಂತ ಕ್ರಾಂತಿಕಾರಿ ಮತ್ತು ಅಪಾಯಕಾರಿ ಆವಿಷ್ಕಾರವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ). ಕನ್ಸೋಲ್ ಟೆಟ್ರಿಸ್ ಮಾಡಿದ ಪ್ರೋಗ್ರಾಮರ್‌ನ ವೀಡಿಯೊವನ್ನು ನಾನು ಅಗೆದು ಹಾಕಿದ್ದೇನೆ. ಮತ್ತು ಅವನ ಆಟದ ಹೋಲಿಕೆಯಲ್ಲಿ ನಾನು "ಹಾವು" ಮಾಡಲು ನಿರ್ಧರಿಸಿದೆ. ವೀಡಿಯೊದಿಂದ ನಾನು ಎರಡು ಮೂಲಭೂತ ವಿಷಯಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೇನೆ - ಆಟದ ಲೂಪ್ (ಮೂರು ಮೂಲಭೂತ ಕಾರ್ಯಗಳು/ಭಾಗಗಳೊಂದಿಗೆ) ಮತ್ತು ಬಫರ್‌ಗೆ ಔಟ್‌ಪುಟ್.

ಆಟದ ಲೂಪ್ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

int main()
   {
      Setup();
      // a game loop
      while (!quit)
      {
          Input();
          Logic();
          Draw();
          Sleep(gameSpeed);  // game timing
      }
      return 0;
   }

ಕೋಡ್ ಸಂಪೂರ್ಣ ಮುಖ್ಯ () ಕಾರ್ಯವನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸುತ್ತದೆ. ಮತ್ತು ಸೂಕ್ತವಾದ ಕಾಮೆಂಟ್ ನಂತರ ಆಟದ ಚಕ್ರವು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಲೂಪ್‌ನಲ್ಲಿ ಮೂರು ಮೂಲಭೂತ ಕಾರ್ಯಗಳಿವೆ: ಇನ್‌ಪುಟ್ (), ಲಾಜಿಕ್ (), ಡ್ರಾ (). ಮೊದಲು, ಇನ್ಪುಟ್ ಡೇಟಾ ಇನ್ಪುಟ್ (ಮುಖ್ಯವಾಗಿ ಕೀಸ್ಟ್ರೋಕ್ಗಳ ನಿಯಂತ್ರಣ), ನಂತರ ನಮೂದಿಸಿದ ಡೇಟಾ ಲಾಜಿಕ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು, ನಂತರ ಪರದೆಯ ಔಟ್ಪುಟ್ - ಡ್ರಾ. ಹೀಗೆ ಪ್ರತಿ ಚೌಕಟ್ಟಿನಲ್ಲೂ. ಅನಿಮೇಷನ್ ಅನ್ನು ಈ ರೀತಿ ರಚಿಸಲಾಗಿದೆ. ಇದು ಕಾರ್ಟೂನ್‌ಗಳಲ್ಲಿರುವಂತೆ. ವಿಶಿಷ್ಟವಾಗಿ, ನಮೂದಿಸಿದ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನನಗೆ ತಿಳಿದಿರುವಂತೆ, ಆಟದ ಫ್ರೇಮ್ ದರವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಆದರೆ ಇಲ್ಲಿ ಲಾಜಿಕ್ () ಕಾರ್ಯವು ತುಂಬಾ ವೇಗವಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಈ ವೇಗವನ್ನು ನಿರ್ಧರಿಸುವ ಗೇಮ್‌ಸ್ಪೀಡ್ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಸ್ಲೀಪ್ () ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಫ್ರೇಮ್ ದರವನ್ನು ನಿಯಂತ್ರಿಸಬೇಕು.

ಆಟದ ಚಕ್ರ. ನೋಟ್‌ಪ್ಯಾಡ್‌ನಲ್ಲಿ "ಹಾವು" ಪ್ರೋಗ್ರಾಮಿಂಗ್

ನೀವು ಅಕ್ಷರ-ಆಧಾರಿತ ಕನ್ಸೋಲ್ ಆಟವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದ್ದರೆ, ನಿಯಮಿತ 'ಕೌಟ್' ಸ್ಟ್ರೀಮ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಡೇಟಾವನ್ನು ಪರದೆಯ ಮೇಲೆ ಔಟ್‌ಪುಟ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ - ಇದು ತುಂಬಾ ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಔಟ್ಪುಟ್ ಅನ್ನು ಪರದೆಯ ಬಫರ್ಗೆ ಕಳುಹಿಸಬೇಕು. ಇದು ಹೆಚ್ಚು ವೇಗವಾಗಿರುತ್ತದೆ ಮತ್ತು ಆಟವು ಯಾವುದೇ ತೊಂದರೆಗಳಿಲ್ಲದೆ ರನ್ ಆಗುತ್ತದೆ. ನಿಜ ಹೇಳಬೇಕೆಂದರೆ, ಸ್ಕ್ರೀನ್ ಬಫರ್ ಎಂದರೇನು ಮತ್ತು ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದು ನನಗೆ ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ. ಆದರೆ ನಾನು ಇಲ್ಲಿ ಉದಾಹರಣೆ ಕೋಡ್ ನೀಡುತ್ತೇನೆ, ಮತ್ತು ಬಹುಶಃ ಯಾರಾದರೂ ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಪರಿಸ್ಥಿತಿಯನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಬಹುದು.

ಸ್ಕ್ರೀನ್ ಬಫರ್ ಅನ್ನು ಪಡೆಯುವುದು (ಮಾತನಾಡಲು):

// create screen buffer for drawings
   HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0,
 							   NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
   DWORD dwBytesWritten = 0;
   SetConsoleActiveScreenBuffer(hConsole);

ನಿರ್ದಿಷ್ಟ ಸ್ಟ್ರಿಂಗ್ ಸ್ಕೋರ್‌ಲೈನ್‌ನ ನೇರ ಪ್ರದರ್ಶನ (ಸ್ಕೋರ್ ಡಿಸ್ಪ್ಲೇ ಲೈನ್):

// draw the score
   WriteConsoleOutputCharacter(hConsole, scoreLine, GAME_WIDTH, {2,3}, &dwBytesWritten);

ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಈ ಆಟದಲ್ಲಿ ಸಂಕೀರ್ಣವಾದ ಏನೂ ಇಲ್ಲ, ಇದು ಪ್ರವೇಶ ಮಟ್ಟದ ಆಟದ ಉತ್ತಮ ಉದಾಹರಣೆ ಎಂದು ನನಗೆ ತೋರುತ್ತದೆ. ಕೋಡ್ ಅನ್ನು ಒಂದು ಫೈಲ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಹಲವಾರು ಕಾರ್ಯಗಳಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾಗಿದೆ. ಯಾವುದೇ ವರ್ಗಗಳಿಲ್ಲ, ಉತ್ತರಾಧಿಕಾರವಿಲ್ಲ. GitHub ನಲ್ಲಿನ ರೆಪೊಸಿಟರಿಗೆ ಹೋಗುವ ಮೂಲಕ ನೀವು ಆಟದ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ನೋಡಬಹುದು.

ಗೇಮ್ 2. ಕ್ರೇಜಿ ಟ್ಯಾಂಕ್ಸ್

• ವೇದಿಕೆ: ವಿಂಡೋಸ್ (ವಿಂಡೋಸ್ 7, 10 ನಲ್ಲಿ ಪರೀಕ್ಷಿಸಲಾಗಿದೆ)
• ಭಾಷೆ: ಸಿ ++
• ಆಟದ ಎಂಜಿನ್: ವಿಂಡೋಸ್ ಕನ್ಸೋಲ್
• ಸ್ಫೂರ್ತಿ: ಒಂದು ಪುಸ್ತಕ ಗೇಮ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮೂಲಕ C++ ಆರಂಭ
• ಭಂಡಾರ: GitHub

ಗೇಮ್ ಕ್ರೇಜಿ ಟ್ಯಾಂಕ್

ಕನ್ಸೋಲ್‌ಗೆ ಅಕ್ಷರಗಳನ್ನು ಮುದ್ರಿಸುವುದು ಬಹುಶಃ ನೀವು ಆಟವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದಾದ ಸರಳ ವಿಷಯವಾಗಿದೆ. ಆದರೆ ನಂತರ ಒಂದು ತೊಂದರೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ: ಚಿಹ್ನೆಗಳು ವಿಭಿನ್ನ ಎತ್ತರಗಳು ಮತ್ತು ಅಗಲಗಳನ್ನು ಹೊಂದಿವೆ (ಎತ್ತರವು ಅಗಲಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ). ಈ ರೀತಿಯಾಗಿ, ಎಲ್ಲವೂ ಅನುಪಾತದಿಂದ ಹೊರಗುಳಿಯುತ್ತವೆ ಮತ್ತು ಎಡಕ್ಕೆ ಅಥವಾ ಬಲಕ್ಕೆ ಚಲಿಸುವುದಕ್ಕಿಂತ ಕೆಳಕ್ಕೆ ಅಥವಾ ಮೇಲಕ್ಕೆ ಚಲಿಸುವಿಕೆಯು ಹೆಚ್ಚು ವೇಗವಾಗಿ ಗೋಚರಿಸುತ್ತದೆ. ಹಾವು (ಆಟ 1) ನಲ್ಲಿ ಈ ಪರಿಣಾಮವು ಬಹಳ ಗಮನಾರ್ಹವಾಗಿದೆ. "ಟ್ಯಾಂಕ್‌ಗಳು" (ಆಟ 2) ಈ ನ್ಯೂನತೆಯನ್ನು ಹೊಂದಿಲ್ಲ, ಏಕೆಂದರೆ ಅಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ವಿವಿಧ ಬಣ್ಣಗಳೊಂದಿಗೆ ಪರದೆಯ ಪಿಕ್ಸೆಲ್‌ಗಳನ್ನು ಚಿತ್ರಿಸುವ ಮೂಲಕ ಆಯೋಜಿಸಲಾಗಿದೆ. ನಾನು ರೆಂಡರರ್ ಬರೆದಿದ್ದೇನೆ ಎಂದು ನೀವು ಹೇಳಬಹುದು. ನಿಜ, ಇದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ, ಆದರೂ ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ.

ಈ ಆಟಕ್ಕಾಗಿ, ಪರದೆಯ ಮೇಲೆ ಪಿಕ್ಸೆಲ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ನನ್ನ ಸಿಸ್ಟಮ್ ಅನ್ನು ವಿವರಿಸಲು ಸಾಕು. ನಾನು ಇದನ್ನು ಆಟದ ಮುಖ್ಯ ಭಾಗವೆಂದು ಪರಿಗಣಿಸುತ್ತೇನೆ. ಮತ್ತು ನೀವು ಎಲ್ಲವನ್ನೂ ನೀವೇ ಬರಬಹುದು.

ಆದ್ದರಿಂದ, ನೀವು ಪರದೆಯ ಮೇಲೆ ನೋಡುತ್ತಿರುವುದು ಕೇವಲ ಚಲಿಸುವ ಬಣ್ಣದ ಆಯತಗಳ ಗುಂಪಾಗಿದೆ.

ಆಯತಗಳ ಸೆಟ್

ಪ್ರತಿಯೊಂದು ಆಯತವನ್ನು ಸಂಖ್ಯೆಗಳಿಂದ ತುಂಬಿದ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಮೂಲಕ, ನಾನು ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸವನ್ನು ಹೈಲೈಟ್ ಮಾಡಬಹುದು - ಆಟದಲ್ಲಿನ ಎಲ್ಲಾ ಮ್ಯಾಟ್ರಿಕ್ಸ್‌ಗಳನ್ನು ಒಂದು ಆಯಾಮದ ರಚನೆಯಂತೆ ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲಾಗಿದೆ. ಎರಡು ಆಯಾಮಗಳಲ್ಲ, ಆದರೆ ಒಂದು ಆಯಾಮ! ಒಂದು ಆಯಾಮದ ಅರೇಗಳು ಕೆಲಸ ಮಾಡಲು ಹೆಚ್ಚು ಸುಲಭ ಮತ್ತು ವೇಗವಾಗಿರುತ್ತದೆ.

ಆಟದ ಟ್ಯಾಂಕ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್‌ನ ಉದಾಹರಣೆ

ಒಂದು ಆಯಾಮದ ಅರೇಯೊಂದಿಗೆ ಗೇಮ್ ಟ್ಯಾಂಕ್‌ನ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

ಒಂದು ಆಯಾಮದ ಅರೇ ಮೂಲಕ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಪ್ರಾತಿನಿಧ್ಯದ ಹೆಚ್ಚು ವಿವರಣಾತ್ಮಕ ಉದಾಹರಣೆ

ಆದರೆ ರಚನೆಯ ಅಂಶಗಳಿಗೆ ಪ್ರವೇಶವು ಡಬಲ್ ಲೂಪ್ನಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ, ಅದು ಒಂದು ಆಯಾಮದ ರಚನೆಯಲ್ಲ, ಆದರೆ ಎರಡು ಆಯಾಮದ ಒಂದು. ನಾವು ಇನ್ನೂ ಮ್ಯಾಟ್ರಿಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿರುವುದರಿಂದ ಇದನ್ನು ಮಾಡಲಾಗಿದೆ.

ಡಬಲ್ ಲೂಪ್‌ನಲ್ಲಿ ಏಕ-ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುವುದು. Y ಎಂಬುದು ಸಾಲು ID, X ಎಂಬುದು ಕಾಲಮ್ ID ಆಗಿದೆ

ದಯವಿಟ್ಟು ಗಮನಿಸಿ: ಸಾಮಾನ್ಯ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಐಡೆಂಟಿಫೈಯರ್‌ಗಳ ಬದಲಿಗೆ i, j, ನಾನು x ಮತ್ತು y ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಬಳಸುತ್ತೇನೆ. ಈ ರೀತಿಯಾಗಿ, ಇದು ನನಗೆ ತೋರುತ್ತದೆ, ಇದು ಕಣ್ಣಿಗೆ ಹೆಚ್ಚು ಆಹ್ಲಾದಕರವಾಗಿರುತ್ತದೆ ಮತ್ತು ಮೆದುಳಿಗೆ ಹೆಚ್ಚು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅಂತಹ ಸಂಕೇತವು ಎರಡು ಆಯಾಮದ ಚಿತ್ರದ ನಿರ್ದೇಶಾಂಕ ಅಕ್ಷಗಳ ಮೇಲೆ ಬಳಸಿದ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಅನುಕೂಲಕರವಾಗಿ ಯೋಜಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.

ಈಗ ಪಿಕ್ಸೆಲ್‌ಗಳು, ಬಣ್ಣ ಮತ್ತು ಪರದೆಯ ಔಟ್‌ಪುಟ್ ಬಗ್ಗೆ. StretchDIBits ಕಾರ್ಯವನ್ನು ಔಟ್‌ಪುಟ್‌ಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ (ಹೆಡರ್: windows.h; ಲೈಬ್ರರಿ: gdi32.lib). ಈ ಕಾರ್ಯವು ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪಡೆಯುತ್ತದೆ: ಚಿತ್ರವನ್ನು ಪ್ರದರ್ಶಿಸುವ ಸಾಧನ (ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ವಿಂಡೋಸ್ ಕನ್ಸೋಲ್ ಆಗಿದೆ), ಚಿತ್ರದ ಪ್ರದರ್ಶನದ ಪ್ರಾರಂಭದ ನಿರ್ದೇಶಾಂಕಗಳು, ಅದರ ಅಗಲ / ಎತ್ತರ ಮತ್ತು ಚಿತ್ರವು ಸ್ವತಃ ಬಿಟ್‌ಮ್ಯಾಪ್‌ನ ರೂಪ, ಬೈಟ್‌ಗಳ ಶ್ರೇಣಿಯಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಬೈಟ್ ಅರೇ ಆಗಿ ಬಿಟ್‌ಮ್ಯಾಪ್!

StretchDIBits() ಕಾರ್ಯವು ಕ್ರಿಯೆಯಲ್ಲಿದೆ:

// screen output for game field
   StretchDIBits(
               deviceContext,
               OFFSET_LEFT, OFFSET_TOP,
               PMATRIX_WIDTH, PMATRIX_HEIGHT,
               0, 0,
               PMATRIX_WIDTH, PMATRIX_HEIGHT,
               m_p_bitmapMemory, &bitmapInfo,
               DIB_RGB_COLORS,
               SRCCOPY
               );

VirtualAlloc() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಾಗಿ ಮೆಮೊರಿಯನ್ನು ಮುಂಚಿತವಾಗಿ ಹಂಚಲಾಗುತ್ತದೆ. ಅಂದರೆ, ಎಲ್ಲಾ ಪಿಕ್ಸೆಲ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಅಗತ್ಯವಿರುವ ಸಂಖ್ಯೆಯ ಬೈಟ್‌ಗಳನ್ನು ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ, ನಂತರ ಅದನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

m_p_bitmapMemory ಬಿಟ್‌ಮ್ಯಾಪ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ:

// create bitmap
   int bitmapMemorySize = (PMATRIX_WIDTH * PMATRIX_HEIGHT) * BYTES_PER_PIXEL;
   void* m_p_bitmapMemory = VirtualAlloc(0, bitmapMemorySize, MEM_COMMIT, PAGE_READWRITE);

ಸ್ಥೂಲವಾಗಿ ಹೇಳುವುದಾದರೆ, ಬಿಟ್‌ಮ್ಯಾಪ್ ಪಿಕ್ಸೆಲ್‌ಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ರಚನೆಯ ಪ್ರತಿ ನಾಲ್ಕು ಬೈಟ್‌ಗಳು RGB ಪಿಕ್ಸೆಲ್ ಆಗಿದೆ. ಪ್ರತಿ ಕೆಂಪು ಬಣ್ಣದ ಮೌಲ್ಯಕ್ಕೆ ಒಂದು ಬೈಟ್, ಹಸಿರು ಬಣ್ಣದ ಮೌಲ್ಯಕ್ಕೆ ಒಂದು ಬೈಟ್ (G), ಮತ್ತು ಪ್ರತಿ ನೀಲಿ ಬಣ್ಣದ ಮೌಲ್ಯಕ್ಕೆ ಒಂದು ಬೈಟ್ (B). ಜೊತೆಗೆ ಇಂಡೆಂಟೇಶನ್‌ಗೆ ಒಂದು ಬೈಟ್ ಉಳಿದಿದೆ. ಈ ಮೂರು ಬಣ್ಣಗಳು - ಕೆಂಪು/ಹಸಿರು/ನೀಲಿ (RGB) - ಪರಿಣಾಮವಾಗಿ ಪಿಕ್ಸೆಲ್ ಬಣ್ಣವನ್ನು ರಚಿಸಲು ವಿಭಿನ್ನ ಪ್ರಮಾಣದಲ್ಲಿ ಪರಸ್ಪರ ಬೆರೆಸಲಾಗುತ್ತದೆ.

ಈಗ, ಮತ್ತೊಮ್ಮೆ, ಪ್ರತಿ ಆಯತ ಅಥವಾ ಆಟದ ವಸ್ತುವನ್ನು ಸಂಖ್ಯೆಯ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈ ಎಲ್ಲಾ ಆಟದ ವಸ್ತುಗಳನ್ನು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಇರಿಸಲಾಗಿದೆ. ತದನಂತರ ಅವುಗಳನ್ನು ಆಟದ ಮೈದಾನದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯಾತ್ಮಕ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ. ನಾನು ಮ್ಯಾಟ್ರಿಕ್ಸ್‌ನಲ್ಲಿ ಪ್ರತಿ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟ ಬಣ್ಣಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡಿದ್ದೇನೆ. ಉದಾಹರಣೆಗೆ, ಸಂಖ್ಯೆ 8 ನೀಲಿ, ಸಂಖ್ಯೆ 9 ಹಳದಿ, ಸಂಖ್ಯೆ 10 ಗಾಢ ಬೂದು, ಇತ್ಯಾದಿ. ಹೀಗಾಗಿ, ನಾವು ಆಟದ ಮೈದಾನದ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳಬಹುದು, ಅಲ್ಲಿ ಪ್ರತಿ ಸಂಖ್ಯೆಯು ಕೆಲವು ರೀತಿಯ ಬಣ್ಣವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಒಂದು ಕಡೆ ಸಂಪೂರ್ಣ ಆಟದ ಮೈದಾನದ ಸಂಖ್ಯಾತ್ಮಕ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಇನ್ನೊಂದೆಡೆ ಚಿತ್ರವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಬಿಟ್ಮ್ಯಾಪ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಇಲ್ಲಿಯವರೆಗೆ, ಬಿಟ್ಮ್ಯಾಪ್ "ಖಾಲಿ" - ಇದು ಇನ್ನೂ ಬಯಸಿದ ಬಣ್ಣದ ಪಿಕ್ಸೆಲ್ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿಲ್ಲ. ಇದರರ್ಥ ಆಟದ ಮೈದಾನದ ಸಂಖ್ಯಾ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಆಧರಿಸಿ ಪ್ರತಿ ಪಿಕ್ಸೆಲ್‌ನ ಮಾಹಿತಿಯೊಂದಿಗೆ ಬಿಟ್‌ಮ್ಯಾಪ್ ಅನ್ನು ಜನಪ್ರಿಯಗೊಳಿಸುವುದು ಕೊನೆಯ ಹಂತವಾಗಿದೆ. ಅಂತಹ ರೂಪಾಂತರದ ಸ್ಪಷ್ಟ ಉದಾಹರಣೆ ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿದೆ.

ಆಟದ ಮೈದಾನದ ಡಿಜಿಟಲ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಆಧಾರಿತ ಮಾಹಿತಿಯೊಂದಿಗೆ ಬಿಟ್‌ಮ್ಯಾಪ್ (ಪಿಕ್ಸೆಲ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್) ಅನ್ನು ಭರ್ತಿ ಮಾಡುವ ಉದಾಹರಣೆ (ಬಣ್ಣ ಸೂಚ್ಯಂಕಗಳು ಆಟದಲ್ಲಿನ ಸೂಚ್ಯಂಕಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ)

ನಾನು ಆಟದಿಂದ ನಿಜವಾದ ಕೋಡ್‌ನ ತುಣುಕನ್ನು ಸಹ ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇನೆ. ಲೂಪ್‌ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿನ ವೇರಿಯಬಲ್ ಕಲರ್ ಇಂಡೆಕ್ಸ್ ಆಟದ ಮೈದಾನದ ಸಂಖ್ಯಾ ಮ್ಯಾಟ್ರಿಕ್ಸ್‌ನಿಂದ (ಮುಖ್ಯ ಡಿಜಿಟಲ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್) ಮೌಲ್ಯವನ್ನು (ಬಣ್ಣ ಸೂಚ್ಯಂಕ) ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ನಂತರ ಬಣ್ಣ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸೂಚ್ಯಂಕದ ಆಧಾರದ ಮೇಲೆ ಬಣ್ಣಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ. ಪರಿಣಾಮವಾಗಿ ಬಣ್ಣವನ್ನು ನಂತರ ಕೆಂಪು, ಹಸಿರು ಮತ್ತು ನೀಲಿ (RGB) ಅನುಪಾತದಲ್ಲಿ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಮತ್ತು ಪಿಕ್ಸೆಲ್‌ಪ್ಯಾಡಿಂಗ್ ಜೊತೆಗೆ, ಈ ಮಾಹಿತಿಯನ್ನು ಪಿಕ್ಸೆಲ್‌ನಲ್ಲಿ ಮತ್ತೆ ಮತ್ತೆ ಬರೆಯಲಾಗುತ್ತದೆ, ಬಿಟ್‌ಮ್ಯಾಪ್‌ನಲ್ಲಿ ಬಣ್ಣದ ಚಿತ್ರವನ್ನು ರೂಪಿಸುತ್ತದೆ.

ಕೋಡ್ ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ಬಿಟ್‌ವೈಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟವಾಗುತ್ತದೆ. ಹಾಗಾಗಿ ಅಂತಹ ರಚನೆಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಎಲ್ಲೋ ಪ್ರತ್ಯೇಕವಾಗಿ ಓದಲು ನಾನು ನಿಮಗೆ ಸಲಹೆ ನೀಡುತ್ತೇನೆ.

ಆಟದ ಮೈದಾನದ ಸಂಖ್ಯಾತ್ಮಕ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಆಧಾರದ ಮೇಲೆ ಮಾಹಿತಿಯೊಂದಿಗೆ ಬಿಟ್ಮ್ಯಾಪ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡುವುದು:

// set pixel map variables
   int colorIndex;
   COLORREF color;
   int pitch;
   uint8_t* p_row;
 
   // arrange pixels for game field
   pitch = PMATRIX_WIDTH * BYTES_PER_PIXEL;     // row size in bytes
   p_row = (uint8_t*)m_p_bitmapMemory;       //cast to uint8 for valid pointer arithmetic
   							(to add by 1 byte (8 bits) at a time)   
   for (int y = 0; y < PMATRIX_HEIGHT; ++y)
   {
       uint32_t* p_pixel = (uint32_t*)p_row;
       for (int x = 0; x < PMATRIX_WIDTH; ++x)
       {
           colorIndex = mainDigitalMatrix[y * PMATRIX_WIDTH + x];
           color = Utils::GetColor(colorIndex);
           uint8_t blue = GetBValue(color);
           uint8_t green = GetGValue(color);
           uint8_t red = GetRValue(color);
           uint8_t pixelPadding = 0;
 
           *p_pixel = ((pixelPadding << 24) | (red << 16) | (green << 8) | blue);
           ++p_pixel;
       }
       p_row += pitch;
   }

ಮೇಲೆ ವಿವರಿಸಿದ ವಿಧಾನದ ಪ್ರಕಾರ, ಕ್ರೇಜಿ ಟ್ಯಾಂಕ್ಸ್ ಆಟದಲ್ಲಿ ಒಂದು ಚಿತ್ರ (ಫ್ರೇಮ್) ರಚನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಡ್ರಾ () ಕಾರ್ಯದಲ್ಲಿ ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಇನ್‌ಪುಟ್ () ಕಾರ್ಯದಲ್ಲಿ ಕೀಸ್ಟ್ರೋಕ್‌ಗಳನ್ನು ನೋಂದಾಯಿಸಿದ ನಂತರ ಮತ್ತು ಲಾಜಿಕ್ () ಕಾರ್ಯದಲ್ಲಿ ಅವುಗಳ ನಂತರದ ಸಂಸ್ಕರಣೆಯ ನಂತರ, ಹೊಸ ಚಿತ್ರ (ಫ್ರೇಮ್) ರಚನೆಯಾಗುತ್ತದೆ. ನಿಜ, ಆಟದ ವಸ್ತುಗಳು ಈಗಾಗಲೇ ಆಟದ ಮೈದಾನದಲ್ಲಿ ವಿಭಿನ್ನ ಸ್ಥಾನವನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಅದರ ಪ್ರಕಾರ, ಬೇರೆ ಸ್ಥಳದಲ್ಲಿ ಎಳೆಯಲಾಗುತ್ತದೆ. ಅನಿಮೇಷನ್ (ಚಲನೆ) ಹೀಗೆ ನಡೆಯುತ್ತದೆ.

ಸಿದ್ಧಾಂತದಲ್ಲಿ (ನಾನು ಏನನ್ನೂ ಮರೆತಿಲ್ಲದಿದ್ದರೆ), ಮೊದಲ ಆಟದಿಂದ (“ಹಾವು”) ಆಟದ ಲೂಪ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಎರಡನೇ ಆಟದಿಂದ (“ಟ್ಯಾಂಕ್‌ಗಳು”) ಪರದೆಯ ಮೇಲೆ ಪಿಕ್ಸೆಲ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವ ವ್ಯವಸ್ಥೆ (“ಟ್ಯಾಂಕ್‌ಗಳು”) ನೀವು ಯಾವುದನ್ನಾದರೂ ಬರೆಯಬೇಕಾಗಿದೆ ವಿಂಡೋಸ್ ಅಡಿಯಲ್ಲಿ ನಿಮ್ಮ 2D ಆಟಗಳು. ಶಬ್ದರಹಿತ! 😉 ಉಳಿದ ಭಾಗಗಳು ಕೇವಲ ಅಲಂಕಾರಿಕವಾಗಿವೆ.

ಸಹಜವಾಗಿ, "ಟ್ಯಾಂಕ್ಸ್" ಆಟವು "ಸ್ನೇಕ್" ಗಿಂತ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ. ನಾನು ಈಗಾಗಲೇ C ++ ಭಾಷೆಯನ್ನು ಬಳಸಿದ್ದೇನೆ, ಅಂದರೆ, ನಾನು ತರಗತಿಗಳೊಂದಿಗೆ ವಿವಿಧ ಆಟದ ವಸ್ತುಗಳನ್ನು ವಿವರಿಸಿದ್ದೇನೆ. ನಾನು ನನ್ನ ಸ್ವಂತ ಸಂಗ್ರಹವನ್ನು ರಚಿಸಿದ್ದೇನೆ - ಕೋಡ್ ಅನ್ನು headers/Box.h ನಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದು. ಮೂಲಕ, ಸಂಗ್ರಹಣೆಯು ಹೆಚ್ಚಾಗಿ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ಹೊಂದಿದೆ. ಬಳಸಿದ ಪಾಯಿಂಟರ್‌ಗಳು. ಸ್ಮರಣೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದೆ. ಪುಸ್ತಕ ನನಗೆ ತುಂಬಾ ಸಹಾಯ ಮಾಡಿದೆ ಎಂದು ನಾನು ಹೇಳಲೇಬೇಕು ಗೇಮ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮೂಲಕ C++ ಆರಂಭ. C++ ನಲ್ಲಿ ಆರಂಭಿಕರಿಗಾಗಿ ಇದು ಉತ್ತಮ ಆರಂಭವಾಗಿದೆ. ಇದು ಚಿಕ್ಕದಾಗಿದೆ, ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ ಮತ್ತು ಉತ್ತಮವಾಗಿ ಸಂಘಟಿತವಾಗಿದೆ.

ಈ ಆಟವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಸುಮಾರು ಆರು ತಿಂಗಳುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ನಾನು ಮುಖ್ಯವಾಗಿ ಊಟದ ಸಮಯದಲ್ಲಿ ಮತ್ತು ಕೆಲಸದಲ್ಲಿ ತಿಂಡಿಗಳ ಸಮಯದಲ್ಲಿ ಬರೆದಿದ್ದೇನೆ. ಕಛೇರಿಯ ಅಡುಗೆಮನೆಯಲ್ಲಿ ಕುಳಿತು ತಿಂಡಿ ತಿಂದು ಕೋಡ್ ಬರೆಸಿದರು. ಅಥವಾ ಮನೆಯಲ್ಲಿ ಊಟದಲ್ಲಿ. ಹಾಗಾಗಿ ನನಗೆ ಅಂತಹ "ಅಡುಗೆ ಯುದ್ಧಗಳು" ಸಿಕ್ಕಿತು. ಯಾವಾಗಲೂ ಹಾಗೆ, ನಾನು ನೋಟ್ಬುಕ್ ಅನ್ನು ಸಕ್ರಿಯವಾಗಿ ಬಳಸಿದ್ದೇನೆ ಮತ್ತು ಎಲ್ಲಾ ಪರಿಕಲ್ಪನಾ ವಿಷಯಗಳು ಅದರಲ್ಲಿ ಜನಿಸಿದವು.

ಪ್ರಾಯೋಗಿಕ ಭಾಗವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು, ನಾನು ನನ್ನ ನೋಟ್‌ಬುಕ್‌ನ ಕೆಲವು ಸ್ಕ್ಯಾನ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇನೆ. ನಾನು ನಿಖರವಾಗಿ ಏನು ಬರೆದಿದ್ದೇನೆ, ಚಿತ್ರಿಸಿದೆ, ಎಣಿಸಿದೆ, ವಿನ್ಯಾಸಗೊಳಿಸಿದ್ದೇನೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು...

ಟ್ಯಾಂಕ್‌ಗಳ ಚಿತ್ರಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು. ಮತ್ತು ಪರದೆಯ ಮೇಲೆ ಪ್ರತಿ ಟ್ಯಾಂಕ್ ಎಷ್ಟು ಪಿಕ್ಸೆಲ್‌ಗಳನ್ನು ಆಕ್ರಮಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸುವುದು

ಅದರ ಅಕ್ಷದ ಸುತ್ತ ತೊಟ್ಟಿಯ ತಿರುಗುವಿಕೆಗೆ ಅಲ್ಗಾರಿದಮ್ ಮತ್ತು ಸೂತ್ರಗಳ ಲೆಕ್ಕಾಚಾರ

ನನ್ನ ಸಂಗ್ರಹಣೆಯ ಸ್ಕೀಮ್ (ಮೆಮೊರಿ ಲೀಕ್ ಇರುವ, ಹೆಚ್ಚಾಗಿ). ಲಿಂಕ್ಡ್ ಪಟ್ಟಿ ಪ್ರಕಾರದ ಪ್ರಕಾರ ಸಂಗ್ರಹವನ್ನು ರಚಿಸಲಾಗಿದೆ

ಮತ್ತು ಇವು ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯನ್ನು ಆಟಕ್ಕೆ ತಿರುಗಿಸುವ ವ್ಯರ್ಥ ಪ್ರಯತ್ನಗಳಾಗಿವೆ

ಸಿದ್ಧಾಂತ

"ಸಾವಿರ ಮೈಲುಗಳ ಪ್ರಯಾಣವೂ ಮೊದಲ ಹೆಜ್ಜೆಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ" (ಪ್ರಾಚೀನ ಚೀನೀ ಬುದ್ಧಿವಂತಿಕೆ)

ಅಭ್ಯಾಸದಿಂದ ಸಿದ್ಧಾಂತಕ್ಕೆ ಹೋಗೋಣ! ನಿಮ್ಮ ಹವ್ಯಾಸಕ್ಕಾಗಿ ಸಮಯವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಹೇಗೆ?

1. ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಬೇಕಾದುದನ್ನು ನಿರ್ಧರಿಸಿ (ಅಯ್ಯೋ, ಇದು ಕಠಿಣ ಭಾಗವಾಗಿದೆ).
2. ಆದ್ಯತೆಗಳನ್ನು ಹೊಂದಿಸಿ.
3. ಹೆಚ್ಚಿನ ಆದ್ಯತೆಗಳಿಗಾಗಿ "ಹೆಚ್ಚುವರಿ" ಎಲ್ಲವನ್ನೂ ತ್ಯಾಗ ಮಾಡಿ.
4. ಪ್ರತಿದಿನ ಗುರಿಯತ್ತ ಸಾಗಿ.
5. ಹವ್ಯಾಸದಲ್ಲಿ ಕಳೆಯಲು ಎರಡು ಅಥವಾ ಮೂರು ಗಂಟೆಗಳ ಉಚಿತ ಸಮಯವನ್ನು ನಿರೀಕ್ಷಿಸಬೇಡಿ.

ಒಂದೆಡೆ, ನಿಮಗೆ ಬೇಕಾದುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬೇಕು ಮತ್ತು ಆದ್ಯತೆ ನೀಡಬೇಕು. ಮತ್ತೊಂದೆಡೆ, ಈ ಆದ್ಯತೆಗಳ ಪರವಾಗಿ ಕೆಲವು ಚಟುವಟಿಕೆಗಳು/ಯೋಜನೆಗಳನ್ನು ತ್ಯಜಿಸಲು ಸಾಧ್ಯವಿದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನೀವು ಎಲ್ಲವನ್ನೂ "ಹೆಚ್ಚುವರಿ" ತ್ಯಾಗ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಜೀವನದಲ್ಲಿ ಗರಿಷ್ಠ ಮೂರು ಮುಖ್ಯ ಚಟುವಟಿಕೆಗಳು ಇರಬೇಕು ಎಂದು ನಾನು ಎಲ್ಲೋ ಕೇಳಿದ್ದೇನೆ. ನಂತರ ನೀವು ಅವುಗಳನ್ನು ಉತ್ತಮ ಗುಣಮಟ್ಟದಲ್ಲಿ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಮತ್ತು ಹೆಚ್ಚುವರಿ ಯೋಜನೆಗಳು/ನಿರ್ದೇಶನಗಳು ಸರಳವಾಗಿ ಓವರ್ಲೋಡ್ ಆಗಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಆದರೆ ಇದೆಲ್ಲವೂ ಬಹುಶಃ ವ್ಯಕ್ತಿನಿಷ್ಠ ಮತ್ತು ವೈಯಕ್ತಿಕ.

ಒಂದು ನಿರ್ದಿಷ್ಟ ಗೋಲ್ಡನ್ ರೂಲ್ ಇದೆ: ಎಂದಿಗೂ 0% ದಿನವನ್ನು ಹೊಂದಿಲ್ಲ! ಇಂಡೀ ಡೆವಲಪರ್‌ನ ಲೇಖನವೊಂದರಲ್ಲಿ ನಾನು ಅದರ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೇನೆ. ನೀವು ಯೋಜನೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಪ್ರತಿದಿನ ಅದರ ಬಗ್ಗೆ ಏನಾದರೂ ಮಾಡಿ. ಮತ್ತು ನೀವು ಎಷ್ಟು ಸಂಪಾದಿಸುತ್ತೀರಿ ಎಂಬುದು ಮುಖ್ಯವಲ್ಲ. ಒಂದು ಪದ ಅಥವಾ ಒಂದು ಸಾಲಿನ ಕೋಡ್ ಅನ್ನು ಬರೆಯಿರಿ, ಒಂದು ಟ್ಯುಟೋರಿಯಲ್ ವೀಡಿಯೊವನ್ನು ವೀಕ್ಷಿಸಿ ಅಥವಾ ಒಂದು ಮೊಳೆಯನ್ನು ಬೋರ್ಡ್‌ಗೆ ಬಡಿಯಿರಿ - ಏನಾದರೂ ಮಾಡಿ. ಕಠಿಣ ಭಾಗವು ಪ್ರಾರಂಭಿಸುತ್ತಿದೆ. ಒಮ್ಮೆ ನೀವು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನೀವು ಬಯಸಿದ್ದಕ್ಕಿಂತ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಮಾಡುತ್ತೀರಿ. ಆದ್ದರಿಂದ ನೀವು ನಿರಂತರವಾಗಿ ನಿಮ್ಮ ಗುರಿಯತ್ತ ಸಾಗುತ್ತೀರಿ ಮತ್ತು ನನ್ನನ್ನು ನಂಬಿರಿ, ಬೇಗನೆ. ಎಲ್ಲಾ ನಂತರ, ಎಲ್ಲಾ ವಿಷಯಗಳ ಮೇಲೆ ಮುಖ್ಯ ಬ್ರೇಕ್ ವಿಳಂಬವಾಗಿದೆ.

ಮತ್ತು 5, 10, 15 ನಿಮಿಷಗಳ ಸಮಯದ ಉಚಿತ "ಮರದ ಪುಡಿ" ಅನ್ನು ನೀವು ಕಡಿಮೆ ಅಂದಾಜು ಮಾಡಬಾರದು ಮತ್ತು ನಿರ್ಲಕ್ಷಿಸಬಾರದು ಎಂದು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ, ಒಂದು ಗಂಟೆ ಅಥವಾ ಎರಡು ಗಂಟೆಗಳ ಕಾಲ ಕೆಲವು ದೊಡ್ಡ "ಲಾಗ್ಗಳು" ನಿರೀಕ್ಷಿಸಿ. ನೀವು ಸಾಲಿನಲ್ಲಿ ನಿಂತಿದ್ದೀರಾ? ನಿಮ್ಮ ಯೋಜನೆಗಾಗಿ ಏನಾದರೂ ಯೋಚಿಸಿ. ಎಸ್ಕಲೇಟರ್ ತೆಗೆದುಕೊಳ್ಳುವುದೇ? ನೋಟ್‌ಪ್ಯಾಡ್‌ನಲ್ಲಿ ಏನನ್ನಾದರೂ ಬರೆಯಿರಿ. ನೀವು ಬಸ್ಸಿನಲ್ಲಿ ಪ್ರಯಾಣಿಸುತ್ತಿದ್ದೀರಾ? ಅದ್ಭುತವಾಗಿದೆ, ಕೆಲವು ಲೇಖನಗಳನ್ನು ಓದಿ. ಪ್ರತಿಯೊಂದು ಅವಕಾಶವನ್ನು ಬಳಸಿಕೊಳ್ಳಿ. YouTube ನಲ್ಲಿ ಬೆಕ್ಕುಗಳು ಮತ್ತು ನಾಯಿಗಳನ್ನು ನೋಡುವುದನ್ನು ನಿಲ್ಲಿಸಿ! ನಿಮ್ಮ ಮೆದುಳನ್ನು ಕಲುಷಿತಗೊಳಿಸಬೇಡಿ!

ಮತ್ತು ಕೊನೆಯ ವಿಷಯ. ಈ ಲೇಖನವನ್ನು ಓದಿದ ನಂತರ, ಆಟದ ಎಂಜಿನ್‌ಗಳನ್ನು ಬಳಸದೆ ಆಟಗಳನ್ನು ರಚಿಸುವ ಕಲ್ಪನೆಯನ್ನು ನೀವು ಇಷ್ಟಪಟ್ಟರೆ, ನಂತರ ಕೇಸಿ ಮುರಾಟೋರಿ ಹೆಸರನ್ನು ನೆನಪಿಡಿ. ಈ ವ್ಯಕ್ತಿ ಹೊಂದಿದ್ದಾನೆ ವೆಬ್ಸೈಟ್. "ವಾಚ್ -> ಹಿಂದಿನ ಸಂಚಿಕೆಗಳು" ವಿಭಾಗದಲ್ಲಿ ನೀವು ಮೊದಲಿನಿಂದ ವೃತ್ತಿಪರ ಆಟವನ್ನು ರಚಿಸುವ ಅದ್ಭುತ ಉಚಿತ ವೀಡಿಯೊ ಟ್ಯುಟೋರಿಯಲ್‌ಗಳನ್ನು ಕಾಣಬಹುದು. ವಿಂಡೋಸ್ ಪಾಠಗಳಿಗಾಗಿ ಸಿ ಗೆ ಐದು ಪರಿಚಯದಲ್ಲಿ ನೀವು ಬಹುಶಃ ಐದು ವರ್ಷಗಳ ವಿಶ್ವವಿದ್ಯಾನಿಲಯದ ಅಧ್ಯಯನಕ್ಕಿಂತ ಹೆಚ್ಚಿನದನ್ನು ಕಲಿಯುವಿರಿ (ಯಾರಾದರೂ ವೀಡಿಯೊದ ಅಡಿಯಲ್ಲಿ ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಇದರ ಬಗ್ಗೆ ಬರೆದಿದ್ದಾರೆ).

ನಿಮ್ಮ ಸ್ವಂತ ಆಟದ ಎಂಜಿನ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಮೂಲಕ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಯಾವುದೇ ಎಂಜಿನ್‌ಗಳ ಬಗ್ಗೆ ನೀವು ಉತ್ತಮ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತೀರಿ ಎಂದು ಕೇಸಿ ವಿವರಿಸುತ್ತಾರೆ. ಚೌಕಟ್ಟುಗಳ ಜಗತ್ತಿನಲ್ಲಿ, ಪ್ರತಿಯೊಬ್ಬರೂ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ, ನೀವು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಕಲಿಯುವಿರಿ, ಬಳಸಬೇಡಿ. ಕಂಪ್ಯೂಟರ್‌ಗಳ ಸ್ವರೂಪವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ. ಮತ್ತು ನೀವು ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ ಮತ್ತು ಪ್ರಬುದ್ಧ ಪ್ರೋಗ್ರಾಮರ್ ಆಗುತ್ತೀರಿ - ಪರ.

ನೀವು ಆಯ್ಕೆ ಮಾಡಿದ ಹಾದಿಯಲ್ಲಿ ಅದೃಷ್ಟ! ಮತ್ತು ಜಗತ್ತನ್ನು ಹೆಚ್ಚು ವೃತ್ತಿಪರವಾಗಿಸೋಣ.

ಲೇಖಕ: ಗ್ರ್ಯಾಂಕಿನ್ ಆಂಡ್ರೆ, DevOps

ಮೂಲ: www.habr.com