Newsfeeds

Term Node

New Drupal Modules - 17 August 2018 - 3:55am

Allow a term to be configured to show the content on a referenced node rather than the default term view.

Categories: Drupal

Some Honest Reflections about Patreon as a Game Media Creator - by Michael Heron

Gamasutra.com Blogs - 17 August 2018 - 3:42am
Launching a crowdfunding effort, whether Kickstarter or Patreon, can be a source of anxiety. It's a mark of confidence in your work, and might be fundamental to its continuation. Still, it's also stressful and this post discusses my experiences.
Categories: Game Theory & Design

OPTASY: Bringing Gutenberg to Drupal: A Modern Admin UI, a Better Editing Experience in Drupal 8

Planet Drupal - 17 August 2018 - 2:35am
Bringing Gutenberg to Drupal: A Modern Admin UI, a Better Editing Experience in Drupal 8 adriana.cacoveanu Fri, 08/17/2018 - 09:35

It's a robust, flexible and admin feature-packed CMS, there's no point in denying it. And yet: Drupal (still) lacks a modern UI that would make building rich web content —  such as landing pages — a breeze. But there is hope: the Gutenberg editor has been ported over, promising a better editing experience in Drupal 8.

The team behind this daring project? Frontkom, a Norwegian digital services agency that:
 

Categories: Drupal

What live game developers can learn from studying urban planning

Social/Online Games - Gamasutra - 17 August 2018 - 1:02am

Spurred by a recent visit home, Amplitude Studios' Maxence Voleau reflects on some good lessons that game devs can learn from how cities inform people about roadwork & other aspects of urban planning. ...

Categories: Game Theory & Design

A Satisfying Conclusion

Gnome Stew - 17 August 2018 - 12:00am

The end is just a new beginning, right?

When I play an RPG, it’s all about the story. Sure, I enjoy the mechanics and tactical stuff too, but if the narrative of the game is lacking, I’m going to lose interest. If there’s no reason for the PCs to be interacting with each other and the game world, then I figure I may as well be playing a board game. Thankfully, most RPGs give me that story I’m looking for. Thing is, though, while most games give a good beginning and a solid middle, a satisfying ending to the game is often missing.

Let’s face it, running a campaign to its completion is hard. Life often gets in the way and derails things bad enough that the campaign dies an ignoble death or languishes in eternal limbo. Depending on why the campaign ended, you’ll get a lot of players and GMs saying they want to pick it back up and finish it properly, but the chances of that happening are incredibly rare. In my thirty-plus years of gaming, far more campaigns have died on the vine than have completed in any kind of satisfying manner.

It can happen because something changes in a player’s life, forcing them to stop playing. It can happen because the game starts going in a direction the GM didn’t expect and they panic and flake out (been there, done that). It can happen because some shiny new game comes along and everyone wants to try it, so they take a ‘little’ break that becomes permanent. And so on and so on.

One-shots may not face the exact same problem as campaigns, but they’re also not immune from the problem either. I consider myself a bit of a connoisseur of convention games, and I’ve played plenty of them that ended weirdly or badly. Usually it’s because the GM doesn’t know how to manage pacing and runs out of time for the finale they had in mind. Sometimes the players go in a completely different direction and the GM has trouble adapting and coming up with a good ending on the fly. Occasionally it’s because the other players at the table just don’t get it and delay getting to that ending no matter how hard the GM tries. Regardless of why a game ends on a flat note, it can still ruin what otherwise might have been a decent game.

I’m not an expert on this by any stretch of the imagination. In my past, I flaked out on a few campaigns because I panicked as a GM. I’ve had convention games fall flat because I couldn’t give them a decent ending or couldn’t get to the ending. What I have done, though, is work hard to try and keep that ending in mind and work on skills to try and give my players a satisfying conclusion.

