Présentation

Les manettes de jeu sont dotées de fonctionnalités supplémentaires améliorer l'interaction et l'immersion des joueurs. Le retour haptique, les capteurs de mouvement et la lumière des manettes de jeu Android sont particulièrement utiles d'approfondir et d'enrichir l'expérience de jeu. Chaque fonctionnalité stimule de façon unique les sens du joueur, ce qui favorise des interactions plus significatives et intuitives dans le jeu.

Technologie tactile

Le retour haptique des manettes de jeu Android est une technologie essentielle qui offre un retour tactile réaliste pendant le jeu.

La technologie haptique transmet des sensations physiques à l'utilisateur grâce à des vibrations. ou mouvements. Par exemple, lorsqu'une explosion se produit dans le jeu, la manette vibre, ce qui permet au joueur de ressentir l'impact de manière réaliste. En outre, de légères vibrations peuvent être synchronisées avec le son d'un personnage qui marche ou en cours d'exécution, offrant ainsi une expérience plus réaliste. Ce type de retour haptique permet aux joueurs de ressentir physiquement les différents événements qui se produisent au cours du jeu.

Cette technologie optimise l'immersion des joueurs, amplifie les réactions émotionnelles et enrichit la dynamique du jeu. Paramètres haptiques dans les manettes de jeu Android non seulement élargir les possibilités créatives pour les développeurs de jeux, mais aussi aux joueurs une expérience de jeu plus réaliste que jamais.

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))
    }
  }
}

Pour utiliser le vibreur, il définit une fonctionnalité et une autorisation.

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

Pour en savoir plus sur VibratorManager et Fichier manifeste d'application.

Capteurs de mouvement

L'une des technologies les plus innovantes pour améliorer les expériences de jeu Manette de jeu Android équipée d'un capteur de mouvement. Cette technologie précisément détecte les mouvements physiques des utilisateurs et traduit ces données en actions dans le jeu, offrant ainsi une expérience plus intuitive et immersive. Dans cette introduction, nous verrons comment fonctionne le capteur de mouvement Les manettes de jeu Android fonctionnent.

Les capteurs de mouvement intègrent généralement des gyroscopes et des accéléromètres pour détecter la mouvements et orientations des utilisateurs.

Il doit implémenter les classes d'écouteurs d'accélération et de gyroscope, et enregistrer ces écouteurs avec le gestionnaire de capteurs de la manette.

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) {
  }
}

Pour en savoir plus sur Capteurs de mouvement SensorEventListener

Éclairages

Les paramètres de couleur claire des manettes de jeu Android ajoutent une nouvelle dimension d'une expérience de jeu immersive grâce à des éléments visuels.

La fonctionnalité de couleur des lumières utilise les LED intégrées à la manette pour afficher différentes couleurs qui réagissent dynamiquement à différents scénarios de jeu. Par exemple, les voyants peuvent clignoter en rouge lorsque la santé du joueur est critique ou s'allument en vert à la fin d'une mission spécifique et fournissent un retour visuel. en fonction des événements dans le jeu. Ces paramètres de couleur claire renforcent l'engagement utilisateur, pour accroître le suspense et le plaisir, tout en aidant les joueurs à se plonger davantage dans le jeu dans l'univers du jeu.

Les fonctionnalités de couleur claire des manettes de jeu Android ont plus d'impact mais il joue un rôle décisif dans la création de l'atmosphère et améliorer l'expérience utilisateur.

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())
        }
      }
    }
  }
}

Pour utiliser le vibreur, il définit une fonctionnalité et une autorisation.

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

Pour en savoir plus sur LightsManager et Fichier manifeste d'application.

Pavé tactile de la manette

Certaines manettes de jeu comprennent un pavé tactile qui peut être utilisé pour diverses les actions de jeu, comme naviguer dans les menus ou contrôler des personnages dans un de manière plus intuitive.

Les manettes de jeu avec pavé tactile intégré permettent de contrôler directement l'appareil Android Le toucher du pavé tactile génère un pointeur de souris à l'écran, ce qui permet pour une navigation aussi intuitive que celle d'une souris.