## animation – Panner Node (Planet Material Day/Night Map)

I made an Earth material that rotates and shows day and night by combining different maps and masks (Similar to these set ups https://youtu.be/FMU1FkHFHXk AND https://youtu.be/ugXWt6AmudY). However, I noticed this method using the panner node with the material only works on the World’s X or Y axis. Our game unfortunately is set up with a different axis which makes it look awkward and the engineer can’t change the game axis set up without a massive overhaul. Is there anyway to manipulate the panner node so the materials will rotate around the object but that animation can be rotated as needed or a workaround to make this day/night material work, or is there another way to show day and night (city lights) for planets?

## Dogerun – The Future Of The Planet Earth

Dogerun is a token on Binance Smart Chain boasting various impressive features. Designed with burning mechanism, the total circulation supply of Dogerun will be exponentially cut. Besides, by combining burning mechanism, innovative Auto- Liquidity function and NFT together, Dogerun liquidity is allowed to increase rapidly.

One of the most important features of Dogerun is that it practices a large-scale decentralization which is rare for other tokens. Mixing these three outstanding features together, users are able to get a power house token out of the hands of anyone, except the community.
Built On Binance Smart Chain

Dogerun (DGR), is a token built on Binance Smart Chain with various layers of features. One noticeable feature of Dogerun is that it practices a large-scale decentralization which is rare for other tokens. Mixing these three outstanding features together, users are able to get a power house token out of the hands of anyone, except the community. 50% incineration is complete. The remaining 50% provides liquidity for pancakeswap. 1% of them are team management.

Airdrop Campaign On-Going

Dogerun (DGR) is a community project. Hence, the community is put up with the responsibility of giving everyone equal chance. With over 100k in USD worth, it’s a great opportunity for all.

Where can you get the coin?

Dogerun (DGR) is listed on Pancakeswap https://exchange.pancakeswap.finance/#/swap…23b50102e100e05

Further Info: https://dogerun.space/

## Square Cube Law

When we increase the range os a spell by a simple value, we increase its area of effect by the square and the volume of effect by the cube. Or rather:

$$R$$ $$A=pi R^2$$ $$V=frac 4 3 pi R^3$$

Energy density is defined as energy per volume. So our power scale should follow the Volumetric scaling, not a linear one. From one step to the next, you increase the energy needed by the third potence.

## Self

A typical human body has about a weight of 100 kilos if we are rather broad. A human body also has a density of 1 ton per cubic meter, so a human is 1/10th of a cubic meter or $$1 times 10^{-1} text m^3$$. That’s, if condensed into a sphere, one of about 30 cm radius. $$frac V pi frac 3 4=R^3$$ $$R=0.287 text{ meters}$$

## Planet

Mother earth has a volume of $$1.08 times 10^{21} text m^3$$.

## Scaling the difference

We want to stretch between $$1 times 10^{-1} text m^3$$ and $$1.08 times 10^{21} text m^3$$ in 10 steps. That’s -1, 0 and 1 to 21, so 23 numerals for the exponent to scale the volume. Let’s try to get a nice progression, with a factor 1 in front.

1. $$10^{-1} text m^3$$ – That’s the volume of our human, so self
2. $$10^{0} text m^3 = 1 text m^3$$ – a 1x1x1 meter cube, or anything you can easily touch with one arm.
3. $$10^{1} text m^3 = 10 text m^3$$ – Anything within 1.3 meters, or about 2 steps
4. $$10^{3} text m^3$$ – Anything within 6.2 meters – about a small building or large room
5. $$10^{6} text m^3$$ – Anything within 62 meters – or almost a Manhattan city block (technically that’d be 80.5 meters)
6. $$10^{9} text m^3$$ – Anythign within 620 meters – about 8 blocks or a city quarter or village
7. $$10^{12} text m^3$$ – Anything within 6.2 kilometers – or if you’d stand in the center of Manhatten, almost the whole of the peninsula. So let’s round that to Town.
8. $$10^{15} text m^3$$ – Anything within 62 kilometers – or about the size of an average county or shire or halfway to space
9. $$10^{18} text m^3$$ – Anything within 620 kilometers – or whatever is within an about a single European country if you are centered in it.
10. $$10^{21} text m^3$$ – Anything within 6203 kilometers – or a sphere as big as earth centered around you. This sphere encompasses a whole continent. Yes, it means you affect less than half the planet, and only a small fraction of the distance to the moon, but this compromise keeps the scaling somewhat nicely.

The scaling here is clearly logarithmic, with two distinct areas: the “short” ranges (steps 1-3) and then the Magnitude steps from 4 to 10. This allows to differentiate better on the low end, and then proceeds into a smooth large scale, offering useful intermediate steps.

## Why this scale?!

So, why did I choose this scale, which focusses on the low end?

### First of all: game usability & realism

Most spells that a typical player character could or should use need to be in distances that are within sight or useable in what accounts for typical combat ranges. These paradigms are fit up to somewhere between steps 6 and 7, depending on the weapons involved – a typical military rifle is useful all within step 6, while modern artillery would go up to 7.

The typical engagement distances of armies over time are rather short, so a focus on the short end for spells is best to model typical spells and have a difference in ranges available that allows separating between short and medium range combat spells. Some examples:

• Spear infantry was limited at 15 feet or about 4.5 meters. That’s Range step 4.
• Archery in the middle ages was used at ranges of about below 300 meters, so inside the range step 6.
• modern infantry combat doesn’t go further than 500 meters usually, and in urban areas is often quoted to be below 50 meters even. Artillery, especially naval one, can stretch that.
• in fact, the typical engagement range in WW1 was 50 to 250 meters
• in WW2, the typical long engagement range for tanks was 500 to 800 meters while infantry fought well shorter at below 300 meters. The longest tank hit recorded was 2.5 kilometers… on a stationary target.
• the longest ever navel artillery hit was 24 kilometers, which makes that the absolute maximum distance we can assume any engagement will happen unless missiles or drones are involved. That is a third of range step 8.
• Drones are generally used on the same side of the planet to keep latency short by reflecting signals of one satellite only. This is pretty much Range step 10.
• Modern ICBMs have ranges that are double the range of our step 10 – 12000 to 16000 km. They can hit literally any target on the planet but spend hours in flight. We are in the same order of magnitude though, so that’s just a little adjustment of factor 2 or something if you really want to have spells that far

### Magic-propagation speed calculation

The scale also has the benefit of being roughly multiples of 60. So it can be used to quickly calculate speeds from the distances. Say our fireball with range step 5 takes 60 seconds to get to that far point, and for math sake, we round to the closest 10. 60 meters/60 seconds means it travels at 1 meter a second, or rather sluggishly and can be dodged. If the range was step 6, that’s 600 meters/60 seconds, so in the area of 10 meters a second – Olympic runner speeds! And if it takes step 6 but only takes 6 seconds, we are at 100 meters per second, that’s the speed of a longbow arrow or about half the speed of a slow bullet or a quarter of a heavy arquebus.

### Look over the plate: other systems

Let me pull out GURPS. GURPS is notorious for cramming everything in spreadsheets. Including this list for range increments from 3rd edition, and I bold roughly equivalent distances to our distances above:

• 1/10″ – 1/5″ – 1/3″ – 1/2″ – 2/3″ – 1″ – 1.5″ – 2″ – 3″ – 6″ – 12″ – 1.5′ – 2′ – 1yd – 1.5yd – 2yd – 3yd – 4.5yd 7yd 10yd 15yd 20yd 30yd 45yd 70yd 100yd 150yd 200yd 300yd 450yd – 700yd – 1000yd – 1500yd – 2000yd – 3000yd – 4500yd – 7000yd/4 mi (~6 km) – 10000yd – 10mi – 15mi – 20mi (~30 km) – 200mi – 2000mi – 20000mi – 200000mi

Those are horrible fine segments, and the modifier progression in that thing goes from -15 to +49 with 0 on the 2-foot step. But for the far distances (where GURPS goes with half my proposed distances but adds another increment in the end), the distances I propose show up, making them at least useable for a simulatoric standpoint.

The picture of putting the focus on the engagement ranges of combat however shows itself in various Fantasy RPGs:

In my decade-and-half of being the GM for various The Dark Eye groups, the longest engagement range ever wanted was 550 meters from the weapon used – a heavy trebuchet. Most TDE spells have a range well below 100 meters, even there are very few spells that have a range of as far as the eye can see or continent. I only know of one instance where such a spell was used in combat at distances further than about 100 meters – and it was aimed at a target the size of a house. Any spell that I witnessed to be used at a longer range was either a communication or clairvoyance spell. In this I am not counting any trans-planar spell: the distance to hell is one step through the invocation/banishment pentagram. As a result of the costs and targeting needed, most combat magic in this system is actually pretty close to mundane ranged weapons when it comes to their ranges, even though the efficiency/impact of the spells can be much higher.

Pathfinder 1e and D&D 3.5 have only very few spells that have ranges that are longer than half a kilometer (those exceptions are generally clairvoyance, communication, or translocation spells). Most combat spells are even limited to less than about 100 meters. Generally, magic can be (and is) treated as just another type of ranged weapon in Pathfinder, even if area-effect spells are common.

Shadowrun also fortifies this experience: Shadowrun imposes no range limit but the (optically redirectable) line of sight (and ability to see its target) of the caster. However, in the last 12 years of playing Shadowrun the longest spell directly cast by any caster I witnessed was about 250 meters using binoculars, and most spells were flung even below 50 meters. In fact, I remember only very few casts of spells further than 50 meters, unless a spirit sent on a mission was involved. As far as I witnessed, even as magic in this system is allowed to be super-long-range, generally it was used at ranges where close-combat weapons are used – and often as a replacement for such.

Mage the Ascension uses one of the magic disciplines as the limiter for distances in its rather freeform magic system, on a success scale: you need 1 to target something that you can see, 2 allows you to reach a very familiar place (like you home) no matter how distant, 3 a familiar place (your buddy’s home), 4 gets you to a place you have been once (like the capitol), 5 can get you somewhere you have only been described or seen on a photo and 6 gets you anywhere on earth you can imagine, even if you have no idea what is there. But yes, Mage is a really poor limiter in magic ranges, as it is very free in casting magic (and only clobbers you over the head with paradox for it).

## Technology for climate rescue of the planet

1. ### Lin En uix_expand uix_collapse New Member

Joined:
Apr 24, 2021
Messages:
1
0

Technology for climate rescue of the planet: I am looking for a partner for the commercialization of a fundamentally new type of green generation power plants – no cyclicity, no carbon footprint, no storage means – generation is activated or deactivated 24/7, with the possibility of a range of generated power depending on the consumption mode, with the possibility of installation directly at 1 a consumer (a private house, for example) or a group of consumers (street, micro-district, etc.) – based on three copyright inventions – an activator, a turbine, a generator – are fundamentally new characteristics and properties for generating green and autonomous electricity.

## canvas – Javascript speed of an animated object (planet orbiting sun)

So I am pretty new to JavaScript and I thought I might make an animation demonstrating a planet orbiting a sun in an elliptical orbit using Kepler’s laws.

I am struggling to get the speed right. So I want the speed of the planet to be slower further away from the sun, and faster closer to the sun.

Within this method I use Keplers laws to calculate the x and y coordinate. I have also calculated the (real) velocity at each point in its trajectory (this may need to be scaled appropriately as I hope to use real astronomical data).

this.position = function(theta) {
var R = Math.pow(((Math.pow(T,2))/((4*Math.pow(Math.PI, 2))/(G*M))),(1/3)) ;
var a = R/(1-e) ;
this.x = radius*Math.cos(theta)*10e-10 + canvas.width/2 ;

}

I’ve got full code on CodePen here: https://codepen.io/yasserqureshi/pen/VwPOEzL?editors=0011

Any help or comments will be appreciated. Thanks!

## What causes the multiple instances of the same object (star or planet) that appears on this photo?

On a photo I took, there seems to be multiple instances of the same object, is it a result of my low quality camera and lens, or something else?

ISO: 3200
3s

## How to have 3d multiple planet gravity in unity c#?

Im using unity and I want to make a game where you can walk around small planets and the further away you get, the weaker the gravity, so you can go to other planets. All the tutorials so far only work with one planet, how do I code this? Is there anything I can download that does it for me?

## planet mercenary – How do the Goaltenders in the Golem EX armor work?

Alright. I can see where this particular interaction is unclear.

As per pg. 136 in the Planet Mercenary rulebook, “An attack that inflicts any amount of hull damage destroys a suit of armor, including one offering one or more Hull Points of protection.”

Keeping in mind the details in the errata (Goaltenders absorb damage first), the RAW reading is:

Each goaltender absorbs 1 Hull damage, before being destroyed. Once all the goaltenders are gone, damage hits armor (destroying it outright if it’s hull damage) and then the player (hopefully destroying them outright for such a silly interaction.)

However, I don’t like that interaction terribly much.

As Goaltenders (pg 137) are added onto existing armor and serve as team protection, I could see the situation be ruled in one of two ways:

1.) Goaltenders (being autonomous floating shields, in effect), are not destroyed by Hull damage when the armor is, thereby providing reduction even after being hit by a weapon that deals hull point damage.

