PHP class_link函数代码示例

, et retourne
    une instance de <?php 
class_link("Http::Response", "Http_1_1Response");
?>
.
</p>
<p>
    C'est tout pour ce qui est de l'interface de la classe <?php 
class_link("Http");
?>
, seulement deux fonctions !
    Il n'y a même pas besoin de se déconnecter du serveur, étant donné que c'est fait automatiquement après chaque
    appel à <code>SendRequest</code>.
</p>

<?php 
h2('Conclusion');
?>
<p>
    La classe <?php 
class_link("Http");
?>
 est un outil puissant pour manipuler le protocole HTTP, et accéder à des pages web
    ou à des fichiers via internet.<br/>
    Jetons maintenant un oeil à son frère, le
    <a class="internal" href="./network-ftp-fr.php" title="Aller au tutoriel suivant">protocole FTP</a>.

</p>

<?php 
require "footer-fr.php";

</code></pre>
<p>
    Puis, vous pouvez attendre les connexions sur ce port.
</p>
<pre><code class="cpp">sf::IPAddress ClientAddress;
sf::SocketTCP Client;
if (Listener.Accept(Client, &amp;ClientAddress) != sf::Socket::Done)
{
    // Erreur...
}
</code></pre>
<p>
    La fonction <code>Accept</code> va attendre jusqu'à ce qu'une connexion arrive,
    puis renvoyer un nouveau socket qui sera utilisé pour échanger les données avec l'ordinateur
    connecté. Si vous passez une instance de <?php 
class_link("IPAddress");
?>
 à la fonction,
    celle-ci sera initialisée avec l'adresse du client (pratique pour savoir qui vient de se connecter).<br/>
    Si la socket est en mode non-bloquant, cette fonction rendra la main immédiatement si aucune connexion n'est en attente,
    et renverra le code <code>sf::Socket::NotReady</code>.
</p>
<p>
    Regardons maintenant comment ça se passe du côté du client. Tout ce que vous avez à faire est créer
    un socket puis le connecter au serveur sur le port que ce dernier écoute.
</p>
<pre><code class="cpp">sf::SocketTCP Client;
if (Client.Connect(4567, "192.168.0.2") != sf::Socket::Done)
{
    // Erreur...
}

                             DefaultVisual(Disp, Screen),
                             0, NULL);

// Et enfin on affiche nos fenêtres fraîchement créées
XMapWindow(Disp, Win);
XMapWindow(Disp, View);
XFlush(Disp);
</code></pre>

<?php 
h2('Définition d\'une vue SFML');
?>
<p>
    Une fois que tous les composants de l'interface ont été créés, nous pouvons définir notre vue SFML. Pour ce faire,
    nous avons juste à construire une instance de <?php 
class_link("RenderWindows");
?>
 et à lui passer l'identificateur de
    la fenêtre X11 :
</p>
<pre><code class="cpp">sf::RenderWindow SFMLView(View);

// Ou, si vous souhaitez le faire après la construction :

SFMLView.Create(View);
</code></pre>
<p>
    Et voilà, vous avez une fenêtre de rendu SFML intégrée à votre interface X11.
</p>

<?php 

</code></pre>
<p>
    Mais revenons à nos moutons : comment une telle transformation peut-elle être appliquée à une entité graphique ? C'est facile : passez-la à la fonction <code>draw</code>.
</p>
<pre><code class="cpp">window.draw(entity, transform);
</code></pre>
<p>
    ... ce qui est en fait un raccourci pour :
</p>
<pre><code class="cpp">sf::RenderStates states;
states.transform = transform;
window.draw(entity, states);
</code></pre>
<p>
    Si votre entité est un <?php 
class_link('Transformable');
?>
 (sprite, texte, forme), avec sa propre transformation interne, alors les deux sont combinées pour produire
    la transformation finale.
</p>

<?php 
h2('Boîtes englobantes');
?>
<p>
    Après avoir transformé et dessiné vos entités, vous voudrez certainement effectuer certains calculs avec elles, comme par exemple détecter les collisions.
</p>
<p>
    Les entités SFML peuvent vous donner leur boîte englobante. La boîte englobante est le rectangle minimal qui contient l'entité, et dont les côtés sont alignés sur
    les axes X et Y.
</p>

    L'autre solution est d'utiliser des sélecteurs. Les sélecteurs permettent de multiplexer un ensemble
    de sockets, sans avoir à faire tourner un autre thread. Ils sont toujours bloquants, mais rendront
    la main dès que l'un des sockets est prêt. Les sélecteurs peuvent aussi utiliser une valeur de
    <em>timeout</em>, pour éviter d'attendre indéfiniment.
</p>

<?php 
h2('Gérer plusieurs clients');
?>
<p>
    Il existe deux types de sélecteurs dans la SFML : <?php 
class_link("SelectorTCP", "Selector");
?>
 (pour les sockets TCP) et
    <?php 
class_link("SelectorUDP", "Selector");
?>
 (pour les sockets UDP). Cependant seul le type de socket diffère, les
    fonctions et le comportement sont exactement les mêmes pour les deux classes.
</p>
<p>
    Donc, tentons d'utiliser un sélecteur TCP. Ici nous allons construire un serveur qui sera
    capable de gérer plusieurs clients à la fois, sans utiliser le moindre thread.
</p>
<pre><code class="cpp">#include &lt;SFML/Network.hpp&gt;

sf::SelectorTCP Selector;
</code></pre>
<p>
    Les sélecteurs se comportent comme des tableaux : vous pouvez ajouter (<code>Add</code>) et retirer
    (<code>Remove</code>) des sockets, ou encore les vider (<code>Clear</code>). Ici nous allons

</p>
<pre><code class="cpp">unsigned int Seed = 10;
sf::Randomizer::SetSeed(Seed);
</code></pre>
<p>
    Vous pouvez également récupérer la graine courante :
</p>
<pre><code class="cpp">unsigned int Seed = sf::Randomizer::GetSeed();
</code></pre>

<?php 
h2('Générer des nombres aléatoires dans des intervalles spécifiques');
?>
<p>
    <?php 
class_link("Randomizer");
?>
 fournit deux fonctions pour générer des nombres aléatoires dans des intervalles donnés.
</p>
<p>
    La première génère des nombres entiers :
</p>
<pre><code class="cpp">// Renvoie un nombre entier aléatoire entre 0 et 100
int Random = sf::Randomizer::Random(0, 100);
</code></pre>
<p>
    Et la seconde génère des flottants :
</p>
<pre><code class="cpp">// Renvoie un nombre réel aléatoire entre -1 et 1
float Random = sf::Randomizer::Random(-1.f, 1.f);
</code></pre>

<p class="important">
    Un son ne peut être spatialisé que s'il ne possède qu'un canal, i.e. si c'est un son mono.<br/>
    La spatialisation est désactivée pour les sons qui possèdent plus de canaux, étant donné qu'ils donnent déjà explicitement leur utilisation des
    haut-parleurs. Il est très important de garder cela en tête.
</p>

<?php 
h2('L\'écouteur');
?>
<p>
    Tous les sons et musiques de votre environnement audio seront entendus par un acteur unique : l'<em>écouteur</em>. Ce qui est restitué à travers
    vos haut-parleurs, c'est ce que l'écouteur entend.
</p>
<p>
    La classe qui définit les propriétés de l'écouteur est <?php 
class_link("Listener");
?>
. Comme l'écouteur est unique dans l'environnement, cette classe ne
    contient que des fonctions statiques et ne doit pas être instanciée.
</p>
<p>
    Tout d'abord, vous pouvez modifier la position de l'écouteur dans la scène :
</p>
<pre><code class="cpp">sf::Listener::setPosition(10.f, 0.f, 5.f);
</code></pre>
<p>
    Si votre monde est en 2D, vous pouvez utiliser la même valeur Y partout, typiquement 0.
</p>
<p>
    En plus de sa position, vous pouvez définir l'orientation de l'écouteur :
</p>

</p>

<?php 
h2('Joystick');
?>
<p>
    The class that provides access to the joysticks' states is <?php 
class_link("Joystick");
?>
. Like the other classes in this tutorial, it only contains static
    functions.
