dnd 5e – What are the DM’s responsibilities when dealing with a character’s death?

This is about Best Practices, not responsibilities.

You ask about responsibilities and there aren’t any, formally.
Informally, the objective of the DM is to facilitate the play experience for the players. There is a practical need to work with the player, once the session is over and before the next session, to get their next character set up and ready to fit into the game world. I’ve done that literally dozens of times, probably hundreds. I have also been the player in that situation dozens of times.

  • Good DMs have always opened up some time to help me get my new PC
    ready for the next session with the group.

Should they leave? Should they just sit quietly and watch? What can
they do? What should I, as DM, do?

It depends on the player.

What I usually do when it comes up during a session

I usually have the dead character’s player, for the rest of that session, do all of the die rolling and movement for the monsters that the party is fighting. I’ve been doing this since I started DMing in the late 1970’s. Very few players don’t enjoy this. Most of them jump right in – when they do it relieves the DM of a lot of detailed work, and (importantly) keeps the player engaged for the rest of the session. (This was very important for pre teens, I found).

For those rare ones who do not embrace that option, I have generally put them to work in creating their next character. They can stay in the room, or, if they don’t want the distraction of the session going on while they do that, move to another room.

For those who get upset and / or rage quit

Yeah, it happens. Some people get very upset about their character’s death. I don’t see it that much anymore, but I saw it a lot among teenaged players and a very few adults.

For those cases:

  1. Express condolences. (I did this even in old school games. I never
    took joy nor pride in the PC dying – some DMs seemed to …)

  2. Remind them that this is a game.

  3. Ask them to make a new character, and encourage them to start right
    now. Sometimes this does not work, and that leaves …

  4. Ask them to come back later, or for the next session, when they have
    cooled down.

Those are DM best practices that I’ve seen, and implemented, over a lot of D&D years.


The Impromptu Funeral – a group option if your players like this

I was in one very memorable group in a high lethality campaign (AD&D 1e) who would, after a battle where a PC died, put together an impromptu funeral pyre and each player would say something nice about the dead PC before the flames burned out – unless hot pursuit was an issue. In a few cases of the latter, we had memorial services at a local tavern during the session wrap up, or at the beginning of the next session.
I (a player) maintained the “Hall of Heroes” notebook where the char sheets of dead PCs was kept. (about a dozen). That small three ring binder is still in a box in my pile of old D&D stuff in the attic.


Proper Prior Planning

DMG p. 236 offers this:

Multiple characters can be a good idea in a game that features nonstop
peril and a high rate of character death. If your group agrees to the
premise, have each player keep one or two additional characters on
hand, ready to jump in whenever the current character dies. Each time
the main character gains a level, the backup characters do as well

If you all are running a campaign with a high lethality rate, or have embraced that tone of a campaign, then having a back up character already put together(one for each player) is a best practice. You still have the matter of what to do ‘for the rest of the session’ or ‘until I can fit in a Meet the New PC situation’ which takes us back to “run the monsters” as a good way to keep the player engaged until the session ends, or the meet up scene arises.

Bonus: this approach is also useful if a player gets tired of a PC and wants to retire (or suicide) the PC and bring in a different one. We’ve had five instances of that in my current shared-world campaign that I DM with my brother.

unity – Game architecture and class responsibilities

I’m a web developer, new to C# and trying to learn Unity. I’ve learned the C# syntax, I understand how to write working code, although I’m having a hard time understanding when and to what classes should I split my code. If I understand correctly, I try to imagine my app being like a house and the classes being like the bricks, doors, windows etc. But even then I just can’t quite get it. I’m somewhat a perfectionist and like to do everything nice, clean and corresponding to the best practices, but I don’t understand the best practices, when to create a GameManager class, when do I create a PlayerController, when do I create a PlayerManager, how will it communicate with my Movement class, what and where should I keep track of, where do I put the states and how will then the states work. Should the door know when it’s being opened or should the door just open on command? Are there any good resources about architecting the systems or maybe you have any suggestions where could I find bigger projects for free to download as examples to see how it’s done? Haven’t found anything good about the subject on a more bigger picture level and the resources I found are very small and specific. Just need a place to start understanding the subject.

c# – Can’t tell exactly what does this class do, the responsibilities of it?

So I Have this class:

public class GeneralService : IDisposable
{ 
    private readonly LoggingService _logginService;
    private readonly DataService _dataService;
    private readonly IServiceProvider _serviceProvider;

    public GeneralService(LoggingService loggingService, DataService dataService, IServiceProvider serviceProvider)
    {
        _logginService = loggingService;
        _dataService = dataService;
        _serviceProvider = serviceProvider;

        var eventBusProvider = serviceProvider.getService<eventBusProvider>();
        eventBusProvider.RegisterForNotification(this, EventTypes.Exception, HandleException);
    }
    public void Dispose()
    {
        var eventBusProvider = _serviceProvider.GetService<eventBusProvider>();
        eventBusProvider.UnRegisterForNotification(this);
    }
    public void Execute(Action action)
    {
        LoggingService loggingService = _serviceProvider.GetService<loggingService>();

        StopWatch watch = new StopWatch();
        watch.Start();
        loggingService.LogInformation("Start Executing");

        try 
        {
            action();
        }
        catch (Exception exception)
        {
            loggingService.LogException(exception);
            return;
        }

        watch.stop();

        _dataService.CreateLog($"{nameof(GeneralService)} - {nameof(Execute)}: {watch.ElapsedMillieseconds}");
    
    }
    private void HandleException(Exception exception)
    {
        var loggingService = new LoggingService();
        _dataService.CreateLog(exception);

        loggingService.LogInformation("Ă‹xception was logged");
    }
}

And I have 2 problems, I can’t describe the responsibilities of this class and I’m not sure exactly how can I refactor it according to industry best practices, any help would be great. thanks in advance.

mysql – Understand responsibilities of database and backend

Rdms are part of the backend, only in rare cases lie access, you can have both.

Even so the gui should always prevent errors in the database, and should control the input of it validity.

Errors happen, should not directly shown to the user. But as you have to debug it, you should show helpful ids or text, that could help fixing things.

For a qualified system you have to go a step further and tell the user how he can fix the problem, for example be editing his input in a correct way.

check constraint help to debug, your code, especially in the beginning, when teh gui is only starting, so no problem will be missed.

Foriegn keys triggers and event help the database maintaining or do things that the user has no inföluence, as the rdms is a background process, that shouldn’t come to light.

object oriented design – Breaking up a class with too many responsibilities

I’m looking for advice on my specific problem, how to break up a class, Basket, that has too many responsibilities.

Currently, it does three things:

  • Keeps track of the products in the basket: addProduct(), removeProduct(), getProductQuantity()
  • Keeps track of the total price of the basket: getTotalBill()
  • Applies discounts: applyDiscount()

Products can have multiple distinct discounts applied to them, but not the same discount more than once. In order to facilitate this here’s my design:

Class Diagram

I can see the following problems with this design:

  • Circular dependency between Discount (that needs a basket in applyDiscount) and Basket (that stores a map of Discount codes)
  • Basket has too many responsibilities. It keeps track of products in the basket, the price and discounts
    • A real life basket only keeps hold of items, not the price or discounts

I’m struggling to think of ways to improve this design. I’ve thought of an alternative idea but it has its tradeoffs:

  • Have a BillCalculator that calculates the total.
    • Users want to know their current cart total at all times, so we’d have to call this each time we add or remove a product from Basket and recalculate the bill from scratch. This is inefficient compared to the current approach where totalQuantity is simply incremented and decremented when addProduct or removeProduct is called.

What am I missing? How can I break up the multiple responsibilities of Basket without sacrificing on efficiency, and without storing the list of products in multiple places?

design – Separate responsibilities when public methods depend on other public methods in same class?

Recently I hit something like the following setup in our codebase, and I’m wondering if there’s a preferred way to do it, to achieve the cleanest separation.

public class FileLoader
{
    public object LoadFile(filename);
    {
        return loadSomethingFromSomewhere(filename)
    }
    
    // new functionality
    public string GetFileVersion(filename);
    {
        return LoadFile(filename).version
    }

    private object loadSomethingFromSomewhere(filename)
    {
        return do().stuff().with(filename)
    }
}

The code already loads a file, and now I want to read some metadata off of it. In the business logic, all this metadata is eventually thrown away, but some parts are now important to introduce.

  • GetFileVersion is a pretty simple fix, and doesn’t break any compatibility. On the other hand, I dislike the fact that it calls another public function, and then adds an extra step on top.
  • Alternatively one could simply tack the version on top of the existing public function, and return it as a <object, string> tuple with the version attached. It doesn’t break responsibility now, but it does in theory break the function signature throughout the codebase, and it introduces information that isn’t always needed.

What say the design gurus?

Workflows – division of responsibilities in different project areas

When I say "realm," I usually mean a relatively large entity or service that is part of an entire product; H. API service, location service, storage service, etc.

Context: A project with over 20 separate services that has been in development for 7 years. It was written from scratch. So if it counts, it's more than 25 years old. About a year ago, a new team was hired to continue development and maintenance. We currently have 10 developers.

The usual workflow is when a new item arrives, it is assigned to a developer, no matter what project area it is in, and then the developer is responsible for its resolution.

It was a bit chaotic for us to evolve over the past year because the codebase, in my view, is huge and no one knows every corner of our app, especially when randomly assigned to different areas.

Question: Is it a sensible idea to assign a developer responsibility for specific areas (services) so that he can focus on learning 1-2 services in detail and then being better informed? For example, we can maintain the same development process, but there will be one person who can perform a quality code review if someone makes a pull request for their area, or can give advice when needed.

We will discuss this internally in the near future. Personally, I do not see any disadvantages and I would like to know if anyone has experience with such an approach, its advantages and disadvantages, or perhaps even other ideas for improving the current workflow.

Can the technology companies in the world handle the responsibilities that we delegate to them?

Wow, where should I start …

Over the last 20 years, we've been passing more and more of our personal information to large private companies, notably American ones. In this documentation, Cold Fusion goes into a mini-documentation about a quarter closer to it.

Among other things, how the competition in the technology industry works, what responsibility the technology companies take for the information we share with them, and how everything shines in freedom of expression. There is also talk about cryptocurrencies and in particular the cryptocurrency Libra, behind which are currencies like Facebook and some of the world's largest technology and payment companies.

The big question being discussed is whether these giant corporations are beginning to gain strength for the benefit of society, and whether they should be divided into smaller units. What do you say? The comments are at your disposal.

Have you seen this youtube video already? What do you think?

_
SEMrush

Does your CV include your online responsibilities? | Forum Promotion

Hi, I'm just wondering if any of you have included some of your online jobs / roles / activities in your resume for work.
There were stories of people even discussing their leadership skills in World of Warcraft in interviews, and I personally pointed out that I had formed and moderated communities in the past. It should not be a central issue, unless the work was significant, but I think it is not only acceptable to refer to it on the CV or in an interview, but also a good thing.

Some things your CV could mention are …

  • Forum ownership / management / moderation / administration skills
  • Website development / design experience
  • Video Editing / Marketing (I have an old game channel with 8,000 subs and 5 million views, so I always mention creating, editing and marketing video / media.)
  • Blogging / Articles: I can reference my articles on FP itself and some other websites. I would not link it to CV, but definitely mention it

There are a lot of things you can do online that actually boost your career. Regardless of whether you include it in your resume or not, it is an amazing advantage to gain experience in some sort of technical skill. You can include it in your resume, or simply discuss it in interviews, or use your online activities as an example, if you have no further professional experience to discuss with interviewers.

What do you all think?

Design – To separate the responsibilities of a common entity

For example, suppose I have a performance class that stores performance information such as name, pop-up message, and so on.

Class GoldMedal implements GameAchievement {
@Run over
String getName () {...}

@Run over
String getAchievementDisplayMessage () {...}

}

When the game ends, I want to record the current achievements in local storage (Common settings) about static keys like ACHIEVEMENT_GOLD_MEDAL:

editor.putBoolean (ACHIEVEMENT_GOLD_MEDAL, isAchievedGoldMedal);

Question: Where should these keys be stored?

It's tempting to put it in it gold medal Since it is directly relevant and intuitive, does it feel like it violates SRP (or No?) Because it's related to the storage mechanism:

Class GoldMedal implements GameAchievement {
// ...

@Run over
String getStorageKey () {...}
}

// Usage:
editor.putBoolean (achievement.getStorageKey (), isAchieved (performance));

Another option that I thought about is to hide them under an interface:

Interface LocallyStorable {
String getStorageKey ();
}

Class GoldMedal implements GameAchievement, LocallyStorable {

@Run over
String getStorageKey () {...}
}

I think my question is generally the best course of action separate responsibilities that relate to a common entity, such as: Game Achievement?

For example, if there is a new property of a Game Achievement in another domain, for example in a tutorial page (String achievementTutorialText), should we make another interface from it?:

Interface GameTutorialComponent {
String getTutorialText ();
}

Many Thanks!