#include "engine/declarations.h"

#include "declarations_app.h"
#include "elements.h"
#include "star.h"



int star_create(struct galaxy *ga, unsigned long b) {
	struct star *s;

	if((ga->sa[b] = malloc(sizeof(struct star))) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				sizeof(struct star));

		return(-1);
	}

	s = ga->sa[b];

	s->id = b;
	s->pd = ga->id;

	s->planets = 0;
	s->created = 0;
	s->fusion = 0.0;
	s->solarsize = 0.0;

	(void) star_create_comp(s);
	(void) star_create_spec(s);
	(void) star_create_draw(s);

	if(star_create_name(s) != 0) {
		return(-1);
	}

	if(star_create_nick(s) != 0) {
		return(-1);
	}

	s->pa = NULL;

	s->solar = NULL;
	s->solar_t = 0;

	return(0);
}

int star_create_neutron(struct galaxy *ga, unsigned long b) {
	struct star *s;

	if((ga->sa[b] = malloc(sizeof(struct star))) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				sizeof(struct star));

		return(-1);
	}

	s = ga->sa[b];

	s->id = b;
	s->pd = ga->id;

	s->planets = 0;
	s->created = 0;
	s->fusion = 0.0;
	s->solarsize = 0.0;

	(void) star_create_comp_neutron(s);
	(void) star_create_spec_neutron(s);
	(void) star_create_draw(s);

	if(star_create_name(s) != 0) {
		return(-1);
	}

	if(star_create_nick(s) != 0) {
		return(-1);
	}

	s->pa = NULL;

	s->solar = NULL;
	s->solar_t = 0;

	return(0);
}

int star_create_blackhole(struct galaxy *ga, unsigned long b) {
	struct star *s;

	if((ga->sa[b] = malloc(sizeof(struct star))) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				sizeof(struct star));

		return(-1);
	}

	s = ga->sa[b];

	s->id = b;
	s->pd = ga->id;

	s->planets = 0;
	s->created = 0;
	s->fusion = 0.0;
	s->solarsize = 0.0;

	(void) star_create_comp_blackhole(s);
	(void) star_create_spec_blackhole(s);
	(void) star_create_draw(s);

	if(star_create_name(s) != 0) {
		return(-1);
	}

	if(star_create_nick(s) != 0) {
		return(-1);
	}

	s->pa = NULL;

	s->solar = NULL;
	s->solar_t = 0;

	return(0);
}

static void star_create_comp(struct star *sa) {
	/* Largest percentage of total mass -order */
	struct star_cont sc[] = {
		{ STAR_COMP_HELIUM_MIN, STAR_COMP_HELIUM_MAX,
			&sa->sc.helium },
		{ STAR_COMP_OXYGEN_MIN, STAR_COMP_OXYGEN_MAX,
			&sa->sc.oxygen },
		{ STAR_COMP_CARBON_MIN, STAR_COMP_CARBON_MAX,
			&sa->sc.carbon },
		{ STAR_COMP_NITROGEN_MIN, STAR_COMP_NITROGEN_MAX,
			&sa->sc.nitrogen },
		{ STAR_COMP_SILICON_MIN, STAR_COMP_SILICON_MAX,
			&sa->sc.silicon },
		{ STAR_COMP_MAGNESIUM_MIN, STAR_COMP_MAGNESIUM_MAX,
			&sa->sc.magnesium },
		{ STAR_COMP_NEON_MIN, STAR_COMP_NEON_MAX,
			&sa->sc.neon },
		{ STAR_COMP_IRON_MIN, STAR_COMP_IRON_MAX,
			&sa->sc.iron },
		{ STAR_COMP_SULFUR_MIN, STAR_COMP_SULFUR_MAX,
			&sa->sc.sulfur },

		{ 0, 0, NULL }
	};

	sa->sc.hydrogen = 100.0 - star_create_comp_op(sc);
}

static void star_create_comp_neutron(struct star *sa) {
	/* Content of neutron star is solid iron here, as nobody knows for sure */
	sa->sc.carbon = 0.0;
	sa->sc.helium = 0.0;
	sa->sc.hydrogen = 0.0;
	sa->sc.iron = 100.0;
	sa->sc.magnesium = 0.0;
	sa->sc.neon = 0.0;
	sa->sc.nitrogen = 0.0;
	sa->sc.oxygen = 0.0;
	sa->sc.silicon = 0.0;
	sa->sc.sulfur = 0.0;
}

static void star_create_comp_blackhole(struct star *sa) {
	/* Content of black hole is not known, they say that it does not contain any kind of information */
	sa->sc.carbon = 0.0;
	sa->sc.helium = 0.0;
	sa->sc.hydrogen = 0.0;
	sa->sc.iron = 0.0;
	sa->sc.magnesium = 0.0;
	sa->sc.neon = 0.0;
	sa->sc.nitrogen = 0.0;
	sa->sc.oxygen = 0.0;
	sa->sc.silicon = 0.0;
	sa->sc.sulfur = 0.0;
}

static float star_create_comp_op(struct star_cont *s) {
	unsigned int i, t;

	float c, d;

	c = 0.0;

	for(i = 0; ; i++) {
		if(s[i].c == NULL) {
			break;
		}

		t = s[i].b - s[i].a;
		t = maths_rand(t) + s[i].a;

		d = (((float) t / 100000.0) / 100.0) * (100.0 - c);

		*s[i].c = d;

		c += d;
	}

	return(c);
}

static void star_create_spec(struct star *sa) {
	sa->ss.bm = (double) maths_rand(140 - -5);				/* Star mean Bt magnitude (-0.5 - 14.0) */
	sa->ss.bm = (sa->ss.bm + -5.0) / 100.0;

	sa->ss.vm = (double) maths_rand(140 - -5);				/* Star mean Vt magnitude (-0.5 - 14.0) */
	sa->ss.vm = (sa->ss.vm + -5.0) / 100.0;

	sa->ss.jm = (double) maths_rand(140 - -14);				/* Star magnitude in Johnson V (-1.44 - 14.0) */
	sa->ss.jm = (sa->ss.jm + -14.0) / 100.0;

	sa->ss.bv = (double) maths_rand(2400 - -315);				/* Star BtVt index (-0.315 - 2.4) (sa->ss.bm - sa->ss.vm) */
	sa->ss.bv = maths_btvt_to_bv((sa->ss.bv + -315.0) / 1000.0);

	sa->ss.parallax = (double) maths_rand(7720 - 1);			/* Star trigonometric parallax (0.1 - 772.0) */
	sa->ss.parallax = (sa->ss.parallax + 10.0) / 100.0;

	sa->ss.magnitude = maths_amag_by_vmag_distance(sa->ss.jm, maths_parsec_by_parallax(sa->ss.parallax));
	sa->ss.temperature = maths_bv_to_temperature(sa->ss.bv);
	sa->ss.radius = maths_radius_by_amag_temperature(sa->ss.magnitude, sa->ss.temperature) / 1000.0;
	sa->ss.luminance = maths_luminance_by_radius_temperature(sa->ss.radius, sa->ss.temperature) * 1000000.0;

	sa->ss.mass = (double) (sa->ss.radius / STAR_SUN_RADIUS_KM) * STAR_SUN_MASS_KG;
	sa->ss.area = (double) (sa->ss.radius * sa->ss.radius) * CONST_PI_4;
	sa->ss.volume = (double) (sa->ss.radius * sa->ss.radius * sa->ss.radius) * CONST_VOLUME_SP;

	(void) star_create_spec_spectral(sa, sa->ss.bv);
	(void) star_create_spec_type(sa, sa->ss.magnitude, sa->ss.temperature);
	(void) star_create_spec_flat(sa);

	/* Energy is calculated what core produces (10%), hence 0.1 */
	sa->ss.energy = (double) 0.007 * 0.1 * sa->ss.mass * (STAR_SOL * STAR_SOL);

	sa->ss.lifetime = sa->ss.energy / sa->ss.luminance;
	sa->ss.lifetime *= 1.0 / CONST_SECS_YEAR;				/* Convert seconds to years */
	sa->ss.lifetime /= 1000000.0;						/* Convert years to millions */

	sa->ss.centripetal = (sa->ss.rotation * sa->ss.rotation) / (sa->ss.radius * 1000.0);

	sa->ss.acceleration = (sa->ss.mass * CONST_GRAVITY) / ((sa->ss.radius * 1000.0) * (sa->ss.radius * 1000.0));
	sa->ss.acceleration -= sa->ss.centripetal;

	sa->ss.velocity = sqrtf((float) (CONST_GRAVITY_2 * (sa->ss.mass / 1000.0)) / sa->ss.radius);
	sa->ss.velocity /= 1000.0;						/* Convert to meters */

	(void) maths_bv_to_rgba(&sa->ss.rgb, sa->ss.bv, sa->ss.vm);
}

static void star_create_spec_spectral(struct star *sa, double b) {
	unsigned int i;

	double d;

	char *r;

	d = 9999.0;
	r = "  ";

	for(i = 0; ; i++) {
		if(star_spectral[i].s == NULL) {
			break;
		}

		if(fabs(b - star_spectral[i].c) < d) {
			d = fabs(b - star_spectral[i].c);
			r = star_spectral[i].s;
		}
	}

	(void) memcpy((void *) sa->spectral, (const void *) r, sizeof(sa->spectral));
}

static void star_create_spec_type(struct star *sa, double a, double k) {
	/* Generate star class */
	if(k > 33000.0) {
		sa->class = STAR_CLASS_O;
	}
	else if(k > 10000.0) {
		sa->class = STAR_CLASS_B;
	}
	else if(k > 7500.0) {
		sa->class = STAR_CLASS_A;
	}
	else if(k > 6000.0) {
		sa->class = STAR_CLASS_F;
	}
	else if(k > 5200.0) {
		sa->class = STAR_CLASS_G;
	}
	else if(k > 3700.0) {
		sa->class = STAR_CLASS_K;
	}
	else if(k > 2400.0) {
		sa->class = STAR_CLASS_M;
	}
	else if(k > 1300.0) {
		sa->class = STAR_CLASS_L;
	}
	else if(k > 500.0) {
		sa->class = STAR_CLASS_T;
	}
	else {
		sa->class = STAR_CLASS_Y;
	}

	/* Generate star type */
	if(a > 15.0) {
		sa->type = STAR_TYPE_DWARF_BROWN;
	}
	else if(a > 10.0) {
		sa->type = STAR_TYPE_DWARF_RED;
	}
	else if(a > 5.0) {
		sa->type = STAR_TYPE_DWARF_WHITE;
	}
	else if(a > 0.0) {
		sa->type = STAR_TYPE_GIANT_SUB;
	}
	else if(a > -5.0) {
		sa->type = STAR_TYPE_GIANT;
	}
	else if(a > -10.0) {
		sa->type = STAR_TYPE_GIANT_SUPER;
	}
	else {
		sa->type = STAR_TYPE_GIANT_HYPER;
	}
}

static void star_create_spec_flat(struct star *sa) {
	unsigned int a, b;

	double c, r;

	/* Rotation speed has 20% tolerance, hence / 5 */
	a = star_flat[sa->class] - (star_flat[sa->class] / 5);
	b = star_flat[sa->class] + (star_flat[sa->class] / 5);

	a *= 36000;
	b *= 36000;

	sa->ss.rotation = (double) (maths_rand(b - a) + a) / 1000.0;

	r = sa->ss.radius * 1000.0;						/* Convert radius to meters */
	c = sa->ss.rotation / r;						/* Star angular velocity */

	sa->ss.flattening = 1.25 * (((c * c) * (r * r * r)) / (CONST_GRAVITY * sa->ss.mass));

	sa->ss.radius_e = sa->ss.radius * (1.0 + 2.0 * sa->ss.flattening / 3.0);
	sa->ss.radius_p = sa->ss.radius * (1.0 - 2.0 * sa->ss.flattening / 3.0);
}

static void star_create_spec_neutron(struct star *sa) {
	double d;

	sa->ss.bm = 0.0;
	sa->ss.vm = 0.0;
	sa->ss.jm = 0.0;
	sa->ss.bv = 0.0;

	sa->ss.parallax = 0.0;

	/* Neutron star mass is from 1 to 5 times of the sun */
	d = (double) (maths_rand(4000000) + 1000000);
	d /= 1000000.0;

	sa->ss.mass = d * STAR_SUN_MASS_KG;

	/* Neutron star radius is from 10 to 30 kilometers */
	d = (double) (maths_rand(20000000) + 10000000);
	d /= 1000000.0;

	sa->ss.radius = d;

	sa->ss.area = (double) (sa->ss.radius * sa->ss.radius) * CONST_PI_4;
	sa->ss.volume = (double) (sa->ss.radius * sa->ss.radius * sa->ss.radius) * CONST_VOLUME_SP;

	sa->ss.magnitude = (double) (maths_rand(20000) + 20000);
	sa->ss.magnitude /= 1000.0;

	sa->ss.temperature = (double) maths_rand(1000000) + 100000.0;
	sa->ss.luminance = maths_luminance_by_radius_temperature(sa->ss.radius, sa->ss.temperature) * 1000000.0;

	(void) star_create_spec_neutron_type(sa);
	(void) star_create_spec_flat(sa);

	sa->ss.energy = (double) 0.007 * sa->ss.mass * (STAR_SOL * STAR_SOL);

	sa->ss.lifetime = sa->ss.energy / sa->ss.luminance;
	sa->ss.lifetime *= 1.0 / CONST_SECS_YEAR;				/* Convert seconds to years */
	sa->ss.lifetime /= 1000000.0;						/* Convert years to millions */

	sa->ss.centripetal = (sa->ss.rotation * sa->ss.rotation) / (sa->ss.radius * 1000.0);

	sa->ss.acceleration = (sa->ss.mass * CONST_GRAVITY) / ((sa->ss.radius * 1000.0) * (sa->ss.radius * 1000.0));
	sa->ss.acceleration -= sa->ss.centripetal;

	sa->ss.velocity = sqrtf((float) (CONST_GRAVITY_2 * (sa->ss.mass / 1000.0)) / sa->ss.radius);
	sa->ss.velocity /= 1000.0;						/* Convert to meters */

	sa->ss.rgb.pixel.r = 255;
	sa->ss.rgb.pixel.g = 255;
	sa->ss.rgb.pixel.b = 255;
	sa->ss.rgb.pixel.a = 255;
}

static void star_create_spec_neutron_type(struct star *sa) {
	unsigned int k;

	k = maths_rand(100);

	/* This neutron star is possibly pulsar or magnetar (25% chance out of 100 for each) */
	if(k < 25) {
		sa->class = STAR_CLASS_NEUTRON_PULSAR;
	}
	else if(k < 50) {
		sa->class = STAR_CLASS_NEUTRON_MAGNETAR;
	}
	else {
		sa->class = STAR_CLASS_NEUTRON_NEUTRON;
	}

	sa->type = STAR_TYPE_NEUTRON;
}

static void star_create_spec_blackhole(struct star *sa) {
	double d;

	sa->ss.bm = 0.0;
	sa->ss.vm = 0.0;
	sa->ss.jm = 0.0;
	sa->ss.bv = 0.0;

	sa->ss.parallax = 0.0;

	d = (double) (maths_rand(1000000) + 1);
	d /= (double) (maths_rand(10) + 1);

	sa->ss.mass = d * STAR_SUN_MASS_KG;

	sa->ss.radius = (double) ((2.0 * CONST_GRAVITY) * sa->ss.mass) / (STAR_SOL * STAR_SOL);
	sa->ss.radius /= 1000.0;						/* Convert to kilometers */

	sa->ss.radius_e = sa->ss.radius;
	sa->ss.radius_p = sa->ss.radius;

	sa->ss.area = (double) (sa->ss.radius * sa->ss.radius) * CONST_PI_4;
	sa->ss.volume = (double) (sa->ss.radius * sa->ss.radius * sa->ss.radius) * CONST_VOLUME_SP;

	sa->ss.acceleration = (float) 1.0 / sa->ss.mass;
	sa->ss.acceleration *= STAR_SOL * STAR_SOL * STAR_SOL * STAR_SOL;
	sa->ss.acceleration /= 4.0 * CONST_GRAVITY;

	sa->ss.velocity = sqrtf((float) (CONST_GRAVITY_2 * (sa->ss.mass / 1000.0)) / sa->ss.radius);
	sa->ss.velocity /= 1000.0;						/* Convert to meters */

	sa->ss.temperature = (double) 1.0 / sa->ss.mass;
	sa->ss.temperature *= CONST_HBAR * (STAR_SOL * STAR_SOL * STAR_SOL);
	sa->ss.temperature /= 8.0 * CONST_KBAR * CONST_PI * CONST_GRAVITY;

	sa->ss.luminance = (double) 1.0 / (sa->ss.mass * sa->ss.mass);
	sa->ss.luminance *= CONST_HBAR * (STAR_SOL * STAR_SOL * STAR_SOL * STAR_SOL * STAR_SOL * STAR_SOL);
	sa->ss.luminance /= 15360.0 * CONST_PI * (CONST_GRAVITY * CONST_GRAVITY);

	sa->ss.lifetime = (double) (sa->ss.mass * sa->ss.mass * sa->ss.mass);
	sa->ss.lifetime *= 5120 * CONST_PI * (CONST_GRAVITY * CONST_GRAVITY);
	sa->ss.lifetime /= CONST_HBAR * (STAR_SOL * STAR_SOL * STAR_SOL * STAR_SOL);

	sa->ss.magnitude = (double) 1e9;

	sa->ss.energy = (double) 0.007 * sa->ss.mass * (STAR_SOL * STAR_SOL);

	sa->ss.rotation = 0.0;
	sa->ss.flattening = 0.0;

	sa->ss.centripetal = 0.0;

	(void) star_create_spec_blackhole_type(sa, sa->ss.mass);

	sa->ss.rgb.pixel.r = STAR_DRAW_LIGHT_BLACKHOLE_RED;
	sa->ss.rgb.pixel.g = STAR_DRAW_LIGHT_BLACKHOLE_GREEN;
	sa->ss.rgb.pixel.b = STAR_DRAW_LIGHT_BLACKHOLE_BLUE;
	sa->ss.rgb.pixel.a = 255;
}

static void star_create_spec_blackhole_type(struct star *sa, double k) {
	double d;

	d = k / STAR_SUN_MASS_KG;

	if(d > 100000.0) {
		sa->class = STAR_CLASS_BLACKHOLE_SUPERMASSIVE;
	}
	else if(d > 5000.0) {
		sa->class = STAR_CLASS_BLACKHOLE_INTERMEDIATE;
	}
	else if(d > 20.0) {
		sa->class = STAR_CLASS_BLACKHOLE_STELLAR;
	}
	else {
		sa->class = STAR_CLASS_BLACKHOLE_MICRO;
	}

	sa->type = STAR_TYPE_BLACKHOLE;
}

static void star_create_draw(struct star *sa) {
	sa->sd.p_w = STAR_DRAW_PREVIEW_WIDTH;
	sa->sd.p_h = STAR_DRAW_PREVIEW_HEIGHT;

	sa->sd.c = maths_rand(STAR_DRAW_NOISE_SEED);

	sa->sd.ca = 0;

	sa->sd.p_t = 0;
	sa->sd.p_p = NULL;

	sa->sd.cc_p = NULL;
	sa->sd.cp_p = NULL;

	(void) memset((void *) &sa->sd.cp, 0, sizeof(sa->sd.cp));
	(void) memset((void *) &sa->sd.cp_f, 0, sizeof(sa->sd.cp_f));

	(void) memset((void *) &sa->sd.cc_s, 0, sizeof(sa->sd.cc_s));
	(void) memset((void *) &sa->sd.cp_s, 0, sizeof(sa->sd.cp_s));
}

static int star_create_name(struct star *sa) {
	char n[STAR_NAME_LEN_MAX];

	/* Generate star name (PARENT_ID-STAR_ID-CLASS-TYPE) */
	(void) snprintf(n, sizeof(n), "%s-%lu-%lu-%u-%u", star_name_p, sa->pd, sa->id, sa->class, sa->type);

	sa->name_t = strnlen(n, sizeof(n) - sizeof(char));

	if((sa->name = malloc((size_t) sa->name_t + (sizeof(char) * 4))) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				(size_t) sa->name_t + sizeof(char));

		return(-1);
	}

	(void) memcpy((void *) sa->name, (const void *) n, sa->name_t);

	sa->name[sa->name_t] = 0;
	sa->name[sa->name_t + 1] = 0;
	sa->name[sa->name_t + 2] = 0;
	sa->name[sa->name_t + 3] = 0;

	return(0);
}

