コンテンツにスキップ

How to manage and sort multiple lists in Scratch games

このコンテンツはまだ日本語訳がありません。

💡 Having trouble with Scratch block assembly? Don’t know how to implement code logic? 🚀 Get Help Now

LM

ListMaster

Posted on August 5, 2024 • Intermediate

📋 Need help with list sorting and duplicate prevention

Hi everyone! I’m working on a block-building game and I’m facing two major challenges:

  1. Preventing duplicate blocks: I need to stop multiple blocks from being placed at the same position. I tried using list contains checks but it’s not working properly.
  2. Sorting multiple lists together: I want to sort blocks by their Y position for proper rendering order, but I also need to keep the X positions and block types synchronized with the same sorting order.

The goal is to have blocks further away render first for consistent perspective. Any help would be much appreciated! 🤔

DS

DataStructure_Expert

Replied 2 hours later • ⭐ Best Answer

Great questions @ListMaster! List management is crucial for complex games. Here’s a comprehensive solution for both problems:

🚫 Problem 1: Preventing Duplicate Block Placement

The issue with simple contains checks is that they don’t verify position pairs. Here’s the correct approach:

    // Create these lists for your blocks
// x_positions, y_positions, block_types

when [space v] key pressed
set [block_exists v] to [false]
set [index v] to [1]

// Check all existing blocks
repeat (length of [x_positions v])
if <<(x position) = (item (index) of [x_positions v])> and <(y position) = (item (index) of [y_positions v])>> then
set [block_exists v] to [true]
stop [this script v]
end
change [index v] by [1]
end

// Only place block if position is empty
if <(block_exists) = [false]> then
add (x position) to [x_positions v]
add (y position) to [y_positions v]
add (current_block_type) to [block_types v]
// Place your block here
end

📊 Problem 2: Sorting Multiple Lists Simultaneously

Here’s a bubble sort implementation that keeps all lists synchronized:

    // Bubble sort all lists by Y position
define sort lists by y position
set [sorted v] to [false]
repeat until <(sorted) = [true]>
set [sorted v] to [true]
set [i v] to [1]

repeat ((length of [y_positions v]) - [1])
// Compare adjacent Y positions
if <(item (i) of [y_positions v]) > (item ((i) + [1]) of [y_positions v])> then
// Swap Y positions
set [temp_y v] to (item (i) of [y_positions v])
replace item (i) of [y_positions v] with (item ((i) + [1]) of [y_positions v])
replace item ((i) + [1]) of [y_positions v] with (temp_y)

// Swap X positions (same indexes)
set [temp_x v] to (item (i) of [x_positions v])
replace item (i) of [x_positions v] with (item ((i) + [1]) of [x_positions v])
replace item ((i) + [1]) of [x_positions v] with (temp_x)

// Swap block types (same indexes)
set [temp_type v] to (item (i) of [block_types v])
replace item (i) of [block_types v] with (item ((i) + [1]) of [block_types v])
replace item ((i) + [1]) of [block_types v] with (temp_type)

set [sorted v] to [false]
end
change [i v] by [1]
end
end

🚀 Optimized Solution: Insertion Sort

For better performance, use insertion sort when adding new blocks:

    define add block at x (x) y (y) type (type)
// Find correct position to insert
set [insert_position v] to [1]
repeat (length of [y_positions v])
if <(y) < (item (insert_position) of [y_positions v])> then
stop [this script v]  // Found position
end
change [insert_position v] by [1]
end

// Insert at correct position
insert (y) at (insert_position) of [y_positions v]
insert (x) at (insert_position) of [x_positions v]
insert (type) at (insert_position) of [block_types v]

🎮 Rendering with Proper Depth

Now render blocks in the correct order:

    when flag clicked
forever
delete all of [rendered_blocks v]

// Render from back to front (sorted by Y)
set [i v] to [1]
repeat (length of [y_positions v])
// Create block at position
create clone of [block v]

// Tell clone its properties
add (item (i) of [x_positions v]) to [rendered_blocks v]
add (item (i) of [y_positions v]) to [rendered_blocks v]
add (item (i) of [block_types v]) to [rendered_blocks v]

change [i v] by [1]
end
end

💡 Pro Tips for List Management

  • Use consistent indexing: Always keep related lists the same length
  • Consider using custom blocks: Create reusable functions for common operations
  • Optimize for your use case: If you’re mostly adding blocks, insertion sort is better than bubble sort
  • Debug with visual feedback: Show list contents on screen while testing

This should solve both your duplicate prevention and sorting issues! Let me know if you need clarification on any part! 😊

LM

ListMaster

Replied 1 hour later

@DataStructure_Expert This is exactly what I needed! Thank you so much! 🎉

The insertion sort approach is brilliant - now my blocks are always sorted and I don’t need to sort the entire list every time. The duplicate prevention is working perfectly too!

OP

OptimizationPro

Replied 2 hours later

Great solution! Here are some additional optimization tips for large lists:

  • Spatial partitioning: Divide your world into chunks and only check blocks in nearby chunks
  • Lazy sorting: Only sort when the view changes, not every frame
  • Binary search: For very large sorted lists, use binary search for faster lookups
  • Culling: Don’t render blocks that are off-screen
    // Example: Chunk-based collision detection
define check collision in chunk (chunk_x) (chunk_y)
set [start_index v] to ((chunk_y) * [chunks_per_row] + (chunk_x))
// Only check blocks in this chunk
repeat [blocks_per_chunk]
// Check collision logic here
end

These techniques can handle thousands of blocks efficiently! 🚀

VB

Vibelf_Community

Pinned Message • Moderator

🚀 Want to Master Advanced Data Structures?

Excellent discussion everyone! For those looking to create even more sophisticated data management systems, our community can help you implement:

  • 📊 Advanced sorting algorithms (quicksort, mergesort)
  • 🗂️ Hash tables and efficient lookups
  • 🌳 Tree structures for hierarchical data
  • 🔍 Search and filtering systems

📚 Related Discussions

Ready to create professional-quality data management systems? Get personalized guidance from our expert tutors in the Vibelf app!