Ejemplo n.º 1
0
/*
============
idProgram::AllocDef
============
*/
idVarDef *idProgram::AllocDef( idTypeDef *type, const char *name, idVarDef *scope, bool constant ) {
	idVarDef	*def;
	idStr		element;
	idVarDef	*def_x;
	idVarDef	*def_y;
	idVarDef	*def_z;

	// allocate a new def
	def = new idVarDef( type );
	def->scope		= scope;
	def->numUsers	= 1;
	def->num		= varDefs.Append( def );

	// add the def to the list with defs with this name and set the name pointer
	AddDefToNameList( def, name );

	if ( ( type->Type() == ev_vector ) || ( ( type->Type() == ev_field ) && ( type->FieldType()->Type() == ev_vector ) ) ) {
		//
		// vector
		//
		if ( !strcmp( name, RESULT_STRING ) ) {
			// <RESULT> vector defs don't need the _x, _y and _z components
			assert( scope->Type() == ev_function );
			def->value.stackOffset	= scope->value.functionPtr->locals;
			def->initialized		= idVarDef::stackVariable;
			scope->value.functionPtr->locals += type->Size();
		} else if ( scope->TypeDef()->Inherits( &type_object ) ) {
			idTypeDef	newtype( ev_field, NULL, "float field", 0, &type_float );
			idTypeDef	*type = GetType( newtype, true );

			// set the value to the variable's position in the object
			def->value.ptrOffset = scope->TypeDef()->Size();

			// make automatic defs for the vectors elements
			// origin can be accessed as origin_x, origin_y, and origin_z
			sprintf( element, "%s_x", def->Name() );
			def_x = AllocDef( type, element, scope, constant );

			sprintf( element, "%s_y", def->Name() );
			def_y = AllocDef( type, element, scope, constant );
			def_y->value.ptrOffset = def_x->value.ptrOffset + type_float.Size();

			sprintf( element, "%s_z", def->Name() );
			def_z = AllocDef( type, element, scope, constant );
			def_z->value.ptrOffset = def_y->value.ptrOffset + type_float.Size();
		} else {
			// make automatic defs for the vectors elements
			// origin can be accessed as origin_x, origin_y, and origin_z
			sprintf( element, "%s_x", def->Name() );
			def_x = AllocDef( &type_float, element, scope, constant );

			sprintf( element, "%s_y", def->Name() );
			def_y = AllocDef( &type_float, element, scope, constant );

			sprintf( element, "%s_z", def->Name() );
			def_z = AllocDef( &type_float, element, scope, constant );

			// point the vector def to the x coordinate
			def->value			= def_x->value;
			def->initialized	= def_x->initialized;
		}
	} else if ( scope->TypeDef()->Inherits( &type_object ) ) {
		//
		// object variable
		//
		// set the value to the variable's position in the object
		def->value.ptrOffset = scope->TypeDef()->Size();
	} else if ( scope->Type() == ev_function ) {
		//
		// stack variable
		//
		// since we don't know how many local variables there are,
		// we have to have them go backwards on the stack
		def->value.stackOffset	= scope->value.functionPtr->locals;
		def->initialized		= idVarDef::stackVariable;

		if ( type->Inherits( &type_object ) ) {
			// objects only have their entity number on the stack, not the entire object
			scope->value.functionPtr->locals += type_object.Size();
		} else {
			scope->value.functionPtr->locals += type->Size();
		}
	} else {
		//
		// global variable
		//
		def->value.bytePtr = &variables[ numVariables ];
		numVariables += def->TypeDef()->Size();
		if ( numVariables > sizeof( variables ) ) {
			throw idCompileError( va( "Exceeded global memory size (%d bytes)", sizeof( variables ) ) );
		}

		memset( def->value.bytePtr, 0, def->TypeDef()->Size() );
	}

	return def;
}
Ejemplo n.º 2
0
void WrappedID3D11DeviceContext::ProcessChunk(uint64_t offset, D3D11ChunkType chunk, bool forceExecute)
{
	if(chunk < FIRST_CONTEXT_CHUNK && !forceExecute)
	{
		if(m_State == READING)
		{
			m_pDevice->GetResourceManager()->MarkInFrame(false);

			m_pDevice->ProcessChunk(offset, chunk);
			m_pSerialiser->PopContext(NULL, chunk);

			m_pDevice->GetResourceManager()->MarkInFrame(true);
		}
		else if(m_State == EXECUTING)
		{
			m_pSerialiser->SkipCurrentChunk();
			m_pSerialiser->PopContext(NULL, chunk);
		}
		return;
	}

	m_CurChunkOffset = offset;

	RDCASSERT(GetType() == D3D11_DEVICE_CONTEXT_IMMEDIATE);

	uint64_t cOffs = m_pSerialiser->GetOffset();

	ResourceId ctxId;
	m_pSerialiser->Serialise("context", ctxId);

	WrappedID3D11DeviceContext *context = (WrappedID3D11DeviceContext *)m_pDevice->GetResourceManager()->GetLiveResource(ctxId);

	if(m_FakeContext != ResourceId())
	{
		if(m_FakeContext == ctxId)
			context = this;
		else
		{
			m_pSerialiser->SetOffset(cOffs);
			m_pSerialiser->SkipCurrentChunk();
			m_pSerialiser->PopContext(NULL, chunk);
			return;
		}
	}
	
	RDCASSERT(WrappedID3D11DeviceContext::IsAlloc(context));
	
	LogState state = context->m_State;

	if(forceExecute)
		context->m_State = EXECUTING;
	else
		context->m_State = m_State;

	m_AddedDrawcall = false;

	switch(chunk)
	{
	case SET_INPUT_LAYOUT:
		context->Serialise_IASetInputLayout(0x0);
		break;
	case SET_VBUFFER:
		context->Serialise_IASetVertexBuffers(0, 0, 0x0, 0x0, 0x0);
		break;
	case SET_IBUFFER:
		context->Serialise_IASetIndexBuffer(0, DXGI_FORMAT_UNKNOWN, 0);
		break;
	case SET_TOPOLOGY:
		context->Serialise_IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED);
		break;

	case SET_VS_CBUFFERS:
		context->Serialise_VSSetConstantBuffers(0, 0, 0x0);
		break;
	case SET_VS_RESOURCES:
		context->Serialise_VSSetShaderResources(0, 0, 0x0);
		break;
	case SET_VS_SAMPLERS:
		context->Serialise_VSSetSamplers(0, 0, 0x0);
		break;
	case SET_VS:
		context->Serialise_VSSetShader(0x0, 0x0, 0);
		break;

	case SET_HS_CBUFFERS:
		context->Serialise_HSSetConstantBuffers(0, 0, 0x0);
		break;
	case SET_HS_RESOURCES:
		context->Serialise_HSSetShaderResources(0, 0, 0x0);
		break;
	case SET_HS_SAMPLERS:
		context->Serialise_HSSetSamplers(0, 0, 0x0);
		break;
	case SET_HS:
		context->Serialise_HSSetShader(0x0, 0x0, 0);
		break;

	case SET_DS_CBUFFERS:
		context->Serialise_DSSetConstantBuffers(0, 0, 0x0);
		break;
	case SET_DS_RESOURCES:
		context->Serialise_DSSetShaderResources(0, 0, 0x0);
		break;
	case SET_DS_SAMPLERS:
		context->Serialise_DSSetSamplers(0, 0, 0x0);
		break;
	case SET_DS:
		context->Serialise_DSSetShader(0x0, 0x0, 0);
		break;
		
	case SET_GS_CBUFFERS:
		context->Serialise_GSSetConstantBuffers(0, 0, 0x0);
		break;
	case SET_GS_RESOURCES:
		context->Serialise_GSSetShaderResources(0, 0, 0x0);
		break;
	case SET_GS_SAMPLERS:
		context->Serialise_GSSetSamplers(0, 0, 0x0);
		break;
	case SET_GS:
		context->Serialise_GSSetShader(0x0, 0x0, 0);
		break;

	case SET_SO_TARGETS:
		context->Serialise_SOSetTargets(0, 0x0, 0x0);
		break;
		
	case SET_PS_CBUFFERS:
		context->Serialise_PSSetConstantBuffers(0, 0, 0x0);
		break;
	case SET_PS_RESOURCES:
		context->Serialise_PSSetShaderResources(0, 0, 0x0);
		break;
	case SET_PS_SAMPLERS:
		context->Serialise_PSSetSamplers(0, 0, 0x0);
		break;
	case SET_PS:
		context->Serialise_PSSetShader(0x0, 0x0, 0);
		break;

	case SET_CS_CBUFFERS:
		context->Serialise_CSSetConstantBuffers(0, 0, 0x0);
		break;
	case SET_CS_RESOURCES:
		context->Serialise_CSSetShaderResources(0, 0, 0x0);
		break;
	case SET_CS_UAVS:
		context->Serialise_CSSetUnorderedAccessViews(0, 0, 0x0, 0x0);
		break;
	case SET_CS_SAMPLERS:
		context->Serialise_CSSetSamplers(0, 0, 0x0);
		break;
	case SET_CS:
		context->Serialise_CSSetShader(0x0, 0x0, 0);
		break;

	case SET_VIEWPORTS:
		context->Serialise_RSSetViewports(0, 0x0);
		break;
	case SET_SCISSORS:
		context->Serialise_RSSetScissorRects(0, 0x0);
		break;
	case SET_RASTER:
		context->Serialise_RSSetState(0x0);
		break;

	case SET_RTARGET:
		context->Serialise_OMSetRenderTargets(0, 0x0, 0x0);
		break;
	case SET_RTARGET_AND_UAVS:
		context->Serialise_OMSetRenderTargetsAndUnorderedAccessViews(0, 0x0, 0x0, 0, 0, 0x0, 0x0);
		break;
	case SET_BLEND:
		context->Serialise_OMSetBlendState(0x0, (FLOAT*)0x0, 0);
		break;
	case SET_DEPTHSTENCIL:
		context->Serialise_OMSetDepthStencilState(0x0, 0);
		break;
		
	case DRAW_INDEXED_INST:
		context->Serialise_DrawIndexedInstanced(0, 0, 0, 0, 0);
		break;
	case DRAW_INST:
		context->Serialise_DrawInstanced(0, 0, 0, 0);
		break;
	case DRAW_INDEXED:
		context->Serialise_DrawIndexed(0, 0, 0);
		break;
	case DRAW:
		context->Serialise_Draw(0, 0);
		break;
	case DRAW_AUTO:
		context->Serialise_DrawAuto();
		break;
	case DRAW_INDEXED_INST_INDIRECT:
		context->Serialise_DrawIndexedInstancedIndirect(0x0, 0);
		break;
	case DRAW_INST_INDIRECT:
		context->Serialise_DrawInstancedIndirect(0x0, 0);
		break;

	case MAP:
		context->Serialise_Map(0, 0, (D3D11_MAP)0, 0, 0);
		break;
	case UNMAP:
		context->Serialise_Unmap(0, 0);
		break;
		
	case COPY_SUBRESOURCE_REGION:
		context->Serialise_CopySubresourceRegion(0x0, 0, 0, 0, 0, 0x0, 0, 0x0);
		break;
	case COPY_RESOURCE:
		context->Serialise_CopyResource(0x0, 0x0);
		break;
	case UPDATE_SUBRESOURCE:
		context->Serialise_UpdateSubresource(0x0, 0, 0x0, 0x0, 0, 0);
		break;
	case COPY_STRUCTURE_COUNT:
		context->Serialise_CopyStructureCount(0x0, 0, 0x0);
		break;
	case RESOLVE_SUBRESOURCE:
		context->Serialise_ResolveSubresource(0x0, 0, 0x0, 0, DXGI_FORMAT_UNKNOWN);
		break;
	case GENERATE_MIPS:
		context->Serialise_GenerateMips(0x0);
		break;

	case CLEAR_DSV:
		context->Serialise_ClearDepthStencilView(0x0, 0, 0.0f, 0);
		break;
	case CLEAR_RTV:
		context->Serialise_ClearRenderTargetView(0x0, (FLOAT*)0x0);
		break;
	case CLEAR_UAV_INT:
		context->Serialise_ClearUnorderedAccessViewUint(0x0, (UINT*)0x0);
		break;
	case CLEAR_UAV_FLOAT:
		context->Serialise_ClearUnorderedAccessViewFloat(0x0, (FLOAT*)0x0);
		break;
	case CLEAR_STATE:
		context->Serialise_ClearState();
		break;
		
	case EXECUTE_CMD_LIST:
		context->Serialise_ExecuteCommandList(0x0, 0);
		break;
	case DISPATCH:
		context->Serialise_Dispatch(0, 0, 0);
		break;
	case DISPATCH_INDIRECT:
		context->Serialise_DispatchIndirect(0x0, 0);
		break;
	case FINISH_CMD_LIST:
		context->Serialise_FinishCommandList(0, 0x0);
		break;
	case FLUSH:
		context->Serialise_Flush();
		break;
		
	case SET_PREDICATION:
		context->Serialise_SetPredication(0x0, 0x0);
		break;
	case SET_RESOURCE_MINLOD:
		context->Serialise_SetResourceMinLOD(0x0, 0);
		break;

	case BEGIN:
		context->Serialise_Begin(0x0);
		break;
	case END:
		context->Serialise_End(0x0);
		break;
		
#if defined(INCLUDE_D3D_11_1)
	case COPY_SUBRESOURCE_REGION1:
		context->Serialise_CopySubresourceRegion1(0x0, 0, 0, 0, 0, 0x0, 0, 0x0, 0);
		break;
	case UPDATE_SUBRESOURCE1:
		context->Serialise_UpdateSubresource1(0x0, 0, 0x0, 0x0, 0, 0, 0);
		break;
	case CLEAR_VIEW:
		context->Serialise_ClearView(0x0, 0x0, 0x0, 0);
		break;

	case SET_VS_CBUFFERS1:
		context->Serialise_VSSetConstantBuffers1(0, 0, 0x0, 0x0, 0x0);
		break;
	case SET_HS_CBUFFERS1:
		context->Serialise_HSSetConstantBuffers1(0, 0, 0x0, 0x0, 0x0);
		break;
	case SET_DS_CBUFFERS1:
		context->Serialise_DSSetConstantBuffers1(0, 0, 0x0, 0x0, 0x0);
		break;
	case SET_GS_CBUFFERS1:
		context->Serialise_GSSetConstantBuffers1(0, 0, 0x0, 0x0, 0x0);
		break;
	case SET_PS_CBUFFERS1:
		context->Serialise_PSSetConstantBuffers1(0, 0, 0x0, 0x0, 0x0);
		break;
	case SET_CS_CBUFFERS1:
		context->Serialise_CSSetConstantBuffers1(0, 0, 0x0, 0x0, 0x0);
		break;
#else
	case COPY_SUBRESOURCE_REGION1:
	case UPDATE_SUBRESOURCE1:
	case CLEAR_VIEW:
	case SET_VS_CBUFFERS1:
	case SET_HS_CBUFFERS1:
	case SET_DS_CBUFFERS1:
	case SET_GS_CBUFFERS1:
	case SET_PS_CBUFFERS1:
	case SET_CS_CBUFFERS1:
		RDCERR("Replaying log with D3D11.1 events on a build without D3D11.1 support");
		break;
#endif

	case BEGIN_EVENT:
		context->Serialise_BeginEvent(0, L"");
		break;
	case SET_MARKER:
		context->Serialise_SetMarker(0, L"");
		break;
	case END_EVENT:
		context->Serialise_EndEvent();
		break;

	case CONTEXT_CAPTURE_FOOTER:
		{
			bool HasCallstack = false;
			m_pSerialiser->Serialise("HasCallstack", HasCallstack);	

			if(HasCallstack)
			{
				size_t numLevels = 0;
				uint64_t *stack = NULL;

				m_pSerialiser->Serialise("callstack", stack, numLevels);

				m_pSerialiser->SetCallstack(stack, numLevels);

				SAFE_DELETE_ARRAY(stack);
			}

			if(m_State == READING)
			{
				AddEvent(CONTEXT_CAPTURE_FOOTER, "IDXGISwapChain::Present()");

				FetchDrawcall draw;
				draw.name = L"Present()";
				draw.flags |= eDraw_Present;

				AddDrawcall(draw, true);
			}
		}
		break;
	default:
		RDCERR("Unrecognised Chunk type %d", chunk);
		break;
	}

	m_pSerialiser->PopContext(NULL, chunk);
	
	if(context->m_State == READING && chunk == SET_MARKER)
	{
		// no push/pop necessary
	}
	else if(context->m_State == READING && chunk == BEGIN_EVENT)
	{
		// push down the drawcallstack to the latest drawcall
		context->m_DrawcallStack.push_back(&context->m_DrawcallStack.back()->children.back());
	}
	else if(context->m_State == READING && chunk == END_EVENT)
	{
		// refuse to pop off further than the root drawcall (mismatched begin/end events e.g.)
		RDCASSERT(context->m_DrawcallStack.size() > 1);
		if(context->m_DrawcallStack.size() > 1)
			context->m_DrawcallStack.pop_back();
	}
	else if(context->m_State == READING)
	{
		if(!m_AddedDrawcall)
			context->AddEvent(chunk, m_pSerialiser->GetDebugStr());
	}

	m_AddedDrawcall = false;
	
	if(forceExecute)
		context->m_State = state;
}
Ejemplo n.º 3
0
bool CInputProcessor::Process(LPDESC lpDesc, const void * c_pvOrig, int iBytes, int & r_iBytesProceed)
{
	const char * c_pData = (const char *) c_pvOrig;

	BYTE	bLastHeader = 0;
	int		iLastPacketLen = 0;
	int		iPacketLen;

	if (!m_pPacketInfo)
	{
		sys_err("No packet info has been binded to");
		return true;
	}

	for (m_iBufferLeft = iBytes; m_iBufferLeft > 0;)
	{
		BYTE bHeader = (BYTE) *(c_pData);
		const char * c_pszName;

		if (bHeader == 0) // 암호화 처리가 있으므로 0번 헤더는 스킵한다.
			iPacketLen = 1;
		else if (!m_pPacketInfo->Get(bHeader, &iPacketLen, &c_pszName))
		{
			sys_err("UNKNOWN HEADER: %d, LAST HEADER: %d(%d), REMAIN BYTES: %d, fd: %d",
					bHeader, bLastHeader, iLastPacketLen, m_iBufferLeft, lpDesc->GetSocket());
			//printdata((BYTE *) c_pvOrig, m_iBufferLeft);
			lpDesc->SetPhase(PHASE_CLOSE);
			return true;
		}

		if (m_iBufferLeft < iPacketLen)
			return true;

		if (bHeader)
		{
			if (test_server && bHeader != HEADER_CG_MOVE)
				sys_log(0, "Packet Analyze [Header %d][bufferLeft %d] ", bHeader, m_iBufferLeft);

			m_pPacketInfo->Start();

			int iExtraPacketSize = Analyze(lpDesc, bHeader, c_pData);

			if (iExtraPacketSize < 0)
				return true;

			iPacketLen += iExtraPacketSize;
			lpDesc->Log("%s %d", c_pszName, iPacketLen);
			m_pPacketInfo->End();
		}

		// TRAFFIC_PROFILER
		if (g_bTrafficProfileOn)
			TrafficProfiler::instance().Report(TrafficProfiler::IODIR_INPUT, bHeader, iPacketLen);
		// END_OF_TRAFFIC_PROFILER

		if (bHeader == HEADER_CG_PONG)
			sys_log(0, "PONG! %u %u", m_pPacketInfo->IsSequence(bHeader), *(BYTE *) (c_pData + iPacketLen - sizeof(BYTE)));

		if (m_pPacketInfo->IsSequence(bHeader))
		{
			BYTE bSeq = lpDesc->GetSequence();
			BYTE bSeqReceived = *(BYTE *) (c_pData + iPacketLen - sizeof(BYTE));

			if (bSeq != bSeqReceived)
			{
				sys_err("SEQUENCE %x mismatch 0x%x != 0x%x header %u", get_pointer(lpDesc), bSeq, bSeqReceived, bHeader);

				LPCHARACTER	ch = lpDesc->GetCharacter();

				char buf[1024];
				int	offset, len;

				offset = snprintf(buf, sizeof(buf), "SEQUENCE_LOG [%s]-------------\n", ch ? ch->GetName() : "UNKNOWN");

				if (offset < 0 || offset >= (int) sizeof(buf))
					offset = sizeof(buf) - 1;

				for (size_t i = 0; i < lpDesc->m_seq_vector.size(); ++i)
				{
					len = snprintf(buf + offset, sizeof(buf) - offset, "\t[%03d : 0x%x]\n",
							lpDesc->m_seq_vector[i].hdr,
							lpDesc->m_seq_vector[i].seq);

					if (len < 0 || len >= (int) sizeof(buf) - offset)
						offset += (sizeof(buf) - offset) - 1;
					else
						offset += len;
				}

				snprintf(buf + offset, sizeof(buf) - offset, "\t[%03d : 0x%x]\n", bHeader, bSeq);
				sys_err("%s", buf);

				lpDesc->SetPhase(PHASE_CLOSE);
				return true;
			}
			else
			{
				lpDesc->push_seq(bHeader, bSeq);
				lpDesc->SetNextSequence();
				//sys_err("SEQUENCE %x match %u next %u header %u", lpDesc, bSeq, lpDesc->GetSequence(), bHeader);
			}
		}

		c_pData	+= iPacketLen;
		m_iBufferLeft -= iPacketLen;
		r_iBytesProceed += iPacketLen;

		iLastPacketLen = iPacketLen;
		bLastHeader	= bHeader;

		if (GetType() != lpDesc->GetInputProcessor()->GetType())
			return false;
	}

	return true;
}
Ejemplo n.º 4
0
void ArenaTeam::DelMember(uint64 guid, bool cleanDb)
{
    // Remove member from team
    for (MemberList::iterator itr = Members.begin(); itr != Members.end(); ++itr)
        if (itr->Guid == guid)
        {
            Members.erase(itr);
            break;
        }

    // Remove arena team info from player data
    if (Player* player = ObjectAccessor::FindPlayer(guid))
    {
        // delete all info regarding this team
        for (uint32 i = 0; i < ARENA_TEAM_END; ++i)
            player->SetArenaTeamInfoField(GetSlot(), ArenaTeamInfoType(i), 0);
        TC_LOG_DEBUG("bg.arena", "Player: %s [GUID: %u] left arena team type: %u [Id: %u, Name: %s].", player->GetName().c_str(), player->GetGUIDLow(), GetType(), GetId(), GetName().c_str());
    }

    // Only used for single member deletion, for arena team disband we use a single query for more efficiency
    if (cleanDb)
    {
        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBER);
        stmt->setUInt32(0, GetId());
        stmt->setUInt32(1, GUID_LOPART(guid));
        CharacterDatabase.Execute(stmt);
    }
}
Ejemplo n.º 5
0
bool ArenaTeam::Create(uint64 captainGuid, uint8 type, std::string const& arenaTeamName,
                                         uint32 backgroundColor, uint8 emblemStyle, uint32 emblemColor,
                                         uint8 borderStyle, uint32 borderColor)
{
    // Check if captain is present
    if (!ObjectAccessor::FindPlayer(captainGuid))
        return false;

    // Check if arena team name is already taken
    if (sArenaTeamMgr->GetArenaTeamByName(arenaTeamName))
        return false;

    // Generate new arena team id
    TeamId = sArenaTeamMgr->GenerateArenaTeamId();

    // Assign member variables
    CaptainGuid = captainGuid;
    Type = type;
    TeamName = arenaTeamName;
    BackgroundColor = backgroundColor;
    EmblemStyle = emblemStyle;
    EmblemColor = emblemColor;
    BorderStyle = borderStyle;
    BorderColor = borderColor;
    uint32 captainLowGuid = GUID_LOPART(captainGuid);

    // Save arena team to db
    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM);
    stmt->setUInt32(0, TeamId);
    stmt->setString(1, TeamName);
    stmt->setUInt32(2, captainLowGuid);
    stmt->setUInt8(3, Type);
    stmt->setUInt16(4, Stats.Rating);
    stmt->setUInt32(5, BackgroundColor);
    stmt->setUInt8(6, EmblemStyle);
    stmt->setUInt32(7, EmblemColor);
    stmt->setUInt8(8, BorderStyle);
    stmt->setUInt32(9, BorderColor);
    CharacterDatabase.Execute(stmt);

    // Add captain as member
    AddMember(CaptainGuid);

    TC_LOG_DEBUG("bg.arena", "New ArenaTeam created [Id: %u, Name: %s] [Type: %u] [Captain low GUID: %u]", GetId(), GetName().c_str(), GetType(), captainLowGuid);
    return true;
}
Ejemplo n.º 6
0
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int C_BaseObject::GetDisplayPriority( void )
{
	return GetObjectInfo( GetType() )->m_iDisplayPriority;	
}
Ejemplo n.º 7
0
const std::string CayenneBody::GetDescription() const
{
  std::stringstream desc;
  desc << GetColor() <<  " Cayenne " << IBody::GetTypeName(GetType()) << " body";
  return desc.str();
}
Ejemplo n.º 8
0
bool PluginPreference::IsBoolean() { return GetType() == PluginPreferenceType::CheckBox; }
Ejemplo n.º 9
0
bool PluginPreference::IsInteger() { return GetType() == PluginPreferenceType::Spinner; }
Ejemplo n.º 10
0
uint32_t PERKRecord::GetFieldAttribute(FIELD_IDENTIFIERS, uint32_t WhichAttribute)
    {
    switch(FieldID)
        {
        case 0: //recType
            return GetType();
        case 1: //flags1
            return CB_UINT32_FLAG_FIELD;
        case 2: //fid
            return CB_FORMID_FIELD;
        case 3: //versionControl1
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 4;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 4: //eid
            return CB_ISTRING_FIELD;
        case 5: //formVersion
            return CB_UINT16_FIELD;
        case 6: //versionControl2
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 2;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 7: //full
            return CB_STRING_FIELD;
        case 8: //description
            return CB_STRING_FIELD;
        case 9: //iconPath
            return CB_ISTRING_FIELD;
        case 10: //smallIconPath
            return CB_ISTRING_FIELD;
        case 11: //ctda Conditions
            return CB_UINT8_FIELD;
        case 12: //ctda_p Conditions
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 3;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 13: //ctda Conditions
            return CB_UNKNOWN_FIELD; // UNPARSED_FIELD;
        case 14: //ctda Conditions
            return CB_UINT32_FIELD;
        case 15: //ctda_p Conditions
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 4;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 16: //ctda_p Conditions
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 4;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 17: //ctda Conditions
            return CB_UINT32_FIELD;
        case 18: //ctda Conditions
            return CB_UNKNOWN_FIELD; // UNPARSED_FIELD;
        case 19: //data DATA ,, Struct
            return CB_UINT8_FIELD;
        case 20: //data DATA ,, Struct
            return CB_UINT8_FIELD;
        case 21: //data DATA ,, Struct
            return CB_UINT8_FIELD;
        case 22: //data DATA ,, Struct
            return CB_UINT8_FIELD;
        case 23: //data DATA ,, Struct
            return CB_UINT8_FIELD;
        case 24: //prke PRKE ,, Struct
            return CB_UINT8_FIELD;
        case 25: //prke PRKE ,, Struct
            return CB_UINT8_FIELD;
        case 26: //prke PRKE ,, Struct
            return CB_UINT8_FIELD;
        case 27: //prke PRKE ,, Struct
            return CB_FORMID_FIELD;
        case 28: //prke PRKE ,, Struct
            return CB_FORMID_FIELD;
        case 29: //prke PRKE ,, Struct
            return CB_UINT8_FIELD;
        case 30: //prke PRKE ,, Struct
            return CB_UINT8_FIELD;
        case 31: //prke PRKE ,, Struct
            return CB_UINT8_FIELD;
        case 32: //prkc Run On
            return CB_SINT8_FIELD;
        case 33: //ctda Conditions
            return CB_UINT8_FIELD;
        case 34: //ctda_p Conditions
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 3;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 35: //ctda Conditions
            return CB_UNKNOWN_FIELD; // UNPARSED_FIELD;
        case 36: //ctda Conditions
            return CB_UINT32_FIELD;
        case 37: //ctda_p Conditions
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 4;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 38: //ctda_p Conditions
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 4;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 39: //ctda Conditions
            return CB_UINT32_FIELD;
        case 40: //ctda Conditions
            return CB_UNKNOWN_FIELD; // UNPARSED_FIELD;
        case 41: //epft Type
            return CB_UINT8_FIELD;
        case 42: //data Leveled Item
            return CB_FORMID_FIELD;
        case 43: //epf2 Button Label
            return CB_ISTRING_FIELD;
        case 44: //epf3 Script Flags
            return CB_UINT16_FIELD;
        case 45: //schr_p Basic Script Data
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 4;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 46: //schr Basic Script Data
            return CB_UINT32_FIELD;
        case 47: //schr Basic Script Data
            return CB_UINT32_FIELD;
        case 48: //schr Basic Script Data
            return CB_UINT32_FIELD;
        case 49: //schr Basic Script Data
            return CB_UINT16_FIELD;
        case 50: //schr Basic Script Data
            return CB_UINT16_FIELD;
        case 51: //scda_p Compiled Embedded Script
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 0; // SCDA.GetSize();
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 52: //sctx Embedded Script Source
            return CB_ISTRING_FIELD;
        case 53: //slsd Local Variable Data
            return CB_UINT32_FIELD;
        case 54: //slsd_p Local Variable Data
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 12;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 55: //slsd Local Variable Data
            return CB_UINT8_FIELD;
        case 56: //slsd_p Local Variable Data
            switch(WhichAttribute)
                {
                case 0: //fieldType
                    return CB_UINT8_ARRAY_FIELD;
                case 1: //fieldSize
                    return 7;
                default:
                    return CB_UNKNOWN_FIELD;
                }
            return CB_UNKNOWN_FIELD;
        case 57: //scvr Name
            return CB_ISTRING_FIELD;
        case 58: //scro Global Reference
            return CB_FORMID_FIELD;
        case 59: //scrv Local Variable
            return CB_UINT32_FIELD;
        default:
            return CB_UNKNOWN_FIELD;
        }
    return CB_UNKNOWN_FIELD;
    }
