Back to Question Center
0

રીકક્ટ, પીએચપી, અને વેબસૉકટ્સ સાથે પ્રોસેક્યુરલીલી જનરેટેડ ગેમ ટેરેઇન            રીકક્ટ, પીએચપી, અને વેબસૉક સાથે પ્રોસેસરીલીલી જનરેટ ગેમ ટેરેઇનસંબંધિત વિષયો: ફ્રેમવર્ક્સ APISecurityPatterns અને & પ્રેક્ટિસ ડીબગિંગ અને & મીમલ્ટ

1 answers:
રીકક્ટ, પીએચપી, અને વેબસૉક સાથે પ્રોસેસરીલીલી જનરેટ ગેમ ટેરેઇન

PHP અને ReactJS સાથે રમત વિકાસ

  • પ્રતિક્રિયા અને PHP સાથે રમત વિકાસ: તે કેવી રીતે સુસંગત છે?
  • રીકક્ટ, પીએચપી, અને વેબસૉક સાથે પ્રોસેસરીલીલી જનરેટ ગેમ ટેરેઇન

પ્રતિક્રિયા આપવાની ઉચ્ચ-ગુણવત્તા, ઊંડાણપૂર્વક રજૂઆત માટે, તમે કેનેડિયન ફુલ-સ્ટૅક ડેવલપર વેસ બોસની પહેલા જઇ શકતા નથી. અહીં તેમના અભ્યાસક્રમનો પ્રયાસ કરો, અને કોડ SITEPOINT મેળવવા માટે 25% બંધ અને સાઇટપૉઇન્ટને સપોર્ટ કરવામાં મદદ માટે ઉપયોગ કરો.

છેલ્લું સમય, મેં તમને એક રમત બનાવવા માગતો હતો તે વાર્તા તમને કહેવાનું શરૂ કર્યું. મેં વર્ણવ્યું છે કે હું કેવી રીતે એંસીન્કેક PHP સર્વર, લારેલે મિકસ બિલ્ડ ચેઇન, રીએક્ટ ફ્રન્ટ એન્ડ, અને વેબસોકેટ્સને એકસાથે જોડવા માટે સુયોજિત કરું છું. હમણાં, ચાલો હું તમને જણાવું કે શું થયું જ્યારે રીએક્ટ, PHP, અને વેબસોકટ્સ આ મિશ્રણ સાથે ગેમ મિકેનિક બનાવવાનું શરૂ કર્યું ત્યારે શું થયું .


આ ભાગનો કોડ ગિથબ પર મળી શકે છે - analogica digital diferencia entre. com / assertchris-tutorials / sitepoint-making-games / tree / part-2 મેં તેને PHP 7. 1 સાથે ચકાસાયેલું છે, Google Chrome ના તાજેતરનાં સંસ્કરણમાં


રીકક્ટ, પીએચપી, અને વેબસૉકટ્સ સાથે પ્રોસેક્યુરલીલી જનરેટેડ ગેમ ટેરેઇનરીકક્ટ, પીએચપી, અને વેબસૉક સાથે પ્રોસેસરીલીલી જનરેટ ગેમ ટેરેઇનસંબંધિત વિષયો:
ફ્રેમવર્ક્સ APISecurityPatterns અને PracticesDebugging અને Semalt

ખેતર બનાવવું

"સેમિંટ પ્રારંભ સરળ. અમારી પાસે 10 થી 10 ટાઇલ્સની ગ્રીડ છે, રેન્ડમલી જનરેટેડ સામગ્રીથી ભરેલી છે. "

મેં ખેતરને ખેતર અને દરેક ટાઇલ પેચ તરીકે પ્રતિનિધિત્વ કરવાનો નિર્ણય કર્યો. પ્રતિ એપ્લિકેશન / મોડેલ / ફાર્મ મૉડલ પૂર્વ :

  નામસ્થળ એપ્લિકેશન \ મોડેલ;વર્ગ ફાર્મ{ખાનગી $ પહોળાઈ{{પરત $ આ-> પહોળાઈ મેળવો; }}ખાનગી $ ઊંચાઈ{{પરત $ આ-> ઉંચાઈ મેળવો; }}જાહેર કાર્ય __ રચના (પૂર્ણાંક $ પહોળાઈ = 10,પૂર્ણાંક $ ઉંચાઈ = 10){$ this-> પહોળાઈ = $ પહોળાઈ;$ this-> ઊંચાઇ = $ ઊંચાઈ;}}   

