DevOps C++ ਅਤੇ "ਕਿਚਨ ਵਾਰਜ਼", ਜਾਂ ਮੈਂ ਖਾਣਾ ਖਾਂਦੇ ਸਮੇਂ ਗੇਮਾਂ ਕਿਵੇਂ ਲਿਖਣੀਆਂ ਸ਼ੁਰੂ ਕੀਤੀਆਂ

"ਮੈਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਮੈਂ ਕੁਝ ਨਹੀਂ ਜਾਣਦਾ" ਸੁਕਰਾਤ

ਕਿਸਦੇ ਲਈ: IT ਲੋਕਾਂ ਲਈ ਜੋ ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ 'ਤੇ ਥੁੱਕਦੇ ਹਨ ਅਤੇ ਆਪਣੀਆਂ ਗੇਮਾਂ ਖੇਡਣਾ ਚਾਹੁੰਦੇ ਹਨ!

ਕਿਸ ਬਾਰੇ ਵਿਚ: ਜੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਹੈ ਤਾਂ C/C++ ਵਿੱਚ ਗੇਮਾਂ ਲਿਖਣਾ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕਰੀਏ!

ਤੁਹਾਨੂੰ ਇਹ ਕਿਉਂ ਪੜ੍ਹਨਾ ਚਾਹੀਦਾ ਹੈ: ਐਪ ਡਿਵੈਲਪਮੈਂਟ ਮੇਰੇ ਕੰਮ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਨਹੀਂ ਹੈ, ਪਰ ਮੈਂ ਹਰ ਹਫ਼ਤੇ ਕੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹਾਂ। ਕਿਉਂਕਿ ਮੈਨੂੰ ਖੇਡਾਂ ਪਸੰਦ ਹਨ!

ਸਤ ਸ੍ਰੀ ਅਕਾਲ ਮੇਰਾ ਨਾਮ ਹੈ ਐਂਡਰੀ ਗ੍ਰੈਨਕਿਨ, ਮੈਂ Luxoft ਵਿਖੇ ਇੱਕ DevOps ਹਾਂ। ਐਪਲੀਕੇਸ਼ਨ ਡਿਵੈਲਪਮੈਂਟ ਮੇਰੀ ਕੰਮ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਨਹੀਂ ਹੈ, ਪਰ ਮੈਂ ਹਰ ਹਫ਼ਤੇ ਕੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹਾਂ। ਕਿਉਂਕਿ ਮੈਨੂੰ ਖੇਡਾਂ ਪਸੰਦ ਹਨ!

ਕੰਪਿਊਟਰ ਗੇਮ ਇੰਡਸਟਰੀ ਬਹੁਤ ਵੱਡੀ ਹੈ, ਅੱਜ ਵੀ ਫਿਲਮ ਇੰਡਸਟਰੀ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਅਫਵਾਹ ਹੈ। ਖੇਡਾਂ ਕੰਪਿਊਟਰ ਦੇ ਵਿਕਾਸ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਲੈ ਕੇ, ਆਧੁਨਿਕ ਮਾਪਦੰਡਾਂ ਦੁਆਰਾ, ਗੁੰਝਲਦਾਰ ਅਤੇ ਬੁਨਿਆਦੀ ਵਿਕਾਸ ਤਰੀਕਿਆਂ ਦੁਆਰਾ ਲਿਖੀਆਂ ਗਈਆਂ ਹਨ। ਸਮੇਂ ਦੇ ਨਾਲ, ਗੇਮ ਇੰਜਣ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਪ੍ਰੋਗ੍ਰਾਮ ਕੀਤੇ ਗਰਾਫਿਕਸ, ਭੌਤਿਕ ਵਿਗਿਆਨ ਅਤੇ ਆਵਾਜ਼ ਦੇ ਨਾਲ ਦਿਖਾਈ ਦੇਣ ਲੱਗੇ। ਉਹ ਤੁਹਾਨੂੰ ਖੇਡ ਦੇ ਵਿਕਾਸ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ ਅਤੇ ਇਸਦੀ ਬੁਨਿਆਦ ਬਾਰੇ ਪਰੇਸ਼ਾਨ ਨਹੀਂ ਹੁੰਦੇ ਹਨ. ਪਰ ਉਹਨਾਂ ਦੇ ਨਾਲ, ਇੰਜਣਾਂ ਦੇ ਨਾਲ, ਡਿਵੈਲਪਰ "ਅੰਨ੍ਹੇ ਹੋ ਜਾਂਦੇ ਹਨ" ਅਤੇ ਡੀਗਰੇਡ ਕਰਦੇ ਹਨ. ਖੇਡਾਂ ਦਾ ਬਹੁਤ ਉਤਪਾਦਨ ਕਨਵੇਅਰ 'ਤੇ ਪਾਇਆ ਜਾਂਦਾ ਹੈ. ਅਤੇ ਉਤਪਾਦਨ ਦੀ ਮਾਤਰਾ ਇਸਦੀ ਗੁਣਵੱਤਾ ਉੱਤੇ ਹਾਵੀ ਹੋਣੀ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦੀ ਹੈ।

ਉਸੇ ਸਮੇਂ, ਜਦੋਂ ਹੋਰ ਲੋਕਾਂ ਦੀਆਂ ਗੇਮਾਂ ਖੇਡਦੇ ਹਾਂ, ਅਸੀਂ ਲਗਾਤਾਰ ਸਥਾਨਾਂ, ਪਲਾਟ, ਪਾਤਰਾਂ, ਗੇਮ ਮਕੈਨਿਕਸ ਦੁਆਰਾ ਸੀਮਿਤ ਹੁੰਦੇ ਹਾਂ ਜੋ ਹੋਰ ਲੋਕ ਆਏ ਸਨ। ਇਸ ਲਈ ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ...

... ਇਹ ਤੁਹਾਡੀ ਆਪਣੀ ਦੁਨੀਆ ਬਣਾਉਣ ਦਾ ਸਮਾਂ ਹੈ, ਸਿਰਫ ਮੇਰੇ ਅਧੀਨ। ਸੰਸਾਰ ਜਿੱਥੇ ਮੈਂ ਪਿਤਾ, ਅਤੇ ਪੁੱਤਰ, ਅਤੇ ਪਵਿੱਤਰ ਆਤਮਾ ਹਾਂ!

