Mirai's Miscellaneous Misadventures

M49 / chapters / test / setup.c

/* license: AGPLv3 or later */
/* copyright 2024 zamfofex */

#include <mimimi-chapters.h>

#include "ground.c"

static void mimimi_test_video_set(struct mimimi_test_video_set *tset, struct mimimi_video_set *set)
{
	static int video_count = 8;
	static int image_count = 8;
	static int width = 48;
	static int height = 48;
	
	int i, j, k;
	struct mimimi_video *videos, *standing, *knocked, *falling, *jumping;
	struct mimimi_image *images, *image;
	unsigned char *colors;
	void **textures;
	
	videos = tset->videos;
	images = tset->images;
	colors = tset->colors;
	textures = tset->textures;
	
	set->standing = videos;
	set->standing_video_count = video_count;
	videos += video_count;
	
	set->jumping = videos;
	set->jumping_video_count = video_count;
	videos += video_count;
	
	for (i = 0 ; i < video_count ; i++)
	{
		standing = set->standing + i;
		standing->count = image_count;
		standing->images = images;
		images += image_count;
		standing->textures = textures;
		textures += image_count;
		
		for (j = 0 ; j < image_count ; j++)
		{
			image = standing->images + j;
			image->width = width;
			image->height = height;
			image->colors = colors;
			colors += width * height;
			for (k = 0 ; k < width * height ; k++) image->colors[k] = 0;
		}
		
		jumping = set->jumping + i;
		jumping->count = image_count;
		jumping->images = images;
		images += image_count;
		jumping->textures = textures;
		textures += image_count;
		
		for (j = 0 ; j < image_count ; j++)
		{
			image = jumping->images + j;
			image->width = width;
			image->height = height;
			image->colors = colors;
			colors += width * height;
			for (k = 0 ; k < width * height ; k++) image->colors[k] = 0;
		}
	}
	
	knocked = videos++;
	knocked->count = 1;
	knocked->images = images++;
	knocked->images[0].width = width;
	knocked->images[0].height = height;
	knocked->images[0].colors = colors;
	knocked->textures = textures++;
	colors += width * height;
	for (i = 0 ; i < width * height ; i++) knocked->images[0].colors[i] = 0;
	
	falling = videos++;
	falling->count = 1;
	falling->images = images++;
	falling->images[0].width = width;
	falling->images[0].height = height;
	falling->images[0].colors = colors;
	colors += width * height;
	falling->textures = textures++;
	for (i = 0 ; i < width * height ; i++) falling->images[0].colors[i] = 0;
	
	set->knocked = knocked;
	set->falling = falling;
}

static void mimimi_test_appearance(struct mimimi_test_sprite *sprite, struct mimimi_engine *engine)
{
	mimimi_test_video_set(&sprite->left, &sprite->appearance.left);
	mimimi_test_video_set(&sprite->right, &sprite->appearance.right);
	
	mimimi_appearance(&sprite->appearance, sprite->model, 24, 37);
	mimimi_prepare_appearance(&sprite->appearance, engine);
}

static void mimimi_test_sprite(struct mimimi_test_sprite *sprite, int x, int y, struct mimimi_model *model, struct mimimi_engine *engine, struct mimimi_position *camera)
{
	sprite->model = model;
	sprite->display.camera = camera;
	sprite->display.sprite = &sprite->sprite;
	sprite->display.appearance = &sprite->appearance;
	sprite->display.animation_time = 0;
	sprite->display.direction = 1;
	sprite->display.width = 24;
	sprite->display.height = 48;
	mimimi_sprite(&sprite->sprite, mimimi_test_ground, x, y, 80, 250);
	mimimi_test_appearance(sprite, engine);
}

static void mimimi_test_mango_tick(struct mimimi_test_sprite *mango, struct mimimi_history *history)
{
	mimimi_controls_tick(&mango->sprite.walk, history, &mimimi_jump, &mango->sprite);
	mimimi_sprite_tick(&mango->sprite);
}

void mimimi_test_tick(void *data, unsigned char left, unsigned char right)
{
	struct mimimi_test *chapter;
	chapter = data;
	mimimi_history_tick(&chapter->history, left, right);
	mimimi_test_mango_tick(&chapter->mango, &chapter->history);
	mimimi_sprite_tick(&chapter->pepper.sprite);
	mimimi_collision_tick(&chapter->collision);
	mimimi_background_tick(&chapter->background, chapter->engine);
	mimimi_display_tick(&chapter->pepper.display, chapter->engine);
	mimimi_display_tick(&chapter->mango.display, chapter->engine);
	mimimi_camera_tick(&chapter->camera, &chapter->mango.sprite.position, 0, -512);
}

static void mimimi_test_background(struct mimimi_test *chapter)
{
	static unsigned char colors[] = {0x0D, 0x05};
	
	int x, y;
	unsigned char color;
	
	chapter->background_image.colors = chapter->background_colors;
	chapter->background_image.width = mimimi_test_ground->width * 16;
	chapter->background_image.height = mimimi_test_ground->height * 16;
	
	for (y = 0 ; y < chapter->background_image.height ; y++)
	for (x = 0 ; x < chapter->background_image.width ; x++)
	{
		color = colors[mimimi_ground_tile(mimimi_test_ground, x / 16, y / 16)];
		chapter->background_image.colors[x + y * chapter->background_image.width] = color;
	}
	
	chapter->background.texture = (*chapter->engine->texture)(chapter->engine->data, &chapter->background_image);
	chapter->background.camera = &chapter->camera;
	chapter->background.x = 0;
	chapter->background.y = 0;
	chapter->background.z = 0;
}

void mimimi_test(void *data, struct mimimi_engine *engine)
{
	struct mimimi_test *chapter;
	chapter = data;
	chapter->engine = engine;
	mimimi_test_sprite(&chapter->mango, 110 * 128, 36 * 128, mimimi_mango, engine, &chapter->camera);
	mimimi_test_sprite(&chapter->pepper, 108 * 128, 36 * 128, mimimi_pepper, engine, &chapter->camera);
	chapter->history.left = 0;
	chapter->history.right = 0;
	chapter->camera = chapter->mango.sprite.position;
	chapter->camera.y -= 512;
	mimimi_test_background(chapter);
	chapter->collision_positions[0] = &chapter->mango.sprite.position;
	chapter->collision_positions[1] = &chapter->pepper.sprite.position;
	chapter->collision.count = 2;
	chapter->collision.positions = chapter->collision_positions;
	chapter->collision.proximity = 128;
	chapter->collision.height = 256;
	chapter->collision.strength = 512;
	chapter->collision.tolerance = 64;
}