Guaranteed to take veteran players by surprise!

Arkanoid – Eternal Battle is an iconic arcade game, developed by TAITO Corporation in 1986. When the mother ship ARKANOID comes under attack, the small spacecraft VAUS manages to escape but ends up warped into another dimension. Wandering in an inter-dimensional labyrinth, VAUS must destroy blocks called “spacewalls” in order to defeat “DOH”, the creator of the maze responsible for ARKANOID’s destruction.

For the first time ever, players will be able to compete against each other, offering an online experience thanks to the Eternal Battle mode, the main new feature of this game, brining the arcade experience to a whole new level. This Battle Royale mode offers the possibility to compete among 25 players online.

The post ARKANOID – Eternal Battle appeared first on Pastagames.

A STUNNING MINIATURIZED JOURNEY
From a gorgeous river to a spider nest or the deep recesses of a tree, Rayman Mini thrusts you into a rich, natural environment through 48 exciting levels!

SURVIVE EPIC BOSS LEVELS
Being “mini” means encountering new kinds of dangers. At the end of each of the 6 worlds, you’ll face an epic boss run that will require your honed reflexes!

RAYMAN, BARBARA, GLOBOX, AND MANY COSTUMES!
Choose between 3 characters and complete the levels to unlock tons of different costumes to customize your experience.

The post Rayman Mini appeared first on Pastagames.

Join the 4-player Battle Arena mode and face rival players from around the world. Use power-ups and master the mazes to be the last PAC-MAN standing! You can also play matches with friends online or share the screen by connecting to 4 controllers on a single Apple device.

Eat PAC-DOTS to gain speed and catch the Power Pellet first, and see your friends and the ghosts running away from the random Power-Up you got, from the classic Energizer, the L.A.S.E.R., the Electric Field or to trigger an Airstrike !

Be careful, the more PAC-MAN you eat, the more Ghosts there will be, and they will try to get revenge on those who ate them!

Also beware of Itchy, a new Ghost poisoning you on touch with a random negative effect.

Players who became ghost can come back as PAC-MAN if they manage to eat another PAC-MAN: don’t give up on victory and get back in the fight!

But beware the 256-glitch ! If there is no winner soon enough, the maze will start to collapse on you and the safe area will shrink until there is only one PAC-MAN left !

Stay tuned, for more game modes and mazes will be released over time, after the game release: the fun never stops with PAC-MAN PARTY ROYALE!

The post PAC-MAN Party Royale appeared first on Pastagames.

The post Pix and the Pastateam wishes you… appeared first on Pastagames.

Join the team with up to 4 players in local co-op!

Compete with your friends in tournaments with the Kung Foot experience (local wireless multiplayer)

Run, jump & smack your way through 100+ maps

Jump to the rhythm and rock the party to beat the crazy musical levels

The post Rayman Legends appeared first on Pastagames.

Pesto a été présenté à la Game Camp 2017 à Lille, vidéo et slides PDF disponibles ci-dessous:

The post Présentation de PESTO à la Game Camp 2017 appeared first on Pastagames.

This article is about string hashes and how we implemented them in our engine. It’s also available on my personal blog.

Strings are often used as identifiers in games: object names, sound effect names, particle type names, etc. They’re a bit like enums with the advantage of allowing your game to be data-driven: you don’t necessarily need to recompile your program to accept new values.

But strings are no fun: storing them efficiently is a headache, they’re bigger and they’re slower than enums.

Fortunately there’s an alternative: string hashes. We like them a lot at Pastagames, and here are our humble solutions to the practical problems that come with them.

Hash Function

There are tons of hash functions out there, so it’s sometimes a little bit hard to choose. Fortunately there are great summaries on the Internet.

We definitely want to hash mostly short strings, and in this case simpler functions are better. In the article linked above, Aras recommends FNV-1a. If you don’t care about javascript as a platform, Murmur2A and Murmur3 may be slightly more efficient.

At Pastagames, we chose djb2 some years ago. All in all, it makes very little difference because we don’t hash strings that often anyway. The goal is to use the hash everywhere instead of the string, so we basically calculate the hash once and then we’re done.

For this usage, 32 bits hashes are often enough. The chances of having a collision are higher than with 64 bits hashes but still very, very low. In our biggest project, we have around 30K unique strings and we haven’t got a single collision. And if we ever have one, well, we can just change one of the strings.

Collision Detection

The chances of having collisions may be low, but detecting them during development is still critical, otherwise you will get really weird bugs.

The basic idea is simple: every time we hash a string, we access a global map (a hash map actually) to check if the hash was already associated with a different string.

In our implementation, this global hash map is mutexed, but to limit the contention when accessing it from multiple threads, we added two layers of thread local caches.

The first layer keeps the 16 most recent hashes and the second layer, the 128 most recent. Of course, those sizes are very dependent on how we use the string hashes and may not help in your case (remember, know your data). In our case, it also helped with the performance in debug builds (where the hash map is a lot slower because inlining is disabled), but not so much in optimized builds (to be fair, our cache implementation is pretty naive and we really stopped at “good enough”).

An alternative to the caches would be to replace the mutex by a readers-writer lock, or even use a lock free hash map (although we do want to keep the hash map implementation simple, for reasons detailed below).

Last thing to note about our implementation: we store the strings in 64KB buffers to reduce the number of memory allocations. Each buffer acts as a linear allocator, and when it’s full we just allocate a new one. We never free the strings so we don’t even need to keep track of these buffers. YOLO.

Debugging

The first thing we did is add a const char* getString() function to our StringHash class. That’s really easy to implement since we just need to access to the global hash map mentioned above. Since the strings are never freed, the pointer returned by the function will always be valid.

With this getString(), we can use strings instead of hashes in the logs, the debug UIs, the editors and even when serializing to textual data formats. The only limitation is that we can only use it in development builds because the collision detection (and the hash map) are disabled the final build. But that’s usually not a problem. To simplify things the getString() function stays defined in the final build, but always returns an empty string.

So far so good, but still, it’s hard to tell that 4086421542 is “banana” when you look at a StringHash variable in the debugger. So the second thing we did is store the pointer returned by getString() along with the hash inside the StringHash class. It makes the string visible in the debugger but it also makes the class bigger, which is not great. Fortunately there’s another option: the Visual Studio Debug Visualizers (aka. the Natvis files) and that’s what we used in the end (at least on the platforms that support it).

Natvis are basically XML “scripts” that tell the debugger how to display a class. In this particular case, we need to use the CustomListItems tag to do a lookup inside the global hash map and find the string. That’s where having a simple hash map implementation becomes important, scripting in XML is painful.

First thing to note, since the key of the map is already a hash, we don’t need a function to rehash it. If you’re using an std::unordered_map, the 3rd template parameter should be a funtion that does nothing.

Next, a hash map that uses linear probing makes everything a lot easier: we can just jump at the right bucket index and do a linear search from there (note that std::unordered_map does not use linear probing, you need a custom hash map like this one).

Here is what the natvis look like (based on the hash map implementation linked above):

<?xml version="1.0" encoding="utf-8"?>

<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">

<Type Name="Pasta::StringHash">
    <Expand>
	    <CustomListItems>
        <Variable Name="buckets" InitialValue="s_GlobalStringMap->buckets_.mpBegin" />
        <Variable Name="num_buckets" InitialValue="s_GlobalStringMap->buckets_.mpEnd - s_GlobalStringMap->m_map.buckets_.mpBegin" />
        <Variable Name="start_bucket" InitialValue="m_hash % num_buckets" />
        <Variable Name="i" InitialValue="start_bucket" />
        <Loop>
          <If Condition="buckets[i].first == m_hash">
            <Item Name="string">buckets[i].second, na</Item>
            <Break />
          </If>
          <Exec>i = (i + 1) % num_buckets</Exec>
        </Loop>
      </CustomListItems>
      <Item Name="hash">m_hash</Item>
    </Expand>
</Type>

</AutoVisualizer>

Very verbose, but not so complicated. We start looking at m_hash % num_buckets and check out every bucket until we find our hash or get back where we started.

It’s also possible to follow the chaining used by std::unordered_map (although more complicated), but another reason to use to linear probing is that some consoles only partially support the natvis file syntax and have a simpler “linear search” tag instead of the very complex CustomListItems tag. But that’s another story.

Here is what it looks like in the debugger:

Exactly like when we store the string inside the class.

One last thing worth mentioning: global StringHash variables are going to access the global hash map in their constructor so we need to make sure that the map is initialized before any StringHash. A typical solution for that (since in C++, global variable initialization order is not defined) is to make the hash map static inside a function. However, we also need to declare a global pointer to the hash map, otherwise we can’t access it from the natvis file.

// --- StringHash.h ---
struct StringHash
{
  ...
  // Declaring the map inside the StringHash class will help the debugger find it
  // (in case another global variable with the same name exist) and will prevent
  // the variable from being optimized away (which can happen since it's never 
  // referenced in the code.)
  static StringMap* s_GlobalStringMap;
}

