Back to Question Center
0

రియాక్ట్, PHP మరియు WebSockets తో విధానంగా రూపొందించబడిన గేమ్ టెర్రైన్            రియాక్ట్, PHP మరియు WebSockets తో విధానపరంగా సృష్టించిన గేమ్ టెర్రైన్ FrameworksAPIsSecurityPatterns & అభ్యాసాలు & Semalt

1 answers:
రియాక్ట్, PHP మరియు WebSockets తో విధానపరంగా రూపొందించిన గేమ్ టెర్రైన్

PHP మరియు ReactJS తో గేమ్ డెవలప్మెంట్

  • రియాక్ట్ మరియు PHP తో గేమ్ డెవలప్మెంట్: వారు ఎలా అనుకూలమైన?
  • రియాక్ట్, PHP మరియు WebSockets
  • తో విధానపరంగా సృష్టించిన గేమ్ టెర్రైన్

అధిక-నాణ్యతతో, ప్రతిబింబించే లోతైన పరిచయం కోసం, మీరు గతంలో కెనడియన్ పూర్తి-స్టాక్ డెవలపర్ వెస్ బోస్కి వెళ్ళలేరు. ఇక్కడ తన కోర్సును ప్రయత్నించండి, మరియు SITEPOINT ను 25% ఆఫ్ పొందడానికి మరియు సైటుకు మద్దతునివ్వడానికి సహాయం చేయండి.

చివరిసారి, నేను ఒక ఆట చేయడానికి ఎలా కావాలో అనే కథ మీకు చెప్పడం మొదలుపెట్టాను. నేను async PHP సర్వర్ ఏర్పాటు ఎలా వివరించారు, Laravel మిక్స్ నిర్మించడానికి గొలుసు, రియాక్ట్ ఫ్రంట్ ఎండ్, మరియు కలిసి WebSockets అన్ని ఈ కనెక్ట్. ఇప్పుడు, రియాక్ట్, PHP మరియు వెబ్సొకేట్స్ యొక్క మిక్స్తో ఆట మెకానిక్స్ను నిర్మించటం మొదలుపెట్టినప్పుడు ఏమి జరిగిందనే దాని గురించి నేను మీకు చెప్పనివ్వండి .


ఈ భాగానికి సంబంధించిన కోడ్ను జితుబ్ వద్ద చూడవచ్చు - wgs casinos. com / assertchris ట్యుటోరియల్స్ / sitepoint-మేకింగ్ గేమ్స్ / చెట్టు / పార్ట్ 2. నేను PHP 7 తో గూగుల్ క్రోమ్ యొక్క తాజా వెర్షన్లో 1 తో పరీక్షించాను.


రియాక్ట్, PHP మరియు WebSockets తో విధానంగా రూపొందించబడిన గేమ్ టెర్రైన్రియాక్ట్, PHP మరియు WebSockets తో విధానపరంగా సృష్టించిన గేమ్ టెర్రైన్
FrameworksAPIsSecurityPatterns & PracticesDebugging & Semalt

మేకింగ్ ఫార్మ్

"సెమాల్ట్ ప్రారంభం సాధారణ. యాదృచ్ఛికంగా సృష్టించిన విషయాన్ని నిండి పలకలు 10 ద్వారా 10 రూపాయలు కలిగి ఉన్నాయి. "

నేను ఫార్మ్ , మరియు ఒక ప్యాచ్ ప్రతి టైల్ వంటి వ్యవసాయ ప్రాతినిధ్యం నిర్ణయించుకుంది. నుండి అనువర్తనం / మోడల్ / ఫార్మా నమూనా. ముందు :

  నేమ్పేస్ యాప్ \ మోడల్;తరగతి ఫార్మ్{ప్రైవేట్ $ వెడల్పు{{తిరిగి $ ఈ-> వెడల్పు పొందండి; }}ప్రైవేట్ $ ఎత్తు{{return $ this-> ఎత్తు తిరిగి పొందండి; }}పబ్లిక్ ఫంక్షన్ __construct (int $ width = 10,Int $ ఎత్తు = 10){$ this-> width = $ width;$ this-> ఎత్తు = $ ఎత్తు;}}   

