ઉબુન્ટુ ટચ [QML] - [ભાગ 2] માટે એપ્લિકેશન બનાવવી

પરિચય:

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

ડેટાબેસ:

ડેટાબેઝ માટે આપણે ઉપયોગ કરીશું યુ 1 ડીબી, જે ડેટાબેસ છે જે ડેટાને ફોર્મેટમાં સાચવે છે JSON.

પહેલા આપણે જોઈએ કે આપણે કયો ડેટા સાચવવો જોઈએ, અમારી પાસે 1 સવાલ છે (પ્રશ્નના ટેક્સ્ટ સિવાય ઓળખકર્તા રાખવું સરસ રહેશે), 4 શક્ય જવાબો સાથે, જેમાં ફક્ત 1 હોઈ શકે છે, તેથી દસ્તાવેજ JSON એક જ પ્રશ્ન હોવો જોઈએ:

{ "id": 1, "પ્રશ્ન": " દેવ હશે.desdelinux.net "," જવાબો" : { r1: "હા", r2: "ના", r3: "ખબર નથી", r4: "આ ખોટો જવાબ છે" }, "સાચો": 3 }

આપણે જોઈએ છીએ કે આપણે ફોર્મેટમાં સ્ટ્રક્ચર્ડ કર્યું છે JSON જ્યાં આપણી પાસે ઓળખકર્તા છે, પ્રશ્નની શબ્દમાળા અને r1, r2 જે જવાબ 1 અને જવાબ 2 ને રજૂ કરે છે, છેવટે આપણી પાસે કયા જવાબો સાચા છે.

ચાલો જોઈએ કે યુ 1 ડીબી કેવી રીતે કાર્ય કરે છે, યુ 1 ડીબીનો ઉપયોગ કરવા માટે તમારે પ્રથમ વસ્તુ મોડ્યુલ આયાત કરવાની છે:

import U1db 1.0 as U1db

અમે ડેટાબેઝ જાહેર કરીએ છીએ:

U1db.Database {
id: aDatabase
path: "aU1DbDatabase"
}

ડેટાબેસેસ AU1DbDat ડેટા.u1db તરીકે સાચવવામાં આવશે, હવે આપણે એક દસ્તાવેજ બનાવીશું:

U1db.Document {
id: aDocument
database: aDatabase
docId: 'helloworld'
create: true
defaults: { "hello": "Hello World!" }
}


