I.Q. Final/Kurushi Final Puzzle List & Stats

Yep, use the nav that's over there → and you'll get a visual representation of all 200-600 puzzles for the selected size. That's the main point of this after all. Unlike the site for the original Intelligent Qube, there aren't any sample solutions here since nobody has written any down and I ain't doing it, sorry.

Apart from this page, this site is generated by a program so that's why it has a, shall we say, minimalist design. All the colours used apart from the cube diagrams are your browser's defaults.

Other Games: I.Q.: Intelligent Qube - I.Q. Remix+ - I.Q. Mania

Back to main page

General Puzzle Stats

These stats don't include the 9x10 Tektonics puzzles, since a) those aren't part of every game and b) would just dominate.

  • Longest Puzzle: 32 turns (8x10 Puzzle 18)
  • Longest Puzzle Group: 14.2 average turns (7x9)
  • Puzzle Group with most forbidden cubes: 8x9 (31.9% of all cubes)
  • Puzzle Group with most advantage cubes: 4x2 (28.9% of all cubes)
  • Average turns to complete the game: 686.86
  • Average TRN of the 9,420 puzzles: 9.39
  • Total advantage cubes: 55576 (14.77%)
  • Total forbidden cubes: 87554 (23.26%)

Turn Speed

This is how long one complete roll advance animation takes. The pause is the time between the end of one advance and the start of the next when no capturing is involved. Holding accelerate and then letting go will change the length of the one-after-next pause by a non-constant amount, even if you hold it again before the second pause happens.

  • Normal: 52 frames. Pause - 31 frames
  • Hard: 41 frames. Pause - 26 frames
  • Super Hard: 31 frames. Pause - 21 frames
  • Ultra Hard: 20 frames. Pause - 17 frames
  • Accelerate / Squashed: 4 frames. Pause - 4 frames

I.Q Algorithm

I.Q Final uses a slightly more advanced formula than a percentage of your stage score to calculate your IQ. Not much more, but a bit.
The formula is:

currentIQ = 
(
    (
        (cumulativeStageMultipliedScore * difficultyBonus * 10) * 
        (100 + 
            (
                (numPerfectAndExcellentPuzzles * 55) / numPuzzles
            )
        )
    )
) / 1000000000
To break it down, the code essentially does this:

previousStageScore = 0
addedAdjustedScores = 0
totalOfPerfectsAndExcellents = 0
totalPuzzles = 0

for each stage
    currentScoreHundreds = endOfStageScore / 100 '' Stage score is from before the stage bonus is added
    stageScoreHundreds = currentScoreHundreds - previousStageScoreHundreds
    adjustedStageScore = stageScoreHundreds * stageMultiplier
    addedAdjustedScores = addedAdjustedScores + adjustedStageScore
    difficultyAdjustedScore = addedAdjustedScores * difficultyBonus * 10

    totalOfPerfectsAndExcellents = totalOfPerfectsAndExcellents + stagePerfectsOrExcellents
    totalPuzzles = totalPuzzles + stagePuzzlesSeen
    performanceBonus = totalOfPerfectsAndExcellents * 55
    performanceBonus = performanceBonus / totalPuzzles
    performanceBonus = 100 + performanceBonus
    
    totalScore = difficultyAdjustedScore * performanceBonus
    iqTotal = totalScore / 1,000,000,000 '' that's 1,000 million, or a billion
nextStage

difficultyBonus = 100, '' Normal
                  110, '' Hard
                  115, '' Super Hard
                  120  '' Ultra Hard

stageMultiplier = 500, '' stage 1
                  480, '' stage 2
                  250, '' stage 3
                  235, '' stage 4
                  220, '' stage 5
                  205, '' stage 6
                  185, '' stage 7
                  165, '' stage 8
                  155, '' stage F
                  155  '' Tektonics

/ is divide
* is multiply

Here's a C# implementation of this with example data

As a check - a score of 145700 at the end of stage one (not counting the bonus) on Normal with 9 perfects or excellents from the 9 puzzles generates an IQ of 112. If you then end stage 2 with 267500 (not counting the bonus) with 15 perfects or excellents from the 18 puzzles, your IQ after 2 stages will then be 186

Tektonics uses the same algorithm, but it is calculated separately from the other stages so the totals and added scores are 0 when calculating. The IQ value generated by Tektonics is then added to the IQ generated from the normal Final stage calculation to get the total IQ.

If you calculate it yourself, please use 8-byte integer types during the calculation. The numbers get too big for 4-byte integers

Stage Stats

