#pragma once
#include "stdafx.h"
#include "common.h"
#include <list>
using namespace std;

#define ORB_RADIUS  32
#define ORB_TOUCHING_DISTANCE2 ((ORB_RADIUS*2)*(ORB_RADIUS*2))

class Orb
{
private:
    bool    falling;
    static const int touchingDistanceSquared = 
                     ORB_TOUCHING_DISTANCE2;
    static RECTF BoundingBox;
    OrbColor color;
    PointF position;
    PointF velocity;
public:
    static const int radius = ORB_RADIUS;
    Orb(OrbColor color, float x, float y);
    void SetVelocity(float x, float y);
    void GetVelocity(PointF* vel);
        
    void GetPosition(PointF* pos);
    OrbColor GetColor();
    bool IsTouching(Orb* otherOrb);
    
    void Step(float timeUnit);

    bool IsFalling() {return falling;};
    void SetFalling();
    bool IsMoving() {return (velocity.x!=0)||(velocity.y!=0);}    
    
    PointF GetPosition() { return position; }
};

#pragma once
#include "stdafx.h"
#include <list>
#include "common.h"
#include "Orb.h"

#include "GameController.h"

using namespace std;

#define PLAY_AREA_SIZE 512

class PlayArea
{
private:
    list<orb*> orbList;
    list<orb*> orbDestructionList;
    GameController* gameController;
    Orb* loadedOrb;
    Orb* movingOrb;
    int        GetColorsInPlay();
    OrbColor        nextOrbColor;

public:
    PlayArea(GameController* controller)
      {orbList;gameController=controller;loadedOrb=NULL;movingOrb = NULL;}
            PlayArea(int playAreaSize);
    Orb*    PlaceOrb(OrbColor color, float x, float y);

    void    LoadOrb(OrbColor color);

    void    SetCannonAngle(float angle);
    void    IncrementAngle(float incrementAmount);

    void    LoadLevel(LPWSTR levelData);

    list<orb*>*    GetOrbList() { return &orbList; }
    Orb*    GetLoadedOrb() { return loadedOrb; }
    Orb*    GetMovingOrb() { return movingOrb; }
    void    FireOrb(float angle);
    void    StopMovingOrb();

    REQUIRESDELETE    MyOrbList*    GetIntersectingOrbList(Orb*);
    OrbColor GetNextOrbColor() { return nextOrbColor; }
    void    SelectNextColor();
    REQUIRESDELETE    list<Orb*>*    PlayArea::GetMatchingSet(Orb* targetOrb);
    list<Orb*>*    GetSuspendedOrbs();
    //void    DestroyOrbs(OrbLink* orbList);
    void    DestroyOrb(Orb* target);
    void Clear();

    int        GetOrbCount();
    Orb*    GetLowestOrb();

};

current->GetPosition(&orb2Position);
movingOrb->GetPosition(&orb1Position);
float dx = orb2Position.x-orb1Position.x;
float dy = orb2Position.y-orb1Position.y;

//Get the distance by which we need to move the orb backwards
float targetDistance = Orb::radius*2-(float)sqrt((double)(dx*dx+dy*dy));

if(targetDistance!=0.0)
{
    //get the (linear) speed of the ball
    movingOrb->GetVelocity(&velocity);
    float speed = (float)sqrt((velocity.x*velocity.x)+
                              (velocity.y*velocity.y));
    
    //calculate the needed time over which the reverse velocity should be applied
    float adjTime = targetDistance/speed;
    //reverse the velocity
    movingOrb->SetVelocity(-velocity.x,-velocity.y);
    //Step Backwards
    movingOrb->Step(adjTime);
    //undo the reverse velocity
    movingOrb->SetVelocity(velocity.x,velocity.y);
    
}

#pragma once
#include "Stdafx.h"
#include "common.h"

#define MAX_CONTROLLER_ANGLE 80.0f
//    The GameController represents the information that we 
//    need to get from the player (as opposed to a physical
//    controller). New methods of interaction added to the
//    game should manipulate this class. This layer of 
//    separation allows for easier adaptation to new control
//    methods reducing/removing the need to modify game logic
//    for a new controller type.
class GameController
{
private:
    float angle ;
    bool actionButtonPressed;

    void CheckAngleBoundaries();
public:
            GameController();
    float    IncrementAngle(float amount);
    float    GetAngle();
    float    GetAngleRad();

    float    SetAngle(float newAngle);

    void    PressActionButton();
    void    ClearActionButton();

    bool IsActionButtonPressed();
};

#pragma once
#include "stdafx.h"
#include "common.h"
#include "PlayArea.h"

#include "Orb.h"
#include "DisplayList.h"
#include "OrbRenderer.h"

class PlayAreaRenderer
{
private:
    OrbRenderer* orbRenderer;
    PlayArea* playArea;
    DisplayList* displayList;
    GameController* gameController;

public:
    PlayAreaRenderer(OrbRenderer * or, PlayArea* pa, 
                     GameController *gc, DisplayList* dl)
    {
        playArea = pa;
        orbRenderer = or;
        displayList = dl;
        gameController = gc;
    }

    void Render();
    
};

#pragma once
#include "stdafx.h"
#include "common.h"

struct DisplayItem
{
    RECT    itemSource;
    RECT    itemDestination;
};

class DisplayList
{
private:
    DisplayItem    itemList[100];
    int itemCount;
public:
            DisplayList(){itemCount=0;}
    void    Clear() {itemCount=0;}
    void    AddItem(RECT* itemSource, RECT* itemDestination);
    void    Render(IDirectDrawSurface* spriteSource, 
                   IDirectDrawSurface* destinationSurface, POINT offset);
};

#pragma once
#include "Stdafx.h"
#include "common.h"
#include "SmiHaptics.h"

class GameEventFeedback
{
    SmiHapticsNote    launchNote[1];

    bool hasNotificationLed;
    bool canBlink;
    bool hasHapticFeedback;
    SMI_HAPTICS_HANDLE hapticsHandle;
public:
    GameEventFeedback();
    ~GameEventFeedback();

    void    OrbFired();
    void    NextColorDecided(OrbColor);
    void    OrbStopped();
    void    ColorMatchMade();
};

OrbRenderer::OrbRenderer(
        float logicalPlayAreaSize, 
        float logicalOrbRadius, 
        float physicalPlayAreaSize, 
        DisplayList* displayList)
{
    this->targetDisplayList=displayList;
    logicalSize = logicalPlayAreaSize;
    this->scalingFactor = physicalPlayAreaSize/logicalPlayAreaSize ;
    destinationOrbSize.x=destinationOrbSize.y= 
              (int)logicalOrbRadius*2.0f*scalingFactor;
    destinationOrbRadius = destinationOrbSize.x/2;
    if(destinationOrbSize.x>=48)
    {
        sourceOrigin.x=0;
        sourceOrigin.y=0;
        orbDisplacement.x=64;
        orbDisplacement.y=0;
        orbImageSize.x=orbImageSize.y=64;
    }
    else if (destinationOrbSize.x>=24)
    {
        sourceOrigin.x=0;
        sourceOrigin.y=64;
        orbDisplacement.x=32;
        orbDisplacement.y=0;
        orbImageSize.x=orbImageSize.y=32;
    }
    else if (destinationOrbSize.x>=12)
    {
        sourceOrigin.x=0;
        sourceOrigin.y=96;
        orbDisplacement.x=16;
        orbDisplacement.y=0;
        orbImageSize.x=orbImageSize.y=16;
    }
    else
    {
        sourceOrigin.x=0;
        sourceOrigin.y=112;
        orbDisplacement.x=8;
        orbDisplacement.y=0;
        orbImageSize.x=orbImageSize.y=8;
    }    
}

 HRESULT WINAPI DirectDrawCreate(
  GUID FAR* lpGUID, 
  LPDIRECTDRAW FAR* lplpDD, 
  IUnknown FAR* pUnkOuter
); 

HRESULT SetCooperativeLevel(
  HWND hWnd, 
  DWORD dwFlags
);

HRESULT CreateSurface(
  LPDDSURFACEDESC lpDDSurfaceDesc, 
  LPDIRECTDRAWSURFACE FAR* lplpDDSurface, 
  IUnknown FAR* pUnkOuter 
);

case VK_UP:
    {
        UINT scanCode = (lParam & 0x00FF0000) >> 16;
        if(TRUE == SmiKeyMsgIsFromWheelKey(wParam,scanCode))
        {
           // Message is from wheelkey rotation
            g_gameController->IncrementAngle(-5);
            
        }
    }
    break;
case VK_DOWN:
    {
        UINT scanCode = (lParam & 0x00FF0000) >> 16;
        if(TRUE == SmiKeyMsgIsFromWheelKey(wParam,scanCode))
        {
           //Message is from Wheelkey Rotation
            g_gameController->IncrementAngle(5);
        }
    }
    break;

SmiAccelerometerCapabilities accelCaps;    
g_hasAccelerometer = (SMI_SUCCESS == SmiAccelerometerGetCapabilities(&accelCaps));

DWORD GetScreenOrientation()
{
    DWORD retVal ;
    HKEY hKey;
    DWORD dataSize = sizeof(DWORD);
    RegOpenKeyEx(HKEY_LOCAL_MACHINE,TEXT("System\\GDI\\Rotation"),NULL,NULL,&hKey);
    RegQueryValueEx(hKey,TEXT("Angle"),NULL,NULL,(LPBYTE)&retVal, &dataSize);
    RegCloseKey(hKey);
    return retVal;
}