static int star_create_nick(struct star *sa) {
	sa->nick = NULL;
	sa->nick_t = 0;

	return(0);
}

int star_create_solar(struct galaxy *ga, unsigned long b) {
	char *e, *f;

	char n[STAR_NAME_LEN_MAX];

	struct star *s;

	s = ga->sa[b];

	/* Generate solar system name (ID-PARENT_ID-STAR_ID-COUNTER) */
	e = star_solar_name_a[maths_rand(STAR_SOLAR_NAME_A)];
	f = star_solar_name_a[maths_rand(STAR_SOLAR_NAME_A)];

	(void) snprintf(n, sizeof(n), _("%s%s-%lu-%lu-%lu system"), e, f, s->pd, s->id, ga->solars++);

	n[0] = (char) toupper((int) n[0]);
	n[1] = (char) toupper((int) n[1]);

	s->solar_t = strnlen(n, sizeof(n) - sizeof(char));

	if((s->solar = malloc((size_t) s->solar_t + (sizeof(char) * 4))) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				(size_t) s->solar_t + sizeof(char));

		return(-1);
	}

	(void) memcpy((void *) s->solar, (const void *) n, s->solar_t);

	s->solar[s->solar_t] = 0;
	s->solar[s->solar_t + 1] = 0;
	s->solar[s->solar_t + 2] = 0;
	s->solar[s->solar_t + 3] = 0;

	return(0);
}

void star_create_spot(struct galaxy *ga, unsigned long b) {
	double i, d, e, g, u, v, x, y, z;

	struct star *s;

	s = ga->sa[b];

	/* Gaussian curve is from 0.0 to 0.4 */
	d = -5.0;
	e = -(d) / (double) ga->stars;

	d += e * (double) b;

	g = maths_gaussian_dens(d);

	/* Which galaxy arm we are on (z = 2 * pi = whole round) */
	z = (CONST_PI * 2.0) / (double) ga->gs.arms;
	z *= b % ga->gs.arms;

	i = ga->gs.steps * (double) b;

	/* Randomness increases a bit towards the galaxy arm tail */
	u = maths_gaussian_rand(g, ga->gs.sigma) * ga->gs.dispersion * (i + 1.0);
	v = maths_gaussian_rand(g, ga->gs.sigma) * ga->gs.dispersion * (i + 1.0);

	x = (sin(i + z) * i) * ga->gs.radius;
	y = (sin(i + z + (CONST_PI / 2.0))) * (i + (CONST_PI / 2.0)) * ga->gs.radius;

	switch(b % 4) {
		case 0:
			x -= u;
			y += v;

			break;
		case 1:
			x -= u;
			y -= v;

			break;
		case 2:
			x += u;
			y -= v;

			break;
		default:
			x += u;
			y += v;

			break;
	}

	s->sp.x = x * CONST_LY_KM;
	s->sp.y = y * CONST_LY_KM;
	s->sp.z = 0.0;

	/* Update galaxy dimensions */
	if(s->sp.x < ga->gd_a.x) {
		ga->gd_a.x = s->sp.x;
	}

	if(s->sp.y < ga->gd_a.y) {
		ga->gd_a.y = s->sp.y;
	}

	if(s->sp.z < ga->gd_a.z) {
		ga->gd_a.z = s->sp.z;
	}

	if(s->sp.x > ga->gd_b.x) {
		ga->gd_b.x = s->sp.x;
	}

	if(s->sp.y > ga->gd_b.y) {
		ga->gd_b.y = s->sp.y;
	}

	if(s->sp.z > ga->gd_b.z) {
		ga->gd_b.z = s->sp.z;
	}

	/* Initial velocity of star makes galaxy to swirl */
	d = 1.0 + (maths_rand(10) / 10.0);
	e = (double) (1.0 / (maths_rand(10) + 1));

	x = (s->sp.x * cos(d) - s->sp.y * sin(d)) / (CONST_LY_KM / 2.0 * e);
	y = (s->sp.x * sin(d) + s->sp.y * cos(d)) / (CONST_LY_KM / 2.0 * e);

	s->sv.x = x;
	s->sv.y = y;
	s->sv.z = 0.0;
}

void star_create_spot_blackhole(struct galaxy *ga, unsigned long b) {
	struct star *s;

	s = ga->sa[b];

	/* Black hole sits at the center of the galaxy */
	s->sp.x = 0.0;
	s->sp.y = 0.0;
	s->sp.z = 0.0;

	s->sv.x = 0.0;
	s->sv.y = 0.0;
	s->sv.z = 0.0;
}

void star_free(struct star *sa) {
	unsigned long i;

	if(sa != NULL) {
		(void) star_live_free(sa);
		(void) star_preview_free(sa);

		if(sa->name != NULL) {
			(void) free(sa->name);
		}

		if(sa->nick != NULL) {
			(void) free(sa->nick);
		}

		if(sa->solar != NULL) {
			(void) free(sa->solar);
		}

		for(i = 0; i < sa->created; i++) {
			(void) planet_free(sa->pa[i]);
		}

		(void) free(sa);
	}
}

void star_image(struct star *sa, char *d, int m) {
	char *s;

	char n[CONFIG_LINE_LENGTH];

	size_t t;

	t = CONFIG_PATH_LENGTH;

	if((s = malloc(t + sizeof(char))) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				t + sizeof(char));

		return;
	}

	if(sa->nick != NULL) {
		(void) snprintf(s, t,
			"%s%cstar_%s_%s.%s",
				d, CONFIG_PATH_DELIM, sa->name, sa->nick, (char *) image_get_suffix_by_type(m));
	}
	else {
		(void) snprintf(s, t,
			"%s%cstar_%s.%s",
				d, CONFIG_PATH_DELIM, sa->name, (char *) image_get_suffix_by_type(m));
	}

	if(star_preview_create(sa, sa->sd.p_w, sa->sd.p_h, 1.5) != 0) {
		(void) free(s);

		return;
	}

	(void) image_write_32(sa->sd.p_p, (size_t) sa->sd.p_w, (size_t) sa->sd.p_h, s, m);

	(void) snprintf(n, sizeof(n), "Star image saved to %s", s);

	(void) universe_set_message(n);

	(void) free(s);
}

void star_preview(struct star *sa, unsigned int h, int x, int y) {
	if(star_preview_create(sa, sa->sd.p_w, sa->sd.p_h, 1.5) != 0) {
		return;
	}

	sa->sd.cp.sx = 0;
	sa->sd.cp.sy = 0;
	sa->sd.cp.dx = x;
	sa->sd.cp.dy = y;
	sa->sd.cp.c.width = (unsigned int) sa->sd.p_w;
	sa->sd.cp.c.height = (unsigned int) sa->sd.p_h;
	sa->sd.cp.s.width = (unsigned int) sa->sd.p_w;
	sa->sd.cp.s.height = (unsigned int) sa->sd.p_h;
	sa->sd.cp.p = sa->sd.p_p;

	(void) gui_draw_copy_alpha(h, &sa->sd.cp);
}

static int star_preview_create(struct star *sa, int w, int h, double u) {
	double d;

	struct position g;
	struct pixel_rgb_8 s;
	struct pixel_rgba_8 a;

	if(sa->sd.p_p != NULL) {
		return(0);
	}

	if(star_preview_create_op(sa, w, h) != 0) {
		return(-1);
	}

	/* Calculate percentage difference of equatorial and polar radius */
	d = fabs(sa->ss.radius_e - sa->ss.radius_p);
	d /= fabs(sa->ss.radius_e + sa->ss.radius_p) / 2.0;
	d *= 100.0;

	if((sa->sd.ca = draw_sphere_matte_noise_2d_cache(w, h, u, 100.0, 100.0 - d, sa->sd.c, 0.15)) == 0) {
		(void) star_preview_free(sa);

		return(-1);
	}

	g.x = STAR_DRAW_LIGHT_X;
	g.y = STAR_DRAW_LIGHT_Y;
	g.z = STAR_DRAW_LIGHT_Z;

	a.pixel.p = sa->ss.rgb.pixel.p;

	switch(sa->type) {
		case STAR_TYPE_BLACKHOLE:
			s.r = STAR_DRAW_LIGHT_BLACKHOLE_RED;
			s.g = STAR_DRAW_LIGHT_BLACKHOLE_GREEN;
			s.b = STAR_DRAW_LIGHT_BLACKHOLE_BLUE;

			break;
		case STAR_TYPE_NEUTRON:
			s.r = STAR_DRAW_LIGHT_NEUTRON_RED;
			s.g = STAR_DRAW_LIGHT_NEUTRON_GREEN;
			s.b = STAR_DRAW_LIGHT_NEUTRON_BLUE;

			break;
		default:
			s.r = STAR_DRAW_LIGHT_DEFAULT_RED;
			s.g = STAR_DRAW_LIGHT_DEFAULT_GREEN;
			s.b = STAR_DRAW_LIGHT_DEFAULT_BLUE;

			break;
	}

	(void) draw_sphere_blur(sa->sd.p_p, &a, &s, &g, 0.5, 2.0, sa->sd.ca);

	return(0);
}

static int star_preview_create_op(struct star *sa, int w, int h) {
	sa->sd.p_t = (w * h) * sizeof(struct pixel_rgba_8);

	if((sa->sd.p_p = malloc(sa->sd.p_t)) == NULL) {
		LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
			_("Failed to allocate %zu bytes of memory"),
				(size_t) sa->sd.p_t);

		return(-1);
	}

	(void) memset((void *) sa->sd.p_p, 0, sa->sd.p_t);

	return(0);
}

void star_preview_free(struct star *sa) {
	if(sa->sd.p_p != NULL) {
		(void) free(sa->sd.p_p);

		sa->sd.p_t = 0;
		sa->sd.p_p = NULL;
	}

	if(sa->sd.ca != 0) {
		(void) draw_sphere_cache_delete(sa->sd.ca);

		sa->sd.ca = 0;
	}
}

void star_run(struct star *sa) {
	unsigned long i;

	double d;

	struct planet *p;

	/* Calculate position for orbiting planets */
	for(i = 0; i < sa->planets; i++) {
		p = sa->pa[i];
		d = CONST_PI_2 * p->distance;

		/* One iteration to position is one second as speed is orbital velocity in km/s */
		p->position += p->ps.speed * clock_get_multiplier();

		if(p->position > d) {
			p->position -= d;
		}

		p->angle = maths_map(p->position, 0.0, d, 0.0, 360.0);
	}

	/* Simulate nuclear fusion */
	(void) star_run_burn(sa);
}

static void star_run_burn(struct star *sa) {
	double d, e;

	char n[CONFIG_LINE_LENGTH];

	if(sa->type == STAR_TYPE_NEUTRON || sa->type == STAR_TYPE_BLACKHOLE) {
		return;
	}

	e = clock_get_ticks();

	/* Simulate nuclear fusion only once per stretching year */
	if(e - sa->fusion < CONST_SECS_YEAR) {
		return;
	}

	sa->fusion = e;

	/* Once the core is completely helium, star is gone for good */
	if(sa->sc.hydrogen > 0.0) {
		d = sa->sc.hydrogen / sa->ss.lifetime;

		sa->sc.hydrogen -= d;
		sa->sc.helium += d;
	}

	d = 0.000001;

	/* If nuclear fusion has ended, convert star to neutron star or black hole */
	if((sa->ss.lifetime -= d) < d) {
		sa->planets = 0;
		sa->solarsize = 0.0;

		(void) star_preview_free(sa);

		/* Mass is calculated what core weights (10%), hence 0.1 */
		if(sa->ss.mass * 0.1 < STAR_SUN_MASS_KG * 3.0) {
			(void) snprintf(n, sizeof(n),
				"%s %s collapsed to neutron star%c%c%c%c",
					star_type[sa->type], sa->name, 0, 0, 0, 0);

			(void) star_create_comp_neutron(sa);
			(void) star_create_spec_neutron(sa);
		}
		else {
			(void) snprintf(n, sizeof(n),
				"%s %s collapsed to black hole%c%c%c%c",
					star_type[sa->type], sa->name, 0, 0, 0, 0);

			(void) star_create_comp_blackhole(sa);
			(void) star_create_spec_blackhole(sa);
		}

		(void) universe_set_message(n);
	}
}

