ಉಬುಂಟು ಟಚ್‌ಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಲಾಗುತ್ತಿದೆ [QML] - [ಭಾಗ 2]

ಪೀಠಿಕೆ:

ಸರಿ ಇಲ್ಲಿ ನಾವು ಅನುಸರಿಸುವ ಪೋಸ್ಟ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮೊದಲ ಭಾಗಇದರಲ್ಲಿ ನಾವು ಡೇಟಾವನ್ನು (ಪ್ರಶ್ನೆಗಳನ್ನು) ನಿರ್ವಹಿಸುವುದರತ್ತ ಗಮನ ಹರಿಸಲಿದ್ದೇವೆ ಮತ್ತು ನಾವು ಆಟದ ತರ್ಕ ಭಾಗದಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ಮುಂದಿನದರಲ್ಲಿ ನಾವು ತರ್ಕವನ್ನು ಮುಗಿಸುತ್ತೇವೆ ಮತ್ತು ಸಮಯ ಮತ್ತು 3 ಆಯ್ಕೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ.

ಡೇಟಾಬೇಸ್:

ಡೇಟಾಬೇಸ್ಗಾಗಿ ನಾವು ಬಳಸುತ್ತೇವೆ ಯು 1 ಡಿಬಿ, ಇದು ಸ್ವರೂಪದಲ್ಲಿ ಡೇಟಾವನ್ನು ಉಳಿಸುವ ಡೇಟಾಬೇಸ್ ಆಗಿದೆ JSON.

ಮೊದಲನೆಯದಾಗಿ ನಾವು ಯಾವ ಡೇಟಾವನ್ನು ಉಳಿಸಬೇಕು ಎಂದು ನೋಡೋಣ, ನಮ್ಮಲ್ಲಿ 1 ಪ್ರಶ್ನೆ ಇದೆ (ಪ್ರಶ್ನೆಯ ಪಠ್ಯವನ್ನು ಹೊರತುಪಡಿಸಿ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿರುವುದು ಒಳ್ಳೆಯದು), 4 ಸಂಭವನೀಯ ಉತ್ತರಗಳೊಂದಿಗೆ, ಅದರಲ್ಲಿ 1 ಮಾತ್ರ ಇರಬಹುದು, ಆದ್ದರಿಂದ ಡಾಕ್ಯುಮೆಂಟ್ JSON ಒಂದೇ ಪ್ರಶ್ನೆ ಹೀಗಿರಬೇಕು:

{ "id": 1, "question": " dev ಇರುತ್ತದೆ.desdelinux.net ", "ಉತ್ತರಗಳು" : { r1: "ಹೌದು", r2: "ಇಲ್ಲ", r3: "ಗೊತ್ತಿಲ್ಲ", r4: "ಇದು ತಪ್ಪು ಉತ್ತರ" }, "ಸರಿಯಾದ": 3 }

ನಾವು ನೋಡುವಂತೆ ನಾವು ಸ್ವರೂಪದಲ್ಲಿ ರಚಿಸಿದ್ದೇವೆ JSON ಅಲ್ಲಿ ನಾವು ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಪ್ರಶ್ನೆಯೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಉತ್ತರ 1 ಮತ್ತು ಉತ್ತರ 2 ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ r1, r2, ಅಂತಿಮವಾಗಿ ನಮ್ಮಲ್ಲಿ ಯಾವ ಉತ್ತರಗಳು ಸರಿಯಾಗಿವೆ.

U1db ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸ್ವಲ್ಪ ನೋಡೋಣ, U1db ಅನ್ನು ಬಳಸಲು ನಾವು ಮೊದಲು ಮಾಡಬೇಕಾಗಿರುವುದು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು:

import U1db 1.0 as U1db

ನಾವು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಘೋಷಿಸುತ್ತೇವೆ:

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

ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು aU1DbDatabase.u1db ಆಗಿ ಉಳಿಸಲಾಗುತ್ತದೆ, ಈಗ ನಾವು ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:

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


