कंट्रोलर की अन्य सुविधाएं

गेम कंट्रोलर में अतिरिक्त सुविधाएं होती हैं. इनसे, गेम खेलने वाले लोगों को गेम में ज़्यादा दिलचस्पी मिलती है और वे बेहतर तरीके से इंटरैक्ट कर पाते हैं. Android गेम कंट्रोलर की हैप्टिक, मोशन सेंसर, और लाइट की सुविधाएं, गेमिंग के अनुभव को बेहतर बनाने में अहम भूमिका निभाती हैं. हर सुविधा, खिलाड़ी की इंद्रियों को अलग-अलग तरीके से उत्तेजित करती है. इससे गेम में ज़्यादा दिलचस्प और सहज इंटरैक्शन को बढ़ावा मिलता है.

हैप्टिक

Android गेम कंट्रोलर में हैप्टिक की सुविधा एक अहम टेक्नोलॉजी है. यह गेमप्ले के दौरान, असली जैसा स्पर्श वाला फ़ीडबैक देती है.

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

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

Kotlin

fun triggerVibrationMultiChannel(
  deviceId: Int, leftIntensity: Int, leftDuration: Int,
  rightIntensity: Int, rightDuration: Int) {
  val inputDevice = InputDevice.getDevice(deviceId)
  val vibratorManager = inputDevice!!.vibratorManager
  if (vibratorManager != null) {
    val vibratorIds = vibratorManager.vibratorIds
    val vibratorCount = vibratorIds.size
    if (vibratorCount > 0) {
      // We have an assumption that game controllers have two vibrators
      // corresponding to a left motor and a right motor, and the left
      // motor will be first.
      updateVibrator(vibratorManager.getVibrator(vibratorIds  [0]), leftIntensity, leftDuration)
      if (vibratorCount > 1) {
        updateVibrator(vibratorManager.getVibrator(vibratorIds[1]), rightIntensity, rightDuration)
      }
    }
  }
}

fun updateVibrator(vibrator: Vibrator?, intensity: Int, duration: Int) {
  if (vibrator != null) {
    if (intensity == 0) {
      vibrator.cancel()
    } else if (duration > 0) {
      vibrator.vibrate(VibrationEffect.createOneShot(duration.toLong(), intensity))
    }
  }
}

Java

public void triggerVibrationMultiChannel(
    int deviceId, int leftIntensity, int leftDuration,
    int rightIntensity, int rightDuration) {

    InputDevice inputDevice = InputDevice.getDevice(deviceId);

    // Check if device exists to avoid NullPointerException
    if (inputDevice == null) {
      return;
    }

    VibratorManager vibratorManager = inputDevice.getVibratorManager();
    if (vibratorManager != null) {
        int[] vibratorIds = vibratorManager.getVibratorIds();
        int vibratorCount = vibratorIds.length;

        if (vibratorCount > 0) {
            // We have an assumption that game controllers have two vibrators
            // corresponding to a left motor and a right motor, and the left
            // motor will be first.
            updateVibrator(vibratorManager.getVibrator(vibratorIds[0]), leftIntensity, leftDuration);

            if (vibratorCount > 1) {
                updateVibrator(vibratorManager.getVibrator(vibratorIds[1]), rightIntensity, rightDuration);
            }
        }
    }
}

public void updateVibrator(Vibrator vibrator, int intensity, int duration) {
    if (vibrator != null) {
        if (intensity == 0) {
            vibrator.cancel();
        } else if (duration > 0) {
            vibrator.vibrate(VibrationEffect.createOneShot. ((long) duration, intensity));
        }
    }
}

वाइब्रेट करने की सुविधा का इस्तेमाल करने के लिए, यह कुकी एक सुविधा और अनुमति सेट करती है.

<application ...>
  ...
  <uses-feature android:name="android.hardware.gamepad" android:required="true"/>
  <uses-permission android:name="android.permission.VIBRATE"/>
  ...
</application>

ध्यान दें: android:hardware:gamepad की सुविधा उपलब्ध होने की जानकारी देते समय, android:required एट्रिब्यूट की वैल्यू true पर सेट न करें. ऐसा करने पर, उपयोगकर्ता डिवाइस पर आपका ऐप्लिकेशन इंस्टॉल नहीं कर पाएंगे.

VibratorManager और ऐप्लिकेशन मेनिफ़ेस्ट के बारे में ज़्यादा जानें.

मोशन सेंसर