// --- StringHash.cpp ---
static StringMap* GetGlobalStringMap()
{
  static StringHash::StringMap s_StringMap;
  return &s_StringMap;
}

StringMap* StringHash::s_GlobalStringMap = GetGlobalStringMap();

Compile Time Hashes

Another advantage of using a simple hash function is that it’s easy to make a constexpr version of it (even with the restrictions of c++11).

For example, djb2:

uint32_t HashStr(const char* _str)
{
  if (*src == 0)
      return 0;

  uint32_t hash = 5381;
  
  char c;
  while ((c = *_str++) != 0)
    hash = ((hash << 5) + hash) + c;

  return hash;
}

Becomes:

constexpr uint32_t HashStrRecur(uint32_t _hash, const char* _str)
{
  return (*_str == 0) ? _hash : HashStrRecur(((_hash << 5) + _hash) + *_str, _str + 1);
}

constexpr uint32_t HashStr(const char* _str)
{
  return (*_str == 0) ? 0 : HashStrRecur(5381, _str);
}

If you also declare the StringHash constructors constexpr, all the hashes of string literals will be calculated at compile time. Yay!

Of course this is incompatible with the collision detection / debugging part, but with a few macros and #ifdefs, it’s pretty easy to have the debug features in development builds and the constexpr for release builds.

That’s all folks!

Phew, that was a little longer than expected.

Next up, the fiber based job system. Completely inspired by the Naughty Dog GDC presentation, but with a few small differences and a few more implementation details.

The post String Hashes appeared first on Pastagames.

Pang Adventures brings new features & gameplay while keeping true to the original spirit:

Local Co-op in every game mode!

3 different modes:
Tour Mode: one location at a time!
Score Attack: 3 lives and NO CONTINUES! The real arcade experience!
Panic Mode: 99 levels of continuous battle! Put your skills to the ultimate test!

The Bros. have upgraded their gear since the last invasion: machine guns, flamethrowers, shurikens…you name it, they’ve got it! Electric, explosive, smoke & lava balls will all be deployed to knock them off their feet!

Boss fights! For the 1st time, the Bros. come face-to-face with the nefarious Alien Commanders! They didn’t come to Earth for the sightseeing…so get ready to blow them to smithereens!

The post Pang Adventures appeared first on Pastagames.

Courtesy of Sylvain HELLIO, Laboratory Mode composer:

“THE SMALLEST PUZZLE GAME IN THE WORLD”

The Laboratory mode, my turf, puts a puzzle spin on the mechanic of picking up ducklings and dropping them off, that you’ll be familiar with from having played the other modes. The key differences being you have to do so in the “perfect” fashion and in the least amount of moves possible for a bonus win, but contrary to the other modes, you have all the time in the world to make up your mind.

As far as the world goes, Pix is now caught in a petri dish, swimming amongst the infinitesimally small creatures that inhabit it, all seen under the eye of a microscope.

When I imagine what kind of music would fit this environment, I assume sound doesn’t travel the same way. They would be slightly filtered (muffled) for example, and events would be unpredictable all while being soft and delicate.
I would also imagine that cells suddenly assemble or particles and plankton would break apart just as suddenly, all in perpetual motion, smoothly transforming from one state to another.
And I’ll try to start hearing this in my head.

AN ORGANIC SYMPHONY

The stylistic starting point agreed upon with Pastagames was that the atmosphere should be laid back, relaxed and ambient. We quickly found several leads to which the team was very open! They love above all else to be surprised so I started thinking hard ^^.

I’m always weary of ambient music; there is a lot of software out there able to do just as well as a human for this particular genre. Speaking of which, games like Electroplankton on NDS, or the Bloom app by Eno & Chilvers use this kind of thing, precisely in an aquatic setting.
Even when a human is behind the keyboard, I feel like the track is trying too hard, showing off in a way… Many keyboards have patches that sound great, and only require a couple of notes and perhaps a filter that you can tweak to create an entire world at your fingertips. It’s like magic!

Either way, my own research on purely ambient tracks has so far been rather inconclusive. They always carried an unwanted amount of tension. Ambient often carries tunes of isolation, loneliness, and even a hint of fear. There’s a good reason why it’s used a lot in sci-fi and horror settings, it works very well!

