## Hi guys, I'd like to introduce myself. I am Kate Ryttenberg

Hi guys, I'd like to introduce myself. I'm Kate Ryttenberg. Working as a public relations manager. Here to learn and help. We look forward to collaborating with you.

## What kinds and approaches are aided and / or hindered by this set of house rules?

For an upcoming DnD 5e campaign, I am considering two house rules, which substantially affect each other. The implications are far-reaching and complex enough. I am having trouble deciding which classes, techniques, and play styles appear ahead or behind.

## Rule 1: Player Release Rule

• When a PC is attacked, they launch a defense and add an AC bonus against static
attack (calculated as attack bonus +10)
• When a PC casts a save spell
in an NPC, they roll and add the DC bonus (the static saving for npc is
calculated as save + 12)

## Rule 2: Combat deck play

• Use a 52-card deck (no jokers) instead of a D20 during combat rounds.
• When initiative is launched in combat, draw 10 cards.
• When a D20 is cast as part of an action (not a free action), you must play a card from your hand.
• Red number cards are listed values
• Black number cards have a listed value plus 10
• Aces are 1 (1 if it is red, 11 if it is black)
• The reais are the top of your discard minus a value. K = D-1, Q = D-2, J = D-3
• If the top card of the discard is real or the discard is empty, the real is = 2
• When the last card in your hand is played, draw up to ten
• When the last card is drawn from your deck, shuffle the discard.
• The advantage is "playing 1 card from your hand, and the top card in the deck takes the highest result"
• The downside is "playing 1 card from your hand, and the top card in the deck takes the lowest result"
• You can complete a full round to discard your entire hand and draw up to ten.

## Notes

The title of this campaign, as it was released to players, is "An extremely heavy and experimental campaign of house rule" so that at least they know what awaits them. ^ _ ^

Rule adjustments and alternatives sound fun for the conversation, but they are not entirely answers.

The motivation here is to turn a random output into a random input, inspired by this video: https://www.youtube.com/watch?v=dwI5b-wRLic

This is intended to cover the "discover the ac / hp / attack value of enemies" aspect of some combat.

## What version of macOS did you introduce / System / Applications?

Today I discovered by chance that there are now several applications stored in `/System/Applications/`. I noticed this when I was trying to find the package ID of a built-in app, and even though it appeared in the Applications folder, it was completely missing. `/Applications`! I suspect this change might have come when I recently upgraded to macOS Catalina, but maybe it was even before that.

What version of macOS did the `/System/Applications` directory? And where is this documented?

## Ordinary differential equations: how to introduce variations in the competitive Lotka-Volterra model?

First, we have these two Lotka-Volterra equations for prey and predators, respectively:

$$frac {dx} {dt} = r_ {x} x (1- alpha y)$$
$$frac {dy} {dt} = r_ {y} y ( beta x -1)$$
$$r_ {x}, r_ {y}, alpha, beta gt 0$$

These equations mean the predator-prey model without interaction between species of the same condition. If there were competition between prey and predators, the equations would be:

$$frac {dx} {dt} = r_ {x} x (1-x- alpha y)$$
$$frac {dy} {dt} = r_ {y} y ( beta x + gamma y-1)$$
$$r_ {x}, r_ {y}, alpha, beta gt 0, gamma in R$$

My question is: what should I do to change these equations if I wanted to introduce more conditions in addition to competition between species such as, for example, the life expectancy of both species, parasitism, diseases, lack of food according to the season? etc.?

Thanks for the help!

## Object-oriented: when is it appropriate to introduce a new abstraction layer in a class hierarchy?

Suppose I am creating a game played on a 2D coordinate grid. The game has 3 types of enemies that move in different ways:

• `Drunkard`: moves using type 1.
• `Mummy`: moves using type 1 movement, except when it is close to the main character, in which you will use type 2 movement.
• `Ninja`: moves using type 3 movement.

These are the ideas that came to mind when organizing the class hierarchy:

### Proposal 1

A single base class from where each enemy derives from:

``````abstract class Enemy:
public show()   // Called each game tick
public update() // Called each game tick
abstract move() // Called in update

class Drunkard extends Enemy:
private move() // Type 1 movement

class Mummy extends Enemy:
private move() // Type 1 + type 2 movement

class Ninja extends Enemy:
private move() // Type 3 movement
``````

Problems:

• Viola DRY since the code is not shared between `Drunkard` Y `Mummy`.

### Proposal 2

Same as proposal 1 but Enemy does more:

``````abstract class Enemy:
public show()            // Called each game tick
public update()          // Called each game tick
private move()           // Tries alternateMove, if unsuccessful, perform type 1 movement
abstract alternateMove() // Returns a boolean

class Drunkard extends Enemy:
private alternateMove(): return False

class Mummy extends Enemy:
private alternateMove() // Type 2 movement if in range, otherwise return false

class Ninja extends Enemy:
private alternateMove() // Type 3 movement and return true
``````

Problems:

• `Ninja` It doesn't really just have one movement, so it doesn't really have an "alternative movement." So, `Enemy` It is a poor representation of all enemies.

### Proposal 3

Expanding proposal 2 with a `MovementPlanEnemy`.

