static void WriteGameCoinData(GameCoin gamecoin_data) { std::string nand_directory = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir); FileSys::ArchiveFactory_ExtSaveData extdata_archive_factory(nand_directory, true); FileSys::Path archive_path(ptm_shared_extdata_id); auto archive_result = extdata_archive_factory.Open(archive_path); std::unique_ptr<FileSys::ArchiveBackend> archive; FileSys::Path gamecoin_path("/gamecoin.dat"); // If the archive didn't exist, create the files inside if (archive_result.Code() == FileSys::ERR_NOT_FORMATTED) { // Format the archive to create the directories extdata_archive_factory.Format(archive_path, FileSys::ArchiveFormatInfo()); // Open it again to get a valid archive now that the folder exists archive = extdata_archive_factory.Open(archive_path).Unwrap(); // Create the game coin file archive->CreateFile(gamecoin_path, sizeof(GameCoin)); } else { ASSERT_MSG(archive_result.Succeeded(), "Could not open the PTM SharedExtSaveData archive!"); archive = std::move(archive_result).Unwrap(); } FileSys::Mode open_mode = {}; open_mode.write_flag.Assign(1); // Open the file and write the default gamecoin information auto gamecoin_result = archive->OpenFile(gamecoin_path, open_mode); if (gamecoin_result.Succeeded()) { auto gamecoin = std::move(gamecoin_result).Unwrap(); gamecoin->Write(0, sizeof(GameCoin), true, reinterpret_cast<const u8*>(&gamecoin_data)); gamecoin->Close(); } }
static GameCoin ReadGameCoinData() { std::string nand_directory = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir); FileSys::ArchiveFactory_ExtSaveData extdata_archive_factory(nand_directory, true); FileSys::Path archive_path(ptm_shared_extdata_id); auto archive_result = extdata_archive_factory.Open(archive_path); if (!archive_result.Succeeded()) { LOG_ERROR(Service_PTM, "Could not open the PTM SharedExtSaveData archive!"); return default_game_coin; } FileSys::Path gamecoin_path("/gamecoin.dat"); FileSys::Mode open_mode = {}; open_mode.read_flag.Assign(1); auto gamecoin_result = (*archive_result)->OpenFile(gamecoin_path, open_mode); if (!gamecoin_result.Succeeded()) { LOG_ERROR(Service_PTM, "Could not open the game coin data file!"); return default_game_coin; } u16 result; auto gamecoin = std::move(gamecoin_result).Unwrap(); GameCoin gamecoin_data; gamecoin->Read(0, sizeof(GameCoin), reinterpret_cast<u8*>(&gamecoin_data)); gamecoin->Close(); return gamecoin_data; }
void Init() { AddService(new PTM_Play_Interface); AddService(new PTM_Sysm_Interface); AddService(new PTM_U_Interface); shell_open = true; battery_is_charging = true; // Open the SharedExtSaveData archive 0xF000000B and create the gamecoin.dat file if it doesn't exist FileSys::Path archive_path(ptm_shared_extdata_id); auto archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path); // If the archive didn't exist, create the files inside if (archive_result.Code().description == ErrorDescription::FS_NotFormatted) { // Format the archive to create the directories Service::FS::FormatArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path); // Open it again to get a valid archive now that the folder exists archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path); ASSERT_MSG(archive_result.Succeeded(), "Could not open the PTM SharedExtSaveData archive!"); FileSys::Path gamecoin_path("gamecoin.dat"); FileSys::Mode open_mode = {}; open_mode.write_flag = 1; open_mode.create_flag = 1; // Open the file and write the default gamecoin information auto gamecoin_result = Service::FS::OpenFileFromArchive(*archive_result, gamecoin_path, open_mode); if (gamecoin_result.Succeeded()) { auto gamecoin = gamecoin_result.MoveFrom(); gamecoin->backend->Write(0, sizeof(GameCoin), 1, reinterpret_cast<const u8*>(&default_game_coin)); gamecoin->backend->Close(); } } }
APGGameMode::APGGameMode() : PowerToWinFactor{ 2.f }, DecayRate{ 0.05f }, CurrentGameState{ EPGPlayState::EUnknown } { UWorld* World = GetWorld(); UGameInstance* GameInstance = (World != nullptr) ? World->GetGameInstance() : nullptr; UPGGameInstance* PGGameInstance = Cast<UPGGameInstance>(GameInstance); if (PGGameInstance && PGGameInstance->PlayerCharacterClass) { DefaultPawnClass = PGGameInstance->PlayerCharacterClass; } else { DefaultPawnClass = ARobotCharacter::StaticClass(); } check(DefaultPawnClass); PlayerControllerClass = APGPlayerController::StaticClass(); static auto HUDBlueprintClassName = TEXT("WidgetBlueprint'/Game/Blueprints/BatteryHUD.BatteryHUD_C'"); static auto HUDFinder = ConstructorHelpers::FClassFinder<UUserWidget>(HUDBlueprintClassName); if (HUDFinder.Succeeded()) { HUDWidgetClass = HUDFinder.Class; } }
ABatteryPickup::ABatteryPickup() { Power = 750.0f; // Assign a static mesh static auto StaticMeshName = TEXT("StaticMesh'/Game/Props/Battery/Meshes/SM_Battery_Medium.SM_Battery_Medium'"); static auto MeshFinder = ConstructorHelpers::FObjectFinder<UStaticMesh>(StaticMeshName); if (MeshFinder.Succeeded()) { GetMeshComponent()->SetStaticMesh(MeshFinder.Object); } GetMeshComponent()->SetSimulatePhysics(true); }
void ARobotCharacter::ConfigureMeshAndAnimation() { // Configure the skeletal mesh and animation blueprints static auto SkeletalMeshName = TEXT("SkeletalMesh'/Game/Characters/Mannequin/Mesh/SK_Mannequin.SK_Mannequin'"); static auto SkeletalMeshFinder = ConstructorHelpers::FObjectFinder<USkeletalMesh>(SkeletalMeshName); if (SkeletalMeshFinder.Succeeded()) { auto MeshComponent = GetMesh(); MeshComponent->SetSkeletalMesh(SkeletalMeshFinder.Object); MeshComponent->SetRelativeLocation(FVector(0.f, 0.f, -95.f)); MeshComponent->SetRelativeRotation(FRotator(0.f, 270.f, 0.f)); ConfigureMeshCollision(); } static auto AnimBlueprintName = TEXT("AnimBlueprint'/Game/Characters/Mannequin/Animations/ThirdPerson_AnimBP.ThirdPerson_AnimBP_C'"); static auto AnimBlueprintFinder = ConstructorHelpers::FObjectFinder<UAnimBlueprintGeneratedClass>(AnimBlueprintName); if (AnimBlueprintFinder.Succeeded()) { GetMesh()->SetAnimInstanceClass(AnimBlueprintFinder.Object); } }
void RunThinkPart() { if (!success_ && !failure_) return; if (Succeeded() && success_) { if (CallSuccess()) return; } if (!Succeeded() && failure_) { HandleSecurity sec(ident_, g_pCoreIdent); ke::AutoArray<cell_t> data(new cell_t[results_.length()]); for (size_t i = 0; i < txn_->entries.length(); i++) data[i] = txn_->entries[i].data; Handle_t dbh = CreateLocalHandle(g_DBMan.GetDatabaseType(), db_, &sec); if (dbh != BAD_HANDLE) { // Add an extra refcount for the handle. db_->AddRef(); } failure_->PushCell(dbh); failure_->PushCell(data_); failure_->PushCell(txn_->entries.length()); failure_->PushString(error_.chars()); failure_->PushCell(failIndex_); failure_->PushArray(data, txn_->entries.length()); failure_->Execute(NULL); handlesys->FreeHandle(dbh, &sec); } }
void OgreScriptEditor::SetScriptAsset(const AssetPtr &scriptAsset) { asset = scriptAsset; assert(asset.lock()); AssetPtr assetPtr = asset.lock(); if (!assetPtr) LogError("OgreScriptEditor: null asset given."); if (assetPtr->Type() != "OgreMaterial" && assetPtr->Type() != "OgreParticle") LogWarning("Created OgreScriptEditor for non-supported asset type " + assetPtr->Type() + "."); lineEditName->setText((assetPtr?assetPtr->Name():QString())); setWindowTitle(tr("OGRE Script Editor:") + (assetPtr?assetPtr->Name():QString())); if (assetPtr && !assetPtr->IsLoaded()) { AssetTransferPtr transfer = framework->Asset()->RequestAsset(assetPtr->Name(), assetPtr->Type(), true); connect(transfer.get(), SIGNAL(Succeeded(AssetPtr)), this, SLOT(OnAssetTransferSucceeded(AssetPtr))); connect(transfer.get(), SIGNAL(Failed(IAssetTransfer *, QString)), SLOT(OnAssetTransferFailed(IAssetTransfer *, QString))); }
bool lcpp::LispFunction_UserDefined::checkArgumentCount(Ptr<LispObject> pArgs) { if(isNil(pArgs)) { // No args are given, but 1 or more are expected. if(m_numArgs > 0) { ezStringBuilder message; message.AppendFormat("Invalid number of arguments: expected %u, got none.", m_numArgs); throw exceptions::InvalidInput(message.GetData()); } return false; } // From here on out we know that pArgs MUST be a cons. EZ_ASSERT(pArgs->is<LispCons>(), "pArgs must be a cons if it is not nil!"); auto pArgList = pArgs.cast<LispCons>(); // pArgs is not nil, which means it's a cons, so we count the args ezUInt32 numElements = 0; auto res = count(pArgList, numElements); EZ_ASSERT(res.Succeeded(), "pArgList is not a regular list!"); // pArgs is not nil but we don't expect any arguments if(m_numArgs == 0) { ezStringBuilder message; message.AppendFormat("Invalid number of arguments: expected no arguments, got %u", numElements); throw exceptions::InvalidInput(message.GetData()); } if(numElements != m_numArgs) { ezStringBuilder message; message.AppendFormat("Invalid number of arguments: Expected %u arguments, got %u", m_numArgs, numElements); throw exceptions::InvalidInput(message.GetData()); } return true; }
bool CompositorD3D11::VerifyBufferSize() { DXGI_SWAP_CHAIN_DESC swapDesc; HRESULT hr; hr = mSwapChain->GetDesc(&swapDesc); if (Failed(hr)) { return false; } if ((swapDesc.BufferDesc.Width == mSize.width && swapDesc.BufferDesc.Height == mSize.height) || mSize.width <= 0 || mSize.height <= 0) { return true; } if (mDefaultRT) { // Make sure the texture, which belongs to the swapchain, is destroyed // before resizing the swapchain. if (mCurrentRT == mDefaultRT) { mCurrentRT = nullptr; } MOZ_ASSERT(mDefaultRT->hasOneRef()); mDefaultRT = nullptr; } if (IsRunningInWindowsMetro()) { hr = mSwapChain->ResizeBuffers(2, mSize.width, mSize.height, DXGI_FORMAT_B8G8R8A8_UNORM, 0); mDisableSequenceForNextFrame = true; } else { hr = mSwapChain->ResizeBuffers(1, mSize.width, mSize.height, DXGI_FORMAT_B8G8R8A8_UNORM, 0); } return Succeeded(hr); }
bool Initialize( HINSTANCE i_hInstance, int i_CmdShow, const char * i_pWindowName, int i_IconID, unsigned int i_WindowWidth, unsigned int i_WindowHeight ) { g_hInstance = i_hInstance; #ifdef UNICODE const size_t lenWindowName = 128; wchar_t WindowName[lenWindowName]; MultiByteToWideChar( CP_ACP, 0, ( i_pWindowName ) ? i_pWindowName : "GLib Render", -1, WindowName, lenWindowName ); LPCTSTR pWindowName = WindowName; #else LPCTSTR pWindowName = ( i_pWindowName ) ? i_pWindowName : "GLib Render"; #endif // UNICODE g_hWnd = _CreateWindow( WndProc, g_hInstance, i_IconID, pWindowName, i_WindowWidth, i_WindowHeight ); if( g_hWnd == nullptr ) { DEBUG_PRINT( "_CreateWindow() failed.\n" ); return NULL; } HRESULT hResult = CreateDevice( g_hWnd ); if( !Succeeded( hResult ) ) { DEBUG_PRINT( "_CreateDevice() failed. HRESULT = %d.\n", hResult ); return false; } ShowWindow( g_hWnd, i_CmdShow ); Input::Initialize(); Sprites::Initialize(); return true; }
lcpp::Ptr<lcpp::LispObject> lcpp::Reader::parseAtom(ezStringIterator& input) { // Special case for + and - characters, since the ezEngine parses (+ 1) as +1... auto ch = input.GetCharacter(); if (ch == '+' || ch == '-') { auto copy = input; ezStringBuilder symbol; symbol.Append(ch); ++copy; ch = copy.GetCharacter(); while(true) { if(isSeparator(ch) || contains("()", char(ch)) || !copy.IsValid()) { // The + or - characters stand alone, which means they're meant to be a symbol. while(input.GetData() != copy.GetData()) { advance(input); } return create<LispSymbol>(symbol); } if (isDigit(ch)) { // The +'s or -'s are sign changers of the digit we just encountered. // Abort reading as symbol. break; } symbol.Append(ch); ++copy; if(copy.IsValid()) { ch = copy.GetCharacter(); } } } // Try parsing for an integer first, then a number, then a symbol const char* lastPos = nullptr; LispInteger::Number_t integer; auto result = to(input, integer, &lastPos); // The string contains a number, but it is a floating point number; reparse. if (result.Succeeded()) { LCPP_SCOPE_EXIT{ while(input.GetData() != lastPos) { advance(input); } }; if(lastPos[0] == '.') { LispNumber::Number_t number; auto result = to(input, number, &lastPos); EZ_ASSERT(result.Succeeded(), "An integer of the form '123.' should be parsed as float!"); return create<LispNumber>(number); } return create<LispInteger>(integer); }
void CancelThinkPart() { if (Succeeded()) error_ = "Driver is unloading"; RunThinkPart(); }