ਅਤੇ ਮੈਂ ਦਿਲੋਂ ਵਿਸ਼ਵਾਸ ਕਰਦਾ ਹਾਂ ਕਿ ਆਪਣੇ ਖੁਦ ਦੇ ਗੇਮ ਇੰਜਣ ਅਤੇ ਇਸ 'ਤੇ ਇੱਕ ਗੇਮ ਲਿਖ ਕੇ, ਤੁਸੀਂ ਆਪਣੀਆਂ ਅੱਖਾਂ ਖੋਲ੍ਹਣ, ਵਿੰਡੋਜ਼ ਨੂੰ ਪੂੰਝਣ ਅਤੇ ਆਪਣੇ ਕੈਬਿਨ ਨੂੰ ਪੰਪ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੋਗੇ, ਇੱਕ ਵਧੇਰੇ ਤਜਰਬੇਕਾਰ ਅਤੇ ਅਟੁੱਟ ਪ੍ਰੋਗਰਾਮਰ ਬਣੋਗੇ।

ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਤੁਹਾਨੂੰ ਇਹ ਦੱਸਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗਾ ਕਿ ਮੈਂ C/C++ ਵਿੱਚ ਛੋਟੀਆਂ ਖੇਡਾਂ ਕਿਵੇਂ ਲਿਖਣੀਆਂ ਸ਼ੁਰੂ ਕੀਤੀਆਂ, ਵਿਕਾਸ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀ ਹੈ ਅਤੇ ਇੱਕ ਵਿਅਸਤ ਮਾਹੌਲ ਵਿੱਚ ਮੈਂ ਇੱਕ ਸ਼ੌਕ ਲਈ ਸਮਾਂ ਕਿੱਥੇ ਲੱਭਦਾ ਹਾਂ। ਇਹ ਵਿਅਕਤੀਗਤ ਹੈ ਅਤੇ ਇੱਕ ਵਿਅਕਤੀਗਤ ਸ਼ੁਰੂਆਤ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ। ਅਗਿਆਨਤਾ ਅਤੇ ਵਿਸ਼ਵਾਸ ਬਾਰੇ ਸਮੱਗਰੀ, ਇਸ ਸਮੇਂ ਸੰਸਾਰ ਦੀ ਮੇਰੀ ਨਿੱਜੀ ਤਸਵੀਰ ਬਾਰੇ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, "ਪ੍ਰਸ਼ਾਸਨ ਤੁਹਾਡੇ ਨਿੱਜੀ ਦਿਮਾਗਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹੈ!".

ਪ੍ਰੈਕਟਿਸ

"ਅਭਿਆਸ ਤੋਂ ਬਿਨਾਂ ਗਿਆਨ ਬੇਕਾਰ ਹੈ, ਗਿਆਨ ਤੋਂ ਬਿਨਾਂ ਅਭਿਆਸ ਖਤਰਨਾਕ ਹੈ." ਕਨਫਿਊਸ਼ਸ

ਮੇਰੀ ਨੋਟਬੁੱਕ ਮੇਰੀ ਜ਼ਿੰਦਗੀ ਹੈ!

ਇਸ ਲਈ, ਅਭਿਆਸ ਵਿੱਚ, ਮੈਂ ਕਹਿ ਸਕਦਾ ਹਾਂ ਕਿ ਮੇਰੇ ਲਈ ਸਭ ਕੁਝ ਇੱਕ ਨੋਟਬੁੱਕ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ. ਮੈਂ ਉੱਥੇ ਨਾ ਸਿਰਫ਼ ਆਪਣੇ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮਾਂ ਨੂੰ ਲਿਖਦਾ ਹਾਂ, ਸਗੋਂ ਡਰਾਅ, ਪ੍ਰੋਗਰਾਮ, ਡਿਜ਼ਾਈਨ ਫਲੋਚਾਰਟ ਅਤੇ ਗਣਿਤ ਸਮੇਤ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹਾਂ। ਹਮੇਸ਼ਾ ਨੋਟਪੈਡ ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਸਿਰਫ਼ ਪੈਨਸਿਲ ਨਾਲ ਹੀ ਲਿਖੋ। ਇਹ ਸਾਫ਼, ਆਰਾਮਦਾਇਕ ਅਤੇ ਭਰੋਸੇਮੰਦ ਹੈ, IMHO।

ਮੇਰੀ (ਪਹਿਲਾਂ ਹੀ ਭਰੀ ਹੋਈ) ਨੋਟਬੁੱਕ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ, ਵਿਚਾਰ, ਡਰਾਇੰਗ, ਡਾਇਗ੍ਰਾਮ, ਹੱਲ, ਬਲੈਕ ਬੁੱਕਕੀਪਿੰਗ, ਕੋਡ ਆਦਿ ਸ਼ਾਮਲ ਹਨ।

ਇਸ ਪੜਾਅ 'ਤੇ, ਮੈਂ ਤਿੰਨ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਿੱਚ ਕਾਮਯਾਬ ਰਿਹਾ (ਇਹ "ਅੰਤਿਮਤਾ" ਦੀ ਮੇਰੀ ਸਮਝ ਵਿੱਚ ਹੈ, ਕਿਉਂਕਿ ਕੋਈ ਵੀ ਉਤਪਾਦ ਮੁਕਾਬਲਤਨ ਬੇਅੰਤ ਵਿਕਸਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ)।

• ਪ੍ਰੋਜੈਕਟ 0: ਇਹ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ C# ਵਿੱਚ ਲਿਖਿਆ ਇੱਕ ਆਰਕੀਟੈਕਟ ਡੈਮੋ 3D ਸੀਨ ਹੈ। ਮੈਕੋਸ ਅਤੇ ਵਿੰਡੋਜ਼ ਪਲੇਟਫਾਰਮਾਂ ਲਈ।
• ਗੇਮ 1: ਵਿੰਡੋਜ਼ ਲਈ ਕੰਸੋਲ ਗੇਮ ਸਧਾਰਨ ਸੱਪ (ਹਰ ਕੋਈ "ਸੱਪ" ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ)। ਸੀ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ।
• ਗੇਮ 2: ਕੰਸੋਲ ਗੇਮ ਕ੍ਰੇਜ਼ੀ ਟੈਂਕਸ (ਹਰ ਕਿਸੇ ਨੂੰ "ਟੈਂਕ" ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ), ਪਹਿਲਾਂ ਹੀ C ++ (ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ) ਅਤੇ ਵਿੰਡੋਜ਼ ਦੇ ਅਧੀਨ ਲਿਖਿਆ ਗਿਆ ਹੈ।

