
French: 
Maintenant nous allons déplacer
le game object Player.
Tout d'abord, nous allons réfléchir à la façon dont
nous voulons que ce game object Player
se comporte.
Nous voulons que le joueur survole
la zone de jeu,
reste dans cette zone et
ne s'envoler pas dans l'espace.
Nous voulons qu'il puisse entrer en collision
avec les games object ramassables et
les ramasser quand cela arrive.
Cela requière la physique.
Unity a deux systèmes de physique.
Un pour la 2D et un pour la 3D.
Ces systèmes sont comparables
et sont compatibles
il peuvent exister dans la même scène
mais chose importante ils ne
pourront pas interagir l'un avec l'autre.
Pour ce projet nous utiliserons
la 2D Physics.
Pour utiliser la 2D Physics
le game object
a besoin d'avoir un composant
Rigidbody2d d'attaché.
Pour attacher un nouveau composant
nous devons
en premier sélectionner le
game object sur

English: 
Now we're going to move the Player game object.
First let's think through how we
want this Player game object to behave.
We want to have the player fly around the game area,
stay on the play field and
not fly off in to space.
We want to be able to collide with our collectable
game objects and pick them up when we do this.
This requires physics.
Unity has two physics systems.
One for 2D and one for 3D.
These systems are comparable to each other
and compatible with each other in that
they can both be in the same scene
but importantly they will
not interact with each other.
For this project we'll be using
2D physics.
To use 2D physics the game object
needs to have a Rigidbody2d component attached.
To attach a new component we must
first select the game object we want to

Japanese: 
これから Player ゲームオブジェクトを動かしてみます
まず、Player ゲームオブジェクトに
どんなふるまいが必要か考えてみましょう
Player はゲームエリアを飛び回り
プレイフィールド内にとどまり
空間に飛び出すべきではありません。
アイテムのゲームオブジェクトと接触して 
それを取得することも必要です
これには 物理演算が必要です
Unity には 2 種類の物理演算があります
2D と 3D 用です
これらのシステムは互いに匹敵し
互換性があります。 そのため
両方を同じシーンに設定することができます
ただし、重要なのは
これらは相互に作用することはできません
このプロジェクトには
2D 物理演算を利用します
2D 物理演算を使用するには、ゲームオブジェクトに
Rigidbody2D コンポーネントをアタッチする必要があります
新規のコンポーネントをアタッチするには
最初に、そのコンポーネントをアタッチしたい

French: 
lequel nous voulons l'attacher,
dans notre cas nous sélectionnerons
notre game object Player.
Ensuite, nous pouvons choisir soit
le menu Component et sélectionner
Physics 2D - Rigidbody2d
ce qui attachera ce composant
au game object sélectionné.
Ou utiliser le bouton
Add Component
dans l'inspector et choisissez
Rigidbody2d.
Il est important de s'assurer
que nous avons ajouté
la version physics 2D
et pas la version physics pour la 3D
comme il y a le choix entre
le composant Rigidbody
pour la physics 3D et
le composant Rigidbody2d.
Ces composants ne peuvent pas
fonctionner
ensemble alors soyez sûr de
choisir le bon
composant suivant votre
type de jeu.
Si nous voulons nous pouvons
réorganiser
l'ordre des composant dans
un game object
en utilisant le menu
déroulant engrenage
dans le coin haut-droit
du composant.
Faire ceci n'a aucun effet
sur la performance de notre jeu,

Japanese: 
ゲームオブジェクトを選びます
この場合は Player ゲームオブジェクトを選択します
それから Component メニューで
Physics 2D > Rigidbody2d
と選び
このコンポーネントと選択したゲームオブジェクトを
アタッチするか
または、Inspector の Add Component ボタンを使い
Rigidbody2D を選びます
大切なのは、Physics や 3D でなく
このコンポーネントの Physics 2D バージョンを
選ぶことです
なぜなら 3D Physics のRigidbody　も 
Rigidbody2D　コンポーネントも
どちらでも選べるからです
これらのコンポーネントは一緒には使えません
作成中のゲームのタイプに
正しいコンポーネントを選ぶよう気を付けてください
必要があれば
コンポーネントの右上の歯車型メニューで
ゲームオブジェクトのコンポーネントの順序を
アレンジしなおすことができます
これによって、ゲームのパフォーマンスに影響はありませんが

English: 
attach the component to,
in this case we'll select our Player game object.
Then we can either choose the
Component menu and select
Physics 2D - Rigidbody2d
which would attach this component to the
game object we've selected.
Or use the Add Component button
in the inspector, choosing Rigidbody2d.
It's important to be sure that we're adding
the physics 2D version of this component
not the physics, or 3D version
since we can choose between both the Rigidbody
component for 3D physics
and the Rigidbody2d component.
These component cannot work
together so be sure to choose the correct
components for our game type.
If we choose to we can rearrange
the order of the components on the game object
using the context sensitive gear menu
in the upper-right of the component.
Doing this has no effect on the performance of our game,

Japanese: 
ゲームオブジェクトのコンポーネントの順番に
一貫性を持たせることは 
Project や Hierarchy を整理整頓した状態に
維持することにより 
開発をスピードアップする助けになることもあります
Component のタイトルバーをクリックして
Component ビューを畳んだり広げたりできることを
覚えておいてください
それでは、Player オブジェクトを制御して
動かしてみることにしましょう
オブジェクトを動かすには キーボードを通して
プレイヤーからの入力を取得し
その入力を、シーン内で Player オブジェクトを動かす力として
as forces to move 
適用する必要があります
これをPlayer ゲームオブジェクトに
スクリプトをアタッチして行います
まず 新しいC# スクリプトを作成しましょう
新しいスクリプトを作るには
いくつか方法があります
Assets > Create > C# Script の順に選んで
新しいC# スクリプトを作成するか
または、Project ビューの Create メニューを
使用する方法もあります

French: 
toutefois avoir un ordre cohérent
des composants de notre
game object
peut nous aider à accélérer
notre développement
en gardant un projet
et une hiérarchie organisée.
N'oubliez pas que l'on peut
rétracter ou développer la
vue composant
en cliquant dans la barre
titre du composant.
Maintenant nous faire déplacer
l'objet Player sous notre contrôle.
Pour faire cela nous avons
besoin d'une
entrée venant du joueur depuis le clavier
et nous appliquerons cette entrée
au game object Player
comme une force pour déplacer
l'objet Player dans la scène.
Nous ferons cela en utilisant
un script
que nous attacherons au
game object Player.
Créons un nouveau script C#.
Pour créer un nouveau script
nous avons plusieurs solutions.
Nous pouvons faire Assets - Create
pour créer notre nouveau script C#.
Ou nous pouvons utiliser
le menu Create
dans la vue Project.

English: 
however having a consistent order
to the components on our game object
may help us speed up our development
by keeping or maintaining an
organised project and hierarchy.
Don't forget we can collapse
or expand the component view
by linking on the component's title bar
Now we need to get the player object
moving under our control.
To do this we need to get input
from our player through the keyboard and we
need to apply that input to the Player game object
as forces to move
the Player object in the scene.
We'll do this by using a script
that we attach to the Player game object.
Let's create a new C# script.
To create a new script
we have some choices.
We can choose Assets - Create
to create our new C# script.
Or we can use the Create menu
in the project view.

Japanese: 
しかし、この場合 もっと効果的な方法は
Player ゲームオブジェクトを選び
Inspector の Add Component ボタンを使用します
Add Component メニューに
New Script という選択肢があります
これを選ぶと いっぺんに
スクリプトの作成とアタッチができます
まずこのスクリプトを 
PlayerController と名付けます
スクリプトの言語を選べます
ここではC# を選び
それから Create and Add をクリックします
単に Return/Enter キーを押しても
同様です
Unity はこのスクリプトを作成、コンパイルし
選択したゲームオブジェクトに
アタッチします
気を付けたいのは
この方法でスクリプトを作成すると
ルートか Project ビューの最上位に
スクリプトアセットは作成されます
Project ビューを効率的に保つために
そのアセットを Scripts ディレクトリに

French: 
Mais ce qui est plus
efficace dans
notre cas est de selectionner
le game object Player
et d'utiliser le bouton
Add Component dans l'inspector.
Le menu Add Component contient
la ligne New Script.
Cela nous permet à la fois de créer
et d'attacher un script en une
seule action.
Premièrement nommons ce script
PlayerController.
Nous pouvons choisir le
langage de ce script,
qui sera C#,
puis cliquez sur Create and Add.
Ou plus simplement tapez
return ou enter
pour confirmer notre sélection.
Unity va créer, compiler
et attacher ce script
au game object sélectionné.
Notons que cette manière de
créer un script créera ce
script asset dans la racine
ou au niveau haut de la vue Project.
Nous allons déplacer l'asset dans
le répertoire Script afin de

English: 
But what might be more efficient in this
case would be to select the Player game object
and use the Add Component button in the inspector.
The Add Component menu contains
the selection New Script.
This allows us to both create
and attach a script in one step.
First let's name this script
PlayerController.
We can choose the language of the script,
which will be C#,
and then click on Create and Add.
Or simply hit the return or enter key
to confirm our selection.
Unity will create, compile
and attach this script
to the selected game object.
We should note that this way of
creating a script will create that
script asset on the root
or top level of our project view.
We'll need to move the asset in to the
Scripts directory in order to

Japanese: 
移動します
Project ビューでスクリプトを選ぶと
Inspector 内でスクリプトアセットの
プレビューが表示されます
ただし、これは編集できません
スクリプトを開いて編集してみましょう
たくさんの方法があります
スクリプトがアタッチしたゲームオブジェクトを
検証しているときは
歯車型メニューで Edit Script を選びます
Project ビューでスクリプトアセットを
ダブルクリックします
または、Project ビューで
スクリプトが選択されているときは
Inspector の Open ボタンを使います
こうして スクリプトを
好みのスクリプトエディターで開きます
最初に、基本スクリプトの
サンプルコードを削除します
次に、このスクリプトで何をしたいのかを
考えてみましょう
必用なのは、各フレームごとに 
プレイヤーの入力をチェックして
その入力を各フレームの動きとして

English: 
maintain an organised project view.
If we select the script in our project view
we see a preview of the script asset
in the inspector but this
text is not editable.
Let's open the script for editing.
We can do this in a number of ways.
When we're inspecting a game object
with the script attached we can
use the context sensitive gear menu.
We can double click on the script asset in
the project view, or we can use the
Open button in the inspector
when we have the script selected
in our project view.
This will open our script
in our preferred script editor.
First let's remove the sample
code provided in the base script.
Next let's think,
what do we want to do with this script?
We want to check every frame
for player input, and then we
want to apply that input to the

French: 
maintenir une vue de projet organisé.
Si vous sélectionnez le script
dans la vue project
vous pouvez voir un aperçu du script
dans l'inspector, mais ce
texte n'est pas éditable.
Ouvrons ce script pour l'éditer.
On peut faire cela de
plusieurs manières.
Quand on inspecte
un game object
avec un script attaché on peut
utiliser le menu
déroulant engrenage.
On peut double cliquer sur
le script asset
dans la vue Project, ou
on peut utiliser
le bouton Open dans l'ispector
quand le script est sélectionné
dans la vue Project.
Cela va ouvrir notre script dans
notre éditeur de script favori.
D'abord retirons le code
d'exemple fourni avec le script
de base.
Maintenant réfléchissons,
que voulons nous faire avec ce script ?
Nous voulons vérifier pour
chaque image
l'entrée du joueur,
puis nous
voulons appliqu er cette entrée au

Japanese: 
Player ゲームオブジェクトに適用することです
では、どうやってこの入力をチェックして適用しましょうか。
2 つ方法があります
Update() と FixedUpdate() です
Update はフレームをレンダリングする前に呼び出されます
たいてのゲームコードは
これを使います
一方、FixedUpdate は
物理演算が行われる寸前に
呼び出されます
私たちは、こちらを物理演算コードに使います
力を Rigidbody2D に適用して 
UFO を動かします
つまり、物理演算です
2D 物理演算が 
3D のそれと違うことは
この場合は、あまり関係ありません
FixedUpdate にコードを加えることにします
次に、どのコードを 
FixedUpdate に加えるかです
Input (入力) が必要なことはわかっていますが
それ以上どうやって調べたらよいでしょうか。
MonoDevelop にはショートカットがあります
それで Unity API を検索できます

French: 
game object Player en tant que
mouvement à chaque image.
A quel moment allons nous
vérifier et appliquer cette entrée ?
Nous avons deux choix ;
Update() et FixedUpdate().
Update est appelé avant
l'affichage de l'image,
et ce sera valable pour la plupart
de notre code de jeu.
FixedUpdate d'autre part
est appelé
juste avant d'effectuer
des calculs de physique
et c'est ici que notre code
de physique ira.
Nous allons bouger notre
UFO en appliquant
une force au Rigidbody2d
en considérant que c'est
de la physique.
Le fait que c'est de la physique 2D
ou bien de la physique 3D
dans ce cas est sans importance.
Nous mettrons notre code
dans FixedUpdate.
La prochaine question est
quel code allons
nous vouloir mettre
dans FixedUpdate ?
Nous savons que nous
avons besoin d'une entrée
mais comment en savoir plus ?
Il y a un raccouci
dans Monodevelop
qui appelle l'aide d'Unity.

English: 
Player game object every frame as movement.
Where will we check for and apply this input?
We have two choices;
Update() and FixedUpdate().
Update is called before rendering a frame,
and this is where most of our game
code will go.
FixedUpdate on the other hand is called
just before performing any
physics calculations
and this is where our physics code will go.
We'll be moving our UFO by applying
forces to the Rigidbody2d
meaning that this is physics.
The fact that it's 2D physics
as distinct from 3D physics
in this case is irrelevant.
We're going to put our code in FixedUpdate.
The next question is what code are we going
to want to put in FixedUpdate?
We know that we need input
but how do we find out more?
There's a shortcut in Monodevelop
that searches the Unity API.

English: 
On the Mac it's Command + '
and on Windows it's Control + '
Select the item we want to research,
in our case Input,
and hold down the command or control key
and then press the ' key.
This search brings up every reference
in our documentation related to Input.
Let's select Input at the top interface
in to the Input system.
This brings up the page on Input.
This is the page on the Input class.
We use this class to read the axis setup
in the Input Manager and to
access multitouch and accelerometer data
on mobile devices.
We read the text on the top of the page to
understand how to use the class.
In our case to get Input from the
Player on all platforms, including mobile devices.
Under the description is a

French: 
Sur Mac c'est Command + '
et sur windows c'est Control + '.
Sélectionnez l'élément que
nous voulons rechercher,
dans notre cas Input,
et maintenez enfoncé la touche
Command ou Control
puis appuyez sur le touche '.
Cette recherche fait apparaître
toutes les références
en lien avec Input dans
notre documentation.
Sélectionnez Input
en haut
lien vers Input.
Cela ouvre la page Input.
Il s'agit de la page de la class Input.
Nous "utiliserons cette class
pour lire la config des axes
dans le gestionnaire d'entrée
et pour accéder aux données
multitouch et accéléromètre
sur les appareils mobiles".
Nous lisons ce texte en
haut de la page
pour comprendre comment
utiliser la class.
Dans notre cas pour récupérer
l'entrée venant du
Player sur tous les systèmes,
incluant les appareils mobiles.
Sous la description apparait une

Japanese: 
Mac では Command + '
Windows では Control + ' です
調べたいものを選びます
この場合は Input です
そして、Command か Control キーを押しながら
 ' キーを押します
この検索で、Unity のドキュメンテーションにある
Input に関する参照すべてが表示されます
一番上の Input を選んで
Input システムを見てみましょう
これで Input に関するページが表示されます
これは Input クラスのページです
このクラスは Input Manager で
軸の設定を読み込み、
モバイルデバイスのmultitouch と accelerometer のデータに
アクセスするために使用されます
ページの上の方にあるテキストを読んで
クラスの使用法を理解します
私たちの場合は、モバイルデバイスを含む
すべてのプラットフォームの Player から Input を取得します
説明の下には

English: 
list of class variables and class functions.
The class variables how information
like the number of touches in touchCount,
or a reference to the default gyroscope with gyro.
The class functions do something for us.
In our case we'll be using
Input.GetAxis.
When we find the item we want
we click on the link to bring up a page
on the function or variable.
Let's look at input.GetAxis.
This page includes the signature of the function,
a description of the function
and code snippets showing
us how to use it in Unity's
Java Script and C#.
We will be using C#.
For more information on Input and the Input Manager
please see the information linked below.
We'll be using Input.GetAxis
in a very similar way to the

Japanese: 
クラスの変数と関数のリストがあります
クラス変数は touchCount のように接触数、または
gyro のようにデフォルトのジャイロスコープの参照などを
一時的に保持します
クラス関数は何かと役に立ちます
ここでは
Input.GetAxis を使います
興味があるものをみつけたときは
リンクをクリックして、その関数や変数に関する
ページを開きます
input.GetAxis を見てみましょう
このページには関数のシグネチャと
関数の説明と
Unity の Java Script と C# で
どのように使うかを示す
コードスニペッツが含まれています
ここではC# を使います
Input と Input Manager に関する情報は
下のリンクのページを参照してください
これから Input.GetAxis を
表示されているコードスニペッツと

French: 
liste de variables de class et
de fonctions de class.
Les variables de class contiennent
les informations
comme le nombre de touches dans
touchCount,
ou une référence au gyroscope par défaut
avec gyro.
Les fonctions de class font quelque
chose pour nous.
Dans notre cas nous
utiliserons
Input.GetAxis.
Une fois trouvé
l’élément voulu
cliquons sur le lien pour
faire apparaître une page
sur la fonction ou la variable.
Examinons input.GetAxis.
Cette page inclut la signature
de la fonction,
une description de la fonction
et des exemples de code montrant
comment l'utiliser dans le
Java Script et le C# d'Unity.
Nous utiliserons le C#.
Pour plus d'informations sur
Input et sur Input Manager
utiliser le lien ci-dessous.
Nous allons utiliser Input.GetAxis
dans une forme similaire au

Japanese: 
とても似た用法で使います
スクリプトに戻って
コードを書いてみましょう
以下を入力します 
float moveHorizontal = Input.GetAxis (*Horizontal*);
float moveVertical = Input.GetAxis (*Vertical*); 
そして Input の行を消します
これで キーボードを通して 
Player から入力を取得できます
Float 変数の moveHorizontal と
moveVertical は
キーボードのキーによって制御される
水平と垂直の軸からの
入力を記録します
InputManager では、これらのキーはデフォルトで
設定されます

French: 
code d'exemple présenté.
Retournons à notre script
et écrivons notre code.
Ecrivons
float moveHorizontal = Input.GetAxis (Horizontal);
float moveVertical = Input.GetAxis (Vertical);
Maintenant nous pouvons
supprimer la ligne Input.
Cela capture l'entrée de notre
Player via le clavier.
Les variables float moveHorizontal
et moveVertical
enregistre les entrées des
axes horizontal et
vertical qui sont controlés
par les touches du clavier.
Ces touches sont configurées
par défaut
dans l'InputManager.

English: 
code snippet shown.
Let's return to our script
and write our code.
Type float moveHorizontal = Input.GetAxis (Horizontal);
float moveVertical = Input.GetAxis (Vertical);
Now we can delete the Input line.
This grabs the input from
our Player through the keyboard.
The float variables moveHorizontal
and moveVertical
record the input from the horizontal
and vertical axis which are controlled
by the keys on the keyboard.
These keys are set by default
in the InputManager.

French: 
Notre game objet Player
utilise un
Rigidbody2d et
interagit avec le moteur physique 2D.
Nous allons utiliser ces entrées
pour ajouter
une pression au Rigidbody2D
et déplacer le game object
Player dans la scène.
Pour en savoir plus sur
comment appliquer une
pression à un Rigidbody2d
regardons la documentation.
D'abord taper Rigidbody2D
dans votre script.
maintenant sélectionnez Rigidbody2d,
maintenez enfoncé la
touche commande sur Mac
ou la touche control sur
Windows
et appuyez sur '.
Encore une fois, cela
nous amène à une page
avec un terme de recherche Rigidbody2d.
Cliquons dessus.
Cela nous amène à la page
Rigidbody2d.
Si nous voulons appliquer une pression
à notre game object Player
nous avons besoin de faire
quelque chose,
alors jetez un œil aux fonctions
disponibles pour la class Rigidbody2d.

English: 
Our Player game object uses a
Rigidbody2d and
interacts with the 2D physics engine.
We'll use this input to add
forces to the Rigidbody2d
and move the Player game object in the scene.
To know more about how to apply forces
to the Rigidbody2d
let's check the documentation.
First type Rigidbody2d in to our script.
Now select Rigidbody2d and
hold down the command key on the Mac
or the control key on Windows
and type '
Again this brings us to a page
with a search term Rigidbody2d.
Let's click on that.
This brings up the Rigidbody2d page.
If we want to apply force to our Player game object
we need to do something,
so let's take a look at the functions
available to the Rigidbody2d class.

Japanese: 
Player ゲームオブジェクトは
Rigidbody2D を利用して
2D 物理演算エンジンと交信します
入力することにより
Rigidbody2D に力を加え
シーンで Player ゲームオブジェクトを動かします
どうやって Rigidbody2D に力を適用するかを
もっと知るために
ドキュメンテーションを見てみましょう
最初に スクリプトに Rigidbody2D と入力します
Rigidbody2D を選んで
Mac なら Command キー
Windows なら Control キー と
‘ を入力します
再び、検索用語 Rigidbody2D で検索される
ページが表示されます
それをクリックしてみましょう
Rigidbody2D ページが表示されます
Player ゲームオブジェクトに力を適用したければ
何かをしなければなりません
それで、Rigidbody2D クラスに使用可能な
関数を見てみましょう

Japanese: 
使いたい関数が見つかるまで
説明を読んで探します
今回はAddForce を選びましょう
これで Rigidbody2D に力を加えます
結果として、動き始めます
リンクをクリックして 
AddForce のページを開いてください
ページの一番上に
関数のシグネチャがあります
シグネチャによると、Rigidbody2D に力を加えるには
vector2 と
オプションで ForceMode　が
必要です
Vector2 とは何でしょうか
Vector2 に関する詳しい情報は
下のリンクのページを参照してください
簡単に言うと Vector2 は 
2 つの十進法の値を 
1 つのコンテナーに保持します
これによって
2D スペースの力のような
X と Y 両軸の力を必要とする値を
自由に変えて使用することが
容易になります
すべてのドキュメンテーションページは関連付けられています
Vector2 をクリックすると
そのドキュメンテーションが

English: 
We can read the descriptions until we
find the one we want.
In this case let's choose AddForce.
This adds force to the Rigidbody2d.
As a result it will start moving.
Click the link and we go to the
page on AddForce.
We can see the signature of the function
at the top of the page.
The signature tells us
we need a vector2
and an optional ForceMode
to add force to our Rigidbody2d.
What is a vector2?
For more detailed information on vector2
please see the information linked below.
But in simple terms the vector2
holds two decimal values
in one container.
This makes it easy for us to move around
and use values for things like a
force in 2D space
which requires a value for force
on both the X and Y axis.
All of our documentation pages are linked together.
If we were to click on Vector2
we would be taken to the documentation

French: 
Regardons leurs descriptions
jusqu'à
trouver celle que nous voulons.
Dans notre cas
choisissons AddForce.
Cela ajoute une pression
au Rigidbody2d.
En conséquence, il commencera à bouger.
Cliquez sur le lien pour aller
à la page sur AddForce.
Nous pouvons voir la
signature de la fonction
en haut de la page.
La signature nous dit que
nous avons besoin d'un
vector2
et en option un ForceMode
pour ajouter une pression
à notre Rigidbody2d.
Qu'est ce qu'un vector2 ?
Pour plus d'information sur
le vector2
utiliser le lien en bas.
Mais en termes simple
un vector2
à deux valeurs décimales
dans un élément.
Cela nous facilite la tache
du déplacement
en utilisant ces valeurs comme
pression dans l'espace 2D
qui requière une valeur
à la fois sur les axes Y et Y.
Toutes nos pages de documentation
sont liées ensemble.
Si nous cliquions sur Vector2
Nous serions portés à la page

English: 
page for Vector2.
The next concept that we need to cover is
how to get a hold of,
or how to reference different
components on our game object.
We're currently writing a script called
PlayerController, which is attached
as a script component
to our Player game object.
>From this script we need to add force
using the Rigidbody2d component.
We want to access that component
from this script.
There are several ways we can do this,
but in our case we'll cover only one
of the main ways of accessing
another component on the same game object.
We'll create a variable to hold
this reference in our script
and we'll set this reference in the Start function.
Let's return to our script.
In our script we need to write

Japanese: 
開きます
次に解決すべき問題は
ゲームオブジェクトの異なるコンポーネントを
どのように捕らえて
参照するかということです
私たちは現在、PlayerController という
スクリプトを作成しています
それはスクリプトコンポーネントとして
Player ゲームオブジェクトにアタッチされています
このスクリプトで Rigidbody2D コンポーネントを使って
力を加えます
スクリプトを通してそのコンポーネントに
アクセスする必要があります
何種類か方法がありますが
同じゲーム上の他のコンポーネントに
アクセスする主な方法のうち
ここでは　1 つだけを取り上げます
スクリプト内で
この参照を記憶する変数を作り
この参照を Start 関数に設定します
スクリプトに戻りましょう
スクリプトに以下を入力します

French: 
de documentation du Vector2.
Le prochain concept que nous
devons aborder est
comment stoker la valeur,
comment lire les différants
composants dans notre game object.
Nous somme en train d'écrire un
script appelé
PlayerController, qui est attaché
à un composant script
de notre game object Player.
À partir de ce script, nous allons
ajouter de la pression
à l'aide du composant Rigidbody2d.
Nous voulons accéder à
ce composant
depuis le script.
Il y a plusieurs façons pour
faire cela,
mais dans notre cas
nous n'en verrons qu'une
seule des principales façons
d'accéder à un
autre composant du même
game object.
Nous allons créer une variable
pour stocker
cette référence dans notre script
et nous affecterons cette référence
dans la fonction Start.
Retournons à notre script.
Dans notre script, nous devons écrire

Japanese: 
Private Rigidbody2D rb2d
これは、参照を記憶する変数を作成します
新しい Start 関数を宣言し
そこに以下を入力します
rb2d = GetComponent ();
FixedUpdate 内で
Vector2 の値を持つ Rigidbody2d.AddForce を
ForceMode をデフォルト設定で
使用します
そして、スクリプトに 
rb2d.AddForce といくつかの Vector2 の値が必要です
さて、どうやって 2 つの float の値を
Vector2 に入力したらよいでしょうか。
まず、新しいVector2 変数を作り
Movement と呼ぶことにします
これは X と Y の値で構成される
新しい Vector2 とイコールで結ばれています
X と Y の値によって 
UFO に加える

English: 
Private Rigidbody2D rb2d
to create the variable to hold the reference.
We're going to declare a new Start function
and in it we're going to write
rb2d = GetComponent ();
In FixedUpdate let's use
Rigidbody2d.AddForce with a vector2
and we'll leave the ForceMode at
default by omitting it from our code
So in our script we need to type
rb2d.AddForce and then some vector2 value.
Now how do we get our two float values
in to a vector2 value?
Let's create a new vector2
variable called Movement.
This will be equal to a new vector2
that's made up of an X and a Y.
The X and Y values will determine
the direction of the force

French: 
Private Rigidbody2D rb2d
pour créer la variable pour
stocker la référence.
Nous allons déclarer une nouvelle
fonction Start
et dedans nous allons écrire
rb2d = GetComponent ();
Dans FixedUpdate utilisons
Rigidbody2d.AddForce avec un vector2
et nous laisserons le ForceMode par
défaut en ne le renseignement pas.
Dans notre script, nous devons donc taper
rb2d.AddForce et une valeur
de forme vector2.
Maintenant, comment pouvons-nous obtenir
nos deux valeurs float
dans une variable de vector2 ?
Créons une nouvelle variable vector2
appelé movement.
qui sera égale à un new vector2
qui est composé d'un X et d'un Y.
Les valeurs X et Y déterminerons
la direction de la pression

English: 
we will add to our UFO.
What is our X value?
That would be moveHorizontal.
With this our left and right keys will
add force moving the UFO to the left or right.
What is our Y?
That would be moveVertical.
Now we use movement,
our new vector2 value in rb2d.AddForce
as rb2d.AddForce(movement)
Let's save this script and return to Unity.
We can check for errors in our footer
or the console, and there are none.
Good.
Now let's test what we've written.
Hit Play.
The first thing we'll notice is that the Player
immediately flies downward off the playing field.
This is because the default for our Rigidbody2D
is to apply gravity downwards
along the Y axis.
Since our game is designed as a

Japanese: 
力の方向が決まります
ここで X 値は何を指すでしょうか
moveHorizontal です
これを使って、左と右のキーは 
UFO を左か右に動かす力を加えます
ここで Y 値は何を指すでしょうか
moveVertical です
rb2d.AddForce の
新しい Vector2 の値 movement を使って
rb2d.AddForce(movement)　とします
スクリプトを保存して Unity に戻ります
フッターかコンソールでエラーを確認できます
エラーはありません
OK です
さて、スクリプトをテストしてみましょう
再生ボタンを押してください
初めに気づくのはPlayer がすぐに
プレイフィールドを外れて、下まで飛んでいってしまうことです
これは、Rigidbody2D のデフォルトで 
Y 軸にそって下向きに重力が
適用されるためです
このゲームはトップダウンビューで

French: 
qui sera ajouté à notre UFO.
Quelle est notre valeur X ?
C'est moveHorizontal.
Avec cela nos touche gauche et droite
ajouterons
une pression qui déplacera
à gauche ou à droite.
Quelle est notre valeur Y ?
C'est moveVertical.
Maintenant utilisons mouvement,
notre valeur de new vector2 dans
rb2d.AddForce
ainsi : rb2d.AddForce(movement).
Sauvegardons ce script et
revenons à Unity.
Nous pouvons vérifier les erreurs
dans le bas de page
de la console, et il n'y en a pas.
Bien.
Maintenant testons ce que
nous avons écrit.
Cliquez sur Play.
La première chose que nous
observons est que le Player
vole immédiatement vers le bas
hors du terrain de jeu.
C'est parce que par défaut
notre Rigidbody2D
applique une gravité vers le bas
le long de l'axe Y.
Comme notre jeu est conçu comme

French: 
une vue de dessus, cela n'a aucun sens.
Quittez le mode Play
Pour éclaircir ce comportement
modifions la proprièté Gravity Scale
de notre Rigidbody2d attaché à notre
Player à 0.
Cela veut dire que aucune gravité
ne sera appliquée.
C'est une des raisons pour
lesquelles faire un
jeu 2D en vue de dessus
est un peu plus facile,
parce que nous n'avons pas à gérer
la gravité dans notre physique.
Maintenant jouons de
nouveau et testons
En utilisant les touches configurées
dans l'InputManager
l'UFO bouge dans la scène.
La gravité est maintenant à 0,
mais le Player
est encore très lent.
C'est probablement trop lent
pour être jouable
mais le concept de base
marche à 100%.
Pour arrêter le test
sortons du mode Play.
Retournons à notre code et créons
un moyen de controler
la vitesse de l'UFO.
Nous avons besoin de multiplier
movement par une valeur.

English: 
top-down view this doesn't make any sense.
Exit Play mode.
To illuminate this behaviour we'll
set the Gravity Scale property
of our Rigidbody2d attached to our Player
to 0.
This means that no gravity
will be applied.
This is one reason why making a top-down
2D game is a little easier,
because we don't have to deal with gravity in our physics.
Now play again and test.
By using the keys setup in the InputManager
the UFO moves in the scene.
Gravity is now off, but the player
is still very slow.
This is probably too slow to be playable
but the basic concept works 100%.
To stop testing exit Play mode.
Let's return to our code and create a
tool that will give us control over
the speed of the UFO.
We need to multiply our movement
by some value.