Ejemplo n.º 11
0
// operator==
bool
BGradient::operator==(const BGradient& other) const
{
	return ((other.GetType() == GetType()) && ColorStopsAreEqual(other));
}
Ejemplo n.º 12
0
/*
+-----------------+------------------------------------------------------------+
| FUNCION         | SndTrxOffLine::ProcessIt                                   |
+-----------------+------------------------------------------------------------+
| DESCRIPCION     | Proceso del objeto                                         |
|                 |                                                            | 
+-----------------+------------------------------------------------------------+
*/
int SndTrxOffLine::ProcessIt()
{
    int             len;
    int             ret;
    int				iCont;
	str_sel_cadata  term_data;
    char            msg_str[2000];
    char            aux_str[20];
    trxOffHeap      infoHeap;         
    DBInfoEnvio     InfoEnvio;        
    str_fet_bu_trx  trxOff;
    int             pos_ocup;
    str_tarjeta     data_tar;
	char			aux_str1[100];	
    DBTrxPk         trxPk;             
    char			idHeap[20];
	char			szFechaEnvio[16];
	int				iErrorBD;
	int				iNroCuotas;

	/* Carga estructura para busqueda de transaccion offline */
    strncpy(trxOff.cod_tar   , CodTarjeta, sizeof(trxOff.cod_tar));
    strncpy(trxOff.cod_est   , "00"      , sizeof(trxOff.cod_est));
    strncpy(trxOff.nro_caj_ca, NroCajCa  , sizeof(trxOff.nro_caj_ca));
    strncpy(trxOff.nro_trx   , NroTrx    , sizeof(trxOff.nro_trx));
	trxOff.nro_caj_ca[sizeof(trxOff.nro_caj_ca)-1]='\0';
    trxOff.cod_tar   [sizeof(trxOff.cod_tar)   -1]='\0';
	trxOff.cod_est   [sizeof(trxOff.cod_est)   -1]='\0';
	trxOff.nro_trx   [sizeof(trxOff.nro_trx)   -1]='\0';

    /* Busca en BD una transaccion offline */
    LogAlarm.Put(0, "TrxOff: Lee offline [%s] [%s] [%s] [%s]\n", trxOff.nro_caj_ca, trxOff.cod_tar, trxOff.cod_est, trxOff.nro_trx);
	ret=DBGetNextTrx(&trxOff, &iErrorBD);
    if (ret!=OK)
    {
		LogAlarm.Put( 0, "TrxOff: Retorno de recuperacion de offline:%d Errno:%d\n", ret, iErrorBD);
		EnviarMsg(orig_pid, "ERROR", 5);
		return OK; 
	}
    //LogAlarm.Put(0, "TrxOff: Rowid a enviar [%s]\n",trxOff.rowid);

	/* Obtiene datos del centro autorizador */
    LogAlarm.Put(5, "TrxOff: Obtiene codigo de centro\n");
	strcpy(data_tar.cod_tar, trxOff.cod_tar);
	ret = ObtCA(&data_tar);
	if (ret!=OK)
	{
		LogAlarm.Put(0, "TrxOff: ERROR al obtener CA. Tar:[%s]\n", trxOff.cod_tar);
		EnviarMsg(orig_pid, "ERROR", 5);
		return OK; 
	}       

	/* Verifica si la caja esta libre */
    strcpy(term_data.nro_caj, trxOff.nro_caj);
    pos_ocup = P.IsPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
    if (pos_ocup)
    {    
		/* Marca la caja como ocupada */
		ret = P.SetPosBusy(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		if (ret!=OK)
		{
			LogAlarm.Put(0, "TrxOff: ERROR al setear caja como ocupada\n");
		}
    }
    else
    {
        /* Retorna envio de caja bloqueada */
		LogAlarm.Put(0, "TrxOff: ERROR. Caja bloqueada\n");
		EnviarMsg(orig_pid, "BLOCK", 5);
		return NOOK;
    }

    /* Arma el mensaje base de acuerdo al codigo de transaccion */
	switch (atoi(trxOff.cod_trx))
	{
	case T_VENT:
		IsoMsg=new Iso_Msg(TYPE_VISA_VENTA_LOCAL);
		break;
	case T_DEVO:
		IsoMsg=new Iso_Msg(TYPE_VISA_DEVOL_LOCAL);
		break;
	case T_PAGO:
		IsoMsg=new Iso_Msg(TYPE_VISA_VENTA_LOCAL);
		sprintf(aux_str1, "%06d", OPCODE_VISA_PAGO_RESUMEN);
		IsoMsg->PutField(3, aux_str1);
		break;
	case T_DEVP:
		IsoMsg=new Iso_Msg(TYPE_VISA_DEVOL_LOCAL);
		sprintf(aux_str1, "%06d", OPCODE_VISA_DEVO_RESUMEN);
		IsoMsg->PutField(3, aux_str1);
		break;
	default: /* Tipo de transaccion desconocida */
		/* Libera la caja */
		ret = P.SetPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		if (ret != OK)
		{
			LogAlarm.Put(0, "TrxOff: ERROR en SetPosFree. CA:[%s] Emp:[%s] Caj:[%s]\n", 
							data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		}
		LogAlarm.Put(0, "TrxOff: ERROR. Mensaje desconocido\n");
		EnviarMsg(orig_pid, "ERROR", 5);
		return NOOK;
	}

	/* Setea centro autorizador */
	IsoMsg->SetNroCA8583(data_tar.nro_ca);

	/* Arma la informacion para el heap */
    infoHeap.origPid=orig_pid;
    strncpy( infoHeap.nroSuc  , trxOff.nro_suc, sizeof(infoHeap.nroSuc  ) );
    strncpy( infoHeap.nroTerm , trxOff.nro_caj, sizeof(infoHeap.nroTerm ) );
    strncpy( infoHeap.nroTrans, trxOff.nro_tic, sizeof(infoHeap.nroTrans) );
    strncpy( infoHeap.fechaTrx, trxOff.fec_loc, sizeof(infoHeap.fechaTrx) );
    strncpy( infoHeap.codTar  , trxOff.cod_tar, sizeof(infoHeap.codTar  ) );
    strncpy( infoHeap.NroCajCa, trxOff.nro_caj_ca,sizeof(infoHeap.NroCajCa));
    strcpy ( infoHeap.Rowid,    trxOff.rowid);
    infoHeap.nroSuc  [sizeof(infoHeap.nroSuc   )-1]='\0';
    infoHeap.nroTerm [sizeof(infoHeap.nroTerm  )-1]='\0';
    infoHeap.nroTrans[sizeof(infoHeap.nroTrans )-1]='\0';
    infoHeap.fechaTrx[sizeof(infoHeap.fechaTrx )-1]='\0';
    infoHeap.codTar  [sizeof(infoHeap.codTar   )-1]='\0';
    infoHeap.NroCajCa[sizeof(infoHeap.NroCajCa )-1]='\0';   

     /* Convierte la tarjeta a standard ISO (sin espsacio y formato LLL-VAR */
    int counter=0;
    for (counter=0;counter<sizeof(trxOff.nro_tar);counter++)
    {
		if (trxOff.nro_tar[counter]<'0' || trxOff.nro_tar[counter]>'9')
		{
			break;
		} 
    }
    trxOff.nro_tar[counter]='\0';

    /* Configura datos de la terminal */
	strcpy(term_data.cod_tar, trxOff.cod_tar);
    strcpy(term_data.nro_suc, infoHeap.nroSuc);
    strcpy(term_data.nro_caj, infoHeap.nroTerm);
    strcpy(term_data.plan_sf, trxOff.plan_sf);

    /* Busca terminal en base de datos */
	ret=getDataByNT2(&term_data);
    if ( (ret!=OK) || (term_data.caj_bloq==1) )
    {
		/* Loguea error de terminal */
		LogErrTerminal.Put(0, "Fecha Hora %s", currentTimeLog() );
        LogErrTerminal.Put(0, "Caja: %s - Sucursal: %s - Tarjeta: %s - Plan: %s - Evento: TrxOff\n\n", 
							term_data.nro_caj, term_data.nro_suc, term_data.cod_tar, term_data.plan_sf);
        LogAlarm.Put(0, "TrxOff: ERROR (%d) de terminal (%s) bloqueada (%d)\n", ret, term_data.nro_caj, term_data.caj_bloq);
    
        /* Libera la caja */
		ret = P.SetPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
        if (ret != OK)
        {
             LogAlarm.Put(0, "TrxOff: ERROR en SetPosFree. CA:[%s] Emp:[%s] Caj:[%s]\n", 
								data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
        }
        EnviarMsg(orig_pid, "ERROR", 5);
        return NOOK;
    }

    /* Numero de Tarjeta */
	sprintf(aux_str1,"%02d%s",counter,trxOff.nro_tar);
    IsoMsg->PutField(2, aux_str1);

    /* Monto */
	sprintf(aux_str1,"%012ld",atol(trxOff.monto));
    IsoMsg->PutField(4, aux_str1);

	/* Fecha de transmision */
	sprintf(szFechaEnvio, currentTimestamp());
    IsoMsg->PutField(7, szFechaEnvio);

	/* Si hora operacion mayor a transmision se rechaza */
	/* Quitar si sincronizan hora los servidores        */
	switch (DBTipoProtocoloISO(trxOff.nro_ca))
	{
	case PROT_ISO_AMEX: 
		if (strcmp(trxOff.fec_loc, szFechaEnvio)>0)
		{
			LogAlarm.Put(0, "TrxOff: Ter:[%s] Trx:[%04d]\n", infoHeap.nroTerm, atoi(infoHeap.nroTrans));
			LogAlarm.Put(0, "TrxOff: ERROR fecha/hora FHoperac[%s] FHtransm[%s]\n", trxOff.fec_loc, szFechaEnvio);
			/* Libera la caja */
			ret = P.SetPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
			if (ret != OK)
			{
				LogAlarm.Put(0, "TrxOff: ERROR en SetPosFree. CA:[%s] Emp:[%s] Caj:[%s]\n", 
								data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
			}
			EnviarMsg(orig_pid, "ERROR", 5);
	        return NOOK;
		}
		break;
	default:
		break;
	}

   	/* Numero de trace */
    TraceNumber.SetNroSuc(term_data.nro_suc);
    TraceNumber.SetNroCaj(term_data.nro_caj);
    TraceNumber.SetNroCA (term_data.nro_ca );
    TraceNumber.SetCodConCie(term_data.cod_con_cie);
    strcpy(aux_str, TraceNumber);
    TraceNumber.Inc();
    IsoMsg->PutField(11, aux_str); 

	/* Hora local */
	IsoMsg->PutField(12, trxOff.fec_loc+4);
    
	/* Fecha local */
	IsoMsg->PutField(13, trxOff.fec_loc);
    
	/* Fecha de expiracion */
	IsoMsg->PutField(14, trxOff.fec_ven);
    
	/* Fecha de captura */
	switch (DBTipoProtocoloISO(trxOff.nro_ca))
	{
	case PROT_ISO_AMEX:
		break;
	default:
		IsoMsg->PutField(17, trxOff.fec_loc);
		break;
	}
    
	/* Modo de ingreso */
	IsoMsg->PutField(22, trxOff.mod_ing );
		
	/* Codigo de red */
    IsoMsg->PutField(24, term_data.cod_red);
    
	/* Codigo de condicion */
	IsoMsg->PutField(25, "00" );

	/* Track 2 si ingreso fue por banda */
	switch (DBTipoProtocoloISO(trxOff.nro_ca))
	{
	case PROT_ISO_AMEX:
		break;
	default:
		if (   !strcmp(trxOff.mod_ing, "022") 
			|| !strcmp(trxOff.mod_ing, "062") ) 
		{
			sprintf(aux_str1, "%02d%s", strlen(trxOff.track2), trxOff.track2);
			IsoMsg->PutField(35, aux_str1);
		}
		break;
	}

	/* Codigo de autorizacion */
	sprintf(aux_str1, "%s", trxOff.cod_aut);
	switch (DBTipoProtocoloISO(trxOff.nro_ca))
	{
	case PROT_ISO_AMEX:
		if( (atoi(trxOff.cod_trx)==T_DEVO) || (atoi(trxOff.cod_trx)==T_DEVP) )
		{
			if (atoi(trxOff.mod_env)==T_OFLI)
			{
				sprintf(aux_str1, "      "); // Devolucion offline Amex
			}
		}
		break;
	default:
		break;
	}
	IsoMsg->PutField(38, aux_str1);

	/* Terminal centro autorizador */
    IsoMsg->PutField(41, term_data.nro_caj_ca);

	/* Comercio centro autorizador */	
    sprintf(aux_str1,"%-15s",term_data.nro_com);
    IsoMsg->PutField(42, aux_str1);

	/* #37322 Cuotas articulos nacionales */
	iNroCuotas = ( term_data.plan_esp > 0 ) ? term_data.plan_esp : atoi(trxOff.nro_cuo) ;
	/* Campo Cuotas */
	sprintf(aux_str1,"003%1.1s%2.2d",trxOff.plan_iso, iNroCuotas);
	if( (atoi(trxOff.cod_trx)==T_DEVO) || (atoi(trxOff.cod_trx)==T_DEVP) )
    {
		if(useCampCuot(trxOff.nro_ca)==1)
		{
			sprintf(aux_str1, "013%1.1s%02d%04d%6s", 
						trxOff.plan_iso, iNroCuotas, atoi(trxOff.nro_tic_ori), trxOff.fec_ori);
		}
    }
	/* Compras AMEX de contado no se envia campo 48 */
	switch (DBTipoProtocoloISO(trxOff.nro_ca))
	{
	case PROT_ISO_AMEX: 
		if (strcmp(aux_str1, "003001")==0) 
		{
			memset(aux_str1, 0, sizeof(aux_str1));
		}
		break;
	default:
		break;
	}
	/* Agrega campo */
	if ( strlen(aux_str1) > 0 )
	{
		IsoMsg->PutField(48, aux_str1);
	}

	/* Codigo de moneda */
	IsoMsg->PutField(49, trxOff.cod_mon );

	/* Fecha de diferimiento (si no es devolucion) */
	if (term_data.dias_dif > 0)
	{
		if( (atoi(trxOff.cod_trx)!=T_DEVO) && (atoi(trxOff.cod_trx)!=T_DEVP) )
		{
			char szFechaDif[6+1];
			if (getFechaDif(trxOff.fec_trx, term_data.dias_dif, szFechaDif)==0)
			{
				ret = strlen(CAMPO_FECHA_DIFE) + strlen(szFechaDif);
				sprintf(aux_str1, "%03d%s%s", ret, CAMPO_FECHA_DIFE, szFechaDif);
				ret = IsoMsg->PutField(59, aux_str1);
				LogAlarm.Put(10, "TrxOff: Campo 59:[%s] Ret:[%d]\n", aux_str1, ret);
			}
		}
	}

    /* Numero de ticket */
	sprintf(aux_str1,"004%04d", atoi(trxOff.nro_tic));
    IsoMsg->PutField(62, aux_str1 );

    LogAlarm.Put(0, "TrxOff: Emp:[%s] Suc:[%s] Ter:[%s] Trx:[%04d] Rowid:[%s]\n", 
						term_data.nro_suc, term_data.nro_caj_sf, infoHeap.nroTerm, 
						atoi(infoHeap.nroTrans), trxOff.rowid);

	/* Arma clave para el heap */
    sprintf(idHeap, "%2.2s%3.3s%5.5s%8.8s", term_data.nro_ca, term_data.nro_suc, term_data.nro_caj, IsoMsg->GetField(11));

    /* Pone datos en el heap */
    LogAlarm.Put(5, "TrxOff: Pone datos en el Heap\n");
	ret=Heap.PutData(idHeap,(char *)&infoHeap, sizeof(infoHeap));
	if (ret==NOOK)
	{
		LogAlarm.Put(0, "TrxOff: ERROR (%d) al insertar en Heap. Clave:[%s]\n", Heap.GetErrno(), idHeap);

		/* Libera la caja */
		ret = P.SetPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		if (ret != OK)
		{
			LogAlarm.Put(0, "TrxOff: ERROR en SetPosFree. CA:[%s] Emp:[%s] Caj:[%s]\n", 
								data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		}
        EnviarMsg(orig_pid, "ERROR", 5);
		return NOOK;
	}

    /* Carga estructura para actualizar la base de datos */
	strncpy( trxPk.nroSuc  , trxOff.nro_suc, sizeof(trxPk.nroSuc  ) );
    strncpy( trxPk.nroTerm , trxOff.nro_caj, sizeof(trxPk.nroTerm ) );
    strncpy( trxPk.nroTrans, trxOff.nro_tic, sizeof(trxPk.nroTrans) );
    strncpy( trxPk.fechaTrx, trxOff.fec_loc, sizeof(trxPk.fechaTrx) );
    strncpy( trxPk.rowid   , trxOff.rowid  , sizeof(trxPk.rowid   ) );

    /* Carga estructura para actualizar la base de datos */
	strncpy(InfoEnvio.cod_est, "01", sizeof(InfoEnvio.cod_est ));
    strncpy(InfoEnvio.fec_env, szFechaEnvio, sizeof(InfoEnvio.fec_env ));
    strncpy(InfoEnvio.nro_lot, "0000", sizeof(InfoEnvio.nro_lot));
    strncpy(InfoEnvio.nro_trc, IsoMsg->GetField(11), sizeof(InfoEnvio.nro_trc));

	/* Actualiza la base de datos */
    ret=DBUpdEnvio(trxPk , InfoEnvio);
    LogAlarm.Put(0, "TrxOff: Actualiza informacion de Envio. Retorno:%d\n", ret);

    /* Registra en cola de timeout */
	strcpy(aux_str, IsoMsg->GetField(11));
    Cfg.GetItem("TimeOutDaemon", "MsgTimeOut1", aux_str1);
	LogAlarm.Put(0, "TrxOff: Timeout ID Trace [%s]\n", idHeap);
    ret=timeout_queue.SetTimeOut(idHeap, atoi(aux_str1), GetType(), "");
    if (ret==NOOK)
    {
        LogAlarm.Put(0, "TrxOff: ERROR (%d) al registrar en TOQ\n",ret);

		/* Libera la caja */
		ret = P.SetPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		if (ret != OK)
		{
			LogAlarm.Put(0, "TrxOff: ERROR en SetPosFree. CA:[%s] Emp:[%s] Caj:[%s]\n", 
							data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
		}

		/* Retira del heap */
		ret=Heap.GetData(idHeap,(char *)&infoHeap, sizeof(infoHeap));
		if (ret == NOOK)
		{
			LogAlarm.Put( 0, "TrxOff: ERROR (%d) al obtener del heap\n", Heap.GetErrno());
		}
		
		/* Envia respuesta */
		EnviarMsg(orig_pid, "ERROR", 5);
		
		return NOOK;
    }

    /* Aplana el mensaje */
    len=IsoMsg->GetMsgString(msg_str);

	/* Loguea el mensaje */
	for (iCont=0; iCont<64; iCont++)
	{
		if (IsoMsg->ChkField(iCont))
		{
			LogAlarm.Put(5, "TrxOff: Campo %02d: Valor:[%s]\n", iCont, IsoMsg->GetField(iCont) );
		}
	}

    /* Envia el mensaje a X25 */
	LogAlarm.Put(0, "TrxOff: Envia a X.25. CAut [%s]\n", term_data.nro_ca);
    ret=XQueue.SendMsg(atoi(term_data.nro_ca)+1, msg_str, len);
    if (ret!=OK)
    {
        LogAlarm.Put(0, "TrxOff: ERROR en Envio X.25(%d)\n", XQueue.GetErrno());

		/* Libera la caja */
        ret = P.SetPosFree(data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
        if (ret != OK)
        {
             LogAlarm.Put(0, "TrxOff: ERROR en SetPosFree. CA:[%s] Emp:[%s] Caj:[%s]\n", 
								data_tar.nro_ca, trxOff.nro_suc, trxOff.nro_caj);
        }
        
		/* Envia respuesta */
		EnviarMsg(orig_pid, "ERROR", 5);

        return NOOK;
    }
    return OK;
}
Ejemplo n.º 13
0
/*--------------------------------------------------------------------------*/
int sci_mcisendstring(char *fname, unsigned long l)
{
    int m1, n1, l1;

    char *Output = NULL;
    int *BoolOutput = NULL;
    int *CodeOutput = NULL;

    CheckRhs(1, 1);
    CheckLhs(1, 3);

    if (GetType(1) == sci_strings)
    {
        MCIERROR Error;
        char *MCICommand = NULL;
        char ReturnString[2048];

        GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
        MCICommand = cstk(l1);

        Error = mciSendString(MCICommand, (LPSTR)ReturnString, sizeof(ReturnString), NULL);

        BoolOutput = (int*)MALLOC(sizeof(int));
        CodeOutput = (int*)MALLOC(sizeof(int));

        *BoolOutput = (int)0;
        *CodeOutput = (int)Error;
        if (Error)
        {
            char ErrorText[128];
            *BoolOutput = (int)FALSE;

            if ( mciGetErrorString(Error, ErrorText, sizeof(ErrorText)) == FALSE )
            {
                wsprintf(ErrorText, "%s", "Unknown MCI error");
            }

            Output = strdup(ErrorText);
        }
        else
        {
            *BoolOutput = (int)TRUE;
            Output = strdup("OK");
        }

        n1 = 1;

        if ( Lhs == 1 )
        {
            CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
            LhsVar(1) = Rhs + 1;
        }
        else if ( Lhs == 2 )
        {
            CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
            LhsVar(1) = Rhs + 1;

            CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
            LhsVar(2) = Rhs + 2;
        }
        else /* Lhs == 3 */
        {
            CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &BoolOutput);
            LhsVar(1) = Rhs + 1;

            CreateVarFromPtr(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &n1, &n1, &CodeOutput);
            LhsVar(2) = Rhs + 2;

            m1 = (int)strlen(Output);
            CreateVarFromPtr(Rhs + 3, STRING_DATATYPE, &m1, &n1, &Output);
            LhsVar(3) = Rhs + 3;
        }

        if (Output)
        {
            FREE(Output);
            Output = NULL;
        }
        if (BoolOutput)
        {
            FREE(BoolOutput);
            BoolOutput = NULL;
        }
        if (CodeOutput)
        {
            FREE(CodeOutput);
            Output = NULL;
        }

        PutLhsVar();

        return 0;
    }
    else
    {
        Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
        return 0;
    }
}
Ejemplo n.º 14
0
    // For a synth fun, we need to ensure that arguments are
    // all aux vars (either base or derived)
    void SpecRewriter::VisitUserSynthFuncExpression(const UserSynthFuncExpression* Exp)
    {
        // Push through the children first.
        auto const& Children = Exp->GetChildren();
        const uint32 NumChildren = Children.size();
        for (auto const& Child : Children) {
            Child->Accept(this);
        }

        // The rewritten expressions are on the stack now,
        // we need to check if any of them is an expression
        // which needs to be computed. If so, we create an
        // aux var for the subexpression and set up an evaluation
        // rule
        // Gather the child expressions first
        vector<Expression> SubstChildren(Children.size());
        for (uint32 i = 0; i < NumChildren; ++i) {
            SubstChildren[Children.size() - i - 1] = RewriteStack.back();
            RewriteStack.pop_back();
        }

        vector<Expression> NewSubstChildren;

        for (auto const& Child : SubstChildren) {
            if (Child->GetOp()->GetArity() > 1) {
                // We need to fixup an eval rule for this child
                // Check if one already exists for it first
                auto it = ExpMap.find(Child);
                if (it != ExpMap.end()) {
                    NewSubstChildren.push_back(it->second);
                } else {
                    // Create a new aux var
                    auto Op = Solver->CreateAuxVariable(AuxIDCounter++, Child->GetType());
                    auto AuxExp = Solver->CreateExpression(Op);
                    ExpMap[Child] = AuxExp;

                    auto Pure = IsPure(Child);
                    if (Pure) {
                        BaseAuxVarOps.push_back(Op);
                    } else {
                        DerivedAuxVarOps.push_back(Op);
                        // set up an eval rule for this aux var
                        EvalRules.push_back(EvalRule(Op, Child));
                    }
                    NewSubstChildren.push_back(AuxExp);
                }
            } else {
                NewSubstChildren.push_back(Child);
            }
        }

        // Create the expression with the substitutions
        auto NewExp = Solver->CreateExpression(Exp->GetOp(), NewSubstChildren);

        // Since this is a synth func expression,
        // we need to create a derived aux var for 
        // ourselves and substitute the derived aux for
        // ourself. But first check if there is already
        // a derived var available (CSE)
        auto it = ExpMap.find(Exp);
        if (it != ExpMap.end()) {
            // No need to create more derived vars
            RewriteStack.push_back(it->second);
        } else {
            auto Op = Solver->CreateAuxVariable(AuxIDCounter++, NewExp->GetType());
            auto AuxExp = Solver->CreateExpression(Op);
            ExpMap[Exp] = AuxExp;

            DerivedAuxVarOps.push_back(Op);
            EvalRules.push_back(EvalRule(Op, NewExp));
            RewriteStack.push_back(AuxExp);
        }
    }
Ejemplo n.º 15
0
const char* C_BaseObject::GetStatusName() const
{
	return GetObjectInfo( GetType() )->m_pStatusName;
}
Ejemplo n.º 16
0
void AirspaceHoldInSim::getDesc( ResourceDesc& resDesc )
{
	resDesc.resid = GetHoldInput()->getID();
	resDesc.resType = GetType();
	resDesc.strRes = PrintResource();
}
Ejemplo n.º 17
0
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_BaseObject::GetTargetIDString( wchar_t *sIDString, int iMaxLenInBytes )
{
	sIDString[0] = '\0';

	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

	if ( !pLocalPlayer )
		return;

	if ( InSameTeam( pLocalPlayer ) || pLocalPlayer->IsPlayerClass( TF_CLASS_SPY ) || pLocalPlayer->GetTeamNumber() == TEAM_SPECTATOR )
	{
		wchar_t wszBuilderName[ MAX_PLAYER_NAME_LENGTH ];

		const char *pszStatusName = GetStatusName();
		wchar_t *wszObjectName = g_pVGuiLocalize->Find( pszStatusName );

		if ( !wszObjectName )
		{
			wszObjectName = L"";
		}

		C_BasePlayer *pBuilder = GetOwner();

		if ( pBuilder )
		{
			g_pVGuiLocalize->ConvertANSIToUnicode( pBuilder->GetPlayerName(), wszBuilderName, sizeof(wszBuilderName) );
		}
		else
		{
			wszBuilderName[0] = '\0';
		}

		// building or live, show health
		const char *printFormatString;
		
		if ( GetObjectInfo(GetType())->m_AltModes.Count() > 0 )
		{
			printFormatString = "#TF_playerid_object_mode";

			pszStatusName = GetObjectInfo( GetType() )->m_AltModes.Element( m_iObjectMode * 3 + 1 );
			wchar_t *wszObjectModeName = g_pVGuiLocalize->Find( pszStatusName );

			if ( !wszObjectModeName )
			{
				wszObjectModeName = L"";
			}

			g_pVGuiLocalize->ConstructString( sIDString, iMaxLenInBytes, g_pVGuiLocalize->Find(printFormatString),
				4,
				wszObjectName,
				wszBuilderName,
				wszObjectModeName);
		}
		else
		{
			if ( m_bMiniBuilding )
				printFormatString = "#TF_playerid_object_mini";
			else
				printFormatString = "#TF_playerid_object";

			g_pVGuiLocalize->ConstructString( sIDString, iMaxLenInBytes, g_pVGuiLocalize->Find( printFormatString ),
				3,
				wszObjectName,
				wszBuilderName );
		}
	}
}
Ejemplo n.º 18
0
/*--------------------------------------------------------------------------*/
int sci_TCL_UpVar (char *fname,unsigned long l)
{
	CheckRhs(2,3);
	CheckLhs(0,1);

	if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
	{
		int m1 = 0, n1 = 0, l1 = 0;
		int m2 = 0, n2 = 0, l2 = 0;

		Tcl_Interp *TCLinterpreter = NULL;
		char *sourceName = NULL, *destName = NULL;
		int *paramoutINT = (int*)MALLOC(sizeof(int));

		GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
		sourceName = cstk(l1);

		GetRhsVar(2,STRING_DATATYPE,&m2,&n2,&l2);
		destName = cstk(l2);

		if (getTclInterp() == NULL)
		{
			releaseTclInterp();
			Scierror(999,_("%s: Error main TCL interpreter not initialized.\n"),fname);
			return 0;
		}
		releaseTclInterp();

		if (Rhs == 3)
		{
			int m3 = 0, n3 = 0, l3 = 0;
			/* three arguments given - get a pointer on the slave interpreter */
			if (GetType(3) == sci_strings)
			{
				GetRhsVar(3,STRING_DATATYPE,&m3,&n3,&l3);
				TCLinterpreter = Tcl_GetSlave(getTclInterp() ,cstk(l3));
				releaseTclInterp();
				if (TCLinterpreter == NULL)
				{
					Scierror(999,_("%s: No such slave interpreter.\n"),fname);
					return 0;
				}
			}
			else
			{
				Scierror(999,_("%s: Wrong type for input argument #%d: String expected.\n"),fname, 3);
				return 0;
			}
		}
		else
		{
			/* only two arguments given - use the main interpreter */
			TCLinterpreter = getTclInterp();
			releaseTclInterp();
		}

		if ( Tcl_GetVar(TCLinterpreter, sourceName, TCL_GLOBAL_ONLY) )
		{
			if ( Tcl_UpVar(TCLinterpreter,"#0", sourceName, destName, TCL_GLOBAL_ONLY) == TCL_ERROR )
			{
				*paramoutINT = (int)(FALSE);
			}
			else
			{
				*paramoutINT = (int)(TRUE);
			}
		}
		else
		{
			*paramoutINT = (int)(FALSE);
		}

		n1 = 1;
		CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &paramoutINT);
		LhsVar(1) = Rhs+1;
        if (paramoutINT) {FREE(paramoutINT); paramoutINT = NULL;}
		PutLhsVar();
	}
	else
	{
		Scierror(999,_("%s: Wrong type for input argument #%d or #%d: String expected.\n"),fname, 1, 2);
	}
	return 0;
}
Ejemplo n.º 19
0
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *C_BaseObject::GetHudStatusIcon( void )
{
	return GetObjectInfo( GetType() )->m_pHudStatusIcon;	
}
Ejemplo n.º 20
0
/*--------------------------------------------------------------------------*/
int C2F(sci_getmd5) (char *fname, unsigned long fname_len)
{
    int m1 = 0, n1 = 0;

    int mn = 0;
    int i  = 0;

    char **Input_Matrix  = NULL;
    char **Output_Matrix = NULL;

    Rhs = Max(Rhs, 0);
    CheckRhs(1, 2) ;
    CheckLhs(1, 1) ;

    if (Rhs == 1)
    {
        if (GetType(1) == sci_strings)
        {
            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &Input_Matrix);
            mn = m1 * n1;

            Output_Matrix = (char**)MALLOC(sizeof(char*) * (mn));
            if (Output_Matrix)
            {
                for (i = 0; i < mn; i++)
                {
                    FILE *fp = NULL;
                    char *MD5 = NULL;
                    char *real_path = NULL;

                    /* Replaces SCI, ~, HOME, TMPDIR by the real path */
                    real_path = expandPathVariable(Input_Matrix[i]);

                    /* bug 4469 */
                    if (isdir(real_path))
                    {
                        Scierror(999, _("%s: The file %s does not exist.\n"), fname, Input_Matrix[i]);
                        freeArrayOfString(Output_Matrix, i);
                        freeArrayOfString(Input_Matrix, mn);
                        FREE(real_path);
                        real_path = NULL;
                        return 0;
                    }

                    wcfopen(fp, real_path, "rb");

                    if (real_path)
                    {
                        FREE(real_path);
                        real_path = NULL;
                    }

                    if (fp)
                    {
                        MD5 = md5_file(fp);
                        fclose(fp);
                        Output_Matrix[i] = strdup(MD5);
                        if (MD5)
                        {
                            FREE(MD5);
                            MD5 = NULL;
                        }
                    }
                    else
                    {
                        Scierror(999, _("%s: The file %s does not exist.\n"), fname, Input_Matrix[i]);
                        freeArrayOfString(Output_Matrix, i);
                        freeArrayOfString(Input_Matrix, mn);
                        return 0;
                    }
                }

                CreateVarFromPtr( Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, Output_Matrix );
                LhsVar(1) = Rhs + 1 ;
                PutLhsVar();
            }
            else
            {
                Scierror(999, _("%s: Memory allocation error.\n"), fname);
            }
        }
        else
        {
            Scierror(999, _("%s: Wrong type of input argument #%d: String expected.\n"), fname, 1);
        }
    }
    else /* Rhs == 2 */
    {
        if ( (GetType(1) == sci_strings) && (GetType(2) == sci_strings) )
        {
            int m2 = 0, n2 = 0, l2 = 0;
            char *Param2 = NULL;

            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &Input_Matrix);
            mn = m1 * n1;

            GetRhsVar(2, STRING_DATATYPE, &m2, &n2, &l2);
            Param2 = cstk(l2);

            if ( stricmp(Param2, "string") == 0 )
            {
                Output_Matrix = (char**)MALLOC(sizeof(char*) * (mn));

                if (Output_Matrix)
                {
                    for (i = 0; i < mn; i++)
                    {
                        char *MD5 = NULL;

                        MD5 = md5_str(Input_Matrix[i]);
                        Output_Matrix[i] = strdup(MD5);
                        if (MD5)
                        {
                            FREE(MD5);
                            MD5 = NULL;
                        }

                        if (Output_Matrix[i] == NULL)
                        {
                            freeArrayOfString(Input_Matrix, m1 * n1);
                            freeArrayOfString(Output_Matrix, i);
                            Scierror(999, ("%s: No more memory.\n"), fname);
                            return 0;
                        }
                    }

                    CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, Output_Matrix );
                    LhsVar(1) = Rhs + 1 ;
                    PutLhsVar();
                }
                else
                {
                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
                }
            }
            else
            {
                Scierror(999, _("%s: Wrong value for input argument #%d: \"%s\" expected.\n"), fname, 2, "string");
            }
        }
        else
        {
            Scierror(999, _("%s: Wrong type for input arguments #%d or #%d: Strings expected.\n"), fname, 1, 2);
        }
    }

    freeArrayOfString(Input_Matrix, mn);
    freeArrayOfString(Output_Matrix, mn);

    return 0;
}
Ejemplo n.º 21
0
const std::string NeunelferBody::GetDescription() const
{
  std::stringstream desc;
  desc << "911 in " << IBody::GetTypeName(GetType()) << " body, " << GetColor() << " color";
  return desc.str();
}
Ejemplo n.º 22
0
//------------------------------------------------------------------------------
bool CvProjectEntry::CacheResults(Database::Results& kResults, CvDatabaseUtility& kUtility)
{
	if(!CvBaseInfo::CacheResults(kResults, kUtility))
		return false;

	m_iMaxGlobalInstances = kResults.GetInt("MaxGlobalInstances");
	m_iMaxTeamInstances = kResults.GetInt("MaxTeamInstances");
	m_iProductionCost = kResults.GetInt("Cost");
	m_iNukeInterception = kResults.GetInt("NukeInterception");
	m_iCultureBranchesRequired = kResults.GetInt("CultureBranchesRequired");
	m_iTechShare = kResults.GetInt("TechShare");
	m_iVictoryDelayPercent = kResults.GetInt("VictoryDelayPercent");

	m_bSpaceship = kResults.GetBool("Spaceship");
	m_bAllowsNukes = kResults.GetBool("AllowsNukes");

	m_strMovieArtDef = kResults.GetText("MovieDefineTag");

	const char* szVictoryPrereq = kResults.GetText("VictoryPrereq");
	m_iVictoryPrereq = GC.getInfoTypeForString(szVictoryPrereq, true);

	const char* szTechPrereq = kResults.GetText("TechPrereq");
	m_iTechPrereq = GC.getInfoTypeForString(szTechPrereq, true);

	const char* szEveryoneSpecialUnit = kResults.GetText("EveryoneSpecialUnit");
	m_iEveryoneSpecialUnit = GC.getInfoTypeForString(szEveryoneSpecialUnit, true);

	const char* szCreateSound = kResults.GetText("CreateSound");
	SetCreateSound(szCreateSound);

	const char* szAnyonePrereqProject = kResults.GetText("AnyonePrereqProject");
	m_iAnyoneProjectPrereq = GC.getInfoTypeForString(szAnyonePrereqProject, true);

	//Arrays
	const char* szProjectType = GetType();
	kUtility.PopulateArrayByValue(m_piResourceQuantityRequirements, "Resources", "Project_ResourceQuantityRequirements", "ResourceType", "ProjectType", szProjectType, "Quantity");

	//Victory Thresholds
	{
		const int iNumVictories = kUtility.MaxRows("Victories");

		kUtility.InitializeArray(m_piVictoryThreshold, iNumVictories);
		kUtility.InitializeArray(m_piVictoryMinThreshold, iNumVictories);

		Database::Results kDBResults;
		char szQuery[512] = {0};
		sprintf_s(szQuery, "select VictoryType, Threshold, MinThreshold from Project_VictoryThresholds where ProjectType = '%s';", szProjectType);
		if(DB.Execute(kDBResults, szQuery))
		{
			while(kDBResults.Step())
			{
				const char* szVictoryType = kDBResults.GetText("VictoryType");
				const int idx = GC.getInfoTypeForString(szVictoryType, true);

				const int iThreshold = kDBResults.GetInt("Threshold");
				const int iMinThreshold = kDBResults.GetInt("MinThreshold");

				m_piVictoryThreshold[idx] = iThreshold;
				m_piVictoryMinThreshold[idx] = iMinThreshold;
			}
		}
	}

	kUtility.SetFlavors(m_piFlavorValue, "Project_Flavors", "ProjectType", szProjectType);
	kUtility.PopulateArrayByValue(m_piProjectsNeeded, "Projects", "Project_Prereqs", "PrereqProjectType", "ProjectType", szProjectType, "AmountNeeded");

	// EventEngine - v0.1, Snarko
	{
		m_asziFlagPrereqs.clear();
		std::string strKey("Project_PrereqFlags");
		Database::Results* pResults = kUtility.GetResults(strKey);
		if(pResults == NULL)
		{
			pResults = kUtility.PrepareResults(strKey, "select * from Project_PrereqFlags where ProjectType = ?");
		}

		pResults->Bind(1, szProjectType);

		while(pResults->Step())
		{
			std::string szFlag = pResults->GetText("Flag");
			int iMinimumValue = pResults->GetInt("MinimumValue");
			m_asziFlagPrereqs.push_back(std::make_pair(szFlag, iMinimumValue));
		}
	}
	// END EventEngine

	return true;
}
Ejemplo n.º 23
0
void ArenaTeam::Disband(WorldSession* session)
{
    // Broadcast update
    if (session)
    {
        BroadcastEvent(ERR_ARENA_TEAM_DISBANDED_S, 0, 2, session->GetPlayerName(), GetName(), "");
        if (Player* player = session->GetPlayer())
            TC_LOG_DEBUG("bg.arena", "Player: %s [GUID: %u] disbanded arena team type: %u [Id: %u, Name: %s].", player->GetName().c_str(), player->GetGUIDLow(), GetType(), GetId(), GetName().c_str());
    }

    // Remove all members from arena team
    while (!Members.empty())
        DelMember(Members.front().Guid, false);

    // Update database
    SQLTransaction trans = CharacterDatabase.BeginTransaction();

    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM);
    stmt->setUInt32(0, TeamId);
    trans->Append(stmt);

    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ARENA_TEAM_MEMBERS);
    stmt->setUInt32(0, TeamId);
    trans->Append(stmt);

    CharacterDatabase.CommitTransaction(trans);

    // Remove arena team from ObjectMgr
    sArenaTeamMgr->RemoveArenaTeam(TeamId);
}
Ejemplo n.º 24
0
globle void gensystem(
  void *theEnv)
  {
   char *commandBuffer = NULL;
   size_t bufferPosition = 0;
   size_t bufferMaximum = 0;
   int numa, i;
   DATA_OBJECT tempValue;
   char *theString;

   /*===========================================*/
   /* Check for the corret number of arguments. */
   /*===========================================*/

   if ((numa = EnvArgCountCheck(theEnv,"system",AT_LEAST,1)) == -1) return;

   /*============================================================*/
   /* Concatenate the arguments together to form a single string */
   /* containing the command to be sent to the operating system. */
   /*============================================================*/

   for (i = 1 ; i <= numa; i++)
     {
      EnvRtnUnknown(theEnv,i,&tempValue);
      if ((GetType(tempValue) != STRING) &&
          (GetType(tempValue) != SYMBOL))
        {
         SetHaltExecution(theEnv,TRUE);
         SetEvaluationError(theEnv,TRUE);
         ExpectedTypeError2(theEnv,"system",i);
         return;
        }

     theString = DOToString(tempValue);

     commandBuffer = AppendToString(theEnv,theString,commandBuffer,&bufferPosition,&bufferMaximum);
    }

   if (commandBuffer == NULL) return;

   /*=======================================*/
   /* Execute the operating system command. */
   /*=======================================*/

#if VAX_VMS
   if (SystemDependentData(theEnv)->PauseEnvFunction != NULL) (*SystemDependentData(theEnv)->PauseEnvFunction)(theEnv);
   VMSSystem(commandBuffer);
   putchar('\n');
   if (SystemDependentData(theEnv)->ContinueEnvFunction != NULL) (*SystemDependentData(theEnv)->ContinueEnvFunction)(theEnv,1);
   if (SystemDependentData(theEnv)->RedrawScreenFunction != NULL) (*SystemDependentData(theEnv)->RedrawScreenFunction)(theEnv);
#endif

#if   UNIX_7 || UNIX_V || LINUX || DARWIN || WIN_MVC || WIN_BTC || WIN_MCW || WIN_GCC || MAC_XCD
   if (SystemDependentData(theEnv)->PauseEnvFunction != NULL) (*SystemDependentData(theEnv)->PauseEnvFunction)(theEnv);
   system(commandBuffer);
   if (SystemDependentData(theEnv)->ContinueEnvFunction != NULL) (*SystemDependentData(theEnv)->ContinueEnvFunction)(theEnv,1);
   if (SystemDependentData(theEnv)->RedrawScreenFunction != NULL) (*SystemDependentData(theEnv)->RedrawScreenFunction)(theEnv);
#else

#if ! VAX_VMS
   EnvPrintRouter(theEnv,WDIALOG,
            "System function not fully defined for this system.\n");
#endif

#endif

   /*==================================================*/
   /* Return the string buffer containing the command. */
   /*==================================================*/

   rm(theEnv,commandBuffer,bufferMaximum);

   return;
  }