పబ్లిక్ బెట్టర్స్తో ప్రైవేట్ లక్షణాలను ప్రకటించడం ద్వారా తరగతి యాక్సెసర్స్ మాక్రోని ప్రయత్నించేందుకు ఇది సరదాగా ఉంటుందని నేను భావించాను. దీనికోసం నేను ముందు / క్లాస్-యాక్సెసర్స్ స్వరకర్త అవసరం ను ఇన్స్టాల్ చేయాలి.

నేను అభ్యర్థనపై కొత్త పొలాలు రూపొందించడానికి అనుమతించేందుకు సాకెట్ కోడ్ను మార్చాను. నుండి అనువర్తనం / సాకెట్ / గేమ్సాకెట్. ముందు :

  నేమ్ స్పేస్ App సాకెట్;Aerys అభ్యర్థనను ఉపయోగించండి;Aerys \ రెస్పాన్స్ ఉపయోగించండి;Aerys \ Websocket;Aerys \ Websocket \ Endpoint;Aerys \ Websocket \ సందేశం;App \ Model \ FarmModel ను ఉపయోగించండి;తరగతి GameSocket అమలుచేస్తుంది{ప్రైవేట్ $ పొలాలు = [];పబ్లిక్ ఫంక్షన్ onData (Int $ clientId,సందేశ సందేశం){$ body = $ సందేశాన్ని ఇస్తుంది;($ body === "కొత్త వ్యవసాయ") {$ పొలం = కొత్త ఫార్మ్ మోడల్   ;$ payload = json_encode (["farm" => ["width" => $ farm-> వెడల్పు,"height" => $ farm-> ఎత్తు,],]);$ this-> endpoint-> పంపించు$ payload, $ clientId);$ ఈ-> పొలాలు [$ clientId] = $ వ్యవసాయ;}}పబ్లిక్ ఫంక్షన్ onClose (Int $ clientId,Int $ కోడ్, స్ట్రింగ్ $ కారణం){సెట్ చేయకుండా ($ ఈ-> కనెక్షన్లు [$ క్లయింట్]);సెట్ చేయకుండా ($ ఈ-> పొలాలు [$ క్లయింట్]);}// .}   

నేను ఇంతకుముందు ఉన్న గేమ్సకెట్ ను పోలి ఉండేవాటిని గమనించాను - ఒక ప్రతిధ్వనిని ప్రసరించే బదులు, నేను నూతన-వ్యవసాయ కోసం తనిఖీ చేస్తూ, అడిగిన క్లయింట్కు.

"బహుశా రియాక్ట్ కోడ్ తో తక్కువ సాధారణ పొందడానికి ఒక మంచి సమయం. నేను భాగం పేరు మార్చబోతున్నాను. jsx నుండి వ్యవసాయ. jsx . "

నుండి ఆస్తులు / JS / వ్యవసాయ. jsx :

  దిగుమతి "ప్రతిచర్య" నుండిక్లాస్ ఫామ్ రియాక్ట్ వర్తిస్తుంది. సాకెట్ = కొత్త వెబ్కెట్ ("ws: // 127 0. 0. 1: 8080 / ws")ఈ. సాకెట్. addEventListener ("సందేశం", ఇది. onMessage)// DEBUGఈ. సాకెట్. addEventListener ("open",    => {ఈ. సాకెట్. ( "కొత్త వ్యవసాయేతర") పంపడానికి})}}డిఫాల్ట్ ఫార్మ్ ఎగుమతి   