ਪ੍ਰੋਜੈਕਟ 0 ਆਰਕੀਟੈਕਟ ਡੈਮੋ

• ਪਲੇਟਫਾਰਮ: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
• ਅਜ਼ਮਾਇਸ਼: C#
• ਖੇਡ ਇੰਜਣ: ਏਕਤਾ
• ਪ੍ਰੇਰਨਾ: ਡੈਰਿਨ ਲਿਲ
• ਭੰਡਾਰ: GitHub

3D ਸੀਨ ਆਰਕੀਟੈਕਟ ਡੈਮੋ

ਪਹਿਲਾ ਪ੍ਰੋਜੈਕਟ C/C++ ਵਿੱਚ ਨਹੀਂ, ਸਗੋਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ C# ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਹ ਇੰਜਣ ਹਾਰਡਵੇਅਰ 'ਤੇ ਇੰਨੀ ਮੰਗ ਨਹੀਂ ਸੀ ਜਿੰਨੀ ਨਾਵਲ ਇੰਜਣ, ਅਤੇ ਇਹ ਵੀ ਮੈਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ ਅਤੇ ਵਰਤਣਾ ਆਸਾਨ ਲੱਗਦਾ ਸੀ। ਮੈਂ ਹੋਰ ਇੰਜਣਾਂ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕੀਤਾ।

ਮੇਰੇ ਲਈ ਏਕਤਾ ਦਾ ਟੀਚਾ ਕਿਸੇ ਕਿਸਮ ਦੀ ਖੇਡ ਨੂੰ ਵਿਕਸਤ ਕਰਨਾ ਨਹੀਂ ਸੀ। ਮੈਂ ਕਿਸੇ ਕਿਸਮ ਦੇ ਕਿਰਦਾਰ ਨਾਲ ਇੱਕ 3D ਦ੍ਰਿਸ਼ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਸੀ। ਉਸਨੂੰ, ਜਾਂ ਸਗੋਂ ਉਸਨੇ (ਮੈਂ ਉਸ ਕੁੜੀ ਨੂੰ ਮਾਡਲ ਬਣਾਇਆ ਜਿਸ ਨਾਲ ਮੈਂ ਪਿਆਰ ਵਿੱਚ ਸੀ =) ਨੂੰ ਬਾਹਰੀ ਸੰਸਾਰ ਨਾਲ ਜਾਣ ਅਤੇ ਗੱਲਬਾਤ ਕਰਨੀ ਪਈ। ਏਕਤਾ ਕੀ ਹੁੰਦੀ ਹੈ, ਵਿਕਾਸ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀ ਹੁੰਦੀ ਹੈ ਅਤੇ ਕੁਝ ਬਣਾਉਣ ਲਈ ਕਿੰਨੀ ਮਿਹਨਤ ਕਰਨੀ ਪੈਂਦੀ ਹੈ, ਇਹ ਸਮਝਣਾ ਹੀ ਜ਼ਰੂਰੀ ਸੀ। ਇਸ ਤਰ੍ਹਾਂ ਆਰਕੀਟੈਕਟ ਡੈਮੋ ਪ੍ਰੋਜੈਕਟ ਦਾ ਜਨਮ ਹੋਇਆ ਸੀ (ਨਾਮ ਦੀ ਖੋਜ ਲਗਭਗ ਬਕਵਾਸ ਤੋਂ ਕੀਤੀ ਗਈ ਸੀ)। ਪ੍ਰੋਗਰਾਮਿੰਗ, ਮਾਡਲਿੰਗ, ਐਨੀਮੇਸ਼ਨ, ਟੈਕਸਟਚਰਿੰਗ ਨੇ ਮੈਨੂੰ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਵਿੱਚ ਸ਼ਾਇਦ ਦੋ ਮਹੀਨੇ ਲਏ.

ਮੈਂ ਯੂਟਿਊਬ 'ਤੇ 3D ਮਾਡਲਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਇਸ ਬਾਰੇ ਟਿਊਟੋਰਿਅਲ ਵੀਡੀਓਜ਼ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕੀਤੀ ਬਲੈਡਰ. ਬਲੈਂਡਰ 3D ਮਾਡਲਿੰਗ (ਅਤੇ ਹੋਰ) ਲਈ ਇੱਕ ਵਧੀਆ ਮੁਫ਼ਤ ਟੂਲ ਹੈ ਜਿਸਨੂੰ ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅਤੇ ਇੱਥੇ ਇੱਕ ਝਟਕਾ ਮੇਰਾ ਇੰਤਜ਼ਾਰ ਕਰ ਰਿਹਾ ਸੀ ... ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਮਾਡਲਿੰਗ, ਐਨੀਮੇਸ਼ਨ, ਟੈਕਸਟਚਰਿੰਗ ਵੱਡੇ ਵੱਖਰੇ ਵਿਸ਼ੇ ਹਨ ਜਿਨ੍ਹਾਂ 'ਤੇ ਤੁਸੀਂ ਕਿਤਾਬਾਂ ਲਿਖ ਸਕਦੇ ਹੋ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਪਾਤਰਾਂ ਲਈ ਸੱਚ ਹੈ। ਉਂਗਲਾਂ, ਦੰਦਾਂ, ਅੱਖਾਂ ਅਤੇ ਸਰੀਰ ਦੇ ਹੋਰ ਹਿੱਸਿਆਂ ਦਾ ਮਾਡਲ ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਸਰੀਰ ਵਿਗਿਆਨ ਦੇ ਗਿਆਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਚਿਹਰੇ ਦੀਆਂ ਮਾਸਪੇਸ਼ੀਆਂ ਨੂੰ ਕਿਵੇਂ ਵਿਵਸਥਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ? ਲੋਕ ਕਿਵੇਂ ਚਲੇ ਜਾਂਦੇ ਹਨ? ਮੈਨੂੰ ਹਰ ਇੱਕ ਬਾਂਹ, ਲੱਤ, ਉਂਗਲੀ, ਗੰਢਾਂ ਵਿੱਚ ਹੱਡੀਆਂ ਨੂੰ "ਸੰਮਿਲਿਤ" ਕਰਨਾ ਪਿਆ!