Ejemplo n.º 25
0
bool ArenaTeam::AddMember(uint64 playerGuid)
{
    std::string playerName;
    uint8 playerClass;

    // Check if arena team is full (Can't have more than type * 2 players)
    if (GetMembersSize() >= GetType() * 2)
        return false;

    // Get player name and class either from db or ObjectMgr
    Player* player = ObjectAccessor::FindPlayer(playerGuid);
    if (player)
    {
        playerClass = player->getClass();
        playerName = player->GetName();
    }
    else
    {
        //          0     1
        // SELECT name, class FROM characters WHERE guid = ?
        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_NAME_CLASS);
        stmt->setUInt32(0, GUID_LOPART(playerGuid));
        PreparedQueryResult result = CharacterDatabase.Query(stmt);

        if (!result)
            return false;

        playerName = (*result)[0].GetString();
        playerClass = (*result)[1].GetUInt8();
    }

    // Check if player is already in a similar arena team
    if ((player && player->GetArenaTeamId(GetSlot())) || Player::GetArenaTeamIdFromDB(playerGuid, GetType()) != 0)
    {
        TC_LOG_DEBUG("bg.arena", "Arena: Player %s (guid: %u) already has an arena team of type %u", playerName.c_str(), GUID_LOPART(playerGuid), GetType());
        return false;
    }

    // Set player's personal rating
    uint32 personalRating = 0;

    if (sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING) > 0)
        personalRating = sWorld->getIntConfig(CONFIG_ARENA_START_PERSONAL_RATING);
    else if (GetRating() >= 1000)
        personalRating = 1000;

    // Try to get player's match maker rating from db and fall back to config setting if not found
    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MATCH_MAKER_RATING);
    stmt->setUInt32(0, GUID_LOPART(playerGuid));
    stmt->setUInt8(1, GetSlot());
    PreparedQueryResult result = CharacterDatabase.Query(stmt);

    uint32 matchMakerRating;
    if (result)
        matchMakerRating = (*result)[0].GetUInt16();
    else
        matchMakerRating = sWorld->getIntConfig(CONFIG_ARENA_START_MATCHMAKER_RATING);

    // Remove all player signatures from other petitions
    // This will prevent player from joining too many arena teams and corrupt arena team data integrity
    Player::RemovePetitionsAndSigns(playerGuid, GetType());

    // Feed data to the struct
    ArenaTeamMember newMember;
    newMember.Name             = playerName;
    newMember.Guid             = playerGuid;
    newMember.Class            = playerClass;
    newMember.SeasonGames      = 0;
    newMember.WeekGames        = 0;
    newMember.SeasonWins       = 0;
    newMember.WeekWins         = 0;
    newMember.PersonalRating   = personalRating;
    newMember.MatchMakerRating = matchMakerRating;

    Members.push_back(newMember);

    // Save player's arena team membership to db
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_TEAM_MEMBER);
    stmt->setUInt32(0, TeamId);
    stmt->setUInt32(1, GUID_LOPART(playerGuid));
    CharacterDatabase.Execute(stmt);

    // Inform player if online
    if (player)
    {
        player->SetInArenaTeam(TeamId, GetSlot(), GetType());
        player->SetArenaTeamIdInvited(0);

        // Hide promote/remove buttons
        if (CaptainGuid != playerGuid)
            player->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);
    }

    TC_LOG_DEBUG("bg.arena", "Player: %s [GUID: %u] joined arena team type: %u [Id: %u, Name: %s].", playerName.c_str(), GUID_LOPART(playerGuid), GetType(), GetId(), GetName().c_str());

    return true;
}
Ejemplo n.º 26
0
bool ArenaTeam::AddMember(const uint64& PlayerGuid)
{
    std::string plName;
    uint8 plClass;

    // arena team is full (can't have more than type * 2 players!)
    if(GetMembersSize() >= GetType() * 2)
        return false;

    Player *pl = objmgr.GetPlayer(PlayerGuid);
    if(pl)
    {
        if(pl->GetArenaTeamId(GetSlot()))
        {
            sLog.outError("Arena::AddMember() : player already in this sized team");
            return false;
        }

        plClass = (uint8)pl->getClass();
        plName = pl->GetName();
    }
    else
    {
        //                                                     0     1
        QueryResult *result = CharacterDatabase.PQuery("SELECT name, class FROM characters WHERE guid='%u'", GUID_LOPART(PlayerGuid));
        if(!result)
            return false;

        plName = (*result)[0].GetCppString();
        plClass = (*result)[1].GetUInt8();
        delete result;

        // check if player already in arenateam of that size
        if(Player::GetArenaTeamIdFromDB(PlayerGuid, GetType()) != 0)
        {
            sLog.outError("Arena::AddMember() : player already in this sized team");
            return false;
        }
    }

    // remove all player signs from another petitions
    // this will be prevent attempt joining player to many arenateams and corrupt arena team data integrity
    Player::RemovePetitionsAndSigns(PlayerGuid, GetType());

    ArenaTeamMember newmember;
    newmember.name              = plName;
    newmember.guid              = PlayerGuid;
    newmember.Class             = plClass;
    newmember.games_season      = 0;
    newmember.games_week        = 0;
    newmember.wins_season       = 0;
    newmember.wins_week         = 0;
    newmember.personal_rating   = 1500;
    members.push_back(newmember);

    CharacterDatabase.PExecute("INSERT INTO arena_team_member (arenateamid, guid, personal_rating) VALUES ('%u', '%u', '%u')", Id, GUID_LOPART(newmember.guid), newmember.personal_rating );

    if(pl)
    {
        pl->SetInArenaTeam(Id, GetSlot());
        pl->SetArenaTeamIdInvited(0);
        pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot()*6) + 5, newmember.personal_rating );

        // hide promote/remove buttons
        if(CaptainGuid != PlayerGuid)
            pl->SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (GetSlot() * 6) + 1, 1);
    }
    return true;
}
Ejemplo n.º 27
0
void WrappedID3D11DeviceContext::AddDrawcall(FetchDrawcall d, bool hasEvents)
{
	if(d.context == ResourceId()) d.context = m_pDevice->GetResourceManager()->GetOriginalID(m_ResourceID);

	if(GetType() == D3D11_DEVICE_CONTEXT_DEFERRED)
	{
		m_pDevice->GetImmediateContext()->AddDrawcall(d, hasEvents);
		return;
	}

	m_AddedDrawcall = true;

	WrappedID3D11DeviceContext *context = (WrappedID3D11DeviceContext *)m_pDevice->GetResourceManager()->GetLiveResource(d.context);

	RDCASSERT(context);

	FetchDrawcall draw = d;
	draw.eventID = m_CurEventID;
	draw.drawcallID = m_CurDrawcallID;

	for(int i=0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
	{
		draw.outputs[i] = ResourceId();
		if(m_CurrentPipelineState->OM.RenderTargets[i])
			draw.outputs[i] = ((WrappedID3D11RenderTargetView *)m_CurrentPipelineState->OM.RenderTargets[i])->GetResourceResID();
	}

	{
		draw.depthOut = ResourceId();
		if(m_CurrentPipelineState->OM.DepthView)
			draw.depthOut = ((WrappedID3D11DepthStencilView *)m_CurrentPipelineState->OM.DepthView)->GetResourceResID();
	}

	m_CurDrawcallID++;
	if(hasEvents)
	{
		vector<FetchAPIEvent> evs;
		evs.reserve(m_CurEvents.size());
		for(size_t i=0; i < m_CurEvents.size(); )
		{
			if(m_CurEvents[i].context == draw.context)
			{
				evs.push_back(m_CurEvents[i]);
				m_CurEvents.erase(m_CurEvents.begin()+i);
			}
			else
			{
				i++;
			}
		}

		draw.events = evs;
	}

	AddUsage(draw);

	// should have at least the root drawcall here, push this drawcall
	// onto the back's children list.
	if(!context->m_DrawcallStack.empty())
	{
		DrawcallTreeNode node(draw);
		node.children.insert(node.children.begin(), draw.children.elems, draw.children.elems+draw.children.count);
		context->m_DrawcallStack.back()->children.push_back(node);
	}
	else
		RDCERR("Somehow lost drawcall stack!");
}
Ejemplo n.º 28
0
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_BaseObject::OnDataChanged( DataUpdateType_t updateType )
{
	if (updateType == DATA_UPDATE_CREATED)
	{
		CreateBuildPoints();
	}

	BaseClass::OnDataChanged( updateType );

	// Did we just finish building?
	if ( m_bWasBuilding && !m_bBuilding )
	{
		FinishedBuilding();
	}

	// Did we just go active?
	bool bShouldBeActive = ShouldBeActive();
	if ( !m_bWasActive && bShouldBeActive )
	{
		OnGoActive();
	}
	else if ( m_bWasActive && !bShouldBeActive )
	{
		OnGoInactive();
	}

	if ( m_bDisabled != m_bOldDisabled )
	{
		if ( m_bDisabled )
		{
			OnStartDisabled();
		}
		else
		{
			OnEndDisabled();
		}
	}

	if ( ( !IsBuilding() && m_iHealth != m_iOldHealth ) )
	{
		// recalc our damage particle state
		BuildingDamageLevel_t damageLevel = CalculateDamageLevel();

		if ( damageLevel != m_damageLevel )
		{
			UpdateDamageEffects( damageLevel );

			m_damageLevel = damageLevel;
		}
	}

	if ( m_bWasBuilding && !m_bBuilding )
	{
		// Force update damage effect when finishing construction.
		BuildingDamageLevel_t damageLevel = CalculateDamageLevel();
		UpdateDamageEffects( damageLevel );
		m_damageLevel = damageLevel;
	}

	// Kill all particles when getting picked up.
	if ( !m_bWasCarried && m_bCarried )
	{
		ParticleProp()->StopParticlesInvolving( this );
	}

	if ( m_iHealth > m_iOldHealth && m_iHealth == m_iMaxHealth )
	{
		// If we were just fully healed, remove all decals
		RemoveAllDecals();
	}

	if ( GetOwner() == C_TFPlayer::GetLocalTFPlayer() )
	{
		IGameEvent *event = gameeventmanager->CreateEvent( "building_info_changed" );
		if ( event )
		{
			event->SetInt( "building_type", GetType() );
			event->SetInt( "object_mode", GetObjectMode() );
			gameeventmanager->FireEventClientSide( event );
		}
	}

	if ( IsPlacing() && GetSequence() != m_nObjectOldSequence )
	{
		// Ignore server sequences while placing
		OnPlacementStateChanged( m_iLastPlacementPosValid > 0 );
	}
}
Ejemplo n.º 29
0
	void PrelightPipeline::DrawLight(const std::shared_ptr<Pass> &pass, const std::shared_ptr<SceneNode> &node)
	{
		auto light = node->GetComponent<Light>();
		auto camPtr = m_CurrentCamera->GetComponent<Camera>();
		auto camPos = m_CurrentCamera->GetWorldPosition();
		auto mesh = light->GetMesh();
		auto worldMatrix = node->GetWorldMatrix();

		Shader::Ptr shader = nullptr;

		if (light->GetType() == LightType::POINT)
		{
			float camNear = (camPtr->GetFrustum().GetWorldSpaceCorners()[0] - camPos).Length();
			if (SphereBounds(node->GetWorldPosition(), light->GetRadius() + camNear).IsInsideFast(camPos))
			{
				glDisable(GL_DEPTH_TEST);
				glCullFace(GL_FRONT);
			}
			else
			{
				glEnable(GL_DEPTH_TEST);
				glCullFace(GL_BACK);
			}

			worldMatrix.AppendScale(Vector4(light->GetRadius(), 0.0f));

			shader = pass->GetShader(ShaderType::POINT_LIGHT);
		}
		else if (light->GetType() == LightType::SPOT)
		{
			auto coneCenter = node->GetWorldPosition();
			auto coneDir = worldMatrix.Multiply(Vector4(0, 1, 0, 0)).Normalized();

			float camNear = (camPtr->GetFrustum().GetWorldSpaceCorners()[0] - camPos).Length();
			float theta = light->GetOutterAngle() * 0.5f;
			float height = light->GetRadius();
			float extra = camNear / std::sin(theta);

			coneCenter = coneCenter - coneDir * extra;
			height += camNear + extra;

			if (PointInCone(coneCenter, coneDir, height, theta, camPos))
			{
				glDisable(GL_DEPTH_TEST);
				glCullFace(GL_FRONT);
			}
			else
			{
				glEnable(GL_DEPTH_TEST);
				glCullFace(GL_BACK);
			}

			shader = pass->GetShader(ShaderType::SPOT_LIGHT);
		}
		else
		{
			glEnable(GL_DEPTH_TEST);
			glCullFace(GL_BACK);

			shader = pass->GetShader(ShaderType::DIR_LIGHT);
		}

		if (shader == nullptr)
		{
			LOGW << "Shader for light " << node->GetName() << " not found!";
			return;
		}

		shader->Bind();

		shader->BindCamera(m_CurrentCamera);
		shader->BindMatrix(Matrix4::WORLD_MATRIX, worldMatrix);

		shader->BindLight(node);
		shader->BindMesh(mesh);

		for (unsigned int i = 0; i < pass->GetTextureCount(true); i++)
		{
			auto ptr = pass->GetTextureAt(i, true);
			shader->BindTexture(ptr->GetName(), ptr);
		}

		glDrawElements(GL_TRIANGLES, mesh->Indices.Data.size(), GL_UNSIGNED_INT, 0);

		shader->UnBind();

		m_DrawCall++;
	}
Ejemplo n.º 30
0
bool ArenaTeam::AddMember(ObjectGuid playerGuid)
{
    std::string plName;
    uint8 plClass;

    // arena team is full (can't have more than type * 2 players!)
    if (GetMembersSize() >= GetMaxMembersSize())
        return false;

    Player* pl = sObjectMgr.GetPlayer(playerGuid);
    if (pl)
    {
        if (pl->GetArenaTeamId(GetSlot()))
        {
            sLog.outError("Arena::AddMember() : player already in this sized team");
            return false;
        }

        plClass = pl->getClass();
        plName = pl->GetName();
    }
    else
    {
        //                                                     0     1
        QueryResult* result = CharacterDatabase.PQuery("SELECT name, class FROM characters WHERE guid='%u'", playerGuid.GetCounter());
        if (!result)
            return false;

        plName = (*result)[0].GetCppString();
        plClass = (*result)[1].GetUInt8();
        delete result;

        // check if player already in arenateam of that size
        if (Player::GetArenaTeamIdFromDB(playerGuid, GetType()) != 0)
        {
            sLog.outError("Arena::AddMember() : player %s already in this sized team", playerGuid.GetString().c_str());
            return false;
        }
    }

    // remove all player signs from another petitions
    // this will be prevent attempt joining player to many arenateams and corrupt arena team data integrity
    Player::RemovePetitionsAndSigns(playerGuid, GetType());

    ArenaTeamMember newmember;
    newmember.name              = plName;
    newmember.guid              = playerGuid;
    newmember.Class             = plClass;
    newmember.games_season      = 0;
    newmember.games_week        = 0;
    newmember.wins_season       = 0;
    newmember.wins_week         = 0;

    int32 conf_value = sWorld.getConfig(CONFIG_INT32_ARENA_STARTPERSONALRATING);
    if (conf_value < 0)                                     // -1 = select by season id
    {
        if (sWorld.getConfig(CONFIG_UINT32_ARENA_SEASON_ID) >= 6)
        {
            if (m_stats.rating < 1000)
                newmember.personal_rating = 0;
            else
                newmember.personal_rating = 1000;
        }
        else
        {
            newmember.personal_rating = 1500;
        }
    }
    else
        newmember.personal_rating = uint32(conf_value);

    m_members.push_back(newmember);

    CharacterDatabase.PExecute("INSERT INTO arena_team_member (arenateamid, guid, personal_rating) VALUES ('%u', '%u', '%u')", m_TeamId, newmember.guid.GetCounter(), newmember.personal_rating);

    if (pl)
    {
        pl->SetInArenaTeam(m_TeamId, GetSlot(), GetType());
        pl->SetArenaTeamIdInvited(0);
        pl->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_PERSONAL_RATING, newmember.personal_rating);

        // hide promote/remove buttons
        if (m_CaptainGuid != playerGuid)
            pl->SetArenaTeamInfoField(GetSlot(), ARENA_TEAM_MEMBER, 1);
    }
    return true;
}