</p>
<p>
    Joysticks are identified by their index (0 to 7, since SFML supports up to 8 joysticks). Therefore, the first argument of every function of
    <?php 
class_link("Joystick");
?>
 is the index of the joystick that you want to query.
</p>
<p>
    You can check whether a joystick is connected or not:
</p>
<pre><code class="cpp">if (sf::Joystick::isConnected(0))
{
    // joystick number 0 is connected
    ...
}
</code></pre>
<p>
    You can also get the capabilities of a connected joystick:
</p>

if (response.isOk())
{
    const std::vector<std::string>& listing = response.getListing();
    for (std::vector<std::string>::const_iterator it = listing.begin(); it != listing.end(); ++it)
        std::cout << "- " << *it << std::endl;
}

// you can also get the listing of a sub-directory of the current directory:
response = ftp.getDirectoryListing("subfolder");
</code></pre>
<p>
    <?php 
class_link("Ftp::ListingResponse");
?>
 is a specialized <?php 
class_link("Ftp::Response");
?>
 that also contains the requested directory/file names.
</p>
<p>
    Changing the current directory:
</p>
<pre><code class="cpp">ftp.changeDirectory("path/to/new_directory"); // the given path is relative to the current directory
</code></pre>
<p>
    Going to the parent directory of the current one:
</p>
<pre><code class="cpp">ftp.parentDirectory();
</code></pre>
<p>
    Creating a new directory (as a child of the current one):

    The style parameter can be a combination of the <code>sf::Style</code> flags, which are
    <code>None</code>, <code>Titlebar</code>, <code>Resize</code>, <code>Close</code> and <code>Fullscreen</code>. The default style is
    <code>Resize | Close</code>.
</p>
<pre><code class="cpp">// This creates a fullscreen window
App.Create(sf::VideoMode(800, 600, 32), "SFML Window", sf::Style::Fullscreen);
</code></pre>

<?php 
h2('Video modes');
?>
<p>
    In the example above, we don't care about the video mode because we run in windowed mode ; any
    size will be ok. But if we'd like to run in fullscreen mode, only a few modes would be allowed.
    <?php 
class_link("VideoMode");
?>
 provides an interface for getting all supported video modes,
    with the two static functions <code>GetModesCount</code> and <code>GetMode</code> :
</p>
<pre><code class="cpp">unsigned int VideoModesCount = sf::VideoMode::GetModesCount();
for (unsigned int i = 0; i &lt; VideoModesCount; ++i)
{
    sf::VideoMode Mode = sf::VideoMode::GetMode(i);

    // Mode is a valid video mode
}
</code></pre>
<p>
    Note that video modes are ordered from highest to lowest, so that
    <code>sf::VideoMode::GetMode(0)</code> will always

</p>
<p>
    It is also possible to get the current playing position, in seconds :
</p>
<pre><code class="cpp">float Position = Sound.GetPlayingOffset();
</code></pre>
<p>
    As usual, no cleanup is needed : all audio classes will free their resources automatically.
</p>

<?php 
h2('Sound buffers and sounds management');
?>
<p>
    You have to be particularly careful when manipulating sound buffers. A <?php 
class_link("SoundBuffer");
?>
    instance is a resource which is slow to load, heavy to copy and uses a lot of memory.
</p>
<p>
    For a good discussion about resource management, I suggest you read the <strong>"Images and sprites management"</strong>
    part of the <a class="internal" href="./graphics-sprite.php" title="Sprites tutorial">sprites tutorial</a>, just
    replacing the word "Image" with "SoundBuffer" and "Sprite" with "Sound".
</p>

<?php 
h2('Conclusion');
?>
<p>
    Now that you can play sounds, let's have a look at how to
    <a class="internal" href="./audio-music.php" title="Go to the next tutorial">play musics</a>.

sf::Texture texture;
texture.loadFromStream(stream);
</code></pre>

<?php 
h2('Common mistakes');
?>
<p>
    Some resource classes are not loaded completely after <code>loadFromStream</code> has been called. Instead, they continue to read from their
    data source as long as they are used. This is the case for <?php 