So, here’s some of my advice on endings:

  • Understand how stories work. While playing RPGs isn’t the same as writing a novel, understanding how action rises and falls or how stories are put together will help immensely with pacing and knowing when it’s time for a climactic conclusion. You don’t need to be an English major for this. Just study your favorite TV shows or novels and pay attention to how they wrap things up. I find modern serialized TV shows are a great example of how to do this. Think of a one-shot as a single episode of a show or a campaign as a full season. Watch how the show does story arcs and how they end episodes or season finales. You can get some useful tools for GMing in figuring out how stories are put together.
  • Reconcile important dangling plot threads. A game’s ending doesn’t need to resolve every single dangling plot thread the players have ever come in contact with, but if you want your players to be truly satisfied with the ending, you damn well better know which ones are important to them. For campaigns, start working on these as you build up to the game’s finale. Hopefully you’ve got some warning or awareness that the campaign is going to be wrapping up, so you can start seeding these into sessions leading up to the end. When you don’t have time to build up to the ending, figure out which bits are most important to your players and make sure those get addressed in the ending. This one isn’t as crucial for one-shots, but it’s still good practice to be aware of the parts of the plots the players are most invested in and making sure that gets resolved.
  • Timing is everything. This goes hand-in-hand with pacing, but as a GM, you must keep a handle on the amount of time you have left. For a one-shot, you know how long that sessions is supposed to last, so keep an eye on the clock. Staying on top of the pacing will help you make sure there’s enough time for that climactic ending you want to have. Losing track of time and suddenly realizing you have to wrap everything up in 20 minutes sucks hard. Campaigns also have their own timing issues. If you know that you’re going to lose a particular player in the next month and want to wrap up the campaign before they leave, you have to start planning it appropriately. You also need to have a handle on how long your finale is actually going to take. I know when I prep for my Eberron game, I often misjudge how long it’s going to take the players to handle a particular thing and have to stretch stuff between multiple sessions.
  • Let them have an epilogue. In a good campaign, players have invested so much into the characters they’ve played. While the story of the campaign as a whole may wrap up as the big bad gets tossed into the fiery mouth of a volcano, what happens to the characters afterwards? Do they buy a farm and settle down to raise a family? Do they finally go home and take up their rightful place as heir to the throne? Do they eventually get bored and start training new adventurers to go off into the wild and fight against the darkness? Did they die and the town that they saved builds a memorial to them? It may not be crucial to the end of a campaign, but it can be immensely rewarding for your players to take the time to talk about what their characters do with their futures. It’s not always relevant to one-shots, but sometimes an epilogue there is a nice touch to wrap up the game.

That’s all, folks!

As a final word of advice, be realistic about your group’s available time. If you can only get together once a month and even those sessions get interrupted, a grandly epic fantasy campaign may not be the best choice for your group. Ever since my group started rotating GMs every few months, and playing games more like they’re a Netflix or BBC show, we’ve mostly avoided the ignoble death of campaigns. Our games vary between short, self-contained campaigns, to ongoing campaigns that have seasons we rotate between. It has helped avoid GM burnout and prevented that sad feeling of watching a character languish in limbo, never to finish the story of their life.

How have you handled endings for your group? Do you also have a graveyard full of lost campaigns and unfulfilled characters, or were you luckier and got those solid endings more often than not? I’d love to hear your advice on giving games a satisfying conclusion.

 

Categories: Game Theory & Design

AddWeb Solution: Let’s Decode The ‘Decoupled Drupal’ Together!

Planet Drupal - 16 August 2018 - 11:31pm

‘Coexistence is the key to our survival’, they say about humanity. The same law applies to and therefore is adapted by the technological world too. ‘Decoupled Drupal’ is the outcome of the same law, coming from the field of web architecture. After years of following the traditional web architecture, Drupal came up with something that was not ‘monolithic’ - something that we call as ‘Decoupled Drupal’ today. Let us explore and decode in detail the web architecture that ‘Decoupled Drupal’ is!

Understanding, Decoupled Drupal

, ,

Freeing the front-end from the control of the content management system and focusing on the just back-end development. The presentation layer, themes, templates - everything front-end is taken care by the adopted front-end framework. This also implies that Drupal has chosen to do what it does the best - building and bettering the content part. The decoupled Drupal exposes the content to other systems such as native applications, JavaScript application, core REST API, IoT devices, et al, which clearly states the fact that every system can easily consume content from Drupal.
 

Decoupled Drupal, also known as Headless Drupal, in simpler words is about not letting go the core and robustness of Drupal by having the control over all the core content management related responsibilities. And yet opening up the door for the productive change on the part of content appearance. Decouple Drupal is a promise of omnichannel delivery for the marketers and publishers.
 

Pick your approach!

, ,

1) Coupled Drupal

This is the most appropriate approach to be adopted for a site that does not demand much rendering and state management from the client’s end. Drupal’s built-in twig templating system is used instead of the huge and heavy JavaScript framework. The help of JQuery can also be taken if needed. Since this approach doesn’t block content marketers by the front-end developers, extra marketing expense could be cut down.

 

2) Progressively Decoupled Drupal

