%+-------------------------------------------------------+%
%|              DAVE'S MATLAB SHOOTER v0.3               |%
%|                 by David Buckingham                   |%
%|                                                       |%
%|         a vertical-scrolling shoot-em-up game         |%
%+-------------------------------------------------------+%

%+-------------------------------------------------------+%
%|                         TIPS                          |%
%|                                                       |%
%| -kill cruisers as quickly as possible.                |%
%| -game lagging too much? set NO_FILL to true.          |%
%| -program needs access to "hitTest.m"                  |%
%| -questions? email xorvox@hotmail.com                  |%
%+-------------------------------------------------------+%

%v0.3
%-bullets, fireballs, explosions, pause messages are all cleared from the
% secreen when game is reset instead of remaining behind the intro message.
%-fixed image layering order. bots now appear behind messages like game
% over and pause, behind health bars, and above stars. fireballs appear
% behind hud bars.
%-duration of superShoot upgrade is now set in seconds according to
% SUPER_SHOOT_DURATION which is 14. Previously, it was set to 1 and
% decremented each frame by SUPER_SHOOT_DRAIN, which was set to .002.
%-no points are scored if INVINCIBLE
%-the problem with bot plots changin slightly when bullets are on screen
% mysteriously fixed itself :)
%-bots can exit bounds to left or right if less than BOT_END above bottom
% instead of always moving out through the bottom of the screen.
%-function name now matches filename (oops).
%-added tips section at top of code
 
%v0.2
%-decrease fireball speed from 3 to 2.5
%-increase hero speed from 7 to 7.5
%-increase shield restore rate from .0001 to .00015 per frame
%-enemy models 1 and 2 drop fewer upgrades
%-waves last longer
%-instead of at top of plot, bots are generated at top of plot plus some
% distance BOT_START. this delays return of bots after using bomb.
%-shorten break between waves to compensate for addition of BOT_START.
%-explosion when fireball hits hero, so you know when your hit.
%-minor updates to comments and code, e.g. comment correct fps.
%-killHero calles makeExplosion instead of creating its own explosion.

%known problems with v0.1:
%-can lag  a bit. when there are many ships on the screen there's alot going
% on each frame. I'm sure the code could use alot of optimization to make
% things run faster. for a quick fix, setting NO_FILL to true should make a
% big difference.
%-bot plots change slightly when bullets are on screen. this drives me nuts.
% if anybody can figure out why this is happening PLEASE let me know.
%-game has not been extensively tested. will want to tweak stuff to
% get the difficulty, excitement, etc. just right for next release
%-imprecision in matlab's 'pause' function means that in-game seconds aren't
%guaranteed to be real-time seconds. on my machine, game seconds are about
%1.5 real seconds.


function [] = me430game(portNumber, teamNumberHexString)

close all
clc

%+-----------------------------------------------------------------------+
%|                              CONSTANTS                                |
%+-----------------------------------------------------------------------+
%here's some values that you might want to mess around with. It is safe
%to modify these to values within the specified ranges.
%-NO_FILL:     true/false
%-INVINCIBLE:  true/false
%-START_WAVE:  1 <= START_WAVE <= 10
NO_FILL = false; %set to true if game lags. ships are just outlines.
INVINCIBLE = false; %hero doesn't die if shield goes below 0
START_WAVE = 1; %wave at game start

FRAME_DELAY = .025; %don't modify this. delay between animation frames.
%to avoid distortion: FIGURE_WIDTH/FIGURE_HEIGHT = PLOT_W/PLOT_H
%we'll use the golden rectangle because its supposed to look nice
%although i doubt it will actually be displayed at the right dimensions.
FIGURE_WIDTH = 464; %pixels
FIGURE_HEIGHT = 750;
PLOT_W = 200; %width in plot units. this will be main units for program
PLOT_H = 324; %height
%number frames between periodic tasks like bot generation and bot firing
%this should be 10.
WAIT_FRAMES = 10; %DONT CHANGE THIS. KEEP IT AT 10.
%these "secons" assume precise frame delays, which matlab doesn't
%guarantee. these "seconds" are about 1.5 real seconds on my machine. let
%me know what you come up with. although there coule be something i'm
%missing in my code thats causing this effect and the frame delays
%could be accurate.
WAVE_BREAK = 3; %number of seconds between waves
ENCORE_DELAY = 1; %number of seconds between death and 'game over' message

%colors
GREEN = [.1, .7, .1];
BLUE = [.3, .3, .9];
WHITE = [1, 1, 1];
RED = [.9, .3, .3];
BULLET_FACE_COLOR = GREEN;
BULLET_EDGE_COLOR = GREEN;
FIRE_FACE_COLOR = [1, 0, 0];
FIRE_EDGE_COLOR = [1, 0, 0];
HERO_COLOR = BLUE;
BOT_COLORS = [.9, .4, .0; ... %bot1 color
  .6, .6, .7; ... %bot2 color
  .8,  0, .4];     %bot3 color
PUP_FACE_COLORS = [GREEN; ... %supershoot
  BLUE; ... %superspeed
  RED];     %nuke
PUP_EDGE_COLOR = [.8, .8, .4];
FIGURE_COLOR = [.15, .15, .15]; %program background
AXIS_COLOR = [0, 0, 0]; %the sky
STAR_COLOR = [.4, .4, .4];
INTRO_COLOR = GREEN; %name of program on intro screen
OVER_COLOR = GREEN; %game over
PAUSE_COLOR = GREEN;
TITLE_COLOR = GREEN;
%color for top bar outline, bottom outline, top fill, bottom fill.
HUD_COLORS = [BLUE; BLUE * .8; GREEN; GREEN * .8];
FILL_DARKEN = 0.3; %multiplied by ship color to make ship fill color

%speeds
BULLET_SPEED = 5;
BOT_SPEEDS = [2, 1.5, .5]; %[bot1, bot2, bot3]
MAX_STAR_SPEED = 5;
MIN_STAR_SPEED = 1;
STILL_SPEED = 1; %how fast 'still' things like explosions should move.
FIRE_SPEED = 2.5; %speed of enemry fireballs
HERO_SPEED = 7.5;

%displaying powerups
d = sqrt(3)/2;
PUP_SHAPE = [-1, -.5, .5, 1, .5, -.5, -1; %hexagon
  0,   d,  d, 0, -d,  -d,  0];
PUP_SIZE = 4;
PUP = PUP_SHAPE .* PUP_SIZE;
PUP_LINE_WIDTH = 2;
theta = pi/64; %how fast pups spin
ROTATION_MATRIX = [cos(theta), sin(theta); ...
  -sin(theta), cos(theta)];
SUPER_LAG = 4; %distance side bullets lag front bullet if superShoot
SUPER_SPACE = 6; %distance of extra bullets from centerline of hero

%powerup effects
HEALTH_BOOST = .3; %health restored by health pup
SUPER_SHOOT_DURATION = 14; %how long superShoot upgrade lasts in 'seconds'

%bullets shot by hero
BULLET_DELAY = 4; %number of frames between bullets
BULLET_SHAPE = 'd';
BULLET_SIZE = 5;
ENERGY_DRAIN = .02; %per shot while shooting
ENERGY_RESTORE = .02; %per frame if not shooting and after delay
ENERGY_DELAY = 30; %how long after stop shooting until energy restore

%fire shot by bots
FIRE_SHAPE = 'o';
FIRE_SIZE = 5;
FIRE_VAR = .5; %alters fire vector so enemies miss sometimes
FIRE_DAMAGE = .5; %damage done to hero by fire

%hero
COLLISION_DAMAGE = .9; %damage done to hero by collision with bot
HEALTH_RESTORE = .00015; %health restored each frame
HERO_START_Y = 20; %hero start position
HERO_W = 15; %hero width
HERO_H = 20; %hero height
HERO_SHAPE = [1 0 1 2 3 4 3 1; ... %x values
  0 1 2 4 2 1 0 0];    %y values
xScale = HERO_W / max(HERO_SHAPE(1,:));
yScale = HERO_H / max(HERO_SHAPE(2,:));
%coordinats for drawing hero at 0,0.
HERO = [HERO_SHAPE(1,:) .* xScale; HERO_SHAPE(2,:) .* yScale];