There’s a trap to watch out for here, we can’t forget that under the microscope live a host of small creatures, there’s life inhabiting the world. We’re still in a cartoon setting, watered down a bit, but cute & cuddly all the same. We will need a bit of rhythm, a beat and something slightly melodic and slightly playful.

But not too melodic nor rhythmic, to avoid the pitfall of having the track becoming too quickly repetitive and redundant. Especially when you know that this kind of Puzzle game music, depending on the level can play for 20 seconds or 5 minutes, that risk is a big one.

So I had to find a melody that would be subtle, only hinted at. Also, to battle the feeling of repetitiveness, we decided on creating a single piece of music but to offer subtle and delicate variations on certain sections throughout the 10 worlds explored by Pix – basically one variation per world (ok, there are a bit more than 10, but I’ll get back to that later). The idea being that we’d end up with a piece that would flow through all of the levels, exploring and revealing each world. A little bit like in The Night of the Hunter, or Apocalypse Now (more fun, obviously) if you see what I mean.

PREPARATION, INSPIRATION

With all this in mind, I got to listening to a ton of stuff to find inspiration. I rarely stumble upon the perfect piece that will serve as sole reference, and that’s a good thing because I’d be too tempted to follow it too closely. “Hey this track is perfect, let’s do the same thing!” – No, that wouldn’t do.

Amongst all the things I listened to, I first picked these (Pasta Pix) that all had that ambient feel and were slightly melodic, but the most influential were the following:

Oneohtrix Point Never – Along:

In an ambient canvas, ONP distills, never completely committing to any in particular, a variety of fragmented melodies, without obvious structure. I can easily imagine micro-organisms acting this way with sudden movements. (Listen to the second half of the track)

Aphex Twin – Alberto Balsam:

This reference piece has a high tempo for a Puzzle Game, but what i heard mostly was the playful mood, slightly mischievous and hesitant with just the right amount of melancholy and ambient feel to top it off.

Tomas Dvorak – Nanorobot Tune:

A great starting point. This track has a few too many events throughout for a Puzzle in the vein of our Laboratory but I like the hints of Funk and the way it quietly screams at you. It’s catchy and low-key all at once. This track helped me a lot during the mixing phase (Sound design elements and drums up front, deep bass, keyboard far off).

Ben Prunty – Civil (Explore) / FTL:

This was a reference we talked about at Pastagames. I feel like the tune is a little too MIDI (meaning digital, laptop generated) and too stereotypical of old-school video games (especially the second part) but it does have that ability to be forgotten all while remaining easily recognized. The theme is subtle and the beat is set by the echo from the keyboards, it’s common but I’ll hold on to that idea for the sections without drums (making them more aerial) that will be recurring throughout the laboratory.

QUICK, TO THE LAB!

After all of the ground work was laid and having listened to all the tracks I could think of, I felt I had the tools to be able to create something fitting, so I stashed everything in the back of my head and got to work.

It was my turn to search, to create sounds and tweak them. To come up with melodic patterns, a succession of chords, rhythms that would speak to me and that I would try to answer, that would take me down a path I haven’t been down before. It’s a small adventure in itself. I’d face problems, find solutions, and have tons of fun of course. And at the end of the day, create a track that feels right and sounds better!

Since I just spoke of these ethereal creative moments, I’ll wrap up the idea we had at the start of making variations inside the track.
The goal was to produce a dozen light variations (rhythm, melody …) on a specific section that I had decided would be the “chorus”. It worked great the first time, but I quickly hit two snags that I hadn’t foreseen.

First, the more I would work on new variations, the more I was tempted to differentiate them even more from the original track, exactly like the trap that you fall into when you work too long on a track without setting anything in stone. Slowly your mindset changes and you quickly come to having doubts about the entire track.
Secondly, while coming up with variations of specific sections, I ALSO wanted to exacerbate the fact that the rest remained identical. And this feeling got stronger the more the variation was pronounced.
In the end, the solution was for me to apply myself at making variations on the entire track for each “world”, all while trying to go as fast as I could. It was a great learning experience!

Par Sylvain HELLIO, compositeur du mode Laboratory

“LA MUSIQUE LABORATORY A LA LOOP: LE PLUS PETIT PUZZLE-GAME DU MONDE”

Le mode Laboratory que j’ai eu à mettre en musique est un mode Puzzle/Réflexion dont le principe de base (récupérer des canards et les déposer dans les nids) est identique aux autres modes de jeu à ce détail près qu’il n’y a souvent qu’un chemin possible et des challenges renouvelés à chaque tableau. Et dernier détail, de taille, le joueur a tout le temps pour réaliser son tableau, mais il obtiendra un bonus en le réalisant en un minimum de coups.