જ્યાં આપણે {«હેલો»: «કંઈક» the, બંધારણ, ડેટા ઉમેરવા, ડેટા મેળવવા, તેમને કા deleteી નાખવા, વગેરેને એક્ઝેક્યુટ કરવા, બંધારણમાં જોઈ શકીએ છીએ. અમારી પાસે U1db.Query તત્વ છે.

ચાલો આપણે અમારી એપ્લિકેશન પર જઈએ અને ડેટાબેસ બનાવીએ, જેમ આપણે જોયું છે કે આપણે ડેટાબેઝને વ્યાખ્યાયિત કરીએ છીએ:

યુ 1 ડીબી. ડેટાબેસ {આઈડી: ડીબી પ્રશ્નો; પાથ: "પ્રશ્નોdb.u1db"

ઠીક છે, હવે ડેટાબેઝ ડોક્યુમેન્ટ સવાલો ડીબીમાં કેટલાક ડિફ putલ્ટ તત્વો મૂકીએ:

    U1db.Document { id: aDocument database: questionsdb docId: 'પ્રશ્નો' બનાવો: સાચા ડિફોલ્ટ્સ: { "પ્રશ્નો": [ {"પ્રશ્ન":"દેવ હશે.desdelinux.net?", "r1":"હા", "r2":"ના", "r3":"નાક", "r4":"ખોટો જવાબ", "સાચો": "3" }, {"પ્રશ્ન ":"હેગ્રીડ (હેરી પોટર) કોણ છે?", "r1":"શાળાના વાઇસ-પ્રિન્સિપાલ", "r2":"ધ ગેમકીપર", "r3":"ધ ટ્રાન્સફોર્મેશન ટીચર", "r4": " A prefect", "correct": "2"}, {"question":"આઇસલેન્ડની રાજધાની શું છે?", "r1":"Amsterdam", "r2":"Reykjavik", "r3":" તિબિલિસી", "r4":"અલમાટી", "સાચો": "2"} ] } }

હું જાણું છું કે કોડ જેવો જોઈએ તે રીતે પ્રદર્શિત થયો નથી, પરંતુ જો આપણે નજીકથી જોશું તો આપણે જોશું કે આપણી પાસે એક તત્વ છે પૂછપરછ, જે »[]» ની સાથે અમે સ્પષ્ટ કરીએ છીએ કે ત્યાં ઘણા (તે સ્થિર નથી) તત્વો હોઈ શકે છે; આ કિસ્સામાં આપણી પાસે 4 મૂળભૂત રીતે, તેના સંબંધિત જવાબો સાથે 4 પ્રશ્નો હશે.

દસ્તાવેજ તત્વો મેળવવા માટે JSON, અમે બનાવેલા દસ્તાવેજના ઓળખકર્તાને નિર્દિષ્ટ કરી શકીએ છીએ (જે છે એ દસ્તાવેજ). ચાલો કલ્પના કરીએ કે આપણે પહેલા પ્રશ્નના ટેક્સ્ટને મેળવવા માંગીએ છીએ:

aDocament.contents.questions [0] .ક્શન

કોડની આ લાઇન અમને તત્વ 0 (ઇન્ડેક્સમાં પ્રથમ) ના દસ્તાવેજ aDocumentની પ્રશ્ન સામગ્રી પરત કરે છે, જે છે: «દેવ હશે.desdelinux.net?" જો આપણે અનુક્રમણિકામાં નંબર 1 મૂકીએ, તો તે બીજો પ્રશ્ન છે.

રમત તર્ક પ્રોગ્રામિંગ

ઠીક છે, હવે જ્યારે આપણે જાણીએ છીએ કે ડેટાબેસેસનો કેટલો વ્યવહાર કરવો છે જ્યાં આપણે પ્રશ્નો સાચવ્યા છે, અમે રમતના તર્કશાસ્ત્રને પ્રોગ્રામ કરવા જઈશું. સૌ પ્રથમ આપણે એક ફાઈલ બનાવીશું જાવાસ્ક્રિપ્ટ (.js): નવી ઉમેરો -> ક્યુટ -> જેએસ ફાઇલ. હું તેને બોલાવીશ તર્ક. js.

ફાઈલમાં આપણે ઘણાં ફંક્શન્સ બનાવવાની છે, જેએસ ફાઇલને આપણા ક્યુએમએલ ડોક્યુમેન્ટમાં આયાત કરવા

લોગિકા તરીકે "logica.js" આયાત કરો

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

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

ફંક્શન નેક્સ્ટ્યુએશન (નંબર) {// ટાઇમ = 0 પ્રશ્શન.ટેક્સ્ટ = એ ડોક્યુમેન્ટ.કોન્ટેન્ટ્સ.ક્યુશન [નંબર] .ક્શન; resp1.text = aDocament.contents.questions [num] .r1; resp2.text = aDocament.contents.questions [num] .r2; resp3.text = aDocament.contents.questions [num] .r3; resp4.text = aDocament.contents.questions [num] .r4; }

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

ફંક્શન હિટ (num, વિકલ્પ) {var હિટ = ખોટું; var num_correcto = aDocament.contents.questions [num]. સુધારા; જો (વિકલ્પ == true_num) હિટ = સાચું; વળતર હિટ; }

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

સૌ પ્રથમ આપણે એક ચલ ઉમેરીશું જે આપણે નિયંત્રિત કરીશું કે કયા પ્રશ્નમાં આપણે તેને નંબર કહીશું; આપણી પાસે ત્રણ વધુ ચલો પણ હશે: હિટ્સ, મિસિસ અને પોઇન્ટ્સ.

    ગુણધર્મ પૂર્ણાંક નંબર: 0 સંપત્તિ પૂર્ણાંક nfaults: 0 સંપત્તિ પૂર્ણાંક જન્મ: 0 મિલકત પૂર્ણાંક npPoint: 0

શરૂઆતમાં તેઓ બધા 0 પર છે.

હવે આપણે બધા જવાબ બટનો પર onન-ક્લીક ઉમેરીશું. ઓન ક્લીક, તેના નામ પ્રમાણે, તે એક ઇવેન્ટ છે જે તે બટન ક્લિક થાય ત્યારે થશે:

            બટન {આઈડી: રીસ્પેસ ટેક્સ્ટ: "રિસ્પોન્સ 1" એન્કરહોરીઝોન્ટલ સેન્ટર: પેરેન્ટ હ.hરઝિન્ટલ સેન્ટરની પહોળાઈ: પેરેન્ટ.વિડ્થ - 1 licનક્લિક્ડ: {જો (લોજિક.કેરેન્ટ (નંબર, 20)) {નંબર = num + 1; લોજિક.એક્સ્ટક્વિશન (નંબર) npPoint = npPoint + 1 જન્મ = જન્મો + 50} અન્ય {nfaults = nfaults + 1}}}

અમે જોયું છે કે જ્યારે તમે બટનને ક્લિક કરો છો, ત્યારે તે તપાસે છે કે તે સાચું છે કે નહીં, જો તે છે, તો બિંદુઓ ઉમેરો અને પ્રશ્ન પસાર કરો, નહીં તો એક જીવન બાકી છે.

જ્યારે પૃષ્ઠ ઘટક લોડ થાય છે ત્યારે આપણે પ્રથમ પ્રશ્ન લોડ કરીશું:

    પૃષ્ઠ {આઈડી: પેજ ગેમ કમ્પોનન્ટ.ઓન કમ્પ્લેટેડ: ic લોજિક.એનક્સ્ટપ્રિગન્ટા (0)}

ચાલો જોઈએ કે તે કેવી રીતે બહાર આવ્યું: