सही मल्टीटच आईडी वापस करना


9

मैंने ट्यूटोरियल पढ़ने और मल्टीटच से संबंधित हर सवाल को देखने के लिए अनगिनत घंटे बिताए हैं। लेकिन मैं अभी यह पता नहीं लगा सकता कि यह कैसे सही ढंग से किया जाए। मैं अपना पाने के लिए एक लूप का उपयोग करता हूं pointerId, मुझे ऐसा करने वाले बहुत से लोग दिखाई नहीं देते हैं, लेकिन इसका एकमात्र तरीका है कि मैं इसे कुछ हद तक काम करने में कामयाब रहा हूं।

मेरी स्क्रीन पर दो जॉयस्टिक्स हैं, एक हिलाने के लिए और दूसरा मेरे स्प्राइट्स रोटेशन को नियंत्रित करने के लिए और वह जिस शूट को शूट करता है, जैसे मॉन्स्टर शूटर में। ये दोनों काम ठीक हैं।

मेरी समस्या है जब मैं इम शूटिंग के रूप में एक ही समय में मेरी स्प्राइट ले जाएँ, मेरी वह यह है कि touchingPointमेरे आंदोलन के लिए के लिए सेट है touchingPointमेरी शूटिंग के, के बाद से xऔर yपर अधिक है touchingPoint(मेरी शूटिंग के moving-stickस्क्रीन के बाईं ओर पर, shooting-stickदाईं ओर) , मेरे स्प्राइट की गति बढ़ जाती है, इससे मेरे स्प्राइट की गति में एक अवांछित परिवर्तन होता है।

यह मैंने आपकी मदद से इसे हल किया है! यह किसी के लिए भी है जो एक समान समस्या में भाग सकता है:

    public void update(MotionEvent event) {
    if (event == null && lastEvent == null) {
        return;
    } else if (event == null && lastEvent != null) {
        event = lastEvent;
    } else {
        lastEvent = event;
    }   

        int action = event.getAction();
        int actionCode = action & MotionEvent.ACTION_MASK;
        int pid = action >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
        int x = (int) event.getX(pid);
        int y = (int) event.getY(pid); 
        int index = event.getActionIndex();
        int id = event.getPointerId(index);
        String actionString = null;


        switch (actionCode)
        {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_POINTER_DOWN:

                actionString = "DOWN";
                try{
                    if(x > 0 && x < steeringxMesh + (joystick.get_joystickBg().getWidth() * 2)
                            && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()){
                            movingPoint.x = x;
                            movingPoint.y = y;
                            dragging = true;
                            draggingId = id;

                        }
                    else if(x > shootingxMesh - (joystick.get_joystickBg().getWidth()) && x < panel.getWidth()
                            && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()){
                            shootingPoint.x = x;
                            shootingPoint.y = y;
                            shooting=true;
                            shootingId=id;
                        }
                    }catch(Exception e){

                    }
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_OUTSIDE:            
                if(id == draggingId)
                    dragging = false;
                if(id ==  shootingId)
                    shooting = false;
                actionString = "UP";
                break;  
            case MotionEvent.ACTION_MOVE:           
                for(index=0; index<event.getPointerCount(); index++) {
                    id=event.getPointerId(index);
                    int xx = (int) event.getX(index); //pro naming of variable
                    int yy = (int) event.getY(index); 
                    if(dragging && id == draggingId) {
                        if(xx > 0 && xx < (steeringxMesh + joystick.get_joystickBg().getWidth() * 2)
                            && yy > yMesh - (joystick.get_joystickBg().getHeight()) && yy < panel.getHeight()) {
                            movingPoint.x = xx;
                            movingPoint.y = yy;
                        }
                        else
                            dragging = false;
                        }
                    if(shooting && id == shootingId){
                        if(xx > shootingxMesh - (joystick.get_joystickBg().getWidth()) && xx < panel.getWidth()
                            && yy > yMesh - (joystick.get_joystickBg().getHeight()) && yy < panel.getHeight()) {
                            shootingPoint.x = xx;
                            shootingPoint.y = yy;                            
                        }
                        else
                            shooting = false;
                        }
                    }

                    actionString = "MOVE";
                    break;

        }
    Log.d(TAG, "actionsString: " + actionString + ", pid: " + pid + ", x: " + x + ", y: " + y);

अगर मैं गलत काम कर रहा हूं, तो मुझे एक बहुत नुकसान नहीं होगा, अगर मैं इस कोड को पोस्ट नहीं करूंगा। मैं बस एक अच्छी समझ नहीं पा सकता हूं कि मल्टीटचिंग कैसे काम करता है।

movingPointमेरी पहली और दूसरी उंगली दोनों के लिए बुनियादी तौर पर परिवर्तन। मैं इसे एक बॉक्स में बांधता हूं, लेकिन जब तक मैं इस बॉक्स के भीतर एक उंगली पकड़ता हूं, यह मेरी दूसरी उंगली को छूने के आधार पर इसके मूल्य को बदल देता है। यह सही दिशा में आगे बढ़ता है और कुछ भी त्रुटि नहीं देता है, समस्या गति-परिवर्तन है, लगभग इसकी तरह यह दो टचपॉइंट जोड़ता है।

जवाबों:


4

मुझे लगता है कि यह आपके लिए काम करेगा।

आपके द्वारा की गई एक गलती हर घटना के लिए सभी बिंदुओं पर चलने वाली थी। यह केवल चाल घटनाओं के लिए आवश्यक है।

दूसरे, आपको वास्तव में इंडेक्स वैल्यू को गेटएक्स और गेटी फ़ंक्शंस में डालने की ज़रूरत है, लेकिन आपको अपने गेम ऑब्जेक्ट्स के संदर्भ के रूप में उपयोग करने के लिए उस इंडेक्स से जुड़ी आईडी मिलती है। आप डाउन ईवेंट के दौरान अपने जॉयस्टिक को एक आईडी असाइन करते हैं और फिर अपने पॉइंटर सूचकांकों के माध्यम से पुनरावृत्ति करते हैं, तो जांचते हैं कि इंडेक्स पॉइंटर आईडी के साथ जुड़ा हुआ है जिसे आपने डाउन इवेंट के दौरान जॉयस्टिक को सौंपा था। यदि यह है, तो जांचें कि क्या यह अभी भी सीमा में है और या तो इसे अपडेट करें या इसे अक्षम करें।

मैं इस कोड का परीक्षण नहीं कर रहा हूं, लेकिन मुझे पता है कि यह अवधारणा में काम करता है क्योंकि मैं अपने कोड में विधि का उपयोग करता हूं। मुझे बताएं कि क्या इसके साथ कोई समस्या है जिसे आप समझ नहीं सकते।

सबसे पहले, आपको अपने जॉयस्टिक वर्ग में निम्नलिखित जोड़ना होगा।

boolean dragging=false;
int draggingId;
boolean shooting=false;
int shootingId;

अपने onTouchEvent को इसमें बदलें।

public boolean onTouchEvent(MotionEvent event) {


    int index = event.getActionIndex();
    int id = event.getPointerId(index);
    String actionString;

    switch (event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
            try{
                    if(x > 0 && x < steeringxMesh + joystick.get_joystickBg().getWidth() * 2)
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()
                        && !joystick.dragging) {
                            movingPoint.x = x;
                            movingPoint.y = y;
                            joystick.dragging = true;
                            joystick.draggingId = id;
                    }
                    else if(x > shootingxMesh - (joystick.get_joystickBg().getWidth()) && x < panel.getWidth()
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()
                        && !joystick.shooting) { 
                            shootingPoint.x = x;
                            shootingPoint.y = y;
                            joystick.shooting=true;
                            joystick.shootingId=id;
                    }
              }
              catch(Exception e){

              }

            actionString = "DOWN";
            break;
        case MotionEvent.ACTION_UP:
            if(id == draggingID)
                joystick.dragging = false;
            if(id ==  shootingID)
                joystick.shooting = false;
            actionString = "UP";
            break;  
        case MotionEvent.ACTION_POINTER_DOWN:
            try{
                    if(x > 0 && x < steeringxMesh + joystick.get_joystickBg().getWidth() * 2)
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()
                        && !joystick.dragging) {
                            movingPoint.x = x;
                            movingPoint.y = y;
                            joystick.dragging = true;
                            joystick.draggingId = id;
                    }
                    else if(x > shootingxMesh - (joystick.get_joystickBg().getWidth()) && x < panel.getWidth()
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()
                        && !joystick.shooting) { 
                            shootingPoint.x = x;
                            shootingPoint.y = y;
                            joystick.shooting=true;
                            joystick.shootingId=id;
                    }
              }
              catch(Exception e){

              }

            actionString = "PNTR DOWN";
            break;
        case MotionEvent.ACTION_POINTER_UP:
            if(id == joystick.draggingID)
                joystick.dragging = false;
            if(id ==  joystick.shootingID)
                joystick.shooting = false;
            actionString = "PNTR UP";
            break;
        case MotionEvent.ACTION_CANCEL:
            if(id == joystick.draggingID)
                joystick.dragging = false;
            if(id ==  joystick.shootingID)
                joystick.shooting = false;
            actionString = "CANCEL";
            break;
        case MotionEvent.ACTION_MOVE:
            for(index=0; index<e.getPointerCount(); index++) {
                id=e.getPointerId(index);
                int x = (int) event.getX(index);
                int y = (int) event.getY(index); 
                if(joystick.dragging && id == joystick.draggingId) {
                    if(x > 0 && x < steeringxMesh + joystick.get_joystickBg().getWidth() * 2)
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()) {
                        movingPoint.x = x;
                        movingPoint.y = y;
                    }
                    else
                        dragging = false;
                    }
                }
                else if(joystick.shooting && id == joystick.shootingId){
                    if(x > shootingxMesh - (joystick.get_joystickBg().getWidth()) && x < panel.getWidth()
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()) {
                        shootingPoint.x = x;
                        shootingPoint.y = y;                            
                    }
                    else
                        shooting = false;
                    }
                }
            }
            actionString = "MOVE";
            break;
        }
    }

आप सर, मेरे हीरो हैं। मैं अपने प्रश्न में अद्यतन कोड जोड़ूंगा ताकि आप देख सकें कि मैंने आपकी मदद से इसे कैसे हल किया! अब मैं अंत में अपना खेल समाप्त कर सकता हूं: D
Green_qaue

7

आप इसे लगभग सही कर रहे हैं, लेकिन आपको इसके बजाय X / Y का अनुरोध करने के लिए अपनी सूचक आईडी का उपयोग करना चाहिए i

    int id = event.getPointerId(i);
    int x = (int) event.getX(id);
    int y = (int) event.getY(id);

गति दस्तावेज से:

एक गति घटना के भीतर व्यक्तिगत संकेत दिखाई देने वाला क्रम अपरिभाषित है। इस प्रकार एक पॉइंटर का पॉइंटर इंडेक्स एक घटना से दूसरे में बदल सकता है लेकिन पॉइंटर की पॉइंटर आईडी को स्थिर रहने की गारंटी दी जाती है जब तक कि पॉइंटर सक्रिय रहता है। एक इशारे में सभी बाद की गति घटनाओं में इसे ट्रैक करने के लिए एक पॉइंटर की सूचक आईडी प्राप्त करने के लिए getPointerId (int) विधि का उपयोग करें। फिर क्रमिक गति घटनाओं के लिए, उस गति घटना में दिए गए सूचक आईडी के लिए सूचक सूचकांक प्राप्त करने के लिए findPointerIndex (int) विधि का उपयोग करें।

event.getX/Yएक पॉइंटर आईडी की आवश्यकता होती है i, इसलिए नहीं , क्योंकि कोई समान नहीं है , वे उसी क्रम में होंगे।

इसके अलावा, एक और सूक्ष्म लेकिन महत्वपूर्ण समस्या है। ध्यान दें कि फ़ंक्शन का getAction () परिवार एक पैरामीटर नहीं लेता है। यह अजीब तरह का है, है ना? X / Y प्राप्त करने के लिए पॉइंटर आईडी की आवश्यकता होती है, लेकिन कार्रवाई नहीं की जाती है? यह कुछ महत्वपूर्ण बातों पर इशारा कर रहा है:

  • आपको प्रत्येक पॉइंटर की प्रत्येक क्रिया के लिए आपको हैंडलर छूने के लिए कॉल मिलता है और सभी पॉइंटर्स के लिए प्रति फ्रेम एक कॉल नहीं
  • getX / Y पॉइंटर के ट्रेस को अब तक देखता है और नवीनतम मान लौटाता है, जबकि getAction केवल वर्तमान ईवेंट के बारे में पूछताछ करता है

तो इसका मतलब है कि आपको प्रति पॉइंटर एक्शन (डाउन / मूव / अप) के लिए आपके टच हैंडलर को एक कॉल मिलेगा । तो दो उंगलियाँ हिलना = 2 कॉल। आपके कोड का एक बुरा दुष्प्रभाव यह है कि यह एक घटना की कार्रवाई को सभी बिंदुओं पर लागू करता है ...

इसलिए, निशान के ऊपर लूप करने के बजाय, बस वर्तमान घटना के लिए पीआईडी ​​/ एक्स / वाई / एक्शन प्राप्त करें (एक साथ आंदोलन के लिए, आपको अपने हैंडलर को थोड़ा बाद में एक और कॉल मिलेगा, जैसे मैंने कहा था)

घटनाओं को संभालने के लिए यहाँ मेरा कोड है:

 public static boolean sendTouchToGameEngine (MotionEvent event)
 {
  int action = event.getAction();
  int actionCode = action & MotionEvent.ACTION_MASK;
  int pid = action >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;

  [...]
  sendTouchToGameEngine(pid, actionCode, (int)event.getX(pid), (int)event.getY(pid));
  [...]

  return true;

}

अपने कोड पर वापस जाने के लिए, आपको निम्नलिखित तरीके से इसे सरल बनाने में सक्षम होना चाहिए। लूप चला गया है, अन्यथा, यदि आपके पास अन्य विरोधाभास हैं जिनका आपने उल्लेख नहीं किया है, तो आप हमेशा इसे वापस जोड़ सकते हैं। यह ट्रैक करके काम करता है कि किस सूचक आईडी का उपयोग किस नियंत्रण (चाल / शूट) के लिए किया जाता है जब DOWN को ट्रिगर किया जाता है और उन्हें UP पर रीसेट किया जाता है। चूंकि आप इशारों का उपयोग नहीं करते हैं, आप अपने स्विच () को DOWN, UP, MOVE और OUTSIDE तक सीमित कर सकते हैं।

int movePointerId = -1;
int shootingPointerId = -1;

void TouchEventHandler(MotionEvent event) {   
    // grab the pointer id 
    int pid = action >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
    int x = (int) event.getX(pid);
    int y = (int) event.getY(pid); 
    int action = event.getAction();
    int actionCode = action & MotionEvent.ACTION_MASK;
    int actionIndex = event.getActionIndex();
    String actionString;


    switch (actionCode)
    {
        case MotionEvent.ACTION_DOWN:
        // on DOWN, figure out whether the player used the moving or shooting control, if any.
        // if so, kept track of which pointer was used, because all following call about that
        // finger touches will use the same pointer id. Also record the current point coordinates.
            actionString = "DOWN";
            try{
                if(x > 0 && x < steeringxMesh + (joystick.get_joystickBg().getWidth() * 2)
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()){
                        movingPoint.x = x;
                        movingPoint.y = y;
                        movePointerId = pid;
                    }
                else if(x > shootingxMesh - (joystick.get_joystickBg().getWidth()) && x < panel.getWidth()
                        && y > yMesh - (joystick.get_joystickBg().getHeight()) && y < panel.getHeight()){
                        shootingPoint.x = x;
                        shootingPoint.y = y;
                        shootingPointerId = pid;
                    }
                }catch(Exception e){

                }
            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_OUTSIDE:
        // whether the player lift the finger or moves it out of bounds
        // figure out which pointer that was and reset it. You can add additional
        // processing here as required
           if( pid == movePointerId )
              movePointerId = -1;
           else if( pid == shootingPointerId )
              shootingPointerId = -1;
            actionString = "UP";
            break;  
        case MotionEvent.ACTION_MOVE:
        // when the player move their finger, it is simply a matter of comparing the pid
        // to know which one it is
          if( pid == movePointerId ) {
                        movingPoint.x = x;
                        movingPoint.y = y;
          } else if( pid == shootingPointerId ) {
                        shootingPoint.x = x;
                        shootingPoint.y = y;
          }
                actionString = "MOVE";

    }
}

इस महान जवाब के लिए धन्यवाद, वास्तव में कुछ चीजों को साफ करता है। क्या आप बता सकते हैं कि यह रेखा क्या sendTouchToGameEngine(pid, actionCode, (int)event.getX(pid), (int)event.getY(pid));करती है और जब आप इसे कहते हैं?
ग्रीन_काऊ

यह भी जब मैं इस लाइन का उपयोग करता हूं: int pid = action >> MotionEvent.ACTION_POINTER_ID_SHIFT;ग्रहण मुझे सुपरसर्वरिंग जोड़ने के लिए कहता है, क्या यह सामान्य है? इतने विस्तृत उत्तर के बाद सभी प्रश्नों के लिए क्षमा करें। MotionEvent मेरे लिए बहुत नया है, और किसी कारण से तर्क को समझ नहीं सकते हैं
Green_qaue

जोड़ा गया अद्यतन कोड, जैसा कि आप देख सकते हैं कि मैं वास्तव में नहीं जानता कि क्या करना है pid, और लूप अभी भी है, इसके बिना काम नहीं करेगा, क्योंकि मुझे प्राप्त करने की आवश्यकता है i
Green_qaue

@Max: sendTouchToGameEngine अगले अपडेट के दौरान संसाधित होने के लिए मेरे गेम इंजन कतार में इस ईवेंट को जोड़ने के लिए बस एक कॉल है। यदि आप अपने इनपुट ईवेंट को प्रदूषित करने के लिए एक कतार का उपयोग नहीं करते हैं, तो आप अप्रत्याशित तरीके से गेम इंजन की स्थिति के साथ अपने कॉलिंग फ़ंक्शन के जोखिम को चलाते हैं, क्योंकि टचवेट UI थ्रेड से आता है और, संभवतः, आपका गेम इंजन अपडेट एक अलग धागे में चलाता है
एडीबी

@ मोम: मैं दुर्भाग्य से चेतावनी के बारे में नहीं जानता। क्या आप हमें बता सकते हैं कि यह कौन सा है?
एडीबी

0

इस कोड के साथ थोड़ा अजीब चल रहा है। मैं एंड्रॉइड का उपयोग नहीं करता हूं, इसलिए शायद मैं सोच रहा हूं कि यह कुछ ऐसा है जो नहीं है। हालाँकि मैंने नोटिस किया कि आप दो बार अलग-अलग तरीकों से दो बार मिल रहे हैं:

पहले आप इसे अपने pointerCountलूप की शुरुआत में इस तरह प्राप्त करें :

(int) event.getX(i)

फिर, आपके स्विच स्टेटमेंट के अंदर आपको ऐसा मिलता है:

(int) event.getX(id)

ध्यान दें कि आप उपयोग iकरने से स्विच करते हैं id

मैं मान रहा हूं कि यह पूर्व पद्धति है। मैं सभी उदाहरणों को बदलने की सलाह देता हूं (int) event.getX(id)और xशुरुआत में आपके द्वारा निर्धारित मूल्य का उपयोग करता हूं। इसी तरह अदला-बदली (int) event.getY(id)करना y

इन भागों की अदला-बदली का प्रयास करें:

int pointerCount = event.getPointerCount(); 
for (int i = 0; i < pointerCount; i++)
{       
    int x = (int) event.getX(i);
    int y = (int) event.getY(i);

फिर अपने स्विच के अंदर इसका उपयोग करें:

    try{
        if(x > 0 && x < touchingBox &&
              y > touchingBox && y < view.getHeight()){
            movingPoint.x = x;
            movingPoint.y = y;
            dragging = true;
        }
        else if(x > touchingBox && x < view.getWidth() &&
                   y > touchingBox && y < view.getHeight()){
            shootingPoint.x = x;
            shootingPoint.y = y;
            shooting=true;
        }else{
            shooting=false;
            dragging=false;
        }

2
इस पर टिप्पणी करने के लिए कि यह उपयोगी क्यों नहीं है और एक नीच के योग्य है? यह विनम्र बात है।
MichaelHouse

सहमत, अगर आप नीचे वोट करते हैं। उसे जाने क्यों। आप एक पूर्व विधि से सही हैं। Ive ने लगभग एक लाख अलग-अलग चीजों की कोशिश की इसलिए मैं इसे हटाना भूल गया।
Green_qaue

क्या आप इसे प्रतिबिंबित करने के लिए अपने प्रश्न में कोड अपडेट कर सकते हैं? मैं आप में से सेटिंग निकाल देखने xऔर y, लेकिन आप अभी से स्थिति हो रही है idबाद में।
MichaelHouse

आह, मुझे आपका उत्तर समझने में थोड़ा समय लगा। लेकिन यह कैसे काम करेगा? अगर मैं एक ही चर का उपयोग करता हूं ( x=event.getX(i)), तो x2 मानों को स्टोर करना होगा जब भी pointerCountअधिक हो तो 1, सही? और वह डसेंट सही लगता है।
ग्रीन_काउ

1
जो मैं समझता हूं, eventवह वास्तव में घटनाओं की सूची है। आप सूची के माध्यम से अलग-अलग घटनाओं तक पहुंचते हैं जैसे आप कर रहे हैं। इसलिए xआपके द्वारा उपयोग की जाने वाली दूसरी घटना के लिए स्थिति तक पहुंचने के लिए event.getX(1)(क्योंकि हम 0 से शुरू कर रहे हैं)। एकाधिक xs हैं, आप पैरामीटर का उपयोग यह बताने के लिए कर रहे हैं कि आपको क्या चाहिए। आप अपने forलूप के साथ सभी घटनाओं के माध्यम से लूप कर रहे हैं, इसलिए उस नंबर का उपयोग करें जिस वर्तमान इवेंट में आप रुचि रखते हैं। मेरा कोड परिवर्तन सुझाव देखें।
MichaelHouse

0

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

मेरी खराब इंग्लिश के लिए माफ़ कीजिये


यह समस्या नहीं है
Green_qaue

ठीक है, सिर्फ एक विचार था
मार्को मार्टिनली

0

मेरा मानना ​​है कि आपकी समस्या यह है कि आप यह मान रहे हैं कि अपडेट के बीच, जिस क्रम में पॉइंटर्स की व्यवस्था की जाती है, वही रहता है। यही कारण है कि सबसे अधिक संभावना नहीं मामले में हो रहा है।

ऐसी स्थिति की कल्पना करें जहां आप उंगली से स्पर्श करते हैं। ए 1 का पॉइंटरकाउंट () होगा, और ए एकमात्र तत्व होगा जिसके बारे में आप पूछ सकते हैं। यदि आप दूसरी उंगली जोड़ते हैं, तो पॉइंटरकाउंट () 2 होगा, ए इंडेक्स 0 पर होगा, बी इंडेक्स 1 पर होगा। यदि आप उंगली ए बढ़ाते हैं, तो पॉइंटरकाउंट () 1 फिर से होगा, और बी इंडेक्स 0 पर होगा। । यदि आप फिर उंगली ए के साथ फिर से स्पर्श करते हैं, तो ए 1 इंडेक्स में होगा और बी इंडेक्स 0 पर होगा

यही कारण है कि पॉइंटर आईडी प्रदान की जाती है, ताकि आप अपडेट के बीच व्यक्तिगत टच को ट्रैक कर सकें। इसलिए यदि फिंगर बी का पहला स्पर्श आईडी 12 को सौंपा गया है, तो हमेशा उस आईडी के पास होगा, जब उंगली ए को हटा दिया जाता है और फिर से जोड़ा जाता है।

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

यहां तक ​​कि अगर एक जॉयस्टिक के पास शुरू होने वाला स्पर्श मूल स्पर्श स्थिति से बहुत दूर निकलता है, तो इसकी आईडी से आप अभी भी सही ढंग से पहचान सकते हैं कि यह जो जॉयस्टिक को नियंत्रित कर रहा है। और एक अच्छा साइड इफेक्ट के रूप में, एक विशेष जॉयस्टिक के पास एक दूसरी आवारा उंगली का कोई प्रभाव नहीं होगा, क्योंकि जॉयस्टिक पहली उंगली के लिए बाध्य होगा जो इसे रिलीज होने तक ट्रिगर कर देगा।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.