Why Should Indie Devs Care About Video Game Usability Testing? - by Barbara Posada Blogs - 4 December 2017 - 7:02am
Testing the usability of your video game means evaluating how happy, comfortable, and satisfied your potential users are when they play it. Achieving those goals is probably not something you can get on the first go.
Categories: Game Theory & Design

Atum Engine - by Eugene Solyanov Blogs - 4 December 2017 - 7:02am
Atum engine is a newcomer in a row of game engines. Most game engines focus on render techniques in features list. The main task of Atum is to deliver the best toolset; that's why, as I hope, Atum will be a good light weighted alternative to Unity for i
Categories: Game Theory & Design

Work-Life Balance as an Indie Dev - by Michael Hicks Blogs - 4 December 2017 - 7:01am
A big struggle for indie devs seems to be balancing life and work. In this video I talk about my experiences with this and methods that have helped me with it.
Categories: Game Theory & Design

Opposing Viewpoints of Virtual Reality - by Ashlye Kaczmarek Blogs - 4 December 2017 - 7:01am
Virtual Reality is still new to our world and there is still things that need to be worked on. The virtual world is growing, but not everyone is so supportive of its breakthrough. This paper discusses the opposing viewpoints of the every growing VR world.
Categories: Game Theory & Design

Best Freelancing Platforms for Developers - by Michael Smith Blogs - 4 December 2017 - 7:01am
Ways you can earn as a freelance developer
Categories: Game Theory & Design

New Bolt Action Releases Available From Warlord Games

Tabletop Gaming News - 4 December 2017 - 7:00am
Tanks! You’re welcome. No, I mean Tanks! And also Tank Destroyers. And a new edition of the Pegasus Bridge and Ham & Jam sets. What I’m saying is that there’s new Bolt Action releases available over in the Warlord Games webshop. There’s also dice, because we all love dice. The vital operation held in the […]
Categories: Game Theory & Design

LakeDrops Drupal Consulting, Development and Hosting: Welcome Matthias

Planet Drupal - 4 December 2017 - 6:50am
Welcome Matthias Jürgen Haas Mon, 12/04/2017 - 15:50

We are so glad to announce that Matthias Walti decided to join LakeDrops. He brings skills and experience in building e-commerce solutions, is a user experience expert and is well known for writing great content which is driven by his marketing background.

Categories: Drupal

Reynald's Expedition: Designing A Hero - by Andrew-David Jahchan Blogs - 4 December 2017 - 6:43am
In this article, we share the creative process we went through when creating Reynald, our first game's main character and eager archeologist!
Categories: Game Theory & Design

A Quick Breakdown of Self-Determination Theory - by Travis Meador Blogs - 4 December 2017 - 6:43am
I was extremely interested in Self-Determination Theory (SDT), as a whole because of the way video games have impacted my own life. This was done with a few classmates and we really got into it.
Categories: Game Theory & Design

Game Industry Blockchain Technologies Should Be Humble to Survive - by Vadim Bulatov Blogs - 4 December 2017 - 6:43am
Among the many blockchain solutions proposed for the gaming industry, the most popular have been those that create marketplaces for in-game purchases used in free-to-play models.These model however, excludes the role of game developers and publishers.
Categories: Game Theory & Design

Design your creative team like a game - by Levi Engel Blogs - 4 December 2017 - 6:43am
Creative people just want to perform at their best and see the team succeed in finding the best solutions to the problems at hand. Formulate the rules of evaluation of the propositions as clearly as you would explain the rules of a game.
Categories: Game Theory & Design

New Blood Bowl, Blood Angles, and Hobbit Pre-orders Available From Games Workshop

Tabletop Gaming News - 4 December 2017 - 6:00am
Games Workshop’s a little bit of all over with this week’s set of pre-releases that you can order now. The biggest one is probably the new Blood Angels codex, as well as a bunch of units for them, including Primaris Marines with Blood Angels insignia. Second would be the Blood Bowl items, which includes a […]
Categories: Game Theory & Design

Agaric Collective: Change the text field maximum length in Drupal 8

Planet Drupal - 4 December 2017 - 4:39am

Once a text field has data stored, it is not very easy or obvious how to change its maximum length. In the UI there is a message warning you that the field cannot be changed, because there is existing data. Sometimes it is necessary to change these values. It seems that there are a few ways and some resources to do this in Drupal 7, but I could not find a way to do this in Drupal 8. I decided to create a small function to do it:

Caution: Any change in the database needs to be done carefully. Before you continue please create a backup of your database.

/** * Update the length of a text field which already contains data. * * @param string $entity_type_id * @param string $field_name * @param integer $new_length */ function _module_change_text_field_max_length ($entity_type_id, $field_name, $new_length) { $name = '' . $entity_type_id . "." . $field_name; // Get the current settings $result = \Drupal::database()->query( 'SELECT data FROM {config} WHERE name = :name', [':name' => $name] )->fetchField(); $data = unserialize($result); $data['settings']['max_length'] = $new_length; // Write settings back to the database. \Drupal::database()->update('config') ->fields(array( 'data' => serialize($data))) ->condition('name', $name) ->execute(); // Update the value column in both the _data and _revision tables for the field $table = $entity_type_id . "__" . $field_name; $table_revision = $entity_type_id . "_revision__" . $field_name; $new_field = ['type' => 'varchar', 'length' => $new_length]; $col_name = $field_name . '_value'; \Drupal::database()->schema()->changeField($table, $col_name, $col_name, $new_field); \Drupal::database()->schema()->changeField($table_revision, $col_name, $col_name, $new_field); // Flush the caches. drupal_flush_all_caches(); }

This method needs the name of the entity, the name of the field, and the name and the new length.

And we can use it like this:

_module_change_text_field_max_length('node', 'field_text', 280);

Usually, this code should be placed in (or called from) a hook_update so it will be executed automatically in the update.

And if the new length is too long to be placed in a regular input area, you can use the Textarea widget for text fields which will allow you to use the larger text area form element for text fields.

Categories: Drupal

Commerce stepped proportional pro-rata

New Drupal Modules - 4 December 2017 - 3:38am

This module provides a pro-rata plugin for Commerce Recurring which allows
proportional pro-rata prices at specific intervals in the billing period.

For example, with a billing period of 1 year, and 4 steps, a price of 100 would
be charged at:

  • 0-3 months: 25
  • 3-6 months: 50
  • 6-9 months: 75
  • 9-12 months: 100
Categories: Drupal

Leavers are ruining Overwatch and Blizzard is doing nothing about it - by Ivan Fortunov Blogs - 4 December 2017 - 3:21am
I loved the game, but now Leavers are ruining Overwatch. Why Blizzard won't solve these problems when there are so many ways to actually do it? Let's take a closer look at the current situation.Why Blizzard won't solve these problems when there are so man
Categories: Game Theory & Design

Constraints And Creativity

Gnome Stew - 4 December 2017 - 3:00am


Several years ago while I was working on my fundamentals before I started my stat degree, I took a creative writing class as an elective*. For one of the assignments, the professor had a local poet visit and speak to us about his craft. I remember his readings being very interesting despite the fact that I’m not really a poetry guy, so I wish I also remembered his name so I could link him here. However, one of the things he said during his question/answer session came back to me recently and it struck me how important it is to my own, and I suspect many people’s, creative process. Asked to comment about his choice to use various structures of poetry, he said something akin to (and this is me paraphrasing from memory, not an exact quote):

“I know a lot of people like writing in free verse because it’s easier than having to deal with all the rules of for example, iambic pentameter,  but to me the reverse is true. I like choosing a structure and a subject and then knowing exactly how I have to write my poem to fit the structure. It allows me to focus on less things. I actually find writing in free verse harder because there are so many more things to consider.”

It’s pretty obvious that what he was talking about is the concept of option paralysis: having so many options that you find yourself unable to make a choice. The other night when I remembered this, I suddenly realized that this is the fundamental conflict I’ve been trying to deal with for years. I’ve written articles about templates, articles about how-to guides, articles about random generation tables, articles about limiting your prep, all in service of making creativity easier by adding constraints. Heck, it even helps explain the article I wrote a few years back about how I love minecraft but hate drawing maps. In construction games your crafting list sits right there on screen like a checklist. Have you made a library? You can build bookshelves and an enchanting table, so you probably need one. Have you made a bathroom? Well, you can’t construct a toilet and you don’t poop, so you probably don’t need one.** In addition, the limited blockset and game physics are both constraints that make construction choices, if not simple, at least limited.

This also explains some of the complaints I have about certain, to be unnamed, RPGs that have endless book after book of race options and endless books of class options. Ironically, several pages of point buy system provides more options than 10 books of races and classes, but causes less option paralysis because everything you can choose is in one central location and follows a simple formula. (It also doesn’t sell dozens of system bloating, unnecessary, expensive books though, so I know why publishers might choose the books over the purchase point system.)

It also explains, for those of us who are old enough to remember 1e and Basic, why the time it takes to do anything with RPGs has ballooned. Not only have the options for each component in your system increased but so have the types of challenges, the play styles, the genres, etc . . .

If you’re unsure that addition of constraints makes creativity easier: Make an adventure using the following constraints – Use one of the 9 forms of the 5 room dungeon. Your rooms are only allowed to be 20’x30′ rectangles or 30′ diameter circles. Your enemies are 3 types of orcs or orc allies and you get one trap. It does damage and adds a status effect. Go. Takes like, 5 minutes, at most, right? Of course everyone who participated has results that look similar, but each is going to be different. There are still nominally 288 dungeon layouts before you flavor it up, you still have dozens of types of orcs and orc allies (warriors, archers, scrubs, shamans, goblins, worgs, bugbears, ogres etc . . .), and dozens of types of traps (darts with slow poison, falling rocks that create difficult terrain, barbed nets, etc . . .) that meet the criteria. In addition, this is just a factor of the chosen constraints. If I had said: Make a village of 5 small buildings populated by were-cats and their animal spies with one hidden dark shrine, it would take the same 5 minutes but be completely different.

So what’s the takeaway? How does this help us? Simple: If you’re staring down a blank sheet of paper at a loss***, start writing constraints on it until you have something manageable enough that allows your creativity to just flow out of your pen (or screen and keyboard – whatever, you get it.) Remember that while it may seem limiting to add constraints, all you’re doing is pre-selecting large swaths of choices to NOT use, and you can constrain differently next time. Here are some easy constraints to add:

  • Large scale
    • Books: For the love of god, constrain books. Don’t go digging through 50 books to find your monster of the week. Don’t hit the internet and dig through a million character builds for your NPCs. Just pick a few books (I’m a fan of just using the core necessary ones) and use only what’s in there.
    • Genre: This is often implied by system, but especially if it isn’t, pick a genre. Even if it is specified by system, you can usually narrow it down a bit. This often greatly constrains your options.
    • Gygaxian Unnaturalism: Pick a reason for Gygaxian Unnaturalism and run with it. Say goodbye to worrying about what monsters eat, why they poop and if they can be reformed (they can’t).
  • Monsters
    • Books again: Lots of systems have monster book after monster book. They’re quick cash-ins. But you don’t need more than the base one. When was the last time you used most of the monsters in the core monster book anyway?
    • Choose a handful: Back in 2009, Martin wrote an article about the Decamer (roughly: ten turds) Campaign. In this concept, your campaign contains only ten monsters total. You don’t have to pick ten awful ones, but constraining yourself in this way makes picking monsters pretty easy.
  • NPCs
    • Generators: Pick a random generator for NPC name, race, class, personality etc. Stick with it.
    • Templates: Alternately, pick a template you like and stick with that instead.
    • Monsters: Need an NPC in combat, reskin a similar monster from the one monster book you allowed yourself. Done.
  • Maps
    • Generators: Find an online map generator. Run it and run with it.
    • 5 Rooms: As linked earlier, there are only 9 (or 3 depending on how you count) forms of the 5 room dungeon. Grab and go.
    • Geomorphs: Plenty of geomorph sets are available. Pick one and use it exclusively.
    • Symbol sets: Pick a symbol set and only use it. For dungeon maps, you may want to also restrict yourself to a handful of room sizes/types.


* Only sorta, but the full story isn’t relevant here.

** Ironically, in Ark you can poop but can’t build a toilet. In 7 Days to Die you can build a toilet but can’t poop. In both games you need poop to make fertilizer though.

*** In a recent blog article on scope and scale, The Angry GM called facing a blank piece of paper “the most powerful, most insurmountable obstacle in the entirety of GM-ing-dom”

Categories: Game Theory & Design

Token UUID

New Drupal Modules - 4 December 2017 - 2:55am
Categories: Drupal

Amazee Labs: GraphQL for Drupalers - the fields

Planet Drupal - 4 December 2017 - 2:20am
GraphQL for Drupalers - the fields

GraphQL is becoming more and more popular every day. Now that we have a beta release of the GraphQL module (mainly sponsored and developed by Amazee Labs) it's easy to turn Drupal into a first-class GraphQL server. In this series, we'll try to provide an overview of its features and see how they translate to Drupal.

Blazej Owczarczyk Mon, 12/04/2017 - 11:20

In the last post we covered the basic building blocks of GraphQL queries. We started with the naming conventions, then we took a look at how and when to use fragments. Finally, we moved on to aliases, which can be used to change names of the fields as well as to use the same field more than once in the same block. This week we'll delve into the ambiguous concept of Fields.

What exactly are GraphQL fields?

Fields are the most important of any GraphQL query. In the following query nodeById, title, entityOwner, and name are all fields.


Each GraphQL field needs to have a type that is stored in the schema. This means that it has to be known up front and cannot be dynamic. At the highest level, there are two types of values a field can return: a scalar and an object.


Scalar fields are leafs of any GraphQL query. They have no subfields and they return a concrete value, title and name in the above query are scalars. There are a few core scalar types in GraphQL, e.g.:

  • ​String: A UTF‐8 character sequence.
  • Int: A signed 32‐bit integer.
  • Float: A signed double-precision floating-point value.
  • Boolean: true or false.

If you're interested in how Drupal typed data is mapped to GraphQL scalars check out the the graphql_core.type_map service parameter and graphql_core.type_mapper service.

Complex types

Objects, like nodeById and entityOwner in the query above, are collections of fields. Each field that is not a scalar has to have at least one sub-field specified. The list of available sub-fields is defined by the object's type. If we paste the query above into graphiQL (/graphql/explorer), we'll see that the entityOwner field is of type User and name is one of User's subfields (of type String).


Fields can also have arguments. Each argument has a name and a type. In the example above nodeById field takes two arguments: id (String) and langcode. The same field can be requested more than once with a different set of arguments by using aliases, as we've seen in the last post.

How do Drupal fields become GraphQL fields?

One of the great new traits of Drupal 8 core is the typed data system. In fact, this is the feature that makes it possible for GraphQL to expose Drupal structures in a generic way. For the sake of improving the developer experience, especially the experience of the developers of decoupled frontends, Drupal fields have been divided into two groups.

Multi-property fields

The first group comprises all the field types that have more than one property. These fields are objects with all their properties as sub-fields.

This is how we'd retrieve values of a formatted text field (body) and a link field. Date fields and entity references also fall into this category. The latter have some unique features so let's check them out.

Entity reference fields

This type of field has 2 properties: the scalar target_id and the computed entity. This special property inherits its type from the entity that the field is pointing to. Actually, we've already seen that in the named fragments example in the last post, where fieldTags and fieldCategory were both term reference fields. Let's bring a simplified example.

Since fieldCategory links to terms, its entity property is of type TaxonomyTerm. We can go further.

The entityOwner property is of type User, so we get their email. Apparently, we can go as deep as the entity graph is. The following query is perfectly valid too.

It retrieves the title of an article that is related to the article that is related to the article with node id one and this is where GraphQL really shines. The query is relatively simple to read, it returns a simple-to-parse response and does it all in one request. Isn't it just beautiful? :)

Single-property fields

The second group comprises all the field types that have exactly one property (usually called value), like core plain text fields, email, phone, booleans and numbers. There's been a discussion about whether such fields should be rolled up to scalars or remain single-property objects. The former option won and in 3.x members of this group have no sub-fields.

That's it for the fields. Next week we're going to talk about... fields again :) but this time we'll see how to create one.

Categories: Drupal

Fuzzy Thinking: Heavy Metal

RPGNet - 4 December 2017 - 12:00am
Fuzzy guns.
Categories: Game Theory & Design

ADCI Solutions: How we built the Symfony CRM for Oxford Business Group

Planet Drupal - 3 December 2017 - 10:35pm

As you know, now the Symfony components are in Drupal Core, and this encourages our team to get to know this framework better. In this article, we will tell you how a CRM system on Symfony may look like, what goals it reaches, and what features includes. This article is written on the base of our real project for Oxford Business Group - a global publisher and consultancy that has offices all around the globe.


Learn about the Symfony CRM





Categories: Drupal


Subscribe to As If Productions aggregator