class_link("Music");
?>
, which streams audio samples as they are played, and for
    <?php 
class_link("Font");
?>
, which loads glyphs on the fly depending on the text that is displayed.
</p>
<p>
    As a consequence, the stream instance that you used to load a music or a font, as well as its data source, must remain alive as long as the resource
    uses it. If it is destroyed while still being used, the behaviour is undefined (can be a crash, corrupt data, or nothing visible).
</p>
<p>
    Another common mistake is to return whatever the internal functions return directly, but sometimes it doesn't match what SFML expects.
    For example, in the FileStream example above, one might be tempted to write the <code>seek</code> function as follows:
</p>
<pre><code class="cpp">sf::Int64 FileStream::seek(sf::Int64 position)
{
    return std::fseek(m_file, position, SEEK_SET);
}</code></pre>

<pre><code class="cpp">sf::Vertex line[] =
{
    sf::Vertex(sf::Vector2f(10, 10)),
    sf::Vertex(sf::Vector2f(150, 150))
};

window.draw(line, 2, sf::Lines);
</code></pre>
<img class="screenshot" src="./images/graphics-shape-line-primitive.png" alt="Une ligne sans épaisseur"/>

<?php 
h2('Formes personnalisées');
?>
<p>
    Vous pouvez étendre l'ensemble des classes de formes avec vos propres types de formes. Pour ce faire, vous devez dériver de <?php 
class_link('Shape');
?>
 et redéfinir
    deux fonctions :
</p>
<ul>
    <li><code>getPointCount</code>: renvoie le nombre de points de la forme</li>
    <li><code>getPoint</code>: renvoie un point de la forme</li>
</ul>
<p>
    Vous devez également appeler la fonction protégée <code>update()</code> à chaque fois que les points de la forme changent, de sorte que la classe de base en soit informée
    et puisse recalculer ce dont elle a besoin.
</p>
<p>
    Voici un exemple complet de classe de forme personnalisée : EllipseShape.
</p>

    To modify or append special data to the buffer, you can then use the <code>Clear()</code> function
    (to clear the internal buffer), <code>Append()</code> (to add raw data), or the &lt;&lt; operator.
</p>
<p>
    Custom packets can be useful in many situations : encryption, compression, adding checksums, filtering received
    data, ...
    You can even provide formatted packets using a fixed structure, or packets that
    act like factories.
</p>

<?php 
h2('Conclusion');
?>
<p>
    The <?php 
class_link("Packet");
?>
 class wraps a lot of low-level network issues, and provides an easy way
    to transfer data with sockets. I encourage you to extend packets to your needs, by overloading
    &lt;&lt; and &gt;&gt; operators, and deriving your own packets classes if necessary.
</p>
<p>
    It is important to remember that SFML packets use their own endianess and structure, so you cannot use
    them to communicate with servers that are not using them. To send raw data, HTTP / FTP requests,
    or whatever not built with SFML, use arrays of bytes instead of SFML packets.
</p>
<p>
    You are now ready to jump to the last tutorial, about
    <a class="internal" href="./network-selector.php" title="Go to the next tutorial">using selectors</a>.
</p>

<p>
    Note: the <code>Download</code> and <code>Upload</code> function may take time to complete, depending on the size of
    file to transfer. If you don't want to block your application it may be a good idea to execute them in a separate
    thread.
</p>
<p>
    <code>KeepAlive</code> is a special function that does nothing. Many FTP servers automatically disconnect clients
    after several minutes of inactivity ; this function can be called when nothing happens, to prevent this
    automatic disconnection.
</p>
<pre><code class="cpp">Server.KeepAlive();
</code></pre>
<p>
    <code>Disconnect</code> disconnects the client from the server. Calling it is not mandatory (but recommended),
    as it is done when the <?php 
class_link("Ftp");
?>
 instance gets destructed.
</p>
<pre><code class="cpp">Server.Disconnect();
</code></pre>

<?php 
h2('Conclusion');
?>
<p>
    This was the last tutorial about the network package. You can now
    <a class="internal" href="./index.php" title="Back to the tutorial index">go to another section</a>,
    and learn a new SFML package.
</p>