हम पेबल के तहत कार्यक्रम करते हैं। पाठ दो: आंसरिंग स्टोन, पासा और सेक्स क्यूब्स

एक घड़ी निश्चित रूप से अच्छी है, लेकिन पूरी साइट इसके साथ भरी हुई है। हमें कुछ और दिलचस्प करने की जरूरत है।

"ट्रैक 60" से गेंद याद है? आइए इसका एनालॉग बनाते हैं - एक एप्लिकेशन जो प्रश्न का उत्तर देता है।

बॉल पेबल गिविंग जवाब

केवल हम एक गेंद नहीं है, लेकिन एक कंकड़, अर्थात् कंकड़ होगा :)
इसके लिए हमें क्या चाहिए? उत्तरों की एक सूची और एक यादृच्छिक संख्या जनरेटर। हम विकिपीडिया पर उत्तरों की सूची लेंगे। एक सरणी बनाएं और उसे उत्तरों से भरें:

static const char* messages[] = {"", " "," "," ","    ","  - "," "," ","","  - ","  ,   "," ","     ","  ","   ","  ","  - ","  - ","   "," ","",}; 

आदेश महत्वपूर्ण नहीं है, वैसे भी वे बेतरतीब ढंग से इसमें से चुने जाएंगे।

हम प्रोग्राम के मुख्य विंडो और पाठ परत को उसी तरह बनाते हैं जैसे पिछले पाठ में , एक छोटे अंतर को छोड़कर - window_set_fullscreen () फ़ंक्शन के साथ हम एप्लिकेशन के शीर्ष बार को हटाते हैं। इसे इस तरह कहा जाता है:

  window_set_fullscreen(window, true); 

पहला तर्क खिड़की का नाम है, दूसरा, क्रमशः, पूर्ण स्क्रीन है, बार के साथ गलत है। सूक्ष्मता - इस फ़ंक्शन को window_stack_push से पहले कॉल किया जाना चाहिए, अन्यथा कोई चमत्कार नहीं होगा।

अब रैंडम नंबर जनरेटर में आते हैं। ऐसा करने के लिए, एक रैंड () फ़ंक्शन है जो प्रत्येक कॉल पर एक यादृच्छिक संख्या देता है। किसी भी सॉफ्टवेयर RNG की तरह, इसे काम शुरू करने से पहले एक यादृच्छिक संख्या के साथ आरंभीकृत करना होगा, अन्यथा प्रत्येक प्रारंभ में संख्याओं की पंक्ति दोहराई जाएगी। यह srand () फ़ंक्शन द्वारा किया जाता है। उदाहरण के लिए, एसडीके में एक उदाहरण है जहां इसे वर्तमान समय के साथ आरंभ किया गया है। चूंकि हमें नहीं पता कि कार्यक्रम किस समय शुरू होगा, और यह समय हर बार अलग होता है, यह हमारे विचार में प्रवेश का पर्याप्त स्रोत है। हम इसे इस तरह करते हैं:

 srand(time(NULL)); 

सच है, जनरेटर अब बड़ी संख्या में उत्पादन कर सकता है - जाहिर है कि हमारे पास संभावित जवाबों की तुलना में अधिक है। इसलिए, जब हम संदेशों के इस निर्माण का उपयोग करते हैं [रैंड ()% 21] । % पूर्णांक विभाजन का शेष है। मान लीजिए कि जनरेटर 456 देता है, वे 21 से विभाजित होते हैं, और शेष (456-21 * 21) - 15 हम प्रतिक्रिया संख्या के रूप में उपयोग करते हैं। यह 21 से अधिक नहीं हो सकता है, क्योंकि इस मामले में शेष विभाजन शून्य के बराबर होगा।

हम उपरोक्त सभी को एक एकल में जोड़ते हैं, और हमें ऐसा फ़ंक्शन कॉल मिलता है:

 text_layer_set_text(text_layer, messages[rand() % 21]); 

यहाँ पूरा स्रोत है:

 #include "pebble.h" Window *window; /*     */ TextLayer *text_layer; /*      */ static const char* messages[] = {"", " "," "," ","    ","  - "," "," ","","  - ","  ,   "," ","     ","  ","   ","  ","  - ","  - ","   "," ","",}; /*    */ int main(void) { window = window_create(); /*   */ window_set_background_color(window, GColorBlack); /*    */ window_set_fullscreen(window, true); /*   */ window_stack_push(window, true); /*   */ text_layer = text_layer_create(GRect(1, 47, 142, 77)); /*    */ text_layer_set_text_color(text_layer, GColorWhite); /*    */ text_layer_set_background_color(text_layer, GColorClear); /*    */ text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); /*   */ text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /*     */ layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /*         */ srand(time(NULL)); /*       */ text_layer_set_text(text_layer, messages[rand() % 21]); /*        */ app_event_loop(); /*  - */ text_layer_destroy(text_layer); /*  ,   */ window_destroy(window); /*  ,   */ } 

कार्यक्रम स्टार्टअप पर एक संदेश प्रदर्शित करता है और अब कुछ भी नहीं करता है। एक अन्य संदेश प्रदर्शित करने के लिए, आपको प्रोग्राम को पुनरारंभ करना होगा:


अगला कदम बटन पर क्लिक करने पर संदेश प्रदर्शित करना है।

कंकड़ एपीआई में, "सदस्यता" शब्द का उपयोग उन कार्यों को नामित करने के लिए किया जाता है जो मुख्य लूप में लॉन्च नहीं किए जाएंगे, लेकिन कुछ कार्यों के बाद - टाइमर का एक टिक, एक बटन दबाकर, और इसी तरह। याद रखें, पिछले पाठ में, हमने एक टाइमर के लिए साइन अप किया था जिसे स्क्रीन रिफ्रेश फ़ंक्शन कहा जाता है? यहां कुछ समान है, हम एक बटन क्लिक की सदस्यता लेते हैं (और एपीआई में पहले से ही कई तैयार विकल्प हैं - एकल क्लिक , डबल क्लिक , होल्ड, और इसी तरह), जिसके बाद हम जो फ़ंक्शन सेट करते हैं वह लॉन्च किया जाएगा।

एपीआई का कहना है कि हमें window_set_click_config_provider () विधि को कॉल करने की आवश्यकता है, जो क्लिक को पकड़ने के लिए पॉइंटर के तर्क के रूप में लेता है, और उस फ़ंक्शन का नाम जिसमें सदस्यता का वर्णन किया जाएगा। कृपया ध्यान दें कि हम यहां बटनों की सदस्यता नहीं लेंगे, लेकिन केवल window_set_click_config_provider में निर्दिष्ट फ़ंक्शन में। यह इस प्रकार किया जाता है:

 window_set_click_config_provider(window, WindowsClickConfigProvider); 

विंडो पॉइंटर विंडो है, फ़ंक्शन का नाम WindowsClickConfigProvider है। इसे बनाएं:

 void WindowsClickConfigProvider(void *context) { } 

और हम अंदर window_single_click_subscribe तरीकों को जोड़ते हैं , जो बटन का नाम लेते हैं और उस फ़ंक्शन को जिस पर नियंत्रण पारित किया जाएगा:

 window_single_click_subscribe(BUTTON_ID_UP, click); 

इस स्थिति में, जब आप बटन दबाते हैं, तो हम क्लिक कहते हैं।
बटन (हमारे पास उनमें से 3) क्रमशः BUTTON_ID_UP, BUTTON_ID_SELECT, BUTTON_ID_DOWN कहलाते हैं। आप "बैक" बटन की सदस्यता ले सकते हैं, लेकिन यह हमेशा आपको पिछली स्क्रीन पर फेंक देगा (यदि एप्लिकेशन में एक स्क्रीन है - मेनू में)।

अब आवेदन इस तरह दिखता है:


और इसका स्रोत:

 #include "pebble.h" Window *window; /*     */ TextLayer *text_layer; /*      */ static const char* messages[] = {"", " "," "," - ","   ","  - "," "," ","","  - ","  ,   "," ","     ","  ","   ","  ","  - ","  - ","   "," ","",}; /*    */ void click(ClickRecognizerRef recognizer, void *context) /*        */ { text_layer_set_text(text_layer, messages[rand() % 21]); /*        */ } void WindowsClickConfigProvider(void *context) /* ,        */ { window_single_click_subscribe(BUTTON_ID_UP, click); /*       click */ window_single_click_subscribe(BUTTON_ID_SELECT, click); window_single_click_subscribe(BUTTON_ID_DOWN, click); } int main(void) { window = window_create(); /*   */ window_set_background_color(window, GColorBlack); /*    */ window_set_fullscreen(window, true); /*   */ window_stack_push(window, true); /*   */ text_layer = text_layer_create(GRect(0, 7, 144, 168)); /*    */ text_layer_set_text_color(text_layer, GColorWhite); /*    */ text_layer_set_background_color(text_layer, GColorClear); /*    */ text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); /*   */ text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /*     */ layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /*         */ srand(time(NULL)); /*       */ window_set_click_config_provider(window, WindowsClickConfigProvider); /*  ,        */ text_layer_set_text(text_layer, "Magic Pebble \n  ,     \"\"  \"\"    "); /*     */ app_event_loop(); /*   */ text_layer_destroy(text_layer); /*  ,   */ window_destroy(window); /*  ,   */ } 

यह काम करता है! आप संस्करण 0.1 असाइन कर सकते हैं :)
लेकिन कुछ गायब है। कुछ प्रभाव जोड़ना अच्छा होगा। आप उत्तर बदलने का एक एनीमेशन बना सकते हैं ताकि बटन पर क्लिक करने पर घड़ी तुरंत जवाब न दे, लेकिन कई सेकंड के लिए विकल्पों को "हल" कर दिया। उद्धरण चिह्नों में - क्योंकि उत्तर किसी भी मामले में यादृच्छिक होगा, लेकिन पहले मामले में उपयोगकर्ता को आवेदन पर अधिक विश्वास होगा - हम लॉटरी खेलते समय संख्याओं के साथ एक बैग या गेंदों से कार्ड चुनने की यादृच्छिक प्रक्रिया से परिचित हैं।

यदि हम थोड़ा सा भौतिकी जोड़ दें तो यह और भी सुंदर हो जाएगा। तथ्य यह है कि लोग खुद को, इस पर शक किए बिना, एक व्युत्क्रम घातांक पर आगे बढ़ने वाली प्रक्रियाओं से घिरे होते हैं - जब प्रक्रियाएं बहुत शुरुआत में "तेज" होती हैं, तो वे रैखिक रूप से आगे नहीं बढ़ते हैं, लेकिन अधिक गति खोने, शुरुआत से अधिक समय बीत चुका है।
यह कुछ भी हो सकता है - उदाहरण के लिए, मेज पर गर्म चाय का ठंडा होना। जब चाय और आसपास की हवा के बीच तापमान का अंतर बड़ा होता है, तो यह थोड़ा गर्म होने की तुलना में बहुत तेजी से ठंडा होता है। या एक गिलास स्पार्कलिंग पानी में बुलबुले। सबसे पहले, जब पानी में कार्बोनिक एसिड की एकाग्रता अधिक होती है, तो यह बहुत सक्रिय रूप से विघटित हो जाता है, लेकिन थोड़ी देर बाद एकाग्रता कम हो जाती है, और इसके साथ बुलबुले की संख्या कम हो जाती है।
इस मामले में, मैं भाग्य के एक पहिया की तरह कुछ करना चाहूंगा - जहां सेगमेंट पहले एक दूसरे को जल्दी से बदलते हैं, धीरे-धीरे धीमा हो रहे हैं। यहाँ घर्षण "दोषी" है - उच्च गति, जितना अधिक पहिया धुरी के खिलाफ रगड़ता है और जितना अधिक यह ऊर्जा खो देता है, यह गर्मी में अनुवाद करता है और धीमा हो जाता है। लेकिन गति में कमी के साथ, घर्षण नुकसान भी कम हो जाता है - परिणामस्वरूप, पहिया अपनी गति का 50% समय के पहले 20% में खो देता है, और शेष 50% में शेष 50%।

हम संदेश परिवर्तन के बीच मिलीसेकंड में समय की गणना करेंगे। प्रयोगों के माध्यम से, यह पाया गया कि मूल्यों की एक अच्छी सीमा 0 से 300-400ms तक है। यदि अंतराल लंबे होते हैं, तो एक भावना है कि पहले से दिखाया गया उत्तर अचानक बदल गया है।
सबसे सरल कार्य जो इस व्यवहार को प्रदान करता है, वह x = x * 2 जैसा कुछ है। लेकिन जब 2 से गुणा किया जाता है, तो फ़ंक्शन ग्राफ बहुत तेजी से बढ़ता है, प्रत्येक पुनरावृत्ति, विलंब समय दोगुना हो जाता है। हमें 256 (अधिकतम विलंब, अगले मूल्य के बाद से - 512 पहले से ही सुविधा की सीमाओं से परे है) केवल 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 + 256 = 511ms की अवधि के साथ चरण 8 पर पहले से ही है। आधा सेकंड भी तेज है।
जाहिर है, मुझे एहसास हुआ कि गुणक 1.08-1.2 के क्षेत्र में होना चाहिए, फिर हमें लगभग 30 कदम और लगभग 3 सेकंड की अवधि मिलनी चाहिए। लेकिन मुझे फ़ंक्शन x = x * y पसंद नहीं है - यह बहुत खोखला हो जाता है, और झिलमिलाहट बहुत धीरे से धीमा हो जाती है (हां, मैं अजीब हूं), मैं इसे "तेज" लंबे समय तक झिलमिलाहट करना पसंद करूंगा, और फिर अचानक रोक दें।

यह सरल हो सकता था - सरणी में देरी के मूल्य को हथौड़ा करना और उन्हें रगड़ना , उन्हें संतुष्ट करने के लिए संपादित करना, क्योंकि उनमें से बहुत सारे नहीं हैं - लगभग 40 टुकड़े। लेकिन यह एक फ़ंक्शन को प्राप्त करने के लिए बहुत अधिक दिलचस्प है जिस तरह से हमें ज़रूरत होती है। चूंकि गुणन हमें सूट नहीं करता है, हम विभाजन की कोशिश करेंगे। X = x / 0.7 जैसा कुछ। लेकिन अपने आप में यह बहुत तेजी से बढ़ता है - हम पहले ही चरण 18 पर 300 प्राप्त करते हैं, लेकिन मैं थोड़ा अधिक चाहूंगा। लेकिन, उदाहरण के लिए, 100 से या 1000 से विभाजित करना संभव है। आइए हम सभी कार्यों के ग्राफ को प्रारंभिक मूल्य के साथ प्लॉट करते हैं। 1. ग्राफ के ऊपर की संख्या कदमों की संख्या है।

खैर, इसका मतलब है कि y = y / 0.7 x = y / 100 हमारे लिए काफी उपयुक्त है, आप इसे कर सकते हैं।

लेकिन शुरुआत के लिए, हम एक गड़बड़ को ठीक करेंगे: स्टार्टअप और संदेशों की जानकारी एक ही परत में हमारे साथ प्रदर्शित की जाती है, फिर संदेश स्क्रीन के शीर्ष पर दिखाई देते हैं (ऊर्ध्वाधर संरेखण, दुर्भाग्य से, नहीं)। हां, और छोटे प्रिंट में, हालांकि उन्हें और भी अधिक बनाया जा सकता है - वे स्क्रीन पर बहुत छोटे और फिट हैं। मुझे एपीआई में परत को आकार देने के लिए तरीके नहीं मिले, इसलिए हमें परत को हटाना होगा और इसे फिर से बनाना होगा, लेकिन विभिन्न निर्देशांक के साथ। हालांकि, यह बदसूरत निकलेगा - कोड का हिस्सा डुप्लिकेट किया जाएगा (इसके निर्माण के बाद परत सेटिंग्स) ताकि ऐसा न हो - हम एक अलग फ़ंक्शन में कोड का हिस्सा निकाल लेंगे।
हम बनाते हैं:

 void config_text_layer(int16_t x,int16_t y,int16_t h,int16_t w, const char *font_key) { } 

पहले 4 पैरामीटर परत बिंदु निर्देशांक और आकार के बारे में जानकारी हैं, पांचवां पैरामीटर फ़ॉन्ट है। तदनुसार, हम इन चर का उपयोग करने के लिए आरंभीकरण कार्यों को फिर से लिखते हैं:

 text_layer = text_layer_create(GRect(x, y, h, w)); text_layer_set_font(text_layer, fonts_get_system_font(font_key)); 

और बाकी लेयर सेटअप कोड के साथ उन्हें हमारे फंक्शन में डालें। अब आप इसे इस तरह से सही जगह पर कर सकते हैं:

 text_layer_destroy(text_layer); config_text_layer(5, 40, 134, 120, FONT_KEY_GOTHIC_28); 