void star_live(unsigned long a, unsigned long b, double u, double v, double s, unsigned int h) {
	unsigned int x, y, w;
	unsigned long i;

	double e, z;

	struct star *sa;
	struct planet *p;

	struct position o;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return;
	}

	if(sa->planets == 0) {
		(void) star_live_title(sa, h);
		(void) star_preview(sa, h,
			(window_get_active_width(h) / 2) - (STAR_DRAW_PREVIEW_WIDTH / 2),
			(window_get_active_height(h) / 2) - (STAR_DRAW_PREVIEW_HEIGHT / 2));

		return;
	}

	if(star_live_op(sa) != 0) {
		return;
	}

	x = window_get_active_width(h);
	y = window_get_active_height(h);

	w = VALUE_MIN2(x, y) - 1;

	x /= 2;
	y /= 2;

	/* Set zoom factor */
	s = maths_clamp(s, 0.0, STAR_LIVE_ZOOM_STEPS - 0.1);
	z = sa->solarsize / STAR_LIVE_ZOOM_STEPS;

	for(i = 0; i < sa->planets; i++) {
		p = sa->pa[i];

		(void) coords_angle_distance_to_position(p->angle, p->distance, &o);

		/* Apply zooming */
		e = sa->solarsize - (z * s);

		sa->sd.cp_p[i].x = maths_map(o.x, 0.0, e, 0.0, (double) w) + x + u;
		sa->sd.cp_p[i].y = maths_map(o.y, 0.0, e, 0.0, (double) w) + y + v;
		sa->sd.cp_p[i].p.pixel.p = p->ps.rgb.pixel.p;

		sa->sd.cc_p[i].x = sa->sd.cp_p[i].x;
		sa->sd.cc_p[i].y = sa->sd.cp_p[i].y;
		sa->sd.cc_p[i].n = 4;
		sa->sd.cc_p[i].r = 10;
		sa->sd.cc_p[i].f = 0.0;
		sa->sd.cc_p[i].d = 360.0;
		sa->sd.cc_p[i].p.pixel.p = p->ps.rgb.pixel.p;
	}

	sa->sd.cc_s.c = (unsigned int) sa->planets;
	sa->sd.cc_s.p = sa->sd.cc_p;

	sa->sd.cp_s.c = (unsigned int) sa->planets;
	sa->sd.cp_s.p = sa->sd.cp_p;

	sa->sd.cl_p[0].x1 = x + u;
	sa->sd.cl_p[0].y1 = y + v - 10;
	sa->sd.cl_p[0].x2 = sa->sd.cl_p[0].x1;
	sa->sd.cl_p[0].y2 = sa->sd.cl_p[0].y1 + 20;
	sa->sd.cl_p[0].p.pixel.p = sa->ss.rgb.pixel.p;
	sa->sd.cl_p[1].x1 = x + u - 10;
	sa->sd.cl_p[1].y1 = y + v;
	sa->sd.cl_p[1].x2 = sa->sd.cl_p[1].x1 + 20;
	sa->sd.cl_p[1].y2 = sa->sd.cl_p[1].y1;
	sa->sd.cl_p[1].p.pixel.p = sa->sd.cl_p[0].p.pixel.p;

	(void) star_preview(sa, h, 0, window_get_active_height(h) - STAR_DRAW_PREVIEW_HEIGHT);

	(void) gui_draw_line(h, &sa->sd.cl_p[0]);
	(void) gui_draw_line(h, &sa->sd.cl_p[1]);

	(void) gui_draw_circles(h, &sa->sd.cc_s);
	(void) gui_draw_subpixels(h, &sa->sd.cp_s);

	(void) star_live_title(sa, h);
}

static int star_live_op(struct star *sa) {
	size_t t;

	if(sa->sd.cc_p == NULL) {
		t = sizeof(struct circle_2) * sa->planets;

		if((sa->sd.cc_p = malloc(t)) == NULL) {
			LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
				_("Failed to allocate %zu bytes of memory"),
					t);

			return(-1);
		}

		(void) memset((void *) sa->sd.cc_p, 0, t);
	}

	if(sa->sd.cp_p == NULL) {
		t = sizeof(struct subpoint_2) * sa->planets;

		if((sa->sd.cp_p = malloc(t)) == NULL) {
			LOGWARN(ERROR_SLIGHT, SUBSYSTEM,
				_("Failed to allocate %zu bytes of memory"),
					t);

			return(-1);
		}

		(void) memset((void *) sa->sd.cp_p, 0, t);
	}

	return(0);
}

static void star_live_title(struct star *sa, unsigned int h) {
	char n[CONFIG_LINE_LENGTH];

	struct pixel_rgb_8 p;

	if(sa->sd.cp_f[0] == 0) {
		if((sa->sd.cp_f[0] = fonts_open("share/detroit/fonts/NotoSans-Italic.ttf", 18, 0)) == 0) {
			return;
		}
	}

	(void) memset((void *) n, 0, sizeof(n));

	if(sa->type == STAR_TYPE_NEUTRON || sa->type == STAR_TYPE_BLACKHOLE) {
		(void) snprintf(n, sizeof(n),
			"%s %s, class %s%c%c%c%c",
				star_type[sa->type], sa->name, star_class[sa->class], 0, 0, 0, 0
		);
	}
	else {
		if(sa->spectral[0] != ' ') {
			(void) snprintf(n, sizeof(n),
				"%s %s, class %s, spectral class %c%c, %lu planets%c%c%c%c",
					star_type[sa->type], sa->name, star_class[sa->class],
					sa->spectral[0], sa->spectral[1], sa->planets, 0, 0, 0, 0);
		}
	}

	p.r = 255;
	p.g = 215;
	p.b = 105;

	(void) fonts_render(sa->sd.cp_f[0], "UTF-8", n, str_len(n, STRING_ASCII), &p, 0);

	sa->sd.cp_t[0].x = 10;
	sa->sd.cp_t[0].y = 10;

	sa->sd.cp_t[0].f = sa->sd.cp_f[0];

	(void) gui_draw_text(h, &sa->sd.cp_t[0]);
}

void star_live_free(struct star *sa) {
	unsigned long i;

	for(i = 0; i < sizeof(sa->sd.cp_f) / sizeof(sa->sd.cp_f[0]); i++) {
		(void) fonts_close(sa->sd.cp_f[i]);
	}

	if(sa->sd.cc_p != NULL) {
		(void) free(sa->sd.cc_p);

		sa->sd.cc_p = NULL;
	}

	if(sa->sd.cp_p != NULL) {
		(void) free(sa->sd.cp_p);

		sa->sd.cp_p = NULL;
	}
}

unsigned long star_live_closest(unsigned long a, unsigned long b, double u, double v) {
	unsigned long i, r;

	double e, f;

	struct star *sa;

	struct position p, q;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return(0);
	}

	r = 0;
	f = sa->solarsize * 2.0;

	q.x = u;
	q.y = v;

	for(i = 0; i < (unsigned long) sa->sd.cp_s.c; i++) {
		p.x = sa->sd.cp_p[i].x;
		p.y = sa->sd.cp_p[i].y;

		e = coords_difference_2d(&p, &q);

		if(e < f) {
			f = e;
			r = i + 1;
		}
	}

	return(r);
}

char *star_get_name(unsigned long a, unsigned long b) {
	struct star *sa;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return(NULL);
	}

	return(sa->name);
}

char *star_get_nick(unsigned long a, unsigned long b) {
	struct star *sa;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return(NULL);
	}

	return(sa->nick);
}

int star_get_ordinary(struct star *sa) {
	int r;

	switch(sa->type) {
		case STAR_TYPE_NEUTRON:
		case STAR_TYPE_BLACKHOLE:
			r = IS_NO;

			break;
		default:
			r = IS_YES;

			break;
	}

	return(r);
}