%bots
%each constant is a list of values, one for each bot model: [m1, m2, m3]
FIRE_PROB = [.02, .04, .1]; %probability of firing each WAIT_FRAMES
BOT_POINTS = [10, 100, 500]; %points awarded for killing
PUP_PROB = [.0033, .0333, .3333]; %probabiliity of droping a powerup
FIRE_BURST = [1, 2, 4]; %how many fireballs shot at a time by a bot
BOT_HEALTH = [1, 3, 12]; %number of hits to kill bot
BOT_W = [9, 13, 18]; %widths
BOT_H = [9, 12, 22]; %heights
%BOT_START distance above top of screen where bots are generaged. This mainly
%determines how long after using bomb powerup until more bots come. this
%also affects bot vectors a bit.
BOT_START = 40;
%BOT_END maximum distance above bottom of screen where bots MIGHT go out
%of bounds according to its vector.
BOT_END = 100;

%bot1
MIN_FORMATION = 3; %minimum number of bots in a formation
MAX_FORMATION = 10; %maximum
BOT1_SHAPE = [1 0 0 1 2 3 3 2 2 1 1; ...
              0 1 2 3 3 2 1 0 1 1 0];
xScale = BOT_W(1) / max(BOT1_SHAPE(1,:));
yScale = BOT_H(1) / max(BOT1_SHAPE(2,:));
%BOT1 is scaled BOT1_SHAPE, it is the coordinates for drawing bot at 0,0.
BOT1 = [BOT1_SHAPE(1,:) .* xScale; BOT1_SHAPE(2,:) .* yScale];

%bot2
BOT2_SHAPE = [0 0 1 3 4 4 3 2 1 0; ...
              1 4 3 3 4 1 2 0 2 1];
xScale = BOT_W(2) / max(BOT2_SHAPE(1,:));
yScale = BOT_H(2) / max(BOT2_SHAPE(2,:));
%scaled BOT2_SHAPE
BOT2 = [BOT2_SHAPE(1,:) .* xScale; BOT2_SHAPE(2,:) .* yScale];
BOT2_TACK_PROB = .15; %chance of bot tacking each WAIT_FRAMES

%bot3
BOT3_SHAPE = [1 2 0 3 6 4 5 3 1; ...
              1 2 4 5 4 2 1 0 1];
xScale = BOT_W(3) / max(BOT3_SHAPE(1,:));
yScale = BOT_H(3) / max(BOT3_SHAPE(2,:));
%scaled BOT3_SHAPE
BOT3 = [BOT3_SHAPE(1,:) .* xScale; BOT3_SHAPE(2,:) .* yScale];

%appearance
SHIP_LINE_WIDTH = 2;
STAR_SHAPE = '*';
BIG_STAR_SIZE = 3;
SMALL_STAR_SIZE = 2;
NUM_STARS = 50; %number of stars

%explosions
EXPLOSION_MIN = 4; %explosion marker start size
EXPLOSION_INCREASE = 5; %increse in explosion marker size each frame
EXPLOSION_DURATION = 5; %how long explosions take in frames

%text and messages
MESSAGE_Y = 190; %placement of pause and gameover messages
FONT = 'Courier'; %used for all text in program
MESSAGE_SPACE = 15; %spacing between message lines
LARGE_TEXT = 18; %text sizes
SMALL_TEXT = 14;
TINY_TEXT = 13;

%hud
HUD_H = 6; %height of one of the hud bars
HUD_W = 85; %width
HUD_MARGIN = 2; %margin around hud bars
HUD_LINE_WIDTH = 9; %width of lines filling hud bars
HUD_BAR  = [0, 0, HUD_W, HUD_W, 0; ...
            0, HUD_H, HUD_H, 0, 0];

%strings
STR_CONTINUE = 'hit any key to continue';
STR_PAUSED = 'GAME PAUSED';
STR_OVER = 'GAME OVER';
STR_CONTROLS = 'reset:(r) quit:(q) pause:any';

%waves
%each row represents a wave of fighters in format: [D, Pb, P1, P2]
%D = duration of wave in seconds
%Pb = probability of generating a bot each WAIT_FRAMES
%P1 = probability that a generated bot is model 1
%P2 = probability that a generated bot is NOT model 3. P2 >= P1
%e.g. if P1=.2 and P2=.7 then:
%probability of generating model1 = .2
%probability of generating model2 = .5
%probability of generating model3 = .3
%if P1 = P2 there are no model 2s
%if p2 = 1, there are no model 3s
%        [D, Pb, P1, P2]
WAVES = [15, .4,  1,  1; ... %wave 1
         30, .4, .6,  1; ... %2
         45, .6, .7,  1; ... %3
         60, .3, .5, .9; ... %4
         75, .4, .4, .9; ... %5
         90, .4, .8, .7; ... %6
         105, .2,  0, .8; ... %7
         120, .3, .1, .8; ... %8
         135, .5, .4, .8; ... %9
         99, .5, .1, .7;];   %10, continues indefinitely


%+-----------------------------------------------------------------------+
%|                        DECLARE VARIABLES                              |
%+-----------------------------------------------------------------------+

fig = []; %main program figure

%boolean flags
quitGame = false; %guard for main loop. when true, program ends
paused = []; %true if game is paused
mouseDown = []; %is the mouse button down
gameOver = []; %bool, hero has died but game not reset yet
intro = []; %bool, are we in the intro screen?
onBreak = []; %bool, are we in a break between waves. no bots are alive
levelOver = []; %bool. level over but not on break yet. bots still alive.

%counters
counter = []; %main counter number of frames since reset
energyCounter = []; %keep track of time until begin to restore energy
encoreCounter = []; %track time after gameover until display message
bulletCounter = []; %time since last bullet fired.
waveCounter = []; %counter at start of current wave or break

%pairs of units and associated plots
%units depicted by markers have a single plot for all units
%units depicted by draswings have a plot for each unit
heroPos = []; %position of hero
heroPlot = []; %plot for hero
smallStars = []; %list of small star locations
smallStarPlot = [];
bigStars = []; %list of big star locations
bigStarPlot = [];
bullets = []; %2xN array of bullet's x and y positions.
bulletPlot = [];
fire = []; %4xN matrix of enemy fireballs in form [x;y;dx;dy]
firePlot = []; %plot of enemy fire
pups = []; %3xN matrix of powerups [x;y;type]
pupPlots = []; %list of powerup plots
explosions = []; %3xN matrix of explosion [x;y;age]
explosionPlots = []; %list of plots of explosions
bots = []; %list of current bots
botPlots = []; %list of current bot plots

%other
superShoot = []; % 0<=x<=1 how much time left for supershot upgrade
energy = []; %amount of energy for shooting. 0 <= energy <= 1.
health = []; % player health
hudPlots = []; %plots for hud. top outline, fill. bottom outline, fill.
starSpeeds = []; %a speeds to move stars. reused for small and large stars
mousePos = []; %position of mouse [x, y]
mainAxis = []; %reference to the main axis
score = []; %current player score
axisTitle = []; %handle to axis title
currentWave = []; %int, the current wave
storedStartX = []; %to be passed to each bot1 in a formation
storedGoalX = []; %to be passed to each bot1 in a formation
formation = []; %int, number of ships left to make for currernt formation
encoreText = []; %used to display game over message. cleared by reset.

% ME430 variables added.
global me430data;
me430data.relativeAnalogPosition = [0.5, 0.5];
me430data.needsToFire = 0;
me430data.teamNumber = hex2dec(teamNumberHexString);
me430data.deaths = 0;

%+-----------------------------------------------------------------------+
%|                          CREATE FIGURE CBF                            |
%+-----------------------------------------------------------------------+
%set up the main figure and axis for the program
%run once at start of program
  function createFigure
    %ScreenSize is a four-element vector: [left, bottom, width, height]:
    scrsz = get(0,'ScreenSize');
    %put our figure in the middle of the screen
    fig = figure('Position',[(scrsz(3)-FIGURE_WIDTH)/2, ...
      (scrsz(4)-FIGURE_HEIGHT)/2, ...
      FIGURE_WIDTH, ...
      FIGURE_HEIGHT]);
    %custom close function.
    set(fig,'CloseRequestFcn',@my_closefcn);
    
    %set background color for figure
    set(fig, 'color', FIGURE_COLOR);
    
    %make custom mouse pointer
    pointer = NaN(16, 16);
    pointer(4, 1:7) = 2;
    pointer(1:7, 4) = 2;
    pointer(4, 4) = 1;
    set(fig, 'Pointer', 'Custom');
    set(fig, 'PointerShapeHotSpot', [4, 4]);
    set(fig, 'PointerShapeCData', pointer);
    
    %register keydown and keyup listeners
    set(fig,'KeyPressFcn',@keyDownListener)
    %set(fig, 'KeyReleaseFcn', @keyUpListener);
    set(fig,'WindowButtonDownFcn', @mouseDownListener);
    set(fig,'WindowButtonUpFcn', @mouseUpListener);
    set(fig,'WindowButtonMotionFcn', @mouseMoveListener);
    
    %figure can't be resized
    set(fig, 'Resize', 'off');
    set(fig, 'Name','ME430 Lab 8 game','NumberTitle','off');
    
    mainAxis = axes(); %handle for axis
    axis([0 PLOT_W 0 PLOT_H]);
    axis manual; %axis wont be resized
    
    %set color for the court, hide axis ticks.
    set(mainAxis, 'color', AXIS_COLOR, 'YTick', [], 'XTick', []);
    %handles to title for displaying wave, score
    axisTitle = title('');
    set(axisTitle, 'FontName', FONT,'FontSize', LARGE_TEXT);
    set(axisTitle, 'Color', TITLE_COLOR);
    
    hold on;
  end


