/* ============ 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; }
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; }
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; }
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); } }
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; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- int C_BaseObject::GetDisplayPriority( void ) { return GetObjectInfo( GetType() )->m_iDisplayPriority; }
const std::string CayenneBody::GetDescription() const { std::stringstream desc; desc << GetColor() << " Cayenne " << IBody::GetTypeName(GetType()) << " body"; return desc.str(); }
bool PluginPreference::IsBoolean() { return GetType() == PluginPreferenceType::CheckBox; }
bool PluginPreference::IsInteger() { return GetType() == PluginPreferenceType::Spinner; }
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; }
// operator== bool BGradient::operator==(const BGradient& other) const { return ((other.GetType() == GetType()) && ColorStopsAreEqual(other)); }
/* +-----------------+------------------------------------------------------------+ | 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; }
/*--------------------------------------------------------------------------*/ 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; } }
// 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); } }
const char* C_BaseObject::GetStatusName() const { return GetObjectInfo( GetType() )->m_pStatusName; }
void AirspaceHoldInSim::getDesc( ResourceDesc& resDesc ) { resDesc.resid = GetHoldInput()->getID(); resDesc.resType = GetType(); resDesc.strRes = PrintResource(); }
//----------------------------------------------------------------------------- // 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 ); } } }
/*--------------------------------------------------------------------------*/ 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, ¶moutINT); 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; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- const char *C_BaseObject::GetHudStatusIcon( void ) { return GetObjectInfo( GetType() )->m_pHudStatusIcon; }
/*--------------------------------------------------------------------------*/ 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; }
const std::string NeunelferBody::GetDescription() const { std::stringstream desc; desc << "911 in " << IBody::GetTypeName(GetType()) << " body, " << GetColor() << " color"; return desc.str(); }
//------------------------------------------------------------------------------ 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; }
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); }
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; }
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; }
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; }
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!"); }
//----------------------------------------------------------------------------- // 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 ); } }
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++; }
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; }