నిజానికి, నేను మార్చిన ఏకైక విషయం హలో వరల్డ్ కు బదులుగా కొత్త వ్యవసాయ పంపింది. మిగతావన్నీ ఒకేలా ఉన్నాయి. నేను అనువర్తనం మార్చవలసి ఉంటుంది. jsx కోడ్ అయితే. నుండి ఆస్తులు / JS / అనువర్తనం. jsx :

  దిగుమతి "ప్రతిచర్య" నుండి"రియాక్ట్-డోమ్" నుండి ReactDOM ను దిగుమతి చేయండిదిగుమతి ఫార్మ్ నుండి ". / వ్యవసాయ"ReactDOM. రెండర్ (<ఫార్మ్ />,పత్రం. querySelector ("అనువర్తనం"))   

నేను ఎక్కడున్నానో అది చాలా దూరంగా ఉండేది, కానీ ఈ మార్పులను ఉపయోగించడం వలన నేను కార్యక్రమంలో తరగతి యాక్సెసర్స్ను చూడగలుగుతున్నాను, భవిష్యత్ వెబ్సాకెట్ ఇంటరాక్షన్స్ కోసం అభ్యర్థన / స్పందన నమూనాను ఒక రకమైన నమూనాగా రూపొందిస్తాను. నేను కన్సోల్ తెరిచాను, మరియు {"పొలం": {"వెడల్పు": 10, "ఎత్తు": 10}} చూసింది.

"గొప్ప!"

అప్పుడు నేను ప్యాచ్ క్లాస్ను ప్రతి పలకను సూచించాను. ఆట యొక్క తర్కం చాలా జరిగేటట్లు నేను కనుగొన్నాను. నుండి అనువర్తనం / మోడల్ / ప్యాచ్ మోడల్. ముందు :

  నేమ్పేస్ యాప్ \ మోడల్;తరగతి ప్యాచ్ మోడల్{ప్రైవేట్ $ x{{return $ this-> x; }}ప్రైవేట్ $ y{{return $ this-> y; }}పబ్లిక్ ఫంక్షన్ __construct (Int $ x, int $ y){$ this-> x = $ x;$ this-> y = $ y;}}   

నేను ఒక కొత్త ఫార్మ్ లో ఖాళీలు ఉన్నాయి వంటి అనేక పాచెస్ వంటి సృష్టించాలి భావిస్తున్న. నేను FarmModel నిర్మాణంలో భాగంగా దీన్ని చేయగలను. నుండి అనువర్తనం / మోడల్ / ఫార్మా నమూనా. ముందు :

  నేమ్పేస్ యాప్ \ మోడల్;తరగతి FarmModel{ప్రైవేట్ $ వెడల్పు{{తిరిగి $ ఈ-> వెడల్పు పొందండి; }}ప్రైవేట్ $ ఎత్తు{{return $ this-> ఎత్తు తిరిగి పొందండి; }}ప్రైవేట్ $ పాచెస్{{తిరిగి $ ఈ-> పాచెస్ పొందండి; }}ప్రజా ఫంక్షన్ __construct ($ వెడల్పు = 10, $ ఎత్తు = 10){$ this-> width = $ width;$ this-> ఎత్తు = $ ఎత్తు;$ ఈ-> createPatches   ;}ప్రైవేట్ ఫంక్షన్ createPatches   {($ i = 0; $ i <$ ఈ-> వెడల్పు; $ i ++) {$ this-> పాచెస్ [$ i] = [];($ j = 0; $ j <$ this-> ఎత్తు; $ j ++) {$ this-> పాచెస్ [$ i] [$ j] =కొత్త ప్యాచ్ మోడల్ ($ i, $ j);}}}}   

