I'm trying to code a DB based web app with Python/Django and I have some issues figuring out which is the best approach for my purpose, so I'll try to explain myself the best way possible.

我正在尝试用Python/Django编写一个基于数据库的Web应用程序，我有一些问题想知道哪种方法最适合我的目的，所以我会试着用最好的方式来解释自己。

The DB stores objects that represent a videogame PG's Armor Pieces. Every piece has some positive/negative abilities scores: wearing a complete Armor set (Helmet, Jacket etc..), the scores for each ability sum up and can give different effects.
So, every armor piece can have different abilities, and each Ability can be shared between several Armor Pieces, but the scores for each Ability may be different for different Armor Pieces.

该数据库存储代表视频游戏PG的装甲碎片的对象。每一件都有一些正面/负面的异能得分：穿戴一套完整的盔甲(头盔、夹克等)，每种异能的得分相加，可以产生不同的效果。因此，每个装甲都可以有不同的能力，每个能力可以在几个装甲之间共享，但不同的装甲可能会有不同的得分。

Once finished, this app should be able to find - if possible - a complete ArmorSet composed of 5 ArmorPiece which have the PieceAbility.scores necessary to activate one or more Effects the user would like.

一旦完成，这个应用程序应该能够找到-如果可能的话-一个完整的ArmorSet由5个ArmorPiess组成，其中有必要的PieceAbility.Score激活一个或多个用户想要的效果。

from django.db import models


class Ability(models.Model):
    name = models.CharField(max_length=20)

    def __str__(self) -> str:
        return self.name

class ArmorSetPart(models.Model):
    part = models.CharField(max_length=10)

    def __str__(self) -> str:
        return self.part

class WeaponClass(models.Model):
    type = models.CharField(max_length=20)

    def __str__(self) -> str:
        return self.type

class Rank(models.Model):
    rank = models.CharField(max_length=10)

    def __str__(self) -> str:
        return self.rank
    
class PieceAbility(models.Model):
    name = models.ForeignKey(Ability, related_name='pieces', on_delete=models.CASCADE)
    score = models.IntegerField(default=0, )

    def __str__(self) -> str:
        return self.name.name + ' ' + '{0:+}'.format(self.score)
    
class Material(models.Model):
    name = models.CharField(max_length=30)

    def __str__(self) -> str:
        return self.name

class CraftMaterial(models.Model):
    material = models.ForeignKey(Material, on_delete=models.CASCADE, null=True)
    quantity = models.IntegerField(default=1)

    def __str__(self) -> str:
        return f'{self.material} x {self.quantity}'

class ArmorPiece(models.Model):
    name = models.CharField(max_length=20)
    weapon_class = models.ForeignKey(WeaponClass, on_delete=models.CASCADE, null=True)
    set_part = models.ForeignKey(ArmorSetPart, related_name='set_parts', on_delete=models.CASCADE)
    rank = models.ForeignKey(Rank, on_delete=models.CASCADE, null=True)
    slots = models.IntegerField(null=True)
    rarity = models.IntegerField(null=True)
    def_min = models.IntegerField(null=True)
    def_max = models.IntegerField(null=True)
    price = models.BigIntegerField()
    fire = models.IntegerField()
    water = models.IntegerField()
    ice = models.IntegerField()
    thund = models.IntegerField()
    drag = models.IntegerField()
    ability = models.ManyToManyField(PieceAbility, related_name='pieces')
    craft_mater = models.ManyToManyField(CraftMaterial, related_name='required_for')

    def __str__(self) -> str:
        return self.name


class Effect(models.Model):
    name = models.CharField(max_length=40)
    ability = models.ForeignKey(Ability, related_name='effects', on_delete=models.CASCADE, null=True)
    necess_score = models.IntegerField(default=10, null=True)

    def __str__(self) -> str:
        return self.name

Now, in the code I wrote above you can see I choosed a ManytoMany relationship between ArmorPiece and PieceAbility, but I'm not satisfied due to the fact in this way DB stores every different PieceAbility.score for each ArmorPiece: if ArmorPiece1 has PieceAbilityA +1, and ArmorPiece2 has the same PieceAbility but with a different score like +4, I now have 2 instances of PieceAbility.
It doesn't seem very efficient to me and I wonder if there is a different/better way to do it.
The same issue shows up with the relationship between models CraftMaterial and ArmorPiece.

现在，在我上面编写的代码中，您可以看到我在ArmorPiess和PieceAability之间选择了ManytoMany关系，但我并不满意，因为数据库以这种方式存储每个ArmorPiess的每个不同的PieceAbility.core：如果ArmorPiece1具有PieceAbilityA+1，而ArmorPiece2具有相同的PieceAability，但具有不同的分数(如+4)，则我现在有2个PieceAability实例。对我来说，这似乎不是很有效，我想知道是否有不同的/更好的方法来做这件事。同样的问题也出现在CraftMaterial和ArmorPiess模型之间的关系上。

The first time I wrote ArmorPiece class there were several ability fields with their score field, like:

我第一次写ArmorPiece类的时候，有几个能力字段和它们的得分字段，比如：

class ArmorPiece(models.Model):
    ability_one = models.ForeignKey(Ability, ...)
    score_one = models.IntegerField()
    ability_two = models.ForeignKey(Ability, ...)
    score_two = models.IntegerField()

I think this way is even worst.

我觉得这条路更糟糕。

I'm a novice. Surely I don't have enough experience to understand which approach is better, so I'm in your hands!

我是个新手。当然，我没有足够的经验来理解哪种方法更好，所以我掌握在你的手中！

The videogame is an old gen Monster Hunter title, if it can help you understand what i mean, and please forgive my English, Thank you in advance!!

这个视频游戏是一个古老的Gen Monster Hunter游戏，如果它能帮助你理解我的意思，请原谅我的英语，提前谢谢你！