ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ'] ", 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਫਿਰ ਵੀ. \\n "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ।] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਫਾਰਮੈਟ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਦੇ ਰੂਪ ਵਿੱਚ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ, ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ। ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ ਨੂੰ ਲਿਖੋ। ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲਸਨੇਕ ਨੂੰ ਲਿਖੋ "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ. \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ, \'ਚਰਿੱਤਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਬੋਰਡ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਟੀਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਰੰਗ ਨਾਲ colors.py ਫਾਈਲ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਕਲਾਸ ਨਾਲ ਸਥਿਰਾਂਕ ਅਤੇ hexagonalsnake.py ਫਾਇਲ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਤੋਂਹੈਕਸਾਗੋਨਲ ਸੱਪ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\nself.cell_size = 30\\n self.game = ਖੇਡ \\n ਚੌਡ਼ਾਈ = self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ ()।ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\n self.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): x ਲਈ \\nਸੀਮਾ (self.game.grid_size): \\n self.draw_hexagon (x, y, GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ \\n ਬਿੰਦੂ = [] \\n (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x * self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\n ਪਾਈ =y * self.cell_size * 3/4 + self.cell_size * math.sin (ਕੋਣ _ ਰੇਡ)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਬਿੰਦੂ, ਭਰੋ = ਰੰਗ,ਆਉਟਲਾਈਨ = GRID _ COLOR) \\n\\n ਡਿਫ ਅਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸੈਲਫ): \\n self.delete (tk.ALL) \\n self.draw_grid () \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y,SNAKE _ COLOR) \\n self.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n "\'\\n\\n ਇਹ ਬੋਰਡ ਕਲਾਸ ਟਿੰਟਰ ਕੈਨਵਸ ਨੂੰ ਅਰੰਭ ਕਰਦੀ ਹੈ, ਖਿੱਚਦੀ ਹੈਗਰਿੱਡ, ਅਤੇ ਖੇਡ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਡਰਾਅ _ ਹੈਕਸਾਗਨ ਵਿਧੀ ਗਣਿਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ ਅਤੇ ਬਣਾਉਂਦੀ ਹੈਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗਨ ਬਹੁਭੁਜ। ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸੀਮਾ. \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ।ਲੋਡ਼ ਪੈਣ ਉੱਤੇ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਰੰਗ ਲਿਖੋ "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ, \'ਚਰਿੱਤਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਬੋਰਡ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਟੀਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਰੰਗ ਨਾਲ colors.py ਫਾਈਲ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਕਲਾਸ ਨਾਲ ਸਥਿਰਾਂਕ ਅਤੇ hexagonalsnake.py ਫਾਇਲ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਤੋਂਹੈਕਸਾਗੋਨਲ ਸੱਪ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\nself.cell_size = 30\\n self.game = ਖੇਡ \\n ਚੌਡ਼ਾਈ = self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ ()।ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\n self.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): x ਲਈ \\nਸੀਮਾ (self.game.grid_size): \\n self.draw_hexagon (x, y, GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ \\n ਬਿੰਦੂ = [] \\n (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x * self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\n ਪਾਈ =y * self.cell_size * 3/4 + self.cell_size * math.sin (ਕੋਣ _ ਰੇਡ)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਬਿੰਦੂ, ਭਰੋ = ਰੰਗ,ਆਉਟਲਾਈਨ = GRID _ COLOR) \\n\\n ਡਿਫ ਅਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸੈਲਫ): \\n self.delete (tk.ALL) \\n self.draw_grid () \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y,SNAKE _ COLOR) \\n self.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n "\'\\n\\n ਇਹ ਬੋਰਡ ਕਲਾਸ ਟਿੰਟਰ ਕੈਨਵਸ ਨੂੰ ਅਰੰਭ ਕਰਦੀ ਹੈ, ਖਿੱਚਦੀ ਹੈਗਰਿੱਡ, ਅਤੇ ਖੇਡ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਡਰਾਅ _ ਹੈਕਸਾਗਨ ਵਿਧੀ ਗਣਿਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ ਅਤੇ ਬਣਾਉਂਦੀ ਹੈਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗਨ ਬਹੁਭੁਜ। ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸੀਮਾ. \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ।ਲੋਡ਼ ਪੈਣ ਉੱਤੇ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਰੰਗਾਂ ਨੂੰ ਲਿਖੋ ", \'ਇੱਥੇ ਰੰਗ ਵਾਲੀ colors.py ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਹੈ।ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਸਥਿਰਾਂਕ। ਇਹ ਸਥਿਰਾਂਕ ਹੋਰ ਫਾਈਲਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। \\n\\n "\'ਪਾਈਥਨ \\nSNAKE _ COLOR ="#32CD32" "#ਲਾਈਮ ਗ੍ਰੀਨ \\nFOOD _ COLOR =" "#FF4500" "#ਓਰੇਂਜ ਰੈੱਡ \\nGRID _ COLOR =" "#708090" "#ਸਲੇਟ ਗ੍ਰੇ\\nBG _ COLOR =" "#F0F8FF" "#NAME _ 3 ਬਲੂ \\n" "\\n" "ਇਹ"ਰੰਗ ਚੰਗੇ ਕੰਟਰਾਸਟ ਪ੍ਰਦਾਨ ਕਰਨ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੋਣ ਲਈ ਚੁਣੇ ਗਏ ਸਨ। ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦੇ ਅਧਾਰ\' ਤੇ ਇਨ੍ਹਾਂ ਮੁੱਲਾਂ ਨੂੰ ਹੋਰ ਰੰਗਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।ਇਹਨਾਂ ਸਥਿਰਾਂ ਨੂੰ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (main.py, hexagonalsnake.py, board.py) ਵਿੱਚ ਆਯਾਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਖੇਡ ਦੇ ਤੱਤਾਂ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕੇ।ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਵਿੱਚ ਪਾਏ ਗਏ ਮੁੱਦੇ।] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ, \'ਚਰਿੱਤਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਬੋਰਡ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਟੀਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਰੰਗ ਨਾਲ colors.py ਫਾਈਲ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਕਲਾਸ ਨਾਲ ਸਥਿਰਾਂਕ ਅਤੇ hexagonalsnake.py ਫਾਇਲ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਤੋਂਹੈਕਸਾਗੋਨਲ ਸੱਪ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\nself.cell_size = 30\\n self.game = ਖੇਡ \\n ਚੌਡ਼ਾਈ = self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ ()।ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\n self.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): x ਲਈ \\nਸੀਮਾ (self.game.grid_size): \\n self.draw_hexagon (x, y, GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ \\n ਬਿੰਦੂ = [] \\n (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x * self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\n ਪਾਈ =y * self.cell_size * 3/4 + self.cell_size * math.sin (ਕੋਣ _ ਰੇਡ)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਬਿੰਦੂ, ਭਰੋ = ਰੰਗ,ਆਉਟਲਾਈਨ = GRID _ COLOR) \\n\\n ਡਿਫ ਅਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸੈਲਫ): \\n self.delete (tk.ALL) \\n self.draw_grid () \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y,SNAKE _ COLOR) \\n self.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n "\'\\n\\n ਇਹ ਬੋਰਡ ਕਲਾਸ ਟਿੰਟਰ ਕੈਨਵਸ ਨੂੰ ਅਰੰਭ ਕਰਦੀ ਹੈ, ਖਿੱਚਦੀ ਹੈਗਰਿੱਡ, ਅਤੇ ਖੇਡ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਡਰਾਅ _ ਹੈਕਸਾਗਨ ਵਿਧੀ ਗਣਿਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ ਅਤੇ ਬਣਾਉਂਦੀ ਹੈਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗਨ ਬਹੁਭੁਜ। ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸੀਮਾ. \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ।ਲੋਡ਼ ਪੈਣ ਉੱਤੇ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਰੰਗਾਂ ਨੂੰ ਲਿਖੋ ", \'ਇੱਥੇ ਰੰਗ ਵਾਲੀ colors.py ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਹੈ।ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਸਥਿਰਾਂਕ। ਇਹ ਸਥਿਰਾਂਕ ਹੋਰ ਫਾਈਲਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। \\n\\n "\'ਪਾਈਥਨ \\nSNAKE _ COLOR ="#32CD32" "#ਲਾਈਮ ਗ੍ਰੀਨ \\nFOOD _ COLOR =" "#FF4500" "#ਓਰੇਂਜ ਰੈੱਡ \\nGRID _ COLOR =" "#708090" "#ਸਲੇਟ ਗ੍ਰੇ\\nBG _ COLOR =" "#F0F8FF" "#NAME _ 3 ਬਲੂ \\n" "\\n" "ਇਹ"ਰੰਗ ਚੰਗੇ ਕੰਟਰਾਸਟ ਪ੍ਰਦਾਨ ਕਰਨ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੋਣ ਲਈ ਚੁਣੇ ਗਏ ਸਨ। ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦੇ ਅਧਾਰ\' ਤੇ ਇਨ੍ਹਾਂ ਮੁੱਲਾਂ ਨੂੰ ਹੋਰ ਰੰਗਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।ਇਹਨਾਂ ਸਥਿਰਾਂ ਨੂੰ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (main.py, hexagonalsnake.py, board.py) ਵਿੱਚ ਆਯਾਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਖੇਡ ਦੇ ਤੱਤਾਂ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕੇ।ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਵਿੱਚ ਮਿਲੇ ਮੁੱਦੇ. \',\' 1. main.py ਫਾਈਲ ਵਿੱਚ, \'game_board.update_display ()\' ਵਿਧੀ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਖ ਖੇਡ ਲੂਪ। ਹਾਲਾਂਕਿ, ਇਸ ਨੂੰ ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅੱਪਡੇਟ ਕਰਨ ਲਈ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਕਾਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\n2.board.py ਫਾਇਲ ਵਿੱਚ \'ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ()\' ਵਿਧੀ \'self.delete (tk.ALL)\' ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਗਰਿੱਡ ਸਮੇਤ ਸਾਰੇ ਕੈਨਵਸ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾ ਸਕਦੀ ਹੈ।ਖੇਡ ਦੇ ਦੌਰਾਨ ਚਮਕਣਾ ਕਿਉਂਕਿ ਖੇਡ ਲੂਪ ਦੇ ਹਰੇਕ ਦੁਹਰਾਓ ਵਿੱਚ ਗਰਿੱਡ ਨੂੰ ਦੁਬਾਰਾ ਖਿੱਚਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, ਸਿਰਫ ਸੱਪ ਅਤੇ ਭੋਜਨ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋਰੀਡ੍ਰੌ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰੋ। \\n\\n3. hexagonalsnake.py ਫਾਇਲ ਵਿੱਚ, \'ਚੇਂਜ _ ਡਾਇਰੈਕਸ਼ਨ ()\' ਵਿਧੀ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਦਿਸ਼ਾ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।ਦਿਸ਼ਾ, ਜਿਸ ਕਾਰਨ ਸੱਪ ਤੁਰੰਤ ਆਪਣੇ ਆਪ ਨਾਲ ਟਕਰਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਨਵੀਂ ਦਿਸ਼ਾ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਹੈਇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਦਿਸ਼ਾ। \\n\\n4. board.py ਫਾਇਲ ਵਿੱਚ, \'ਡਰਾਅ _ ਹੈਕਸਾਗਨ ()\' ਵਿਧੀ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਦੇ ਅਧਾਰ ਉੱਤੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ। ਇਹਹੈਕਸਾਗਨਾਂ ਦੀ ਗਲਤ ਸਥਿਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ ਸੈੱਲ ਦਾ ਆਕਾਰ 2 ਨਾਲ ਵੰਡਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਚੁਣਿਆ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਹੈ2 ਨਾਲ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ। \\n\\n5. ਮੌਜੂਦਾ ਕੋਡ ਖੇਡ ਦੀ ਗਤੀ ਜਾਂ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਖੇਡ ਬਹੁਤ ਤੇਜ਼ ਜਾਂ ਬਹੁਤ ਹੌਲੀ ਚੱਲ ਸਕਦੀ ਹੈ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿਸਿਸਟਮ। ਸੱਪ ਦੀ ਲੰਬਾਈ ਜਾਂ ਲੰਘੇ ਸਮੇਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਖੇਡ ਦੀ ਗਤੀ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਇੱਕ ਢੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n6. ਕੋਡ ਵਿੱਚ ਇੱਕ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਸਕੋਰਿੰਗ ਵਿਧੀ ਜਾਂ ਕੋਈ ਵੀ ਜੀ. ਯੂ. ਆਈ. ਤੱਤ (ਉਦਾਹਰਣ ਵਜੋਂ, "ਗੇਮ ਓਵਰ" ਜਾਂ "ਵਿਰਾਮਿਤ")। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ।ਉਪਭੋਗਤਾ ਦਾ ਤਜਰਬਾ. \\n\\n7. ਕੋਡ ਖੇਡ ਨੂੰ ਰੋਕਣ ਜਾਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰਨ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਨੂੰ ਹੋਰ ਬਿਹਤਰ ਬਣਾਇਆ ਜਾਵੇਗਾ।ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ. \\n\\n8. ਕੋਡ ਵਿੱਚ ਕੋਈ ਟਿੱਪਣੀਆਂ ਜਾਂ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ। ਟਿੱਪਣੀਆਂ ਅਤੇ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਕੋਡ ਪਡ਼੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਹੋਵੇਗਾ ਅਤੇਕਾਇਮ ਰੱਖਣਯੋਗਤਾ. \\n\\n9. ਮੌਜੂਦਾ ਲਾਗੂਕਰਨ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਸੱਪ ਪੂਰੇ ਗਰਿੱਡ ਨੂੰ ਭਰ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪੈਦਾ ਕਰਨਾ ਅਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ।ਨਵਾਂ ਭੋਜਨ। ਇਸ ਸਥਿਤੀ ਲਈ ਇੱਕ ਜਾਂਚ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਦੇ ਤਰਕ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ। \\n\\n10. ਕੋਡ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਜਾਂ ਅਪਵਾਦ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਕੈਚਿੰਗ. ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਜੋਡ਼ਨਾ, ਖ਼ਾਸਕਰ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਅਤੇ ਟੀਕਿੰਟਰ ਨਾਲ ਸਬੰਧਤ ਕੋਡ ਲਈ, ਖੇਡ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਬਣਾਵੇਗਾ। \', "ਉਦੇਸ਼ਃ ਇੱਕ ਬਣਾਓਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਠੀਕ ਕੀਤਾ ਮੁੱਖ ਲਿਖੋ "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ, \'ਚਰਿੱਤਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਬੋਰਡ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਟੀਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਰੰਗ ਨਾਲ colors.py ਫਾਈਲ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਕਲਾਸ ਨਾਲ ਸਥਿਰਾਂਕ ਅਤੇ hexagonalsnake.py ਫਾਇਲ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਤੋਂਹੈਕਸਾਗੋਨਲ ਸੱਪ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\nself.cell_size = 30\\n self.game = ਖੇਡ \\n ਚੌਡ਼ਾਈ = self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ ()।ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\n self.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): x ਲਈ \\nਸੀਮਾ (self.game.grid_size): \\n self.draw_hexagon (x, y, GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ \\n ਬਿੰਦੂ = [] \\n (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x * self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\n ਪਾਈ =y * self.cell_size * 3/4 + self.cell_size * math.sin (ਕੋਣ _ ਰੇਡ)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਬਿੰਦੂ, ਭਰੋ = ਰੰਗ,ਆਉਟਲਾਈਨ = GRID _ COLOR) \\n\\n ਡਿਫ ਅਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸੈਲਫ): \\n self.delete (tk.ALL) \\n self.draw_grid () \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y,SNAKE _ COLOR) \\n self.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n "\'\\n\\n ਇਹ ਬੋਰਡ ਕਲਾਸ ਟਿੰਟਰ ਕੈਨਵਸ ਨੂੰ ਅਰੰਭ ਕਰਦੀ ਹੈ, ਖਿੱਚਦੀ ਹੈਗਰਿੱਡ, ਅਤੇ ਖੇਡ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਡਰਾਅ _ ਹੈਕਸਾਗਨ ਵਿਧੀ ਗਣਿਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ ਅਤੇ ਬਣਾਉਂਦੀ ਹੈਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗਨ ਬਹੁਭੁਜ। ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸੀਮਾ. \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ।ਲੋਡ਼ ਪੈਣ ਉੱਤੇ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਰੰਗਾਂ ਨੂੰ ਲਿਖੋ ", \'ਇੱਥੇ ਰੰਗ ਵਾਲੀ colors.py ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਹੈ।ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਸਥਿਰਾਂਕ। ਇਹ ਸਥਿਰਾਂਕ ਹੋਰ ਫਾਈਲਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। \\n\\n "\'ਪਾਈਥਨ \\nSNAKE _ COLOR ="#32CD32" "#ਲਾਈਮ ਗ੍ਰੀਨ \\nFOOD _ COLOR =" "#FF4500" "#ਓਰੇਂਜ ਰੈੱਡ \\nGRID _ COLOR =" "#708090" "#ਸਲੇਟ ਗ੍ਰੇ\\nBG _ COLOR =" "#F0F8FF" "#NAME _ 3 ਬਲੂ \\n" "\\n" "ਇਹ"ਰੰਗ ਚੰਗੇ ਕੰਟਰਾਸਟ ਪ੍ਰਦਾਨ ਕਰਨ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੋਣ ਲਈ ਚੁਣੇ ਗਏ ਸਨ। ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦੇ ਅਧਾਰ\' ਤੇ ਇਨ੍ਹਾਂ ਮੁੱਲਾਂ ਨੂੰ ਹੋਰ ਰੰਗਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।ਇਹਨਾਂ ਸਥਿਰਾਂ ਨੂੰ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (main.py, hexagonalsnake.py, board.py) ਵਿੱਚ ਆਯਾਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਖੇਡ ਦੇ ਤੱਤਾਂ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕੇ।ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਵਿੱਚ ਮਿਲੇ ਮੁੱਦੇ. \',\' 1. main.py ਫਾਈਲ ਵਿੱਚ, \'game_board.update_display ()\' ਵਿਧੀ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਖ ਖੇਡ ਲੂਪ। ਹਾਲਾਂਕਿ, ਇਸ ਨੂੰ ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅੱਪਡੇਟ ਕਰਨ ਲਈ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਕਾਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\n2.board.py ਫਾਇਲ ਵਿੱਚ \'ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ()\' ਵਿਧੀ \'self.delete (tk.ALL)\' ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਗਰਿੱਡ ਸਮੇਤ ਸਾਰੇ ਕੈਨਵਸ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾ ਸਕਦੀ ਹੈ।ਖੇਡ ਦੇ ਦੌਰਾਨ ਚਮਕਣਾ ਕਿਉਂਕਿ ਖੇਡ ਲੂਪ ਦੇ ਹਰੇਕ ਦੁਹਰਾਓ ਵਿੱਚ ਗਰਿੱਡ ਨੂੰ ਦੁਬਾਰਾ ਖਿੱਚਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, ਸਿਰਫ ਸੱਪ ਅਤੇ ਭੋਜਨ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋਰੀਡ੍ਰੌ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰੋ। \\n\\n3. hexagonalsnake.py ਫਾਇਲ ਵਿੱਚ, \'ਚੇਂਜ _ ਡਾਇਰੈਕਸ਼ਨ ()\' ਵਿਧੀ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਦਿਸ਼ਾ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।ਦਿਸ਼ਾ, ਜਿਸ ਕਾਰਨ ਸੱਪ ਤੁਰੰਤ ਆਪਣੇ ਆਪ ਨਾਲ ਟਕਰਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਨਵੀਂ ਦਿਸ਼ਾ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਹੈਇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਦਿਸ਼ਾ। \\n\\n4. board.py ਫਾਇਲ ਵਿੱਚ, \'ਡਰਾਅ _ ਹੈਕਸਾਗਨ ()\' ਵਿਧੀ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਦੇ ਅਧਾਰ ਉੱਤੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ। ਇਹਹੈਕਸਾਗਨਾਂ ਦੀ ਗਲਤ ਸਥਿਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ ਸੈੱਲ ਦਾ ਆਕਾਰ 2 ਨਾਲ ਵੰਡਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਚੁਣਿਆ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਹੈ2 ਨਾਲ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ। \\n\\n5. ਮੌਜੂਦਾ ਕੋਡ ਖੇਡ ਦੀ ਗਤੀ ਜਾਂ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਖੇਡ ਬਹੁਤ ਤੇਜ਼ ਜਾਂ ਬਹੁਤ ਹੌਲੀ ਚੱਲ ਸਕਦੀ ਹੈ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿਸਿਸਟਮ। ਸੱਪ ਦੀ ਲੰਬਾਈ ਜਾਂ ਲੰਘੇ ਸਮੇਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਖੇਡ ਦੀ ਗਤੀ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਇੱਕ ਢੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n6. ਕੋਡ ਵਿੱਚ ਇੱਕ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਸਕੋਰਿੰਗ ਵਿਧੀ ਜਾਂ ਕੋਈ ਵੀ ਜੀ. ਯੂ. ਆਈ. ਤੱਤ (ਉਦਾਹਰਣ ਵਜੋਂ, "ਗੇਮ ਓਵਰ" ਜਾਂ "ਵਿਰਾਮਿਤ")। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ।ਉਪਭੋਗਤਾ ਦਾ ਤਜਰਬਾ. \\n\\n7. ਕੋਡ ਖੇਡ ਨੂੰ ਰੋਕਣ ਜਾਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰਨ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਨੂੰ ਹੋਰ ਬਿਹਤਰ ਬਣਾਇਆ ਜਾਵੇਗਾ।ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ. \\n\\n8. ਕੋਡ ਵਿੱਚ ਕੋਈ ਟਿੱਪਣੀਆਂ ਜਾਂ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ। ਟਿੱਪਣੀਆਂ ਅਤੇ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਕੋਡ ਪਡ਼੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਹੋਵੇਗਾ ਅਤੇਕਾਇਮ ਰੱਖਣਯੋਗਤਾ. \\n\\n9. ਮੌਜੂਦਾ ਲਾਗੂਕਰਨ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਸੱਪ ਪੂਰੇ ਗਰਿੱਡ ਨੂੰ ਭਰ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪੈਦਾ ਕਰਨਾ ਅਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ।ਨਵਾਂ ਭੋਜਨ। ਇਸ ਸਥਿਤੀ ਲਈ ਇੱਕ ਜਾਂਚ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਦੇ ਤਰਕ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ। \\n\\n10. ਕੋਡ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਜਾਂ ਅਪਵਾਦ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਕੈਚਿੰਗ. ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਜੋਡ਼ਨਾ, ਖ਼ਾਸਕਰ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਅਤੇ ਟੀਕਿੰਟਰ ਨਾਲ ਸਬੰਧਤ ਕੋਡ ਲਈ, ਖੇਡ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਬਣਾਵੇਗਾ। \', "ਉਦੇਸ਼ਃ ਇੱਕ ਬਣਾਓਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਕੀਤੀ ਮੁੱਖ ਲਿਖੋ, \'ਇੱਥੇ ਠੀਕ ਕੀਤੀ ਗਈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ main.py ਫਾਈਲ ਹੈ। ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨਮੁੱਖ ਲੂਪ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਅਤੇ ਇੱਕ ਸੱਪ ਸਪੀਡ ਵੇਰੀਏਬਲ ਨੂੰ ਜੋਡ਼ਨਾ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਦਾ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਦਾ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਸੱਪ ਦਾ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ\\ \'ਸੱਜੇ\']: \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\n game.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\nroot.destroy () \\n ਹੋਰਃ \\n root.after (ਸੱਪ _ ਸਪੀਡ, ਮੇਨ _ ਲੂਪ) \\n\\nroot = tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame= ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ board = ਬੋਰਡ (ਰੂਟ, ਗੇਮ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਆਨ _ ਕੀ) \\n\\nsnake _ ਸਪੀਡ = 100 #ਲਈ ਇਸ ਮੁੱਲ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋਤੇਜ਼ ਜਾਂ ਹੌਲੀ ਸੱਪ ਦੀ ਗਤੀ \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\' ਇਸ ਠੀਕ ਕੀਤੀ ਗਈ main.py ਫਾਈਲ ਵਿੱਚ ਅੰਦਰ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਸ਼ਾਮਲ ਹੈ।ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਮੇਨ _ ਲੂਪ ਫੰਕਸ਼ਨ। ਇਹ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਸੱਪ _ ਸਪੀਡ ਵੇਰੀਏਬਲ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।ਖੇਡ ਨੂੰ ਤੇਜ਼ ਜਾਂ ਹੌਲੀ ਬਣਾਉਣ ਲਈ ਸੱਪ _ ਸਪੀਡ ਵੇਰੀਏਬਲ ਨੂੰ ਐਡਜਸਟ ਕਰ ਸਕਦਾ ਹੈ। \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \'ਸਿਰਫ਼ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂਅੱਖਰ (\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਲਿਖੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ, \'ਚਰਿੱਤਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਬੋਰਡ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਟੀਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਰੰਗ ਨਾਲ colors.py ਫਾਈਲ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਕਲਾਸ ਨਾਲ ਸਥਿਰਾਂਕ ਅਤੇ hexagonalsnake.py ਫਾਇਲ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਤੋਂਹੈਕਸਾਗੋਨਲ ਸੱਪ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\nself.cell_size = 30\\n self.game = ਖੇਡ \\n ਚੌਡ਼ਾਈ = self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ ()।ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\n self.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): x ਲਈ \\nਸੀਮਾ (self.game.grid_size): \\n self.draw_hexagon (x, y, GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ \\n ਬਿੰਦੂ = [] \\n (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x * self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\n ਪਾਈ =y * self.cell_size * 3/4 + self.cell_size * math.sin (ਕੋਣ _ ਰੇਡ)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਬਿੰਦੂ, ਭਰੋ = ਰੰਗ,ਆਉਟਲਾਈਨ = GRID _ COLOR) \\n\\n ਡਿਫ ਅਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸੈਲਫ): \\n self.delete (tk.ALL) \\n self.draw_grid () \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y,SNAKE _ COLOR) \\n self.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n "\'\\n\\n ਇਹ ਬੋਰਡ ਕਲਾਸ ਟਿੰਟਰ ਕੈਨਵਸ ਨੂੰ ਅਰੰਭ ਕਰਦੀ ਹੈ, ਖਿੱਚਦੀ ਹੈਗਰਿੱਡ, ਅਤੇ ਖੇਡ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਡਰਾਅ _ ਹੈਕਸਾਗਨ ਵਿਧੀ ਗਣਿਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ ਅਤੇ ਬਣਾਉਂਦੀ ਹੈਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗਨ ਬਹੁਭੁਜ। ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸੀਮਾ. \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ।ਲੋਡ਼ ਪੈਣ ਉੱਤੇ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਰੰਗਾਂ ਨੂੰ ਲਿਖੋ ", \'ਇੱਥੇ ਰੰਗ ਵਾਲੀ colors.py ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਹੈ।ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਸਥਿਰਾਂਕ। ਇਹ ਸਥਿਰਾਂਕ ਹੋਰ ਫਾਈਲਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। \\n\\n "\'ਪਾਈਥਨ \\nSNAKE _ COLOR ="#32CD32" "#ਲਾਈਮ ਗ੍ਰੀਨ \\nFOOD _ COLOR =" "#FF4500" "#ਓਰੇਂਜ ਰੈੱਡ \\nGRID _ COLOR =" "#708090" "#ਸਲੇਟ ਗ੍ਰੇ\\nBG _ COLOR =" "#F0F8FF" "#NAME _ 3 ਬਲੂ \\n" "\\n" "ਇਹ"ਰੰਗ ਚੰਗੇ ਕੰਟਰਾਸਟ ਪ੍ਰਦਾਨ ਕਰਨ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੋਣ ਲਈ ਚੁਣੇ ਗਏ ਸਨ। ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦੇ ਅਧਾਰ\' ਤੇ ਇਨ੍ਹਾਂ ਮੁੱਲਾਂ ਨੂੰ ਹੋਰ ਰੰਗਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।ਇਹਨਾਂ ਸਥਿਰਾਂ ਨੂੰ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (main.py, hexagonalsnake.py, board.py) ਵਿੱਚ ਆਯਾਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਖੇਡ ਦੇ ਤੱਤਾਂ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕੇ।ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਵਿੱਚ ਮਿਲੇ ਮੁੱਦੇ. \',\' 1. main.py ਫਾਈਲ ਵਿੱਚ, \'game_board.update_display ()\' ਵਿਧੀ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਖ ਖੇਡ ਲੂਪ। ਹਾਲਾਂਕਿ, ਇਸ ਨੂੰ ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅੱਪਡੇਟ ਕਰਨ ਲਈ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਕਾਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\n2.board.py ਫਾਇਲ ਵਿੱਚ \'ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ()\' ਵਿਧੀ \'self.delete (tk.ALL)\' ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਗਰਿੱਡ ਸਮੇਤ ਸਾਰੇ ਕੈਨਵਸ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾ ਸਕਦੀ ਹੈ।ਖੇਡ ਦੇ ਦੌਰਾਨ ਚਮਕਣਾ ਕਿਉਂਕਿ ਖੇਡ ਲੂਪ ਦੇ ਹਰੇਕ ਦੁਹਰਾਓ ਵਿੱਚ ਗਰਿੱਡ ਨੂੰ ਦੁਬਾਰਾ ਖਿੱਚਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, ਸਿਰਫ ਸੱਪ ਅਤੇ ਭੋਜਨ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋਰੀਡ੍ਰੌ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰੋ। \\n\\n3. hexagonalsnake.py ਫਾਇਲ ਵਿੱਚ, \'ਚੇਂਜ _ ਡਾਇਰੈਕਸ਼ਨ ()\' ਵਿਧੀ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਦਿਸ਼ਾ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।ਦਿਸ਼ਾ, ਜਿਸ ਕਾਰਨ ਸੱਪ ਤੁਰੰਤ ਆਪਣੇ ਆਪ ਨਾਲ ਟਕਰਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਨਵੀਂ ਦਿਸ਼ਾ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਹੈਇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਦਿਸ਼ਾ। \\n\\n4. board.py ਫਾਇਲ ਵਿੱਚ, \'ਡਰਾਅ _ ਹੈਕਸਾਗਨ ()\' ਵਿਧੀ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਦੇ ਅਧਾਰ ਉੱਤੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ। ਇਹਹੈਕਸਾਗਨਾਂ ਦੀ ਗਲਤ ਸਥਿਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ ਸੈੱਲ ਦਾ ਆਕਾਰ 2 ਨਾਲ ਵੰਡਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਚੁਣਿਆ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਹੈ2 ਨਾਲ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ। \\n\\n5. ਮੌਜੂਦਾ ਕੋਡ ਖੇਡ ਦੀ ਗਤੀ ਜਾਂ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਖੇਡ ਬਹੁਤ ਤੇਜ਼ ਜਾਂ ਬਹੁਤ ਹੌਲੀ ਚੱਲ ਸਕਦੀ ਹੈ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿਸਿਸਟਮ। ਸੱਪ ਦੀ ਲੰਬਾਈ ਜਾਂ ਲੰਘੇ ਸਮੇਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਖੇਡ ਦੀ ਗਤੀ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਇੱਕ ਢੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n6. ਕੋਡ ਵਿੱਚ ਇੱਕ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਸਕੋਰਿੰਗ ਵਿਧੀ ਜਾਂ ਕੋਈ ਵੀ ਜੀ. ਯੂ. ਆਈ. ਤੱਤ (ਉਦਾਹਰਣ ਵਜੋਂ, "ਗੇਮ ਓਵਰ" ਜਾਂ "ਵਿਰਾਮਿਤ")। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ।ਉਪਭੋਗਤਾ ਦਾ ਤਜਰਬਾ. \\n\\n7. ਕੋਡ ਖੇਡ ਨੂੰ ਰੋਕਣ ਜਾਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰਨ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਨੂੰ ਹੋਰ ਬਿਹਤਰ ਬਣਾਇਆ ਜਾਵੇਗਾ।ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ. \\n\\n8. ਕੋਡ ਵਿੱਚ ਕੋਈ ਟਿੱਪਣੀਆਂ ਜਾਂ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ। ਟਿੱਪਣੀਆਂ ਅਤੇ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਕੋਡ ਪਡ਼੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਹੋਵੇਗਾ ਅਤੇਕਾਇਮ ਰੱਖਣਯੋਗਤਾ. \\n\\n9. ਮੌਜੂਦਾ ਲਾਗੂਕਰਨ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਸੱਪ ਪੂਰੇ ਗਰਿੱਡ ਨੂੰ ਭਰ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪੈਦਾ ਕਰਨਾ ਅਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ।ਨਵਾਂ ਭੋਜਨ। ਇਸ ਸਥਿਤੀ ਲਈ ਇੱਕ ਜਾਂਚ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਦੇ ਤਰਕ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ। \\n\\n10. ਕੋਡ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਜਾਂ ਅਪਵਾਦ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਕੈਚਿੰਗ. ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਜੋਡ਼ਨਾ, ਖ਼ਾਸਕਰ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਅਤੇ ਟੀਕਿੰਟਰ ਨਾਲ ਸਬੰਧਤ ਕੋਡ ਲਈ, ਖੇਡ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਬਣਾਵੇਗਾ। \', "ਉਦੇਸ਼ਃ ਇੱਕ ਬਣਾਓਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਕੀਤੀ ਮੁੱਖ ਲਿਖੋ, \'ਇੱਥੇ ਠੀਕ ਕੀਤੀ ਗਈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ main.py ਫਾਈਲ ਹੈ। ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨਮੁੱਖ ਲੂਪ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਅਤੇ ਇੱਕ ਸੱਪ ਸਪੀਡ ਵੇਰੀਏਬਲ ਨੂੰ ਜੋਡ਼ਨਾ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਦਾ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਦਾ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਸੱਪ ਦਾ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ\\ \'ਸੱਜੇ\\\']: \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\n game.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\nroot.destroy () \\n ਹੋਰਃ \\n root.after (ਸੱਪ _ ਸਪੀਡ, ਮੇਨ _ ਲੂਪ) \\n\\nroot = tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame= ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ board = ਬੋਰਡ (ਰੂਟ, ਗੇਮ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਆਨ _ ਕੀ) \\n\\nsnake _ ਸਪੀਡ = 100 #ਲਈ ਇਸ ਮੁੱਲ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋਤੇਜ਼ ਜਾਂ ਹੌਲੀ ਸੱਪ ਦੀ ਗਤੀ \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\' ਇਸ ਠੀਕ ਕੀਤੀ ਗਈ main.py ਫਾਈਲ ਵਿੱਚ ਅੰਦਰ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਸ਼ਾਮਲ ਹੈ।ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਮੇਨ _ ਲੂਪ ਫੰਕਸ਼ਨ। ਇਹ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਸੱਪ _ ਸਪੀਡ ਵੇਰੀਏਬਲ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।ਖੇਡ ਨੂੰ ਤੇਜ਼ ਜਾਂ ਹੌਲੀ ਬਣਾਉਣ ਲਈ ਸੱਪ _ ਸਪੀਡ ਵੇਰੀਏਬਲ ਨੂੰ ਐਡਜਸਟ ਕਰ ਸਕਦਾ ਹੈ। \', "ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ।ਸਿਰਫ਼ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂਅੱਖਰ (\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਲਿਖੋ।ਹੈਕਸਾਗੋਨਲਸਨੇਕ "," ਇੱਥੇ ਠੀਕ ਕੀਤੀ ਗਈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ hexagonalsnake.py ਫਾਇਲ ਹੈ। ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਉਲਟ ਦਿਸ਼ਾ ਲਈ ਇੱਕ ਚੈੱਕ ਅਤੇ ਇੱਕ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ।ਸਕੋਰਿੰਗ ਵਿਧੀ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n ਕਲਾਸਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\n self.food =self.generate_food () \\n self.game_over = ਗਲਤ \\n self.score = 0\\n\\n ਪਰਿਵਰਤਨ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n ਵਿਰੋਧੀ = {\'ਉੱਪਰ\': \'ਨਾਮ _ 2\', \'ਨਾਮ _ 2\':\'ਅੱਪ\', \'ਖੱਬੇ\': \'ਸੱਜੇ\', \'ਸੱਜੇ\': \'ਖੱਬੇ\'} \\n ਜੇਕਰ ਨਵੀਂ _ ਦਿਸ਼ਾ! = ਉਲਟ [self.direction]: \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡਿਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n self.score + = 1\\n ਨਹੀਂ ਤਾਂਃself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਸ ਠੀਕ ਕੀਤੀ ਗਈ hexagonalsnake.py ਫਾਇਲ ਵਿੱਚ ਉਲਟ ਦਿਸ਼ਾ ਲਈ ਇੱਕ ਚੈੱਕ ਸ਼ਾਮਲ ਹੈਸੱਪ ਨੂੰ ਤੁਰੰਤ ਆਪਣੇ ਨਾਲ ਟਕਰਾਉਣ ਤੋਂ ਰੋਕਣ ਲਈ \'ਚੇਂਜ _ ਡਾਇਰੈਕਸ਼ਨ ()\' ਵਿਧੀ, ਅਤੇ ਇਹ ਵਾਧੇ ਦੁਆਰਾ ਇੱਕ ਸਕੋਰਿੰਗ ਵਿਧੀ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਸੱਪ ਭੋਜਨ ਖਾਂਦਾ ਹੈ ਤਾਂ ਸਕੋਰ "", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲਕੇਵਲ. \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਇਸ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਗਿਆ ਹੈ।ਕੋਡ. \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਬੋਰਡ ਲਿਖੋ "] ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ', ' [\'ਇੱਕ ਸਿੰਗਲ ਬਿੰਦੂ ਲਿਖੋ\', \'.\', \'ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ\' \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮਾਡਿਊਲਾਂ ਨਾਲ। \\n -ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਬਾਰੇ ਕਦਮ ਦਰ ਕਦਮ ਦੱਸੋ।ਹਾਲੇ ਤੱਕ. \\n ", ਕਦਮ 1: ਪ੍ਰੋਜੈਕਟ ਢਾਂਚੇ ਦੀ ਯੋਜਨਾ ਬਣਾਓ \\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਨੂੰ ਰੱਖਣ ਅਤੇ ਗੇਮ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਮੁੱਖ ਫਾਈਲ (ਜਿਵੇਂ main.py) ਬਣਾਓ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ(ਉਦਾਹਰਨ ਲਈ hexagonalsnake.py) ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ, ਜਿਸ ਵਿੱਚ ਖੇਡ ਤਰਕ ਅਤੇ ਜ਼ਰੂਰੀ ਢੰਗ ਸ਼ਾਮਲ ਹੋਣਗੇ। \\n-ਇੱਕ ਫਾਈਲ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ board.py)ਟੀਕਿੰਟਰ ਨਾਲ ਖੇਡ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਰੱਖਣ ਲਈ। \\n-ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਫਾਈਲ (ਜਿਵੇਂ colors.py) ਬਣਾਓ।ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n\\n ਕਦਮ 2: ਮੁੱਖ ਫਾਇਲ (main.py) \\n ਸੈੱਟ ਅੱਪ ਕਰੋ-ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟਕਿੰਟਰ, ਹੈਕਸਾਗੋਨਲਸਨੇਕ, ਬੋਰਡ, ਰੰਗ) ਆਯਾਤ ਕਰੋ। \\n-ਸ਼ੁਰੂ ਕਰੋਟੀਕਿੰਟਰ ਵਿੰਡੋ ਅਤੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ (ਸਿਰਲੇਖ, ਅਕਾਰ, ਆਦਿ) ਸੈੱਟ ਕਰੋ। \\n-ਬੋਰਡ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ ਅਤੇ ਇਸ ਨੂੰ ਟੀਕਿੰਟਰ ਵਿੰਡੋ ਵਿੱਚ ਪੈਕ ਕਰੋ। \\n-ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਵਾਈਲ ਲੂਪ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਜਾਂ ਟੀਕਿੰਟਰ ਮੇਨ ਲੂਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। \\n-ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ (ਜਿਵੇਂ ਕਿ ਕੀਬੋਰਡ ਈਵੈਂਟਸ) ਨੂੰ ਸੰਭਾਲੋ।ਮੁੱਖ ਗੇਮ ਲੂਪ। \\n\\n ਕਦਮ 3: ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ (hexagonalsnake.py) ਨੂੰ ਲਾਗੂ ਕਰੋ \\n-ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਨੂੰ ਗੁਣਾਂ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਸੱਪ ਦਾ ਸਰੀਰ, ਦਿਸ਼ਾ ਅਤੇ ਖੇਡ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਪਰਿਵਰਤਨ. \\n-ਸੱਪ ਦੀ ਗਤੀ, ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਭੋਜਨ ਲਈ ਢੰਗਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਖਪਤ। \\n-ਖੇਡ ਦੀ ਸਥਿਤੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਸੱਪ ਦੀ ਸਥਿਤੀ, ਖੇਡ ਦੀ ਸਥਿਤੀ, ਸਕੋਰ, ਆਦਿ)। \\n\\n ਕਦਮ 4: ਬੋਰਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਕਲਾਸ (board.py) \\n-ਟੀਕਿੰਟਰ ਕੈਨਵਸ, ਗਰਿੱਡ ਅਕਾਰ ਅਤੇ ਹੋਰ ਡਿਸਪਲੇ-ਸਬੰਧਤ ਵੇਰੀਏਬਲਾਂ ਲਈ ਗੁਣਾਂ ਨਾਲ ਬੋਰਡ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। \\n-ਲਾਗੂ ਕਰੋਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗੋਨਲ ਗਰਿੱਡ, ਸੱਪ ਅਤੇ ਭੋਜਨ ਨੂੰ ਖਿੱਚਣ ਦੇ ਢੰਗ। \\n-ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਕਰੋ (ਜਿਵੇਂ ਕਿ ਕੈਨਵਸ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ)।ਖੇਡ ਅਵਸਥਾ ਦੇ ਅਧਾਰ ਉੱਤੇ। \\n\\n ਕਦਮ 5: ਐਰਗੋਨੋਮਿਕ ਰੰਗ ਸਥਿਰਾਂਕਾਂ (colors.py) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ \\n-RGB ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰੰਗ ਸਥਿਰਾਂਕਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਚੰਗੇ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।ਇਸ ਦੇ ਉਲਟ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹਨ। \\n-ਇਹਨਾਂ ਰੰਗਾਂ ਦੀ ਵਰਤੋਂ ਛੇਭੁਜੀ ਗਰਿੱਡ, ਸੱਪ, ਭੋਜਨ ਅਤੇ ਹੋਰ ਖੇਡ ਤੱਤਾਂ ਲਈ ਕਰੋ। \\n\\n ਕਦਮ 6: ਖੇਡ ਨੂੰ ਲਾਗੂ ਕਰੋ।ਤਰਕ\\n-ਮੁੱਖ ਗੇਮ ਲੂਪ ਵਿੱਚ, ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਗੇਮ ਸਥਿਤੀ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। \\n-ਕਾਲ ਕਰਕੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰੋ।ਬੋਰਡ ਕਲਾਸ ਦੇ ਢੁਕਵੇਂ ਢੰਗ। \\n-ਸੱਪ ਦੀ ਦਿਸ਼ਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਅਤੇ ਹੋਰ ਖੇਡ ਘਟਨਾਵਾਂ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਨੂੰ ਸੰਭਾਲੋ (ਜਿਵੇਂ ਕਿ ਵਿਰਾਮ,ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰੋ, ਆਦਿ). \\n\\n ਕਦਮ 7: ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ \\n-ਖੇਡ ਨੂੰ ਚਲਾਓ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰੋ ਕਿ ਕੋਈ ਬੱਗ, ਕਰੈਸ਼ ਜਾਂ ਅਣਚਾਹੇ ਨਹੀਂ ਹਨ।ਵਿਵਹਾਰ। \\n-ਅਨੁਕੂਲ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਲਈ ਕੋਡ, ਗੇਮ ਲੌਜਿਕ ਅਤੇ ਡਿਸਪਲੇਅ ਵਿੱਚ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਤਬਦੀਲੀਆਂ ਕਰੋ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਕਦਮ ਦਰ ਕਦਮ ਸਮਝਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦਾ ਸਨਮਾਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਵੇ, ਬਿਨਾਂ ਕੋਈ ਕੋਡ ਲਿਖੇ। "," ਕਦਮ 1: ਪਾਈਥਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।3. 7. 9 ਅਨੁਕੂਲਤਾ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਪਾਈਥਨ 3.7.9 ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਇਸ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜੋ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ 3.7.9. \\n\\n ਕਦਮ 2: ਮੋਡੀਊਲ ਦਰਾਮਦ ਨੂੰ ਸੀਮਤ ਕਰੋ \\n-ਸਿਰਫ ਜ਼ਰੂਰੀ ਮੋਡੀਊਲ (ਟੀਕਿੰਟਰ ਅਤੇ ਗਣਿਤ) ਨੂੰ ਆਯਾਤ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ।ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ। ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਜਿੱਥੇ ਵੀ ਸੰਭਵ ਹੋਵੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰੋ। \\n\\n ਕਦਮ 3: ਕੋਡ ਸੰਕੁਚਿਤਤਾ \\n-ਟਰੈਕ ਰੱਖੋਹਰੇਕ ਫਾਇਲ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ 2048 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਟੈਕਸਟ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਸੰਪਾਦਕ ਜਾਂ IDE. \\n-ਛੋਟੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬੇਲੋਡ਼ੀਆਂ ਚਿੱਟੀਆਂ ਥਾਵਾਂ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਖੇਪ ਰੱਖ ਕੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। \\n-ਵਰਤੋਂਪਾਈਥਨ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਮਿਨੀਫਿਕੇਸ਼ਨ ਤਕਨੀਕਾਂ, ਜਿਵੇਂ ਕਿ ਸੂਚੀ ਦੀ ਸਮਝ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਅਤੇ ਹੋਰ ਇੱਕ-ਲਾਈਨਰ ਜਦੋਂ ਉਚਿਤ ਹੋਵੇ। \\n-ਬ੍ਰੇਕ ਨਾਮ _ 2ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟੇ, ਮੁਡ਼ ਵਰਤੋਂ ਯੋਗ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਕਦਮ 4: ਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਰਹੇਜ਼ ਕਰੋ \\n-ਕੈਮਲਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਾਂਅੰਡਰਸਕੋਰ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਚਣ ਲਈ ਸੱਪ ਕੇਸ ਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ ਲਈ ਪਾਸਕਲ ਕੇਸ ਨਾਮਕਰਨ ਸੰਮੇਲਨਾਂ। \\n\\nਸਟੈਪ 5: ਸ਼ਾਮਲ ਕਰੋਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਲੋਡ਼ੀਂਦਾ ਡੇਟਾ-ਜੇਕਰ ਗੇਮ ਨੂੰ ਖਾਸ ਡੇਟਾ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਜਿਵੇਂ ਕਿ ਰੰਗ ਮੁੱਲ, ਗੇਮ ਸੈਟਿੰਗਜ਼), ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਕਰੋ।ਫਾਇਲਾਂ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਵੱਖਰੀ ਫਾਈਲ ਵਿੱਚ ਸਥਿਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ) ਬਾਹਰੀ ਫਾਇਲਾਂ ਜਾਂ ਸਰੋਤਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਬਜਾਏ। \\n\\n ਕਦਮ 6: ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ\\n-ਰੰਗ ਚੁਣੋਉਹ ਯੋਜਨਾਵਾਂ ਜੋ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ (ਜਿਵੇਂ ਸੱਪ, ਭੋਜਨ, ਪਿਛੋਕਡ਼) ਵਿਚਕਾਰ ਚੰਗਾ ਅੰਤਰ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ।ਇੱਕ ਅਰਾਮਦਾਇਕ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਉਪਕਰਣਾਂ ਅਤੇ ਰੋਸ਼ਨੀ ਦੀਆਂ ਸਥਿਤੀਆਂ। \\n-ਪੂਰੇ ਖੇਡ ਵਿੱਚ ਇੱਕ ਇਕਸਾਰ ਰੰਗ ਸਕੀਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜਿਵੇਂ ਕਿਮੇਨੂ, ਖੇਡ ਦੇ ਤੱਤ ਅਤੇ ਪਿਛੋਕਡ਼। \\n\\n ਕਦਮ 7: ਨਿਰੰਤਰ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ \\n-ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਨਿਯਮਿਤ ਤੌਰ \'ਤੇ ਖੇਡ ਦੀ ਜਾਂਚ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਇਹਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ (ਪਾਈਥਨ ਸੰਸਕਰਣ, ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ, ਅੱਖਰ ਦੀ ਸੀਮਾ, ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂ, ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ, ਐਰਗੋਨੋਮਿਕ ਡਿਸਪਲੇ)। \\n-ਜ਼ਰੂਰੀ ਬਣਾਓਜੇ ਕੋਈ ਰੁਕਾਵਟ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਖੇਡ ਨੂੰ ਦੁਬਾਰਾ ਟੈਸਟ ਕਰੋ। \\n\\n ਕਦਮ 8: ਕੋਡ ਸਮੀਖਿਆ \\n-ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ,ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਸਾਰੀਆਂ ਰੁਕਾਵਟਾਂ ਪੂਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਕੋਡ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਹੈ, ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕੋਡ ਸਮੀਖਿਆ ਕਰੋ। \\n-ਜੇ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਪੀਅਰ ਜਾਂ ਕੁਸ਼ਲ ਕੋਡ ਰੱਖੋ।ਸਹਿਯੋਗੀ ਕਿਸੇ ਵੀ ਸੰਭਾਵਿਤ ਮੁੱਦੇ ਜਾਂ ਸੁਧਾਰ ਦੇ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹਨ। "", ਪਾਈਥਨ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਲੋਡ਼ੀਂਦੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੋ।ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਫਾਈਲ ਦੇ ਨਾਮ ਨੂੰ ਕੁੰਜੀ ਅਤੇ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਦੇ ਵੇਰਵੇ ਨੂੰ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ। \\n ", \'{\\n" ਮੇਨ ":" ਮੁੱਖਫਾਈਲ ਜਿਸ ਵਿੱਚ ਮੁੱਖ ਗੇਮ ਲੂਪ, ਟਕਿੰਟਰ ਵਿੰਡੋ ਸ਼ੁਰੂਆਤੀਕਰਨ, ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਹੈਂਡਲਿੰਗ ਹੈ।, "\\n" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ":" ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ "ਕਲਾਸ, ਜਿਸ ਵਿੱਚ ਗੇਮ ਲੌਜਿਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।, "\\n" ਬੋਰਡਃ "ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਬੋਰਡ ਕਲਾਸ ਰੱਖਣ ਵਾਲੀ ਫਾਈਲ।ਟਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਕੈਨਵਸ ਨੂੰ ਖਿੱਚਣ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਦੇ ਢੰਗ ਸ਼ਾਮਲ ਹਨ।, "\\n" ਰੰਗਃ "ਇੱਕ ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਰੰਗ ਸਥਿਰਤਾ ਵਾਲੀ ਫਾਈਲ,ਵੱਖ-ਵੱਖ ਤੱਤਾਂ ਲਈ ਪੂਰੀ ਖੇਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। "\\n}", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਮੁੱਖ \\n ਨੂੰ ਲਿਖੋ।ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਮੈਂ ਮੁੱਖ ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ ਜੋ ਟਿੰਟਰ ਵਿੰਡੋ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਗੇਮ ਲੂਪ ਸੈਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈਇਨਪੁਟਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (hexagonalsnake.py, board.py, colors.py) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਸਬੰਧਤ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟੀਕਿੰਟਰ tk\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ\\n ਬੋਰਡ ਆਯਾਤ ਬੋਰਡ ਤੋਂ \\n\\ndef\'ਤੇ _ ਕੁੰਜੀ\' (ਘਟਨਾ): \\n ਕੁੰਜੀ = event.keysym \\n ਜੇਕਰ \'ਅੱਪ\', \'ਨਾਮ _ 2\', \'ਖੱਬਾ\', \'ਸੱਜਾ\' ਵਿੱਚ ਕੁੰਜੀ ਹੈਃ \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\ngame.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\n root.destroy () \\n ਹੋਰਃ \\n root.after (100, ਮੇਨ _ ਲੂਪ) \\n\\nroot =tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame = ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ ਬੋਰ੍ਡੁ = ਬੋਰਡ (ਰੂਟ,ਖੇਡ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਕੀ ਉੱਤੇ) \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\\n ਇਹ ਕੋਡ ਇੱਕ ਟਿੰਟਰ ਵਿੰਡੋ ਬਣਾਉਂਦਾ ਹੈ, ਨੂੰ ਅਰੰਭ ਕਰਦਾ ਹੈਹੈਕਸਾਗੋਨਲ ਸੱਪ ਅਤੇ ਬੋਰਡ ਦੇ ਉਦਾਹਰਣ, ਸੱਪ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮੁੱਖ ਈਵੈਂਟ ਹੈਂਡਲਰ ਸਥਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਨਾਲ ਮੁੱਖ ਗੇਮ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ।ਗੇਮ ਲੂਪ ਗੇਮ ਦੀ ਸਥਿਤੀ ਅਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਗੇਮ ਖਤਮ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਲੂਪ ਦੇ ਅਗਲੇ ਦੁਹਰਾਓ ਨੂੰ ਤਹਿ ਕਰਦਾ ਹੈ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਨੂੰ ਲਿਖੋ "," ਅੱਖਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਕਲਾਸ ਬੁਨਿਆਦੀ ਖੇਡ ਤਰਕ, ਸੱਪ ਦੀ ਗਤੀ ਅਤੇ ਟੱਕਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਨੂੰ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਬਣਾਇਆ ਹੈਰੰਗ ਸਥਿਰਾਂਕਾਂ ਨਾਲ colors.py ਫਾਇਲ। \\n\\n "\'ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਬੇਤਰਤੀਬੇ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR,BG _ COLOR\\n\\n ਵਰਗ ਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\nself.food = self.generate_food () \\n self.game_over = ਗਲਤ \\n\\n ਡੈਫ ਤਬਦੀਲੀ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡੈਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n ਨਹੀਂ ਤਾਂਃ \\nself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਹ ਸ਼੍ਰੇਣੀ ਖੇਡ ਅਵਸਥਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਸੱਪ ਦੀ ਗਤੀ, ਭੋਜਨ ਉਤਪਾਦਨ ਅਤੇ ਖੇਡ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ।ਹਾਲਾਤ. ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਸੀਮਾ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n -ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਹੈ ਨਾਮ _ 1). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਨਾਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈਪ੍ਰੋਜੈਕਟ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਬੋਰਡ ਨੂੰ ਲਿਖੋ, \'ਚਰਿੱਤਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ, ਮੈਂ ਬੋਰਡ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।ਟੀਕਿੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੇਮ ਬੋਰਡ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕਲਾਸ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਕੋਡ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਰੰਗ ਨਾਲ colors.py ਫਾਈਲ ਬਣਾ ਚੁੱਕੇ ਹੋ।ਹੈਕਸਾਗੋਨਲ ਸਨੈਕ ਕਲਾਸ ਨਾਲ ਸਥਿਰਾਂਕ ਅਤੇ hexagonalsnake.py ਫਾਇਲ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਆਯਾਤ ਤੋਂਹੈਕਸਾਗੋਨਲ ਸੱਪ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\nself.cell_size = 30\\n self.game = ਖੇਡ \\n ਚੌਡ਼ਾਈ = self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ ()।ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\n self.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): x ਲਈ \\nਸੀਮਾ (self.game.grid_size): \\n self.draw_hexagon (x, y, GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ \\n ਬਿੰਦੂ = [] \\n (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x * self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\n ਪਾਈ =y * self.cell_size * 3/4 + self.cell_size * math.sin (ਕੋਣ _ ਰੇਡ)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਬਿੰਦੂ, ਭਰੋ = ਰੰਗ,ਆਉਟਲਾਈਨ = GRID _ COLOR) \\n\\n ਡਿਫ ਅਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸੈਲਫ): \\n self.delete (tk.ALL) \\n self.draw_grid () \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y,SNAKE _ COLOR) \\n self.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n "\'\\n\\n ਇਹ ਬੋਰਡ ਕਲਾਸ ਟਿੰਟਰ ਕੈਨਵਸ ਨੂੰ ਅਰੰਭ ਕਰਦੀ ਹੈ, ਖਿੱਚਦੀ ਹੈਗਰਿੱਡ, ਅਤੇ ਖੇਡ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਉੱਤੇ ਡਿਸਪਲੇਅ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਡਰਾਅ _ ਹੈਕਸਾਗਨ ਵਿਧੀ ਗਣਿਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ ਅਤੇ ਬਣਾਉਂਦੀ ਹੈਕੈਨਵਸ ਉੱਤੇ ਹੈਕਸਾਗਨ ਬਹੁਭੁਜ। ਨੋਟ ਕਰੋ ਕਿ ਪੂਰੇ ਲਾਗੂ ਕਰਨ ਲਈ 2048 ਅੱਖਰ ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਲਈ ਵਾਧੂ ਤਰੀਕਿਆਂ ਅਤੇ ਅਨੁਕੂਲਤਾਵਾਂ ਦੀ ਲੋਡ਼ ਹੋ ਸਕਦੀ ਹੈ।ਸੀਮਾ. \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲ। \\n-ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ।ਲੋਡ਼ ਪੈਣ ਉੱਤੇ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੇ ਰੰਗਾਂ ਨੂੰ ਲਿਖੋ ", \'ਇੱਥੇ ਰੰਗ ਵਾਲੀ colors.py ਫਾਈਲ ਦਾ ਇੱਕ ਸੰਖੇਪ ਸੰਸਕਰਣ ਹੈ।ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ ਲਈ ਸਥਿਰਾਂਕ। ਇਹ ਸਥਿਰਾਂਕ ਹੋਰ ਫਾਈਲਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਖੇਡ ਤੱਤਾਂ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। \\n\\n "\'ਪਾਈਥਨ \\nSNAKE _ COLOR ="#32CD32" "#ਲਾਈਮ ਗ੍ਰੀਨ \\nFOOD _ COLOR =" "#FF4500" "#ਓਰੇਂਜ ਰੈੱਡ \\nGRID _ COLOR =" "#708090" "#ਸਲੇਟ ਗ੍ਰੇ\\nBG _ COLOR =" "#F0F8FF" "#NAME _ 3 ਬਲੂ \\n" "\\n" "ਇਹ"ਰੰਗ ਚੰਗੇ ਕੰਟਰਾਸਟ ਪ੍ਰਦਾਨ ਕਰਨ ਅਤੇ ਅੱਖਾਂ \'ਤੇ ਅਸਾਨ ਹੋਣ ਲਈ ਚੁਣੇ ਗਏ ਸਨ। ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦੇ ਅਧਾਰ\' ਤੇ ਇਨ੍ਹਾਂ ਮੁੱਲਾਂ ਨੂੰ ਹੋਰ ਰੰਗਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।ਇਹਨਾਂ ਸਥਿਰਾਂ ਨੂੰ ਹੋਰ ਲੋਡ਼ੀਂਦੀਆਂ ਫਾਈਲਾਂ (main.py, hexagonalsnake.py, board.py) ਵਿੱਚ ਆਯਾਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਖੇਡ ਦੇ ਤੱਤਾਂ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕੇ।ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤੀਆਂ ਕੋਡ ਫਾਈਲਾਂ ਵਿੱਚ ਮਿਲੇ ਮੁੱਦੇ. \',\' 1. main.py ਫਾਈਲ ਵਿੱਚ, \'game_board.update_display ()\' ਵਿਧੀ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਮੁੱਖ ਖੇਡ ਲੂਪ। ਹਾਲਾਂਕਿ, ਇਸ ਨੂੰ ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਅੱਪਡੇਟ ਕਰਨ ਲਈ \'ਮੈਨ _ ਲੂਪ ()\' ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਕਾਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\n2.board.py ਫਾਇਲ ਵਿੱਚ \'ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ()\' ਵਿਧੀ \'self.delete (tk.ALL)\' ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਗਰਿੱਡ ਸਮੇਤ ਸਾਰੇ ਕੈਨਵਸ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾ ਸਕਦੀ ਹੈ।ਖੇਡ ਦੇ ਦੌਰਾਨ ਚਮਕਣਾ ਕਿਉਂਕਿ ਖੇਡ ਲੂਪ ਦੇ ਹਰੇਕ ਦੁਹਰਾਓ ਵਿੱਚ ਗਰਿੱਡ ਨੂੰ ਦੁਬਾਰਾ ਖਿੱਚਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, ਸਿਰਫ ਸੱਪ ਅਤੇ ਭੋਜਨ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋਰੀਡ੍ਰੌ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰੋ। \\n\\n3. hexagonalsnake.py ਫਾਇਲ ਵਿੱਚ, \'ਚੇਂਜ _ ਡਾਇਰੈਕਸ਼ਨ ()\' ਵਿਧੀ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਦਿਸ਼ਾ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।ਦਿਸ਼ਾ, ਜਿਸ ਕਾਰਨ ਸੱਪ ਤੁਰੰਤ ਆਪਣੇ ਆਪ ਨਾਲ ਟਕਰਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਨਵੀਂ ਦਿਸ਼ਾ ਵਰਤਮਾਨ ਦੇ ਉਲਟ ਹੈਇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਦਿਸ਼ਾ। \\n\\n4. board.py ਫਾਇਲ ਵਿੱਚ, \'ਡਰਾਅ _ ਹੈਕਸਾਗਨ ()\' ਵਿਧੀ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਦੇ ਅਧਾਰ ਉੱਤੇ ਹੈਕਸਾਗਨ ਵਰਟੀਸ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ। ਇਹਹੈਕਸਾਗਨਾਂ ਦੀ ਗਲਤ ਸਥਿਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ ਸੈੱਲ ਦਾ ਆਕਾਰ 2 ਨਾਲ ਵੰਡਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਚੁਣਿਆ \'ਸੈੱਲ _ ਸਾਈਜ਼\' ਹੈ2 ਨਾਲ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ। \\n\\n5. ਮੌਜੂਦਾ ਕੋਡ ਖੇਡ ਦੀ ਗਤੀ ਜਾਂ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਖੇਡ ਬਹੁਤ ਤੇਜ਼ ਜਾਂ ਬਹੁਤ ਹੌਲੀ ਚੱਲ ਸਕਦੀ ਹੈ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿਸਿਸਟਮ। ਸੱਪ ਦੀ ਲੰਬਾਈ ਜਾਂ ਲੰਘੇ ਸਮੇਂ ਦੇ ਅਧਾਰ ਉੱਤੇ ਖੇਡ ਦੀ ਗਤੀ ਨੂੰ ਅਨੁਕੂਲ ਕਰਨ ਲਈ ਇੱਕ ਢੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ। \\n\\n6. ਕੋਡ ਵਿੱਚ ਇੱਕ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਸਕੋਰਿੰਗ ਵਿਧੀ ਜਾਂ ਕੋਈ ਵੀ ਜੀ. ਯੂ. ਆਈ. ਤੱਤ (ਉਦਾਹਰਣ ਵਜੋਂ, "ਗੇਮ ਓਵਰ" ਜਾਂ "ਵਿਰਾਮਿਤ")। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਸਕੋਰ ਜਾਂ ਗੇਮ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ।ਉਪਭੋਗਤਾ ਦਾ ਤਜਰਬਾ. \\n\\n7. ਕੋਡ ਖੇਡ ਨੂੰ ਰੋਕਣ ਜਾਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਮੁਡ਼ ਸ਼ੁਰੂ ਕਰਨ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ। ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਨੂੰ ਹੋਰ ਬਿਹਤਰ ਬਣਾਇਆ ਜਾਵੇਗਾ।ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ. \\n\\n8. ਕੋਡ ਵਿੱਚ ਕੋਈ ਟਿੱਪਣੀਆਂ ਜਾਂ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ। ਟਿੱਪਣੀਆਂ ਅਤੇ ਡੌਕਸਟਰਿੰਗ ਸ਼ਾਮਲ ਕਰਨ ਨਾਲ ਕੋਡ ਪਡ਼੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਹੋਵੇਗਾ ਅਤੇਕਾਇਮ ਰੱਖਣਯੋਗਤਾ. \\n\\n9. ਮੌਜੂਦਾ ਲਾਗੂਕਰਨ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਸੱਪ ਪੂਰੇ ਗਰਿੱਡ ਨੂੰ ਭਰ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਪੈਦਾ ਕਰਨਾ ਅਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ।ਨਵਾਂ ਭੋਜਨ। ਇਸ ਸਥਿਤੀ ਲਈ ਇੱਕ ਜਾਂਚ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਖੇਡ ਦੇ ਤਰਕ ਵਿੱਚ ਵਾਧਾ ਹੋਵੇਗਾ। \\n\\n10. ਕੋਡ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਜਾਂ ਅਪਵਾਦ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ।ਕੈਚਿੰਗ. ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਜੋਡ਼ਨਾ, ਖ਼ਾਸਕਰ ਉਪਭੋਗਤਾ ਇਨਪੁਟਸ ਅਤੇ ਟੀਕਿੰਟਰ ਨਾਲ ਸਬੰਧਤ ਕੋਡ ਲਈ, ਖੇਡ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਬਣਾਵੇਗਾ। \', "ਉਦੇਸ਼ਃ ਇੱਕ ਬਣਾਓਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਸਿਰਫ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਦੇ ਨਾਲ। \\n-ਲੋਡ਼ ਪੈਣ \'ਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ(ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ). \\n-ਕੋਡ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਕੀਤੀ ਮੁੱਖ ਲਿਖੋ, \'ਇੱਥੇ ਠੀਕ ਕੀਤੀ ਗਈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ main.py ਫਾਈਲ ਹੈ। ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨਮੁੱਖ ਲੂਪ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਅਤੇ ਇੱਕ ਸੱਪ ਸਪੀਡ ਵੇਰੀਏਬਲ ਨੂੰ ਜੋਡ਼ਨਾ।ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਦਾ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਦਾ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਸੱਪ ਦਾ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ ਆਯਾਤ ਬੋਰਡ ਤੋਂ\\ \'ਸੱਜੇ\\\']: \\n game.change_direction (ਕੁੰਜੀ) \\n\\ndef ਮੈਨ _ ਲੂਪ (): \\n game.update_state () \\n game_board.update_display () \\n ਜੇਕਰ game.game_over: \\nroot.destroy () \\n ਹੋਰਃ \\n root.after (ਸੱਪ _ ਸਪੀਡ, ਮੇਨ _ ਲੂਪ) \\n\\nroot = tk.Tk ()\\nroot.title ("ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ")\\nroot.resizable (ਗਲਤ, ਗਲਤ) \\ngame= ਹੈਕਸਾਗੋਨਲ ਸੱਪ () \\ngame _ board = ਬੋਰਡ (ਰੂਟ, ਗੇਮ)\\ngame_board.pack ()\\nroot.bind (\\\'<ਕੁੰਜੀ>\\\', ਆਨ _ ਕੀ) \\n\\nsnake _ ਸਪੀਡ = 100 #ਲਈ ਇਸ ਮੁੱਲ ਨੂੰ ਅਨੁਕੂਲ ਕਰੋਤੇਜ਼ ਜਾਂ ਹੌਲੀ ਸੱਪ ਦੀ ਗਤੀ \\nmain _ ਲੂਪ ()\\nroot.mainloop () \\n \'\\n\' ਇਸ ਠੀਕ ਕੀਤੀ ਗਈ main.py ਫਾਈਲ ਵਿੱਚ ਅੰਦਰ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਸ਼ਾਮਲ ਹੈ।ਖੇਡ ਦੌਰਾਨ ਡਿਸਪਲੇਅ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਮੇਨ _ ਲੂਪ ਫੰਕਸ਼ਨ। ਇਹ ਸੱਪ ਦੀ ਗਤੀ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਸੱਪ _ ਸਪੀਡ ਵੇਰੀਏਬਲ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।ਖੇਡ ਨੂੰ ਤੇਜ਼ ਜਾਂ ਹੌਲੀ ਬਣਾਉਣ ਲਈ ਸੱਪ _ ਸਪੀਡ ਵੇਰੀਏਬਲ ਨੂੰ ਐਡਜਸਟ ਕਰ ਸਕਦਾ ਹੈ। \', "ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ।ਸਿਰਫ਼ ਟੀਕਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਨਹੀਂਅੱਖਰ (\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਲਿਖੋ।ਹੈਕਸਾਗੋਨਲਸਨੇਕ "," ਇੱਥੇ ਠੀਕ ਕੀਤੀ ਗਈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ hexagonalsnake.py ਫਾਇਲ ਹੈ। ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਉਲਟ ਦਿਸ਼ਾ ਲਈ ਇੱਕ ਚੈੱਕ ਅਤੇ ਇੱਕ ਚੈੱਕ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ।ਸਕੋਰਿੰਗ ਵਿਧੀ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਰੈਂਡਮ\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR, FOOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n ਕਲਾਸਹੈਕਸਾਗੋਨਲ ਸੱਪਃ \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n self.grid_size = 20\\n self.snake = [[10,10], [10,11], [10,12]] \\n self.direction = \'ਅੱਪ\' \\n self.food =self.generate_food () \\n self.game_over = ਗਲਤ \\n self.score = 0\\n\\n ਪਰਿਵਰਤਨ _ ਦਿਸ਼ਾ (ਸਵੈ, ਨਵੀਂ _ ਦਿਸ਼ਾ): \\n ਵਿਰੋਧੀ = {\'ਉੱਪਰ\': \'ਨਾਮ _ 2\', \'ਨਾਮ _ 2\':\'ਅੱਪ\', \'ਖੱਬੇ\': \'ਸੱਜੇ\', \'ਸੱਜੇ\': \'ਖੱਬੇ\'} \\n ਜੇਕਰ ਨਵੀਂ _ ਦਿਸ਼ਾ! = ਉਲਟ [self.direction]: \\n self.direction = ਨਵੀਂ _ ਦਿਸ਼ਾ \\n\\n ਡਿਫਭੋਜਨ ਤਿਆਰ ਕਰੋ (ਸਵੈ): \\n ਭੋਜਨ = [random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਜਦੋਂ ਕਿ ਭੋਜਨ self.snake: \\n ਭੋਜਨ =[random.randint (0, self.grid_size-1), random.randint (0, self.grid_size-1)] \\n ਭੋਜਨ ਵਾਪਸ ਕਰੋ \\n\\n ਡੇਫ ਅੱਪਡੇਟ _ ਸਟੇਟ (ਸੈਲਫ): \\n ਹੈਡ =self.snake [0] ਕਾਪੀ () \\n ਜੇਕਰ self.direction = = \'ਉੱਪਰ\': \\n ਸਿਰ [1]-= 1\\n ਐਲੀਫ self.direction = = \'NAME _ 2\': \\n ਸਿਰ [1] + = 1\\n ਐਲੀਫ self.direction = = \'ਖੱਬਾ\': \\nਹੈੱਡ [0]-= 1 \\n ਐਲੀਫ self.direction = = \'ਸਹੀ\': \\n ਹੈੱਡ [0] + = 1\\n\\n ਜੇਕਰ ਹੈੱਡ = = self.food: \\n self.food = self.generate_food () \\n self.score + = 1\\n ਨਹੀਂ ਤਾਂਃself.snake. ਪੌਪ () \\n\\n ਜੇਕਰ (ਹੈੱਡ [0] <0 ਜਾਂ ਹੈੱਡ [0]> = self.grid_size ਜਾਂ ਹੈੱਡ [1] <0 ਜਾਂ ਹੈੱਡ [1]> = self.grid_size ਜਾਂ ਹੈੱਡ self.snake): \\n self.game_over= ਸੱਚ \\n ਹੋਰਃ \\n self.snake.insert (0, ਸਿਰ) \\n \'\\n\' ਇਸ ਠੀਕ ਕੀਤੀ ਗਈ hexagonalsnake.py ਫਾਇਲ ਵਿੱਚ ਉਲਟ ਦਿਸ਼ਾ ਲਈ ਇੱਕ ਚੈੱਕ ਸ਼ਾਮਲ ਹੈਸੱਪ ਨੂੰ ਤੁਰੰਤ ਆਪਣੇ ਨਾਲ ਟਕਰਾਉਣ ਤੋਂ ਰੋਕਣ ਲਈ \'ਚੇਂਜ _ ਡਾਇਰੈਕਸ਼ਨ ()\' ਵਿਧੀ, ਅਤੇ ਇਹ ਵਾਧੇ ਦੁਆਰਾ ਇੱਕ ਸਕੋਰਿੰਗ ਵਿਧੀ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।ਜਦੋਂ ਸੱਪ ਭੋਜਨ ਖਾਂਦਾ ਹੈ ਤਾਂ ਸਕੋਰ "", ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਟਿੰਟਰ ਅਤੇ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ ਨਾਲਕੇਵਲ. \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦਾ ਨਾਮ _ 1 ਹੈ)। \\n-ਇਸ ਵਿੱਚ ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ (\'_\') ਨਹੀਂ ਵਰਤਿਆ ਗਿਆ ਹੈ।ਕੋਡ. \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਬੋਰਡ ਲਿਖੋ, \'ਇੱਥੇ ਹੈਠੀਕ ਕੀਤੀ ਗਈ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ board.py ਫਾਇਲ। ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਫਲੈਕਰਿੰਗ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਅਤੇ ਇਸ ਵਿੱਚ ਇੱਕ ਵਿਧੀ ਜੋਡ਼ਨਾ ਸ਼ਾਮਲ ਹੈ।ਸਕੋਰ ਵੇਖਾਓ। \\n\\n \'\' ਪਾਈਥਨ\\ਨਿੰਪੋਰਟ ਟਕਿੰਟਰ ਨੂੰ tk\\ਨਿੰਪੋਰਟ ਗਣਿਤ\\n ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਤੋਂ ਆਯਾਤ ਹੈਕਸਾਗੋਨਲਸਨੈਕ ਰੰਗਾਂ ਤੋਂ ਆਯਾਤ SNAKE _ COLOR,FOOD _ COLOR, GRID _ COLOR, BG _ COLOR\\n\\n ਕਲਾਸ ਬੋਰਡ (tk.Canvas): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਰੂਟ, ਗੇਮ): \\n self.cell_size = 30\\n self.game = ਗੇਮ ਦੀ ਚੌਡ਼ਾਈ =self.cell_size * game.grid_size \\n ਉਚਾਈ = self.cell_size * game.grid_size \\n ਸੁਪਰ (). _ _ init _ (ਰੂਟ, ਚੌਡ਼ਾਈ = ਚੌਡ਼ਾਈ, ਉਚਾਈ = ਉਚਾਈ, bg = BG _ COLOR) \\nself.draw_grid () \\n\\n ਡਿਫ ਡਰਾਅ _ ਗਰਿੱਡ (ਸੈਲਫ): ਸੀਮਾ ਵਿੱਚ y ਲਈ \\n (self.game.grid_size): ਸੀਮਾ ਵਿੱਚ x ਲਈ \\n (self.game.grid_size): \\n self.draw_hexagon (x, y, y)GRID _ COLOR) \\n\\n ਡਿਫ ਡ੍ਰਾ ਹੈਕਸਾਗਨ (ਸਵੈ, x, y, ਰੰਗ): \\n ਬਿੰਦੂ = [] \\n ਸੀਮਾ ਵਿੱਚ ਕੋਣ ਲਈ (0,360,60): \\n ਕੋਣ _ ਰੇਡ = math.radians (ਕੋਣ) \\n px = x *self.cell_size + self.cell_size/2 * (1 + y% 2) + self.cell_size * math.cos (ਕੋਣ _ ਰੇਡ)/2\\nπ = y * self.cell_size * 3/4 + self.cell_size *math.sin (angle _ rad)/2\\n points.extend ([px, py]) \\n self.create_polygon (ਅੰਕ, ਭਰੋ = ਰੰਗ, ਰੂਪ ਰੇਖਾ = GRID _ COLOR) \\n\\n ਡਿਫ ਡਿਸਪਲੇਅ _ ਸਕੋਰ (ਸੈਲਫ, ਸਕੋਰ): \\nਟੈਕਸਟ = f "ਸਕੋਰਃ {ਸਕੋਰ}" \\n self.create_text (50,10, ਟੈਕਸਟ = ਟੈਕਸਟ, ਭਰੋ = "ਕਾਲਾ", ਫੌਂਟ = ("ਏਰੀਅਲ", 12)) \\n\\n ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ (ਸਵੈ): \\nself.delete ("ਸੱਪ") \\n self.delete ("ਭੋਜਨ") \\n x ਲਈ, y self.game.snake ਵਿੱਚਃ \\n self.draw_hexagon (x, y, SNAKE _ COLOR) \\nself.draw_hexagon (self.game.food [0], self.game.food [1], FOOD _ COLOR) \\n self.display_score (self.game.score) \\n \'\\n\' ਇਹ ਠੀਕ ਕੀਤੀ ਗਈ board.py ਫਾਈਲ ਹੈ।ਇਸ ਵਿੱਚ ਇੱਕ ਅਨੁਕੂਲ ਅੱਪਡੇਟ _ ਡਿਸਪਲੇਅ ਵਿਧੀ ਸ਼ਾਮਲ ਹੈ ਜੋ ਸਿਰਫ ਸੱਪ ਅਤੇ ਭੋਜਨ ਤੱਤਾਂ ਨੂੰ ਹਟਾ ਕੇ ਝਟਕੇ ਨੂੰ ਘੱਟ ਕਰਦੀ ਹੈ। ਇਹ ਇੱਕ ਡਿਸਪਲੇ _ ਸਕੋਰ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।ਗੇਮ ਬੋਰਡ ਉੱਤੇ ਮੌਜੂਦਾ ਸਕੋਰ ਦਰਸਾਉਣ ਦਾ ਤਰੀਕਾ। \',\' ਉਦੇਸ਼ਃ ਇੱਕ ਹੈਕਸਾਗੋਨਲ ਸੱਪ ਗੇਮ ਬਣਾਓ \\nਕੰਸਟ੍ਰੇੰਟਸਃ \\n-ਪਾਈਥਨ 3.7.9 ਨਾਲ ਟੀਕਿੰਟਰ ਅਤੇਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਮੋਡੀਊਲ। \\n-ਲੋਡ਼ ਪੈਣ ਉੱਤੇ ਗਣਿਤ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਕਰੋ। \\n-ਸੰਖੇਪ ਕੋਡ (ਹਰੇਕ ਫਾਈਲ 2048 ਅੱਖਰਾਂ ਦੀ ਹੈ)। \\n-ਕੋਈ ਅੰਡਰਸਕੋਰ ਅੱਖਰ ਨਹੀਂ(\'_\') ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n-ਕੋਈ ਵੀ ਲੋਡ਼ੀਂਦਾ ਡਾਟਾ ਪ੍ਰੋਜੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n-ਐਰਗੋਨੋਮਿਕ ਰੰਗਦਾਰ ਡਿਸਪਲੇਅ। \\n ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਅਤੇ ਸਹੀ ਰੰਗ ਲਿਖੋ। ', 'ਇੱਕ ਬਿੰਦੂ ਲਿਖੋ \n ']