## world of darkness – How does the Prime Sphere affect gaining and storing Quintessence in M20?

Previous answers did not satisfy me so I tried to look into the matter more thoroughly, asking a few friends who are in the know and trying to cite sources that clarify things as much as possible. Of particular help was Antonios “Rave-n” Galatis, co-developer in the making of M20, who helped me put all this together as clear and well-defined as possible.

## For starters let’s clarify a few things:

As a Mage you can Meditate near a Node to

(M20 -Meditation p.281)

(Quintessence Rating being equal to your Avatar Background)

The process of of drawing Quint. from a source (Node/Tass/etc) is also called “Channeling” (M20 – How Do You DO That, ‘Channeling Quintessence’ p.43) and, evidently, does not decrease/drain the actual Node’s reserve.
This particular method via Meditation is simply your own Avatar refreshing its full potency, its natural energy reserves (M20 – Quintessence p.332). Furthermore, both in the latter and in (M20 – How Do You DO That, ‘The Basics’ p.42) it is made clear that you can Channel more Quintessence into your Pattern than that Rating through a Prime 1 Effect. Essentially, we come to the result that
– (Mages have a “default” amount of Quintessence in their pattern which depends on the potency of their Avatar (as per the relevant trait)

It should also be mentioned that “Channeling” actually has a somewhat broader meaning which, usually, meaning with “moving” Quintessence from a source to a recipient, as the previous sources mention.

So, to answer the actual items the question consists of:

• Prime1 states that without it “a mage can’t absorb Quint. beyond their Avatar Rating. Does that mean the previous limit is no longer relevant or something else?

Yes. A Prime 1 Effect indeed allows you to gain (and store) more Quintessence than your Quintessence/Avatar Rating from a Node. However, that Rating “limit” still remains relevant because it’s the natural “energy baseline” you replenish your reserves to when Meditating at a Node, as described above. Furthermore the Avatar/Quintessence Rating defines *Note: In spite of the general “Rank 1 = Perception” paradigm of Sphere Effects, this seems rather certain due to having 2 sources, mentioned above.*

• Prime1 also states you can “perceive and channel Quintessence from Nodes/Tass/Wonders”. Can’t you already get Quint. from Nodes via Meditating (the Skill) on them? Does this represent another way to do the same, possibly in less time or does “channelling” imply manipulation of Quintessence without absorbing it into your Pattern?

See previous element. Moreover, the “Tass/Wonders” part of the text seems to imply the overall possibilities in studying the Prime Sphere so it’s a bit confusing. Which brings us to…

• Prime3, the one which causes the most confusion, states that with it you can “draw both free and raw quint from Nodes/Tass/Junctures etc”. This directly correlates with the previous point as they appear, at least, to have some common ground, which seems irregular given their different level. What does each one do?

We can conclude that Prime 3 is the required rank to Channel from Tass/Wonders/Junctures and, probably every non-Node source, into Effects or Patterns(including your own). This deduction comes from the both the very description of the Rank and a relevant table in Common Magickal Effects (M20 – ‘Quintessence Quintessence Energy’ p.510), where ‘Absorb’ probably means to Channel into yourself.

Also, something that should be mentioned is that if a Mage simply wishes to use the Quintessence reserves in a Tass, they don’t need to roll for an Effect if the Tass is on their person, and even if it is at a distance a Prime 2 roll suffices. That part is verified by (M20 – How Do You DO That, ‘Accessing Tass or Periapt Quintessence’ p.45)

## world of darkness – Usage of Prime Sphere M20

We started an M20 campaign and I created a character that focuses on Prime and Life Spheres. Life is a very useful sphere and can have many good effects on its own. Prime on the other hand seems a little tricky to me.

The character concept is of a hunter that hunts down and kills Technocracy affiliated people. He is an expert in Melee, Firearms and Do. He has a Wonder background of twin Revolvers that produce infinite bullets via Matter magic (they need to be fed 1 point of Quintessence every 4 clips).

The only usages I have of my Prime sphere at the moment are:

• Feeding the revolvers
• Enchanting the bullets with quintessence for aggravated dmg
• Creating a lightsaber out of raw quintessence for use with my Weapon Art Do special skill
• Enchanting my fists with Quintessence to deal better damage via Do/Martial Arts techniques

But this seems to lackluster and there are no combinations with Life magic. Are there any other usages that I’m not seeing? I really like the idea of a character that plays with magic in its purest form but I can’t seem to find ways to make it awesome…

• Prime 3/Life 3
• Melee/Firearms 3 and Do 2
• Node BG 5
• Avatar BG 4
• Buffed up physical stats using Life 3
• Cyclic Mage merit (we try to adventure while we are in our zenith)

I have access to a Sanctum, Resources 5 and a Mansion which is built over our Node (also contains the Sanctum). My team has Time3/Corre3, Mind2/Prime1/Life3, Mind3/Forces3.

PS: Yes Revolvers do indeed have clips in MTA

## dnd 5e – How does Freezing Sphere delayed explosion interact with simple coverings?

There are spells, which can create a bead like object which will explode after
a time. Otiluke’s Freezing Sphere is the one I am particularly interested in (incidentally for the same bard my earlier question about Destructive Wave was for), as it is rather safer to handle than Delayed Blast Fireball

Relevant snippets from spell description:

A frigid globe of cold energy streaks from your fingertips to a point of your choice within range, where it explodes in a 60-foot-radius sphere.

(…)

You can refrain from firing the globe after completing the spell, if you wish. A small globe about the size of a sling stone, cool to the touch, appears in your hand. (…) You can also set the globe down without shattering it. After 1 minute, if the globe hasn’t already shattered, it explodes.

How much cover can block the spell effect?

Example cases to make answering easier:

• The spell globe is suddenly placed on the table in front of you by a Mage Hand. It may explode at any time. Clever as you are, you cover it with your brass beer mug and wait 1 minute. Did you just foil a level 6 spell? What if you covered it with your cloak? Or a napkin?

• You, the mighty culinary wizard, cast the spell, put the globe into a jar filled with cream and berries, close it with a lid, and give it to a servant to hurriedly take it to the king’s feast. Did you just initiate an assassination, or send out an exquisite ice-cream dessert?

## at.algebraic topology – Outer automorphism group of Brieskorn homology sphere?

In this post, it is discussed how a Brieskorn homology sphere $$Sigma(a_1,a_2,a_3)$$ with $$displaystyle frac{1}{a_1}+ frac{1}{a_2}+ frac{1}{a_3} < 1$$ is an aspherical manifold with superperfect fundamental group and non-trivial center. Would anyone know what the outer automorphism groups of their fundamental groups are? I’m looking to do semidirect products with these groups as the kernel group with another group ($$mathbb{Z} times mathbb{Z}$$) as the quotient group, so I need to know the outer automorphism grousp of these groups.

## world of darkness – Detecting Magick use by using the Prime Sphere

I have a Mage: the Ascension 20th Anniversary Edition game running and one of the players played a game of Mage the Ascension Second Edition before that with a different Storyteller.

In that chronicle they used the prime sphere as a universal detection spell for the use of magick (however that player is unsure if that was just a houserule).

The rulebook of M20 states inside the description of what you can do with the first dot of the Prime Sphere on page 520 (highlights added by the asker):

She may spot energetic ebbs and flows, can sense and at least try to
, and could also absorb
Quintessence into her personal Pattern.

One wiki states for a 1 dot rote of the prime sphere:

Etheric Senses: The mage can perceive Quintessential energy, and is
alerted when someone uses magic in their vicinity. source

They state Mage: The Ascension Revised Edition Pg. 179-180 as the source for this rote together with page 520 in the M20 core rulebook.

Is that a correct application of rules as written in Mage the Ascension Second Edition and would the rules of Mage: the Ascension 20th Anniversary Edition allow for a similar reading?

## equation solving – Mathematica crashing on Solve (finding points on 4 circles on a sphere). How to reformulate?

I define a small circle on a unit sphere by the direction of the plane’s normal and its distance to the sphere center (i.e. origin) like this (parametrized by the angle t):

``````sphereCircleRadiusFromOfs(ofs_) := Sqrt(1 - ofs^2);
pointOnSphereCircle(dir_, ofs_) := dir*ofs + Normalize@Cross(Cross({0, 1, 0}, dir), dir) * sphereCircleRadiusFromOfs(ofs);
sphereCircle(dir_, ofs_, t_) := dir + RotationMatrix(t, dir).(pointOnSphereCircle(dir, ofs) - dir);
``````

Now, given 4 such circles with plane normals towards the 4 vertices of a regular tetrahedron and a distance of 1/Sqrt(2), I want to find solutions for the 4 angles such that the sums of the 4 points on the 4 circle are {0,0,0}.

I attempt to this by:

``````ofs = 1/Sqrt(2);
sol = Solve(
sphereCircle(Normalize@{+1, +1, +1}, ofs, tPPP) +
sphereCircle(Normalize@{+1, -1, -1}, ofs, tPNN) +
sphereCircle(Normalize@{-1, +1, -1}, ofs, tNPN) +
sphereCircle(Normalize@{-1, -1, +1}, ofs, tNNP) == {0, 0, 0}, {tPPP, tPNN, tNPN, tNNP})
``````

Unfortunately, Mathematica keeps computing forever, consuming more and more memory and will eventually crash. Is there a way to reformulate the problem such that Mathematica is more successful in solving it ?

I am trying to make a moon object. I have a (mostly) spherical object model that I want to place the moon texture on top of. The moon texture is an equirectangular projection as seen below.

However, the moon drawn is rendered like this:

As you can see, not all of the north pole is rendering. Roughly 3/4 of the moon seems to have rendered, but it doesnt seem to have any of the red transition color in the north pole.

The moon model was made in Blender by simply creating a UV Sphere and then exporting it with triangulation enabled. No changes were made. The moon obj file can be found here in text version. Maybe the normals aren’t correct? I tried using an ico sphere as well, but the results with that were even worse. Any advice for why it isn’t rendering correctly?

Here is the sphere mesh if that helps:

## geometry – Create N points that are spaced as far as possible within a D dimensional sphere

I’m not a big geometry buff, but I was wondering if you’re give a dimension $$D$$ and a number of points $$N$$ and a radius $$R$$ of a sphere in that dimension. How would you generate $$N$$ points on the edge or in the sphere such that their magnitude and cosine similarity between each point is as far as possible? The dimensional space could be something as large as 512.

## simulations – Sphere – AABOX Edge detection

I am trying to implement a particle-AABOX edge collision, the below images represent, two timesteps(dt) where the spherical particle is accelerated by gravity.

I have the particle center C and its radius r, along with AABOX coordinates as B_min and Bmax.

I have to check if the particle collides with any edges, and then bounce back, if a collision happens.

If I use Arvo’s AABB vs Sphere collision algorithm, then I can find if there is an intersection within the radius, but I can’t get the hitpoint and hitdistance.

And after getting the hitpoint and hitdistance, how to reflect it back? (for every timestep, I will have the current position C, and also the previous position P).

I tried to calculate it by implementing,

``````BOX_N(0) = make_vector(-1, 0, 0);// x-min;
BOX_P(0) = make_point(bb_min.x, bb_min.y + (bb_max.y - bb_min.y) / 2.0f , bb_min.z + (bb_max.z - bb_min.z) / 2.0f);

BOX_N(1) = make_vector(1, 0, 0); // x-max
BOX_P(1) = make_point(bb_max.x, bb_min.y + (bb_max.y - bb_min.y) / 2.0f , bb_min.z + (bb_max.z - bb_min.z) / 2.0f);

BOX_N(2) = make_vector(0, -1, 0);// y-min;
BOX_P(2) = make_point(bb_min.x + (bb_max.x - bb_min.x) / 2.0f, bb_min.y, bb_min.z + (bb_max.z - bb_min.z) / 2.0f);

BOX_N(3) = make_vector(0, 1, 0); // y-max
BOX_P(3) = make_point(bb_min.x + (bb_max.x - bb_min.x) / 2.0f, bb_max.y, bb_min.z + (bb_max.z - bb_min.z) / 2.0f);

BOX_N(4) = make_vector(0, 0, -1);// z-min;
BOX_P(4) = make_point(bb_min.x + (bb_max.x - bb_min.x) / 2.0f, bb_min.y + (bb_max.y - bb_min.y) / 2.0f , bb_min.z);

BOX_N(5) = make_vector(0, 0, 1); // z-max
BOX_P(5) = make_point(bb_min.x + (bb_max.x - bb_min.x) / 2.0f, bb_min.y + (bb_max.y - bb_min.y) / 2.0f , bb_max.z);

__device__ int box_collision(const Point& previous_position, const Point& current_position, const Vector& direction, const float& radius, Point& hitPoint, Vector& normal, float& hit_distance) {
Point boxPoint;
int index;

if (current_position.x < (bb_min.x + radius)) { index = 1; normal = BOX_N(0); boxPoint = BOX_P(0); boxPoint.x += radius;}
else if (current_position.x > (bb_max.x - radius)) { index = 1; normal = BOX_N(1); boxPoint = BOX_P(1); boxPoint.x -= radius;}

else if (current_position.y < (bb_min.y + radius)) { index = 2; normal = BOX_N(2); boxPoint = BOX_P(2); boxPoint.y += radius;}
else if (current_position.y > (bb_max.y - radius)) { index = 2; normal = BOX_N(3); boxPoint = BOX_P(3); boxPoint.y -= radius;}

else if (current_position.z < (bb_min.z + radius)) { index = 3; normal = BOX_N(4); boxPoint = BOX_P(4); boxPoint.z += radius;}
else if (current_position.z > (bb_max.z - radius)) { index = 3; normal = BOX_N(5); boxPoint = BOX_P(5); boxPoint.z -= radius;}
else return 0;

auto denom = vdot(direction, normal);
if (denom < 1e-6) return 0;

hit_distance = vdot(normal, boxPoint - previous_position) / denom;
if (hit_distance < 0) return 0;

hitPoint = previous_position + hit_distance * direction;

return index;
}

inline __device__ bool compute_box_collision(Point& previous_position, Point& current_position, const float& radius) {
Point hitPoint;
Vector normal;
float hit_distance;

Vector direction = vnormalize(current_position - previous_position);

int collision = box_collision(previous_position, current_position, direction, radius, hitPoint, normal, hit_distance);

if (!collision) return true;

Vector damping{1, 1, 1};
if (collision == 1) damping.x = bounce_factor;
else if (collision == 2) damping.y = bounce_factor;
else if (collision == 3) damping.z = bounce_factor;

float relection_length = vlength(hitPoint - current_position);

Vector R = vnormalize(direction - 2.0f * vdot(normal, direction) * normal) * damping;

current_position = hitPoint + R * relection_length;
previous_position = hitPoint - R * hit_distance;

return false;
}
``````

by calling the 2nd function to check for collision,

``````inline __device__ bool compute_box_collision(Point& previous_position, Point& current_position, const float& radius)
``````

In the above code, I used the ray-plane interesection, and then use reflection of the direction to get the bounce direction, but after 500-550 timesteps, the solution deviates and becomes numerically unstable(possibly they settle at the bottom and collides continously). Is there something, I am missing here? Or am I doing something wrong?

Note: I am using simiulating 10k particles, so the solution deviation compounds by a large amount.

## 3d – Triangle vs Sphere collision detection

I am working on collision detection for my 3D game, and I don’t really know how to approach this problem. I have an ellipsoid that i use for my player’s collision shape.

My idea is that I transform the vertex data in such a way that my ellipsoid can be represented as a sphere, which would make intersection testing easier. But the thing is, how would I know if there is a collision happening if the plane intersects with the sphere, but none of the vertices do?

I want a simple solution to this problem. No velocity vectors or predictions, just a static test to see if there is an intersection.