ਕਲੈਵਿਕਲ, ਵਾਧੂ ਹੱਡੀਆਂ ਦੇ ਲੀਵਰਾਂ ਦਾ ਮਾਡਲ ਬਣਾਓ, ਤਾਂ ਜੋ ਐਨੀਮੇਸ਼ਨ ਕੁਦਰਤੀ ਦਿਖਾਈ ਦੇਵੇ। ਅਜਿਹੇ ਪਾਠਾਂ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਅਹਿਸਾਸ ਹੁੰਦਾ ਹੈ ਕਿ ਐਨੀਮੇਟਡ ਫਿਲਮਾਂ ਦੇ ਨਿਰਮਾਤਾ ਸਿਰਫ 30 ਸਕਿੰਟ ਦੀ ਵੀਡੀਓ ਬਣਾਉਣ ਲਈ ਕਿੰਨਾ ਵੱਡਾ ਕੰਮ ਕਰਦੇ ਹਨ। ਪਰ 3D ਫਿਲਮਾਂ ਘੰਟਿਆਂ ਲਈ ਰਹਿੰਦੀਆਂ ਹਨ! ਅਤੇ ਫਿਰ ਅਸੀਂ ਸਿਨੇਮਾਘਰਾਂ ਤੋਂ ਬਾਹਰ ਆਉਂਦੇ ਹਾਂ ਅਤੇ ਕੁਝ ਅਜਿਹਾ ਕਹਿੰਦੇ ਹਾਂ: "ਤਾ, ਇੱਕ ਗੰਦੀ ਕਾਰਟੂਨ / ਫਿਲਮ! ਉਹ ਬਿਹਤਰ ਕਰ ਸਕਦੇ ਸਨ…” ਮੂਰਖ!

ਅਤੇ ਇਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਿੰਗ ਬਾਰੇ ਇੱਕ ਹੋਰ ਗੱਲ. ਜਿਵੇਂ ਕਿ ਇਹ ਨਿਕਲਿਆ, ਮੇਰੇ ਲਈ ਸਭ ਤੋਂ ਦਿਲਚਸਪ ਹਿੱਸਾ ਗਣਿਤ ਦਾ ਸੀ। ਜੇਕਰ ਤੁਸੀਂ ਸੀਨ (ਪ੍ਰੋਜੈਕਟ ਵਰਣਨ ਵਿੱਚ ਰਿਪੋਜ਼ਟਰੀ ਦਾ ਲਿੰਕ) ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਕੈਮਰਾ ਇੱਕ ਗੋਲੇ ਵਿੱਚ ਕੁੜੀ ਦੇ ਚਰਿੱਤਰ ਦੇ ਦੁਆਲੇ ਘੁੰਮਦਾ ਹੈ। ਅਜਿਹੇ ਕੈਮਰਾ ਰੋਟੇਸ਼ਨ ਨੂੰ ਪ੍ਰੋਗ੍ਰਾਮ ਕਰਨ ਲਈ, ਮੈਨੂੰ ਪਹਿਲਾਂ ਚੱਕਰ (2D), ਅਤੇ ਫਿਰ ਗੋਲਾ (3D) 'ਤੇ ਸਥਿਤੀ ਬਿੰਦੂ ਦੇ ਕੋਆਰਡੀਨੇਟਸ ਦੀ ਗਣਨਾ ਕਰਨੀ ਪੈਂਦੀ ਸੀ। ਮਜ਼ੇਦਾਰ ਗੱਲ ਇਹ ਹੈ ਕਿ ਮੈਂ ਸਕੂਲ ਵਿਚ ਗਣਿਤ ਨੂੰ ਨਫ਼ਰਤ ਕਰਦਾ ਸੀ ਅਤੇ ਇਸ ਨੂੰ ਘਟਾਓ ਨਾਲ ਜਾਣਦਾ ਸੀ। ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ, ਸ਼ਾਇਦ, ਕਿਉਂਕਿ ਸਕੂਲ ਵਿਚ ਉਹ ਤੁਹਾਨੂੰ ਇਹ ਨਹੀਂ ਸਮਝਾਉਂਦੇ ਕਿ ਇਹ ਗਣਿਤ ਜ਼ਿੰਦਗੀ ਵਿਚ ਕਿਵੇਂ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੇ ਟੀਚੇ, ਸੁਪਨੇ ਦੇ ਜਨੂੰਨ ਹੋ ਜਾਂਦੇ ਹੋ, ਤਾਂ ਮਨ ਸਾਫ਼, ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ! ਅਤੇ ਤੁਸੀਂ ਗੁੰਝਲਦਾਰ ਕੰਮਾਂ ਨੂੰ ਇੱਕ ਦਿਲਚਸਪ ਸਾਹਸ ਵਜੋਂ ਸਮਝਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ. ਅਤੇ ਫਿਰ ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ: "ਠੀਕ ਹੈ, *ਪਿਆਰੇ* ਗਣਿਤ-ਵਿਗਿਆਨੀ ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਕਿਉਂ ਨਹੀਂ ਦੱਸ ਸਕੇ ਕਿ ਇਹ ਫਾਰਮੂਲੇ ਕਿੱਥੇ ਝੁਕੇ ਜਾ ਸਕਦੇ ਹਨ?"।

ਇੱਕ ਚੱਕਰ ਅਤੇ ਇੱਕ ਗੋਲੇ ਉੱਤੇ ਇੱਕ ਬਿੰਦੂ ਦੇ ਨਿਰਦੇਸ਼ਾਂਕ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਫਾਰਮੂਲੇ ਦੀ ਗਣਨਾ (ਮੇਰੀ ਨੋਟਬੁੱਕ ਤੋਂ)

ਖੇਡ 1

