Example #1
0
IE::point
Region::Position() const
{
	IE::point point = { int16(fRegion->use_point_x),
						int16(fRegion->use_point_y) };
	return point;
}
void CUser::ChatTargetSelect(Packet & pkt)
{
	uint8 type = pkt.read<uint8>();

	// TO-DO: Replace this with an enum
	// Attempt to find target player in-game
	if (type == 1)
	{
		Packet result(WIZ_CHAT_TARGET, type);
		std::string strUserID;
		pkt >> strUserID;
		if (strUserID.empty() || strUserID.size() > MAX_ID_SIZE)
			return;

		CUser *pUser = g_pMain->GetUserPtr(strUserID.c_str(), TYPE_CHARACTER);
		if (pUser == NULL || pUser == this)
		{
			result << int16(0); 
		}
/*		TO-DO: Implement PM blocking
		else if (pUser->isBlockingPMs())
		{
			result << int16(-1);
		}
*/
		else
		{
			m_sPrivateChatUser = pUser->GetSocketID();
			result << int16(1) << pUser->m_pUserData.m_id;
		}
		Send(&result);
	}
void CUser::MerchantItemCancel(Packet & pkt)
{
    Packet result(WIZ_MERCHANT, uint8(MERCHANT_ITEM_CANCEL));
    _MERCH_DATA *pMerch = nullptr;
    _ITEM_DATA *pItem = nullptr;

    uint8 bSrcPos = pkt.read<uint8>();

    /*	if (this == nullptr)
    		result << int16(-1);*/
    // Invalid source position
    if (bSrcPos >= MAX_MERCH_ITEMS)
        result << int16(-2);
    // There's no item in that list..?
    else if ((pMerch = &m_arMerchantItems[bSrcPos])->nNum == 0)
        result << int16(-3);
    // Check to make sure we've got a valid stack
    else if (pMerch->sCount + (pItem = &m_sItemArray[pMerch->bOriginalSlot])->sCount > HAVE_MAX)
        result << int16(-3); // custom error
    else
    {
        pItem->nNum = pMerch->nNum;
        pItem->sCount = pMerch->sCount;
        pItem->sDuration = pMerch->sDuration;
        pItem->nSerialNum = pMerch->nSerialNum; // NOTE: Stackable items will have an issue with this.
        memset(pMerch, 0, sizeof(_MERCH_DATA));
        result << int16(1) << bSrcPos;
    }

    Send(&result);
}
void CUser::MerchantItemCancel(Packet & pkt)
{
	Packet result(WIZ_MERCHANT, uint8(MERCHANT_ITEM_CANCEL));
	uint8 bSrcPos = pkt.read<uint8>();

/*	if (this == NULL)
		result << int16(-1);*/
	// Invalid source position
	if (bSrcPos >= MAX_MERCH_ITEMS)
		result << int16(-2);
	// There's no item in that list..?
	else if (m_arSellingItems[bSrcPos].nNum == 0)
		result << int16(-3);
	// Check to make sure we've got a valid stack
	else if (m_arSellingItems[bSrcPos].sCount + m_pUserData->m_sItemArray[m_arSellingItems[bSrcPos].bOriginalSlot].sCount > HAVE_MAX) 
		result << int16(-3); // custom error
	else
	{
		// NOTE: As we don't remove the item from the inventory (I think we should, though), we can just unset the item in the selling list.
		memset(&m_arSellingItems[bSrcPos], 0, sizeof(_MERCH_DATA));
		result << int16(1) << bSrcPos;
	}

	Send(&result);
}
Example #5
0
void
RoomContainer::MouseOver(uint16 x, uint16 y)
{
	const uint16 kScrollingStep = 64;

	uint16 horizBorderSize = 35;
	uint32 vertBorderSize = 40;

	// TODO: Less hardcoding of the window number
	Window* window = GUI::Get()->GetWindow(1);
	if (window != NULL) {
		horizBorderSize += window->Width();
	}

	sint16 scrollByX = 0;
	sint16 scrollByY = 0;
	if (x <= horizBorderSize)
		scrollByX = -kScrollingStep;
	else if (x >= fViewPort.w - horizBorderSize)
		scrollByX = kScrollingStep;

	if (y <= vertBorderSize)
		scrollByY = -kScrollingStep;
	else if (y >= fViewPort.h - vertBorderSize)
		scrollByY = kScrollingStep;

	IE::point point = { int16(x), int16(y) };
	ConvertToArea(point);

	_UpdateCursor(x, y, scrollByX, scrollByY);

	// TODO: This screams for improvements
	if (fWed != NULL) {
		int32 cursor = -1;
		fMouseOverObject = _ObjectAtPoint(point, cursor);
		if (cursor != -1)
			GUI::Get()->SetCursor(cursor);
	} else if (fWorldMap != NULL) {
		for (uint32 i = 0; i < fWorldMap->CountAreaEntries(); i++) {
			AreaEntry& area = fWorldMap->AreaEntryAt(i);
			GFX::rect areaRect = area.Rect();
			if (rect_contains(areaRect, point)) {
				ConvertFromArea(areaRect);
				ConvertToScreen(areaRect);
				//char* toolTip = area.TooltipName();
				//RenderString(toolTip, GraphicsEngine::Get()->ScreenSurface());
				//free(toolTip);
				GraphicsEngine::Get()->ScreenBitmap()->StrokeRect(areaRect, 600);
				break;
			}
		}
	}

	IE::point newAreaOffset = fAreaOffset;
	newAreaOffset.x += scrollByX;
	newAreaOffset.y += scrollByY;

	SetAreaOffset(newAreaOffset);
}
 //------------------------------------------------------------------------
 inline void cell_aa::set(int cx, int cy, int c, int a)
 {
     x = int16(cx);
     y = int16(cy);
     packed_coord = (cy << 16) + cx;
     cover = c;
     area = a;
 }
Example #7
0
void PlayerLogger::LogDamage(bool done, uint16 damage, uint16 heal, ObjectGuid const & unitGuid, uint16 spell)
{
    if (!IsLoggingActive(done ? PLAYER_LOGMASK_DAMAGE_DONE : PLAYER_LOGMASK_DAMAGE_GET))
        return;
    PlayerLogDamage log = PlayerLogDamage(sWorld.GetUptime());
    log.dmgUnit = (unitGuid.GetCounter() == playerGuid) ? 0 : (unitGuid.IsPlayer() ? unitGuid.GetCounter() : unitGuid.GetEntry());
    log.SetCreature(unitGuid.IsCreatureOrPet());
    log.damage = damage > 0 ? int16(damage) : -int16(heal);
    log.spell = spell;
    ((std::vector<PlayerLogDamage>*)(data[done ? PLAYER_LOG_DAMAGE_DONE : PLAYER_LOG_DAMAGE_GET]))->push_back(log);
}
Example #8
0
bool
RoomContainer::LoadWorldMap()
{
	if (fWorldMap != NULL)
		return true;

	_Unload();

	GUI* gui = GUI::Get();

	gui->Clear();
	
	if (!gui->Load("GUIWMAP")) {
		return false;
	}

	gui->ShowWindow(0);
	Window* window = gui->GetWindow(0);
	if (window != NULL) {
		// TODO: Move this into GUI ?
		Control* control = window->GetControlByID(4);
		if (control != NULL)
			control->AssociateRoom(this);
	}

	fAreaOffset.x = fAreaOffset.y = 0;

	Core::Get()->EnteredArea(this, NULL);

	SetName("WORLDMAP");

	GraphicsEngine::Get()->SetWindowCaption(Name());

	fWorldMap = gResManager->GetWMAP(Name());

	worldmap_entry entry = fWorldMap->WorldMapEntry();
	fWorldMapBackground = gResManager->GetMOS(entry.background_mos);
	fWorldMapBitmap = fWorldMapBackground->Image();
	for (uint32 i = 0; i < fWorldMap->CountAreaEntries(); i++) {
		AreaEntry& areaEntry = fWorldMap->AreaEntryAt(i);
		const Bitmap* iconFrame = areaEntry.Icon();
		IE::point position = areaEntry.Position();
		GFX::rect iconRect(int16(position.x - iconFrame->Frame().w / 2),
					int16(position.y - iconFrame->Frame().h / 2),
					iconFrame->Frame().w, iconFrame->Frame().h);

		GraphicsEngine::Get()->BlitBitmap(iconFrame, NULL,
				fWorldMapBitmap, &iconRect);

	}
	return true;
}
Example #9
0
static DB_INLINE void blend_color_func(rgb_color* target, const rgb_color other, uint8 amount)
{
	const uint8 alphaMix = (uint8)( ((int16(other.alpha)-int16(255-target->alpha))*amount)/255
									+ (255-target->alpha) );
	target->red = (uint8)( ((int16(other.red)-int16(target->red))*alphaMix)/255
								+ target->red );
	target->green = (uint8)( ((int16(other.green)-int16(target->green))*alphaMix)/255
								+ target->green );
	target->blue = (uint8)( ((int16(other.blue)-int16(target->blue))*alphaMix)/255
								+ target->blue );
	target->alpha = (uint8)( ((int16(other.alpha)-int16(target->alpha))*amount)/255
								+ target->alpha );
}
Example #10
0
void HexMapTest::SetZoom(float deltaZoom, int multiplier)
{
	if (deltaZoom >= 1)
		deltaZoom = (deltaZoom-1)*multiplier+1;
	else
		deltaZoom = (deltaZoom-1)+1;
	if (multiplier != 1 && deltaZoom > float(multiplier))
		deltaZoom = float(multiplier);
	if (multiplier != 1 && deltaZoom < 1.0f/multiplier)
		deltaZoom = 1.0f/multiplier;
	zoom = zoom_initial * deltaZoom;
	screenTranslationX = int16(screenTranslationX_initial*zoom/zoom_initial);
	screenTranslationY = int16(screenTranslationY_initial*zoom/zoom_initial);
	SetModelMatrix();
}
Example #11
0
static void ReadJP2KImage( GenericImage<P>& img, jas_stream_t* jp2Stream, jas_image_t* jp2Image )
{
   int width = jas_image_cmptwidth( jp2Image, 0 );
   int height = jas_image_cmptheight( jp2Image, 0 );
   int numberOfChannels = jas_image_numcmpts( jp2Image );

   jas_matrix_t* pixels = nullptr;

   try
   {
      pixels = jas_matrix_create( 1, width );
      if ( pixels == nullptr )
         throw Error( "Memory allocation error reading JPEG2000 image" );

      // Allocate pixel data
      img.AllocateData( width, height, numberOfChannels,
                        (jas_clrspc_fam( jas_image_clrspc( jp2Image ) ) == JAS_CLRSPC_FAM_GRAY) ?
                              ColorSpace::Gray : ColorSpace::RGB );

      for ( int c = 0; c < numberOfChannels; ++c )
      {
         int n = jas_image_cmptprec( jp2Image, c );
         bool s = jas_image_cmptsgnd( jp2Image, c ) != 0;

         for ( int y = 0; y < height; ++y )
         {
            jas_image_readcmpt( jp2Image, c, 0, y, width, 1, pixels );

            typename P::sample* f = img.ScanLine( y, c );

            if ( n == 8 )
            {
               if ( s )
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( int8( jas_matrix_get( pixels, 0, x ) ) );
               else
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( uint8( jas_matrix_get( pixels, 0, x ) ) );
            }
            else
            {
               if ( s )
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( int16( jas_matrix_get( pixels, 0, x ) ) );
               else
                  for ( int x = 0; x < width; ++x )
                     *f++ = P::ToSample( uint16( jas_matrix_get( pixels, 0, x ) ) );
            }
         }
      }

      jas_matrix_destroy( pixels ), pixels = nullptr;
   }
   catch ( ... )
   {
      if ( pixels != nullptr )
         jas_matrix_destroy( pixels );
      throw;
   }
}
std::string MySQLPreparedStatement::getQueryString(std::string const& sqlPattern) const
{
    std::string queryString = sqlPattern;

    size_t pos = 0;
    for (uint32 i = 0; i < m_stmt->statement_data.size(); i++)
    {
        pos = queryString.find('?', pos);
        std::stringstream ss;

        switch (m_stmt->statement_data[i].type)
        {
            case TYPE_BOOL:
                ss << uint16(m_stmt->statement_data[i].data.boolean);
                break;
            case TYPE_UI8:
                ss << uint16(m_stmt->statement_data[i].data.ui8);  // stringstream will append a character with that code instead of numeric representation
                break;
            case TYPE_UI16:
                ss << m_stmt->statement_data[i].data.ui16;
                break;
            case TYPE_UI32:
                ss << m_stmt->statement_data[i].data.ui32;
                break;
            case TYPE_I8:
                ss << int16(m_stmt->statement_data[i].data.i8);  // stringstream will append a character with that code instead of numeric representation
                break;
            case TYPE_I16:
                ss << m_stmt->statement_data[i].data.i16;
                break;
            case TYPE_I32:
                ss << m_stmt->statement_data[i].data.i32;
                break;
            case TYPE_UI64:
                ss << m_stmt->statement_data[i].data.ui64;
                break;
            case TYPE_I64:
                ss << m_stmt->statement_data[i].data.i64;
                break;
            case TYPE_FLOAT:
                ss << m_stmt->statement_data[i].data.f;
                break;
            case TYPE_DOUBLE:
                ss << m_stmt->statement_data[i].data.d;
                break;
            case TYPE_STRING:
                ss << '\'' << m_stmt->statement_data[i].str << '\'';
                break;
            case TYPE_NULL:
                ss << "NULL";
                break;
        }

        std::string replaceStr = ss.str();
        queryString.replace(pos, 1, replaceStr);
        pos += replaceStr.length();
    }

    return queryString;
}
Example #13
0
    //play npc emote
    static bool HandleNpcPlayEmoteCommand(ChatHandler* handler, const char* args)
    {
        uint32 emote = atoi((char*)args);

        Creature* target = handler->getSelectedCreature();
        if (!target)
        {
            handler->SendSysMessage(LANG_SELECT_CREATURE);
            handler->SetSentErrorMessage(true);
            return false;
        }

        if (target->GetTransport() && target->GetGUIDTransport())
        {
            PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_TRANSPORT_EMOTE);

            stmt->setInt16(0, int16(emote));
            stmt->setInt32(1, target->GetTransport()->GetEntry());
            stmt->setInt32(2, target->GetGUIDTransport());

            WorldDatabase.Execute(stmt);
        }

        target->SetUInt32Value(UNIT_NPC_EMOTESTATE, emote);

        return true;
    }