As opposed to the original, in this game you require 2 rows minimum to survive a squash on the first puzzle of the last wave of a stage.

Additionally, you need 2 more if you want the next puzzle to start without waiting for the stage to finish collapsing first. So, if you only have 3 spare rows and get squashed, you will have to wait for all of the rows to collapse before the next puzzle will begin.

 Stage
Stat12345678FT*
Starting Size (Rows) 16282737333538363738
Wave 1 Size 6151521181621181810
Wave 2 Size 9151821181624181810
Wave 3 Size 12181824211824202010
Slack Space 287111016121415

* - Tektonics goes on for 20 waves, each is 10 in length

Puzzle RNG

The puzzle set for the entire game is decided during the black screen between the menu and the first stage.

How it's decided is different to the first game. However the rand function is implemented in the same way.

  1. Upon booting, the rand seed is set to 0.
  2. For every frame the game is on a menu with a spinning globe, a random number is generated and discarded to change the seed.
  3. After selecting Start, one more random number is generated. This random number is used to seed the game's custom random number generator.

Before the first stage loads:

  1. The custom seed is multiplied by five and has one added and updated with the result

Then for each puzzle:

  1. The frame before a new puzzle appears, the custom seed is multiplied by five and has one added and updated with the result.
  2. The lower 16 bits of this calculation are then passed to the DetermineWhichPuzzle function (below) which does more calculations to create a puzzle number.
  3. The horizontal flip chance is 30%, the same as the first game. Instead of using a new random number however, it uses the result of the seed calculation like the puzzle generation.

How Again! Works

Unlike the first game, getting squashed by the cubes doesn't always make Again! appear and the puzzle repeat.

  • When you get squashed by the cubes, the game adds 1 to the squashed counter
  • If, after you stand up, you get squashed a second time on the same puzzle, the game will add another 1 to the squashed counter
  • If you capture any cubes on the same turn you are squashed (so the cubes pause while on top of you), the game will add 1 to the counter for that too
  • If you are squashed but manage to capture all the non-black cubes (regardless of how many black ones you capture), the game will award you a normal Great! Perfect! or Excellent! and all of those reset the squashed counter to 0

For Again! to happen, the squashed counter needs to be exactly 1 when the game picks the next puzzle to play. If it is 2 or more, or 0, Again! won't happen and the normal next puzzle will play instead.

You cannot complete a puzzle, get squashed, and do the same puzzle again like you could in Intelligent Qube.

Puzzle Determination (C#)

ushort DetermineWhichPuzzle(uint seedCalc, WaveInformation wi)
{
    // as mentioned above, seedCalc is the low 16-bits of the 32-bit result of the puzzle rng, ie it is called like
    // puzzleNum = DetermineWhichPuzzle(puzzRng & 0xFFFF, waveInfo);
    // so it is a value in the range of 0 - 0xFFFF

    ushort numPuzzles = wi.numPuzzles; // the number of puzzles defined for this wave size
    // if there are 500 puzzles for this size, use 100, otherwise use 200
    uint boost = (numPuzzles != 500) ? 200u : 100u;
    
    // The '/' is divide (quotient), and '%' is modulus (remainder of division by that number)
    // this is whole number division, so for example 15 / 10 is 1, not 1.5. And 15 % 10 is 5.
    uint puzzleNum = seedCalc / 50;
    seedCalc = seedCalc % 50;
    if (seedCalc < 23) // seedCalc between 0 and 22 - 46% chance of this branch
    {
        puzzleNum = puzzleNum % boost;
    }
    else if (seedCalc < 38) // seedCalc between 23 and 37 - 30% chance of this branch
    {
        puzzleNum = boost + (puzzleNum % 200);
    }
    else // arg >= 38 // seedCalc between 38 and 49 - 24% chance of this branch
    {
        puzzleNum = ((boost + 200) + (puzzleNum % 200));
    }
    uint temp = puzzleNum;
    // if the puzzleNum generated is more than the number of puzzle defined for this wave
    // then continually subtract 200 until we have one that is
    while (temp >= numPuzzles)
    {
        puzzleNum -= 200;
        temp = puzzleNum;
    }
    return (ushort)puzzleNum;
}

Other Differences To Intelligent Qube

In this game, it is not possible to run between the cubes. The collsion of the cubes overlaps the gridlines so even if you are perfectly positioned on them, you will be squashed. You also cannot squeeze underneath the cubes to mark a square while they are rolling, nor can you mark them from behind.

The bug with the diagonal movement values has also been fixed so all diagonal directions move 28 units instead of left + down moving 29.

@adeyblue