PC World Komputer 1996 December/PCWKCD1296.iso/vjplusb/activex/inetsdk/samples/axscript/spruuids/src/sproa.cpp

C/C++ Source or Header | 1996-07-15 | 23.0 KB | 1,036 lines

//---------------------------------------------------------------------------
// SprOA.cpp
//---------------------------------------------------------------------------
// Sprite handler, OLE Automation support
//---------------------------------------------------------------------------
// (C) Copyright 1992-1996 by Microsoft Corporation.  All rights reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//---------------------------------------------------------------------------

#include "Main.h"
#include "Spr.h"
#include "DispIDs.h"
#include <math.h>


//---------------------------------------------------------------------------
// DEBUG info
//---------------------------------------------------------------------------
SZTHISFILE


//***************************************************************************
//***************************************************************************
//**
//**  SpriteClass Class
//**
//***************************************************************************
//***************************************************************************


//***************************************************************************
// Fire ISpriteClassEvents Events
//***************************************************************************

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void CSpriteClass::FireInit
(
  CSprite *pspr,
  VARIANT *pvarUser
)
{
  IDispatch **ppdisp = m_cp.m_rgpdisp;
  VARIANTARG  var[2];

  VariantInit(&var[1]);
  var[1].vt = VT_DISPATCH;
  var[1].pdispVal = pspr->GetDispatch();
  pspr->AddRef();
  VariantInit(&var[0]);
  VariantCopy(&var[0], pvarUser);

  for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
    if (*ppdisp)
      InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Init, var, 2);

  pspr->Release();    // For var[1].pdispVal
  VariantClear(&var[0]);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void CSpriteClass::FireTick
(
  CSprite *pspr
)
{
  IDispatch **ppdisp = m_cp.m_rgpdisp;
  VARIANTARG  var[1];

  VariantInit(&var[0]);
  var[0].vt = VT_DISPATCH;
  var[0].pdispVal = pspr->GetDispatch();
  pspr->AddRef();

  for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
    if (*ppdisp)
      InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Tick, var, 1);

  pspr->Release();    // For var[0].pdispVal
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void CSpriteClass::FireBorder
(
  CSprite *pspr,
  BRD      brd
)
{
  IDispatch **ppdisp = m_cp.m_rgpdisp;
  VARIANTARG  var[2];

  VariantInit(&var[1]);
  var[1].vt = VT_DISPATCH;
  var[1].pdispVal = pspr->GetDispatch();
  pspr->AddRef();
  VariantInit(&var[0]);
  var[0].vt = VT_I4;
  var[0].lVal = brd;

  for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
    if (*ppdisp)
      {
      BOOL f;
      HRESULT hr = InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Border, var, 2);
      if (hr)
        f = TRUE;
      }

  pspr->Release();    // For var[1].pdispVal
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void CSpriteClass::FireTerm
(
  CSprite *pspr
)
{
  IDispatch **ppdisp = m_cp.m_rgpdisp;
  VARIANTARG  var[1];

  VariantInit(&var[0]);
  var[0].vt = VT_DISPATCH;
  var[0].pdispVal = pspr->GetDispatch();
  pspr->AddRef();

  for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
    if (*ppdisp)
      InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Term, var, 1);

  pspr->Release();    // For var[0].pdispVal
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void CSpriteClass::FireLastTerm
(
  void
)
{
  IDispatch **ppdisp = m_cp.m_rgpdisp;

  for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
    if (*ppdisp)
      InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_LastTerm, NULL, 0);
}


