Dealing with (supposedly) in-character bullying

There is a member in our current gaming group that has been difficult to deal with and I would really appreciate some advice. For context: We are a group of four people, including the DM, and have been playing Pathfinder for well over a year now. Age-wise we are in our late-twenties to early forties, with myself being the youngest player. I am a player, as is he. (Let’s call him Kevin.)

Kevin’s character has been ridiculing mine throughout the campaign. Sometimes it’s mean-spirited, often it’s just utterly nonsensical and without basis. He frequently presents her as stupid (her Intelligence is 12 – so, no genius, but still above average) or mocks her for things she never did. Examples include throwing sticks and shouting “Careful, snake!” because according to him, she is afraid of snakes (she isn’t) or making jokes about her always pooping her pants (something she never has).

It’s both bewildering and annoying and it really puts a damper on roleplaying the character, because any real or perceived weakness will instantly be turned into a stupid joke. Same with any “peace offering”. Heck, last session we did a mock magic-duel in front of an audience in honour of his god (my idea and he liked it). My character tried to be supportive, tried to make him look cool, because hey, it was supposed to be his show. (i.e., I deliberately failed a few saves in the beginning.) Meanwhile, Kevin’s character tried his best to humiliate her in front of the audience.

To boot, I am the only girl in the group. And while I wouldn’t go so far as to call it outright sexism, there is a really icky/degrading vibe to a lot of those jokes. (Slapping her awake with sausages when she is unconscious or pouring water over her pants to make it look like she peed herself.) It’s not inherently sexual, but it still feels gross.

All in all, none of those jokes are horrible, but they aren’t funny either and they just keep piling up, basically every session. And again, most of the time they do not even make sense.

Kevin’s character has done some name-calling or trolling to NPCs or the other remaining PC as well, but only once or twice. I’m his prime “target”. The other players think he behavior is a bit rude, but don’t feel strongly enough about it to speak up and I don’t want people to ‘pick a side’ in this, tbh.

The main problem is that it is really hard to tell “player-voice” and “character-voice” apart with Kevin. He is very hard to read as a person and very tight-lipped, getting any information out of him is like pulling teeth. When I tried to talk to him about his “jokes”, he acted surprised and implied he was just roleplaying his character. (He has 6 Charisma.) I’m not sure I buy it, since some of the jokes have been meta (like gifting me a oversexed joke-mini with no similarity to my PC because: “look, it’s her!”) and he isn’t even roleplaying anything else. (And we have yet to see that 22 Wisdom roleplayed in any form…) After our talk, it got better for a short while, but now he is right back to normal.

I have tried “playing along” and reacting in-character. This has included storming off crying and generally acting upset and hurt. Kevin’s character acted disinterested and called her overly emotional and, again, stupid for it. (Whereas Kevin himself seemed mostly amused, because he provoked me/made me ‘lose’? I don’t even know, to be honest.)

All in all, it’s not bad enough to be a deal breaker. The rest of the group is fine, the adventure is cool and he is just one guy. I don’t want to blow it out of proportions by involving the whole group. But it is, frankly, annoying and I don’t know how to deal with it. Any advice?

EDIT 02.07.2018:

Thank you for the extensive feedback and advice. I was blow away by how seriously you took this, since I was afraid I was just being whiny and paranoid. Your reaction really made me reevaluate the whole situation and I realized that I have actually been kind of a doormat throughout this whole campaign. This needs to change. ASAP.

Most of you suggest bringing it up with the DM. I don’t want to do that yet, since it is pretty much an official accusation and will probably escalate things. But I did bring it up with the one remaining player, “Josh”. He agreed that Kevins behavior was out of line and promised to support me and speak up the next time it happened.

(There has been some comments whether his or the DMs behavior is “cowardly” and while I do appreciate your fervor, I think I need to defend them a bit here. Josh and I have been Rpg-buddies for a long time and we play well off each other, precisely because we are both very “live and let live” with loooong fuses. This may not always be the best way to deal with stuff, but we avoided a lot of drama with that approach in the past. Do I wish he would have spoken up on his own? Maybe. But in the end, he’ll have my back. As for the DM, Kevin is a challenging player in general and not easy to assert any “authority” over. He might just be picking his battles. Again, maybe not optimal, but hey. We are all only human.)

This evening (CEST) we will have our first session since I posted this question. If Kevin tries any of his “humor” again I will speak up at the table. You guys gave me great advice and material on what to say and how to phrase it. A lot of bullies back off when facing open resistance. Maybe just showing him that I won’t be his easy target any longer will solve this. If not, step two will be involving the DM. And step three will be quitting the group, if nothing else helps.

I’ll keep you updated.

EDIT 11.07.2018:

Posted recent – and hopefully final – developments of this mess as an answer.

Dealing with USB Arduinos

It is probably common enough knowledge now that you should not plug into your computer any device that an attacker has had physical access to. Especially USB devices.

Thanks to the many tutorials on how to make your own RubberDucky/BadUSB, it is very easy and simple for any malicious actor to make one especially using an Arduino Leonardo-based board.

Consider the case of ordering an Arduino Leonardo online. If before delivery it should get compromised, evil-made style or intercepted during delivery, is there any way to detect it? Are there any telltale signs I can look for in the output of dmesg?

If I were reasonably sure that the device is 100% an Arduino Leonardo that may have simply have been compromised, would clearing it by uploading a new sketch from a Live OS be enough to make it safe for use?

To be clear, the threat model I’m assuming is an adversary that can execute an evil-maid level attack but not one that can probably manufacture their own Arduino clones.

Dealing with 2 Immature Players Who Detract from the Experiences of Others

I have read a number of threads here similar to but not the same as the problem my group and I are having (including this thread, this answer, this answer to a similar situation, and this question which addresses only 1 person).

I have a question related to dealing specifically with 2 problem players, and would like to explore avenues of resolution other than disbanding or kicking these players out of the group.

After joining a new group recently, I am finding more and more that two people in the group are surprisingly immature, a fact not helped by them both feeding off of each other’s behaviour. While this is not necessarily a problem in and of itself (and in theory could actually lead to some fun interactions), it is unfortunately leading to some detrimental effects for the rest of the group (and the DM in particular). these effects include:

  • Slowing the game down – When these two players get together, they tend to distract one another. This is especially frustrating when playing with a larger group (5 or 6 other players), since in talking to one another they miss what is happening, and we consistently spend time having to catch them up on what other players have done, the state of the battlefield, etc. While not a huge problem for me as a player (though certainly irritating), our DM is getting understandably frustrated having to repeat everything twice, since neither of these two players are paying attention. They also don’t think ahead when its not their turns, and since they are both spellcasters, this frustrates us other players a great deal, as our turns often take under 30 seconds, while because of their distracting behaviour their turns frequently take upwards of 5 minutes each.
  • Losing a sense of cohesion – Their two characters almost exclusively look out for each other, even to the detriment of the rest of the party. While this could make for an interesting dynamic in game, their behaviour is inconsistent, and they appear to show little loyalty to the order our group serves (around which our 2 month campaign has been based; loyalty to this order was the prerequisite for joining the group), our overarching mission, and more importantly the welfare of our group (eg last session they refused to heal our tank because they wanted to save their healing spells for “more important characters”). This is, unsurprisingly, leading to resentment both in and outside of the game.
  • Ruining Immersion – A large draw for many of us to this group in particular is the role playing aspect of the game. However, the constant bickering and out-of-game discussions among these 2 players is constantly drawing us out of the game. Our DM has tried calling them out at the table for being distracting and taking away from the game, as well as speaking to them privately (though I was not present when this conversation took place). Regardless, the poor behaviour continues, and our DM appears to be at his wit’s end.
  • Poor Gameplay – Before anyone gets upset about me listing this, let me explain. The two players tend to make decisions against the advice of the rest of the group and the DM (which is fine – after all, we are roleplaying). HOWEVER, these decisions (unsurprisingly) often lead to a poor situation for them, to which they respond with resentment towards the group and the DM, consequently leading them to spend the rest of the night complaining about how boring the game is, and further distracting the group. For example, in our last session we were fighting a group of dragons. Rather than mounting their dragons and helping in the fight, both decided instead to head into town and get drunk, even after the rest of us, including the DM, advised against it. When they realized that the rest of us were having a great time slaying Shadow Dragons, they complained that they were stuck in a tavern in town essentially doing nothing, and began berating the DM for not allowing them to instantaneously join the battle. We are unsure of how to handle this behaviour, and their boredom undoubtedly contributes to the distracting behaviour that is frustrating the rest of the group.

Ultimately, the question boils down to this: How do we deal with 2 immature players who feed off of one another, and detract from the experiences of other players?

Although simply kicking them out or forming a new group is certainly an option, I figured sharing our predicament with the wonderful RPG community here may lead to some unexpected solutions which may help us actually resolve the problem.

Seeking 1990s horror game of otherworldly PCs dealing with monsters on modern Earth

In the 1990s I once played a horror RPG. I’d like to track it down again but I’m unable to figure out what it was. As best I can remember:

  • The PCs are powerful, almost alien beings. Players had a great deal of freedom in what their PCs looked like.
  • The PCs normally reside in another universe or plane. Their homes were reflections of themselves, and may have been able to violate the laws of physics.
  • Other alien horrors would enter Earth occasionally. They could be overt or subtle. PCs would be called to Earth to hunt down and destroy these horrors. The core problem may have been that the horror’s presence caused or was caused by a tear in reality?
  • There may have been a mechanic where normal humans could be blind to the supernatural, making it easier for PCs to blend in but also giving cover to the horrors.
  • It was billed as a horror game.
  • I played it somewhere between fall of 1993 and spring of 1997. I think it was newish when we played.
  • Based on reviews, I’m pretty sure it’s not Kult.

What was this game?

Dealing with people who turn up late for sessions

I run sessions every Monday evening at a pub in the centre of London, and most people come to play straight from work. Up until recently we were attempting to start at 7pm, but there were one or two players out of five who struggled to get there on time, which was causing disruption to the rest of the group.

We talked about this as a group and decided to move the start time back to 7.15pm, with people asked to arrive early enough so that we could start playing at that time. However, what has actually happened is that some people are now arriving at 7.25, which means that overall we are losing a good half an hour of gaming time before everyone is sat down, knows what is going on and are ready to play.

I find this extremely frustrating and disrepectful to me as GM and to those players who make an effort to arrive on time. The problem is that I’m not sure what, if anything, I can do to stop this from happening. I’ve considered various approaches, with the most severe being asking disruptive players to leave the game, but I really don’t want to have to do this.

So, my question is:

What strategies are there for minimising the disruption caused by players that turn up late to sessions, and what can I do to prevent this from happening in the first place?

Dealing with large code base quickly in agile

At my current company, the project I work on is coded in Java, at least for the systems / backend part. Whenever I get assigned a task dealing with the Java code, it take me hours or even days to figure everything out and apply my solutions. The reasons are:

1) Very large Java EE code base

2) A lot of abstraction

3) Get lost in figuring out all the abstractions such as methods then i often spiral down a hole where i think of something else and forget my original solution etc.

My work environment is agile and I am expected to deliver quickly, but as a fairly new member of the company and a huge code base that was built before i joined, it is difficult for me to meet “agile” timing.

How is one supposed to deal with such a huge code base where nearly every single line/function leads to another abstraction and within those are even more abstractions in a timely manner?

Edit: I know I can ask my peers but at the same time i do not want to be constantly bothering them since problem solving is part of my job

Efficient algorithm to simulate dealing cards from a large deck of cards?

In shedding-type card games, the dealer starts by dealing a shuffled deck of cards to the players (if there are N players, card i goes to player i mod N). If the number of each type of card is known, is there a way to simulate dealing the cards and get a count of each type of card each player has?

For example, if there are N=3 players, and there are 5 card types and the count of each card is [3000000000, 3000000000, 3000000000, 3000000000, 2], one possible output is [1000000000, 1000000000, 1000000000, 1000000000, 1], [1000000000, 1000000000, 1000000000, 1000000000, 1], [1000000000, 1000000000, 1000000000, 1000000000, 0], which represents the number of cards of each type that each player has.

A naive algorithm is to create a large array of all of the cards, do the Fisher–Yates shuffle on it, and then go through each element and increment the count of the card for the current player and set the current player to the next player.

Is there a more efficient algorithm? It would have to generate the output with the same probability that the naive algorithm would.

What is a good Object-Oriented design for geometry objects when building libraries dealing with geometry operations?

I am trying to design an object-oriented library to handle geometric calculations. However, I am trying to exaggerate on being “tightly” object-oriented and applying relevant “best practices”. I know that there is no reason to be dogmatic about patterns, I am just trying to squeeze out every bit of possibility that I have not found out any different way for what I am about to ask.

Consider trying to design a path, composed of segments. I consider having a common interface for segments, which offers a method to calculate points of intersection with another segment. In short, the tentative signature of such a method might look like:

abstract class Segment {     ...      Point[] Intersection(Segment other);      ... } 

However, when implementing such a method, it might be necessary to check what actual implementation lies behind the “other” Segment. This can be done through run-time type checks, given that the language supports it, otherwise, I have to use some kind of enum to differentiate between segments and, potentially, cast the object to call corresponding methods. In any case, I cannot “extract” some common interface for this kind of design.

I have considered “forcingly” establishing a base-assumption that all path segments boil down to sequences of points, and unify the algorithmic intersection process as being always a line-to-line intersection between all sub-segments, but this will rob the design of a very significant (in my opinion) optimization possibility. Considering the ubiquity and “temporal density” of geometry-based operations the library will be built to support, it is very important, in terms of performance, to take advantage of special shapes having “closed forms” to calculate intersections between them (such as a circular arc with a line), instead of testing a multitude of small line-segment pairs to identify intersection points.

Apart from that, if I make the simplifying assumption of paths consisting of path sequences, I will have to make another relatively pervasive (for such a library) design choice, that of point density, to trace, for example, the various segment types. This would be, in my opinion, a reasonably architecturally-relevant parameter when considering an end result of drawing, e.g. on-screen, in order to achieve a given level of smoothness, for example. However, I feel this is, conceptually” an unsuitable abstraction for the geometric operations between pure geometric abstractions. A circle is not a series of line segments and should not need 5,10 or 100 coordinate pairs to be represented. It is just a center and a radius.

My question is, is there any other way to be object-oriented when dealing with base classes for geometry entities, or the “usual” way of doing things is with an enumeration and implementations checking segment type and exploiting specific geometric relations to potentially optimize the procedures?

The reason I am giving so much thought on this is that I might find myself having to implement special segment types, such as, for example, parametric curves, in the future, or simply allow extension of the API outside of the API itself. If I use the enum-based, type-checked everything-with-everything intersection tests (and do so also for other spatial operations between segments besides intersection), “outsider” extensions of the API will have to “register” themselves in the segment-types enumeration, which would necessitate either changing and rebuilding the original API, or providing a mechanism for external registrations. Or simply make a true global capture of all possible segment geometric forms to account for everything.

To make it simple, assume that I implement this only with segments, and then I add a new implementation of a circular arc. I can “teach” the circular arc how to intersect itself with straight line segments (by checking the segment type for “line”, for example), but I can not “teach” the line segment how to intersect itself with arcs without going back to change the original library.

I understand that there are methods or techniques to provide all this flexibility (I could make segments register special “injected” intersection methods for specific identifiers, which would be determined by the external API extension objects, so that lines will first check whether the object they intersect with is such a “special” type, or simply make intersection methods virtual, so that the developer trying to extend my API will be able to manually “teach” all existing segment implementations how to intersect themselves with my original objects). All I am asking is, is there any other elegant way to tackle this situation?

The top-voted answer to this question suggests excluding the method entirely and delegating it to a different class. This does sound somewhat counter-intuitive, given that segments do know their geometries. However, segments do not know other segments’ geometries, so it appears to be reasonable design decision to “outsource” the intersection method, one that still necessitates knowing the segment type at run-time, however. Since I am trying to represent segments as interfaces “ignorant” of the underlying type (as in “I want to support the use of the segment interface as being ignorant of the underlying implementation”). Apart from that, I would not resort to empty marker interfaces to differentiate between classes. An external “intersector”-like class would look interesting, though I would avoid making it static, in order to allow for extensions and potential changes of strategy (different implementations, optimizing for speed, employing snapping, etc).

As a DM, how to avoid unconscious metagaming when dealing with a high AC character?

In my previous campaign, a player started the campaign with a tanky fighter build with a chain mail, a shield, and Defense fighting style, for a total of 19 starting AC. For a level 1.

I was still learning to DM, so I became frustrated whenever it was a monster’s turn and the closest target was him. Unconsciously, I finished the monster’s turn noticeably more quickly than others attacking other targets (“Oh, a 12. The dagger can’t pierce your armor. Okay, next one is …”)

This resulted in:

  1. Frustration when forced to deal with him – closest target or the only target.
  2. Preference on attacking targets other than him, if possible.
  3. Preference to attack with save-based effects on him. Usually I saved limited resources of save-based effects and exclusively used them on the tank.

I tried to become as objective as possible, and this resulted in me trying to do the reverse: forcing my monsters to be inefficient by attacking him over easier-to-hit target beside him, reluctant to use save-based effects on him, etc.

I tried to be fair, but it seems I become meta-metagaming and I don’t like that.

How to deal with this tank fairly? I’ve tried not to think about the 19 AC, but it is inevitable that I need that info to properly play the game (and the AC won’t likely to change for a long time).

Dealing with interrupt and sleep

I was thinking that I could calmly Thread.sleep() on an interrupted thread. Sonar doesn’t think so, of course.

In some circumstates we should waiting for conditions, even if an interrupt occured. Is there anything wrong, for example, with the code below? Is there any better solution?

private void waitFinish() {     boolean wasInterrupted = false;     while (asyncProgressCounter.get() > 0) {         try {             Thread.sleep(100);         } catch (InterruptedException e) { // NOSONAR             wasInterrupted = true;         }     }     if (wasInterrupted) {         Thread.currentThread().interrupt();     }     onFinish(); }