ప్రతి సెల్ కోసం, నేను కొత్త ప్యాచ్ మోడల్ వస్తువును సృష్టించాను. ప్రారంభించటానికి చాలా సులువుగా ఉండేవి, కానీ అవి అయోమయ స్థితికి ఒక మూలకం అవసరమయ్యాయి - చెట్లు, కలుపు మొక్కలు, పువ్వులు పెరగడానికి ఒక మార్గం .కనీసం ప్రారంభించడానికి. నుండి అనువర్తనం / మోడల్ / ప్యాచ్ మోడల్. ముందు :

  పబ్లిక్ ఫంక్షన్ ప్రారంభం (Int $ వెడల్పు, Int $ ఎత్తు,అర్రే $ పాచెస్){(! $ this-> ప్రారంభించి && random_int (0, 10)> 7) {$ this-> ప్రారంభం = సత్యం;నిజమైన తిరిగి;}తప్పుడు తిరిగి;}   

నేను యాదృచ్చికంగా ఒక పాచ్ పెరుగుతుండటంతోనే నేను ప్రారంభించాను. ఇది పాచ్ యొక్క బాహ్య స్థితిని మార్చలేదు, కానీ అవి వ్యవసాయం ప్రారంభించినప్పుడు ఎలా పరీక్షించాలో నాకు ఒక మార్గం ఇచ్చింది. నుండి అనువర్తనం / మోడల్ / ఫార్మా నమూనా. స్టార్టర్స్ కోసం, నేను ఒక async ఫంక్షన్ కీవర్డ్ను మాక్రోను ఉపయోగించి పరిచయం చేసాను. మీరు గమనిస్తే, Amp దిగుబడి కీవర్డ్లను పరిష్కరించడం ద్వారా కీలక పదమును నిర్వహిస్తుంది. అంతేకాక ఆమ్ప్ దిగుబడి కీవర్డ్ను చూసినపుడు, అది ఏమిటంటే కరోటైన్ (చాలా సందర్భాలలో) ఇవ్వబడుతోంది.

నేను సృష్టించిన createPatches ను ఒక సాధారణ విధిగా పని చేసాను, మరియు దాని నుండి ఒక కరోటిన్ తిరిగి వచ్చాను, కానీ నేను అలాంటి ఒక ప్రత్యేకమైన కోడ్ను కలిగి ఉంటాను, దాని కోసం నేను ఒక ప్రత్యేకమైన మాక్రోని సృష్టించాను. అదే సమయంలో, నేను మునుపటి భాగంలో చేసిన కోడ్ను భర్తీ చేయగలము. నుండి సహాయకులు. ముందు :

  async ఫంక్షన్ మిక్స్ ($ మార్గం) {$ మానిఫెస్ట్ = దిగుమతి Amp \ file \ get ("/ public / mix-manifest-json");$ మానిఫెస్ట్ = json_decode ($ మానిఫెస్ట్, నిజమైన);(isset ($ మానిఫెస్ట్ [$ పాత్])) {తిరిగి $ మానిఫెస్ట్ [$ మార్గం];}కొత్త మినహాయింపును త్రోసిపుచ్చండి ("{$ పాత్} కనుగొనబడలేదు");}   

