void SPaperExtractSpritesDialog::CreateExtractedSprites() { FAssetToolsModule& AssetToolsModule = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools"); FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser"); TArray<UObject*> ObjectsToSync; // Create the factory used to generate the sprite auto SpriteFactory = NewObject<UPaperSpriteFactory>(); SpriteFactory->InitialTexture = SourceTexture; // Create the sprite FString Name; FString PackageName; FScopedSlowTask Feedback(ExtractedSprites.Num(), NSLOCTEXT("Paper2D", "Paper2D_ExtractSpritesFromTexture", "Extracting Sprites From Texture")); Feedback.MakeDialog(true); for (const FPaperExtractedSprite ExtractedSprite : ExtractedSprites) { Feedback.EnterProgressFrame(1, NSLOCTEXT("Paper2D", "Paper2D_ExtractSpritesFromTexture", "Extracting Sprites From Texture")); SpriteFactory->bUseSourceRegion = true; const FIntRect& ExtractedRect = ExtractedSprite.Rect; SpriteFactory->InitialSourceUV = FVector2D(ExtractedRect.Min.X, ExtractedRect.Min.Y); SpriteFactory->InitialSourceDimension = FVector2D(ExtractedRect.Width(), ExtractedRect.Height()); // Get a unique name for the sprite // Extracted sprite name is a name, we insert a _ as we're appending this to the texture name // Opens up doors to renaming the sprites in the editor, and still ending up with TextureName_UserSpriteName FString Suffix = TEXT("_"); Suffix.Append(ExtractedSprite.Name); AssetToolsModule.Get().CreateUniqueAssetName(SourceTexture->GetOutermost()->GetName(), Suffix, /*out*/ PackageName, /*out*/ Name); const FString PackagePath = FPackageName::GetLongPackagePath(PackageName); if (UObject* NewAsset = AssetToolsModule.Get().CreateAsset(Name, PackagePath, UPaperSprite::StaticClass(), SpriteFactory)) { ObjectsToSync.Add(NewAsset); } if (GWarn->ReceivedUserCancel()) { break; } } if (ObjectsToSync.Num() > 0) { ContentBrowserModule.Get().SyncBrowserToAssets(ObjectsToSync); } }
/* !!!! This function is designed for the controller !!!!! Purpose: Parse the message into each of the components and then distrubute the commands as nessesary Input: Recieve Queue Output: none */ void Parse_Data(void) { // Local variables for assigning the bytes too unsigned char node; unsigned char sub_comp; unsigned char instruction; // Grab the three bytes and sort according to their representation node = rxdata[0]; sub_comp = rxdata[1]; instruction = rxdata[2]; SCIprintf("%d%d%d", rxdata[0], rxdata[1], rxdata[2]); //putsSCI(rxdata); switch (node) { case PID: Feedback(sub_comp, instruction); break; // Elevator Car case CAR: Car(sub_comp, instruction); break; // Floor 1 case F1: Floor(F1, sub_comp, instruction); break; // Floor 2 case F2: Floor(F2, sub_comp, instruction); break; // Floor 3 case F3: Floor(F3, sub_comp, instruction); break; default: msDELAY(100); break; } }
Feedback Game::move(Cell from, Cell to, MoveResult force_result) { Element from_element = board[from.get_id()]; Element to_element = board[to.get_id()]; assert(!from_element.is_empty()); assert(from.get_type() != Headquarter); bool occupy_state[4631] = {0}; for(int i=0; i<4631; i++) { if(is_valid_cell_id(i)) { occupy_state[i] = !board[i].is_empty(); } } MoveResult result; std::list<Cell> route; bool show_flag = false; if(!from_element.is_unknown() && !to_element.is_unknown()) { assert(force_result == Nothing); // count the number of 40 int n_of_40_before = 0; if(!from_element.is_empty() && piece_of(from_element) == Piece(40)) { n_of_40_before++; } if(!to_element.is_empty() && piece_of(to_element) == Piece(40)) { n_of_40_before++; } // process board if(!to_element.is_empty()) { result = Piece::attack(piece_of(from_element), piece_of(to_element)); } else { result = Nothing; } route = get_route( from, to, occupy_state, piece_of(from_element) == Piece(32) ); assert(!route.empty()); if(result == Nothing || result == Bigger) { board[to.get_id()] = from_element; } else if(result == Equal) { board[to.get_id()] = Element(); } board[from.get_id()] = Element(); // count the number of 40 int n_of_40_after = 0; Element target = board[to.get_id()]; if(!target.is_empty() && !target.is_unknown()) { if(piece_of(target) == Piece(40)) { n_of_40_after++; } } if(n_of_40_after < n_of_40_before) { show_flag = true; } } else { assert(force_result != Nothing); result = force_result; route = get_route(from, to, occupy_state, true); assert(!route.empty()); if(result == Nothing || result == Bigger) { board[to.get_id()] = from_element; } else if(result == Equal) { board[to.get_id()] = Element(); } board[from.get_id()] = Element(); } steps++; last_feedback = Feedback(result, route, show_flag); return last_feedback; }
// Searches for an obviously optimal strategy. // If one exists, returns the total cost of the strategy. // Otherwise, returns -1. // @todo Change return type to StrategyCost. static int fill_obviously_optimal_strategy( Engine &e, CodewordRange secrets, bool min_depth, // whether to minimize the worst-case depth int max_depth, // maximum number of extra guesses, not counting // the initial guess StrategyTree &tree // Strategy tree that stores the best strategy ) { int extra; //Codeword guess = ObviousStrategy(e).make_guess(secrets, &extra); Codeword guess = make_less_obvious_guess(e, secrets, &extra); --extra; // @todo Take into account the lower-bound estimate of non-possible // guesses. if (!guess || (extra > max_depth) || (min_depth && extra > 1)) return -1; // VERBOSE_COUT << "Found obvious guess: " << obvious << std::endl; // Automatically fill the strategy tree using this guess.This requires // all cells in the partition to have no more than two possibilities. // This is equivalent to Knuth's 'x' notation in writing a strategy. Feedback perfect = Feedback::perfectValue(e.rules()); FeedbackList fbs; e.compare(guess, secrets, fbs); size_t n = secrets.size(); int depth = tree.currentDepth(); int cost = 0; for (size_t j = 0; j < Feedback::size(e.rules()); ++j) { Codeword first; for (size_t i = 0; i < n; ++i) { if (fbs[i] == Feedback(j)) { if (!first) { ++cost; first = secrets[i]; StrategyTree::Node node(depth + 1, guess, fbs[i]); tree.append(node); if (fbs[i] != perfect) { ++cost; StrategyTree::Node leaf(depth + 2, first, perfect); tree.append(leaf); } } else { cost += 3; tree.append(StrategyTree::Node(depth + 2, first, e.compare(secrets[i], first))); tree.append(StrategyTree::Node(depth + 3, secrets[i], perfect)); } } } } return cost; // @todo: try guesses from non-secrets. }
void CreateSpritesFromTextures(TArray<UTexture2D*>& Textures) { const FString DefaultSuffix = TEXT("_Sprite"); FAssetToolsModule& AssetToolsModule = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools"); FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser"); TArray<UObject*> ObjectsToSync; for (auto TextureIt = Textures.CreateConstIterator(); TextureIt; ++TextureIt) { UTexture2D* Texture = *TextureIt; // Create the factory used to generate the sprite UPaperSpriteFactory* SpriteFactory = ConstructObject<UPaperSpriteFactory>(UPaperSpriteFactory::StaticClass()); SpriteFactory->InitialTexture = Texture; // Create the sprite FString Name; FString PackageName; if (!bExtractSprites) { // Get a unique name for the sprite AssetToolsModule.Get().CreateUniqueAssetName(Texture->GetOutermost()->GetName(), DefaultSuffix, /*out*/ PackageName, /*out*/ Name); const FString PackagePath = FPackageName::GetLongPackagePath(PackageName); if (UObject* NewAsset = AssetToolsModule.Get().CreateAsset(Name, PackagePath, UPaperSprite::StaticClass(), SpriteFactory)) { ObjectsToSync.Add(NewAsset); } } else { FScopedSlowTask Feedback(1, NSLOCTEXT("Paper2D", "Paper2D_ExtractSpritesFromTexture", "Extracting Sprites From Texture")); Feedback.MakeDialog(true); // First extract the rects from the texture TArray<FIntRect> ExtractedRects; UPaperSprite::ExtractRectsFromTexture(Texture, /*out*/ ExtractedRects); // Sort the rectangles by approximate row struct FRectangleSortHelper { FRectangleSortHelper(TArray<FIntRect>& InOutSprites) { // Sort by Y, then by X (top left corner), descending order (so we can use it as a stack from the top row down) TArray<FIntRect> SpritesLeft = InOutSprites; SpritesLeft.Sort([](const FIntRect& A, const FIntRect& B) { return (A.Min.Y == B.Min.Y) ? (A.Min.X > B.Min.X) : (A.Min.Y > B.Min.Y); }); InOutSprites.Reset(); // Start pulling sprites out, the first one in each row will dominate remaining ones and cause them to get labeled TArray<FIntRect> DominatedSprites; DominatedSprites.Empty(SpritesLeft.Num()); while (SpritesLeft.Num()) { FIntRect DominatingSprite = SpritesLeft.Pop(); DominatedSprites.Add(DominatingSprite); // Find the sprites that are dominated (intersect the infinite horizontal band described by the dominating sprite) for (int32 Index = 0; Index < SpritesLeft.Num();) { const FIntRect& CurElement = SpritesLeft[Index]; if ((CurElement.Min.Y <= DominatingSprite.Max.Y) && (CurElement.Max.Y >= DominatingSprite.Min.Y)) { DominatedSprites.Add(CurElement); SpritesLeft.RemoveAt(Index, /*Count=*/ 1, /*bAllowShrinking=*/ false); } else { ++Index; } } // Sort the sprites in the band by X and add them to the result DominatedSprites.Sort([](const FIntRect& A, const FIntRect& B) { return (A.Min.X < B.Min.X); }); InOutSprites.Append(DominatedSprites); DominatedSprites.Reset(); } } }; FRectangleSortHelper RectSorter(ExtractedRects); Feedback.TotalAmountOfWork = ExtractedRects.Num(); for (int ExtractedRectIndex = 0; ExtractedRectIndex < ExtractedRects.Num(); ++ExtractedRectIndex) { Feedback.EnterProgressFrame(1, NSLOCTEXT("Paper2D", "Paper2D_ExtractSpritesFromTexture", "Extracting Sprites From Texture")); FIntRect& ExtractedRect = ExtractedRects[ExtractedRectIndex]; SpriteFactory->bUseSourceRegion = true; SpriteFactory->InitialSourceUV = FVector2D(ExtractedRect.Min.X, ExtractedRect.Min.Y); SpriteFactory->InitialSourceDimension = FVector2D(ExtractedRect.Width(), ExtractedRect.Height()); // Get a unique name for the sprite const FString Suffix = FString::Printf(TEXT("%s_%d"), *DefaultSuffix, ExtractedRectIndex); AssetToolsModule.Get().CreateUniqueAssetName(Texture->GetOutermost()->GetName(), Suffix, /*out*/ PackageName, /*out*/ Name); const FString PackagePath = FPackageName::GetLongPackagePath(PackageName); if (UObject* NewAsset = AssetToolsModule.Get().CreateAsset(Name, PackagePath, UPaperSprite::StaticClass(), SpriteFactory)) { ObjectsToSync.Add(NewAsset); } if (GWarn->ReceivedUserCancel()) { break; } } } } if (ObjectsToSync.Num() > 0) { ContentBrowserModule.Get().SyncBrowserToAssets(ObjectsToSync); } }