Créez votre jeu Facebook et Unity - Introduction à l'API de Facebook | Simpliv

Créez votre jeu Facebook et Unity - Introduction à l'API de Facebook | Simpliv

Créez votre jeu Facebook et Unity - Introduction à l'API de Facebook

Description
Découvrez l'API de Facebook, connectez des milliers de joueurs, créez un Flappy Bird like avec Unity sur navigateur web.

Formation pour apprendre à créer votre un JEU VIDÉO 2D web avec Facebook et Unity, de type Flappy Bird.

Bienvenue dans cette formation axée sur l'utilisation de Facebook avec Unity afin d'apprendre les fonctionnalités indispensables à tout jeu vidéo utilisant Facebook :

Créer une application Facebook
Héberger son jeu vidéo
Authentification
Récupération des informations de l'utilisateur (dont l'avatar)
Partager du contenu la timeline de l'utilisateur
Retrouver ici les principes de base du développement de jeux vidéos avec facebook, tout en utilisant le langage C# dans les scripts.


Dernière Mise à jour Mars 2019

La première section vous permettra de créer votre première application Facebook, choix de la plateforme WebGL, hébergement web, découverte du dashboard Facebook, déployer sur les serveurs... vous verrez ainsi les bases des services Facebook, sans oublier le paramétrage de Unity.

Dans la seconde section nous mettrons en place les bases du jeu vidéo qui sera crée dans ce cours. Ainsi nous commencerons concrètement le développement de votre jeu vidéo :

Etude du package initial du jeu
Création d'un prefab heart
Gestion de la vie du joueur
Prise en main du projet
Nous verrons donc comment gérer les collisisions 2D, notion de layer et order in layer, utiliser un rigidbody...

La troisième section entre dans l'API Facebook, afin de pouvoir se connecter. L'API sera ainsi étudiée, puis mise en place dans un script qui sera à intégrer par vos soins, dans le jeu vidéo.

Nous en profiterons pour générer les prefabs coeur tout en utilisant une interface pour visualiser les vies à l'écran.

Une fois connectés, il sera temps d'afficher les informations dans la section 4. Le graphe de Facebook sera présentée afin de comprendre la requête sur le noeud "me" qui permettra entre autres, de récupérer le pseudo du joueur.

De plus nous verrons la notion de pooler, notion essentielle dans la création de jeux vidéos, puis nous l'utiliserons pour générer efficacement nos coeurs.

Le tout sera affiché à l'écran, puis un test en ligne sur le serveur sera effectué. Enfin l'implémentation de la récupération de l'avatar sera traitée en exercice.

Pour terminer nous verrons dans la section 5, comment partager du contenu sur Facebook. La méthode ShareLink du sdk Facebook pour Unity sera utilisée est utilisée dans notre jeu vidéo tout en modifiant le comportement initial du jeu au GameOver.

Une nouvelle interface sera donc mise en place et le script GameControl sera modifié en conséquence... Nous verrons donc comment créer des boutons et leur donner une action à accomplir grâce à l'EventSystem de Unity.

Nous utiliserons aussi PlayerPrefs afin d'enregistrer le pseudo et l'avatar du joueur.

Note: l'accès à ce cours vous offre aussi la possibilité de rejoindre gratuitement la communauté Make Your Game, et ainsi retrouver plus de contenu sur la création de jeux vidéos: https://makeyourgame.fun

Toutes les vidéos sont enregistrées en 1080p, assurant une qualité optimale de votre visionnage.

Si vous rencontrez des difficultés en cours d'apprentissage, vous pouvez me contacter par email et je ferai de mon possible pour vous débloquer.

N'hésitez plus et plongez dans la création de votre premier jeu, avec Facebook et Unity, en cliquant sur Suivre ce cours en haut à droite.

Basic knowledge
Afin de pouvoir suivre sereinement le cours, voici les pré-requis:

Avoir des bases dans le langage c-sharp (C#)
Les bases de l'utilisation de Unity
Ce cours n'est donc pas destiné aux débutants.es, si c'est votre cas, veuillez plutôt commencer votre apprentissage par un autre cours: Apprenez à coder en C# tout en créant votre propre jeu avec Unity 2018

Voici un code de réduction de 50% : 2019-FB-50 / 50 %

Si le code ne fonctionne pas, merci de me contacter par email sur: [email protected]

What will you learn
Dans ce cours vous apprendrez à :

Créer une application Facebook avec Unity
Découvrir Facebook et son API
Se connecter avec Facebook
Récupérer les informations de l'utilisateur Facebook
Découvrir le graphe de Facebook
Afficher l'avatar du joueur dans l'application
Héberger gratuitement son jeu vidéo sur les serveurs de Facebook
Partager sur la timeline Facebook du joueur depuis le jeu vidéo
Utiliser un pooler
Créer des interfaces (IHM) simples
Gérer les permissions Facebook
Utiliser le sdk Facebook pour Unity

Maîtrisez l'audio avec Unity - Créez votre AudioManager | Simpliv

Maîtrisez l'audio avec Unity - Créez votre AudioManager | Simpliv

Maîtrisez l'audio avec Unity - Créez votre AudioManager

Description
Bienvenue dans cette formation complète sur l'API Audio de Unity.

Avec plus de 6 heures de formation, vous allez créer votre premier AudioManager qui vous permettra de gérer avec facilité vos sons dans vos jeux vidéos, et vous étudierez aussi certains cas d'études typiques des jeux vidéos.

Vous apprendrez ainsi comment maîtrisez l'audio sous Unity en commençant par les bases, puis progressivement comment créer des ambiances de jeu différentes gérées par script, en utilisant les snapshot et les effets.

De plus nous utiliserons le microphone du device pour recréer un My TomTalking Like.


Dernière Mise à jour Mars 2019

I/ Les bases de l'Audio

La première section reprend les bases de l'API Audio en présentant :

AudioClip
AudioSource
AudioListener
Utilisation concrète de l'API pour jouer une musique de fond et bien d'autres choses.
II/ Première version de l'AudioManager

Puis nous verrons comment créer la première version de notre AudioManager, qui jouera le rôle de centralisateur des sons. "Un anneau pour les unifier..." Vous prendrez ainsi le rôle de développeur afin d'implémenter la gestion de vos sons.

Tout passera par lui, musique comme bruitages, permettant de simplifier le process des lancements d'AudioClip dans votre jeu vidéo.

III/ Présentation de l'AudioMixer

L'AudioMixer sera ensuite présenté afin de pouvoir mixer nos AudioClip et de régler très facilement les niveaux sonores de nos sons. (AudioMixerGroup, Soloed, Mute, Views, Colors, Hiérarchie des AudioGroup...)

Cette étude théorique est bien sûr toujours accompagnée de mises en pratiques, comme l'ajout d'une musique d'ambiance supplémentaire.

IV/ Amélioration de l'AudioManager

Cette section nous amènera sur la finalisation de notre AudioManager:

prise en charge des sons 3D
ajout de la gestion d'AudioMixerGroup sur l'AudioManager
modifications du script initial
V/ Etude des effets

Cette partie présente certains effets (lowpass, echo, reverb...) ainsi que leur utilisation sur la table de mixage.

Un premier cas d'étude sera ajouté très prochainement.

Les snapshots permettent d'apporter des ambiance de sons différentes de manière simplifiée. Nous allons voir ici comment changer d'ambiance par script, tout en préparant notre table de mixage.

VI/ Etude de cas : son étouffé

En partant d'un package existant, nous allons ajouter progressivement différents sons et musiques d'ambiance, tout en utilisant encore une fois les snapshots. Ainsi nous pourrons changer par script, l'ambiance générale de notre scène.

VII/ Développement de My Tom Talking Like

En réutilisant les connaissances acquises à travers ce cours, nous allons recréer cette application qui permet d'enregistrer une voix, puis de la déformer avant de l'entendre de nouveau.

Note: l'accès à ce cours vous offre aussi la possibilité de rejoindre gratuitement la communauté Make Your Game, et ainsi retrouver plus de contenu sur la création de jeux vidéos: https://makeyourgame.fun

Tous les sons utiles sont mis à disposition afin de pouvoir suivre la formation. A chaque fois une référence à l'auteur sera faite.

Toutes les vidéos sont enregistrées en 1080p, assurant une qualité optimale de votre visionnage.

La formation dispose aussi d'exercices pour valider vos acquis.

N'hésitez plus et maîtrisez l'API Sound de Unity en cliquant sur Suivre ce cours en haut à droite.

Basic knowledge
Bases d'utilisation de Unity
Bases de programmation orientée Objet
Unity 5,Unity 2017, ou Unity 2018 installé ...une vidéo vous indiquera comment installer Unity avec Unity Hub
What will you learn
Gérer les sons 2D/3D depuis Unity 5 (compatible Unity 2017 et 2018)
Gérer les AudioMixer
Créer des snapshots
Utiliser le microphone du device pour enregistrer et déformer notre voix
Créer un My Talking Tom Like
Gérer les effets
Exploiter les snapshots par script pour créer des ambiances de jeux
Gérer les niveaux sonores de votre jeu vidéo
Utiliser son outil d'AudioManager
Exporter un package finalisé

What the difference between REST API and RESTful API?

What the difference between REST API and RESTful API?

Representational state transfer (REST) is a style of software architecture. As described in a dissertation by Roy Fielding, REST is an "architectural style" that basically exploits the existing technology and protocols of the Web. RESTful is typically used to refer to web services implementing such an architecture.

The short answer is that REST stands for Representational State Transfer. It’s an architectural pattern for creating web services. A RESTful service is one that implements that pattern.

The long answer starts with “sort of” and “it depends” and continues with more complete definitions.

Defining REST

Let’s start by defining what REST is and is not. For some, REST means a server that exchanges JSON documents with a client over HTTP. Not only is that not a complete definition, but it’s also not always true. The REST specification doesn’t require HTTP or JSON. (The spec doesn’t mention JSON or XML at all.)

The Origins of REST

Roy Fielding introduced the REST architectural pattern in a dissertation he wrote in 2000. The paper defines a means for clients and servers to exchange application data. A key feature is that the client doesn’t need to know anything about the application in advance. The link is to chapter five of his paper. While the entire dissertation describes the hows and whys of REST, that chapter defines the architectural pattern.

Fielding doesn’t mandate specific requirements. Instead, he defines REST regarding constraints and architectural elements.

REST’s Architectural Constraints

Here is a summary of the constraints.

  • Client-server – REST applications have a server that manages application data and state. The server communicates with a client that handles the user interactions. A clear separation of concerns divides the two components. This means you can update and improve them in independent tracks.
  • Stateless – servers don’t maintain any client state. Clients manage their application state. Their requests to servers contain all the information required to process them.
  • Cacheable – servers must mark their responses as cacheable or not. So, infrastructures and clients can cache them when possible to improve performance. They can dispose of non-cacheable Information, so no client uses stale data.
  • Uniform interface – this constraint is REST’s most well known feature or rule, depending on who you ask. Fielding says “The central feature that distinguishes the REST architectural style from other network-based styles is its emphasis on a uniform interface between components.” REST services provide data as resources, with a consistent namespace. We’ll cover this in detail below.
  • Layered system – components in the system cannot “see” beyond their layer. So, you can easily add load-balancers and proxies to improve security or performance.

A RESTful service is more than a web server that exchanges JSON, or any other, documents. These constraints work together to create a very specific type of application.

Applying the Constraints

First, the client-server, layered systems and stateless constraints combine to form an application with solid boundaries and clear separations between concerns. Data moves from the server to the client upon request. The client displays or manipulates it. If the state changes, the client sends it back to the server for storage. Fielding specifically contrasts REST with architectures that use distributed objects to hide data from other components. In REST, the client and server share knowledge about data and state. The architecture doesn’t conceal data, it only hides implementations.

The cacheable and uniform state constraints go one step further. Application data is available to clients in a clear and consistent interface and cached when possible.

So, that’s the technical definition of REST. What does it look like in the real world?

RPC Over HTTP vs. RESTful

Often when someone says that a service “isn’t REST,” they’re looking at the URIs or how the service uses HTTP verbs. They’re referring to REST’s presentation of data as a uniform set of resources.

This distinction is sometimes framed as a difference between remote procedures calls (RPC) and REST. Imagine a web service for listing, adding, and removing, items from an e-commerce inventory.

In one version, there’s a single URL that we query with HTTP GETs or POSTs.  You interact with the service by POSTing a document, setting the contents to reflect what you want to do.

Add new items with a POST with a NewItem:

POST /inventory HTTP/1.1
 
{
    "NewItem": {
          "name": "new item",
          "price": "9.99",
          "id": "1001"
      }
}    

Query for items with a POST and an ItemRequest:

POST /inventory HTTP/1.1
 
{
    "ItemRequest": {
          "id": "1001"
      }
}

Some implementations accept a request for a new item with a get, too.

POST /inventory?id=1001 HTTP/1.1

We also change or delete items with a POST and an ItemDelete or ItemUpdate.

POST /inventory HTTP/1.1
 
{
    "ItemDelete": {
          "id": "1001"
      }
}

This isn’t REST. We’re not exchanging the state of resources. We’re calling a function with arguments that happen to be in a JSON document or URL arguments.

A RESTful service has a URI for each item in the inventory.

So, adding a new item would look like the example above.

POST /item HTTP/1.1
 
{
    "Item": {
          "name": "new item",
          "price": "9.99",
          "id": "1001"
      }
}    

But the similarities end there. Retrieving an item is always a GET:

GET /item/1001 HTTP/1.1   

Deleting is a DELETE:

DELETE /item/1001 HTTP/1.1  

Modifying an item is a PUT:

POST /inventory HTTP/1.1
 
{
    "Item": {
          "name": "new item",
          "price": "7.99",
          "id": "1001"
      }
}    

The difference is important. In REST, operations that use distinct HTTP actions. These verbs correspond directly to the activity on the data. GET, POST, PUT, DELETE and PATCH all have specific contracts. Most well-designed REST APIs also return specific HTTP codes, depending on the result of the request.

The critical point is that the URIs operate on the data, not on remote methods.

But there’s another reason why the resource model is essential.

REST vs RESTful and the Richardson Maturity Model

When you model your URIs after resources and use HTTP verbs you make your API predictable. Once developers know how you defined your resources, they can almost predict what the API looks like. Here again, the emphasis is on understanding the data, not the operations.

But even if you can’t make the API entirely predictable, you can document any REST service with hypertext. So, each item returned in the inventory app would contain links for deleting, modifying, or setting the inventory level of the resource. Fielding says that before a service is RESTful, it must provide hypertext media as part of the API.

Many sites don’t meet this requirement but are still called REST. Fact is, many sites break the rules in one way or another. So many that Leonard Richardson created a model breaks down REST into levels of compliance

We’ve already covered the source levels:

  • 0 – exporting an API over HTTP with methods called with arguments
  • 1 – Exporting resources instead of methods
  • 2 – Proper use of HTTP verbs
  • 3 – Exporting hypertext with objects that make all or part of the API discoverable.

Richardson’s model is his own, and it doesn’t map directly into Fielding’s spec. Since Fielding requires level three, he would say that most apps aren’t REST anyway.

The point is many services that we colloquially refer to as REST, technically aren’t.

REST vs RESTful: Does It Matter?

So, does the REST vs. RESTful comparison matter? Probably not. How well your architecture complies with an arbitrary standard isn’t as important with how well it suits your needs and can grow with your business.

The REST architectural pattern has many advantages. Fielding designed it for the web and, 18 years later, most of the constraints he had in mind are still with us. In 2000 we didn’t have Android or the iPhone. IE5 had 50% of the browser market share. It’s biggest rival was Firefox. But Fielding recognized what online applications needed and how web clients would evolve from HTML display engines into complete applications. The tools we use today have grown to suit REST, not the other way around.

Thank you for reading. Hope this tutorial will help you!

APIs for Beginners - What is an API? How to use an API?

APIs for Beginners - What is an API? How to use an API?

APIs for Beginners, What exactly is an API? How do you use an API? Learn all about APIs in this full course for beginners. Learn how to use Postman and helper libraries in both JavaScript and Python. Lean how to create a project using an API using both Node.js and Flask. Learn what APIs do, why APIs exist, and the many benefits of APIs. Explore APIs online

APIs for Beginners - What is an API? How do you use an API? Learn all about APIs (Application Programming Interfaces) in this full course for beginners. You will learn what APIs do, why APIs exist, and the many benefits of APIs. APIs are used all the time in programming and web development so it is important to understand how to use them.

You will also get hands-on experience with a few popular web APIs. As long as you know the absolute basics of coding and the web, you'll have no problem following along.

⭐️ Course Contents ⭐️

⭐️ Unit 1 - What is an API
⌨️ Video 1 - Welcome (0:00:00)
⌨️ Video 2 - Defining Interface (0:03:57)
⌨️ Video 3 - Defining API (0:07:51)
⌨️ Video 4 - Remote APIs (0:12:55)
⌨️ Video 5 - How the web works (0:17:04)
⌨️ Video 6 - RESTful API Constraint Scavenger Hunt (0:22:00)

⭐️ Unit 2 - Exploring APIs
⌨️ Video 1 - Exploring an API online (0:27:36)
⌨️ Video 2 - Using an API from the command line (0:44:30)
⌨️ Video 3 - Using Postman to explore APIs (0:53:56)
⌨️ Video 4 - Please please Mr. Postman (1:03:33)
⌨️ Video 5 - Using Helper Libraries (JavaScript) (1:14:41)
⌨️ Video 6 - Using Helper Libraries (Python) (1:24:40)

⭐️ Unit 3 - Using APIs
⌨️ Video 1 - Introducing the project (1:34:18)
⌨️ Video 2 - Flask app (1:36:07)
⌨️ Video 3 - Dealing with API Limits (1:50:00)
⌨️ Video 4 - JavaScript Single Page Application (1:54:27)
⌨️ Video 5 - Moar JavaScript and Recap (2:07:53)
⌨️ Video 6 - Review (2:18:03)