int star_print_catalog(struct star *sa) {
	int r;

	char n;

	r = catalog_entry_open();

	r += catalog_entry_item_save((void *) &sa->id, sizeof(sa->id));
	r += catalog_entry_item_save((void *) &sa->pd, sizeof(sa->pd));

	r += catalog_entry_item_save((void *) &sa->planets, sizeof(sa->planets));
	r += catalog_entry_item_save((void *) &sa->solarsize, sizeof(sa->solarsize));

	r += catalog_entry_item_save((void *) &sa->class, sizeof(sa->class));
	r += catalog_entry_item_save((void *) &sa->type, sizeof(sa->type));

	r += catalog_entry_item_save((void *) &sa->spectral, sizeof(sa->spectral));

	/* Star position and velocity */
	r += catalog_entry_item_save((void *) &sa->sp.x, sizeof(sa->sp.x));
	r += catalog_entry_item_save((void *) &sa->sp.y, sizeof(sa->sp.y));
	r += catalog_entry_item_save((void *) &sa->sp.z, sizeof(sa->sp.z));

	r += catalog_entry_item_save((void *) &sa->sv.x, sizeof(sa->sv.x));
	r += catalog_entry_item_save((void *) &sa->sv.y, sizeof(sa->sv.y));
	r += catalog_entry_item_save((void *) &sa->sv.z, sizeof(sa->sv.z));

	/* Star composition */
	r += catalog_entry_item_save((void *) &sa->sc.carbon, sizeof(sa->sc.carbon));
	r += catalog_entry_item_save((void *) &sa->sc.helium, sizeof(sa->sc.helium));
	r += catalog_entry_item_save((void *) &sa->sc.hydrogen, sizeof(sa->sc.hydrogen));
	r += catalog_entry_item_save((void *) &sa->sc.iron, sizeof(sa->sc.iron));
	r += catalog_entry_item_save((void *) &sa->sc.magnesium, sizeof(sa->sc.magnesium));
	r += catalog_entry_item_save((void *) &sa->sc.neon, sizeof(sa->sc.neon));
	r += catalog_entry_item_save((void *) &sa->sc.nitrogen, sizeof(sa->sc.nitrogen));
	r += catalog_entry_item_save((void *) &sa->sc.oxygen, sizeof(sa->sc.oxygen));
	r += catalog_entry_item_save((void *) &sa->sc.silicon, sizeof(sa->sc.silicon));
	r += catalog_entry_item_save((void *) &sa->sc.sulfur, sizeof(sa->sc.sulfur));

	/* Star specs */
	r += catalog_entry_item_save((void *) &sa->ss.bm, sizeof(sa->ss.bm));
	r += catalog_entry_item_save((void *) &sa->ss.vm, sizeof(sa->ss.vm));
	r += catalog_entry_item_save((void *) &sa->ss.jm, sizeof(sa->ss.jm));
	r += catalog_entry_item_save((void *) &sa->ss.bv, sizeof(sa->ss.bv));

	r += catalog_entry_item_save((void *) &sa->ss.parallax, sizeof(sa->ss.parallax));

	r += catalog_entry_item_save((void *) &sa->ss.radius, sizeof(sa->ss.radius));
	r += catalog_entry_item_save((void *) &sa->ss.radius_e, sizeof(sa->ss.radius_e));
	r += catalog_entry_item_save((void *) &sa->ss.radius_p, sizeof(sa->ss.radius_p));
	r += catalog_entry_item_save((void *) &sa->ss.magnitude, sizeof(sa->ss.magnitude));
	r += catalog_entry_item_save((void *) &sa->ss.temperature, sizeof(sa->ss.temperature));
	r += catalog_entry_item_save((void *) &sa->ss.luminance, sizeof(sa->ss.luminance));

	r += catalog_entry_item_save((void *) &sa->ss.mass, sizeof(sa->ss.mass));
	r += catalog_entry_item_save((void *) &sa->ss.area, sizeof(sa->ss.area));
	r += catalog_entry_item_save((void *) &sa->ss.volume, sizeof(sa->ss.volume));
	r += catalog_entry_item_save((void *) &sa->ss.energy, sizeof(sa->ss.energy));
	r += catalog_entry_item_save((void *) &sa->ss.lifetime, sizeof(sa->ss.lifetime));

	r += catalog_entry_item_save((void *) &sa->ss.rotation, sizeof(sa->ss.rotation));
	r += catalog_entry_item_save((void *) &sa->ss.flattening, sizeof(sa->ss.flattening));

	r += catalog_entry_item_save((void *) &sa->ss.centripetal, sizeof(sa->ss.centripetal));
	r += catalog_entry_item_save((void *) &sa->ss.acceleration, sizeof(sa->ss.acceleration));
	r += catalog_entry_item_save((void *) &sa->ss.velocity, sizeof(sa->ss.velocity));

	r += catalog_entry_item_save((void *) &sa->ss.rgb, sizeof(sa->ss.rgb));

	/* Star drawing variables */
	r += catalog_entry_item_save((void *) &sa->sd.p_w, sizeof(sa->sd.p_w));
	r += catalog_entry_item_save((void *) &sa->sd.p_h, sizeof(sa->sd.p_h));

	r += catalog_entry_item_save((void *) &sa->sd.c, sizeof(sa->sd.c));

	/* Star name */
	n = 0;

	if(sa->name != NULL) {
		r += catalog_entry_item_save((void *) sa->name, sa->name_t + sizeof(char));
	}
	else {
		r += catalog_entry_item_save((void *) &n, sizeof(n));
	}

	if(sa->nick != NULL) {
		r += catalog_entry_item_save((void *) sa->nick, sa->nick_t + sizeof(char));
	}
	else {
		r += catalog_entry_item_save((void *) &n, sizeof(n));
	}

	if(sa->solar != NULL) {
		r += catalog_entry_item_save((void *) sa->solar, sa->solar_t + sizeof(char));
	}
	else {
		r += catalog_entry_item_save((void *) &n, sizeof(n));
	}

	return(r);
}

void star_render(unsigned int h, unsigned long a, unsigned long b) {
	struct star *sa;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return;
	}

	(void) star_preview(sa, h, 0, 0);
}

void star_store(unsigned long a, unsigned long b, char *s) {
	struct star *sa;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return;
	}

	(void) star_image(sa, s, IMAGE_FORMAT_TGA);
}

void star_print(unsigned long a, unsigned long b) {
	struct star *sa;

	if((sa = universe_get_star_by_id(a, b)) == NULL) {
		return;
	}

	(void) star_print_human(sa);
}