A website that requires client-side interaction, Progressively Decoupled Drupal is being used. Under this approach the core strength of Drupal - its HTML generation is not eliminated and yet the benefits of the Javascript framework is adapted. The best of both the frameworks raises the quality of interactive experience plus a robust back-end. Usage of JavaScript enables the content marketers to freely gather the experience and benefit from it, without much of the developer’s support.

 

3) Fully Decoupled Drupal

The entire structure here is separated in terms of the content and the presentation, where the former one is taken care by Drupal and the later one is prominently undertaken by JavaScript frameworks. With both the advantages and disadvantages attached to this approach, it is not a highly recommended one. Independence on the underlying CMS and usage of the richness of JavaScript and its community, is one of the major advantages of the fully decoupled Drupal, while the addition of complexity to the technology stack is one of the major disadvantages.

Why should you be adapting Decoupled Drupal?
 

, ,

The popularity of the Decoupled Drupal is a reason enough to confirm how beneficial it has proven to be, so far. Let us share some prominent reasons why adopting the decoupled Drupal will prove to be advantageous for you:

 

1) Intact Security

Security - the key benefit of using Drupal is kept intact since the content management and back-end is taken care of by Drupal itself. The administrative CMS is kept far from the public eye is also something that helps in keeping the security level high.

 

2) Elevated Team Performance

Drupal CMS development requires more technical expertise as compared to that of some other front-end framework. So, when an expert of Drupal has more time and scope to focus on the segment that he has an expertise upon, the outcome would naturally be of that stature. In addition, the front-end developer will also have the freedom to work on his expertise and hence would be able to give better justice to your website with an overall elevation in the team’s performance.

 

3) Broader Approach

Drupal has always been broad with its approach, be it any website or organisation. In addition, Drupal now also has the publishing functionality that streamlines the experience for content creation. Under this architecture, it’s easier to push and manage the content to other places. This widens the possibility of the same content being spread and published on multiple channels.

 

4) Flexibility

Decoupled Drupal enables and accelerates the scope flexibility, whenever the website is in need of some change or upgradation. The independence to work and focus upon one single aspect, the developers and designers are granted the flexibility to dedicate their time to their respective jobs. The elimination of dependency of the back-end developers/tools from the front-end developers/system is what lifts up the scope of flexibility.
 

Already thinking of adapting the highly-trending and powerful architecture - Decoupled Drupal? Well, our Drupal-expert team might help you get a detailed and better understanding of the same. A customized viewpoint of Decoupled Drupal for your website surely makes a huge difference. Let our Drupal developers make that difference for you!

I hope this blog helps you to expand your Decoupled Drupal knowledge …Thanks! If you need more assistance regarding Drupal Development Services, feel free to contact us now.

Categories: Drupal

Designing Omnidirectional Levels for Lightfield - by Julia Murczek

Gamasutra.com Blogs - 16 August 2018 - 10:47pm
In this multipart series about the development of Lightfield we take a look back at some of the different areas. In this part I talk about the challenges we had to overcome when designing the race tracks for the omnidirectional parkour-style racing game.
Categories: Game Theory & Design

We’re making the first game that legally shows Nazi symbols in Germany – here’s why you should care - by Jörg Friedrich

Gamasutra.com Blogs - 16 August 2018 - 10:47pm
Battling the Nazis in World War 2 is a frequently-used setting in video games. Yet, in Germany -homeland of the Nazis, video games were not allowed to show any of their symbols. This has changed now. Here is how, why and what this means.
Categories: Game Theory & Design

PreviousNext: Introducing the Element Class Formatter module for Drupal 8

Planet Drupal - 16 August 2018 - 9:25pm

Allow sitebuilders to easily add classes onto field elements with the new element_class_formatter module.

by Rikki Bochow / 17 August 2018

Adding classes onto a field element (for example a link or image tag - as opposed to the wrapper div) isn't always the easiest thing to do in Drupal. It requires preprocessing into the elements render array, using special Url::setOptions functions, or drilling down a combinations of objects and arrays in your Twig template.

The element_class_formatter module aims to make that process easier. At PreviousNext we love field formatters! We write custom ones where needed, and have been re-using a few generic ones for quite a while now. This module extends our generic ones into a complete set, to allow for full flexibility, sitebuilding efficiency and re-usability of code. 

To use this module, add and enable it just like any other, then visit one of your Manage Display screens. The most widely available formatter is the Wrapper (with class) one, but the others follow a similar naming convention; "Formatter name (with class)". The majority of these formatters extend a core formatter, so all the normal formatter options should still be available.

The manage display page with new (with class) field formatters selected