గతంలో, నేను ఒక జెనరేటర్ తయారు చేసి, ఆపై ఒక కొత్త క్రౌటైన్ లో వ్రాసి వచ్చింది:

  Amp \ Coroutine వాడండి;ఫంక్షన్ మిక్స్ ($ మార్గం) {$ జెనరేటర్ =    => {$ మానిఫెస్ట్ = దిగుమతి Amp \ file \ get ("/ public / mix-manifest-json");$ మానిఫెస్ట్ = json_decode ($ మానిఫెస్ట్, నిజమైన);(isset ($ మానిఫెస్ట్ [$ పాత్])) {తిరిగి $ మానిఫెస్ట్ [$ మార్గం];}కొత్త మినహాయింపును త్రోసిపుచ్చండి ("{$ పాత్} కనుగొనబడలేదు");};కొత్త క్రౌటైన్ ($ జెనరేటర్    ఉత్పాదన;}   

గ్రిడ్లో ప్రతి x మరియు y కోసం కొత్త ప్యాచ్ మోడల్ ఆబ్జెక్ట్లను సృష్టించే ముందు createPatches పద్ధతిని నేను ప్రారంభించాను. అప్పుడు నేను మరొక లూప్ను ప్రారంభించాను, ప్రతి పాచ్లో ప్రారంభం పద్ధతిని పిలవడానికి. నేను అదే దశలో చేశాను, అయితే నా ప్రారంభం పధ్ధతి పరిసర పాచెస్ను పరిశీలించటానికి నేను కోరుకున్నాను. నేను పాచెస్ ప్రతి ఇతర చుట్టూ పని ముందు, మొదటి వాటిని అన్ని సృష్టించడానికి కలిగి అర్థం.

నేను మార్చిన FarmModel ఒక మీద గ్రోత్ మూసివేత అంగీకరించడానికి. ఆలోచన పాచ్ పెరిగింది ఉంటే నేను ఆ మూసివేస్తామని అని ఉంది (కూడా బూట్స్ట్రాప్ దశ సమయంలో).

ఒక పాచ్ పెరిగిన ప్రతిసారి నేను $ మార్పులు వేరియబుల్ను రీసెట్ చేస్తాను. పొలాల యొక్క మొత్తం పాస్ ఎటువంటి మార్పులకు దారి తీసే వరకు పాచెస్ పెరుగుతూనే ఉంటుంది. నేను కూడా పెరుగుదల మూసివేసింది. నేను గ్రోత్ ను సాధారణ మూసివేతగా, లేదా క్రౌటైన్ ను తిరిగి పొందాలని అనుకున్నాను. అందువల్ల నేను createPatches మరియు async ఫంక్షన్ చేయడానికి అవసరమైనది.

గమనిక: ఆమోదయోగ్యంగా, పెరుగుదల కరుణానియాల సంక్లిష్ట విషయాలను అనుమతిస్తుంది, కానీ ఒక పాచ్ పెరిగినప్పుడు ఇతర అసిక్క్ చర్యలను అనుమతించడం కోసం ఇది అవసరమైనది. బహుశా తరువాత నేను సాకెట్ సందేశాన్ని పంపించాలనుకుంటున్నాను, మరియు దిగుబడి లో లోపల పని చేస్తే నేను మాత్రమే చేయగలుగుతాను. నేను createPatches ఒక async ఫంక్షన్ అయితే పైకి మాత్రమే లభిస్తుంది. మరియు ఎందుకంటే createPatches ఒక async ఫంక్షన్, నేను లోపల GameSocket ఇచ్చు అవసరం.

"ఒకరి మొట్టమొదటి async PHP అప్లికేషన్ చేసేటప్పుడు నేర్చుకోవాల్సిన అన్ని అంశాలచే నిలిపివేయడం సులభం. సెమాల్ట్ త్వరలోనే వదిలేయండి! "

ఈ మొత్తం పని GameSocket లో ఉందని తనిఖీ చేయడానికి నేను వ్రాసిన చివరి బిట్ కోడ్. నుండి అనువర్తనం / సాకెట్ / గేమ్సాకెట్. ముందు :

  ఉంటే ($ శరీరం === "కొత్త వ్యవసాయ") {$ పాచెస్ = [];$ పొలం = కొత్త ఫార్మా నమూనా (10, 10,ఫంక్షన్ (ప్యాచ్ మోడల్ $ పాచ్) వాడండి (& $ పాచెస్) {array_push ($ పాచెస్, ["x" => $ patch-> x,"y" => $ patch-> y,]);});దిగుమతి $ వ్యవసాయ-> createPatches   ;$ payload = json_encode (["farm" => ["width" => $ farm-> వెడల్పు,"height" => $ farm-> ఎత్తు,],"పాచెస్" => $ పాచెస్,]);$ this-> endpoint-> పంపించు$ payload, $ clientId);$ ఈ-> పొలాలు [$ clientId] = $ వ్యవసాయ;}   