void star_print_human(struct star *sa) {
	(void) fprintf(stdout, _("* %s %s, class %s"), star_type[sa->type], sa->name, star_class[sa->class]);

	if(sa->type != STAR_TYPE_NEUTRON && sa->type != STAR_TYPE_BLACKHOLE) {
		if(sa->spectral[0] != ' ') (void) fprintf(stdout, _(", spectral class %c%c"), sa->spectral[0], sa->spectral[1]);
	}

	if(sa->planets != 0) {
		(void) fprintf(stdout, _(", %s with %lu planets"), sa->solar, sa->planets);
	}

	(void) fprintf(stdout, "%c%c", CONFIG_LINE_FEED, CONFIG_LINE_FEED);

	(void) fprintf(stdout, _(" absolute magnitude......... %g%c"), sa->ss.magnitude, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" luminance.................. %g watts%c"), sa->ss.luminance, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" temperature................ %g kelvin%c"), sa->ss.temperature, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _("                             %g celsius%c"), maths_kelvin_to_celsius(sa->ss.temperature), CONFIG_LINE_FEED);
	(void) fprintf(stdout, _("                             %g fahrenheit%c"), maths_kelvin_to_fahrenheit(sa->ss.temperature), CONFIG_LINE_FEED);
	(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);

	(void) fprintf(stdout, _(" mean radius................ %g kilometers%c"), sa->ss.radius, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" equatorial radius.......... %g kilometers%c"), sa->ss.radius_e, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" polar radius............... %g kilometers%c"), sa->ss.radius_p, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" rotation velocity.......... %g meters per second%c"), sa->ss.rotation, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" flattening................. %g%c"), sa->ss.flattening, CONFIG_LINE_FEED);
	(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);

	(void) fprintf(stdout, _(" mass....................... %g kilograms%c"), sa->ss.mass, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" area....................... %g square kilometers%c"), sa->ss.area, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" volume..................... %g cubic kilometers%c"), sa->ss.volume, CONFIG_LINE_FEED);
	(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);

	(void) fprintf(stdout, _(" energy..................... %g joules%c"), sa->ss.energy, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" lifetime................... %g million years%c"), sa->ss.lifetime, CONFIG_LINE_FEED);
	(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);

	(void) fprintf(stdout, _(" centripetal acceleration... %g meters per second%c"), sa->ss.centripetal, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" gravity acceleration....... %g meters per second%c"), sa->ss.acceleration, CONFIG_LINE_FEED);
	(void) fprintf(stdout, _(" escape velocity............ %g kilometers per second%c"), sa->ss.velocity, CONFIG_LINE_FEED);
	(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);

	if(sa->type != STAR_TYPE_BLACKHOLE) {
		(void) fprintf(stdout, _(" color...................... %d/%d/%d/%d in RGBA (0-255)%c"), sa->ss.rgb.pixel.r, sa->ss.rgb.pixel.g, sa->ss.rgb.pixel.b, sa->ss.rgb.pixel.a, CONFIG_LINE_FEED);
		(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);
	}

	if(sa->type != STAR_TYPE_NEUTRON && sa->type != STAR_TYPE_BLACKHOLE) {
		(void) fprintf(stdout, _(" chemical composition percentages%c"), CONFIG_LINE_FEED);
		(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);

		(void) star_print_human_op(sa, _(ELEMENT_CARBON_ELEMENT_NAME), ELEMENT_CARBON_STANDARD_STATE, ELEMENT_CARBON_TEMP_MELTING, ELEMENT_CARBON_TEMP_BOILING, sa->sc.carbon);
		(void) star_print_human_op(sa, _(ELEMENT_HELIUM_ELEMENT_NAME), ELEMENT_HELIUM_STANDARD_STATE, ELEMENT_HELIUM_TEMP_MELTING, ELEMENT_HELIUM_TEMP_BOILING, sa->sc.helium);
		(void) star_print_human_op(sa, _(ELEMENT_HYDROGEN_ELEMENT_NAME), ELEMENT_HYDROGEN_STANDARD_STATE, ELEMENT_HYDROGEN_TEMP_MELTING, ELEMENT_HYDROGEN_TEMP_BOILING, sa->sc.hydrogen);
		(void) star_print_human_op(sa, _(ELEMENT_IRON_ELEMENT_NAME), ELEMENT_IRON_STANDARD_STATE, ELEMENT_IRON_TEMP_MELTING, ELEMENT_IRON_TEMP_BOILING, sa->sc.iron);
		(void) star_print_human_op(sa, _(ELEMENT_MAGNESIUM_ELEMENT_NAME), ELEMENT_MAGNESIUM_STANDARD_STATE, ELEMENT_MAGNESIUM_TEMP_MELTING, ELEMENT_MAGNESIUM_TEMP_BOILING, sa->sc.magnesium);
		(void) star_print_human_op(sa, _(ELEMENT_NEON_ELEMENT_NAME), ELEMENT_NEON_STANDARD_STATE, ELEMENT_NEON_TEMP_MELTING, ELEMENT_NEON_TEMP_BOILING, sa->sc.neon);
		(void) star_print_human_op(sa, _(ELEMENT_NITROGEN_ELEMENT_NAME), ELEMENT_NITROGEN_STANDARD_STATE, ELEMENT_NITROGEN_TEMP_MELTING, ELEMENT_NITROGEN_TEMP_BOILING, sa->sc.nitrogen);
		(void) star_print_human_op(sa, _(ELEMENT_OXYGEN_ELEMENT_NAME), ELEMENT_OXYGEN_STANDARD_STATE, ELEMENT_OXYGEN_TEMP_MELTING, ELEMENT_OXYGEN_TEMP_BOILING, sa->sc.oxygen);
		(void) star_print_human_op(sa, _(ELEMENT_SILICON_ELEMENT_NAME), ELEMENT_SILICON_STANDARD_STATE, ELEMENT_SILICON_TEMP_MELTING, ELEMENT_SILICON_TEMP_BOILING, sa->sc.silicon);
		(void) star_print_human_op(sa, _(ELEMENT_SULFUR_ELEMENT_NAME), ELEMENT_SULFUR_STANDARD_STATE, ELEMENT_SULFUR_TEMP_MELTING, ELEMENT_SULFUR_TEMP_BOILING, sa->sc.sulfur);

		(void) fprintf(stdout, "%c", CONFIG_LINE_FEED);
	}
}

static void star_print_human_op(struct star *a, char *s, int e, float m, float b, float c) {
	char *x, *y, *z;

	size_t i, t;

	char n[STAR_NAME_LEN_MAX];

	switch(e) {
		case ELEMENT_STATE_GAS:
			x = _(ELEMENT_STATE_GAS_GAS);
			y = _(ELEMENT_STATE_GAS_LIQUID);
			z = _(ELEMENT_STATE_GAS_ICE);

			break;
		case ELEMENT_STATE_LIQUID:
			x = _(ELEMENT_STATE_LIQUID_VAPOR);
			y = _(ELEMENT_STATE_LIQUID_LIQUID);
			z = _(ELEMENT_STATE_LIQUID_ICE);

			break;
		case ELEMENT_STATE_SOLID:
			x = _(ELEMENT_STATE_SOLID_VAPOR);
			y = _(ELEMENT_STATE_SOLID_MOLTEN);
			z = _(ELEMENT_STATE_SOLID_SOLID);

			break;
		default:
			x = "";
			y = "";
			z = "";

			break;
	}

	if(a->ss.temperature >= b) {
		(void) snprintf(n, sizeof(n), "%s, %s", s, x);
	}
	else if(a->ss.temperature >= m) {
		(void) snprintf(n, sizeof(n), "%s, %s", s, y);
	}
	else {
		(void) snprintf(n, sizeof(n), "%s, %s", s, z);
	}

	(void) fprintf(stdout, "  %s", n);

	t = str_len(n, STRING_ASCII);

	if(t < 26) {
		for(i = 0; i < 26 - t; i++) {
			(void) fprintf(stdout, ".");
		}
	}

	(void) fprintf(stdout, " %f%c", c, CONFIG_LINE_FEED);
}