ಪ್ರಶ್ನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಡೇಟಾವನ್ನು ಸೇರಿಸಲು, ಡೇಟಾವನ್ನು ಪಡೆಯಲು, ಅವುಗಳನ್ನು ಅಳಿಸಲು ಇತ್ಯಾದಿ {«ಹಲೋ»: «ಏನೋ» the ಸ್ವರೂಪವನ್ನು ನಾವು ಎಲ್ಲಿ ನೋಡಬಹುದು. ನಮ್ಮಲ್ಲಿ U1db.Query ಅಂಶವಿದೆ.

ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹೋಗಿ ನಮ್ಮ ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸೋಣ, ನಾವು ನೋಡಿದಂತೆ ನಾವು ಡೇಟಾಬೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ:

U1db. ಡೇಟಾಬೇಸ್ {id: db ಪ್ರಶ್ನೆಗಳು; ಮಾರ್ಗ: "questionsdb.u1db"}

ಸರಿ, ಈಗ ಡೇಟಾಬೇಸ್ ಡಾಕ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ಕೆಲವು ಡೀಫಾಲ್ಟ್ ಅಂಶಗಳನ್ನು ಪ್ರಶ್ನೆಗಳನ್ನು ಇಡೋಣ:

    U1db.Document { id: aDocument database: questionsdb docId: 'questions' create: true defaults: { "questions": [ {"question":"dev ಇರುತ್ತದೆ.desdelinux.net ?", "r1":"ಹೌದು", "r2":"ಇಲ್ಲ", "r3":"ಮೂಗು", "r4":"ತಪ್ಪು ಉತ್ತರ", "ಸರಿಯಾದ": "3" }, {"ಪ್ರಶ್ನೆ ":"ಹ್ಯಾಗ್ರಿಡ್ (ಹ್ಯಾರಿ ಪಾಟರ್) ಯಾರು?", "r1":"ಶಾಲೆಯ ಉಪ ಪ್ರಾಂಶುಪಾಲರು", "r2":"ಆಟದ ಕೀಪರ್", "r3":"ಪರಿವರ್ತನೆ ಶಿಕ್ಷಕ", "r4":" ಒಬ್ಬ ಪ್ರಿಫೆಕ್ಟ್", "ಸರಿಯಾದ": "2"}, {"ಪ್ರಶ್ನೆ":"ಐಸ್‌ಲ್ಯಾಂಡ್‌ನ ರಾಜಧಾನಿ ಯಾವುದು?", "r1":"ಆಮ್ಸ್ಟರ್‌ಡ್ಯಾಮ್", "r2":"ರೇಕ್‌ಜಾವಿಕ್", "r3":" ಟಿಬಿಲಿಸಿ ", "r4":"Almaty", "ಸರಿಯಾದ": "2"} ] } }

ಕೋಡ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಿದಂತೆ ಪ್ರದರ್ಶಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ, ಆದರೆ ನಾವು ನೋಡಿದರೆ ನಮ್ಮಲ್ಲಿ ಒಂದು ಅಂಶವಿದೆ ಎಂದು ನೋಡುತ್ತೇವೆ ಪ್ರಶ್ನೆಗಳು, »[] with ನೊಂದಿಗೆ ಹಲವಾರು (ಅವು ಸ್ಥಿರವಾಗಿಲ್ಲ) ಅಂಶಗಳಿರಬಹುದು ಎಂದು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ; ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 4, ಆಯಾ ಉತ್ತರಗಳೊಂದಿಗೆ 4 ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿರುತ್ತೇವೆ.

ಡಾಕ್ಯುಮೆಂಟ್ ಅಂಶಗಳನ್ನು ಪಡೆಯಲು JSON, ನಾವು ರಚಿಸಿದ ಡಾಕ್ಯುಮೆಂಟ್‌ನ ಗುರುತಿಸುವಿಕೆಯನ್ನು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು (ಅದು a ಡಾಕ್ಯುಮೆಂಟ್). ಮೊದಲ ಪ್ರಶ್ನೆಯ ಪಠ್ಯವನ್ನು ಪಡೆಯಲು ನಾವು ಬಯಸುತ್ತೇವೆ ಎಂದು imagine ಹಿಸೋಣ:

aDocument.contents.questions [0]. ಪ್ರಶ್ನೆ

ಕೋಡ್‌ನ ಈ ಸಾಲು ಡಾಕ್ಯುಮೆಂಟ್‌ನ ಡಾಕ್ಯುಮೆಂಟ್‌ನ ಪ್ರಶ್ನೆ ವಿಷಯವನ್ನು ನಮಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅಂಶ 0 (ಸೂಚ್ಯಂಕದಲ್ಲಿ ಮೊದಲನೆಯದು), ಇದು: «ದೇವ್ ಇರುತ್ತದೆ.desdelinux.net?" ನಾವು ಸೂಚ್ಯಂಕದಲ್ಲಿ ಸಂಖ್ಯೆ 1 ಅನ್ನು ಹಾಕಿದರೆ, ಅದು ಎರಡನೇ ಪ್ರಶ್ನೆಯಾಗಿದೆ.

ಆಟದ ತರ್ಕವನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ಉಳಿಸಿದ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು ಎಂದು ಈಗ ನಮಗೆ ತಿಳಿದಿದೆ, ನಾವು ಆಟದ ತರ್ಕವನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ಹೋಗುತ್ತೇವೆ. ಮೊದಲಿಗೆ ನಾವು ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ (.js): ಹೊಸ -> Qt -> Js ಫೈಲ್ ಸೇರಿಸಿ. ನಾನು ಅವನನ್ನು ಕರೆಯುತ್ತೇನೆ log.js.

ಫೈಲ್ನಲ್ಲಿ ನಾವು ನಮ್ಮ qml ಡಾಕ್ಯುಮೆಂಟ್ಗೆ ಜೆಎಸ್ ಫೈಲ್ ಅನ್ನು ಆಮದು ಮಾಡಲು ಹಲವಾರು ಕಾರ್ಯಗಳನ್ನು ರಚಿಸಲಿದ್ದೇವೆ:

"Loga.js" ಅನ್ನು ಲಾಜಿಕಾದಂತೆ ಆಮದು ಮಾಡಿ

ನಾವು ಲಾಜಿಕಾ ಎಂಬ ಹೆಸರನ್ನು ಸಂಯೋಜಿಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಕಾರ್ಯವನ್ನು ಕರೆಯಲು ಬಯಸಿದಾಗ ನಾವು ಅದನ್ನು Logica.funcion () ಎಂದು ಮಾಡುತ್ತೇವೆ, ಅದು ಅದರ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರುವ ವಸ್ತುವಿನಂತೆ.

ಸದ್ಯಕ್ಕೆ, ಪೋಸ್ಟ್ ತುಂಬಾ ಉದ್ದವಾಗದಂತೆ, ನಾವು ಪ್ರಶ್ನೆಯ ಸಮಯ ಮತ್ತು ನಂತರದ ಆಯ್ಕೆಗಳನ್ನು ಬಿಡುತ್ತೇವೆ, ನಾವು ಪ್ರಶ್ನೆಗಳು ಮತ್ತು ಬಿಂದುಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ, ಪ್ರಶ್ನೆಯಿಂದ ಮುಂದುವರಿಯಲು ನಾವು ಬಳಸುವ ಕಾರ್ಯವನ್ನು ನೋಡೋಣ:

ಕಾರ್ಯ ಮುಂದಿನ ಪ್ರಶ್ನೆ (ಸಂಖ್ಯೆ) {// ಸಮಯ = 0 ಪ್ರಶ್ನೆ.ಟೆಕ್ಸ್ಟ್ = aDocument.contents.questions [ಸಂಖ್ಯೆ]. ಪ್ರಶ್ನೆ; resp1.text = aDocument.contents.questions [ಸಂಖ್ಯೆ] .r1; resp2.text = aDocument.contents.questions [ಸಂಖ್ಯೆ] .r2; resp3.text = aDocument.contents.questions [ಸಂಖ್ಯೆ] .r3; resp4.text = aDocument.contents.questions [ಸಂಖ್ಯೆ] .r4; }

ನಾವು ನೋಡುವಂತೆ, ನಾವು ಎಲ್ಲಿದ್ದೇವೆ ಎಂಬ ಪ್ರಶ್ನೆ ಸಂಖ್ಯೆಯನ್ನು ನಾವು ವಾದವಾಗಿ ರವಾನಿಸುತ್ತೇವೆ ಮತ್ತು ಇಲ್ಲಿಂದ ಅದು ಗುಂಡಿಗಳಿಗೆ ಉತ್ತರಗಳನ್ನು ಮತ್ತು ಪ್ರಶ್ನೆ ಲೇಬಲ್‌ಗೆ ಇರಿಸುತ್ತದೆ. ಆಯ್ದ ಉತ್ತರ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಮೌಲ್ಯೀಕರಿಸಲು ಈಗ ನೋಡೋಣ:

ಫಂಕ್ಷನ್ ಹಿಟ್ (ಸಂಖ್ಯೆ, ಆಯ್ಕೆ) {var ಹಿಟ್ = ಸುಳ್ಳು; var num_correcto = aDocument.contents.questions [num] .correcto; if (ಆಯ್ಕೆ == correct_num) hit = true; ರಿಟರ್ನ್ ಹಿಟ್; }

ಕೋಡ್ ತಾನೇ ಹೇಳುತ್ತದೆ, ಒಂದು ವೇಳೆ ಆಯ್ಕೆಮಾಡಿದ ಆಯ್ಕೆಯು ಡೇಟಾಬೇಸ್ ಒದಗಿಸಿದಂತೆಯೇ ಇದ್ದರೆ, ಅದು ನಿಜವಾಗುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ಆಗುವುದಿಲ್ಲ. ಈಗ ನಾವು ಈ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ, ನಾವು ಅವುಗಳನ್ನು ನಮ್ಮ qml ಕೋಡ್‌ನಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತೇವೆ.

ಮೊದಲನೆಯದಾಗಿ ನಾವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಅದು ನಾವು ಯಾವ ಪ್ರಶ್ನೆಯಲ್ಲಿದೆ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ, ನಾವು ಅದನ್ನು ಸಂಖ್ಯೆ ಎಂದು ಕರೆಯುತ್ತೇವೆ; ನಾವು ಇನ್ನೂ ಮೂರು ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ: ಹಿಟ್ಸ್, ಮಿಸ್ ಮತ್ತು ಪಾಯಿಂಟ್ಸ್.

    ಆಸ್ತಿ ಇಂಟ್ ಸಂಖ್ಯೆ: 0 ಆಸ್ತಿ ಇಂಟ್ ಎನ್ಫಾಲ್ಟ್ಸ್: 0 ಆಸ್ತಿ ಇಂಟ್ ಜನನಗಳು: 0 ಆಸ್ತಿ ಇಂಟ್ ಎನ್ ಪಾಯಿಂಟ್ಸ್: 0

ಆರಂಭದಲ್ಲಿ ಅವೆಲ್ಲವೂ 0 ನಲ್ಲಿವೆ.

ಈಗ ನಾವು ಎಲ್ಲಾ ಉತ್ತರ ಗುಂಡಿಗಳಿಗೆ ಆನ್‌ಕ್ಲಿಕ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ. onClick, ಅದರ ಹೆಸರೇ ಹೇಳುವಂತೆ, ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಅದು ಸಂಭವಿಸುತ್ತದೆ:

            ಬಟನ್ {id: resp1 ಪಠ್ಯ: "ಪ್ರತಿಕ್ರಿಯೆ 1" ಆಧಾರಗಳು Logic.nextQuestion (num) npoints = npoints + 20 births = births + 1} else {nfaults = nfaults + 1}}}

ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಮಾಡುವುದರ ಮೂಲಕ, ಅದು ಸರಿಯಾಗಿದೆಯೆ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಅದು ಸರಿಯಾಗಿದ್ದರೆ, ಅಂಕಗಳನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಪ್ರಶ್ನೆಯನ್ನು ರವಾನಿಸಿ, ಇಲ್ಲದಿದ್ದರೆ ಒಂದು ಜೀವನ ಉಳಿದಿದೆ.

ಪುಟದ ಘಟಕವು ಲೋಡ್ ಆದಾಗ ಅಂತಿಮವಾಗಿ ನಾವು ಮೊದಲ ಪ್ರಶ್ನೆ ಲೋಡ್ ಮಾಡುತ್ತೇವೆ:

    ಪುಟ {id: pageGame Component.onCompleted: {Logic.nextPregunta (0)}

ಅದು ಹೇಗೆ ಬದಲಾಯಿತು ಎಂಬುದನ್ನು ನೋಡೋಣ: