Page creation date :

Notes on this Tips

This sample is based on the programs published on the following sites. I change the code a little to make it easier to understand and explain it in Japanese. Basically, we use the original code as is, so if you actually adopt it in your game program, correct it in a timely manner and use it.

Reference site

In addition, it is explained on the assumption that you have some basic knowledge about MonoGame and XNA. See MonoGame Tips and XNA Tips for the ruddly.

In particular, as mathematics, vectors, trigonometric functions, matrices, etc. are essential, so please know what they are to some extent.


  • Windows 10
  • Code can be used on other MonoGame-enabled platforms
Visual Studio
  • Visual Studio 2019
.NET Core
  • 3.1
  • 3.8

About samples

The light rotates to track the light in the direction the target is.

If you move the cat with a mouse or key,

The light follows the cat.

How to operate

What's To Do Keyboard Gamepad (XInput) Mouse Touch
Cat Movement ↑↓←→
  • Left Stick
  • DPad
Left button Touch anywhere
End of game Esc Back - -

What to prepare

Images that move the target and the lights to track.


Download the program for all the code.


/// <summary>猫が動くスピード。これはフレームあたりのピクセル数です。</summary>
const float CatSpeed = 10.0f;

/// <summary>スポットライトが回転する速度。これはフレームあたりのラジアンで表されます。</summary>
const float SpotlightTurnSpeed = 0.025f;

Cat movement and light tracking are not instantaneous, but move and rotate frame by frame.

By the way, since game time is not used in this sample, the actual time operation and speed may be different depending on the platform. Try to use game time in the actual game you make.


readonly GraphicsDeviceManager _graphics;

/// <summary>画像を表示するための SpriteBatch です。</summary>
SpriteBatch _spriteBatch;

/// <summary>スポットライトのテクスチャー(画像)です。</summary>
Texture2D _spotlightTexture;

/// <summary>スポットライトの位置です。</summary>
Vector2 _spotlightPosition = new Vector2();

/// <summary>スポットライトの中心位置です、ここを中心に回転します。</summary>
Vector2 _spotlightOrigin = new Vector2();

/// <summary>スポットライトが現在向いている角度。単位はラジアンです。値 0 は右を指します。</summary>
float _spotlightAngle = 0.0f;

/// <summary>猫のテクスチャー(画像)です。</summary>
Texture2D _catTexture;

/// <summary>猫の位置です。</summary>
Vector2 _catPosition = new Vector2();

/// <summary>猫の中心位置です。</summary>
Vector2 _catOrigin = new Vector2();

Basically, you just have the information to display the sprite. The important thing is _spotlightAngle to have automatically calculate to point to the target.


public AimingGame()
  graphics = new GraphicsDeviceManager(this);
  ontent.RootDirectory = "Content";
  sMouseVisible = true;

  graphics.PreferredBackBufferWidth = 320;
  graphics.PreferredBackBufferHeight = 480;

  // フルスクリーンにしたい場合はコメントを外してください。
  //graphics.IsFullScreen = true;

There is nothing to keep in mind other than lower resolutions for mobile.

Initialize method

protected override void Initialize()

  // base.Initialize が完了すると、GraphicsDevice が作成され、ビューポートの大きさがわかります。
  // スポットライトを画面の中央に配置する必要があるため、ビューポートを使用してそれがどこにあるかを計算します。
  Viewport vp = _graphics.GraphicsDevice.Viewport;
  _spotlightPosition.X = vp.X + vp.Width / 2;
  _spotlightPosition.Y = vp.Y + vp.Height / 2;

  // もう一度ビューポートサイズを使用して、今度は猫を画面に配置します。位置は x=1/4 y=1/2 です。
  _catPosition.X = vp.X + vp.Width / 4;
  _catPosition.Y = vp.Y + vp.Height / 2;

Determines the initial position of each image. Note that you are Viewport writing code after to base.Initialize() use .

LoadContent method

protected override void LoadContent()
  // テクスチャをロードし、スプライトバッチを作成します。
  _spotlightTexture = Content.Load<Texture2D>("spotlight");
  _catTexture = Content.Load<Texture2D>("cat");
  _spriteBatch = new SpriteBatch(_graphics.GraphicsDevice);

  // テクスチャをロードしたので、それらを使用して、描画時に使用するいくつかの値を計算できます。
  // スポットライトを描くときは、光源の周りを回転する必要があります。
  // 今回用意した画像は左中央が光源なのでその位置を中心位置として設定します。
  _spotlightOrigin.X = 0;
  _spotlightOrigin.Y = _spotlightTexture.Height / 2;

  // 猫の中心位置を決定します。とりあえず画像の真ん中とします。
  _catOrigin.X = _catTexture.Width / 2;
  _catOrigin.Y = _catTexture.Height / 2;

SpriteBatch I'm creating and loading textures.

In addition, the center position of the cat image and the center position (rotation axis) of the spotlight are set here. Because the center position changes depending on the image It is set individually.

Update method

protected override void Update(GameTime gameTime)

  // 猫が画面外に出ないように制御します。
  Viewport vp = _graphics.GraphicsDevice.Viewport;
  _catPosition.X = MathHelper.Clamp(_catPosition.X, vp.X, vp.X + vp.Width);
  _catPosition.Y = MathHelper.Clamp(_catPosition.Y, vp.Y, vp.Y + vp.Height);

  // TurnToFace 関数を使用して、_spotlightAngle を更新して猫の方を向くようにします。
  _spotlightAngle = TurnToFace(_spotlightPosition, _catPosition, _spotlightAngle, SpotlightTurnSpeed);


The HandleInput method handles the player's operations, which will be discussed later. The position of the cat is determined by input. We alsoViewport use to prevent the cat from appearing on the screen.

TurnToFace The method rotates the spotlight. The position of the spotlight and the position of the cat, the current angle of the light and the maximum rotation speed are now determined to determine the orientation of the light in the frame. We'll talk about what we're about later.

By the way, I'm not using it in this Tips, but you need to use the gameTime variable to match the game speed.

HandleInput method

/// <summary>
/// 入力を処理します。
/// </summary>
void HandleInput()
  KeyboardState currentKeyboardState = Keyboard.GetState();
  GamePadState currentGamePadState = GamePad.GetState(PlayerIndex.One);
  MouseState currentMouseState = Mouse.GetState();
  TouchCollection currentTouchState = TouchPanel.GetState();

  // ゲーム終了操作を確認します。
  if (currentKeyboardState.IsKeyDown(Keys.Escape) ||
      currentGamePadState.Buttons.Back == ButtonState.Pressed)

  // ユーザーが猫を動かしたいかどうかを確認します。 catMovement というベクトルを作成します。
  // これは、すべてのユーザーの入力の合計を格納します。
  Vector2 catMovement = currentGamePadState.ThumbSticks.Left;

  // y を反転:スティックでは、下は -1 ですが、画面では、下がプラスです。
  catMovement.Y *= -1;

  if (currentKeyboardState.IsKeyDown(Keys.Left) ||
      currentGamePadState.DPad.Left == ButtonState.Pressed)
    catMovement.X -= 1.0f;
  if (currentKeyboardState.IsKeyDown(Keys.Right) ||
      currentGamePadState.DPad.Right == ButtonState.Pressed)
    catMovement.X += 1.0f;
  if (currentKeyboardState.IsKeyDown(Keys.Up) ||
      currentGamePadState.DPad.Up == ButtonState.Pressed)
    catMovement.Y -= 1.0f;
  if (currentKeyboardState.IsKeyDown(Keys.Down) ||
      currentGamePadState.DPad.Down == ButtonState.Pressed)
    catMovement.Y += 1.0f;

  // タッチポイントに向かって移動します。
  // CatSpeed からタッチポイントまでの距離内に入ると、猫の速度を落とします。
  float smoothStop = 1;

  //if (currentTouchState != null )
    if (currentTouchState.Count > 0)
      Vector2 touchPosition = currentTouchState[0].Position;
      if (touchPosition != _catPosition)
        catMovement = touchPosition - _catPosition;
        float delta = CatSpeed - MathHelper.Clamp(catMovement.Length(), 0, CatSpeed);
        smoothStop = 1 - delta / CatSpeed;

  Vector2 mousePosition = new Vector2(currentMouseState.X, currentMouseState.Y);
  if (currentMouseState.LeftButton == ButtonState.Pressed && mousePosition != _catPosition)
    catMovement = mousePosition - _catPosition;
    float delta = CatSpeed - MathHelper.Clamp(catMovement.Length(), 0, CatSpeed);
    smoothStop = 1 - delta / CatSpeed;

  // ユーザーの入力を正規化して、猫が CatSpeed より速く進むことができないようにします。
  if (catMovement != Vector2.Zero)

  _catPosition += catMovement * CatSpeed * smoothStop;

The player's input process. What we are doing here is the cat move and end of the game operation.

Input devices are supported in a variety of fields: Keyboard, Gamepad, Mouse, Touch .

Basically, I'm just moving with a directional key, touching it, or pointing the cat at the position I clicked, so I won't go into too much detail. As a detailed control point,

  • The stick is reversed because the up direction is positive, while the screen position is positive in the downward direction.
  • Do not move beyond points after the cat reaches its desired position with the mouse or touch
  • Once you have determined the direction of travel, normalize it to make it a unit vector (direction only) and finally multiply the movement speed.

It comes to.

TurnToFace method

/// <summary>
/// オブジェクトの位置、ターゲットの位置、現在の角度、および最大回転速度を指定して、
/// オブジェクトが直面する必要のある角度を計算します。
/// </summary>
/// <param name="position">オブジェクトの位置。ここではスポットライトの位置。</param>
/// <param name="faceThis">ターゲットの位置。ここでは猫の位置。</param>
/// <param name="currentAngle">現在の角度。</param>
/// <param name="turnSpeed">最大回転速度。</param>
/// <returns>決定された角度。</returns>
private static float TurnToFace(Vector2 position, Vector2 faceThis, float currentAngle, float turnSpeed)
  // :
  // :

This is the main process for Tips. The process of determining the angle so that the spotlight faces the cat. Pass spotlight position, cat position, current angle, maximum rotational speed as arguments. The return value is the final rotation position. It is not the amount of rotation from the current position.

// この図を参照してください。
//      C 
//     /|
//    / |
//   /  | y
//  / o |
// S----
//     x
// ここで、S はスポットライトの位置、C は猫の位置、o は猫を指すためにスポットライトが向いている角度です。
// o の値を知る必要があります。
// これには三角法を使用して算出します。
//      tan(theta)       = 高さ / 底辺
//      tan(o)           = y / x
// この方程式の両辺のアークタンジェントを取ると
//      arctan( tan(o) ) = arctan( y / x )
//      o                = arctan( y / x )
// したがって、x と y を使用して、「desiredAngle」である o を見つけることができます。
// x と y は、2つのオブジェクト間の位置の違いにすぎません。
float x = faceThis.X - position.X;
float y = faceThis.Y - position.Y;

// Atan2 関数を使用します。Atanは、y / x のアークタンジェントを計算し、x と y の符号を使用して、
// 結果を入れるデカルト象限を決定するという追加の利点があります。
float desiredAngle = (float)Math.Atan2(y, x);

As mentioned in the comments, trigonometric (inverse trigonometric functions) is used to calculate angles from positions. If you explain the contents of mathematics, it will be a tip, so you should know that you should use arctangent here. The method used is Math.Atan2 . Math.Atan note that it is not.

See the following figure for the return value. Returns a value of -π to +π with the direction of +x as 0. Note that the +y direction returns a positive result, but at window coordinates the bottom is the +y direction.

// これで猫を向くために必要な設定角度がわかりました。turnSpeed (回転スピード) に制約されていなければ簡単です。
// desiredAngle を返すだけです。
// 代わりに回転量を計算し、それが turnSpeed を超えないようにする必要があります。

// まず、WrapAngle を使用して、-Pi から Pi(-180度から180度)の結果を取得し、
// どれだけ回転させたいかを判断します。
// これは猫の方向に向くのに必要な回転角度です。
float difference = WrapAngle(desiredAngle - currentAngle);

// -turnSpeed と turnSpeed の間にクランプします。
// 要は1フレームの回転角度上限を超えないようにします。
difference = MathHelper.Clamp(difference, -turnSpeed, turnSpeed);

// したがって、ターゲットに最も近いのは currentAngle + difference です。
// もう一度 WrapAngle を使用して、それを返します。
return WrapAngle(currentAngle + difference);

Once you have an angle to point the target, the rest is determined the angle from the current position to the desired angle. Here we have the maximum speed that can be rotated in one frame, MathHelper.Clamp(difference, -turnSpeed, turnSpeed) does not exceed the maximum value.

Also, if calculated simply by plus or minus, it rotates backwards beyond the range of +π and -π, so I adjust it with the WrapAngle method. This method is described in the next section.

Finally, when the angle to which it is rotated is determined, return.

WrapAngle method

/// <summary>
/// -Pi と Pi の間のラジアンで表される角度を返します。
/// 例えば degree で -200°なら +360°して 160°とします。反対側も同様です。
/// </summary>
private static float WrapAngle(float radians)
  while (radians < -MathHelper.Pi)
    radians += MathHelper.TwoPi;
  while (radians > MathHelper.Pi)
    radians -= MathHelper.TwoPi;
  return radians;

If the angle exceeds the range of -π to +π, it may rotate in the opposite direction to the direction that should be rotated, If this range is exceeded, add or subtract 2π to keep it within the above range.

Draw method

protected override void Draw(GameTime gameTime)
  GraphicsDevice device = _graphics.GraphicsDevice;


  // 猫を描画します。
  _spriteBatch.Draw(_catTexture, _catPosition, null, Color.White, 0.0f, _catOrigin, 1.0f, SpriteEffects.None, 0.0f);

  // 加算合成でスプライトバッチを開始し、スポットライトを当てます。 加算合成は、ライトや火などの効果に非常に適しています。
  _spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive);
  _spriteBatch.Draw(_spotlightTexture, _spotlightPosition, null, Color.White, _spotlightAngle, _spotlightOrigin, 1.0f, SpriteEffects.None, 0.0f);


Once you've calculated the position and rotation, all you have to do is draw the sprite along that number. In order to express the cat as if the light is hit, additive synthesis is performed when drawing the spotlight.


I think it's very important to know about this technique because there are relatively many situations in the game where you decide which way your opponent is in. This method is commonly used in 2D games, and can be calculated using quaternions in 3D games. But there are many things that use 2D calculations in 3D, so it's safe to know.