if(g_hasAccelerometer)
{
    SmiAccelerometerVector vect,rotatedVect;
    if(SMI_SUCCESS==SmiAccelerometerGetVector(&vect))
    {
        switch(screenOrientation)
        {
        case 0:
            rotatedVect = vect;
            break;
        case 90:
            rotatedVect.x=-vect.y;
            rotatedVect.y=vect.x;
            rotatedVect.z=vect.z;
            break;
        case 180:
            rotatedVect.x=-vect.x;
            rotatedVect.y=-vect.y;
            rotatedVect.z=vect.z;
            break;
        case 270:
            rotatedVect.x=vect.y;
            rotatedVect.y=-vect.x;
            rotatedVect.z=vect.z;
            break;
        }
        float angle;
        float absAngle;
        float distance;
        if(rotatedVect.y==0)
            angle = 0;
        else
        {
            angle = -atan(rotatedVect.x / rotatedVect.y);
            angle = (angle/(2*3.141592))*360.0;
        }
        g_gameController->SetAngle(angle);
    }
}

void GameEventFeedback::NextColorDecided(OrbColor color)
{
    SmiLedAttributes attrib;
    switch(color)
    {
        
        case Orb_Red: attrib.color=RGB(0xFF,0x00,0x00);    break;
        case Orb_Yellow: attrib.color=RGB(0xFF,0xFF,0x00);    break;
        case Orb_Green:    attrib.color=RGB(0x00,0xFF,0x00);    break;
        case Orb_Blue:    attrib.color=RGB(0x00,0x00,0xFF);    break;
        case Orb_Teal:    attrib.color=RGB(0x00,0xFF,0xFF);    break;
        case Orb_Purple: attrib.color=RGB(0xFF,0x00,0xFF);    break;
        case Orb_White:    attrib.color=RGB(0xFF,0xFF,0xFF);    break;
        default:    attrib.color=0;break;
    };
    attrib.onTime=750;
    attrib.offTime=250;
    attrib.duration=4000;
    attrib.pattern= SMI_LED_PATTERN_SOLID;
    SmiLedTurnOn(SMI_LED_ID_NOTIFICATION,&attrib);
}

SmiHapticsNote    launchNote[1];    //Haptic note array of one element

GameEventFeedback::GameEventFeedback()
{
    hapticsHandle=NULL;
    SmiLedCapabilities ledCaps;
    SmiHapticsCapabilities hapticCaps;

    SMI_RESULT result;
    result = SmiLedGetCapabilities(SMI_LED_ID_NOTIFICATION,&ledCaps);
    if(result==SMI_SUCCESS)
    {
        

        hasNotificationLed = true;
        canBlink = ledCaps.blinkIsSupported;
    }
    result = SmiHapticsGetCapabilities(&hapticCaps);
    if(SMI_SUCCESS==result)
    {
       //Haptic feedback hardware is present
        if(SMI_SUCCESS==SmiHapticsOpen(&hapticsHandle))
        {
           //Open a handle to the haptic feedback
           //device and populate the note data 
           //according to the hardware's capability
            hasHapticFeedback = true;

            launchNote[0].duration=max(hapticCaps.minPeriod,400);
            launchNote[0].magnitude=255;
            if(hapticCaps.startEndMagIsSupported)
            {
                launchNote[0].startingMagnitude=64;
                launchNote[0].endingMagnitude=255;
            }
                launchNote[0].period=max(hapticCaps.minPeriod,0.);
            if(hapticCaps.noteStyleIsSupported)
                launchNote[0].style=SMI_HAPTICS_NOTE_STYLE_STRONG;
        }
        else
        {
            hasHapticFeedback = false;
        }
    }
}

void GameEventFeedback::OrbFired()
{
    SmiHapticsPlayNotes(hapticsHandle,1,launchNote,FALSE,NULL);
}

void GameEventFeedback::OrbStopped()
{
    SmiHapticsPlayNotes(hapticsHandle,1,launchNote,FALSE,NULL);
}

//if an optical mouse is present then 
//ensure it is in navigation mode. 
SmiOpticalMouseCapabilities mouseCaps;
//Get the optical mouse capabilities
SmiOpticalMouseGetCapabilities(&mouseCaps);
// if a mouse pad is present
if(mouseCaps.multiOperationModeIsSupported)
{
    //ensure the mouse pad is in navidation mode
    SmiOpticalMouseSetMode(SMI_OPTICAL_MOUSE_MODE_NAVIGATION);
}

while(keepRunning)
{
   if(g_bHasFocus)
   {
      if(PeekMessage(&msg,NULL,0,0,TRUE))
      {
         if(msg.message==WM_QUIT)
            keepRunning=false;
         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
         {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
         }
      }
      else
      {
         //Execute Game Logic Here
         
         //Relinquish control of the processor but 
         //stay on queue of threads ready to run
         //within the thread scheduler
         Sleep(0);
      }
   }
   else
   {
      if(GetMessage(&msg,NULL,0,0))
      {
         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
         {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
         }
      }
   }
}