Palworld Breeding Algorithm Formula (Reverse-engineered, accuracy not guaranteed)

> Disclaimer: The algorithm described in this article was reverse-engineered through data unpacking + actual breeding data. It is not guaranteed to be 100% correct. We apologize for any errors. All in-game situations take precedence.
>
> Online Breeding Calculator Tool: https://www.maingamers.com/games/palworld/tools/breeding

---

## 1. Algorithm Overview

Breeding consists of four layers of decision-making:

```
Input: Parent A, Parent B
  │
  ├─① DT_PalCombiUnique Special Case Hit → Return fixed offspring
  │
  ├─② Same Species Self-Breeding (A.id === B.id) AND A can be an offspring → Return self
  │
  └─③ Standard Formula
        ├─ target = floor((CombiRank_A + CombiRank_B + 1) / 2)
        ├─ Construct offspring candidate pool 'pool' based on rules
        └─ Select the one with the minimum |CombiRank - target| from 'pool'; if distances are equal, resolve by tie-breaking rules
```

---

## 2. Data Sources and Fields

### 2.1 Data Tables

| Table | Unpack Path | Purpose |
|---|---|---|
| `DT_PalMonsterParameter` | `Pal/DataTable/Character/DT_PalMonsterParameter.json` | Pal Parameters |
| `DT_PalCombiUnique` | `Pal/DataTable/Character/DT_PalCombiUnique.json` | Special Breeding Cases |

### 2.2 Fields Involved in Calculation

| Field | Role |
|---|---|
| `CombiRank` | Calculate target; offspring distance; tie-breaking comparison |
| `IgnoreCombi` | Parents usable, offspring not usable; affects offspring pool and tie-breaking |
| `Tribe` | Special case table parent matching |
| `Gender` | Special case table optional condition |
| `ZukanIndex` | Parent/offspring admission (must be ≥ 0) |
| `ZukanIndexSuffix` | B variant identification; offspring pool and tie-breaking |
| `IsBoss` / `IsTowerBoss` / `IsRaidBoss` | Offspring pool exclusion |
| `ChildCharacterID` | Special case offspring output |

### 2.3 Terminology

- **IgnoreCombi Parent**: Pals with `IgnoreCombi === true` can be parents but not standard offspring from the formula.
- **B Variant**: `ZukanIndexSuffix` is not empty (usually `B`), and its CombiRank may differ from the standard entry.
- **Single Legend Combination** (`oneLegend`): Exactly one parent has `IgnoreCombi` set to true.
- **dominantNonLegend**: The non-IgnoreCombi parent with the higher CombiRank.

---

## 3. Index Construction

For each row in `DT_PalMonsterParameter` where `IsPal=true`:

1. **Canonical Row**: When multiple rows share the same `BPClass`, select the canonical row (`sourceKey === BPClass`); exclude internal rows like `BOSS_`/`RAID_`/`GYM_`/`QUEST_` and `*_Oilrig`, `*_Tower`.
2. **Parent Pool** (`breedable`): `CombiRank` is valid (< 9000), has a Zukan Index, is not a Raid/Tower Boss, and is not an internal variant; `IgnoreCombi=true` can also be a parent.
3. **Offspring Pool** (`childCandidates`): Satisfies parent conditions, and `IgnoreCombi=false`, not `IsBoss`.

---

## 4. Special Breeding Cases

Check `DT_PalCombiUnique`: Match parents by `Tribe` (order doesn't matter). If the `Gender` condition is met, return `ChildCharacterID` and skip the formula.

---

## 5. Same Species Self-Breeding

If `parentA.id === parentB.id` and this Pal is in the offspring pool → the offspring is itself.

---

## 6. Standard Formula

### 6.1 target

```
target = floor((CombiRank_ParentA + CombiRank_ParentB + 1) / 2)
```

### 6.2 Offspring Candidate Pool

Let `nonB` = offspring candidates without the B suffix, `maxParentRank` = max(Parent CombiRank). Execute in order; stop upon a match:

**Rule A — Parent with B Suffix**

```
If ParentA.ZukanIndexSuffix === "B" OR ParentB.ZukanIndexSuffix === "B"
  → pool = nonB
```

**Rule B — Both Parents are IgnoreCombi**

```
If ParentA.ignored && ParentB.ignored
  → pool = nonB excluding candidates where CombiRank === target
```

**Rule C — Single IgnoreCombi + High Fertility Non-Legend**

```
If oneLegend && dominantNonLegend.rank >= 1700
  probe = offspring candidates \ { B variants with CombiRank === target }
  If the closest B variant in 'probe' has a |rank - target| >= 2
    → pool = nonB
```

**Rule D — Base Pool and Unique Closest B**

```
pool = offspring candidates \ { B variants with CombiRank === target }

poolNonB = non-B variants in 'pool'
poolB    = B variants in 'pool'
bestBDist = minimum distance from 'poolB' to target
bestNDist = minimum distance from 'poolNonB' to target
uniqueClosestB = Exactly 1 B variant is the closest to target with distance === bestBDist

If bestBDist < bestNDist AND uniqueClosestB:
  If oneLegend:
    If dominantNonLegend.rank >= 1000
      → Remove this unique closest B variant from 'pool', keep 'pool'
    Else
      → pool = poolNonB
  Else
    → pool = poolNonB
```

**Rule E — All Closest Tier are B Variants (Both Parents Not IgnoreCombi)**

```
tierDist = minimum distance from 'pool' to target
tier     = candidates in 'pool' with |rank - target| === tierDist

If NOT oneLegend
  AND all variants in 'tier' are B variants
  AND bestNDist - tierDist >= 10
  AND maxParentRank > 2000
    → pool = poolNonB
```

**Rule F — Default**

```
Return the current pool
```

### 6.3 Select Offspring

From `pool`, select the one with the minimum `|CombiRank - target|`. If multiple have the same minimum distance, proceed to tie-breaking rules.

---

## 7. Tie-Breaking Rules

Let `best` and `candidate` have the same distance to `target`.

### 7.1 Same Type (Both B Variants or Both Non-B Variants)

```
If both are B variants AND oneLegend AND 650 <= maxParentRank < 1200:
  If one has rank < target and the other has rank >= target
    → Select the one with rank < target
  Else
    → Select the one with the higher CombiRank

Else:
  → Select the one with the higher CombiRank
```

### 7.2 Mixed (One B Variant, One Non-B Variant)

Evaluate in order; return upon match:

| Condition | Result |
|---|---|
| `oneLegend` AND `dominantNonLegend.rank > 1000` | Prioritize the side with `CombiRank >= target`; if on the same side, select the higher CombiRank |
| `maxParentRank >= 1500` | Prioritize non-B variants |
| `650 <= maxParentRank < 1100` | Select the one with the higher CombiRank |
| Others | Prioritize non-B variants |