तो चलिए इसे क्लिक फंक्शन में करते हैं, जिसे बटन क्लिक करने पर हम कहते हैं। हाँ, हर बार बटन दबाए जाने पर एक परत बनाई जाएगी, इससे एक साधारण जाँच से बचा जा सकता है, जैसे कुछ:

 bool first_time=true; if (first_time == true) { text_layer_destroy(text_layer); config_text_layer(5, 40, 134, 120, FONT_KEY_GOTHIC_28); first_time = false; } 

लेकिन मैंने परेशान नहीं किया। बेहतर है कि टाइमर करें। एपीआई में एक खोज ने फ़ंक्शन app_timer_register () दिया , जो एमएस में मान के तर्क के रूप में लेता है जिसके माध्यम से टाइमर काम करेगा, फ़ंक्शन का नाम जिसे ट्रिगर किया जाना चाहिए, और उस फ़ंक्शन के पास होने वाले डेटा के लिए एक सूचक होना चाहिए। दुर्भाग्य से, मुझे समझ में नहीं आया कि मुझे सूचक के साथ कैसे काम करना है, इसलिए मुझे कोड की सुंदरता पर थूकना होगा और इसे एक वैश्विक चर के माध्यम से करना होगा:

 float timer_delay=1; 

हम एक फ़ंक्शन बनाते हैं जो टाइमर को कभी-कभी बढ़ते अंतराल के साथ कॉल करेगा।

 void timer_call() /*       */ { text_layer_set_text(text_layer, messages[rand() % 21]); /*    */ if (timer_delay < 300*100 ) /*      300... */ { timer_delay=timer_delay/0.7; /* ... ... */ app_timer_register(timer_delay/100, timer_call, NULL); /* ...    */ } else /*     300... */ { timer_delay=1; /*       -     */ } } 

फ़ंक्शन का केंद्र एक टाइमर_डेल फ़्लोटिंग पॉइंट चर है। इसे 0.7 तक विभाजित किया जाता है जब तक कि यह 30000 तक नहीं पहुंच जाता है। चर के प्रत्येक नए मूल्य को 100 से विभाजित किया जाता है और देरी फ़ंक्शन app_timer_register को एक तर्क के रूप में दिया जाता है, जो ट्रिगर होने पर, फिर से इस फ़ंक्शन को कॉल करेगा।

यह केवल इस फ़ंक्शन को क्लिक में जोड़ने के लिए बना हुआ है () :

 void click(ClickRecognizerRef recognizer, void *context) /* ,      */ { text_layer_destroy(text_layer); /*      */ config_text_layer(5, 40, 134, 120, FONT_KEY_GOTHIC_28); /*         */ timer_call(); /*       */ } 

और आप परिणाम का आनंद ले सकते हैं:

यदि आप थोड़ा सोचते हैं कि हमने क्या किया, तो यह पता चला कि हमने वास्तविक दुनिया में आरएनजी के रूप में उपयोग किए जाने वाले किसी भी टुकड़े का अनुकरण करने के लिए एक मंच बनाया है। एक गेंद के अंदर एक तरल पदार्थ में एक बहुआयामी आकृति का जटिल आंदोलन एक ऐसी प्रक्रिया है जिसकी भविष्यवाणी नहीं की जा सकती है। साथ ही पासा। वैसे, पासा! एक और आवेदन के लिए एक विकल्प क्या नहीं है?
मैं वास्तव में हड्डियों के किनारों पर चित्र देखने के लिए मिला और भर आया ... नहीं, ठीक है, ये भी चित्र हैं। और पासा पर भी। केवल डॉट्स में नहीं। सामान्य तौर पर, मुझे यह पता चला:


और वह सब है। जब इतना बड़ा विचार है तो क्या पासा है। चलो इसे लागू करते हैं!

सेक्स रूलेट

कार्यक्रम का तर्क वही रहता है। संदेश सरणी बदलें:

 static const char* messages[] = {" "," "," "," "," "," "," "," "," "," "," "," "," "," ","  "," "," "," ","  "," "," "," ","  ",}; 

और स्टार्टअप पर एक संदेश:

 text_layer_set_text(text_layer, "Sex Roulette \n    ,      -->"); 