The field formatter settings, with all the default options

Use this module alongside Reusable style guide components with Twig embed, Display Suite with Layouts and some Bare templates to get optimum Drupal markup. Or just use it to learn how to write your own custom field formatters!

For feature requests or issues please see the modules Issue queue on Drupal.org

Tagged Field Formatters, Contrib Modules
Categories: Drupal

ADCI Solutions: ADCI Solutions got featured at Awwwards

Planet Drupal - 16 August 2018 - 8:34pm

One more reason to be proud of using the Drupal CMS. We tried ourselves at one of the most respectable rankings - Awwwards, and the ADCI Solutions' Drupal project got 7 points there!

Check this short blog post for more details.

Categories: Drupal

Copy Filter

New Drupal Modules - 16 August 2018 - 4:39pm

Provides a filter which removes extraneous styling and formatting when copying from a third-party text editor.

Categories: Drupal

Entity Asset

New Drupal Modules - 16 August 2018 - 12:40pm
Categories: Drupal

Bulk field

New Drupal Modules - 16 August 2018 - 12:12pm
Categories: Drupal

Matomo reporting API

New Drupal Modules - 16 August 2018 - 9:38am

Provides an API to retrieve statistics from the Matomo open source web analytics platform. This module is intended for developers to integrate statistics in their projects, it has no UI for end users or site builders.

Dependencies

See the matomo_reporting_api_example module for an example implementation of a block that shows some Matomo statistics.

Categories: Drupal

Lullabot: GatsbyJS with Creator Kyle Mathews

Planet Drupal - 16 August 2018 - 8:56am
Mike and Matt are joined by Lullabot John Hannah to talk with the creator of GatsbyJS
Categories: Drupal

Filter Twig

New Drupal Modules - 16 August 2018 - 8:19am

This is a very simple module to make twig values available as an input filter.

Composer Install

If your site is managed via Composer, use Composer to download the module.

composer require "drupal/filter_twig ^1.0"

Or

Install the module as any other module.

Usage

Visit the text format administration page at:

/admin/config/content/formats/filters

Categories: Drupal

Drupal.org blog: Developer Tools Initiative - Part 5: Announcing our Migration

Planet Drupal - 16 August 2018 - 7:31am

This is the fifth post in our series about integrating Drupal.org with a 3rd party developer tooling provider:

In this post we are announcing our migration to a new tooling provider, and outlining the phases of that migration process to take place over the next several months.

Announcing our partnership with GitLab

Wait, what?

Yes, in our four part series from December of last year it certainly looked like we were going in a different direction for the future of Drupal's developer stack.

So what changed?

Last year we laid out a model for integrating Drupal.org with a third party tooling provider, which we described as "Drupal Flow". This model was deliberately laid out to be agnostic to the provider we chose, so long as certain requirements were met. We worked with representatives from three potential providers at the time: GitHub, GitLab, and BitBucket, and each one had pros and cons. Once we had completed our evaluation, BitBucket was the only provider without hard blockers to the integration we wanted to build.

However, following our blog series, the GitLab team reached out directly to the Drupal Association team, and asked us to give them the chance to resolve the blockers and close the gaps in our integration.

At the same time, we saw an outpouring of feedback from our community asking us to see if we could find a way to make GitLab work.

And so we did.

The Agreement

For the past six months we've been working closely with Eliran Mesika, the Director of Partnerships at GitLab, in addition to CEO Sid Sijbrandij and members of GitLab's engineering team. They've escalated the internal priority of issues that blocked our adoption of GitLab, offered technical and financial support for the migration, and made a commitment to ongoing support for the Drupal project.

And so we're happy to announce that Drupal.org is going to be moving our code collaboration tools for our forty-five thousand projects to GitLab over the course of the coming months.

Three Phases to the Migration Phase 1: Replacing Drupal.org's Git backend

The first phase of the Drupal.org migration

  • Transparently replace Drupal’s current underlying Git infrastructure (for repository hosting, maintainer permissions, code viewing) with GitLab repositories, GitLab roles and permissions for maintainers, and the GitLab code viewing UI.
  • Enable inline code editing (only for maintainers for this phase).
  • During this phase, Drupal.org will remain the primary source of information.  SSH keys, new projects, etc. will be created on Drupal.org.

This first phase, while modest, will bring some concrete benefits to the project:

  • Maintainers will be able to begin familiarizing themselves with GitLab's code collaboration tools.
  • Code viewing will receive a significant upgrade from CGIT to GitLab's built-in code viewer.
  • And Drupal.org's old Git server will be phased out.