Japanese: 
デザインされているので適切でありません
Play モードを閉めます
このビヘイビアを取り除くために
Player にアタッチしている Rigidbody2D の 
Gravity Scale プロパティーを
0 に設定します
つまり、重力の影響を
無しにします
これが、トップダウン 2D ゲームを作るのが
少し簡単である理由の 1 つです
物理演算で重力を考えなくてよいからです
では、もう 1 度プレイしてテストしましょう
InputManager で設定したキーを使って
UFO はシーン内で動きます
重力はオフですが、プレイヤーの動きは
まだ、かなり遅いです
プレイするには多分遅すぎます
ただし、基本コンセプトは完璧です
テストを終わらせるには Play モードを終了します
コードに戻り、
UFO のスピードを制御する
ツールを作りましょう
ある値で movement を乗ずる
必要があります

Japanese: 
その値は、単純にスクリプトに加えることもできますが
ただし、調整や変更が
必要になった場合は
スクリプトエディターに戻り
スクリプトの値を変更し
リコンパイルしなくてはなりません
これでは時間がかかります
解決策として、スクリプトに
パブリックの変数を作成します
では、パブリックの float 型の Speed を作りましょう
スクリプトにパブリックの変数を作ることで
この変数は編集可能なプロパティーとして
Inspector に表示されます
パブリック変数を使うと 
すべての変更をエディターで行えます
それでは、movement を speed で乗じてみましょう
この方法を使うと
エディターで
movement の値を制御できます
この変更を保存して Unity に戻ります
エディターにもどると
PlayerController Script　に
Speed プロパティーがあることに気づきます

French: 
On peut entrer cette valeur ici
dans notre script, mais si jamais
on avait besoin de faire
des réglages ou des changements
nous devrions
retourner dans l'éditeur de script
et changer la valeur dans le script,
puis recompiler.
Cela prendrait du temps.
La solution est de créer une
variable public dans notre script.
Créons une variable public float
appelée speed.
En créant une variable public dans
notre script
cette variable apparaîtra
dans l'inspecteur
comme une propriété éditable.
Quand on utilise une variable public
on peut
faire tous les changements
dans l'éditeur.
Multiplions movement par speed.
Qui nous permettra de controler
la valeur movement depuis
l'éditeur.
Sauvegardons ces changements
et retournons à Unity.
Quand nous retournons à l'éditeur
nous pouvons voir
notre script PlayerController
qui maintenant a une propriété Speed.

English: 
We could simply enter that value here
on our script, but if we ever needed to make any
tweaks or changes we would have
to return to our scripting editor
and change the value in the script,
and then recompile.
This would take time.
The solution is to create a public
variable in our script.
Let's create a public float called Speed.
By creating a public variable in our script
this variable will show up in the inspector
as an editable property.
When we use a public variable we can
make all of our changes in the editor.
Let's now multiply movement by speed.
We can use this to control
our movement value from
inside the editor.
Let's save these changes and return to Unity.
When we return to the editor we can see
our PlayerController script
now has a Speed property.

French: 
Mettons cette propriété à 1000.
Cliquons sur Play et testons.
Ça fonctionne, mais Player
se déplace
trop vite !
Mais le modifier est
rapide aussi.
Sortons du mode Play et
changeons la valeur à 10.
C'est mieux !
Félicitations, on peut maintenant
déplacer
notre Player.
Vous remarquerez cependant
que le joueur peut
voler à travers les murs,
ce n'est pas ce que l'on veut.
Dans la prochaine leçon nous
ajouterons des détecteurs de collisions.
Sous-titres réalisés par la communauté d’Amara.org

English: 
Let's set this property to 1000.
Play the scene and test.
It works, but the Player is moving
way too fast!
But changes are fast too.
Let's exit Play mode and let's
change the value to 10.
That's better!
Congratulations, we can now move our
Player character.
You'll notice however that the player can just
fly through the walls, which is not what we want.
In the next lesson we'll add collision detection.
Subtitles by the Amara.org community

Japanese: 
このプロパティーを 1000 に設定しましょう
シーンを再生しテストします
動きますが、プレイヤーの動きが
速すぎますね。
でも、変更も素早くできますよ
プレイモードを終了して
値を 10 に変えましょう
良くなりました
よくできました。プレイヤーを
動かせるようになりました
ただし、壁を通り抜けて飛ぶだけです
これは、私たちの望んでいるものとは違います
次のレッスンでは、衝突の検出を加えます