%+-----------------------------------------------------------------------+
%|                          CREATE PLOTS CBF                             |
%+-----------------------------------------------------------------------+
%make all permanent plots.
%plot coords all set to NaN for blank plots, data provided later
%run once at start of program
  function createPlots
    
    %plot hud
    for n = 1:4
      hudPlots(n) = plot(NaN, NaN, '-');
      set(hudPlots(n), 'Color', HUD_COLORS(n,:));
    end
    set(hudPlots(2), 'LineWidth', HUD_LINE_WIDTH);
    set(hudPlots(4), 'LineWidth', HUD_LINE_WIDTH);
    
    %plot stars
    smallStarPlot = plot(NaN,NaN);
    bigStarPlot = plot(NaN,NaN);
    set(smallStarPlot, 'Marker', STAR_SHAPE);
    set(smallStarPlot, 'MarkerEdgeColor', STAR_COLOR);
    set(smallStarPlot, 'MarkerSize', SMALL_STAR_SIZE);
    set(smallStarPlot, 'LineStyle', 'none');
    set(bigStarPlot, 'Marker', STAR_SHAPE);
    set(bigStarPlot, 'MarkerEdgeColor', STAR_COLOR);
    set(bigStarPlot, 'MarkerSize', BIG_STAR_SIZE);
    set(bigStarPlot, 'LineStyle', 'none');
    %move stars to the bottom of the display stack
    uistack(smallStarPlot, 'bottom');
    uistack(bigStarPlot, 'bottom');
    
    %plot hero
    if NO_FILL
      heroPlot = plot(NaN,NaN, '-');
      set(heroPlot, 'LineWidth', SHIP_LINE_WIDTH);
      set(heroPlot, 'Color', HERO_COLOR);
    else
      heroPlot = patch(NaN,NaN, 'b');
      set(heroPlot, 'LineWidth', SHIP_LINE_WIDTH);
      set(heroPlot, 'EdgeColor', HERO_COLOR);
      set(heroPlot, 'FaceColor', HERO_COLOR * FILL_DARKEN);
    end
    
    
    %plot bullets
    bulletPlot = plot(NaN,NaN);
    set(bulletPlot, 'Marker', BULLET_SHAPE);
    set(bulletPlot, 'MarkerFaceColor', BULLET_FACE_COLOR);
    set(bulletPlot, 'MarkerEdgeColor', BULLET_EDGE_COLOR);
    set(bulletPlot, 'MarkerSize', BULLET_SIZE);
    set(bulletPlot, 'LineStyle', 'None');
    
    %plot fire
    firePlot = plot(NaN,NaN);
    set(firePlot, 'Marker', FIRE_SHAPE);
    set(firePlot, 'MarkerFaceColor', FIRE_FACE_COLOR);
    set(firePlot, 'MarkerEdgeColor', FIRE_EDGE_COLOR);
    set(firePlot, 'MarkerSize', FIRE_SIZE);
    set(firePlot, 'LineStyle', 'None');
    %move fireballs bellow everything except stars in visual stack
    uistack(firePlot, 'bottom');
    uistack(firePlot, 'up', 3)
  end


%+-----------------------------------------------------------------------+
%|                             RESET CBF                                 |
%+-----------------------------------------------------------------------+
%run at start of program and at game reset
%set all variables to starting values
  function reset
    energyCounter = 0;
    encoreCounter = 0;
    counter = 0;
    waveCounter = 0;
    energy = 0;
    health = 0;
    intro = true;
    bulletCounter = 0;
    
    %just because it looks wierd for stars to stay the same when you
    %restart the game.
    for k = 1:(NUM_STARS / 2)
      starSpeeds(k) = ...
        (rand * (MAX_STAR_SPEED - MIN_STAR_SPEED) + MIN_STAR_SPEED);
    end
    for k = 1:(NUM_STARS / 2)
      smallStars(1,k) = randi(PLOT_W);
      smallStars(2,k) = randi(PLOT_H);
      bigStars(1,k) = randi(PLOT_W);
      bigStars(2,k) = randi(PLOT_H);
    end
    
    for n = 1:4
      set(hudPlots(n), 'XData', NaN, 'YData', NaN);
    end
    
    delete(encoreText(:)); %in case of game over message
    encoreText = [];
    
    
    delete(botPlots(:));
    botPlots = [];
    
    pups = [];
    delete(pupPlots(:));
    pupPlots = [];
    
    explosions = [];
    delete(explosionPlots(:));
    explosionPlots = [];
    
    set(bulletPlot, 'XData', NaN, 'YData', NaN);
    bullets = [];

    set(firePlot, 'XData', NaN, 'YData', NaN);
    fire = [];
    set(heroPlot, 'XData', NaN, 'YData', NaN);
    bots = [];
    paused = false;
    if START_WAVE > size(WAVES, 1)
      currentWave = size(WAVES, 1);
    elseif START_WAVE < 1
      currentWave = 1;
    else
      currentWave = START_WAVE;
    end
    onBreak = true;
    levelOver = false;
    heroPos = [(PLOT_W - HERO_W)/2, HERO_START_Y];
    mousePos = heroPos;

    score = 0;
    formation = 0;
    gameOver = false;
    
    showIntro;
    
  end


%+-----------------------------------------------------------------------+
%|                         REFRESH STAR PLOT CBF                         |
%+-----------------------------------------------------------------------+
%this is separated from refreshPlots so it can run during intro
%runs every frame
  function refreshStarPlot
    set(smallStarPlot, 'XData', smallStars(1,:), 'YData', smallStars(2,:));
    set(bigStarPlot, 'XData', bigStars(1,:), 'YData', bigStars(2,:));
  end