Pour l’univers, on se retrouve cette fois-ci plongé dans un microscope donc dans l’infiniment petit, le micro-organique, et en milieu aquatique/aqueux.

Donc quand on en vient à se demander quelle musique pourrait habiter cet environnement, on peut déjà imaginer que les sons ne se propagent pas de la même manière. Ils sont un peu filtrés (étouffés) par exemple, et les événements sont imprévisibles, tout en étant doux léger, et délicat.

J’imagine aussi des cellules qui s’assemblent subitement, des particules ou des planctons qui se mettent à bouger brusquement et furtivement. En tout cas je vois de la matière en mouvement, éventuellement qui se transforme. Et je vais intérieurement commencer à essayer d’entendre ça.

DOUCE AMBIANCE

Le point de départ stylistique défini avec Pastagames était globalement ambiant, calme et posé. On a évoqué quelques pistes mais ils étaient plutôt très ouverts (ces gens-là aiment avant tout être surpris… ^^)

Les trucs ambiants, je m’en méfie un peu, il y a aujourd’hui beaucoup de logiciels de musique générative qui font très bien le travail d’un humain pour ce style de musique. D’ailleurs des jeux comme Electroplankton sur NDS, ou l’application Bloom d’Eno et Chilvers partent de ce principe, à l’intérieur justement d’un univers aquatique. Et même quand c’est un humain derrière le clavier, j’ai l’impression qu’il y a de l’esbroufe et de la frime là-dedans. Pleins de synthés ont des patchs qui sonnent suffisamment bien, il suffit alors simplement de déclencher deux ou trois notes sur le clavier, de bouger éventuellement un filtre, et tout un monde se crée sous vos doigts. C’est magique !

De toute façon mes recherches sur les morceaux purement ambiants s’avèrent assez peu concluantes, ils portaient en eux à chaque fois un caractère trop anxiogène. Ambiant signifie souvent isolement, solitude, voire légère flippe. Ca n’est pas pour rien qu’on les utilise dans les univers SF ou d’horreur, ça fonctionne très bien !

Il y a donc un piège, n’oublions pas que dans le microscope il y a plein de petits animaux, il y a de la vie, c’est habité. Et on est encore dans un univers cartoon, dilué certes, mais un peu choupinou quand même. Il faudra donc un soupçon de rythme, de battement, et quelque chose de légèrement mélodique, un brin enjoué.

Mais alors attention pas trop mélodique, ni trop rythmé, car ici le risque alors est que votre musique devienne plus rapidement répétitive et redondante. Et la musique de style Puzzle/Réflexion sachant qu’elle pourra tourner, selon les phases de jeux et les joueurs aussi bien 20 secondes que 5 minutes, tombe vite dans cet écueil.

Il fallait donc une mélodie un peu suggérée, cachée. Notons que pour pallier ce problème de répétition, on avait prévu de réaliser une seule musique mais de proposer de légères et délicates variations sur certains passages au fil des 10 mondes explorés, en gros une variation sur chaque monde (bon…hum en fait il y en a eu plus.. j’y reviendrai plus tard). L’idée à la fin étant d’avoir un grand morceau fleuve, qui dévoilerait, explorerait au fil du jeu, de nouvelles couleurs, de nouveaux climats et paysages, de manière discrète, douce et très progressive. Un peu comme la rivière dans La nuit du Chasseur, ou ApocalypseNow (en plus fun, on s’entend) si vous voyez ce que je veux dire.

PREPARATION, INSPIRATION

Bon du coup j’ai écouté plein de chose pour trouver l’inspiration, je tombe rarement sur un morceau qui va complètement faire office de référence et c’est tant mieux car j’aurais trop tendance à m’enfermer dedans. «Hey, ce morceau est parfait, eh bien faisons pareil !» Non, non.

Parmi tout ce que j’ai écouté, j’ai d’abord relevé pêle-mêle ceux-ci (Pasta Pix) tous teintés d’ambiant et légèrement mélodique, mais les plus déterminants ont été les suivants :

Oneohtrix Point Never – Along:

Dans un canevas ambiant ONP distille, sans jamais les affirmer complètement, des fragments de mélodies très variés et apparemment sans logique particulière. J’imagine bien des micro-organismes se comporter comme ça, par soubresauts. (écouter à partir de la moitié)

Aphex Twin – Alberto Balsam:

Le morceau de référence ici a un tempo élevé pour un Puzzle Game mais ce qui me parle particulièrement c’est son mood joueur, un peu farceur et hésitant, avec juste ce qu’il faut de mélancolie et d’esprit ambiant.

TomasDvorak – Nanorobot Tune:

Un très bon point d’appui. Il a une densité en événements légèrement trop élevée pour un Puzzle du genre de laboratory mais j’aime bien sa touche un peu funk, sautillante tout en retenue. C’est entraînant et discret à la fois. Ce titre m’a pas mal servi pour le mixage (Eléments de sound design et batterie devant, basse profonde, synthé au loin).

Ben Prunty – Civil (Explore) / FTL:

Ca a été une référence évoqué avec Pastagames. Je trouve le morceau un peu trop MIDI (c-à-d numérique, laptop generated) et trop typé jeu vidéo old-school (surtout la 2eme partie) mais il a une bonne capacité à se faire oublier tout en demeurant facilement identifiable. Le thème est discret et la pulsation est donnée par l’écho sur les synthés, c’est un truc classique mais je garde cette idée en tête notamment pour tous les passages sans batterie, plus aériens que je vais devoir ménager dans la musique de Laboratory.

VITE, AU LABO !

Après ces réflexions et ces écoutes je sens que j’ai suffisamment d’éléments intéressants pour commencer, je place tout ça un peu de côté, quelque part dans un coin de ma tête, et je me mets au travail.

A mon tour, de chercher, de créer des sons et les triturer, de poser des motifs mélodiques, des suites d’accords, des rythmes qui vont me parler, auxquels je vais tenter de répondre, qui vont m’emmener dans un endroit que je ne connais pas encore tout à fait. C’est une petite aventure. Je vais rencontrer des problèmes, et trouver des solutions, et m’amuser, évidemment. Et au bout du compte fabriquer un morceau, pour qu’il ait une belle allure.

D’ailleurs puisque je viens d’évoquer les moments créatifs un peu compliqués, je termine sur l’idée que nous avions eue au départ de faire des variations à l’intérieur du morceau.

L’idée était simplement de produire une dizaine de variations assez légères et anecdotiques (rythme, mélodie..) et exclusivement sur un passage précis, en l’occurrence j’avais choisis le «refrain». Ca a très bien fonctionné une première fois,

mais je me suis rapidement retrouvé devant deux problèmes que je n’avais pas anticipés.

D’abord plus je travaillais sur de nouvelles variations plus j’étais tenté de les faire de plus en en plus marquées, exactement comme ce piège qui vous attend au tournant lorsque vous travaillez trop longtemps sur un morceau sans rien fixer, peu à peu votre état d’esprit change et pouvez vite vous retrouver à tout remettre en question…

Le deuxième problème était qu’en faisant des variations sur des points précis je mettais AUSSI en avant le fait que le reste ne changeait pas. L’effet s’accentuant plus les variations étaient fortes.

Les solutions ont finalement été de m’appliquer à faire des variations sur l’ensemble du morceau pour chaque «monde». En essayant bien sûr d’aller le plus vite possible. Un excellent exercice !

The post Laboratory Music Dissected appeared first on Pastagames.

la Paris Games Week 2014 a fermé ses portes hier après 5 journées marathon pendant lesquelles nous avons pris un énorme plaisir à rencontrer joueurs et professionnels de tout poil!

Ce genre d’événement nous rappelle aussi combien le monde du jeu vidéo français n’est pas si petit et “fermé” que cela, et que vous, joueurs, êtes curieux et demandeurs d’expériences de jeu variées!

Autant dire que notre borne d’arcade et nos pads PS4 ne sont pas resté bien longtemps inactifs (pour notre plus grand plaisir^^) et que vous étiez très, très nombreux au rendez-vous.

Alors, forcément, on a très envie de dire:

Merci à toutes et tous d’être passé sur l’espace Made In France!

Merci à la team Drakonia et à Grégory pour leur organisation et leur bonne humeur sans faille!

Merci à nos fidèles et dévoués Jennifer et Thomas pour avoir tenu la baraque à frite pendant 5 looongues journées!

Merci à MO5 pour avoir pris notre “petite” borne sous leur aile!

Et un coucou aux gars de Sushee que nous aurons plaisir à retrouver, on l’espère, sur d’autres événements!

A tout bientôt dans les allées d’un salon!

Hervé et la Pastateam

The post Paris Games Week 2014 : une semaine de fou! appeared first on Pastagames.