Example #14
0
uint64 KaxInternalBlock::ReadInternalHead(IOCallback & input)
{
	binary Buffer[5], *cursor = Buffer;
	uint64 Result = input.read(cursor, 4);
	if (Result != 4)
		return Result;
	
	// update internal values
	TrackNumber = *cursor++;
	if ((TrackNumber & 0x80) == 0) {
		// there is extra data
		if ((TrackNumber & 0x40) == 0) {
			// We don't support track numbers that large !
			return Result;
		}
		Result += input.read(&Buffer[4], 1);
		TrackNumber = (TrackNumber & 0x3F) << 8;
		TrackNumber += *cursor++;
	} else {
		TrackNumber &= 0x7F;
	}

    
	big_int16 b16;
	b16.Eval(cursor);
	assert(ParentCluster != NULL);
	Timecode = ParentCluster->GetBlockGlobalTimecode(int16(b16));
	bLocalTimecodeUsed = false;
	cursor += 2;

	return Result;
}
Example #15
0
void _GlReplicateAlgo::FillOffsets(	int32 index, int32 size, int32 low, int32 high,
									GlCache1d* cache)
{
	float		mod;
	if (cache) {
		float	v = 0.5; 
		if (size > 1) v = ( (index * 2) / float((size - 1) * 2) );
		v = cache->At(v);
//printf("\tGlTile %ld: mod %f v %f\n", index, mod, v);
		mod = v;
	} else mod = 1 / float((index * 2) + 2);
// Old style (when algo1d's had At() -- new style should work fine
#if 0
	GlAlgo1d*	algo = Algo1dAt(_ALGO_INDEX);
	
	if (algo) {
		float	v = 0.5f; 
		if (size > 1) v = ( (index * 2) / float((size - 1) * 2) );
		v = algo->At(v);
//printf("\tGlTile %ld: mod %f v %f\n", index, mod, v);
		mod = v;
	} else mod = 1 / float((index * 2) + 2);
#endif
	float		half = (high - low) / 2.0f;
	for (int32 k = 0; k < 256; k++) {
		if (k < low || k > high) mOffset[k] = 0;
		else mOffset[k] = int16((k - low - half) * mod);
	}
}
Example #16
0
//--------------------------------------------------------------------------
size_t PcmWavAudioCodec::readData(int16* _data, size_t _maxFrames)
{
    size_t offset = mDataStream->tellg();
    if(offset >= mEndOffset)
        return false;

    size_t frames = (mEndOffset - offset) / mBytesPerSampleInFile / mSoundInfo.channels;
    if(frames > _maxFrames)
        frames = _maxFrames;
    if(frames == 0)
        return 0;

    size_t sizeInBytes = frames * mBytesPerSampleInFile * mSoundInfo.channels;
    mDataStream->read( (void*) _data, sizeInBytes);

    if(mBytesPerSampleInFile == 1)
    {
        // in-place conversion 8-bit -> 16-bit
        // (waveform data range for 8-bit is [0..255],
        // for 16-bit is [-32768..32767]
        int8* srcptr = (int8*) _data + sizeInBytes;
        int16* destptr = _data + sizeInBytes;
        while(destptr != _data)
            *(--destptr) = int16(*(--srcptr)) * 256 - 32768;
    }
    return frames;
}
Example #17
0
WMOAreaTableEntry const* GetWMOAreaTableEntryByTripple(int32 rootid, int32 adtid, int32 groupid)
{
    auto i = sWMOAreaInfoByTripple.find(WMOAreaTableKey(int16(rootid), int8(adtid), groupid));
    if (i != sWMOAreaInfoByTripple.end())
        return i->second;

    return nullptr;
}
Example #18
0
inline TUString::TUString(TSysStr& str, bool loan, TLangId lang)
:
  Lang(lang),
  Kind(loan ? isExtBstr : isBstr),
  RefCnt(int16(loan ? 2 : 1)),
  Bstr(str.operator BSTR())
{
}
Example #19
0
inline TUString::TUString(BSTR str, bool loan, TLangId lang)
:
  Lang(lang),
  Kind(loan ? isExtBstr : isBstr),
  RefCnt(int16(loan ? 2 : 1)), 
  Bstr(str)
{
}
Example #20
0
uint8 CMagicProcess::ExecuteType2(int magicid, int tid, int data1, int data2, int data3)
{
	Packet result(AG_MAGIC_ATTACK_RESULT, uint8(MAGIC_EFFECTING));
	int damage = m_pSrcUser->GetDamage(tid, magicid);;
	uint8 bResult = 1;
	
	result << magicid << m_pSrcUser->m_iUserId << tid << data1;

	if (damage > 0){
		CNpc* pNpc = nullptr ;      // Pointer initialization!
		pNpc = g_pMain->m_arNpc.GetData(tid-NPC_BAND);
		if(pNpc == nullptr || pNpc->m_NpcState == NPC_DEAD || pNpc->m_iHP == 0)	{
			bResult = 0;
			goto packet_send;
		}

		if (!pNpc->SetDamage(magicid, damage, m_pSrcUser->m_strUserID, m_pSrcUser->m_iUserId + USER_BAND))
		{
			result	<< int16(bResult) << data3 << int16(0) << int16(0) << int16(0)
					<< int16(damage == 0 ? -104 : 0);
			g_pMain->Send(&result);

			pNpc->SendExpToUserList(); // 경험치 분배!!
			pNpc->SendDead();
			m_pSrcUser->SendAttackSuccess(tid, MAGIC_ATTACK_TARGET_DEAD, damage, pNpc->m_iHP);
			//m_pSrcUser->SendAttackSuccess(tid, ATTACK_TARGET_DEAD, damage, pNpc->m_iHP);

			return bResult;
		}
		else	{
			// 공격 결과 전송
			m_pSrcUser->SendAttackSuccess(tid, ATTACK_SUCCESS, damage, pNpc->m_iHP);
		}
	}
//	else
//		result = 0;

packet_send:
	// this is a little redundant but leaving it in just in case order is intended
	// this should all be removed eventually anyway...
	result	<< int16(bResult) << data3 << int16(0) << int16(0) << int16(0)
			<< int16(damage == 0 ? -104 : 0);
	g_pMain->Send(&result);
	return bResult;
}
std::string MySQLPreparedStatement::getQueryString(const char *query)
{
    std::string queryString = query;

    uint32 pos = 0;
    for (uint32 i = 0; i < m_stmt->statement_data.size(); i++)
    {
        pos = queryString.find("?", pos);
        std::stringstream replace;

        replace << '\'';

        switch (m_stmt->statement_data[i].type)
        {
            case TYPE_BOOL:
                replace << (m_stmt->statement_data[i].data.boolean ? '1' : '0');
                break;
            case TYPE_UI8:
                replace << uint16(m_stmt->statement_data[i].data.ui8);  // stringstream will append a character with that code instead of numeric representation
                break;
            case TYPE_UI16:
                replace << m_stmt->statement_data[i].data.ui16;
                break;
            case TYPE_UI32:
                replace << m_stmt->statement_data[i].data.ui32;
                break;
            case TYPE_I8:
                replace << int16(m_stmt->statement_data[i].data.i8);  // stringstream will append a character with that code instead of numeric representation
                break;
            case TYPE_I16:
                replace << m_stmt->statement_data[i].data.i16;
                break;
            case TYPE_I32:
                replace << m_stmt->statement_data[i].data.i32;
                break;
            case TYPE_UI64:
                replace << m_stmt->statement_data[i].data.ui64;
                break;
            case TYPE_I64:
                replace << m_stmt->statement_data[i].data.i64;
                break;
            case TYPE_FLOAT:
                replace << m_stmt->statement_data[i].data.f;
                break;
            case TYPE_DOUBLE:
                replace << m_stmt->statement_data[i].data.d;
                break;
            case TYPE_STRING:
                replace << m_stmt->statement_data[i].str;
                break;
        }
        replace << '\'';
        queryString.replace(pos, 1, replace.str());
    }

    return queryString;
}
Example #22
0
void Core::CheckDataTypeSizes()
{
    CheckType(int8(), 8, "int8");
    CheckType(uint8(), 8, "uint8");
    CheckType(int16(), 16, "int16");
    CheckType(uint16(), 16, "uint16");
    CheckType(int32(), 32, "int32");
    CheckType(uint32(), 32, "uint32");
}
Example #23
0
t_freq_gen::t_freq_gen(vector<uint16> frequencies, int8 db_level) {
	assert(frequencies.size() > 0);
	assert(db_level <= 0);
	
	_frequencies = frequencies;
	
	// dB = 20 * log(amplitude / 32768)
	// 32767 is used below as +32768 does not fit in 16 bits
	_amplitude = int16(pow(10.0, db_level / 20.0) * 32767 / _frequencies.size());
}
/**
* Draws the enemy image
*/
void MeleeEnemy::draw() {

	if (mDrawDirection == 1) {
		Iw2DSetImageTransform(IW_2D_IMAGE_TRANSFORM_FLIP_X);
	}

	CIwSVec2 screenCentre = CIwSVec2((int16)Iw2DGetSurfaceWidth() >> 1, (int16)Iw2DGetSurfaceHeight() >> 1);

	b2Transform t = mBody->GetTransform();
	CIwSVec2 pos = screenCentre + (CIwSVec2(int16(t.p.x*8), -int16(t.p.y*8)));

	float normalRegionHeight = (52.0f/100.0f) * ((mHealth/mMaxHealth)*100.0f);
	float hurtRegionHeight = 52.0f - normalRegionHeight;

	CIwColour col;
	col.Set(255, 50, 50);
	Iw2DSetColour(col);
	Iw2DDrawImageRegion(mImg, pos - CIwSVec2((mFrameWidth/1.5)*mSpriteScale, ((52/2)*mSpriteScale)), CIwSVec2(mFrameWidth*1.5, hurtRegionHeight*mSpriteScale), CIwSVec2(mFrame, mVerFrame), CIwSVec2(mFrameWidth, hurtRegionHeight));

	col.Set(255, 255, 255);
	Iw2DSetColour(col);
	Iw2DDrawImageRegion(mImg, pos - CIwSVec2((mFrameWidth/1.5)*mSpriteScale, (((52/2)*mSpriteScale))-hurtRegionHeight), CIwSVec2(mFrameWidth*1.5, normalRegionHeight*mSpriteScale), CIwSVec2(mFrame, hurtRegionHeight+mVerFrame), CIwSVec2(mFrameWidth, normalRegionHeight));

	if(mFrameDelay <= 0) {
		mFrame += (mFrameWidth);

		if (mFrame > (mFrameCount*mFrameWidth)) {

			//setIdle();
			mFrame = 0;
			if(punching) {
				setIdle();
				mPunchTimer = 10.0f;
			}
		}
		mFrameDelay = 5;
	}

	mFrameDelay--;

	Iw2DSetImageTransform(IW_2D_IMAGE_TRANSFORM_NONE);
}
Example #25
0
static int16 InterpolateAngle(int16 Angle, GLfloat MixFrac, int16 AddlAngle)
{
  if (MixFrac != 0 && AddlAngle != Angle) {
    int16 AngleDiff = NORMALIZE_ANGLE(AddlAngle - Angle);
    if (AngleDiff >= HALF_CIRCLE) {
      AngleDiff -= FULL_CIRCLE;
    }
    Angle += int16(MixFrac*AngleDiff);
  }
  return NORMALIZE_ANGLE(Angle);
}
Example #26
0
void SampleConverter::convert(int16 *dest, const float *source, int samplecount)
{
	while (samplecount--) {
		register int32 sample = (int32) (*source++ * 32767.0f);
		if (sample > 32767)
			*dest++ = 32767;
		else if (sample < -32767)
			*dest++ = -32767;
		else
			*dest++ = int16(sample);
	}
}
Example #27
0
//-----------------------------------------------------------------------------
void ExampleRender()
{
	static const CIwSVec2 imageSize(g_Image->GetWidth() >> 3, g_Image->GetHeight() >> 3);
	static const CIwSVec2 halfImageSize = imageSize >> 1;

	const CIwSVec2 screenCentre = CIwSVec2((int16)Iw2DGetSurfaceWidth() >> 1, (int16)Iw2DGetSurfaceHeight() >> 1);

	const b2Transform t = g_body->GetTransform();
	const CIwSVec2 pos = screenCentre + (CIwSVec2(int16(t.p.x*8), -int16(t.p.y*8)));
	const float angle = -t.q.GetAngle() * (180.0f/3.14159f);	// reverse angle as our screen-Y coord is reversed

	CIwMat2D rot;
	rot.SetRot(iwangle(angle * 1024 / 90), CIwVec2(pos) << 3);
	Iw2DSetTransformMatrixSubPixel(rot);

	Iw2DDrawImage(g_Image, pos - halfImageSize, imageSize);

    //
    Iw2DSetTransformMatrix(CIwMat2D::g_Identity);
    Iw2DSurfaceShow();
}
Example #28
0
bool Debugger_v2::cmd_sceneInfo(int argc, const char **argv) {
	DebugPrintf("Current scene: %d '%s'\n", _vm->_currentScene, _vm->_sceneList[_vm->_currentScene].filename1);
	DebugPrintf("\n");
	DebugPrintf("Exit information:\n");
	DebugPrintf("Exit1: leads to %d, position %dx%d\n", int16(_vm->_sceneExit1), _vm->_sceneEnterX1, _vm->_sceneEnterY1);
	DebugPrintf("Exit2: leads to %d, position %dx%d\n", int16(_vm->_sceneExit2), _vm->_sceneEnterX2, _vm->_sceneEnterY2);
	DebugPrintf("Exit3: leads to %d, position %dx%d\n", int16(_vm->_sceneExit3), _vm->_sceneEnterX3, _vm->_sceneEnterY3);
	DebugPrintf("Exit4: leads to %d, position %dx%d\n", int16(_vm->_sceneExit4), _vm->_sceneEnterX4, _vm->_sceneEnterY4);
	DebugPrintf("Special exit information:\n");
	if (!_vm->_specialExitCount) {
		DebugPrintf("No special exits.\n");
	} else {
		DebugPrintf("This scene has %d special exits.\n", _vm->_specialExitCount);
		for (int i = 0; i < _vm->_specialExitCount; ++i) {
			DebugPrintf("SpecialExit%d: facing %d, position (x1/y1/x2/y2): %d/%d/%d/%d\n", i,
			            _vm->_specialExitTable[20 + i], _vm->_specialExitTable[0 + i], _vm->_specialExitTable[5 + i],
			            _vm->_specialExitTable[10 + i], _vm->_specialExitTable[15 + i]);
		}
	}

	return true;
}
int16
TransformMatrix::getScaleAndShift(scaleInt_t& outScale, double inScale, 
                                  int maxShift)
{
  // I guess this function could be optimized.
   double testNumber = inScale;
   int shift = 0;
   while ( fabs(testNumber) < (32767/2) && ( shift <= maxShift ) ) {
      testNumber *= 2;
      shift += 1;
   }
   outScale = int16(testNumber/2.0);
   return shift-1;
}
Example #30
0
/**
* @brief	Handles King candidacy recommendations by 
* 			leaders of top 10 clans.
*
* @param	pUser	The user sending the packet.
* @param	pkt  	The packet.
*/
void CKingSystem::CandidacyRecommend(CUser * pUser, Packet & pkt) 
{
	Packet result(WIZ_KING, uint8(KING_ELECTION));
	std::string strUserID;
	pkt.SByte();
	pkt >> strUserID;
	if (strUserID.empty() || strUserID.length() > MAX_ID_SIZE)
		return;

	result << uint8(KING_ELECTION_NOMINATE);

	// Make sure it's nomination time.
	if (m_byType != ELECTION_TYPE_NOMINATION)
	{
		result << int16(-2);
		pUser->Send(&result);
		return;
	}

	FastGuard lock(m_lock);

	// Make sure the user nominating a King is a clan leader
	if (!pUser->isClanLeader()
		// ... of a top 10 clan.
			|| m_top10ClanSet.find(pUser->GetClanID()) == m_top10ClanSet.end()
			// ... and they haven't resigned their candidacy.
			|| m_resignedCandidateList.find(pUser->m_strUserID) != m_resignedCandidateList.end())
	{
		result << int16(-3);
		pUser->Send(&result);
		return;
	}

	// Send request to database.
	result << strUserID;
	g_pMain->AddDatabaseRequest(result, pUser);
}