हम निर्देशांक को इंगित करते हुए ग्राफिक सरणी द्वारा इंगित मेमोरी में बनाते हैं। वाक्य रचना बिल्कुल उसी तरह है जैसे text_layer_create:

 image_layer = bitmap_layer_create(GRect(0 , 0, 144, 144)); 

बनाई गई परत को मुख्य विंडो परत का बच्चा बनाएं। इसकी आवश्यकता क्यों है? यह "ऊंचाई" को समायोजित करता है (सीएसएस के संदर्भ में, अगर कोई समझता है कि यह अन्य परतों के संबंध में परत का z- सूचकांक है), यह इस बात पर निर्भर करता है कि परतें एक-दूसरे को कैसे ओवरलैप करती हैं। सभी बच्चे पूरे माता-पिता से ऊपर हैं और अपने निष्कर्ष के साथ इसे बंद करते हैं।

 layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(image_layer)); 

ब्लेंडिंग मोड सेट करें। इस पैरामीटर के आधार पर, चित्र पृष्ठभूमि के साथ अलग-अलग बातचीत करेगा।

 bitmap_layer_set_compositing_mode(image_layer, GCompOpAssignInverted); 

सभी विकल्पों का वर्णन यहां किया जा सकता है , या आप चित्र में चिपक सकते हैं:

स्रोत इस मामले में एक ग्राफिक परत है, और गंतव्य इसका मूल है, खिड़की की मुख्य परत। मोनोक्रोम चित्रों के साथ काम करते समय यह 6 विकल्पों में कितना सरल और अद्भुत है ...

अब हम यादृच्छिक चित्रों का उत्पादन करने जा रहे हैं। चलो किसी भी क्वेरी जैसे " पोज़ आइकन " के लिए उपयुक्त चित्रों (दो-रंग और छोटे) के लिए Google में देखें।
इस साइट ने यह पाया:

वेक्टर डाउनलोड करें, किसी भी सीमा को हटा दें, उच्च रिज़ॉल्यूशन के साथ पीएनजी को निर्यात करें, इसे किसी प्रकार के ग्राफिक संपादक में खोलें।
हम प्रत्येक तस्वीर का चयन करते हैं, असफल और असंगत लोगों को हटाते हैं, इसे एक वर्ग में दर्ज करते हैं, इसे 144 पिक्सेल तक कम करते हैं, खामियों को साफ करते हैं। हमारे काम का परिणाम चित्रों के साथ एक फ़ोल्डर होना चाहिए:

चित्रों में से एक के लिए हम मेनू के लिए एक लोगो बनाते हैं, आकार में 24x28 पिक्सेल:
->

प्रोजेक्ट फ़ोल्डर में appinfo.json फ़ाइल खोलें और इसमें हमारे बनाए संसाधन जोड़ें। दुर्भाग्य से, मैं यह नहीं बता सकता कि यह CloudPebble में कैसे किया जाता है - इसने अचानक मेरे लिए काम करना बंद कर दिया, पासवर्ड स्वीकार नहीं किया और मेरी सभी परियोजनाओं के स्रोतों को बंद कर दिया। इसलिए मैंने आधिकारिक साइट से निर्देशों के अनुसार कंप्यूटर पर विकास पर्यावरण स्थापित किया, और मैं वहां लिखता हूं।