• ਪਲੇਟਫਾਰਮ: ਵਿੰਡੋਜ਼ (ਵਿੰਡੋਜ਼ 7, 10 'ਤੇ ਟੈਸਟ ਕੀਤਾ ਗਿਆ)
• ਅਜ਼ਮਾਇਸ਼: ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਸ਼ੁੱਧ ਸੀ ਵਿਚ ਲਿਖਿਆ ਗਿਆ ਸੀ
• ਖੇਡ ਇੰਜਣ: ਵਿੰਡੋਜ਼ ਕੰਸੋਲ
• ਪ੍ਰੇਰਨਾ: javidx9
• ਭੰਡਾਰ: GitHub

ਸਧਾਰਨ ਸੱਪ ਦੀ ਖੇਡ

3D ਦ੍ਰਿਸ਼ ਕੋਈ ਖੇਡ ਨਹੀਂ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, 3D ਵਸਤੂਆਂ (ਖਾਸ ਕਰਕੇ ਅੱਖਰ) ਨੂੰ ਮਾਡਲਿੰਗ ਅਤੇ ਐਨੀਮੇਟ ਕਰਨਾ ਲੰਬਾ ਅਤੇ ਮੁਸ਼ਕਲ ਹੈ। ਏਕਤਾ ਦੇ ਨਾਲ ਖੇਡਣ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਮੈਨੂੰ ਬੇਸਿਕਸ ਤੋਂ ਜਾਰੀ ਰੱਖਣਾ ਹੈ, ਜਾਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ। ਖੇਡਾਂ ਦੀ ਬਣਤਰ ਨੂੰ ਸਮਝਣ ਲਈ ਕੁਝ ਸਧਾਰਨ ਅਤੇ ਤੇਜ਼, ਪਰ ਉਸੇ ਸਮੇਂ ਗਲੋਬਲ।

ਅਤੇ ਸਾਡੇ ਕੋਲ ਸਧਾਰਨ ਅਤੇ ਤੇਜ਼ ਕੀ ਹੈ? ਇਹ ਸਹੀ ਹੈ, ਕੰਸੋਲ ਅਤੇ 2 ਡੀ. ਵਧੇਰੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, ਕੰਸੋਲ ਅਤੇ ਚਿੰਨ੍ਹ ਵੀ. ਦੁਬਾਰਾ ਫਿਰ, ਮੈਂ ਇੰਟਰਨੈਟ 'ਤੇ ਪ੍ਰੇਰਨਾ ਲੱਭਣਾ ਸ਼ੁਰੂ ਕੀਤਾ (ਆਮ ਤੌਰ 'ਤੇ, ਮੈਂ ਇੰਟਰਨੈਟ ਨੂੰ XNUMXਵੀਂ ਸਦੀ ਦੀ ਸਭ ਤੋਂ ਕ੍ਰਾਂਤੀਕਾਰੀ ਅਤੇ ਖਤਰਨਾਕ ਕਾਢ ਮੰਨਦਾ ਹਾਂ)। ਮੈਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਦਾ ਇੱਕ ਵੀਡੀਓ ਖੋਦਿਆ ਜਿਸ ਨੇ ਕੰਸੋਲ ਟੈਟ੍ਰਿਸ ਬਣਾਇਆ. ਅਤੇ ਉਸਦੀ ਖੇਡ ਦੀ ਸਮਾਨਤਾ ਵਿੱਚ, ਉਸਨੇ "ਸੱਪ" ਨੂੰ ਕੱਟਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ. ਵੀਡੀਓ ਤੋਂ, ਮੈਂ ਦੋ ਬੁਨਿਆਦੀ ਚੀਜ਼ਾਂ ਬਾਰੇ ਸਿੱਖਿਆ - ਗੇਮ ਲੂਪ (ਤਿੰਨ ਬੁਨਿਆਦੀ ਫੰਕਸ਼ਨਾਂ / ਹਿੱਸਿਆਂ ਦੇ ਨਾਲ) ਅਤੇ ਬਫਰ ਲਈ ਆਉਟਪੁੱਟ।

ਗੇਮ ਲੂਪ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ:

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

