/*
 * circles.c:
 *	Adapted from an RTB BASIC program as a simple demo
 *
 * Gordon Henderson, June 2019
 *********************************************************************************
 */

#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdint.h>

#include "ruby.h"

#pragma static-locals (1);


void circleOpen (uint16_t x, uint16_t y, uint16_t r)
{
  move (x, y) ;
  plot (145, r,r) ;
}

void circleFilled (uint16_t x, uint16_t y, uint16_t r)
{
  move (x, y) ;
  plot (153, r,r) ;
}


uint8_t sorting, solid ;

#define	MAX_CIRCLES	100


#define	gWidth	640
#define	gHeight	480

uint16_t where   = gWidth / 32 ;
uint16_t radMax  = gHeight / 2 ;

uint16_t cx     [MAX_CIRCLES] ;
uint16_t cy     [MAX_CIRCLES] ;
uint16_t speed  [MAX_CIRCLES] ;
uint16_t col    [MAX_CIRCLES] ;
uint16_t size   [MAX_CIRCLES] ;
uint16_t pause  [MAX_CIRCLES] ;
uint16_t rMax   [MAX_CIRCLES] ;

uint16_t numCircles ;

void swp (uint16_t i, uint16_t j)
{
  uint16_t tmp ;

  tmp = cx     [i] ; cx     [i] = cx     [j] ; cx     [j] = tmp ;
  tmp = cy     [i] ; cy     [i] = cy     [j] ; cy     [j] = tmp ;
  tmp = speed  [i] ; speed  [i] = speed  [j] ; speed  [j] = tmp ;
  tmp = col    [i] ; col    [i] = col    [j] ; col    [j] = tmp ;
  tmp = size   [i] ; size   [i] = size   [j] ; size   [j] = tmp ;
  tmp = pause  [i] ; pause  [i] = pause  [j] ; pause  [j] = tmp ;
}


void circle (uint16_t x, uint16_t y, uint16_t r)
{
  if (solid)
    circleFilled (x, y, r) ;
  else
    circleOpen (x, y, r) ;
}


void sortData (void)
{
  int16_t i ;
  uint16_t j, k, m ;

  m = numCircles / 2 ;

  while (m > 0)
  {
    j = m ;
    while (j <= numCircles)
    {
      i = j - m ;
      while (i >= 0)
      {
	k = i + m ;
	if (size [k] >= size [i])
	  swp (i, k) ;
	else
	  break ;
	i = i - m ;
      }
      j = j + 1 ;
    }
    m = m / 2 ;
  }
}


void drawCircles (void)
{
  uint16_t circ ;

  sortData () ;

  for (circ = 0 ; circ < numCircles ; ++circ)
  {
    if (pause [circ] == 0)
    {
      gcol (0, col [circ]) ;
      circle (cx [circ], cy [circ], size [circ] + 0) ;
      circle (cx [circ], cy [circ], size [circ] + 1) ;
      circle (cx [circ], cy [circ], size [circ] + 2) ;
    }
  }
}

void updateCircles (void)
{
  uint16_t circ ;

  for (circ = 0 ; circ < numCircles ; ++circ)
  {
    if (pause [circ] == 0)
    {
      size [circ] += speed [circ] ;
      if (size [circ] > radMax)
	pause [circ] = rand () % 100 + 1 ;
    }
    else
    {
      --pause [circ] ;
      if (pause [circ] == 0)	// Create new circle
      {
	cx    [circ] = rand () % gWidth ;
	cy    [circ] = rand () % gHeight ;
	speed [circ] = rand () %  5 + 1 ;
	col   [circ] = rand () % 15 + 1 ;
	size  [circ] = rand () %  5 + 5 ;
      }
    }
  }
}


uint16_t main (void)
{
  register uint16_t i ;
  uint8_t input [20] ;
  uint8_t c ;

  osw0.in     = input ;
  osw0.maxLen =  19 ;
  osw0.min    =  32 ;
  osw0.max    = 127 ;


  cls () ;

  for (i = 0 ; i < MAX_CIRCLES ; ++i)
  {
    speed [i] = size [i] = 0 ;
    pause [i] =  1 ;
  }

  cls () ;
  cputs ("Circles!\n") ;

  for (;;)
  {
    cputs ("how many circles (5-100)? ") ;
    osWord (0, (uint8_t *)&osw0) ;
    numCircles = atoi (input) ;
    if ((numCircles > 4) && (numCircles < 101))
      break ;
  }

  cputs ("Solid or open? ") ;
  for (;;)
  {
    c = toupper (cgetc ()) ;
    if (c == 'S')
    {
      solid = 1 ;
      cputs ("Solid\n") ;
      break ;
    }

    if (c == 'O')
    {
      solid = 0 ;
      cputs ("Open\n") ;
      break ;
    }
  }

  cputs ("Sort? ") ;
  for (;;)
  {
    c = toupper (cgetc ()) ;
    if (c == 'Y')
    {
      sorting = 1 ;
      cputs ("Sorting\n") ;
      break ;
    }

    if (c == 'N')
    {
      sorting = 0 ;
      cputs ("Not sorting\n") ;
      break ;
    }
  }

  cputs ("Press SPACE to start ... ") ;
  while (cgetc () != ' ') 
    ;

  for (;;)
  {
    updateCircles () ;
    cls () ;
    drawCircles   () ;
    vdu (0) ;
  }

  return EXIT_SUCCESS;
}