Phase 2: Enabling Merge Requests, Inline Code Editing, and Web-based Code Review
  • The timeline for Phase 2 is dependent on GitLab’s resolution of a diskspace deduplication issue, which they have committed to on our behalf: https://gitlab.com/gitlab-org/gitlab-ce/issues/23029
  • Enable GitLab Merge Requests, GitLab inline code editing in the web UI, and GitLab web-based code review.
  • During this phase, Drupal.org will handle any 'create branch/merge request' integrations from the Drupal.org Issue queues, and related call-backs from GitLab into the Drupal.org issue comment stream.

Phase 2 is where we realize some tremendous benefits to developer velocity and collaboration:

  • By adding merge requests, contributing to Drupal will become much more familiar to the broad audience of open source contributors who learned their skills in the post-patch era.
  • By adding inline editing and web-based code review, it will be much easier to make quick contributions. This not only lowers the barrier to contribution for people new to our community, it also saves significant effort for our existing community members, as they'll no longer need to clone work locally and generate patches.
  • Finally, by creating a tight integration between the Drupal.org issue queues and GitLab's development tools, we'll be able to transition to this new toolset without disrupting the community's existing way of collaborating.
Phase 3: Evaluating Additional Features

Phase 3 has no strict timeline, but will be dependent on feedback from the community as they get up to speed on using the new GitLab-based contribution workflow for Drupal.

  • Evaluate additional features such as:

    • Integrating or replacing DrupalCI with GitLab CI
    • Enabling GitLab issues for a sub-set of projects
    • Enabling GitLab confidential issues for specific use-cases (security releases)
    • Possible MatterMost integration, etc.

These additional features may allow us to further improve the velocity of the Drupal project, or realize additional cost savings for the association. For example, we may be able to use GitLab's test runner integration to orchestrate tests across a wider variety of cloud platforms, helping us find the best pricing. We may be able to entirely replace security.drupal.org with a private issue tracker, eliminating an entire sub-site for the Drupal.org team to maintain. We may even be able to enhance existing community services like SimplyTest.me by integrating features like GitLab's AutoDevops tools to automatically create review environments for issues or branches.

We won't really know what's possible within the scope of our resources until the first two phases are completed, but this helps to show that by hitching our toolset to a partner that specializes in collaboration, we may be able to realize even more benefits for our community.

Changes to Git Remotes
  • Git remote urls for pushes to full projects have changed:
    • If you have an established Git remote in the format
      <username>@git.drupal.org:project/<yourproject>.git
      the format should be changed to:
      git@git.drupal.org:project/<yourproject>.git

  • HTTPS clone urls for full projects are unchanged.
  • HTTPS clone urls and Git remote urls for sandbox projects have changed:
    • For remotes of the format:
      <username>@git.drupal.org:sandbox/<username>/<node-id>.git
      the format should be changed to:
      git@git.drupal.org:sandbox/<username>-<nodeid>.git
    • Clone urls will be changing from:
      https://git.drupal.org/sandbox/<username>/<nodeid>.git
      to the format:
      https://git.drupal.org/sandbox/<username>-<nodeid>.git

Important: If you have any automated systems which authenticate to Git, such as CI pipelines or repo mirroring, ensure they are updated as well.

For more detailed information about these changes, as well as instructions for changing your Git remotes or setting ssh keys, please consult these instructions: https://drupal.org/gitauth

How to follow our progress

Issues for the Drupal.org migration to GitLab will be opened in the Drupal.org Infrastructure queue and tagged 'GitLab'.

For questions or concerns, please create an issue at https://www.drupal.org/node/add/project-issue/infrastructure

Categories: Drupal

Postmortem: Black &amp; White Bushido, the stealth-em-up arena brawler - by Anil Mistry

Gamasutra.com Blogs - 16 August 2018 - 7:18am
We have released Black & White Bushido on PC, PS4 and Xbox One. In autumn 2018 we will release the game on Nintendo Switch, but first we wanted to take a look at what we have learnt so far on our journey, what went right and what we would do differently.
Categories: Game Theory & Design

Five Tips for VR/AR Device-independent Unity Projects - by Jonathan Linowes

Gamasutra.com Blogs - 16 August 2018 - 3:58am
How does a Unity developer “create once, build many” while dealing with the rich, varied, constantly changing plethora of VR or AR toolkits and services? At Parkerhill, we came up with a set of best practices that work for us.
Categories: Game Theory & Design

Pages

Subscribe to As If Productions aggregator