ਕੋਡ ਇੱਕ ਵਾਰ ਵਿੱਚ ਪੂਰਾ ਮੁੱਖ () ਫੰਕਸ਼ਨ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਅਤੇ ਖੇਡ ਚੱਕਰ ਅਨੁਸਾਰੀ ਟਿੱਪਣੀ ਦੇ ਬਾਅਦ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ. ਲੂਪ ਵਿੱਚ ਤਿੰਨ ਬੁਨਿਆਦੀ ਫੰਕਸ਼ਨ ਹਨ: Input(), Logic(), Draw(). ਪਹਿਲਾਂ, ਇਨਪੁਟ ਡੇਟਾ ਇਨਪੁਟ (ਮੁੱਖ ਤੌਰ 'ਤੇ ਕੀਸਟ੍ਰੋਕ ਦਾ ਨਿਯੰਤਰਣ), ਫਿਰ ਦਾਖਲ ਕੀਤੇ ਡੇਟਾ ਲੋਜਿਕ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨਾ, ਫਿਰ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ - ਡਰਾਅ। ਅਤੇ ਇਸ ਲਈ ਹਰ ਫਰੇਮ. ਐਨੀਮੇਸ਼ਨ ਇਸ ਤਰੀਕੇ ਨਾਲ ਬਣਾਈ ਜਾਂਦੀ ਹੈ। ਇਹ ਕਾਰਟੂਨ ਵਰਗਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਇਨਪੁਟ ਡੇਟਾ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਸਮਾਂ ਲੱਗਦਾ ਹੈ ਅਤੇ, ਜਿੱਥੋਂ ਤੱਕ ਮੈਂ ਜਾਣਦਾ ਹਾਂ, ਗੇਮ ਦੀ ਫਰੇਮ ਰੇਟ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪਰ ਇੱਥੇ Logic() ਫੰਕਸ਼ਨ ਬਹੁਤ ਤੇਜ਼ ਹੈ। ਇਸ ਲਈ, ਫਰੇਮ ਰੇਟ ਨੂੰ ਗੇਮਸਪੀਡ ਪੈਰਾਮੀਟਰ ਦੇ ਨਾਲ ਸਲੀਪ() ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਇਸ ਦਰ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ।

ਖੇਡ ਚੱਕਰ. ਨੋਟਪੈਡ ਵਿੱਚ ਸੱਪ ਪ੍ਰੋਗਰਾਮਿੰਗ

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰਤੀਕ ਕੰਸੋਲ ਗੇਮ ਵਿਕਸਿਤ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਆਮ ਸਟ੍ਰੀਮ ਆਉਟਪੁੱਟ 'ਕਾਉਟ' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਕ੍ਰੀਨ 'ਤੇ ਡੇਟਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ - ਇਹ ਬਹੁਤ ਹੌਲੀ ਹੈ। ਇਸ ਲਈ, ਆਉਟਪੁੱਟ ਨੂੰ ਸਕਰੀਨ ਬਫਰ ਵਿੱਚ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ. ਬਹੁਤ ਤੇਜ਼ ਅਤੇ ਗੇਮ ਬਿਨਾਂ ਕਿਸੇ ਗੜਬੜ ਦੇ ਕੰਮ ਕਰੇਗੀ। ਇਮਾਨਦਾਰ ਹੋਣ ਲਈ, ਮੈਨੂੰ ਬਿਲਕੁਲ ਸਮਝ ਨਹੀਂ ਆਉਂਦੀ ਕਿ ਸਕ੍ਰੀਨ ਬਫਰ ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਪਰ ਮੈਂ ਇੱਥੇ ਇੱਕ ਕੋਡ ਉਦਾਹਰਨ ਦੇਵਾਂਗਾ, ਅਤੇ ਸ਼ਾਇਦ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਕੋਈ ਵਿਅਕਤੀ ਸਥਿਤੀ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੇਗਾ.

ਸਕ੍ਰੀਨ ਬਫਰ ਪ੍ਰਾਪਤ ਕਰਨਾ (ਜੇਕਰ ਮੈਂ ਅਜਿਹਾ ਕਹਿ ਸਕਦਾ ਹਾਂ):

// 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 ++
• ਖੇਡ ਇੰਜਣ: ਵਿੰਡੋਜ਼ ਕੰਸੋਲ
• ਪ੍ਰੇਰਨਾ: ਇੱਕ ਕਿਤਾਬ ਗੇਮ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੁਆਰਾ 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_bitmapਮੈਮੋਰੀ ਬਿਟਮੈਪ ਬਣਾਉਣਾ:

// 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++ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਯਾਨੀ ਮੈਂ ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਵੱਖ-ਵੱਖ ਗੇਮ ਆਬਜੈਕਟ ਦਾ ਵਰਣਨ ਕੀਤਾ ਹੈ। ਮੈਂ ਆਪਣਾ ਸੰਗ੍ਰਹਿ ਬਣਾਇਆ ਹੈ - ਤੁਸੀਂ ਸਿਰਲੇਖ/Box.h ਵਿੱਚ ਕੋਡ ਦੇਖ ਸਕਦੇ ਹੋ। ਤਰੀਕੇ ਨਾਲ, ਸੰਗ੍ਰਹਿ ਵਿੱਚ ਇੱਕ ਮੈਮੋਰੀ ਲੀਕ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਹੈ. ਪੁਆਇੰਟਰ ਵਰਤੇ। ਮੈਮੋਰੀ ਨਾਲ ਕੰਮ ਕੀਤਾ. ਮੈਨੂੰ ਕਹਿਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਤਾਬ ਨੇ ਮੇਰੀ ਬਹੁਤ ਮਦਦ ਕੀਤੀ. ਗੇਮ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੁਆਰਾ C++ ਦੀ ਸ਼ੁਰੂਆਤ. ਇਹ C++ ਵਿੱਚ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਇੱਕ ਵਧੀਆ ਸ਼ੁਰੂਆਤ ਹੈ। ਇਹ ਛੋਟਾ, ਦਿਲਚਸਪ ਅਤੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਵਿਵਸਥਿਤ ਹੈ।

ਇਸ ਗੇਮ ਨੂੰ ਵਿਕਸਿਤ ਕਰਨ ਵਿੱਚ ਲਗਭਗ ਛੇ ਮਹੀਨੇ ਲੱਗੇ। ਮੈਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਕੰਮ 'ਤੇ ਦੁਪਹਿਰ ਦੇ ਖਾਣੇ ਅਤੇ ਸਨੈਕਸ ਦੌਰਾਨ ਲਿਖਿਆ। ਉਹ ਦਫਤਰ ਦੀ ਰਸੋਈ ਵਿਚ ਬੈਠ ਗਿਆ, ਭੋਜਨ 'ਤੇ ਸਟੰਪ ਕੀਤਾ ਅਤੇ ਕੋਡ ਲਿਖਿਆ. ਜਾਂ ਰਾਤ ਦੇ ਖਾਣੇ ਲਈ ਘਰ ਵਿੱਚ. ਇਸ ਲਈ ਮੈਨੂੰ ਅਜਿਹੇ "ਰਸੋਈ ਵਾਰ" ਮਿਲੀ. ਹਮੇਸ਼ਾਂ ਵਾਂਗ, ਮੈਂ ਇੱਕ ਨੋਟਬੁੱਕ ਦੀ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੋਂ ਕੀਤੀ, ਅਤੇ ਸਾਰੀਆਂ ਸੰਕਲਪਿਕ ਚੀਜ਼ਾਂ ਇਸ ਵਿੱਚ ਪੈਦਾ ਹੋਈਆਂ ਸਨ.

ਵਿਹਾਰਕ ਭਾਗ ਦੇ ਅੰਤ ਵਿੱਚ, ਮੈਂ ਆਪਣੀ ਨੋਟਬੁੱਕ ਦੇ ਕੁਝ ਸਕੈਨ ਕੱਢਾਂਗਾ। ਇਹ ਦਿਖਾਉਣ ਲਈ ਕਿ ਮੈਂ ਕੀ ਲਿਖ ਰਿਹਾ ਸੀ, ਡਰਾਇੰਗ ਕਰ ਰਿਹਾ ਸੀ, ਗਿਣ ਰਿਹਾ ਸੀ, ਡਿਜ਼ਾਈਨ ਕਰ ਰਿਹਾ ਸੀ...

ਟੈਂਕ ਚਿੱਤਰ ਡਿਜ਼ਾਈਨ. ਅਤੇ ਸਕ੍ਰੀਨ 'ਤੇ ਹਰੇਕ ਟੈਂਕ ਨੂੰ ਕਿੰਨੇ ਪਿਕਸਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਦੀ ਪਰਿਭਾਸ਼ਾ

ਇਸ ਦੇ ਧੁਰੇ ਦੁਆਲੇ ਟੈਂਕ ਦੇ ਘੁੰਮਣ ਲਈ ਐਲਗੋਰਿਦਮ ਅਤੇ ਫਾਰਮੂਲੇ ਦੀ ਗਣਨਾ

ਮੇਰੇ ਸੰਗ੍ਰਹਿ ਦਾ ਚਿੱਤਰ (ਮੈਮੋਰੀ ਲੀਕ ਵਾਲਾ, ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾ ਹੈ)। ਸੰਗ੍ਰਹਿ ਨੂੰ ਇੱਕ ਲਿੰਕਡ ਸੂਚੀ ਦੇ ਰੂਪ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ

ਅਤੇ ਇਹ ਖੇਡ ਵਿੱਚ ਨਕਲੀ ਬੁੱਧੀ ਨੂੰ ਪੇਚ ਕਰਨ ਦੀਆਂ ਵਿਅਰਥ ਕੋਸ਼ਿਸ਼ਾਂ ਹਨ

ਥਿਊਰੀ

"ਇੱਕ ਹਜ਼ਾਰ ਮੀਲ ਦੀ ਯਾਤਰਾ ਵੀ ਪਹਿਲੇ ਕਦਮ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ" (ਪ੍ਰਾਚੀਨ ਚੀਨੀ ਬੁੱਧੀ)

ਆਓ ਅਭਿਆਸ ਤੋਂ ਸਿਧਾਂਤ ਵੱਲ ਵਧੀਏ! ਤੁਸੀਂ ਆਪਣੇ ਸ਼ੌਕ ਲਈ ਸਮਾਂ ਕਿਵੇਂ ਲੱਭਦੇ ਹੋ?

1. ਇਹ ਨਿਰਧਾਰਤ ਕਰੋ ਕਿ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਕੀ ਚਾਹੁੰਦੇ ਹੋ (ਹਾਏ, ਇਹ ਸਭ ਤੋਂ ਮੁਸ਼ਕਲ ਹੈ).
2. ਤਰਜੀਹਾਂ ਨਿਰਧਾਰਤ ਕਰੋ.
3. ਉੱਚ ਤਰਜੀਹਾਂ ਦੀ ਖ਼ਾਤਰ ਸਭ "ਜ਼ਿਆਦਾ" ਕੁਰਬਾਨ ਕਰੋ.
4. ਹਰ ਰੋਜ਼ ਆਪਣੇ ਟੀਚਿਆਂ ਵੱਲ ਵਧੋ।
5. ਇਹ ਉਮੀਦ ਨਾ ਕਰੋ ਕਿ ਸ਼ੌਕ ਲਈ ਦੋ ਜਾਂ ਤਿੰਨ ਘੰਟੇ ਦਾ ਖਾਲੀ ਸਮਾਂ ਹੋਵੇਗਾ.

ਇੱਕ ਪਾਸੇ, ਤੁਹਾਨੂੰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਤਰਜੀਹ ਦਿਓ. ਦੂਜੇ ਪਾਸੇ, ਇਹਨਾਂ ਤਰਜੀਹਾਂ ਦੇ ਹੱਕ ਵਿੱਚ ਕੁਝ ਕੇਸਾਂ/ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਛੱਡਣਾ ਸੰਭਵ ਹੈ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਤੁਹਾਨੂੰ ਹਰ ਚੀਜ਼ ਦੀ ਕੁਰਬਾਨੀ ਦੇਣੀ ਪਵੇਗੀ "ਬੇਲੋੜੀ". ਮੈਂ ਕਿਤੇ ਸੁਣਿਆ ਸੀ ਕਿ ਜ਼ਿੰਦਗੀ ਵਿਚ ਵੱਧ ਤੋਂ ਵੱਧ ਤਿੰਨ ਮੁੱਖ ਕੰਮ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਫਿਰ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨਾਲ ਵਧੀਆ ਸੰਭਵ ਤਰੀਕੇ ਨਾਲ ਨਜਿੱਠਣ ਦੇ ਯੋਗ ਹੋਵੋਗੇ. ਅਤੇ ਵਾਧੂ ਪ੍ਰੋਜੈਕਟ/ਨਿਰਦੇਸ਼ ਕਾਰਨੀ ਨੂੰ ਓਵਰਲੋਡ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦੇਣਗੇ। ਪਰ ਇਹ ਸਭ, ਸ਼ਾਇਦ, ਵਿਅਕਤੀਗਤ ਅਤੇ ਵਿਅਕਤੀਗਤ ਹੈ.

ਇੱਥੇ ਇੱਕ ਸੁਨਹਿਰੀ ਨਿਯਮ ਹੈ: ਕਦੇ ਵੀ 0% ਦਿਨ ਨਹੀਂ ਹੁੰਦਾ! ਮੈਂ ਇੱਕ ਇੰਡੀ ਡਿਵੈਲਪਰ ਦੁਆਰਾ ਇੱਕ ਲੇਖ ਵਿੱਚ ਇਸ ਬਾਰੇ ਸਿੱਖਿਆ. ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਹਰ ਰੋਜ਼ ਇਸ ਬਾਰੇ ਕੁਝ ਨਾ ਕੁਝ ਕਰੋ। ਅਤੇ ਇਸ ਨਾਲ ਕੋਈ ਫਰਕ ਨਹੀਂ ਪੈਂਦਾ ਕਿ ਤੁਸੀਂ ਕਿੰਨੀ ਕਮਾਈ ਕਰਦੇ ਹੋ। ਇੱਕ ਸ਼ਬਦ ਜਾਂ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਲਿਖੋ, ਇੱਕ ਟਿਊਟੋਰਿਅਲ ਵੀਡੀਓ ਦੇਖੋ, ਜਾਂ ਬੋਰਡ ਵਿੱਚ ਇੱਕ ਨਹੁੰ ਮਾਰੋ—ਬੱਸ ਕੁਝ ਕਰੋ। ਸਭ ਤੋਂ ਔਖਾ ਹਿੱਸਾ ਸ਼ੁਰੂ ਹੋ ਰਿਹਾ ਹੈ. ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਉਸ ਤੋਂ ਥੋੜਾ ਹੋਰ ਕਰੋਗੇ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਸੀ। ਇਸ ਲਈ ਤੁਸੀਂ ਲਗਾਤਾਰ ਆਪਣੇ ਟੀਚੇ ਵੱਲ ਵਧੋਗੇ ਅਤੇ, ਮੇਰੇ ਤੇ ਵਿਸ਼ਵਾਸ ਕਰੋ, ਬਹੁਤ ਜਲਦੀ। ਆਖ਼ਰਕਾਰ, ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ 'ਤੇ ਮੁੱਖ ਬ੍ਰੇਕ ਢਿੱਲ ਹੈ.

ਅਤੇ ਇਹ ਯਾਦ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਤੁਹਾਨੂੰ 5, 10, 15 ਮਿੰਟਾਂ ਵਿੱਚ ਸਮੇਂ ਦੇ ਮੁਫਤ "ਬਰਾਏ" ਨੂੰ ਘੱਟ ਨਹੀਂ ਸਮਝਣਾ ਚਾਹੀਦਾ ਅਤੇ ਨਜ਼ਰਅੰਦਾਜ਼ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ, ਇੱਕ ਜਾਂ ਦੋ ਘੰਟੇ ਤੱਕ ਚੱਲਣ ਵਾਲੇ ਕੁਝ ਵੱਡੇ "ਲੌਗ" ਦੀ ਉਡੀਕ ਕਰੋ. ਕੀ ਤੁਸੀਂ ਲਾਈਨ ਵਿੱਚ ਖੜੇ ਹੋ? ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਕਿਸੇ ਚੀਜ਼ ਬਾਰੇ ਸੋਚੋ. ਕੀ ਤੁਸੀਂ ਐਸਕੇਲੇਟਰ ਉੱਪਰ ਜਾ ਰਹੇ ਹੋ? ਇੱਕ ਨੋਟਬੁੱਕ ਵਿੱਚ ਕੁਝ ਲਿਖੋ. ਕੀ ਤੁਸੀਂ ਬੱਸ ਵਿੱਚ ਖਾਂਦੇ ਹੋ? ਠੀਕ ਹੈ, ਕੁਝ ਲੇਖ ਪੜ੍ਹੋ. ਹਰ ਮੌਕੇ ਦੀ ਵਰਤੋਂ ਕਰੋ। YouTube 'ਤੇ ਬਿੱਲੀਆਂ ਅਤੇ ਕੁੱਤਿਆਂ ਨੂੰ ਦੇਖਣਾ ਬੰਦ ਕਰੋ! ਆਪਣੇ ਦਿਮਾਗ ਨਾਲ ਗੜਬੜ ਨਾ ਕਰੋ!

ਅਤੇ ਆਖਰੀ. ਜੇ, ਇਸ ਲੇਖ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਗੇਮ ਇੰਜਣਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਗੇਮਾਂ ਬਣਾਉਣ ਦਾ ਵਿਚਾਰ ਪਸੰਦ ਕੀਤਾ ਹੈ, ਤਾਂ ਕੈਸੀ ਮੁਰਾਟੋਰੀ ਦਾ ਨਾਮ ਯਾਦ ਰੱਖੋ. ਇਸ ਬੰਦੇ ਕੋਲ ਹੈ ਵੈਬਸਾਈਟ. "ਵਾਚ -> ਪਿਛਲੇ ਐਪੀਸੋਡਸ" ਭਾਗ ਵਿੱਚ ਤੁਹਾਨੂੰ ਸਕ੍ਰੈਚ ਤੋਂ ਇੱਕ ਪੇਸ਼ੇਵਰ ਗੇਮ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਇਸ ਬਾਰੇ ਸ਼ਾਨਦਾਰ ਮੁਫਤ ਵੀਡੀਓ ਟਿਊਟੋਰਿਅਲ ਮਿਲਣਗੇ। ਤੁਸੀਂ ਯੂਨੀਵਰਸਿਟੀ ਵਿੱਚ ਪੰਜ ਸਾਲਾਂ ਦੇ ਅਧਿਐਨ ਦੇ ਮੁਕਾਬਲੇ ਵਿੰਡੋਜ਼ ਪਾਠਾਂ ਲਈ ਪੰਜ Intro to C ਵਿੱਚ ਹੋਰ ਸਿੱਖ ਸਕਦੇ ਹੋ (ਕਿਸੇ ਨੇ ਵੀਡੀਓ ਦੇ ਹੇਠਾਂ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਇਸ ਬਾਰੇ ਲਿਖਿਆ ਹੈ)।

ਕੇਸੀ ਇਹ ਵੀ ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਆਪਣੇ ਗੇਮ ਇੰਜਣ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਨਾਲ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਮੌਜੂਦਾ ਇੰਜਣ ਦੀ ਬਿਹਤਰ ਸਮਝ ਹੋਵੇਗੀ। ਫਰੇਮਵਰਕ ਦੀ ਦੁਨੀਆ ਵਿੱਚ, ਜਿੱਥੇ ਹਰ ਕੋਈ ਸਵੈਚਾਲਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ, ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ, ਨਾ ਕਿ ਵਰਤਣਾ। ਕੰਪਿਊਟਰ ਦੇ ਸੁਭਾਅ ਨੂੰ ਸਮਝੋ। ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਬਹੁਤ ਜ਼ਿਆਦਾ ਬੁੱਧੀਮਾਨ ਅਤੇ ਪਰਿਪੱਕ ਪ੍ਰੋਗਰਾਮਰ ਵੀ ਬਣੋਗੇ - ਇੱਕ ਪ੍ਰੋ.

ਤੁਹਾਡੇ ਚੁਣੇ ਹੋਏ ਮਾਰਗ 'ਤੇ ਚੰਗੀ ਕਿਸਮਤ! ਅਤੇ ਆਓ ਸੰਸਾਰ ਨੂੰ ਹੋਰ ਪੇਸ਼ੇਵਰ ਬਣਾਉ।

ਲੇਖਕ: ਗ੍ਰੈਨਕਿਨ ਐਂਡਰੀ, DevOps

ਸਰੋਤ: www.habr.com