गेम खेलने के अनुभव को बेहतर बनाने वाली सबसे नई टेक्नोलॉजी में से एक है, मोशन सेंसर से लैस Android गेम कंट्रोलर. यह टेक्नोलॉजी, उपयोगकर्ताओं की शारीरिक गतिविधियों का सटीक पता लगाती है. साथ ही, उस डेटा को गेम में होने वाली कार्रवाइयों में बदलती है. इससे गेम खेलने का अनुभव ज़्यादा सहज और दिलचस्प हो जाता है. इस जानकारी में, हम जानेंगे कि Android गेम कंट्रोलर में मोशन सेंसर की सुविधाएं कैसे काम करती हैं.

मोशन सेंसर में आम तौर पर, जाइरोस्कोप और एक्सलरोमीटर शामिल होते हैं. इनसे उपयोगकर्ताओं की गतिविधियों और ओरिएंटेशन का पता चलता है.

इसे ऐक्सलरेशन और जायरोस्कोप लिसनर क्लास लागू करनी होंगी. साथ ही, इन लिसनर को कंट्रोलर के सेंसर मैनेजर के साथ रजिस्टर करना होगा.

Kotlin

fun setIntegratedAccelerometerActive(deviceId: Int) {
  val device = InputDevice.getDevice(deviceId)
  val sensorManager = device?.sensorManager
  val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
  if (accelerometer != null) {
    val accelerometerListener =
      GameControllerAccelerometerListener(accelerometer)
    sensorManager.registerListener(
      accelerometerListener, accelerometer,
      SensorManager.SENSOR_DELAY_GAME
    )
  }
}

fun setIntegratedGyroscopeActive(deviceId: Int) {
  val device = InputDevice.getDevice(deviceId)
  val sensorManager = device?.sensorManager
  val gyroscope = sensorManager?.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
  if (gyroscope != null) {
    val gyroscopeListener = GameControllerGyroscopeListener(gyroscope)
    sensorManager.registerListener(
      gyroscopeListener, gyroscope,
      SensorManager.SENSOR_DELAY_GAME
    )
  }
}

class GameControllerAccelerometerListener(private val listenerAccelerometer: Sensor?) :
  SensorEventListener {
  override fun onSensorChanged(event: SensorEvent) {
    if (listenerAccelerometer != null) {
      synchronized(listenerAccelerometer) {
        if (event.sensor == listenerAccelerometer) {
          Log.d("Accelerometer",
            "onSensorChanged " + event.values[0] + ", "
            + event.values[1] + ", " + event.values[2])
        }
      }
    }
  }

  override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
  }
}

class GameControllerGyroscopeListener(private val listenerGyroscope: Sensor?) :
  SensorEventListener {
  override fun onSensorChanged(event: SensorEvent) {
    if (listenerGyroscope != null) {
      synchronized(listenerGyroscope) {
        if (event.sensor == listenerGyroscope) {
          Log.d("Gyroscope",
            "onSensorChanged " + event.values[0] + ", " +
            event.values[1] + ", " + event.values[2])
        }
      }
    }
 }

  override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
  }
}

Java

public void setIntegratedAccelerometerActive(int deviceId) {
    InputDevice device = InputDevice.getDevice(deviceId);
    // Safe handling for null device or sensor manager
    if (device == null) {
      return;
    }
    SensorManager sensorManager = device.getSensorManager();
    if (sensorManager == null) {
      return;
    }

    Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    if (accelerometer != null) {
      GameControllerAccelerometerListener   accelerometerListener =
          new GameControllerAccelerometerListener(accelerometer);
        sensorManager.registerListener(
          accelerometerListener, accelerometer,
          SensorManager.SENSOR_DELAY_GAME
        );
    }
}

public void setIntegratedGyroscopeActive(int deviceId) {
    InputDevice device = InputDevice.getDevice(deviceId);
    if (device == null) {
        return;
    }
    SensorManager sensorManager = device.getSensorManager();
    if (sensorManager == null) {
        return;
    }
    Sensor gyroscope = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    if (gyroscope != null) {
        GameControllerGyroscopeListener gyroscopeListener =
          new GameControllerGyroscopeListener(gyroscope);
        sensorManager.registerListener(
          gyroscopeListener, gyroscope,
          SensorManager.SENSOR_DELAY_GAME
        );
    }
}

public static class GameControllerAccelerometerListener implements SensorEventListener {
    private final Sensor listenerAccelerometer;
    public GameControllerAccelerometerListener(Sensor   listenerAccelerometer) {
        this.listenerAccelerometer = listenerAccelerometer;
    }
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (listenerAccelerometer != null) {
            synchronized (listenerAccelerometer) {
                if (event.sensor == listenerAccelerometer) {
                    Log.d("Accelerometer",
                      "onSensorChanged " + event.values[0] + ", "
                      + event.values[1] + ", " + event.values[2]);
                }
            }
        }
    }
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }
}

public static class GameControllerGyroscopeListener implements SensorEventListener {
    private final Sensor listenerGyroscope;

    public GameControllerGyroscopeListener(Sensor listenerGyroscope) {
        this.listenerGyroscope = listenerGyroscope;
    }
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (listenerGyroscope != null) {
            synchronized (listenerGyroscope) {
                if (event.sensor == listenerGyroscope) {
                    Log.d("Gyroscope",
                      "onSensorChanged " + event.values[0] +  ", " +
                        event.values[1] + ", " + event.values  [2]);
                }
            }
        }
    }
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }
}

मोशन सेंसर और SensorEventListener के बारे में ज़्यादा जानकारी के लिए.

लाइटें

Android गेम कंट्रोलर पर लाइट के रंग की सेटिंग से, विज़ुअल एलिमेंट के ज़रिए गेमप्ले में एक नया इमर्सिव डाइमेंशन जुड़ जाता है.

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

Android गेम कंट्रोलर में मौजूद लाइट कलर की सुविधा, सिर्फ़ सजावट के लिए नहीं होती. यह गेम के मूड को सेट करने और उपयोगकर्ता अनुभव को बेहतर बनाने में अहम भूमिका निभाती है.

कोटीन

fun changeControllerLightColor(deviceId: Int, color: Int) {
  val device = InputDevice.getDevice(deviceId)
  device?.let {
    if (it.sources and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK) {
      val lightsManager = device.lightsManager
      lightsManager?.let { manager ->
        manager.lights.forEach { light ->
          val stateBuilder = LightState.Builder()
          stateBuilder.setColor(color)
          val requestBuilder = LightsRequest.Builder()
          requestBuilder.addLight(light, stateBuilder.build())
          val lightsSession = lightsManager.openSession()
          lightsSession.requestLights(requestBuilder.build())
        }
      }
    }
  }
}

Java

public void changeControllerLightColor(int deviceId, int  color) {
    InputDevice device = InputDevice.getDevice(deviceId);

    if (device != null) {
      // Check if the device is a joystick.
      // Note: Parentheses are required around the bitwise AND operation in Java
      // because == has higher precedence than &.
        if ((device.getSources() & InputDevice.  SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK) {
            LightsManager lightsManager = device.getLightsManager();

            if (lightsManager != null) {
                for (Light light : lightsManager.getLights()) {
                    LightState.Builder stateBuilder = new   LightState.Builder();
                    stateBuilder.setColor(color);

                    LightsRequest.Builder requestBuilder = new LightsRequest.Builder();
                    requestBuilder.addLight(light, stateBuilder.build());

                    LightsManager.Session lightsSession =   lightsManager.openSession();
                    lightsSession.requestLights(requestBuilder.build());
                }
            }
        }
    }
}

वाइब्रेट करने की सुविधा का इस्तेमाल करने के लिए, यह कुकी एक सुविधा और अनुमति सेट करती है.

<application ...>
  ...
  <uses-feature android:name="android.hardware.gamepad" android:required="true"/>
  <uses-permission android:name="android.permission.LIGHTS" />
  ...
</application>

ध्यान दें: android:hardware:gamepad की सुविधा उपलब्ध होने की जानकारी देते समय, android:required एट्रिब्यूट की वैल्यू "true" पर सेट न करें. ऐसा करने पर, उपयोगकर्ता डिवाइस पर आपका ऐप्लिकेशन इंस्टॉल नहीं कर पाएंगे.

LightsManager और ऐप्लिकेशन मेनिफ़ेस्ट के बारे में ज़्यादा जानें.

कंट्रोलर टचपैड

कुछ गेम कंट्रोलर में टचपैड होता है. इसका इस्तेमाल गेम में कई कार्रवाइयों के लिए किया जा सकता है. जैसे, मेन्यू में नेविगेट करना या गेम के किरदारों को ज़्यादा आसानी से कंट्रोल करना.

पहली इमेज. गेम कंट्रोलर पर मौजूद टचपैड.

टचपैड वाले गेम कंट्रोलर से, Android डिवाइस को सीधे कंट्रोल किया जा सकता है. टचपैड को छूने पर, स्क्रीन पर माउस पॉइंटर दिखता है. इससे माउस की तरह नेविगेट करना आसान हो जाता है.