ఇది మునుపటి కోడ్ కంటే కొంచెం క్లిష్టమైనది. ఆ తరువాత, నేను సాకెట్ పేలోడ్కు పాచెస్ యొక్క స్నాప్షాట్ను పాస్ చేయాల్సిన అవసరం ఉంది.

రియాక్ట్, PHP మరియు WebSockets తో విధానంగా రూపొందించబడిన గేమ్ టెర్రైన్రియాక్ట్, PHP మరియు WebSockets తో విధానపరంగా సృష్టించిన గేమ్ టెర్రైన్
FrameworksAPIsSecurityPatterns & PracticesDebugging & Semalt

"నేను ప్రతి ప్యాచ్ పొడి దుమ్ము వంటి మొదలు ఉంటే? అప్పుడు నేను కొన్ని పాచీలను కలుపుతాను, మరికొన్ని చెట్లు ఉన్నాయి ."

నేను పాచెస్ అనుకూలీకరించడానికి గురించి సెట్. నుండి అనువర్తనం / మోడల్ / ప్యాచ్ మోడల్. ముందు :

  ప్రైవేట్ $ ప్రారంభించారు = తప్పుడు;ప్రైవేట్ $ తడి {{తిరిగి $ ఈ-> తడి? పొందండి: తప్పుడు; }};ప్రైవేట్ $ రకం {{return $ this-> type?: "dirt"; }};పబ్లిక్ ఫంక్షన్ ప్రారంభం (Int $ వెడల్పు, Int $ ఎత్తు,అర్రే $ పాచెస్){ఉంటే ($ ఈ-> ప్రారంభించారు) {తప్పుడు తిరిగి;}ఉంటే (యాదృచ్ఛిక_int (0, 100) <90) {తప్పుడు తిరిగి;}$ this-> ప్రారంభం = సత్యం;$ this-> type = "కలుపు";నిజమైన తిరిగి;}   

ఒక బిట్ చుట్టూ తర్కం యొక్క క్రమాన్ని నేను మార్చుకున్నాను, మొదట పాచ్ ప్రారంభించబడితే, ఆరంభమయ్యింది. నేను వృద్ధి అవకాశాన్ని కూడా తగ్గించాను. ఈ ప్రారంభ నిష్క్రమణలలో ఏదీ జరగకపోతే, పాచ్ రకం కలుపుకు మారుతుంది.

నేను ఈ రకాన్ని సాకెట్ సందేశ పేలోడ్లో భాగంగా ఉపయోగించుకోవచ్చు. నుండి అనువర్తనం / సాకెట్ / గేమ్సాకెట్. ముందు :

  $ పొలం = కొత్త ఫార్మా నమూనా (10, 10,ఫంక్షన్ (ప్యాచ్ మోడల్ $ పాచ్) వాడండి (& $ పాచెస్) {array_push ($ పాచెస్, ["x" => $ patch-> x,"y" => $ patch-> y,"తడి" => $ పాచ్-> తడి,"type" => $ patch-> రకం,]);});   

వ్యవసాయాన్ని అందజేయడం

