ayin/benches/benchmark.rs

use criterion::{Criterion, criterion_group, criterion_main};
use std::hint::black_box;

fn criterion_benchmark(c: &mut Criterion) {
    c.bench_function("minimal", |b| {
        b.iter(|| {
            let program = "
let main = fn() {
  1
}
";
            ayin::run_main(black_box(program))
        })
    });

    c.bench_function("game", |b| {
        b.iter(|| {
            let program = "
let main = fn() {
  setup()
}

let screen_size = 360
let shoot_timer = 60
let dim = {
  .w: 16,
  .h: 16,
}
let bullet_dim = {
  .w: dim.w / 4,
  .h: dim.h / 4,
}

let migrate = fn(state) {
	return setup();
    state
}


let setup = fn() {
  return {
    .player: {
	  .pos: {
	    .x: (screen_size - dim.w) - dim.w,
		.y: dim.h,
	  },
      .speed: 360,
	},
	.enemy: {
	  .pos: {
	    .x: dim.w,
		.y: dim.h,
	  },
      .speed: 20,
      .timer: shoot_timer,
	},
	.bullets: {
	  .pos: {
	    .x: dim.w,
		.y: dim.h,
	  },
	  .movement: {
	    .x: 0,
	    .y: 0,
	  },
      .speed: 180,
	},
	.timer: 0,
	.status: \"ongoing\",
  };
}

let move_player = fn(state, input) {
  let delta = get_frame_time();

  let dpad_x = if input.gamepad1.dpad.right { 1 } else { 0 } + if input.gamepad1.dpad.left { -1 } else { 0 };
  let dpad_y = if input.gamepad1.dpad.down  { 1 } else { 0 } + if input.gamepad1.dpad.up   { -1 } else { 0 };

  let movement = {
    .x: input.gamepad1.sticks.left.x + dpad_x,
    .y: input.gamepad1.sticks.left.y + dpad_y,
  };

  state.player.pos.x =
    max(0,
      min( state.player.pos.x + (delta * state.player.speed * movement.x)
	     , screen_size - dim.w
	     )
	);
  state.player.pos.y =
    max(0,
      min( state.player.pos.y + (delta * state.player.speed * movement.y)
	     , screen_size - dim.w
	     )
    );
}

let update = fn(state, input) {
  let delta = get_frame_time();
  state.timer = state.timer + delta;

  move_player(state, input);

  let enemy_movement = {
    .x: if abs(state.enemy.pos.x - state.player.pos.x) < 5 { 0 } else { if state.enemy.pos.x < state.player.pos.x { 1 } else { -1 } },
    .y: if abs(state.enemy.pos.y - state.player.pos.y) < 5 { 0 } else { if state.enemy.pos.y < state.player.pos.y { 1 } else { -1 } },
  };

  state.enemy.pos.x =
    max(0,
      min( state.enemy.pos.x + (delta * state.enemy.speed * enemy_movement.x)
	     , screen_size - dim.w
	     )
	);
  state.enemy.pos.y =
    max(0,
      min( state.enemy.pos.y + (delta * state.enemy.speed * enemy_movement.y)
	     , screen_size - dim.w
	     )
    );

  state.enemy.timer = state.enemy.timer - 1;
  if state.enemy.timer == 0 {
     state.enemy.timer = shoot_timer;
	 state.bullets.pos.x = state.enemy.pos.x + (dim.w * enemy_movement.x);
	 state.bullets.pos.y = state.enemy.pos.y + (dim.h * enemy_movement.y);
	 state.bullets.movement.x = enemy_movement.x;
	 state.bullets.movement.y = enemy_movement.y;
  };

  state.bullets.pos.x =
      state.bullets.pos.x + (delta * state.bullets.speed * state.bullets.movement.x);
  state.bullets.pos.y =
      state.bullets.pos.y + (delta * state.bullets.speed * state.bullets.movement.y);

  return state;
}

let draw = fn(state) {
  frame_clear(0, 0, 0);
  let player_rect = {
    .x: state.player.pos.x,
    .y: state.player.pos.y,
    .w: dim.w,
    .h: dim.h,
  };
  let color = { .r: 155, .g: 205, .b: 255 };
  draw_rectangle(player_rect, color);

  let enemy_rect = {
    .x: state.enemy.pos.x,
    .y: state.enemy.pos.y,
    .w: dim.w,
    .h: dim.h,
  };

  let color = { .r: 255, .g: 155, .b: 255 };
  draw_rectangle(enemy_rect, color);

  let bullet_rect = {
    .x: state.bullets.pos.x,
    .y: state.bullets.pos.y,
    .w: bullet_dim.w,
    .h: bullet_dim.h,
  };

  let color = { .r: 255, .g: 255, .b: 255 };
  draw_rectangle(bullet_rect, color);

  draw_text(\"RUN!!!\", 20, 50, 50, { .r: 255, .g: 55, .b: 55 });
}

let min = fn(a,b) {
  if a < b {
    a
  } else {
    b
  }
}

let max = fn(a,b) {
  if a < b {
    b
  } else {
    a
  }
}

let abs = fn(a) {
	if a >= 0 { a } else { 0 - a }
}

let is_touching = fn(rect1, rect2) {
	if ((rect1.x < rect2.x) && ((rect1.x + rect1.w) > rect2.x))
	&& ((rect1.y < rect2.y) && ((rect1.y + rect1.h) > rect2.y)) {
	  true
	} else {
      false
	}
}
";
            ayin::run_main(black_box(program))
        })
    });
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);