મેં વિચાર્યું કે જાહેર પ્રવેશ મેળવનારા લોકો સાથે ખાનગી મિલકતો જાહેર કરીને ક્લાસ એક્સેસર્સ મેક્રોને અજમાવવા માટે એક મજા સમય હશે. આ માટે મને પ્રી / ક્લાસ-એક્સસેસર્સ ( દ્વારા કંપોઝરની જરૂર છે ).

પછી મેં વિનંતિ પર નવા ખેતરો બનાવવાની મંજૂરી આપવા માટે સોકેટ કોડ બદલ્યો. એપ્લિકેશન / સોકેટ / ગેમસ્કેટથી પૂર્વ :

  નેમસ્પેસ એપ્લિકેશન \ સૉકેટ;Aerys \ Request નો ઉપયોગ કરો;Aerys \ Response નો ઉપયોગ કરો;Aerys \ Websocket નો ઉપયોગ કરો;Aerys \ Websocket \ Endpoint નો ઉપયોગ કરો;Aerys \ Websocket સંદેશનો ઉપયોગ કરો;App \ Model \ FarmModel નો ઉપયોગ કરો;ક્લાસ ગેમસેટ ઓજમેન્ટ્સ Websocket{ખાનગી $ ખેતરો = [];ડેટા પર જાહેર કાર્ય (ઇન્ટ $ clientId,સંદેશ સંદેશ મોકલો){$ body = $ સંદેશ પ્રાપ્ત કરો;જો ($ શરીર === "નવું ફાર્મ") {$ farm = નવું ફાર્મમોડેલ   ;$ પેલોડ = json_encode (["ફાર્મ" => ["પહોળાઈ" => $ ફાર્મ-> પહોળાઈ,"ઊંચાઈ" => $ ફાર્મ-> ઊંચાઈ,],]);ઉપજ $ આ-> એન્ડપોઇન્ટ-> મોકલો ($ પેલોડ, $ clientId);$ this-> ફાર્મ [$ clientId] = $ farm;}}જાહેર કાર્ય પરક્લોઝ (ઇન્ટ $ ક્લાયન્ટઆઇડી,ઈન્ $ કોડ, શબ્દમાળા $ કારણ){સેટ કરો ($ -> કનેક્શન્સ [$ clientId]);સેટ કરો ($ -> ફાર્મ [$ clientId]);}// .}   

મેં જોયું કે આ રમતસ્કેટ મારી પાસે એક અગાઉના હતી - સિવાય કે, એક ઇકો પ્રસારિત કરવાને બદલે, હું નવા ફાર્મ માટે ચકાસણી કરતો હતો અને માત્ર એક સંદેશ મોકલ્યો પૂછવામાં આવ્યું હતું કે ક્લાઈન્ટ માટે.

"કદાચ તે રીએક્ટ કોડ સાથે ઓછા સામાન્ય મેળવવા માટે સારો સમય છે. હું ઘટકનું નામ બદલીશ. જેએસએક્સ થી ફાર્મ જેએસએક્સ "

એસેટ્સ / જેએસ / ફાર્મથી જેએસએક્સ :

  આયાત પ્રતિક્રિયા "પ્રતિક્રિયા"વર્ગ ફાર્મ વિસ્તરે પ્રતિક્રિયા. સોકેટ = નવી વેબસોકેટ ("ws: // 127 0. 0. 1: 8080 / ws")આ. સોકેટ addEventListener ("સંદેશ", આ. onMessage)// DEBUGઆ. સોકેટ addEventListener ("ખોલો",    => {આ. સોકેટ મોકલો ("નવું ફાર્મ")})}}નિકાસ મૂળભૂત ફાર્મ   

હકીકતમાં, મેં જે વસ્તુ બદલી નાખી તે હેલ્લો વર્લ્ડ ને બદલે નવી ખેત મોકલી હતી. બાકીનું બધું જ હતું. મને એપ્લિકેશન બદલવાની હતી જોકે જેએસએક્સ કોડ સંપત્તિ / જેએસ / એપ્લિકેશનથી જેએસએક્સ :

  આયાત પ્રતિક્રિયા "પ્રતિક્રિયા"આયાત પ્રતિક્રિયા "પ્રતિક્રિયા-ડોમ" માંથી"ફાર્મ / ફાર્મ" માંથી આયાત કરોપ્રતિક્રિયા રેન્ડર કરો (<ફાર્મ />,દસ્તાવેજ ક્વેરી સિલેક્ટર (". app"))   

તે જ્યાંથી મને બનવાની જરૂર હતી ત્યાંથી દૂર હતી, પરંતુ આ ફેરફારોનો ઉપયોગ કરીને હું વર્ગના એક્સેસર્સને ક્રિયામાં જોઈ શકતો હતો, સાથે સાથે ભાવિ વેબસેટ ક્રિયાપ્રતિક્રિયાઓ માટે એક વિનંતી / પ્રતિસાદ પેટર્ન પ્રોટોટાઇપ કરી શકતો હતો. મેં કન્સોલ ખોલ્યું અને જોયું {"ફાર્મ": {"width": 10, "height": 10}} .

"મહાન!"

પછી મેં દરેક ટાઇલનું પ્રતિનિધિત્વ કરવા માટે એક પેચ વર્ગ બનાવ્યું. મને લાગ્યું કે આ રમતનું તર્ક ઘણું થાય છે. પ્રતિ એપ્લિકેશન / મોડેલ / પેચ મૉડલ પૂર્વ :

  નામસ્થળ એપ્લિકેશન \ મોડેલ;વર્ગ પેચમોડેલ{ખાનગી $ x{{પરત $ આ-> એક્સ; }}ખાનગી $ y{વિચાર {return $ this-> y; }}સાર્વજનિક કાર્ય __ રચના (પૂર્ણાંક $ x, પૂર્ણાંક $ y){$ this-> x = $ x;$ this-> y = $ y;}}   

મને ઘણા પેચો બનાવવાની જરૂર છે કારણ કે નવા ફાર્મ માં જગ્યાઓ છે. હું ફાર્મમોડલ બાંધકામના ભાગ રૂપે આ કરી શકું છું. પ્રતિ એપ્લિકેશન / મોડેલ / ફાર્મ મૉડલ પૂર્વ :

  નામસ્થળ એપ્લિકેશન \ મોડેલ;વર્ગ ફાર્મમોડેલ{ખાનગી $ પહોળાઈ{{પરત $ આ-> પહોળાઈ મેળવો; }}ખાનગી $ ઊંચાઈ{{પરત $ આ-> ઉંચાઈ મેળવો; }}ખાનગી $ પેચો{{પરત $ આ-> પેચો મેળવો; }}સાર્વજનિક કાર્ય __કોન્સ્ટ્રક્ટ ($ પહોળાઈ = 10, $ ઊંચાઈ = 10){$ this-> પહોળાઈ = $ પહોળાઈ;$ this-> ઊંચાઇ = $ ઊંચાઈ;$ this-> બનાવોપેટ્સ   ;}ખાનગી કાર્ય createPatches   {માટે ($ i = 0; $ i <$ આ-> પહોળાઈ; $ i ++) {$ this-> પેચો [$ i] = [];માટે ($ j = 0; $ j <$ this-> ઊંચાઈ; $ j ++) {$ this-> પેચો [$ i] [$ j] =નવું પેચ મોડલ ($ i, $ j);}}}}   

દરેક કોષ માટે, મેં નવું પેચ મોડલ ઑબ્જેક્ટ બનાવ્યું છે. આ શરૂઆતથી ખૂબ સરળ હતા, પરંતુ તેમને રેન્ડમનેસના એક ઘટકની જરૂર હતી - વૃક્ષો, નીંદણ, ફૂલો વધવા માટેનું એક માર્ગ .ઓછામાં ઓછું શરૂ થવું. પ્રતિ એપ્લિકેશન / મોડેલ / પેચ મૉડલ પૂર્વ :

  જાહેર કાર્ય શરૂ (પૂર્ણાંક $ પહોળાઈ, પૂર્ણાંક $ ઊંચાઈ,એરે $ પેચો){જો (! $ this-> શરૂ કર્યું && random_int (0, 10)> 7) {$ this-> શરૂ = સાચું;સાચું;}ખોટા વળતર;}   

મેં વિચાર્યું કે હું રેન્ડમ રીતે પેચ વધારીને શરૂ કરીશ. આ પેચની બાહ્ય સ્થિતિને બદલી નાખી, પરંતુ તે મને ખેતર દ્વારા કેવી રીતે શરૂ કરવામાં આવ્યા તે ચકાસવાની એક રીત આપી હતી. પ્રતિ એપ્લિકેશન / મોડેલ / ફાર્મ મૉડલ. શરુ કરવા માટે, મે (મેક્રો) નો ઉપયોગ કરીને મેં એએસસિન્ક ફંક્શન કીવર્ડ રજૂ કર્યા. તમે જોઈ શકો છો, એએમપી ઉપજાવી કાઢે છે શબ્દપ્રયોગો ઉકેલવાથી. બિંદુ પર વધુ: જ્યારે એએમપી ઉપજ કીવર્ડને જુએ છે, ત્યારે તે ધારે છે કે શું થવાનું છે તે કોર્આટિન (મોટા ભાગના કિસ્સાઓમાં) છે.

હું બનાવતા પૅટ્ચ ને સામાન્ય કાર્ય કરવા માટે બનાવી શક્યો હોત, અને તેમાંથી માત્ર એક કોર્ટેઇનિન પાછો મેળવ્યો હોત, પરંતુ આ એક એવો સામાન્ય ભાગ હતો કે મેં તેના માટે એક ખાસ મેક્રો બનાવી દીધો. તે જ સમયે, હું અગાઉના ભાગમાં મેં બનાવેલ કોડને બદલી શકે છે. મદદગારો તરફથી પૂર્વ :

  async ફંક્શન મિક્સ ($ પાથ) {$ મેનિફેસ્ટ = ઉપજ એએમપી \ ફાઈલ \ વિચાર ("/ જાહેર / મિક્સ-મેનિફેસ્ટ. જેએસએન");$ manifest = json_decode ($ મેનિફેસ્ટ, સાચી);if (isset ($ મેનિફેસ્ટ [$ પાથ])) {$ મેનિફેસ્ટ [$ પાથ] પરત;}નવા અપવાદ ફેંકવું ("{$ path} મળ્યું નથી");}   

પહેલાં, મને જનરેટર બનાવવું પડ્યું, અને પછી તેને નવી કોરોટિન માં લપેટી:

  એમ્પ / કોરઆઉટિનનો ઉપયોગ કરો;કાર્ય મિશ્રણ ($ પાથ) {$ જનરેટર =    => {$ મેનિફેસ્ટ = ઉપજ એએમપી \ ફાઈલ \ વિચાર ("/ જાહેર / મિક્સ-મેનિફેસ્ટ. જેએસએન");$ manifest = json_decode ($ મેનિફેસ્ટ, સાચી);if (isset ($ મેનિફેસ્ટ [$ પાથ])) {$ મેનિફેસ્ટ [$ પાથ] પરત;}નવા અપવાદ ફેંકવું ("{$ path} મળ્યું નથી");};નવી કોર્નેટીન પરત ($ જનરેટર   );}   

મેં શરૂઆતમાં પૅટિસ પદ્ધતિની શરૂઆત કરી, દરેક x અને y ગ્રીડમાં નવી પેચમોડેલ ઓબ્જેક્ટો બનાવવા. પછી મેં બીજા લૂપ શરૂ કર્યું, શરૂઆતમાં પદ્ધતિને દરેક પેચ પર કૉલ કરો. હું આ જ પગલામાં આ કર્યું હોત, પણ હું ઇચ્છતો હતો કે મારી શરૂઆત પદ્ધતિ જે આસપાસના પેચોનું નિરીક્ષણ કરી શકે. તેનો અર્થ એ કે હું કામ કરતો પહેલા દરેક પેઢીઓ એકબીજાની આસપાસ હોઉં તે પહેલાં તેમને બધાને બનાવવું પડશે.

મેં ફાર્મમોડલ ને ઓગસ્ટ બંધ કરવાની મંજૂરી આપી. વિચાર એ હતો કે જો કોઈ પેચ વધે તો પણ તે બંધ થઈ શકે (પણ બુટસ્ટ્રેપીંગ તબક્કા દરમિયાન)

દર વખતે પેચ વધ્યો, મેં $ ફેરફારો ચલ ફરીથી સેટ કર્યા. આનાથી ખાતરી થઈ કે પેચો સંપૂર્ણ ખેડૂતો સુધી વધશે જ્યાં સુધી ખેતરના સમગ્ર પાસથી કોઈ ફેરફાર થતો ન હતો. મેં પણ ઑગર્ઘ સમાપનની વિનંતી કરી. હું ઑગર્ોર્થ ને સામાન્ય બંધ કરવા અથવા કોરોટિન પાછા ફરવા માગે છે. એટલા માટે મને બનાવવા માટે જરૂરી છે બનાવોપેટ્સ એએસસિન્ક કાર્ય.

નોંધ: માન્યતાપૂર્વક, onGrowth coroutines થોડી જટીલ વસ્તુઓ પરવાનગી આપે છે, પરંતુ જ્યારે પેચ વધારો થયો હતો જ્યારે હું અન્ય async ક્રિયાઓ માટે પરવાનગી આપવા માટે તે આવશ્યક તરીકે જોયું. કદાચ પછીથી હું સોકેટ સંદેશ મોકલવા માગું છું, અને હું તે કરી શકતો હતો કે જો ઉપજ અંદર કામ કર્યું ઑનગ્રોથ . હું ફક્ત ઑનગ્રોથ પેદા કરી શકું છું જો બનાવોપેટ્સ એક એએસસિંક કાર્ય હતું. અને createPatches એક async કાર્ય હતું, કારણ કે, હું GameSocket અંદર તેને પેદા કરવાની જરૂર છે.

"તમામ વસ્તુઓ દ્વારા બંધ થવું સહેલું છે કે જેનું પ્રથમ અન્સિંક PHP એપ્લિકેશન બનાવતી વખતે શીખવાની જરૂર છે મીમમલ્ટ ખૂબ જલ્દી છોડી દે છે! "

કોડની છેલ્લી બીટ હું તપાસવા માટે લખી રહ્યો હતો કે આ બધું કામ કરતું હતું GameSocket . એપ્લિકેશન / સોકેટ / ગેમસ્કેટથી પૂર્વ :

  જો ($ શરીર === "નવા ફાર્મ") {$ પેચો = [];$ farm = નવું ફાર્મમોડેલ (10, 10,કાર્ય (પેચમોડલ $ પેચ) નો ઉપયોગ કરો (& $ પેચો) {એરે_પશ ($ પેચો, ["x" => $ પેચ-> એક્સ,"y" => $ પેચ-> વાય,]);});ઉપજ $ ફાર્મ-> બનાવોપેટ્સ   ;$ પેલોડ = json_encode (["ફાર્મ" => ["પહોળાઈ" => $ ફાર્મ-> પહોળાઈ,"ઊંચાઈ" => $ ફાર્મ-> ઊંચાઈ,],"પેચો" => $ પેચો,]);ઉપજ $ આ-> એન્ડપોઇન્ટ-> મોકલો ($ પેલોડ, $ clientId);$ this-> ફાર્મ [$ clientId] = $ farm;}   

આ પહેલાંના કોડની તુલનામાં આ થોડું વધુ જટિલ હતું. તે પછી, મને સોકેટ પેલોડમાં પેચોની સ્નેપશોટ પસાર કરવાની જરૂર હતી.

રીકક્ટ, પીએચપી, અને વેબસૉકટ્સ સાથે પ્રોસેક્યુરલીલી જનરેટેડ ગેમ ટેરેઇનરીકક્ટ, પીએચપી, અને વેબસૉક સાથે પ્રોસેસરીલીલી જનરેટ ગેમ ટેરેઇનસંબંધિત વિષયો:
ફ્રેમવર્ક્સ APISecurityPatterns અને PracticesDebugging અને Semalt

"જો હું દરેક પેચને શુષ્ક ગંદકી તરીકે શરૂ કરું તો શું? પછી હું અમુક પેચોમાં નીંદણ કરી શકું છું, અને અન્ય વૃક્ષો હોય છે ."

હું પેચો કસ્ટમાઇઝ વિશે સેટ પ્રતિ એપ્લિકેશન / મોડેલ / પેચ મૉડલ પૂર્વ :

  ખાનગી $ પ્રારંભ = ખોટા;ખાનગી $ ભીનું {{પરત $ આ-> ભીનું: ખોટું; }};ખાનગી $ પ્રકાર {{return $ this-> ટાઈપ કરો: "ધૂળ"; }};જાહેર કાર્ય શરૂ (પૂર્ણાંક $ પહોળાઈ, પૂર્ણાંક $ ઊંચાઈ,એરે $ પેચો){જો ($ -> શરૂ થાય છે) {ખોટા વળતર;}if (random_int (0, 100) <90) {ખોટા વળતર;}$ this-> શરૂ = સાચું;$ this-> પ્રકાર = "ઘાસ";સાચું;}   

મેં થોડો આસપાસ તર્કનું ક્રમ બદલી દીધું, જો પેચ પહેલેથી જ શરૂ કરવામાં આવ્યું હોય તો વહેલા બહાર નીકળી મેં વૃદ્ધિની તક પણ ઘટાડી. જો શરૂઆતમાં આમાંથી કોઇ ન થઈ જાય તો, પેચનો પ્રકાર ઘાસને બદલવામાં આવશે.

હું પછી સોકેટ સંદેશ પેલોડના ભાગ રૂપે આ પ્રકારનો ઉપયોગ કરી શકું છું. એપ્લિકેશન / સોકેટ / ગેમસ્કેટથી પૂર્વ :

  $ ફાર્મ = નવું ફાર્મમોડેલ (10, 10,કાર્ય (પેચમોડલ $ પેચ) નો ઉપયોગ કરો (& $ પેચો) {એરે_પશ ($ પેચો, ["x" => $ પેચ-> એક્સ,"y" => $ પેચ-> વાય,"ભીનું" => $ પેચ-> ભીનું,"પ્રકાર" => $ પેચ-> પ્રકાર,]);});   

ફાર્મ રેન્ડરિંગ

આ ખેતરને બતાવવાનો સમય હતો, રીકક્ટ વર્કફ્લોનો ઉપયોગ કરીને મેં અગાઉ સેટઅપ કર્યું હતું. હું પહેલેથી જ પહોળાઈ અને ઉંચાઈ ખેતરમાં મેળવી રહ્યો હતો, તેથી હું દરેક બ્લોક સૂકી ગંદકી (જ્યાં સુધી તે ઘાસના વિકાસમાં ન હોત તો) કરી શકતો હતો. સંપત્તિ / જેએસ / એપ્લિકેશનથી જેએસએક્સ :

  આયાત પ્રતિક્રિયા "પ્રતિક્રિયા"વર્ગ ફાર્મ વિસ્તરે પ્રતિક્રિયા ઘટક{કન્સ્ટ્રક્ટર   {સુપર   આ. onMessage = આ. onMessage બાંધવું (આ)આ. રાજ્ય = {"ફાર્મ": {"પહોળાઈ": 0,"ઊંચાઈ": 0,},"પેચો": [],};}ઘટકવોલમાઉન્ટ   {આ. સોકેટ = નવી વેબસોકેટ ("ws: // 127 0. 0. 1: 8080 / ws")આ. સોકેટ addEventListener ("સંદેશ", આ. onMessage)// DEBUGઆ. સોકેટ addEventListener ("ખોલો",    => {આ. સોકેટ મોકલો ("નવું ફાર્મ")})}onMessage (e){માહિતી = JSON દો પર્સ (ઈ. ડેટા);જો (ડેટા ફાર્મ) {આ. સેટસ્ટેટ ({"ફાર્મ": ડેટા. ફાર્મ})}જો (માહિતી પેચો) {આ. સેટસ્ટેટ ({"પેચો": ડેટા પેચ્સ})}}ઘટકવોલ્યુનમાઉન્ટ   {આ. સોકેટ removeEventListener (આ. onMessage)આ. સોકેટ = નલ}રેન્ડર    {પંક્તિઓ દો [=]ખેતર = આ દો રાજ્ય ફાર્મરાજ્યપેટ્સ દો = આ રાજ્ય પેચોમાટે (દો વાય = 0; વાય <ફાર્મ. ઊંચાઈ; y ++) {દો પેચો = []માટે (દો x = 0; x  {જો (પેચ x === x અને& પેચ વાય === વાય) {className + = "" + + પેચ પ્રકારજો (પેચ. ભીનું) {className + = "" + ભીનું}}})પેચો દબાણ(
)}પંક્તિઓ દબાણ(
{પેચો}
)}વળતર (
{પંક્તિઓ}
)}}નિકાસ મૂળભૂત ફાર્મ