Note: I prefer this solution, because it effectively provides a player extra levels of protection against big guns (each Goaltender effectively absorbing damage post the initial hull damage.)

2.) Goaltenders serve as an extra layer of armor, with each Goaltender absorbing 1 Hull damage before being obliterated.

Note: I like this solution less, as it makes Goaltenders pretty good. It shouldn’t be too unbalancing, but it’s a wacky interaction with these little drones absorbing giant anti-vehicular attacks, while your armor remains intact.

So in summation, my preferred solution is this:

Hull damage destroys the armor, leaving the Goaltenders to function as written, with Goaltenders providing reduction against non-Hull damage as normal.

This doesn’t really relate to “How armor w/ hull Points functions against AVPL weapons”, though it might one day and if it does, I’ll try to come back to update and correct this (or write the rules in such a way that it’s moot.)

## python – I want to have a trail in the planet animation

I have been working on a 2 body problem which involves animation of a planet around a star. I want my planet to leave a little trail behind while moving something like this. My code plots everything perfectly except this one thing. I am not able to get the trail of the planet.

fig, ax = plt.subplots()

print(func(0.98, -np.pi, 0, 0, 0.001))
ax.set(xlim = (-1.2,1.5), ylim = (-1.5,1.5), xlabel = 'x axis', ylabel='y axis', title = 'Planet's orbit')

def polar_animator(i):
trail = 40
l1.set_data(x_graph(i-1:i), y_graph(i-1:i))
return l1,

l1, = ax.plot((),(), 'o-')
l2, = ax.plot((-0.8),(0),marker= 'o')

ani = animation.FuncAnimation(fig, polar_animator, frames= len(x_graph), interval=5, blit=True)
ani.save('planet.mp4', writer= 'ffmpeg')

The output I am getting is just a ball moving around the sun.

## projectile physics – How to calculate trajectory on a planet with drag factor

I’m curious what is the valid calculation of a projectile trajectory in case when:

• surface is not flat but spherical like a planet
• drag is enabled (for example 0.1)
• and we are in 3D

I’ve found calculations where either the drag or the spherical surface factor was missing. I assume in each simulation step I have to recalculate the direction of the gravity which is the direction between the current position of the projectile and center of the planet.

I’ve tried to reuse the SimulateArc method in one of these answers: https://stackoverflow.com/questions/61125224/2d-projectile-trajectory-predictionunity-2d

I changed Vector2 to Vector3 and added a gravity direction recalculation on the loop after the new position is calculated. But Drag factor is missing yet. Is it a good approach to solve this issue? If not how should I calculate the trajectory also with the Drag factor?

private void CalculateTrajectory()
{
float simulateForDuration = 5f;//simulate for 5 secs in the furture
float simulationStep = 0.1f;//Will add a point every 0.1 secs.

int steps = (int)(simulateForDuration/simulationStep);//50 in this example
Vector3 calculatedPosition;
Vector3 directionVector = unit.CannonDirection;
Vector3 launchPosition = unit.StartPosition;
float launchSpeed = unit.ShootPower;

for(int i = 0; i < steps; ++i)
{
calculatedPosition = launchPosition + ( directionVector * (launchSpeed * i * simulationStep));
//Calculate gravity
Vector3 gravity = (planet.transform.position - transform.position).normalized * gravityConst;
calculatedPosition += gravity * ( i * simulationStep) *  ( i * simulationStep);

Gizmos.DrawSphere(calculatedPosition, 0.5f);
}

}

EDIT 1:
I tried to code the formula provided by Sacha but it seems it is not perfect yet (only on flat surface and without drag for now, if it works then I will add the drag factor and a sphere surface):

private void CalculateTrajectory()
{
float simulateForDuration = 5f;
float simulationStep = 0.1f;

int steps = (int)(simulateForDuration / simulationStep);
float mass = 0.5f;
Vector3 previousPosition = transform.position;
Vector3 previousVelocity = transform.forward.normalized * 5;
Vector3 gravity = Physics.gravity;

for (int i = 0; i < steps; ++i)
{
Vector3 acceleration = (previousVelocity + gravity) / mass;
Vector3 newVelocity = previousVelocity + acceleration * simulationStep;
Vector3 newPosition = previousPosition + newVelocity * simulationStep;

Gizmos.DrawSphere(newPosition, 0.2f);

previousPosition = newPosition;
previousVelocity = newVelocity;
}

}

Here is my projectile creation code:

GameObject clone = GameObject.Instantiate(sphere);
clone.transform.position = transform.position;
clone.transform.forward = transform.forward;

Rigidbody rb = clone.GetComponent<Rigidbody>();
rb.velocity = clone.transform.forward.normalized * 5f;

What did I miss?

EDIT 2:
I tried another approach:

float simulateForDuration = 5f;
float simulationStep = 0.02f;

int steps = (int)(simulateForDuration / simulationStep);
Vector3 initialVelocity = transform.forward.normalized * 5f;

for (int i = 0; i < steps; ++i)
{
Vector3 pos = new Vector3(
transform.position.x + initialVelocity.x * (i * simulationStep),
transform.position.y + initialVelocity.y * (i * simulationStep) - 0.5f * -Physics.gravity.y * Mathf.Pow(i * simulationStep, 2),
transform.position.z + initialVelocity.z * (i * simulationStep));

Gizmos.DrawSphere(pos, 0.05f);
}

Result:

This seems fine when I have only gravity on axis Y. We can say that the first version is almost fine, but I cannot figure out what is missing.

EDIT Final:
Based on Sacha updated answer regarding P = m * g the calculation is fine. I also had to update the AddForce method on the projectile itself because I added 9.81 * normalizedDirectionToTheCenter for the projectile as gravity. Now it is 9.81 * projectileMass * normalizedDirectionToTheCenter .

Here is the full code:

private void CalculateTrajectory()
{
float simulateForDuration = 10f;
float simulationStep = 0.02f;

int steps = (int)(simulateForDuration / simulationStep);
float mass = r.mass; // Mass of the projectile.

Vector3 previousPosition = transform.position;
Vector3 previousVelocity = transform.forward.normalized * power;

for (int i = 1; i < steps; ++i)
{
Vector3 directionToCenter = (planet.position - previousPosition).normalized;
Vector3 gravity = directionToCenter * 9.81f;

// Separated vectors to understand better.
Vector3 force = gravity * mass;
Vector3 acceleration = force / mass;
Vector3 newVelocity = previousVelocity + acceleration * simulationStep;
Vector3 newPosition = previousPosition + newVelocity * simulationStep;

Gizmos.DrawSphere(newPosition, 0.05f);

previousPosition = newPosition;
previousVelocity = newVelocity;
}
}

Thanks Sacha!