``````abstract class Enemy:
public show()   // Called each game tick
public update() // Called each game tick
abstract move() // Called in update

class MovementPlanEnemy:
private move() // Type 1 movement
abstract alternateMove()

class Drunkard:
private alternateMove() // Return false

class Mummy:
private alternateMove() // Tries type 2 movement

class Ninja:
private move() // Type 3 movement
``````

Problems:

• Ugly and possibly oversized.

### Question

Proposition 1 is simple but has a lower level of abstraction. Proposition 3 is complex but has a higher level of abstraction.

I understand all about the "composition about inheritance" and how it can solve this whole disaster. However, I have to implement this for a school project that requires us to use inheritance. So, given this restriction, what would be the best way to organize this class hierarchy? Is this just an example of why inheritance is inherently bad?

I guess since my restriction is that I have to use inheritance, I'm really asking the broader question: In general, when is it appropriate to introduce a new abstraction layer at the expense of complicating the architecture of the program?

Edit: updated title.

## design patterns: the best way to introduce a restriction in the values ​​of a dictionary?

Let's say we have a `Person` class:

``````class Person:
def __init__(self):
self.moods = {
"happy": 5,
"angry": 5,
}

self.moods(mood) += valChange
``````

How could a restriction on the values ​​of `self.moods`?

I tried to implement it using descriptors, although I don't like it.

The following works but I don't think it's worth it because now I have to add `.__get__(instance=self, owner=None)` to `self.moods()` every time I need to access a mood, or `.__set__(instance=self, value=)` When you want to update one. This will quickly contaminate my code and make it illegible, so I am not a fan of this approach.

``````class OneDigitNumericValue():    # descriptor class
def __set_name__(self, owner, name):
self.name = name

def __init__(self, defaultVal=5):
self.value = defaultVal

def __get__(self, instance, owner) -> object:
return self.value

def __set__(self, instance, value) -> None:
if not (0 < value < 9) or int(value) != int:
raise AttributeError("The value is invalid")
self.value = value

class Person:
moods = {
"happy": OneDigitNumericValue(),
"angry": OneDigitNumericValue(),
}

oldVal = self.moods(mood).__get__(self, owner=None)
self.moods(mood).__set__(self, value=oldVal + valChange)
``````

So the question is: What would be a better way to implement restrictions on the values ​​of `self.moods`?

## Python 3.x: alternative way to introduce a restriction other than my descriptor approach?

Let's say we have a `Person` class:

``````class Person:
def __init__(self):
self.moods = {
"happy": 5,
"angry": 5,
}

self.moods(mood) += valChange
``````

How could a restriction on the values ​​of `self.moods`?

I tried to implement it using descriptors, although I don't like it.

The following works but I don't think it's worth it because now I have to add `.__get__(instance=self, owner=None)` to `self.moods()` every time I need to access a mood, or `.__set__(instance=self, value=)` When you want to update one. This will quickly contaminate my code and make it illegible, so I am not a fan of this approach.

``````class OneDigitNumericValue():    # descriptor class
def __set_name__(self, owner, name):
self.name = name

def __init__(self, defaultVal=5):
self.value = defaultVal

def __get__(self, instance, owner) -> object:
return self.value

def __set__(self, instance, value) -> None:
if not (0 < value < 9) or int(value) != int:
raise AttributeError("The value is invalid")
self.value = value

class Person:
moods = {
"happy": OneDigitNumericValue(),
"angry": OneDigitNumericValue(),
}

oldVal = self.moods(mood).__get__(self, owner=None)
self.moods(mood).__set__(self, value=oldVal + valChange)
``````

So the question is: What would be a better way to implement restrictions on the values ​​of `self.moods`?

## studio lighting: who was the first to introduce a beauty dish?

While it is not exactly a soft light reflector as in the beauty dish, the rebound lighting itself was first used in 1956 by Subrata Mitra, but in the cinema.

The technique itself was designed to overcome the exposure difficulties encountered during the filming of Aparajito, which is the second among the three films of Satyajit Ray's famous Apu Trilogy.

If this is considered, and from sanmai's research, we can reduce the window of this invention to the two decades between 1956 and 1975.

I'm not sure if this qualifies as an appropriate response, but I hope this helps!

## How can a GM introduce tactical play into seemingly safe activities? [on hold]

In particular, there are 4 PCs of level 8-9 that do not have any travel augmentation skills besides Fly (Warlock). They are starting to travel longer distances for reasons of history, which will take a few weeks on horseback. In the past, they bought or exchanged to teleport, but did not choose to follow that route in this case.

The road is certainly less dangerous than where they are heading, which makes any challenging 1 / day encounter unlikely (a wild Ultraloth appears!), But I would like to find a way to have a meaningful combat experience in sessions without Avoid for more than a month or more trips, as this is something that the group appreciates and enjoys.

The thoughts that came to mind were less "two muscular men block your path" and more social gatherings during trips and large-scale problems in population centers or points of interest. There are also several threats independent of location that would be relevant and enjoyable, but are linked to other stories.

I would like the travel time to feel meaningful, both selfishly (if they can go anywhere at any time there is preparation to do so) and by a small sense of respect for realism. I hope that a month of travel without downtime will result in at least one session of ~ 3 hours of time at the table, except for the detours chosen by the PC.