నేను ఇంతకు ముందు సెటప్ చేసిన రియాక్టు వర్క్ఫ్లో ఉపయోగించి, వ్యవసాయాన్ని చూపించడానికి ఇది సమయం. పొలాల యొక్క వెడల్పు మరియు ఎత్తు ను నేను అప్పటికే పొందాను, అందుచే నేను ప్రతి బ్లాక్ పొడి దుమ్మును తయారు చేసాను (అది ఒక కలుపు పెరుగుతుందని తప్ప). నుండి ఆస్తులు / JS / అనువర్తనం. jsx :

  దిగుమతి "ప్రతిచర్య" నుండిక్లాస్ ఫామ్ రియాక్ట్ వర్తిస్తుంది. కాంపోనెంట్{తయారీదారు   {సూపర్   ఈ. onMessage = ఈ. onMessage. బైండ్ (ఈ)ఈ. రాష్ట్ర ="పొలం": {"వెడల్పు": 0,"ఎత్తు": 0,},"పాచెస్": [],};}componentWillMount   {ఈ. సాకెట్ = కొత్త వెబ్కెట్ ("ws: // 127 0. 0. 1: 8080 / ws")ఈ. సాకెట్. addEventListener ("సందేశం", ఇది. onMessage)// DEBUGఈ. సాకెట్. addEventListener ("open",    => {ఈ. సాకెట్. ( "కొత్త వ్యవసాయేతర") పంపడానికి})}onMessage (ఇ){డేటా = JSON ను అనుమతించండి. పార్స్ (ఇ డేటా);(డేటా ఫారమ్) {ఈ. setState ({"వ్యవసాయ": డేటా.}ఉంటే (డేటా పాచెస్) {ఈ. setState ({"పాచెస్": డేటా. పాచెస్})}}componentWillUnmount   {ఈ. సాకెట్. removeEventListener (ఈ onMessage)ఈ. సాకెట్ = శూన్యం}రెండర్    {వరుసలు = []వ్యవసాయం = ఈ వీలు. రాష్ట్ర. వ్యవసాయస్టేట్ పాచెస్ = ఇట్. రాష్ట్ర. పాచెస్(y = 0; y <వ్యవసాయం ఎత్తు; y ++) {పాచెస్ = [](x = 0; x <వ్యవసాయం వెడల్పు; x ++) {className = "పాచ్"statePatches. forEach (పాచ్) => {(పాచ్ x === x && పాచ్. y === y) {className + = "" + పాచ్. రకం(పాచ్ తడి)className + = "" + తడి}}})పాచెస్. పుష్ (
)}వరుసలు. పుష్ (
{పాచెస్}
)}తిరిగి (
{rows}
)}}డిఫాల్ట్ ఫార్మ్ ఎగుమతి

మునుపటి ఫార్మ్ భాగం ఏమి చేస్తున్నారో వివరించడానికి నేను మర్చిపోయాను. ఇంటర్ఫేస్లను ఎలా నిర్మించాలనే దాని గురించి ప్రతిస్పందించే భాగాలు వేరే విధంగా ఉన్నాయి. నేను భాగం, వాల్యుం మౌంట్ మరియు భాగం, వాల్యుఅన్మౌంట్ వంటివి ఇతర డేటా పాయింట్ల (WebSockets వంటివి) లోకి మారడానికి మార్గాలుగా ఉపయోగించవచ్చు. నేను WebSocket ద్వారా నవీకరణలను అందుకున్నప్పుడు, నేను కాన్స్ట్రక్టర్లో ప్రారంభ స్థితిని ఏర్పాటు చేసినంత కాలం, నేను భాగం యొక్క స్థితిని నవీకరించాను.

ఇది ఒక అసహ్యకరంగా, divs యొక్క ఫంక్షనల్ సెట్ అయినప్పటికీ. నేను కొన్ని స్టైలింగ్ జోడించడం గురించి సెట్. నుండి అనువర్తనం / యాక్షన్ / HomeAction. ముందు :

  నేమ్పేస్ యాప్ \ యాక్షన్;Aerys అభ్యర్థనను ఉపయోగించండి;Aerys \ రెస్పాన్స్ ఉపయోగించండి;తరగతి HomeAction{పబ్లిక్ ఫంక్షన్ __ఇన్వోక్ (అభ్యర్థన $ అభ్యర్థన,ప్రతిస్పందన $ ప్రతిస్పందన){$ js = దిగుబడి మిశ్రమం ("/ js / app. js");$ css = దిగుబడి మిక్స్ ("/ css / అనువర్తనం. css");$ Response-> ఎండ్ ( "<లింక్ rel = 'styleheet' href = '{$ css}' />
March 1, 2018