%+-----------------------------------------------------------------------+
%|                         REFRESH PLOTS CBF                             |
%+-----------------------------------------------------------------------+
%this runs at the end of each frame and updates the data in each plot
%according to game data. entities represented by points, such as stars
%and fireballs, have one plot, e.g. the firePlot of fireballs. entities
%represented by drawn shapes, such as bots and powerups, have a plot
%for each entity. e.g. there is a list of powerup plots called pupPlots, a
%list of bot plots called botPlots.
  function refreshPlots
    
    refreshStarPlot;
    
    %stars
    set(smallStarPlot, 'XData', smallStars(1,:), 'YData', smallStars(2,:));
    set(bigStarPlot, 'XData', bigStars(1,:), 'YData', bigStars(2,:));
    
    %hero
    %current hero plot points given hero position
    if ~gameOver
      curHero = [HERO(1,:) + heroPos(1); HERO(2,:) + heroPos(2)];
      set(heroPlot, 'XData', curHero(1,:), 'YData', curHero(2,:));
    end
    
    %bots
    for k = 1:length(bots)
      bot = eval(['BOT', num2str(bots{k}.model)]);
      set(botPlots(k), ...
        'XData', bot(1,:) + bots{k}.pos(1), ...
        'YData', bot(2,:) + bots{k}.pos(2));
    end
    
    %bullets
    if size(bullets, 2) > 0
      set(bulletPlot, 'XData', bullets(1,:), 'YData', bullets(2,:));
    else
      set(bulletPlot, 'XData', NaN, 'YData', NaN);
    end
    
    %fire
    if size(fire, 2) > 0
      set(firePlot, 'XData', fire(1,:), 'YData', fire(2,:));
    else
      set(firePlot, 'XData', NaN, 'YData', NaN);
    end
    
    %explosions
    for k = 1:size(explosions, 2)
      set(explosionPlots(k), 'XData', explosions(1,k), ...
        'YData', explosions(2,k));
    end
    
    %pups
    %rotate pups and move them to new position
    for k = 1:size(pups,2)
      temp = [get(pupPlots(k), 'XData')' - pups(1,k); ...
        (get(pupPlots(k), 'YData')' - pups(2,k)) - STILL_SPEED];
      
      temp = ROTATION_MATRIX * temp;
      
      set(pupPlots(k), 'XData', temp(1,:) + pups(1,k), ...
        'YData', temp(2,:) + pups(2,k));
    end
    
    %hud
    bottomBarY = HUD_MARGIN + (.5 * HUD_H);
    topBarY = (2 * HUD_MARGIN) + (1.5 * HUD_H);
    set(hudPlots(2), 'XData', [HUD_MARGIN, HUD_MARGIN + ...
      (HUD_W * health)], ...
      'YData', [topBarY, topBarY]);
    set(hudPlots(4), 'XData', [HUD_MARGIN, HUD_MARGIN + ...
      (HUD_W * energy)], ...
      'YData', [bottomBarY, bottomBarY]);
    
    %score
    %we'll update the title displaying the curreent wave and score.
    waveString = sprintf('wave:%d', currentWave);
    scoreString = sprintf('score:%.6d', score);
    set(axisTitle, 'String', [waveString, '   ', scoreString]);
     
  end


%+-----------------------------------------------------------------------+
%|                           UPDATE BARS CBF                             |
%+-----------------------------------------------------------------------+
%update data in energy bar and health bar. this is probably not the best
%place to check if the hero is dead, but since we're checking the health
%level anyway and this runs each frame, its easy to do it here.
%runs every frame
  function updateBars
    if energyCounter == 0
      energy = energy + ENERGY_RESTORE;
      if energy > 1
        energy = 1;
      end
    else
      energyCounter = energyCounter - 1;
    end
    
    if superShoot > 0
      superShoot = superShoot - FRAME_DELAY;
    else
        superShoot = 0;
    end
    
    if ~gameOver
    health = health + HEALTH_RESTORE;
    if health > 1
      health = 1;
    elseif health < 0
      health = 0;
      killHero;
    end
    end
  end



%+-----------------------------------------------------------------------+
%|                             SHOW INTRO CBF                            |
%+-----------------------------------------------------------------------+
%displayes the intro screen in its own loop (so the main game loop isn't 
%running). this function is kind fo weird but i wanted to make it pretty
%independent of the rest of the program because it IS different. unlike
%most of the settings throughout the program that are declared as top-level
%constants, this function uses a lot of its own local variables. so if we
%want to change how intro looks, we should edit settings here. this layout
%is not every elegent, it's very "brute force"-ish, but it allows for
%easy and precise control over the placement of elements on the intro
%screen.
  function showIntro
    
    intro = true;
    t = []; %handles to text boxes
    b = []; %handles to bots
    p = []; %handles to pups
    h = []; %handles for hud bars
    
    %settings that controll element placement
    top = 290;
    padding0 = 10;
    padding1 = 20; %space between lines
    padding2 = 30;
    padding3 = 40;
    labelSpace1 = 10; %space between labels and bots, pups
    labelSpace2 = 5; %space between hud bars and labels
    spacer = 58; %horizontal spacing between bots and pups
    hudIndent = 45;
    
    %how full hud bars are
    shieldFull = .6;
    energyFull = .8;
    
    %locations of text
    welcomeY = top;
    titleY = welcomeY - padding1;
    useY = titleY - padding1;
    killY = useY - padding2;
    botsY = killY - padding3;
    pointsY = botsY - padding0;
    getY = pointsY - padding2;
    pupsY = getY - padding2;
    watchY = pupsY - padding2;
    barsY = watchY - padding1;
    controlsY = barsY - padding2;
    x = PLOT_W/2;
    
    %create text
    t(1) = text(x, welcomeY, 'welcome to');
    t(2) = text(x, titleY, 'ME430 MATLAB SHOOTER');
    t(3) = text(x, useY, 'use joystick to move and shoot');
    t(4) = text(x, killY, 'kill enemies:');
    t(5) = text(x, botsY, 'fighter    destroyer    cruiser');
    t(6) = text(x, pointsY, [num2str(BOT_POINTS(1)), ' pts     ', ...
                           num2str(BOT_POINTS(2)), ' pts     ', ...
                           num2str(BOT_POINTS(3)), ' pts']);
    t(7) = text(x, getY, 'get upgrades:');
    t(8) = text(x, pupsY, 'blaster     shield       bomb ');
    t(9) = text(x, watchY, 'watch bars:');
    t(10) = text(hudIndent + HUD_W + labelSpace2, barsY-1, ['shield', 10, 'energy']);
    t(11) = text(x, controlsY, STR_CONTROLS);
    t(12) = text(x, controlsY - MESSAGE_SPACE, STR_CONTINUE);
    
    %settings for text
    for k = 1:length(t)
      set(t(k), 'HorizontalAlignment', 'Center');
      set(t(k), 'FontName', FONT);
    end
    for k = [1, 3, 4, 7, 9, 11, 12]
      set(t(k), 'Color', WHITE);
      set(t(k), 'FontSize',SMALL_TEXT);
    end
    for k = [5, 6, 8, 10]
      set(t(k), 'Color', WHITE);
      set(t(k), 'FontSize',TINY_TEXT);
    end
    set(t(2), 'FontSize',LARGE_TEXT);
    set(t(2), 'Color', INTRO_COLOR);
    set(t(10), 'HorizontalAlignment', 'Left');
    
    %make bot images
    b(1) = patch(BOT1(1,:) + x - spacer - (BOT_W(1) / 2), ...
      BOT1(2,:) + botsY + labelSpace1, 'w');
    b(2) = patch(BOT2(1,:) + x - (BOT_W(2) / 2), ...
      BOT2(2,:) + botsY + labelSpace1, 'w');
    b(3) = patch(BOT3(1,:) + x + spacer - (BOT_W(3) / 2), ...
      BOT3(2,:) + botsY + labelSpace1, 'w');
    for k = 1:length(b)
      set(b(k), 'LineWidth', SHIP_LINE_WIDTH);
      set(b(k), 'FaceColor', BOT_COLORS(k,:) * FILL_DARKEN);
      set(b(k), 'EdgeColor', BOT_COLORS(k,:));
    end
    
    %make powerup images
    p(1) = patch(PUP(1,:) + x - spacer, ...
      PUP(2,:) + pupsY + labelSpace1 + (PUP_SIZE / 2), 'w');
    p(2) = patch(PUP(1,:) + x, ...
      PUP(2,:) + pupsY + labelSpace1 + (PUP_SIZE / 2), 'w');
    p(3) = patch(PUP(1,:) + x + spacer, ...
      PUP(2,:) + pupsY + labelSpace1 + (PUP_SIZE / 2), 'w');
    for k = 1:length(p)
      set(p(k), 'LineWidth', PUP_LINE_WIDTH);
      set(p(k), 'EdgeColor', PUP_EDGE_COLOR);
      set(p(k), 'FaceColor', PUP_FACE_COLORS(k,:));
    end
    
    %make hud images
    set(hudPlots(1), 'XData', HUD_BAR(1,:) + hudIndent, ...
      'YData', HUD_BAR(2,:) + barsY);
    
    set(hudPlots(3), 'XData', HUD_BAR(1,:) + hudIndent, ...
      'YData', HUD_BAR(2,:) + barsY - HUD_MARGIN - HUD_H);
    
    %y positions for bar fill
    topBarY = barsY + (.5 * HUD_H);
    bottomBarY = topBarY - HUD_MARGIN - HUD_H;
    
    set(hudPlots(2), 'XData', [hudIndent, hudIndent + (shieldFull * HUD_W)], ...
                     'YData', [topBarY, topBarY]);
    set(hudPlots(4), 'XData', [hudIndent, hudIndent + (energyFull * HUD_W)], ...
                     'YData', [bottomBarY, bottomBarY]);
    
    %loop for intro
    while intro && ~quitGame;
      moveStars;
      refreshStarPlot;
      pause(FRAME_DELAY);
      % Added to let the fire button start the game.
      if me430data.needsToFire
          intro = false;
      end
    end
    delete(t(:));
    delete(h(:));
    delete(b(:));
    delete(p(:));
    endIntro;
  end


%+-----------------------------------------------------------------------+
%|                           END INTRO CBF                               |
%+-----------------------------------------------------------------------+
%all this does is redraw the hud bars after the intro
  function endIntro
    set(hudPlots(1), 'XData', HUD_BAR(1,:) + HUD_MARGIN, ...
      'YData', HUD_BAR(2,:) + (2 * HUD_MARGIN) + HUD_H);
    
    set(hudPlots(3), 'XData', HUD_BAR(1,:) + HUD_MARGIN, ...
      'YData', HUD_BAR(2,:) + HUD_MARGIN);
  end


%+-----------------------------------------------------------------------+
%|                            SET WAVE CBF                               |
%+-----------------------------------------------------------------------+
%controlls the flow of the game. there are essentially 6 game states.
%gameOver is after hero dies but before game is restarted.
%paused and intro run in their own loops and are not controleld by this
%function. onBreak, levelOver, and regular gameplay run in the main loop
%and are controlled by this function. 'counter' is a global coutner that
%keeps track of how many frames have elapsed since reset. 'waveCounter'
%is set and compared against 'counter' to control game flow. levelOver
%is after the time for a level has finished but before all bots are killed.
%onBreak is after levelOver and all bots are killed but before next attack
%has started (even thought the current wave increments as soot as onBreak
%begins. WAVE_BREAK and wave durations are in (quasi)seconds. run this
%functione very WAIT_FRAMES.
 function setWave
    count = counter - waveCounter;
    
    if levelOver && (size(bots, 2) == 0)
         levelOver = false;
         onBreak = true;
         waveCounter = counter;
         currentWave = currentWave + 1;
    elseif onBreak && (count > WAVE_BREAK / FRAME_DELAY)
        waveCounter = counter; %reset waveCounter

        onBreak = false; %break's over
    elseif (count > WAVES(currentWave,1) / FRAME_DELAY && ...
        size(WAVES, 1) > currentWave)
      %wave is over
      %take a break
      waveCounter = counter;
      levelOver = true;
      end
    end


%+-----------------------------------------------------------------------+
%|                           MOVE STARS CBF                              |
%+-----------------------------------------------------------------------+
%update star positions based on starSpeeds.
%run each frame.
  function moveStars
    smallStars(2,:) = smallStars(2,:) - starSpeeds;
    bigStars(2,:) = bigStars(2,:) - starSpeeds;
    for k = 1:(NUM_STARS / 2)
      if smallStars(2,k) < 0
        smallStars(1,k) = rand * PLOT_W;
        smallStars(2,k) = PLOT_H;
      end
      if bigStars(2,k) < 0
        bigStars(1,k) = rand * PLOT_W;
        bigStars(2,k) = PLOT_H;
      end
    end
  end


%+-----------------------------------------------------------------------+
%|                           MOVE BULLETS CBF                            |
%+-----------------------------------------------------------------------+
%update bullet positions based on bullet speed.
%run each frame.
  function moveBullets
        
    %use a while loop to make a reverse for loop
    %we need to count down so we dont try to access
    %items at higher index than exist after removal
    k = size(bullets,2);
    while k > 0
      if bullets(2,k) > PLOT_H
        %remove any bullets past top of plot from bullets list
        %miraculously this works even when k is 0 or end
        bullets = [bullets(:,1:k-1), bullets(:,k+1:end)];
      end
      k = k-1;
    end
    
    if size(bullets, 2) > 0
      bullets(2,:) = bullets(2,:) + BULLET_SPEED;
    end
    
  end


%+-----------------------------------------------------------------------+
%|                            MOVE FIRE CBF                              |
%+-----------------------------------------------------------------------+
%update fireball positions based on vector data of each fireball.
%run each frame.
  function moveFire
    
    %use a while loop to make a reverse for loop
    %we need to count down so we dont try to access
    %items at higher index than exist after removal
    k = size(fire,2);
    while k > 0
      if (fire(2,k) > PLOT_H || ...
          fire(2,k) < 0 || ...
          fire(1,k) > PLOT_W || ...
          fire(1,k) < 0)
        %remove out of bounds fire
        fire = [fire(:,1:k-1), fire(:,k+1:end)];
      end
      k = k-1;
    end
    
    if size(fire, 2) > 0
      fire(1:2,:) = fire(1:2,:) + fire(3:4,:);
    end
    
  end


%+-----------------------------------------------------------------------+
%|                            MOVE HERO CBF                              |
%+-----------------------------------------------------------------------+
%update hero position based on hero speed and mouse position.
%run each frame.
  function moveHero
    if ~gameOver
      
      heroSpeed = HERO_SPEED;
      
% ------------------- Original mouse mechanism ---------------------------      
      %tempPos is a 2x3 matrix
      %tempMousePos = get(mainAxis,'CurrentPoint');
      %hold mouse position in a 1x2 matrix
      %mousePos = [tempMousePos(1), tempMousePos(3)];
% -----------------------------------------------------------------------

      % ME430 override
      %fprintf('Using me430data.relativeAnalogPosition (%.3f, %.3f)\n', me430data.relativeAnalogPosition(1), me430data.relativeAnalogPosition(2));
      %xVal = me430data.relativeAnalogPosition(1) * PLOT_W;
      %yVal = me430data.relativeAnalogPosition(2) * PLOT_W;
      minMove = 1;
      scalingFactor = 15;
      xMove = (me430data.relativeAnalogPosition(1) - 0.5) * scalingFactor;
      yMove = (me430data.relativeAnalogPosition(2) - 0.5) * scalingFactor;
      if xMove < minMove && xMove > -minMove
          xMove = 0;
      end
      if yMove < minMove && yMove > -minMove
          yMove = 0;
      end
      xVal = mousePos(1) + xMove;
      yVal = mousePos(2) + yMove;
      if xVal < 0
          xVal = 0;
      end
      if yVal < 0
          yVal = 0;
      end
      if yVal > PLOT_H
          yVal = PLOT_H;
      end
      if xVal > PLOT_W
          xVal = PLOT_W;
      end
      mousePos = [xVal, yVal];
      set(me430data.analogMarker, 'xdata', xVal, 'ydata', yVal);
      
      
      %get vector from ship to mouse
      heroCenter = [heroPos(1) + (HERO_W / 2), heroPos(2) + (HERO_H / 2)];
      tempV = mousePos - heroCenter;
      %magnitude of tempV
      magnitude = (sqrt(tempV(1)^2 + tempV(2)^2));
      if magnitude > heroSpeed
        %normalize the vector
        tempV = tempV ./ magnitude;
        %set new ship position
        heroPos = heroPos + (tempV * heroSpeed);
      else
        %set ship position to mouse position
        heroPos = [mousePos(1) - (HERO_W / 2), mousePos(2) - (HERO_H /2)];
      end
      
      %keep hero within bounds
      if (heroPos(1) < 0)
        heroPos(1) = 0;
      elseif (heroPos(1) > PLOT_W - HERO_W)
        heroPos(1) = PLOT_W - HERO_W;
      end
      if (heroPos(2) < 0)
        heroPos(2) = 0;
      elseif (heroPos(2) > PLOT_H - HERO_H)
        heroPos(2) = PLOT_H - HERO_H;
      end
    end
  end


%+-----------------------------------------------------------------------+
%|                            MOVE BOTS CBF                              |
%+-----------------------------------------------------------------------+
%update bot positions based on vector data for each bot.
%tack (switch direction of) bot2s if appropriate.
%kill out of bounds bots.
%run every frame.
  function moveBots
    k = length(bots);
    while k > 0
      bots{k}.pos = bots{k}.pos + bots{k}.vector;
      switch bots{k}.model
        case 1
          
        case 2
          if (bots{k}.pos(1) > PLOT_W - BOT_W(2))
            bots{k}.pos(1) = PLOT_W - BOT_W(2);
            bots{k}.vector(1) = abs(bots{k}.vector(1)) * -1;
          elseif (bots{k}.pos(1) < 0)
            bots{k}.pos(1) = 0;
            bots{k}.vector(1) = abs(bots{k}.vector(1));
            %use 5 so out of sync with calls to generateBots in main loop
            %for better efficiency
          elseif (mod(counter, WAIT_FRAMES) == 5)
            if (rand < BOT2_TACK_PROB)
              bots{k}.vector(1) = bots{k}.vector(1) * -1;
            end
          end
          
        case 3
      end
      
      %clean up dead bots
      if bots{k}.pos(2) < 0 - BOT_H(bots{k}.model) || ...
         bots{k}.pos(1) < 0 - BOT_W(bots{k}.model) || ...
         bots{k}.pos(1) > PLOT_W
        killBot(k);
      end
      k = k-1;
    end
  end


%+-----------------------------------------------------------------------+
%|                       MOVE EXPLOSIONS CBF                             |
%+-----------------------------------------------------------------------+
%move explosions according to STILL_SPEED.
%expand explosions.
%remove finished explosions.
%run every frame.
  function moveExplosions
    k = size(explosions, 2);
    while k > 0
      oldMarker = get(explosionPlots(k), 'MarkerSize');
      set(explosionPlots(k), 'MarkerSize', ...
        (oldMarker + EXPLOSION_INCREASE));
      explosions(2,k) = explosions(2,k) - STILL_SPEED;
      explosions(3,k) = explosions(3,k) + 1;
      if explosions(3,k) > EXPLOSION_DURATION;
        delete(explosionPlots(k));
        explosionPlots = [explosionPlots(:,1:k-1), ...
          explosionPlots(:,k+1:end)];
        explosions = [explosions(:,1:k-1), ...
          explosions(:,k+1:end)];
      end
      k = k - 1;
    end
  end


%+-----------------------------------------------------------------------+
%|                        MOVE PUPS CBF                                  |
%+-----------------------------------------------------------------------+
%move powerups according to STILL_SPEED.
%remove out of bounds powerups.
%run every frame.
  function movePups
    if size(pups, 2) > 0
      pups(2,:) = pups(2,:) - STILL_SPEED;
    end
    k = size(pups, 2);
    while k > 0
      if pups(2,k) < 0 - 10
        killPup(k);
      end
      k = k-1;
    end
  end


%+-----------------------------------------------------------------------+
%|                         KILL PUP CBF                                  |
%+-----------------------------------------------------------------------+
%remove a powerup.
%called when a pup goes out of bounds or is picked up by hero.
  function killPup (n)
    %remove it from list of pups
    pups = [pups(:,1:n-1), pups(:,n+1:end)];
    %cleare plot
    delete(pupPlots(n));
    %remove plot from list of pup plots.
    pupPlots = [pupPlots(:,1:n-1), pupPlots(:,n+1:end)];
  end


%+-----------------------------------------------------------------------+
%|                          KILL HERO  CBF                               |
%+-----------------------------------------------------------------------+
%make explosions, clear hero plot, set gameOver to true
%set encoreCounter to wait for game over message
%called if health < 0.
  function killHero
    
    if INVINCIBLE
      disp('you died!')
    else
      heroCenter = [heroPos + ([HERO_W, HERO_H] ./ 2)];
      makeExplosion(heroCenter, HERO_COLOR);
      set(heroPlot, 'XData', NaN, 'YData', NaN);
      gameOver = true;
      encoreCounter = floor(ENCORE_DELAY / FRAME_DELAY);
      
      % TODO
      me430data.deaths = me430data.deaths + 1;
      fprintf(me430data.pic, me430data.deaths + me430data.teamNumber);
    end
  end


%+-----------------------------------------------------------------------+
%|                          KILL BOT CBF                                 |
%+-----------------------------------------------------------------------+
%make explosion, clear bot plot, maybe make pup, etc.
%called when a bot leaves bounds or bot health drops to 0.
  function killBot(k)
    %make a new explosion where ship was
    model = bots{k}.model;
    if bots{k}.pos(2) > 0 - BOT_H(model)
      botCenter = bots{k}.pos + ([BOT_W(model), BOT_H(model)] ./ 2);
      makeExplosion(botCenter, BOT_COLORS(model,:));
      if rand < PUP_PROB(model)
        makePup(botCenter, randi([1, 3]));
      end
    end
    %clean up
    %clear plot
    delete(botPlots(k));
    %remove plot from list of botPlots
    botPlots = [botPlots(:,1:k-1), botPlots(:,k+1:end)];
    %remove bot from list of bots
    bots = [bots(:,1:k-1), bots(:,k+1:end)];
    
  end


%+-----------------------------------------------------------------------+
%|                             SHOOT CBF                                 |
%+-----------------------------------------------------------------------+
%controls firing of hero's gun.
%called every frame.
  function shoot
    
    if ~gameOver %no shooting if your dead
      
      %this makes delay between bullets so they dont shoot every frame
      if bulletCounter > 0
        bulletCounter = mod(bulletCounter + 1, BULLET_DELAY);
      %elseif mouseDown
      elseif me430data.needsToFire == 1
        me430data.needsToFire = 0;
        if energy - ENERGY_DRAIN >= 0 %only shoot if have enough energy
          bullets(1, end+1) = heroPos(1) + (HERO_W / 2);
          bullets(2, end) = heroPos(2) + HERO_H;
          if superShoot > 0 %make 2 extra bullets if we have powerup.
            bullets(1, end+1) = heroPos(1) + (HERO_W / 2) + SUPER_SPACE;
            bullets(2, end) = heroPos(2) + HERO_H - SUPER_LAG;
            bullets(1, end+1) = heroPos(1) + (HERO_W / 2) - SUPER_SPACE;
            bullets(2, end) = heroPos(2) + HERO_H - SUPER_LAG;
          end
          bulletCounter = bulletCounter + 1;
          energy = energy - ENERGY_DRAIN; %each shot drains energy
          energyCounter = ENERGY_DELAY; %reset delay until restore enrgy
          if energy < 0
            energy = 0;
          end
        end
      end
    end
  end


%+-----------------------------------------------------------------------+
%|                          BOTS FIRE CBF                                |
%+-----------------------------------------------------------------------+
%shoot fireballs from bots.
%for each bot, is the bot in the middle of a firing burst?
%if it is, fire again and decrement burst count.
%otherwise, decide if bot wants to fire. if so, set firing burst.
%called every WAIT_FRAMES
  function botsFire
    if ~gameOver
      for k = 1:length(bots)
        bot = bots{k};
        if bot.burst > 0;
            makeFire([bot.pos(1) + (BOT_W(bot.model) / 2), ...
            bot.pos(2) + (BOT_H(bot.model) / 2)]);
            bots{k}.burst = bot.burst - 1;
        
        elseif rand < FIRE_PROB(bot.model)
          bots{k}.burst = FIRE_BURST(bot.model);

        end
      end
    end
  end


%+-----------------------------------------------------------------------+
%|                         GENERATE BOTS CBF                             |
%+-----------------------------------------------------------------------+
%use WAVE information to create new bots.
%if were in the middle of a bot1 formation, make another bot1 and
%decrement formation count.
%otherwise decide wether to make a new bot and, if so, what model.
%runse every WAIT_FRAMES
  function generateBots
    
    if formation > 0
      makeBot(1, storedStartX, storedGoalX)
      formation = formation - 1;
      
    elseif ~levelOver && ~onBreak
      waveData = WAVES(currentWave,:);
      if rand < (waveData(2)); %we'll make a bot
        startX = rand * (PLOT_W - max(BOT_W)); %random starting x
        goalX = rand * (PLOT_W - max(BOT_W)); %directed toward random x
        modelSelect = rand;
        if modelSelect < waveData(3) %start a bot1 formation
          storedStartX = startX;
          storedGoalX = goalX;
          formation = randi([MIN_FORMATION, MAX_FORMATION]);
        elseif modelSelect < waveData(4) %make a bot2
          makeBot(2, startX, goalX);
        else %make a bot3
          makeBot(3, startX, goalX);
        end
      end
    end
  end


%+-----------------------------------------------------------------------+
%|                           MAKE BOT CBF                                |
%+-----------------------------------------------------------------------+
%create a new bot based on input model and position
%make appropriate settings to bot.
%make a corresponding plot in botPlots.
%called by generateBots.
  function makeBot(model, startX, goalX)
    %bot vector
   
    if model == 2
      if startX > PLOT_W / 2
        tempV = [-1, -1];
      else
        tempV = [1, -1];
      end
    else
      tempV = [goalX - startX, BOT_END - PLOT_H];
    end
    %normalize it
    normV = tempV ./ (sqrt(tempV(1)^2 + tempV(2)^2));
    %multiply by bot speed
    botV = normV .* BOT_SPEEDS(model);
    
    bots{end+1} = struct( ...
      'model', model, ...
      'pos', [startX, PLOT_H + BOT_START], ...
      'health', BOT_HEALTH(model), ...
      'vector', botV, ...
      'burst', 0);
    %goalX only affects bot1s and bot2s
    %dir only affects bot2s.
    %it determines which tack bot2 is on
    %if startx > middle of plot, set it to -1
    
    if NO_FILL
      tempPlot = plot(NaN, NaN, '-');
      set(tempPlot, 'LineWidth', SHIP_LINE_WIDTH);
      set(tempPlot, 'Color', BOT_COLORS(model,:));
    else
      tempPlot = patch(NaN, NaN, 'w');
      set(tempPlot, 'LineWidth', SHIP_LINE_WIDTH);
      set(tempPlot, 'EdgeColor', BOT_COLORS(model,:));
      set(tempPlot, 'FaceColor', BOT_COLORS(model,:) * FILL_DARKEN);
    end
    %move bot to bottom of visual stack but just above stars
    uistack(tempPlot, 'bottom');
    uistack(tempPlot, 'up', 2);
    botPlots(end+1) = tempPlot;
  end


%+-----------------------------------------------------------------------+
%|                           MAKE PUP CBF                                |
%+-----------------------------------------------------------------------+
%create a new pup based on input position and type
%make a coresponding plot in pupPlots.
%called by killBot.
  function makePup (pos, n)
    pups(:,end+1) = [pos, n];
    tempPlot = patch(PUP(1,:) + pos(1), PUP(2,:) + pos(2), ...
                     PUP_FACE_COLORS(n,:));
    set(tempPlot, 'EdgeColor', PUP_EDGE_COLOR);
    set(tempPlot, 'LineWidth', PUP_LINE_WIDTH);
    pupPlots(end+1) = tempPlot;
  end


%+-----------------------------------------------------------------------+
%|                          MAKE EXPLOSION CBF                           |
%+-----------------------------------------------------------------------+
%create a new explosion based on input position and color
%make a corresponding plot in explosionPlots.
%called by killBot and killHero.
  function makeExplosion (pos, color)
    explosions(:,end+1) = [pos, 0];
    tempPlot = plot(NaN, NaN);
    set(tempPlot, 'Marker', 'o');
    set(tempPlot, 'MarkerSize', EXPLOSION_MIN);
    set(tempPlot, 'MarkerEdgeColor', color);
    set(tempPlot, 'MarkerFaceColor', color * 0.1);
    
    explosionPlots(end+1) = tempPlot;
  end


%+-----------------------------------------------------------------------+
%|                          MAKE FIRE CBF                                |
%+-----------------------------------------------------------------------+
%make a new fireball based on input position.
%fireball vector set to hero position and altered by a small random value.
%called by botsFire.
  function makeFire(pos)
    tempV = [heroPos(1) + (HERO_W / 2), heroPos(2) + (HERO_H / 2)] - pos;
    tempV = [tempV(1) * (1 + (((rand * 2) - 1) * FIRE_VAR)), ...
      tempV(2) * (1 + (((rand * 2) - 1) * FIRE_VAR))];
    %normalize it
    normV = tempV ./ (sqrt(tempV(1)^2 + tempV(2)^2));
    %multiply by fire speed
    fireV = normV .* FIRE_SPEED;
    fire(:,end+1) = [pos(1); pos(2); fireV(1); fireV(2) - STILL_SPEED];
  end


%+-----------------------------------------------------------------------+
%|                         CHECK COLLISIONS CBF                          |
%+-----------------------------------------------------------------------+
%check for collisions between (bots, hero), (bots, bullets), (fire, hero),
%and (pups, hero).
%uses separate hitTest function. 
%carries out appropriate actions if collision detected.
%run every frame.
  function checkCollisions
    %cycle through bots
    bot = size(bots,2);
    while bot > 0
%------------------------ CHECK BOTS AGAINST HERO ------------------------
      %if bot collides with hero, kill both
      if hitTest(heroPos(1), heroPos(2), HERO_W, HERO_H, ...
          bots{bot}.pos(1), bots{bot}.pos(2), ...
          BOT_W(bots{bot}.model), BOT_H(bots{bot}.model))
        
        if ~gameOver
          killBot(bot);
          health = health - COLLISION_DAMAGE;

        end
      else
        %bot didnt colide with hero, check if it hit each bullet
        bul = size(bullets,2);
        while bul > 0
%----------------------- CHECK BOTS AGAINST BULLETS ----------------------
          if hitTest(bots{bot}.pos(1), bots{bot}.pos(2), ...
              BOT_W(bots{bot}.model), BOT_H(bots{bot}.model), ...
              bullets(1,bul), bullets(2,bul))
            
            bullets(2,bul) = PLOT_H + 1;
            bots{bot}.health = bots{bot}.health - 1;
            %if bot out of health, kill bot. break loop and go to next bot.
            if bots{bot}.health <= 0
              %update score
              if ~INVINCIBLE %no points for cheaters!
                score = score + BOT_POINTS(bots{bot}.model);
              end
              killBot(bot);
              bul = 0;
            end
          end
          %decrement bullet counter.
          bul = bul-1;
        end
      end
      %decrement bot counter.
      bot = bot - 1;
    end
%------------------------- CHECK FIRE AGAINST HERO -----------------------
    if ~gameOver
      f = size(fire, 2);
      while f > 0
        if hitTest(heroPos(1), heroPos(2), HERO_W, HERO_H, ...
            fire(1,f), fire(2,f))
          %decrement health due to collision with fireball
          health = health - FIRE_DAMAGE;
          makeExplosion([fire(1,f), fire(2,f)], FIRE_FACE_COLOR);
          fire(2,f) = 0 - 1;
        end
        f = f-1;
      end
    end
    
%------------------------- CHECK PUPS AGAINST HERO -----------------------
if ~gameOver
  p = size(pups, 2);
  while p > 0
    if hitTest(heroPos(1), heroPos(2), HERO_W, HERO_H, ...
        pups(1,p), pups(2,p))
      %hero picked up a powerup. no carry out appropriate action
      switch pups(3,p)
        case 1 %superShoot powerup
          superShoot = SUPER_SHOOT_DURATION;
        case 2 %shield boost
          health = health + HEALTH_BOOST;
          if health > 1
            health = 1;
          end
        case 3 %bomb. kill all bots
          k = size(bots,2);
          while k > 0
            killBot(k);
            k = k-1;
          end
          
      end          
          killPup(p); %remove the pup after collision with hero.

    end
    p = p-1;
  end
end

  end %end cbf



%+-----------------------------------------------------------------------+
%|                           PAUSE GAME CBF                              |
%+-----------------------------------------------------------------------+
%run a loop separate from the main game loop.
%display paused message.
%called when player hits a key.
%ends when player hits a key.
  function pauseGame()
    paused = true;
    
    encoreText(1) = text(0, 0, STR_PAUSED);
    set(encoreText(1), 'Position', [PLOT_W/2, MESSAGE_Y]);
    set(encoreText(1), 'Color', PAUSE_COLOR);
    set(encoreText(1), 'HorizontalAlignment', 'Center');
    set(encoreText(1), 'FontSize', LARGE_TEXT,'FontName', FONT);
    encoreText(2) = text(0, 0, [STR_CONTROLS 10 10 STR_CONTINUE]);
    set(encoreText(2), 'Position', [PLOT_W/2, MESSAGE_Y - MESSAGE_SPACE]);
    set(encoreText(2), 'Color', WHITE);
    set(encoreText(2), 'HorizontalAlignment', 'Center');
    set(encoreText(2), 'VerticalAlignment', 'Top');
    set(encoreText(2), 'FontSize',SMALL_TEXT,'FontName', FONT);
    while paused;
      pause(FRAME_DELAY);
      if me430data.needsToFire
        paused = false;
      end
    end
    delete(encoreText(:));

  end


%+-----------------------------------------------------------------------+
%|                            ENCORE CBF                                 |
%+-----------------------------------------------------------------------+
%display game over message
%encoreCounter was set on gameOver.
%If it gets down to 1, its time to display the game over message
%use global handles so message can be cleared by reset.
  function encore
    if encoreCounter > 0
      encoreCounter = encoreCounter - 1;
      if encoreCounter == 0
        encoreText(1) = text(0, 0, STR_OVER);
        set(encoreText(1), 'Position', [PLOT_W/2, MESSAGE_Y]);
        set(encoreText(1), 'Color', OVER_COLOR);
        set(encoreText(1), 'HorizontalAlignment', 'Center');
        set(encoreText(1), 'FontSize', LARGE_TEXT,'FontName', FONT);
        encoreText(2) = text(0, 0, STR_CONTINUE);
        set(encoreText(2), 'Position', [PLOT_W/2, MESSAGE_Y - MESSAGE_SPACE]);
        set(encoreText(2), 'Color', WHITE);
        set(encoreText(2), 'HorizontalAlignment', 'Center');
        set(encoreText(2), 'FontSize',SMALL_TEXT,'FontName', FONT);
      end

    end

  end


%+-----------------------------------------------------------------------+
%|                        USER INTERFACE LISTENERS                       |
%+-----------------------------------------------------------------------+
  function keyDownListener(src,event)    
    switch event.Key
      case 'r'
        reset;
      case 'q'
        paused = false;
        quitGame = true;
      otherwise
        if intro
          intro = false;
        elseif gameOver
          reset;
        elseif paused
          paused = false;
        else
          pauseGame;
        end
    end
  end

  function mouseDownListener(src,event);
    %     if intro
    %       intro = false;
    %     elseif gameOver
    %       reset;
    %     else
    mouseDown = true;
    %    end
  end

  function mouseUpListener(src,event);
    mouseDown = false;
  end

  function mouseMoveListener(src, event)
    %no body.
    %this handler must be registerd for axis 'CurrentPoint' to be
    %updated when mouse moves.
  end

%redefinition of CloseRequestFcn
%so don't get stuck in loop if close window while paused
%probably don't want to modify this.
  function my_closefcn(src, event)
    paused = false; %this is the only modification to the default definition
    if isempty(gcbf)
      if length(dbstack) == 1
        warning('MATLAB:closereq', ...
          'Calling closereq from the command line is now obsolete, use close instead');
      end
      close force
    else
      if (isa(gcbf,'ui.figure'))
        % Convert GBT1.5 figure to a double.
        delete(double(gcbf));
      else
        delete(gcbf);
      end
    end
  end




%+-----------------------------------------------------------------------+
%|                             MAIN SCRIPT                               |
%+-----------------------------------------------------------------------+
open_ports=instrfind('Type','serial','Status','open');
if ~isempty(open_ports)
     fclose(open_ports);
end
me430data.pic = openSerial(portNumber);
fprintf(me430data.pic, me430data.deaths + me430data.teamNumber);

createFigure; %set up the figure
createPlots; %make all permanent plots
reset; %set variables to starting values. 

me430data.analogMarker = plot(mainAxis, PLOT_W/2, PLOT_W/2, 'b+');

while ~quitGame
  moveStars;
  moveHero;
  moveBots;
  moveFire;
  moveBullets;
  moveExplosions;
  movePups;
  shoot;
  checkCollisions;
  updateBars; %set data for hud bars. kill hero if health < 0.
  encore;
  refreshPlots; %set data in all the plots
  counter = counter + 1; %increment main game counter.
  %here's things that can happen every WAIT_FRAMES staggered in execution
  f = (mod(counter, WAIT_FRAMES));
  if f == 0
    if ~gameOver
      if ~INVINCIBLE %no points for cheaters!
        score = score + 1;
      end
      setWave;
    end
  elseif f == 4
    generateBots;
  elseif f == 6
    botsFire
  end
  pause(FRAME_DELAY); %freeze program for each frame.
  if gameOver
    if me430data.needsToFire
      me430data.needsToFire = 0; % Don't reuse the same fire to restart.
      reset
    end
  end
end
close(fig);

end


% --------------------- Moved into this file -----------------------------

%input: x, y, width, height for one rectangle,
%       EITHER x, y, for test point
%       OR, x, y, width, height, for test rectangle

function [hit] = hitTest (x1, y1, w1, h1, x2, y2, varargin)
if size(varargin, 2) == 0
  w2 = 0;
  h2 = 0;
elseif size(varargin, 2) == 2
  w2 = varargin{1};
  h2 = varargin{2};
end

hit = (x2 + w2) > x1 && ...
  x2 < (x1 + w1) && ...
  (y2 + h2) > y1 && ...
  y2 < (y1 + h1);
end



% -------------------------------------------------------------------------
% ------------------------ ME430 Added ------------------------------------
% -------------------------------------------------------------------------


function serialObj = openSerial(portNumber)
portStr = sprintf('COM%d',portNumber);
fprintf('Connecting to %s...',portStr);
serialObj = serial(portStr, 'BaudRate', 9600,...
    'TimeOut',0.2,...
    'BytesAvailableFcnMode','byte',...
    'BytesAvailableFcnCount',1,...
    'BytesAvailableFcn',@serial_PICDEM_BytesAvailableFcn);
fprintf('Status is %s\n',serialObj.Status);
fprintf('Opening...');
fopen(serialObj);
fprintf('Status is %s\n',serialObj.Status);
end

function serial_PICDEM_BytesAvailableFcn(serialObj, eventData)
%serial_PICDEM_BytesAvailableFcn bytes from serial object
%  This is the callback function after a 'terminator' is received
global me430data;

%fprintf(' .\n');
numBytes = get(serialObj, 'BytesAvailable');
if (numBytes > 0)
    receivedData = fread(serialObj, numBytes, 'uint8');
    for i = 1:numBytes
        singleByte = receivedData(i);
        receivedTeam = bitand(singleByte, hex2dec('F0'));
        %fprintf('receivedTeam = %d\n', receivedTeam);
        %fprintf('teamNumber = %d\n', me430data.teamNumber);
        if (receivedTeam == me430data.teamNumber)
          singleByte = singleByte - me430data.teamNumber;
          handleSingleByte(singleByte);
        end
    end    
end
end


function handleSingleByte(singleByte)
% Constants for fake enums.
READY = 0;
READY_FOR_HORZ_VALUE_1 = 1;
READY_FOR_HORZ_VALUE_2 = 2;
READY_FOR_HORZ_VALUE_3 = 3;
READY_FOR_HORZ_VALUE_4 = 4;
READY_FOR_VERT_VALUE_1 = 5;
READY_FOR_VERT_VALUE_2 = 6;
READY_FOR_VERT_VALUE_3 = 7;
READY_FOR_VERT_VALUE_4 = 8;
RA0_HORZ_PREFIX = 10;
RA1_VERT_PREFIX = 11;
BUTTON_PRESS = 12;
persistent rxState;
persistent horzValues;
persistent vertValues;
global me430data;

switch singleByte
    case RA0_HORZ_PREFIX
        rxState = READY_FOR_HORZ_VALUE_1;
    case RA1_VERT_PREFIX
        rxState = READY_FOR_VERT_VALUE_1;
    case BUTTON_PRESS
        rxState = READY;
        me430data.needsToFire = 1;
    otherwise
        if (singleByte >= 0 && singleByte <= 9)
            switch rxState
                case READY_FOR_HORZ_VALUE_1
                    horzValues(1) = singleByte;
                    rxState = READY_FOR_HORZ_VALUE_2;
                case READY_FOR_HORZ_VALUE_2
                    horzValues(2) = singleByte;
                    rxState = READY_FOR_HORZ_VALUE_3;
                case READY_FOR_HORZ_VALUE_3
                    horzValues(3) = singleByte;
                    rxState = READY_FOR_HORZ_VALUE_4;
                case READY_FOR_HORZ_VALUE_4
                    horzValues(4) = singleByte;
                    rxState = READY;
                    horzValue = horzValues(1) * 1000 + horzValues(2) * 100 + horzValues(3) * 10 + horzValues(4);
                    me430data.relativeAnalogPosition(2) = horzValue/1023;
                case READY_FOR_VERT_VALUE_1
                    vertValues(1) = singleByte;
                    rxState = READY_FOR_VERT_VALUE_2;
                case READY_FOR_VERT_VALUE_2
                    vertValues(2) = singleByte;
                    rxState = READY_FOR_VERT_VALUE_3;
                case READY_FOR_VERT_VALUE_3
                    vertValues(3) = singleByte;
                    rxState = READY_FOR_VERT_VALUE_4;
                case READY_FOR_VERT_VALUE_4
                    vertValues(4) = singleByte;
                    rxState = READY;
                    vertValue = vertValues(1) * 1000 + vertValues(2) * 100 + vertValues(3) * 10 + vertValues(4);
                    me430data.relativeAnalogPosition(1) = vertValue/1023;
            end
        end
end
end