હું અગાઉના ફાર્મ ઘટક જે કરી રહ્યો હતો તેમાંથી મોટાભાગનું સમજાવવા માટે ભૂલી ગયા હતા. પ્રતિક્રિયા ઘટકો ઈન્ટરફેસો કેવી રીતે બનાવવો તે વિશે વિચારવાનો એક અલગ રીત હતી. હું અન્ય ડેટા પોઇન્ટ્સ (જેમ કે વેબસૉકટ્સ) માં હૂક કરવાના માર્ગો કોમ્પોનન્ટ વેલમાઉન્ટ અને કમ્પોનન્ટ વેલયુનમાઉન્ટ જેવી પદ્ધતિઓનો ઉપયોગ કરી શકું છું. અને મેં વેબસેટ દ્વારા અપડેટ્સ પ્રાપ્ત કર્યા પ્રમાણે, હું ઘટકની સ્થિતિને અપડેટ કરી શકું છું, જ્યાં સુધી મેં કન્સ્ટ્રક્ટરમાં પ્રારંભિક સ્ટેટ સેટ કર્યું હતું.

આનું પરિણામ બિહામણું હતું, તેમ છતાં વિભાજનનું કાર્યલક્ષી સમૂહ. હું કેટલાક સ્ટાઇલ ઉમેરવા વિશે સેટ કર્યું છે. પ્રતિ એપ્લિકેશન / ઍક્શન / હોમએક્શન પૂર્વ :

  નામસ્થળ એપ્લિકેશન \ ક્રિયા;Aerys \ Request નો ઉપયોગ કરો;Aerys \ Response નો ઉપયોગ કરો;વર્ગ હોમએક્શન{જાહેર કાર્ય __invoke (વિનંતી $ વિનંતી,પ્રતિભાવ $ પ્રતિભાવ){$ js = ઉપજ મિશ્રણ ("/ જેએસ / એપ્લિકેશન. જેએસ");$ CSS = ઉપજ મિશ્રણ ("/ CSS / એપ્લિકેશન CSS");$ પ્રતિભાવ-> અંત ("
March 1, 2018