ਪਰਿਕਿਰਿਆਤਮਕ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੀ ਗਈ ਖੇਡ ਭੂਮੀ ਪ੍ਰਤੀਕਰਮ, PHP, ਅਤੇ ਵੈਬ ਸੌਕੇਟ ਨਾਲ ਪਰਿਕਿਰਿਆਤਮਕ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੀ ਗਈ ਖੇਡ ਭੂਮੀ ਪ੍ਰਤੀਕਰਮ, PHP, ਅਤੇ ਵੈਬ ਸੌਕੇਟਸਰੇਟਿਡ ਵਿਸ਼ਿਆਂ: ਫਰੇਮਵਰਕਸਪੀਆਈਸੀਸ ਸੁਰੱਖਿਆਪੱਤਰ ਅਤੇ & ਪ੍ਰੈਕਟਿਸਡ ਡੀਬੱਗਿੰਗ & ਮਿਗਲ
PHP ਅਤੇ ReactJS ਦੇ ਨਾਲ ਖੇਡ ਵਿਕਾਸ
- ਰੀਐਕਟਰ ਅਤੇ PHP ਨਾਲ ਗੇਮ ਡਿਵੈਲਪਮੈਂਟ: ਉਹ ਕਿੰਨੇ ਅਨੁਕੂਲ ਹਨ?
- ਪਰਿਕਿਰਿਆਤਮਕ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੀ ਗੇਮ ਟੈਰੀਨ ਰੀਐਕਟ, ਪੀਐਚਪੀ ਅਤੇ ਵੈਬ ਸੌਕੇਟ
ਉੱਚ ਗੁਣਵੱਤਾ, ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਨ ਲਈ ਡੂੰਘਾਈ ਨਾਲ ਜਾਣ-ਪਛਾਣ ਲਈ, ਤੁਸੀਂ ਕੈਨੇਡਾ ਦੇ ਪੂਰੇ ਸਟੈਕ ਵਿਕਾਸਕਾਰ ਵੇਸ ਬੋਸ ਤੋਂ ਪਹਿਲਾਂ ਨਹੀਂ ਜਾ ਸਕਦੇ. ਇੱਥੇ ਆਪਣੇ ਕੋਰਸ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਅਤੇ ਕੋਡ SITEPOINT ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ 25% ਬੰਦ ਅਤੇ ਸਾਈਟਪੌਰਟ ਦੀ ਸਹਾਇਤਾ ਕਰਨ ਲਈ ਮਦਦ ਕਰੋ.
ਪਿਛਲੀ ਵਾਰ, ਮੈਂ ਤੁਹਾਨੂੰ ਕਹਾਣੀ ਦੱਸਣਾ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤਾ ਕਿ ਮੈਂ ਕਿਵੇਂ ਖੇਡਣਾ ਚਾਹੁੰਦਾ ਸੀ. ਮੈਂ ਦੱਸਿਆ ਕਿ ਕਿਵੇਂ ਮੈਂ ਐਸਸੀਨਕ PHP ਸਰਵਰ, ਲਰਲੇਲ ਮਿਕਸ ਬਿਲਡ ਚੇਨ, ਰੀਕੈਕਟ ਫਰੰਟ ਐਂਡ, ਅਤੇ ਵੈੱਬਸੌਕੈਟਸ ਨੂੰ ਇਸਦੇ ਨਾਲ ਜੋੜਦੇ ਹੋਏ ਸੈਟ ਅਪ ਕਰਦਾ ਹਾਂ - monitor system temp. ਹੁਣ, ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂ ਕਿ ਕੀ ਹੋਇਆ ਜਦੋਂ ਮੈਂ ਗੇਮ ਮਕੈਨਿਕ ਨੂੰ ਰਿਐਕਟਰ, ਪੀਐਚਪੀ, ਅਤੇ ਵੈਬ ਸੌਕੇਟ ਨਾਲ ਮਿਲਾ ਕੇ .
ਇਸ ਹਿੱਸੇ ਦਾ ਕੋਡ ਗਿੱਠੂਬ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ. com / assertchris-tutorials / sitepoint-making-games / tree / part-2 ਮੈਂ ਇਸ ਨੂੰ PHP 7 ਨਾਲ ਪ੍ਰੀਖਣ ਕੀਤਾ ਹੈ. 1 , ਗੂਗਲ ਕਰੋਮ ਦੇ ਨਵੇਂ ਵਰਜਨ ਵਿੱਚ.
ਫਾਰਮ ਬਣਾਉਣਾ
"ਸਮਾਲ ਚਾਲੂ ਸਧਾਰਨ ਸ਼ੁਰੂ ਕਰੋ. ਸਾਡੇ ਕੋਲ 10 ਤੋਂ 10 ਟਾਇਲਸ ਦੀ ਗਰਿੱਡ ਹੈ, ਜੋ ਬੇਤਰਤੀਬ ਤੌਰ ਤੇ ਤਿਆਰ ਕੀਤੀ ਗਈ ਸਮੱਗਰੀ ਨਾਲ ਭਰਿਆ ਹੋਇਆ ਹੈ. "
ਮੈਂ ਫਾਰਮ ਫਾਰਮ ਅਤੇ ਪੈਚ ਦੇ ਰੂਪ ਵਿੱਚ ਹਰੇਕ ਟਾਇਲ ਨੂੰ ਦਰਸਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ. ਤੋਂ ਐਪ / ਮਾਡਲ / ਫਾਰਮਮੋਡੀਲ. ਪੂਰਵ :
ਨਾਮਸਪੇਸ ਐਪ \ ਮਾਡਲ;ਕਲਾਸ ਫਾਰਮ{ਪ੍ਰਾਈਵੇਟ $ ਚੌੜਾਈ{ਪ੍ਰਾਪਤ ਕਰੋ {ਵਾਪਸੀ $ this-> ਚੌੜਾਈ; }}ਨਿਜੀ ਡਾਲਰ ਉਚਾਈ{ਪ੍ਰਾਪਤ ਕਰੋ {ਰਿਟਰਨ $ ਇਸ-> ਉਚਾਈ; }}ਜਨਤਕ ਫੰਕਸ਼ਨ __ਕੰਟਰੋਲ (int $ width = 10,int $ height = 10){$ this-> ਚੌੜਾਈ = $ ਚੌੜਾਈ;$ this-> ਉਚਾਈ = $ ਉਚਾਈ;}} ਮੈਂ ਸੋਚਿਆ ਕਿ ਇਹ ਜਨਤਕ ਗਾਰਟਰਾਂ ਦੇ ਨਾਲ ਪ੍ਰਾਈਵੇਟ ਜਾਇਦਾਦਾਂ ਦੀ ਘੋਸ਼ਣਾ ਕਰ ਕੇ ਕਲਾਸ ਦੇ ਐਕਸੈਸਸਰਜ਼ ਮੈਕਰੋ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ ਇੱਕ ਮਜ਼ੇਦਾਰ ਸਮਾਂ ਹੋਵੇਗਾ. ਇਸ ਲਈ ਮੈਨੂੰ ਪ੍ਰੀ / ਕਲਾਸ-ਐਕਸੈਸਸਰ (33 ਰਾਹੀਂ) ਕੰਪੋਜ਼ਰ ਦੀ ਲੋੜ ਸੀ ).
ਫਿਰ ਮੈਂ ਬੇਨਤੀ 'ਤੇ ਨਵੇਂ ਖੇਤਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਸਾਕਟ ਕੋਡ ਬਦਲਿਆ. ਤੋਂ ਐਪ / ਸਾਕਟ / ਗੇਮਸਾਕਟ ਪੂਰਵ :
ਨਾਂ-ਸਪੇਸ ਐਪ ਸਾਕਟ;Aerys \ Request ਦੀ ਵਰਤੋਂ ਕਰੋ;Aerys \ Response ਦੀ ਵਰਤੋਂ ਕਰੋ;Aerys \ Websocket ਵਰਤੋ;Aerys \ Websocket \ Endpoint;Aerys \ Websocket \ Message ਵਰਤੋਂ;ਐਪ \ ਮਾਡਲ \ ਫਾਰਮਮੋਡਲ ਵਰਤੋ;ਕਲਾਸ ਗੇਮ ਸਵਿੱਚ ਔਜੈਂਟ ਵੈਬਸਸੈਟ{ਪ੍ਰਾਈਵੇਟ $ ਫਾਰਮਾਂ = [];ਜਨਤਕ ਫੰਕਸ਼ਨ ਔਨ ਡਾਟਾ (ਇੰਟ $ ਕਲਾਇੰਟ ਆਈਡੀ,ਸੁਨੇਹਾ ਸੁਨੇਹਾ ਭੇਜੋ){$ body = $ ਸੰਦੇਸ਼ ਪੈਦਾ ਕਰੋ;ਜੇ ($ body === "ਨਵਾਂ-ਫਾਰਮ") {$ ਫਾਰਮ = ਨਵਾਂ ਫਾਰਮਮੌਡਲ ;$ payload = json_encode (["ਫਾਰਮ" => ["ਚੌੜਾਈ" => $ ਫਾਰਮ-> ਚੌੜਾਈ,"ਉਚਾਈ" => $ ਫਾਰਮ-> ਉੱਚਾਈ,],]);ਉਪਰੋਕਤ $-> ਅੰਤਮ ਪੁਆਇੰਟ-> ਭੇਜੋ ($ ਪੇਲੋਡ, $ clientId);$ this-> ਫਾਰਮ [$ clientId] = $ ਫਾਰਮ;}}ਜਨਤਕ ਫੰਕਸ਼ਨ ਔਨਕੌਸ (ਇੰਟ $ ਕਲਾਇੰਟ ਆਈਡੀ,int $ ਕੋਡ, ਸਤਰ $ ਕਾਰਨ){ਅਨਸੈਟ ਕਰੋ ($-> ਕਨੈਕਸ਼ਨ [$ clientId]);ਅਨਸੈਟ ਕਰੋ ($-> ਫਾਰਮਾਂ [$ clientId]);}// .} ਮੈਂ ਦੇਖਿਆ ਕਿ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਗੇਮ ਸਾਕਟ ਮੇਰੇ ਕੋਲ ਪਿਛਲੇ ਇੱਕ ਸੀ - ਸਿਵਾਏ, ਇੱਕ ਈਕੋ ਪ੍ਰਸਾਰਣ ਕਰਨ ਦੀ ਬਜਾਏ, ਮੈਂ ਨਵੇਂ-ਫਾਰਮ ਲਈ ਚੈੱਕ ਕਰ ਰਿਹਾ ਸੀ ਅਤੇ ਸਿਰਫ ਇੱਕ ਸੁਨੇਹਾ ਵਾਪਸ ਭੇਜਿਆ ਸੀ ਗਾਹਕ ਨੂੰ ਪੁੱਛੋ
"ਸ਼ਾਇਦ ਇਹ ਰੀਐਕੱਟ ਕੋਡ ਦੇ ਨਾਲ ਘੱਟ ਆਮ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਧੀਆ ਸਮਾਂ ਹੈ. ਮੈਂ ਭਾਗ ਨੂੰ ਬਦਲਣ ਜਾ ਰਿਹਾ ਹਾਂ jsx ਤੋ ਫਾਰਮ jsx . "
ਜਾਇਦਾਦ / ਜੇ ਐਸ / ਫਾਰਮ ਤੋਂ jsx :
ਆਯਾਤ "ਪ੍ਰਤੀਕਿਰਿਆ"ਕਲਾਸ ਫਾਰਮ ਵਿਚ ਵਾਧਾ ਹੋਇਆ ਹੈ. ਸਾਕਟ = ਨਵਾਂ ਵੈਬਸਾਕਟ ("ws: // 127 0. 0. 1: 8080 / ਵਾਂ")ਇਹ. ਸਾਕਟ addEventListener ("ਸੰਦੇਸ਼", ਇਹ. onMessage)// DEBUGਇਹ. ਸਾਕਟ addEventListener ("ਖੋਲ੍ਹੋ", => {ਇਹ. ਸਾਕਟ ਭੇਜੋ ("ਨਵਾਂ-ਫਾਰਮ")})}}ਨਿਰਯਾਤ ਮੂਲ ਫਾਰਮ ਦਰਅਸਲ, ਜੋ ਇਕੋ ਚੀਜ਼ ਮੈਂ ਬਦਲ ਗਈ ਸੀ, ਉਹ ਹੈਲੋ ਸੰਸਾਰ ਦੀ ਬਜਾਏ ਨਵੇਂ ਫਾਰਮ ਨੂੰ ਭੇਜ ਰਹੀ ਸੀ . ਬਾਕੀ ਸਭ ਕੁਝ ਇੱਕੋ ਜਿਹਾ ਸੀ. ਮੈਨੂੰ ਐਪ ਬਦਲਣਾ ਪਏਗਾ jsx ਕੋਡ ਹਾਲਾਂਕਿ. ਸੰਪਤੀ / ਜੇ ਐਸ / ਐਪ ਤੋਂ jsx :
ਆਯਾਤ "ਪ੍ਰਤੀਕਿਰਿਆ""ਪ੍ਰਤੀਕਿਰਿਆ-ਡੋਮ" ਤੋਂ ਰੀਐਕਟੀਮੌਟ ਆਯਾਤ ਕਰੋ". / ਫਾਰਮ" ਤੋਂ ਆਯਾਤ ਫਾਰਮਪ੍ਰਤੀਕਰਮ ਦੇਣਾ ਹੈ( <ਫਾਰਮ /> ,ਦਸਤਾਵੇਜ਼. ਸਵਾਲ-ਚੋਣਕਾਰ (". ਐਪ")) ਇਹ ਕਿਧਰੇ ਸੀ ਜਿੱਥੋਂ ਮੈਨੂੰ ਹੋਣਾ ਚਾਹੀਦਾ ਸੀ, ਪਰ ਇਹਨਾਂ ਤਬਦੀਲੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਂ ਕਲਾਸ ਦੇ ਐਕਸੈਸਰਜ਼ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖ ਸਕਦਾ ਹਾਂ, ਨਾਲ ਹੀ ਭਵਿੱਖ ਦੀ ਵੈਬਸਾocketਟ ਇੰਟਰੈਕਸ਼ਨਾਂ ਲਈ ਬੇਨਤੀ / ਪ੍ਰਤੀਰੂਪ ਪੈਟਰਨ ਦੀ ਇੱਕ ਪ੍ਰੋਟੋਟਾਈਪ. ਮੈਂ ਕੰਸੋਲ ਖੋਲ੍ਹਿਆ, ਅਤੇ ਵੇਖਿਆ {"ਫਾਰਮ": {"ਚੌੜਾਈ": 10, "ਉਚਾਈ": 10}} .
"ਮਹਾਨ!"
ਫੇਰ ਮੈਂ ਇੱਕ ਟਰੀ ਪੈਚ ਕਲਾਸ ਬਣਾਈ ਜੋ ਹਰੇਕ ਟਾਇਲ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ. ਮੈਂ ਇਹ ਸੋਚ ਰਿਹਾ ਸੀ ਕਿ ਖੇਡ ਦੇ ਬਹੁਤ ਸਾਰੇ ਤਰਕ ਹੋਣਗੇ. ਐਪ / ਮਾਡਲ / ਪੈਚਮੌਡਲ. ਪੂਰਵ :
ਨਾਮਸਪੇਸ ਐਪ \ ਮਾਡਲ;ਕਲਾਸ ਪੈਚਮੌਡਲ{ਪ੍ਰਾਈਵੇਟ $ x{ਪ੍ਰਾਪਤ ਕਰੋ {ਰਿਟਰਨ $ ਇਸ-> x; }}ਪ੍ਰਾਈਵੇਟ $ y{ਪ੍ਰਾਪਤ ਕਰੋ {ਰਿਟਰਨ $ ਇਸ-> y; }}ਜਨਤਕ ਫੰਕਸ਼ਨ __ਕੰਟਰੋਲ (int $ x, int $ y){$ this-> x = $ x;$ this-> y = $ y;}} ਮੈਨੂੰ ਬਹੁਤ ਸਾਰੇ ਪੈਚ ਬਣਾਉਣ ਦੀ ਲੋੜ ਪਵੇਗੀ ਕਿਉਂਕਿ ਇੱਕ ਨਵੇਂ ਫਾਰਮ ਵਿੱਚ ਸਪੇਸ ਹਨ. ਮੈਂ ਫਾਰਮਾਂਮੈਲਲ ਉਸਾਰੀ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਇਸ ਨੂੰ ਕਰ ਸਕਦਾ ਹਾਂ. ਤੋਂ ਐਪ / ਮਾਡਲ / ਫਾਰਮਮੋਡੀਲ. ਪੂਰਵ :
ਨਾਮਸਪੇਸ ਐਪ \ ਮਾਡਲ;ਕਲਾਸ ਫਾਰਮਮੋਡਲ{ਪ੍ਰਾਈਵੇਟ $ ਚੌੜਾਈ{ਪ੍ਰਾਪਤ ਕਰੋ {ਵਾਪਸੀ $ this-> ਚੌੜਾਈ; }}ਨਿਜੀ ਡਾਲਰ ਉਚਾਈ{ਪ੍ਰਾਪਤ ਕਰੋ {ਰਿਟਰਨ $ ਇਸ-> ਉਚਾਈ; }}ਪ੍ਰਾਈਵੇਟ $ ਪੈਚ{ਪ੍ਰਾਪਤ ਕਰੋ {ਰਿਟਰਨ $ ਇਸ-> ਪੈਚ; }}ਜਨਤਕ ਫੰਕਸ਼ਨ __ਕੰਟਰੋਲ ($ width = 10, $ height = 10){$ this-> ਚੌੜਾਈ = $ ਚੌੜਾਈ;$ this-> ਉਚਾਈ = $ ਉਚਾਈ;$ this-> createPatches ;}ਪ੍ਰਾਈਵੇਟ ਫੰਕਸ਼ਨ createPatches {($ i = 0; $ i <$ this-> ਚੌੜਾਈ; $ i ++) ਲਈ {$ this-> ਪੈਚ [$ i] = [];ਲਈ ($ j = 0; $ j <$ this-> ਉੱਚਾਈ; $ j ++) {$ this-> ਪੈਚ [$ i] [$ j] =ਨਵਾਂ ਪੈਚਮੌਡਲ ($ i, $ j);}}}} ਹਰ ਇੱਕ ਸੈਲ ਲਈ, ਮੈਂ ਇੱਕ ਨਵਾਂ ਪੈਚਮੋਡਲ ਇਕਾਈ ਬਣਾਈ. ਇਹ ਸ਼ੁਰੂਆਤ ਬਹੁਤ ਹੀ ਸੌਖੇ ਸਨ, ਪਰ ਉਹਨਾਂ ਨੂੰ ਬੇਤਰਤੀਬਤਾ ਦੀ ਇੱਕ ਤੱਤ ਦੀ ਜ਼ਰੂਰਤ ਸੀ- ਰੁੱਖਾਂ, ਜੰਗਲੀ ਬੂਟੀ, ਫੁੱਲਾਂ ਨੂੰ ਵਧਣ ਦਾ ਤਰੀਕਾ .ਘੱਟੋ-ਘੱਟ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਲਈ. ਐਪ / ਮਾਡਲ / ਪੈਚਮੌਡਲ. ਪੂਰਵ :
ਜਨਤਕ ਫੰਕਸ਼ਨ ਸ਼ੁਰੂ (ਟੀ $ ਚੌੜਾਈ, ਇੰਚ $ ਦੀ ਉਚਾਈ,ਐਰੇ $ ਪੈਚ){ਜੇ (! $ this-> ਅਰੰਭ ਕੀਤਾ && random_int (0, 10)> 7) {$ this-> ਸ਼ੁਰੂ = ਸਹੀ;ਵਾਪਿਸ ਸੱਚ ਹੈ;}ਵਾਪਿਸ ਝੂਠ;} ਮੈਂ ਸੋਚਿਆ ਕਿ ਮੈਂ ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਇੱਕ ਪੈਚ ਵਧਣ ਨਾਲ ਸ਼ੁਰੂ ਕਰਾਂਗਾ. ਇਸ ਨੇ ਪੈਚ ਦੀ ਬਾਹਰੀ ਸਥਿਤੀ ਨੂੰ ਨਹੀਂ ਬਦਲਿਆ, ਪਰ ਇਹ ਮੈਨੂੰ ਇਹ ਟੈਸਟ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਕਿ ਉਹ ਫਾਰਮ ਦੁਆਰਾ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕੀਤੀ ਗਈ ਸੀ. ਤੋਂ ਐਪ / ਮਾਡਲ / ਫਾਰਮਮੋਡੀਲ. ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ, ਮੈਂ ਮੈਕਰੋ ਦੀ ਵਰਤੋਂ ਨਾਲ ਇੱਕ ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਕੀਵਰਡ ਦੀ ਸ਼ੁਰੂਆਤ ਕੀਤੀ. ਤੁਸੀਂ ਵੇਖਦੇ ਹੋ, ਐਮਪ ਪ੍ਰੋਮਾਈਜ਼ ਨੂੰ ਹੱਲ ਕਰਕੇ ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ. ਇਸ ਨੁਕਤੇ 'ਤੇ ਹੋਰ: ਜਦੋਂ ਐੱਪ ਉਪਜ ਕੀਵਰਡ ਨੂੰ ਵੇਖਦਾ ਹੈ, ਤਾਂ ਇਹ ਮੰਨ ਲੈਂਦਾ ਹੈ ਕਿ ਜੋ ਕੁੱਝ ਪਾਇਆ ਜਾ ਰਿਹਾ ਹੈ ਉਹ ਕੋਆਰਟੀਨ ਹੈ (ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ).
ਮੈਂ ਬਣਾ ਪਾਏ ਪੈਚ ਇੱਕ ਸਧਾਰਣ ਫੰਕਸ਼ਨ ਕਰ ਸਕਦਾ ਸੀ, ਅਤੇ ਸਿਰਫ ਇਸ ਤੋਂ ਇੱਕ ਕਾਰਾਇਟੀਨ ਵਾਪਸ ਕਰ ਸਕਦਾ ਸੀ, ਪਰ ਇਹ ਅਜਿਹਾ ਇੱਕ ਆਮ ਕੋਡ ਸੀ ਜਿਸ ਨਾਲ ਮੈਂ ਇਸਦੇ ਲਈ ਇੱਕ ਖਾਸ ਮੈਕਰੋ ਬਣਾਈ ਸੀ. ਉਸੇ ਸਮੇਂ, ਮੈਂ ਪਿਛਲੇ ਹਿੱਸੇ ਵਿੱਚ ਕੀਤੇ ਗਏ ਕੋਡ ਨੂੰ ਬਦਲ ਸਕਦਾ ਸੀ ਮਦਦਗਾਰਾਂ ਤੋਂ ਪੂਰਵ :
async ਫੰਕਸ਼ਨ ਮਿਕਸ ($ ਮਾਰਗ) {$ manifest = ਉਪਜ ਐਮ ਪੀ \ ਫਾਇਲ \ ਪ੍ਰਾਪਤ ਕਰੋ (". / ਜਨਤਕ / ਮਿਕਸ-ਮੈਨੀਫੈਸਟ. ਜੇਸਨ");$ manifest = json_decode ($ ਮੈਨੀਫੈਸਟ, ਸਹੀ);ਜੇ (isset ($ ਮੈਨੀਫੈਸਟ [$ ਪਾਥ])) {$ ਮੈਨੀਫੈਸਟ [$ ਪਾਥ] ਵਾਪਸ ਭੇਜੋ;}ਨਵਾਂ ਅਪਵਾਦ ਸੁੱਟੋ ("{$ ਪਾਥ} ਨਹੀਂ ਮਿਲਿਆ");} ਪਹਿਲਾਂ, ਮੈਨੂੰ ਜਨਰੇਟਰ ਬਣਾਉਣਾ ਪਿਆ, ਅਤੇ ਫਿਰ ਇਸ ਨੂੰ ਇੱਕ ਨਵੇਂ ਕੋਰੂਟਾਈਨ ਵਿੱਚ ਸਮੇਟਣਾ ਪਿਆ:
Amp \ Coroutine;ਫੰਕਸ਼ਨ ਮਿਕਸ ($ ਮਾਰਗ) {$ generator = => {$ manifest = ਉਪਜ ਐਮ ਪੀ \ ਫਾਇਲ \ ਪ੍ਰਾਪਤ ਕਰੋ (". / ਜਨਤਕ / ਮਿਕਸ-ਮੈਨੀਫੈਸਟ. ਜੇਸਨ");$ manifest = json_decode ($ ਮੈਨੀਫੈਸਟ, ਸਹੀ);ਜੇ (isset ($ ਮੈਨੀਫੈਸਟ [$ ਪਾਥ])) {$ ਮੈਨੀਫੈਸਟ [$ ਪਾਥ] ਵਾਪਸ ਭੇਜੋ;}ਨਵਾਂ ਅਪਵਾਦ ਸੁੱਟੋ ("{$ ਪਾਥ} ਨਹੀਂ ਮਿਲਿਆ");};ਨਵੇਂ ਕੋਰਟਨਾਈਨ ($ ਜਨਰੇਟਰ ) ਨੂੰ ਵਾਪਸ ਕਰੋ;} ਮੈਂ ਗਰਿੱਡ ਵਿੱਚ x ਅਤੇ y ਲਈ ਹਰੇਕ ਪੈਚਮੋਡੀਲ ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ ਪਲੇਟੈਚ ਵਿਧੀ ਨੂੰ ਪਹਿਲਾਂ ਦੀ ਤਰ੍ਹਾਂ ਸ਼ੁਰੂ ਕੀਤਾ. ਫਿਰ ਮੈਂ ਇਕ ਹੋਰ ਲੂਪ ਸ਼ੁਰੂ ਕੀਤਾ, ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਹਰੇਕ ਪੈਚ ਤੇ ਵਿਧੀ ਮੈਂ ਇਹਨਾਂ ਨੂੰ ਉਸੇ ਪਗ ਵਿੱਚ ਹੀ ਕਰਵਾ ਲਿਆ ਹੁੰਦਾ, ਪਰ ਮੈਂ ਚਾਹੁੰਦਾ ਸੀ ਕਿ ਮੈਂ ਸ਼ੁਰੂਆਤ ਤਰੀਕੇ ਨਾਲ ਆਲੇ ਦੁਆਲੇ ਦੇ ਪੈਚਾਂ ਦਾ ਮੁਆਇਨਾ ਕਰ ਸਕੀਏ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮੈਨੂੰ ਇਹ ਕੰਮ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਭ ਨੂੰ ਪਹਿਲਾਂ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਪੈਚ ਇੱਕ ਦੂਜੇ ਦੇ ਆਸਪਾਸ ਆਉਂਦੇ ਸਨ.
ਮੈਂ ਫਾਰਮਾਂਮੋਡਲ ਨੂੰ ਬਦਲਣ ਲਈ ਔਨ ਗਰਰੋਥ ਬੰਦ ਕਰਨ ਲਈ ਬਦਲਿਆ. ਇਹ ਵਿਚਾਰ ਇਹ ਸੀ ਕਿ ਜੇ ਮੈਂ ਇੱਕ ਪੈਚ ਵਧਦਾ ਹਾਂ (ਬੂਟਸਟਰੈਪਿੰਗ ਪੜਾਅ ਦੇ ਦੌਰਾਨ ਵੀ) ਤਾਂ ਮੈਂ ਬੰਦ ਕਰ ਸਕਦਾ ਹਾਂ
ਜਦੋਂ ਵੀ ਪੈਚ ਵਧਦਾ ਹੈ, ਮੈਂ $ ਬਦਲਾਵ ਵੇਰੀਏਬਲ ਨੂੰ ਮੁੜ ਸੈਟ ਕਰਾਂਗਾ. ਇਸ ਨਾਲ ਯਕੀਨੀ ਬਣਾਇਆ ਗਿਆ ਕਿ ਪੈਚ ਵਧਦੇ ਰਹਿਣਗੇ ਜਦ ਤਕ ਕਿ ਫਾਰਮ ਦੇ ਪੂਰੇ ਪਾਸ ਨੇ ਕੋਈ ਤਬਦੀਲੀ ਨਹੀਂ ਕੀਤੀ. ਮੈਂ ਗੇਗ੍ਰੈਥ ਬੰਦ ਹੋਣ ਦੀ ਵੀ ਮੰਗ ਕੀਤੀ. ਮੈਂ ਗੇਗ੍ਰੈਥ ਨੂੰ ਇੱਕ ਆਮ ਬੰਦ ਹੋਣ ਦੀ ਇਜ਼ਾਜਤ ਦੇਣਾ ਚਾਹੁੰਦਾ ਸੀ, ਜਾਂ ਫਿਰ ਕੋਰੂਟਾਈਨ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ. ਇਸ ਲਈ ਮੈਨੂੰ ਬਣਾਉਣ ਪੈਚ ਇੱਕ ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਦੀ ਲੋੜ ਸੀ.
ਨੋਟ: ਸਪਸ਼ਟ ਹੈ ਕਿ, ਗੇਗ੍ਰੈਥ ਕੋਰੋਨੇਿਨਸ ਨੂੰ ਗੁੰਝਲਦਾਰ ਚੀਜ਼ਾਂ ਨੂੰ ਥੋੜਾ ਥੋੜ੍ਹਾ ਦਿੰਦੇ ਹਾਂ, ਪਰ ਮੈਂ ਇਸ ਨੂੰ ਹੋਰ ਅਸਿੰਕ ਕਿਰਿਆਵਾਂ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਸਮਝਿਆ ਜਦੋਂ ਪੈਚ ਵੱਡਾ ਹੋਇਆ. ਸ਼ਾਇਦ ਬਾਅਦ ਵਿਚ ਮੈਂ ਇਕ ਸਾਕਟ ਸੰਦੇਸ਼ ਭੇਜਣਾ ਚਾਹਾਂਗਾ, ਅਤੇ ਮੈਂ ਕੇਵਲ ਅਜਿਹਾ ਹੀ ਕਰ ਸਕਦਾ ਸਾਂ ਜੇ ਉਪਜ ਅੰਦਰ ਕੰਮ ਕੀਤਾ ਆਨਗ੍ਰੋਥ . ਮੈਂ ਕੇਵਲ ਆਨਗ੍ਰੋਥ ਪੈਦਾ ਕਰ ਸਕਦਾ ਸਾਂ ਜੇ createPatches ਇੱਕ ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਸੀ. ਅਤੇ ਕਿਉਂਕਿ createPatches ਇੱਕ async ਫੰਕਸ਼ਨ ਸੀ, ਮੈਨੂੰ ਇਸ ਨੂੰ ਅੰਦਰ GameSocket ਅੰਦਰ ਪੈਦਾ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ.
"ਹਰ ਚੀਜ਼ ਦੁਆਰਾ ਬੰਦ ਕਰਨਾ ਅਸਾਨ ਹੁੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਪਹਿਲੇ ਅਸਿੰਕ PHP ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਸਮੇਂ ਸਿੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਸਿਮਟਲ ਬਹੁਤ ਜਲਦੀ ਹਾਰਦਾ ਹੈ! "
ਕੋਡ ਦੀ ਆਖਰੀ ਬਿੱਟ ਜੋ ਮੈਂ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਲਿਖਣ ਲਈ ਲੋੜੀਂਦੀ ਸੀ ਕਿ ਇਹ ਸਭ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ GameSocket . ਤੋਂ ਐਪ / ਸਾਕਟ / ਗੇਮਸਾਕਟ ਪੂਰਵ :
ਜੇ ($ ਸਰੀਰ === "ਨਵਾਂ-ਫਾਰਮ") {$ ਪੈਚ = [];$ farm = ਨਵਾਂ ਫਾਰਮਮੋਡਲ (10, 10,ਫੰਕਸ਼ਨ (ਪੈਂਚਮੋਡਲ $ ਪੈਚ) ਵਰਤੋਂ (& $ ਪੈਚ) {ਅਰੇ_ਪਾਸ਼ ($ ਪੈਚ, ["x" => $ ਪੈਚ-> x,"y" => $ ਪੈਚ-> y,]);});ਉਪਜ $ farm-> createPatches ;$ payload = json_encode (["ਫਾਰਮ" => ["ਚੌੜਾਈ" => $ ਫਾਰਮ-> ਚੌੜਾਈ,"ਉਚਾਈ" => $ ਫਾਰਮ-> ਉੱਚਾਈ,],"ਪੈਚ" => $ ਪੈਚ,]);ਉਪਰੋਕਤ $-> ਅੰਤਮ ਪੁਆਇੰਟ-> ਭੇਜੋ ($ ਪੇਲੋਡ, $ clientId);$ this-> ਫਾਰਮ [$ clientId] = $ ਫਾਰਮ;} ਇਹ ਮੇਰੇ ਪਿਛਲੇ ਕੋਡ ਨਾਲੋਂ ਥੋੜਾ ਜਿਹਾ ਗੁੰਝਲਦਾਰ ਸੀ. ਉਸ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ ਸਾਕਟ ਪਲੋਡ ਦੇ ਪੈਚ ਦੀ ਇੱਕ ਸਨੈਪਸ਼ਾਟ ਪਾਸ ਕਰਨ ਦੀ ਲੋੜ ਸੀ.
"ਜੇ ਮੈਂ ਹਰ ਪੈਚ ਨੂੰ ਸੁੱਕੀ ਗੰਦਗੀ ਦੇ ਤੌਰ ਤੇ ਅਰੰਭ ਕਰਾਂ? ਫਿਰ ਮੈਂ ਕੁਝ ਪੈੜਾਂ ਦੀ ਜੰਗਲੀ ਬੂਟੀ ਬਣਾ ਸਕਦਾ ਹਾਂ, ਅਤੇ ਦੂਜੇ ਦਰੱਖਤ ."
ਮੈਂ ਪੈਚਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਸੈੱਟ ਕੀਤਾ. ਐਪ / ਮਾਡਲ / ਪੈਚਮੌਡਲ. ਪੂਰਵ :
ਪ੍ਰਾਈਵੇਟ $ ਸ਼ੁਰੂ = ਝੂਠ;ਪ੍ਰਾਈਵੇਟ $ ਵੈਸਟ {ਪ੍ਰਾਪਤ ਕਰੋ {ਵਾਪਸ $ ਇਸ-> ਭਿੱਜੇ?: ਗਲਤ; }};ਪ੍ਰਾਈਵੇਟ $ ਟਾਈਪ {ਪ੍ਰਾਪਤ ਕਰੋ {ਰਿਟਰਨ $ ਇਸ-> ਟਾਈਪ?: "ਮੈਲ"; }};ਜਨਤਕ ਫੰਕਸ਼ਨ ਸ਼ੁਰੂ (ਇੰਟ $ ਚੌੜਾਈ, ਇੰਚ $ ਦੀ ਉਚਾਈ,ਐਰੇ $ ਪੈਚ){ਜੇ ($ -> ਸ਼ੁਰੂ) {ਵਾਪਿਸ ਝੂਠ;}if (random_int (0, 100) <90) {ਵਾਪਿਸ ਝੂਠ;}$ this-> ਸ਼ੁਰੂ = ਸਹੀ;$ this-> ਟਾਈਪ = "ਬੂਟੀ";ਵਾਪਿਸ ਸੱਚ ਹੈ;} ਮੈਂ ਥੋੜ੍ਹੀ ਜਿਹੀ ਤਰਤੀਬ ਦੇ ਆਰਡਰ ਨੂੰ ਬਦਲਿਆ, ਜਲਦੀ ਤੋਂ ਬਾਹਰ ਨਿਕਲਿਆ ਜੇਕਰ ਪੈਚ ਪਹਿਲਾਂ ਹੀ ਸ਼ੁਰੂ ਹੋ ਗਿਆ ਹੈ. ਮੈਂ ਵਿਕਾਸ ਦੀ ਸੰਭਾਵਨਾ ਵੀ ਘਟਾ ਦਿੱਤੀ. ਜੇ ਇਹਨਾਂ ਵਿਚੋਂ ਕੋਈ ਵੀ ਸ਼ੁਰੂਆਤੀ ਨਿਕਲਣ ਦਾ ਨਹੀਂ ਹੋਇਆ ਤਾਂ ਪੈਚ ਦੀ ਕਿਸਮ ਨੂੰ ਜੰਗਲੀ ਬੂਟੀ ਤੱਕ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ.
ਫਿਰ ਮੈਂ ਇਸ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਸਾਕਟ ਸੰਦੇਸ਼ ਪਲੋਡ ਦੇ ਹਿੱਸੇ ਦੇ ਤੌਰ ਤੇ ਕਰ ਸਕਦਾ ਹਾਂ. ਤੋਂ ਐਪ / ਸਾਕਟ / ਗੇਮਸਾਕਟ ਪੂਰਵ :
$ ਫਾਰਮ = ਨਵਾਂ ਫਾਰਮਮੋਡਲ (10, 10,ਫੰਕਸ਼ਨ (ਪੈਂਚਮੋਡਲ $ ਪੈਚ) ਵਰਤੋਂ (& $ ਪੈਚ) {ਅਰੇ_ਪਾਸ਼ ($ ਪੈਚ, ["x" => $ ਪੈਚ-> x,"y" => $ ਪੈਚ-> y,"ਗਿੱਲਾ" => $ ਪੈਚ-> ਭਿੱਜ,"ਟਾਈਪ" => $ ਪੈਚ-> ਟਾਈਪ ਕਰੋ,]);}); ਫਾਰਮ ਪੇਸ਼ਕਾਰੀ
ਇਹ ਫਾਰਮ ਨੂੰ ਦਿਖਾਉਣ ਦਾ ਸਮਾਂ ਸੀ, ਜੋ ਪਹਿਲਾਂ ਵਰਕਫਲੋ ਦੁਆਰਾ ਸੈੱਟਅੱਪ ਕੀਤਾ ਸੀ. ਮੈਨੂੰ ਪਹਿਲਾਂ ਹੀ ਚੌੜਾਈ ਅਤੇ ਉਚਾਈ ਫਾਰਮ ਪ੍ਰਾਪਤ ਹੋ ਰਹੀ ਸੀ, ਇਸ ਲਈ ਮੈਂ ਹਰ ਬਲਾਕ ਨੂੰ ਸੁੱਕੀ ਗੰਦਗੀ ਬਣਾ ਸਕਦਾ ਸੀ (ਜੇਕਰ ਇਹ ਬੂਟੀ ਨਹੀਂ ਉੱਗਦਾ). ਸੰਪਤੀ / ਜੇ ਐਸ / ਐਪ ਤੋਂ jsx :
ਆਯਾਤ "ਪ੍ਰਤੀਕਿਰਿਆ"ਕਲਾਸ ਫਾਰਮ ਵਿਚ ਵਾਧਾ ਹੋਇਆ ਹੈ. ਕੰਪੋਨੈਂਟ{ਕੰਸਟਰਕਟਰ {ਸੁਪਰ ਇਹ. onMessage = ਇਹ onMessage ਬਾਈਡ (ਇਹ)ਇਹ. state = {"ਫਾਰਮ": {"ਚੌੜਾਈ": 0,"ਉਚਾਈ": 0,},"ਪੈਚ": [],};}componentWillMount {ਇਹ. ਸਾਕਟ = ਨਵਾਂ ਵੈਬਸਾਕਟ ("ws: // 127 0. 0. 1: 8080 / ਵਾਂ")ਇਹ. ਸਾਕਟ addEventListener ("ਸੰਦੇਸ਼", ਇਹ. onMessage)// DEBUGਇਹ. ਸਾਕਟ addEventListener ("ਖੋਲ੍ਹੋ", => {ਇਹ. ਸਾਕਟ ਭੇਜੋ ("ਨਵਾਂ-ਫਾਰਮ")})}onMessage (e){ਡਾਟਾ = JSON ਦਿਉ ਪਾਰਸ (ਈ. ਡੇਟਾ);ਜੇ (ਡਾਟੇ ਫਾਰਮ) {ਇਹ. setState ({"ਫਾਰਮ": ਡੇਟਾ ਫਾਰਮ})}ਜੇ (ਡਾਟਾ ਪੈਂਚ) {ਇਹ. setState ({"ਪੈਚ": ਡਾਟਾ. ਪੈਚ})}}componentWillUnmount {ਇਹ. ਸਾਕਟ removeEventListener (ਇਹ. onMessage)ਇਹ. socket = null}ਦੇਣਾ ਹੈ {ਰੋਲ ਦਿਉ [[]ਖੇਤ ਦਿਉ = ਇਹ. ਰਾਜ ਫਾਰਮਸਟੇਟ ਪੈਚ = ਇਸ ਰਾਜ ਪੈਚਲਈ (y y = 0; y <ਫਾਰਮ ਉੱਚਾਈ; y ++) {ਪੈਚ ਦਿਓ - []ਲਈ (x x = x; x <ਫਾਰਮ. ਚੌੜਾਈ; x ++) {ਕਲਾਸ ਨੇਮ = "ਪੈਚ" ਦਿਉਸਟੇਟ ਪੈਚ forEach ((ਪੈਚ)) => {ਜੇ (ਪੈਚ. x === x && ਪੈਚ. y === y) {className + = "" + ਪੈਚ. ਟਾਈਪ ਕਰੋਜੇ (ਪੈਚ.className + = "" + ਵੀਹ}}})ਪੈਚ ਧੱਕਾ( )}ਕਤਾਰਾਂ ਧੱਕਾ( {ਪੈਚ} )}ਵਾਪਸੀ ( {ਕਤਾਰ} )}}ਨਿਰਯਾਤ ਮੂਲ ਫਾਰਮ ਮੈਂ ਪਿਛਲੇ ਫਾਰਮ ਹਿੱਸੇ ਵਿਚ ਜੋ ਕੁਝ ਕਰ ਰਿਹਾ ਸੀ, ਉਸ ਦੀ ਜ਼ਿਆਦਾ ਸਮਝਾਉਣ ਲਈ ਮੈਂ ਭੁੱਲ ਗਿਆ ਸੀ. ਇੰਟਰੈਕਟਸ ਨੂੰ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਸੋਚਣ ਦਾ ਇਕ ਵੱਖਰਾ ਢੰਗ ਹੈ. ਮੈਂ ਕੰਪੋਨੈਂਟ ਵਾਈਲਮੌਂਟ ਅਤੇ ਕੰਪੋਨੈਂਟਵਿਲਯੂਮੈਂਟ ਨੂੰ ਹੋਰ ਡਾਟਾ ਪੁਆਇੰਟ (ਜਿਵੇਂ ਕਿ ਵੈਬ ਸੌਕੇਟਾਂ) ਵਿੱਚ ਜੋੜਨ ਦੇ ਢੰਗਾਂ ਦੇ ਤੌਰ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ. ਅਤੇ ਜਿਵੇਂ ਮੈਂ ਵੈਬਸੋਟਟ ਰਾਹੀਂ ਅਪਡੇਟਸ ਪ੍ਰਾਪਤ ਕਰਦਾ ਸੀ, ਮੈਂ ਕੰਪੋਨੈਂਟ ਦੇ ਰਾਜ ਨੂੰ ਅਪਡੇਟ ਕਰ ਸਕਦਾ ਸੀ, ਜਦੋਂ ਤੱਕ ਕਿ ਮੈਂ ਕੰਸਟ੍ਰਕਟਰ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਸਟੇਟ ਸੈਟ ਕਰ ਚੁੱਕਾ ਸੀ.
ਇਸਦਾ ਨਤੀਜਾ ਇੱਕ ਬਦਸੂਰਤ ਹੋ ਗਿਆ, ਭਾਵ ਕਿ ਵੰਡਾਂ ਦੇ ਕਾਰਜਸ਼ੀਲ ਸਮੂਹ. ਮੈਂ ਕੁਝ ਸਟਾਈਲ ਸ਼ਾਮਲ ਕਰਨ ਬਾਰੇ ਸੈਟ ਕੀਤਾ. ਐਪ / ਐਕਸ਼ਨ / ਹੋਮ ਐਕਸ਼ਨ. ਪੂਰਵ :
ਨਾਂ-ਸਪੇਸ ਐਪ / ਐਕਸ਼ਨ;Aerys \ Request ਦੀ ਵਰਤੋਂ ਕਰੋ;Aerys \ Response ਦੀ ਵਰਤੋਂ ਕਰੋ;ਕਲਾਸ{ਜਨਤਕ ਫੰਕਸ਼ਨ __ ਇਨਕੌਕ (ਬੇਨਤੀ $ ਬੇਨਤੀ,ਜਵਾਬ $ ਪ੍ਰਤੀ ਜਵਾਬ{$ js = ਉਪਜ ਮਿਕਸ ("/ ਜੇ ਐਸ / ਐਪੀ. ਜੇ ਐਸ");$ css = ਉਪਜ ਮਿਕਸ ("/ CSS / ਐਪ. ਸੀਐਸ");$ response-> ਅੰਤ ("