//***************************************************************************
// ISpriteClass Interface
//***************************************************************************

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Application
(
  ISpruuidsApp** ppRet
)
{
  if (!ppRet)
    return E_INVALIDARG;
  return g_punkApplicationNA->QueryInterface(IID_ISpruuidsApp, (void **)ppRet);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Parent
(
  IGame** ppRet
)
{
  if (!ppRet)
    return E_INVALIDARG;
  return m_pdisp->m_punkParent->QueryInterface(IID_IGame, (void **)ppRet);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::CreateSprite
(
  int       x,
  int       y,
  VARIANT   arg,
  ISprite **ppRet
)
{
  CSprite *pspr = new CSprite(this, x, y, NULL, &arg);
  if (!pspr)
    return E_OUTOFMEMORY;
  *ppRet = pspr;
  (*ppRet)->AddRef();
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Tag
(
  VARIANT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  VariantInit(pRet);
  return VariantCopy(pRet, &m_varTag);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_Tag
(
  VARIANT val
)
{
  return VariantCopy(&m_varTag, &val);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Image
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_iimg;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_Image
(
  int val
)
{
  if (val > 0 && val < m_pdisp->m_cimg)
    m_iimg = val;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Border
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_brd;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_Border
(
  int val
)
{
  m_brd = val;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Collide
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_maskCollide;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_Collide
(
  int val
)
{
  m_maskCollide = val;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_MaximumVelocity
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_vFullMax);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_MaximumVelocity
(
  FLOAT val
)
{
  m_vFullMax = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_Friction
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_friction;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_Friction
(
  FLOAT val
)
{
  m_friction = val;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_MaximumAcceleration
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_aFullMax);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_MaximumAcceleration
(
  FLOAT val
)
{
  m_aFullMax = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_AccelerationFriction
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_frictionAccel;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::put_AccelerationFriction
(
  FLOAT val
)
{
  m_frictionAccel = val;
  m_fFrictionAccel = (val != (FLOAT)1.0);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSpriteClass::get_SpriteCount
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_cspr;
  return S_OK;
}



//***************************************************************************
//***************************************************************************
//**
//**  Sprite Class
//**
//***************************************************************************
//***************************************************************************


//***************************************************************************
// ISprite Interface
//***************************************************************************

//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Application
(
  ISpruuidsApp** ppRet
)
{
  if (!ppRet)
    return E_INVALIDARG;
  return g_punkApplicationNA->QueryInterface(IID_ISpruuidsApp, (void **)ppRet);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Parent
(
  ISpriteClass** ppRet
)
{
  if (!ppRet)
    return E_INVALIDARG;
  return m_psc->QueryInterface(IID_ISpriteClass, (void **)ppRet);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::MoveTo
(
  FLOAT x,
  FLOAT y
)
{
  this->MoveToFull(FULLOFFLOAT(x), FULLOFFLOAT(y), TRUE);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::MoveBy
(
  FLOAT dx,
  FLOAT dy
)
{
  this->MoveByFull(FULLOFFLOAT(dx), FULLOFFLOAT(dy), TRUE);
  return S_OK;
}



//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::MoveAtSprite
(
  ISprite* sprite,
  float    dMax,
  float    scale,
  long     flags
)
{
  if (!sprite)
    return E_INVALIDARG;

  // Store parameters & do every tickMove ticks if MAS_REMEMBER set.
  if (flags & MAS_REMEMBER)
    {
    if (m_psprAt)
      {
      m_psprAt->Release();
      m_psprAt = NULL;
      }
    m_psprAt = (CSprite *)(void *)sprite;
    if (!m_psprAt)
      return S_OK;
    m_psprAt->AddRef();
    m_dMaxAt = dMax;
    m_scaleAt = scale;
    m_flagsAt = flags;
    return S_OK;
    }

  // Otherwise, do this right now.
  this->DoMoveAt((CSprite *)(void *)sprite, dMax, scale, flags, FALSE);
  return S_OK;
}



//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::Remove
(
  void
)
{
  this->MarkFree();
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::Refresh
(
  void
)
{
  this->_FDraw(FALSE);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::IgnoreMove
(
  void
)
{
  m_fIgnoreMove = TRUE;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Left
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_xFull);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Left
(
  FLOAT val
)
{
  m_xFull = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Top
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_yFull);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Top
(
  FLOAT val
)
{
  m_yFull = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Vx
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_vxFull);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Vx
(
  FLOAT val
)
{
  m_vxFull = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Vy
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_vyFull);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Vy
(
  FLOAT val
)
{
  m_vyFull = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Ax
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_axFull);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Ax
(
  FLOAT val
)
{
  m_axFull = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Ay
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = FLOATOFFULL(m_ayFull);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Ay
(
  FLOAT val
)
{
  m_ayFull = FULLOFFLOAT(val);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_FrictionX
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = m_fx;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_FrictionX
(
  FLOAT val
)
{
  m_fx = val;
  m_fFriction = (m_fx != 1.0) || (m_fy != 1.0);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_FrictionY
(
  FLOAT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;

  *pRet = m_fy;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_FrictionY
(
  FLOAT val
)
{
  m_fy = val;
  m_fFriction = (m_fx != 1.0) || (m_fy != 1.0);
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Width
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_pimg->cx;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Height
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_pimg->cy;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Image
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_iimg;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Image
(
  int val
)
{
  if (val >= 0 && val < m_pdisp->m_cimg)
    {
    PIMG pimgCur = m_pimg;

    if (!m_fHidden)
      this->_Erase();
    m_iimg = val;
    m_pimg = &(m_pdisp->m_prgimg[m_iimg]);
    // Keep image centered, if Visible
    if (!m_fHidden)
      {
      m_x += (pimgCur->cx - m_pimg->cx) >> 1;
      m_y += (pimgCur->cy - m_pimg->cy) >> 1;
      this->_FDraw(FALSE);
      }
    }
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_TickMove
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_tickMoveMax;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_TickMove
(
  int val
)
{
  m_tickMoveMax = val;
  if (m_tickMove > m_tickMoveMax)
    m_tickMove = m_tickMoveMax;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_TickEvent
(
  int* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_tickEvtMax;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_TickEvent
(
  int val
)
{
  m_tickEvtMax = val;
  if (m_tickEvt > m_tickEvtMax)
    m_tickEvt = m_tickEvtMax;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Visible
(
  VARIANT_BOOL* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  *pRet = m_fHidden ? 0 : -1;
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Visible
(
  VARIANT_BOOL val
)
{
  if (m_fLinked)
    {
    m_fHidden = !val;
    if (!m_fHidden)
      this->_Erase();
    else
      this->_FDraw(FALSE);
    }
  return S_OK;
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::get_Tag
(
  VARIANT* pRet
)
{
  if (!pRet)
    return E_INVALIDARG;
  VariantInit(pRet);
  return VariantCopy(pRet, &m_varTag);
}


//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
STDMETHODIMP CSprite::put_Tag
(
  VARIANT val
)
{
  return VariantCopy(&m_varTag, &val);
}

//--- EOF -------------------------------------------------------------------