तो, appinfo.json के बारे में। यह इस तरह दिखता है:

 { "uuid": "0f7b8336-d72d-4806-9191-566ffd8f3a8c", "shortName": "SexRoulette", "longName": "SexRoulette", "companyName": "vvzvlad", "versionCode": 1, "versionLabel": "1.0.0", "watchapp": { "watchface": false }, "appKeys": { "dummy": 0 }, "resources": { "media": [ { "menuIcon": true, "type": "png", "name": "DEFAULT_MENU_ICON", "file": "img/logo.png" }, { "type": "png", "name": "POSE_1", "file": "img/1.png" }, 

शुरुआत में आपके परिचित क्षेत्र हैं, जिनमें से अर्थ बिना स्पष्टीकरण के भी स्पष्ट है, और फिर इसमें सभी 32 चित्रों का वर्णन किया गया है। कृपया ध्यान दें कि संरचना इस तरह से होनी चाहिए:

  { "type": "png", "name": " ", "file": "img/1.png" }, { "type": "png", "name": " ", "file": "img/1.png" } 

अंतिम ब्रैकेट के बाद, कॉमा नहीं होना चाहिए, साथ ही फ़ाइल पते को निर्दिष्ट करने के बाद। और फ़ील्ड प्रकार, नाम, फ़ाइल के क्रम में बिल्कुल पालन करना चाहिए।
यह लानत है, आधिकारिक दस्तावेज के विपरीत है:

क्रैम करने के लिए गधे में कीबोर्ड! मैं उन लोगों को दस्त की किरणें भेजता हूं जिन्होंने यह दस्तावेज लिखा था, मैंने आधे घंटे के लिए बेवकूफ बनाया और सोचा कि वह किस बारे में कोस रहा था। वह इतनी दृढ़ता से शपथ लेता है कि आप वास्तव में यह नहीं समझ पाएंगे कि वह इसे पसंद नहीं करता है:

 Traceback (most recent call last): File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Scripting.py", line 351, in execute return execute_method(self) File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Build.py", line 106, in execute self.execute_build() File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Build.py", line 109, in execute_build self.recurse([self.run_dir]) File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/Pebble/.waf-1.7.11-478a7e7e9ed077304a8092741524bf8b/waflib/Context.py", line 128, in recurse user_function(self) File "/Users/vvzvlad/Documents/PebbleSDK-2.0-BETA2/SexRoulette/wscript", line 18, in build ctx.load('pebble_sdk') 

खैर, उसके साथ नरक करने के लिए। जैसा कि आप पहले से ही समझ चुके हैं, मेनू के लिए चित्र-आइकन "menuIcon" फ़ील्ड के साथ चिह्नित है : सच है , और आप इसे प्रोग्राम से भी एक्सेस कर सकते हैं।

आइये वापस अपनी तस्वीरों पर आते हैं। प्रलेखन इस तरह से छवि अपलोड करने का सुझाव देता है:

 image = gbitmap_create_with_resource(RESOURCE_ID_POSE_1); 

जो हमारे लिए उपयुक्त नहीं है। एक प्रजाति के राक्षसी निर्माण का उपद्रव न करें

 select rand() % 31 case 1 image = gbitmap_create_with_resource(RESOURCE_ID_POSE_1); case 2 image = gbitmap_create_with_resource(RESOURCE_ID_POSE_2); 

यह बदसूरत है। प्रलेखन से हम समझते हैं कि RESOURCE_ID_POSE_2 केवल प्रकार uint32_t का एक चर है जिसमें संसाधन संख्या संग्रहीत है।

हम अपनी आवश्यकता के प्रकार का एक सरणी बनाते हैं:

 static const uint32_t images[] 

और हम इसमें उन संसाधनों को सूचीबद्ध करते हैं जिनकी हमें आवश्यकता है:

 static const uint32_t images[] = {RESOURCE_ID_POSE_1,RESOURCE_ID_POSE_2,RESOURCE_ID_POSE_3,RESOURCE_ID_POSE_4,RESOURCE_ID_POSE_5,RESOURCE_ID_POSE_6,RESOURCE_ID_POSE_7,RESOURCE_ID_POSE_8,RESOURCE_ID_POSE_9,RESOURCE_ID_POSE_10,RESOURCE_ID_POSE_11,RESOURCE_ID_POSE_12,RESOURCE_ID_POSE_13,RESOURCE_ID_POSE_14,RESOURCE_ID_POSE_15,RESOURCE_ID_POSE_16,RESOURCE_ID_POSE_17,RESOURCE_ID_POSE_18,RESOURCE_ID_POSE_19,RESOURCE_ID_POSE_20,RESOURCE_ID_POSE_21,RESOURCE_ID_POSE_22,RESOURCE_ID_POSE_23,RESOURCE_ID_POSE_24,RESOURCE_ID_POSE_25,RESOURCE_ID_POSE_26,RESOURCE_ID_POSE_27,RESOURCE_ID_POSE_28,RESOURCE_ID_POSE_29,RESOURCE_ID_POSE_30,RESOURCE_ID_POSE_31,RESOURCE_ID_POSE_32,}; 

अब हम उसी तरह से एक यादृच्छिक तस्वीर को पाठ के रूप में कह सकते हैं:

 image = gbitmap_create_with_resource(images[rand() % 31]); 

हमने फ्लैश मेमोरी से नोक्सिस्टेंस की एक तस्वीर को कॉल किया और इसे रैम में रखा। अब हमें छवि फ़ंक्शन बिटमैप_लेयर_सेट_बिटमैप के भंडारण स्थान पर एक पॉइंटर पास करने की आवश्यकता है, जो इसे वांछित ग्राफिक परत पर प्रदर्शित करेगा।
यह इस प्रकार किया जाता है:

 bitmap_layer_set_bitmap(image_layer, image); 

image_layer ग्राफिक्स लेयर में मेमोरी के एक टुकड़े के लिए एक पॉइंटर है, और इमेज मेमोरी में एक पिक्चर के लिए एक पॉइंटर है।
सब कुछ पसंद है। भागो!

घड़ी ने लटका दिया, फिर रिबूट किया, और दूसरी शुरुआत के बाद, वे रिकवरी में गए और अपग्रेड करने के लिए कहा।
यह सही है, हम, प्रत्येक चक्र में एक तस्वीर को मेमोरी में लोड कर रहे हैं, इसे वहां से उतारना नहीं है। उन्होंने रैम को स्कोर किया, और घड़ी को लोड करने से इनकार कर दिया।
यह स्पाआर्टा है! embeeeeedded! वे इसे माफ नहीं करते।
हम इसे सही करते हैं। , .

 gbitmap_destroy(image); image = gbitmap_create_with_resource(images[rand() % 31]); bitmap_layer_set_bitmap(image_layer, image); 

image , gbitmap_destroy . App Crashed…
, , - . , - . :

 bool first_time=true; 

, :

 void timer_call() { first_time = false; 

gbitmap_destroy — first_time == false, text_layer_destroy config_text_layer click — , first_time == true:

 void timer_call() { if (first_time == false) { gbitmap_destroy(image); bitmap_layer_destroy(image_layer); } first_time = false; ..... void click(ClickRecognizerRef recognizer, void *context) { if (first_time == true) { text_layer_destroy(text_layer); config_text_layer(0, 146, 144, 168-146, FONT_KEY_GOTHIC_18); } 

यह काम करता है!


, . :

  text_layer_destroy(text_layer); window_destroy(window); gbitmap_destroy(image); bitmap_layer_destroy(image_layer); 

gbitmap. , ! , — . . — , :

 if (first_time == false) { gbitmap_destroy(image); } 

.
?! .

. . 7575 :

appinfo.json, , images:

 static const uint32_t images[] = {RESOURCE_ID_DICE_1,RESOURCE_ID_DICE_2,RESOURCE_ID_DICE_3,RESOURCE_ID_DICE_4,RESOURCE_ID_DICE_5,RESOURCE_ID_DICE_6,}; 

: WindowsClickConfigProvider click . , ! .

:

 accel_tap_service_subscribe(accel_int); 

, :

 void accel_int(AccelAxisType axis, int32_t direction) { if (first_time == true) { text_layer_destroy(text_layer); } timer_call(); } 

: ( ) — . — :) .

timer_call . ( , — 144144, ), . — . rand . 7575 144168. , , , 0...69(144-75) -, 0...93(168-75) y-. : rand()%(144-75) rand()%(168-75) . :

 image_layer = bitmap_layer_create(GRect(rand()%(144-75), rand()%(168-75), 75, 75)); 

:

 if (timer_delay < 300*1000 ) { timer_delay=timer_delay/0.7; app_timer_register(timer_delay/1000, timer_call, NULL); } 

100, — 1000. . , , . , — , , — , .

, . : , . . , API :

 light_enable(bool enable) light_enable_interaction() 

. . : l ight_enable(true) light_enable(false) , — , ( ). ( , ?), . - timer_call .
— main :

 text_layer_set_text(text_layer, "    "); 

:

 if (first_time == true) { text_layer_destroy(text_layer); } else { bitmap_layer_destroy(image_layer); gbitmap_destroy(image); } accel_tap_service_unsubscribe(); 

. — , . — , — , — accel_int



यह काम करता है!


, :

संदर्भ

MagicPebble mypebblefaces.com
- mypebblefaces.com
mypebblefaces.com
MagicPebble github.com
- github.com
github.com
, Pebble , . ( « pebble »). , — .