ivanch/pet-companion-back
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: ivanch:06455db59882643906e84082b0235f22677d1a52
Branches Tags
ivanch:main
...
compare: ivanch:5289910270cb5ebe6e3c81c0ffb3763888e79c3b
Branches Tags
ivanch:main

3 Commits
06455db598 ... 5289910270

Author SHA1 Message Date
Jose Henrique
5289910270 inventory working :D 2025-02-05 19:38:25 -03:00
Jose Henrique
7a2c3d2f67 not working inventory :c 2025-02-04 17:47:18 -03:00
Jose Henrique
f234b5d84d Add skill management system: implement Skill and PetSkill models, create SkillController, and update ApplicationDbContext for skills 2025-02-02 15:30:48 -03:00
32 changed files with 2783 additions and 619 deletions
Show Stats Expand all files Collapse all files

113
Controllers/InventoryController.cs Normal file
View File

@ -0,0 +1,113 @@
using Microsoft.AspNetCore.Mvc;
using PetCompanion.Models;
using PetCompanion.Services;
namespace PetCompanion.Controllers
{
[ApiController]
[Route("api/v1/[controller]")]
public class InventoryController : ControllerBase
{
private readonly PetInventoryService inventoryService;
private readonly ILogger<InventoryController> logger;
private readonly Guid userId = Guid.Parse("f5f4b3b3-3b7b-4b7b-8b7b-7b7b7b7b7b7b");
public InventoryController(
ILogger<InventoryController> logger,
PetInventoryService inventoryService)
{
this.logger = logger;
this.inventoryService = inventoryService;
}
[HttpGet("{petId}")]
public IActionResult GetInventory(string petId)
{
try
{
var inventory = inventoryService.GetInventory(petId, userId.ToString());
return Ok(inventory);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPut("{petId}/{itemId}/use")]
public IActionResult UseItem(string petId, int itemId)
{
try
{
var updatedPet = inventoryService.UseItem(petId, userId.ToString(), itemId);
return Ok(updatedPet);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPut("{petId}/{itemId}/equip")]
public IActionResult EquipItem(string petId, int itemId)
{
try
{
var updatedPet = inventoryService.EquipItem(petId, userId.ToString(), itemId);
return Ok(updatedPet);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPut("{petId}/{equipTarget}/unequip")]
public IActionResult UnequipItem(string petId, ItemEquipTarget equipTarget)
{
try
{
var updatedPet = inventoryService.UnequipItem(petId, userId.ToString(), equipTarget);
return Ok(updatedPet);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPut("{petId}/{itemId}/drop")]
public IActionResult DropItem(string petId, int itemId)
{
try
{
var updatedPet = inventoryService.DropItem(petId, userId.ToString(), itemId);
return Ok(updatedPet);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPost("{petId}/create")]
public IActionResult AddItem(string petId, [FromBody] AddItemRequest request)
{
try
{
var updatedPet = inventoryService.AddItemToPet(petId, userId.ToString(), request.ItemId, request.Quantity);
return Ok(updatedPet);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
}
public class AddItemRequest
{
public int ItemId { get; set; }
public int Quantity { get; set; } = 1;
}
}

60
Controllers/SkillController.cs Normal file
View File

@ -0,0 +1,60 @@
using Microsoft.AspNetCore.Mvc;
using PetCompanion.Services;
namespace PetCompanion.Controllers
{
[ApiController]
[Route("api/v1/[controller]")]
public class SkillController : ControllerBase
{
private readonly SkillService _skillService;
private readonly PetSkillService _petSkillService;
private readonly ILogger<SkillController> _logger;
private Guid userId = Guid.Parse("f5f4b3b3-3b7b-4b7b-8b7b-7b7b7b7b7b7b");
public SkillController(
ILogger<SkillController> logger,
SkillService skillService,
PetSkillService petSkillService)
{
_logger = logger;
_skillService = skillService;
_petSkillService = petSkillService;
}
[HttpGet]
public IActionResult GetAvailableSkills()
{
var skills = _skillService.GetAvailableSkills();
return Ok(skills);
}
[HttpGet("{petId}/skills")]
public IActionResult GetPetSkills(string petId)
{
try
{
var skills = _petSkillService.GetPetSkills(petId, userId.ToString());
return Ok(skills);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPost("{petId}/allocate/{skillId}")]
public IActionResult AllocateSkillPoint(string petId, int skillId)
{
try
{
var result = _petSkillService.AllocateSkillPoint(petId, userId.ToString(), skillId);
return Ok(result);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
}
}

57
Data/ApplicationDbContext.cs
View File

@ -12,6 +12,12 @@ namespace PetCompanion.Data
public DbSet<Pet> Pets { get; set; }
public DbSet<PetStats> PetStats { get; set; }
public DbSet<Resources> Resources { get; set; }
public DbSet<Skill> Skills { get; set; }
public DbSet<SkillEffect> SkillEffects { get; set; }
public DbSet<PetSkill> PetSkills { get; set; }
public DbSet<GameItem> GameItems { get; set; }
public DbSet<Inventory> Inventories { get; set; }
public DbSet<EquippedItem> EquippedItems { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
@ -29,6 +35,57 @@ namespace PetCompanion.Data
.HasConversion(
v => v != DateTime.MinValue ? v.ToUniversalTime() : v,
v => v != DateTime.MinValue ? DateTime.SpecifyKind(v, DateTimeKind.Utc) : v);
modelBuilder.Entity<PetSkill>()
.HasOne(ps => ps.Pet)
.WithMany(p => p.Skills)
.HasForeignKey(ps => ps.PetId);
modelBuilder.Entity<PetSkill>()
.HasOne(ps => ps.Skill)
.WithMany(s => s.PetSkills)
.HasForeignKey(ps => ps.SkillId);
modelBuilder.Entity<SkillEffect>()
.HasOne(se => se.Skill)
.WithMany(s => s.Effects)
.HasForeignKey(se => se.SkillId);
modelBuilder.Entity<EquippedItem>()
.HasOne(e => e.Pet)
.WithMany(p => p.EquippedItemsList)
.HasForeignKey(e => e.PetId);
modelBuilder.Entity<EquippedItem>()
.HasOne(e => e.GameItem)
.WithMany()
.HasForeignKey(e => e.GameItemId);
// Seed initial skills
var skills = SkillsData.GetInitialSkills();
var skillWithoutEffects = SkillsData.GetInitialSkills().Select(s => new Skill
{
Id = s.Id,
Name = s.Name,
Type = s.Type,
Description = s.Description,
PointsCost = s.PointsCost,
Icon = s.Icon,
SkillsIdRequired = s.SkillsIdRequired
}).ToList();
foreach (var skill in skillWithoutEffects)
{
modelBuilder.Entity<Skill>().HasData(skill);
}
foreach (var skill in skills)
{
foreach (var effect in skill.Effects)
{
modelBuilder.Entity<SkillEffect>().HasData(effect);
}
}
}
}
}

273
Data/SkillsData.cs Normal file
View File

@ -0,0 +1,273 @@
using PetCompanion.Models;
namespace PetCompanion.Data
{
public static class SkillsData
{
public static IEnumerable<Skill> GetInitialSkills()
{
return new List<Skill>
{
new Skill
{
Id = 1,
Name = "Vitality Mastery",
Description = "Increases maximum health of your pet, making it more resilient.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "❤",
SkillsIdRequired = null,
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 1,
SkillId = 1,
Tier = SkillTier.I,
Effect = "MaxHealth",
Value = 25
},
new SkillEffect
{
Id = 2,
SkillId = 1,
Tier = SkillTier.II,
Effect = "MaxHealth",
Value = 50
},
new SkillEffect
{
Id = 3,
SkillId = 1,
Tier = SkillTier.III,
Effect = "MaxHealth",
Value = 100
}
}
},
new Skill
{
Id = 2,
Name = "Mind Enhancement",
Description = "Increases maximum intelligence of your pet, improving its learning capabilities.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "🧠",
SkillsIdRequired = null,
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 4,
SkillId = 2,
Tier = SkillTier.I,
Effect = "MaxIntelligence",
Value = 5
},
new SkillEffect
{
Id = 5,
SkillId = 2,
Tier = SkillTier.II,
Effect = "MaxIntelligence",
Value = 10
},
new SkillEffect
{
Id = 6,
SkillId = 2,
Tier = SkillTier.III,
Effect = "MaxIntelligence",
Value = 20
}
}
},
new Skill
{
Id = 3,
Name = "Strength Training",
Description = "Increases maximum strength of your pet, making it more powerful.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "💪",
SkillsIdRequired = null,
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 7,
SkillId = 3,
Tier = SkillTier.I,
Effect = "MaxStrength",
Value = 5
},
new SkillEffect
{
Id = 8,
SkillId = 3,
Tier = SkillTier.II,
Effect = "MaxStrength",
Value = 10
},
new SkillEffect
{
Id = 9,
SkillId = 3,
Tier = SkillTier.III,
Effect = "MaxStrength",
Value = 20
}
}
},
new Skill
{
Id = 4,
Name = "Charisma Boost",
Description = "Increases maximum charisma of your pet, making it more charming.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "🎭",
SkillsIdRequired = null,
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 10,
SkillId = 4,
Tier = SkillTier.I,
Effect = "MaxCharisma",
Value = 5
},
new SkillEffect
{
Id = 11,
SkillId = 4,
Tier = SkillTier.II,
Effect = "MaxCharisma",
Value = 10
},
new SkillEffect
{
Id = 12,
SkillId = 4,
Tier = SkillTier.III,
Effect = "MaxCharisma",
Value = 20
}
}
},
new Skill
{
Id = 5,
Name = "Luck of the Draw",
Description = "Increases luck of your pet, making it more fortunate to find rare items.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "🍀",
SkillsIdRequired = new List<int> { 4 },
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 13,
SkillId = 5,
Tier = SkillTier.I,
Effect = "Luck",
Value = 1
},
new SkillEffect
{
Id = 14,
SkillId = 5,
Tier = SkillTier.II,
Effect = "Luck",
Value = 2
},
new SkillEffect
{
Id = 15,
SkillId = 5,
Tier = SkillTier.III,
Effect = "Luck",
Value = 3
}
}
},
new Skill
{
Id = 6,
Name = "Agility Training",
Description = "Increases agility of your pet, making it faster in combat.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "🏃",
SkillsIdRequired = new List<int> { 3 },
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 16,
SkillId = 6,
Tier = SkillTier.I,
Effect = "Agility",
Value = 1
},
new SkillEffect
{
Id = 17,
SkillId = 6,
Tier = SkillTier.II,
Effect = "Agility",
Value = 2
},
new SkillEffect
{
Id = 18,
SkillId = 6,
Tier = SkillTier.III,
Effect = "Agility",
Value = 3
}
}
},
new Skill
{
Id = 7,
Name = "Perception Boost",
Description = "Increases perception of your pet, making it more aware of its surroundings.",
Type = SkillType.GROUND,
PointsCost = 1,
Icon = "👀",
SkillsIdRequired = new List<int> { 2 },
Effects = new List<SkillEffect>
{
new SkillEffect
{
Id = 19,
SkillId = 7,
Tier = SkillTier.I,
Effect = "Perception",
Value = 1
},
new SkillEffect
{
Id = 20,
SkillId = 7,
Tier = SkillTier.II,
Effect = "Perception",
Value = 2
},
new SkillEffect
{
Id = 21,
SkillId = 7,
Tier = SkillTier.III,
Effect = "Perception",
Value = 3
}
}
}
};
}
}
}

21
GameItemsData.csv Normal file
View File

@ -0,0 +1,21 @@
Id,Name,Type,Rarity,Description,Price,Effect,EquipTarget
1,Apple,Material,Common,Crafting material (coming soon),0,Nothing,None
2,Superfood Smoothie,Consumable,Uncommon,Adds +30 food resources; Restores 5 Intelligence,0,ADD_FOOD_RESOURCES_30,None
3,Energy Drink,Consumable,Rare,Reduces Cooldown by 5 min,0,REDUCE_COOLDOWN_5,None
4,Golden Apple,Consumable,Legendary,Adds +20 Intelligence (Permanent); Adds +100 food resources,0,ADD_INTELLIGENCE_20,None
5,Healing Potion,Consumable,Uncommon,Adds +20 to Health; Adds +20 food resources,0,ADD_HEALTH_20_AND_FOOD_20,None
6,Charisma Cookie,Consumable,Rare,Adds +2 Charisma (Permanent),0,ADD_CHARISMA_2,None
7,XP Booster,Consumable,Rare,Award +10 XP,0,ADD_XP_10,None
8,Sleeping Draught,Consumable,Common,Reduces Cooldown for resting by 10 min,0,REDUCE_REST_COOLDOWN_10,None
9,Mystery Meat,Consumable,Uncommon,Randomly ±2 to one stat (Permanent),0,ADD_RANDOM_STAT_2,None
10,Elixir of Vitality,Consumable,Legendary,Fully restores all stats and health; Adds +1 Level,0,RESTORE_STATS;ADD_LEVEL_1,None
11,Leather Hat,Equipment,Common,Helmet: +5 Max Health,0,ADD_MAX_HEALTH_5,Head
12,Wizard Hat,Equipment,Rare,Helmet: +15 Max Intelligence,0,ADD_MAX_INTELLIGENCE_15,Head
13,Knight's Armor,Equipment,Rare,Chest: +15 Max Strength,0,ADD_MAX_STRENGTH_15,Body
14,Golden Boots,Equipment,Uncommon,Legging: +10 Max Charisma,0,ADD_MAX_CHARISMA_10,Legs
15,Laser Pointer,Equipment,Common,Weapon: +5 Max Strength,0,ADD_MAX_STRENGTH_5,Weapon
16,Celestial Crown,Equipment,Legendary,Helmet: +20 max to all stats,0,ADD_MAX_ALL_STATS_20,Head
17,Dragon Scale Shield,Equipment,Legendary,Weapon: +50 Max Health,0,ADD_MAX_HEALTH_50,Weapon
18,Feathers,Material,Common,Crafting material (coming soon),0,Nothing,None
19,Phoenix Feather,Material,Legendary,Crafting material (coming soon),0,Nothing,None
21,Basic Kibble,Consumable,Common,Adds +20 food resources,0,ADD_FOOD_RESOURCES_20,None
1 Id Name Type Rarity Description Price Effect EquipTarget
2 1 Apple Material Common Crafting material (coming soon) 0 Nothing None
3 2 Superfood Smoothie Consumable Uncommon Adds +30 food resources; Restores 5 Intelligence 0 ADD_FOOD_RESOURCES_30 None
4 3 Energy Drink Consumable Rare Reduces Cooldown by 5 min 0 REDUCE_COOLDOWN_5 None
5 4 Golden Apple Consumable Legendary Adds +20 Intelligence (Permanent); Adds +100 food resources 0 ADD_INTELLIGENCE_20 None
6 5 Healing Potion Consumable Uncommon Adds +20 to Health; Adds +20 food resources 0 ADD_HEALTH_20_AND_FOOD_20 None
7 6 Charisma Cookie Consumable Rare Adds +2 Charisma (Permanent) 0 ADD_CHARISMA_2 None
8 7 XP Booster Consumable Rare Award +10 XP 0 ADD_XP_10 None
9 8 Sleeping Draught Consumable Common Reduces Cooldown for resting by 10 min 0 REDUCE_REST_COOLDOWN_10 None
10 9 Mystery Meat Consumable Uncommon Randomly ±2 to one stat (Permanent) 0 ADD_RANDOM_STAT_2 None
11 10 Elixir of Vitality Consumable Legendary Fully restores all stats and health; Adds +1 Level 0 RESTORE_STATS;ADD_LEVEL_1 None
12 11 Leather Hat Equipment Common Helmet: +5 Max Health 0 ADD_MAX_HEALTH_5 Head
13 12 Wizard Hat Equipment Rare Helmet: +15 Max Intelligence 0 ADD_MAX_INTELLIGENCE_15 Head
14 13 Knight's Armor Equipment Rare Chest: +15 Max Strength 0 ADD_MAX_STRENGTH_15 Body
15 14 Golden Boots Equipment Uncommon Legging: +10 Max Charisma 0 ADD_MAX_CHARISMA_10 Legs
16 15 Laser Pointer Equipment Common Weapon: +5 Max Strength 0 ADD_MAX_STRENGTH_5 Weapon
17 16 Celestial Crown Equipment Legendary Helmet: +20 max to all stats 0 ADD_MAX_ALL_STATS_20 Head
18 17 Dragon Scale Shield Equipment Legendary Weapon: +50 Max Health 0 ADD_MAX_HEALTH_50 Weapon
19 18 Feathers Material Common Crafting material (coming soon) 0 Nothing None
20 19 Phoenix Feather Material Legendary Crafting material (coming soon) 0 Nothing None
21 21 Basic Kibble Consumable Common Adds +20 food resources 0 ADD_FOOD_RESOURCES_20 None

20
Items.csv
View File

@ -1,20 +0,0 @@
Item Name, Type, Rarity, Description
Basic Kibble,Consumable,Common,Adds +20 food resources
Superfood Smoothie,Consumable,Uncommon,Adds +30 food resources; Restores 5 Intelligence
Energy Drink,Consumable,Rare,Reduces Cooldown by 5 min
Golden Apple,Consumable,Legendary,Adds +20 Intelligence (Permanent); Adds +100 food resources
Healing Potion,Consumable,Uncommon,Adds +20 to Health; Adds +20 food resources
Charisma Cookie,Consumable,Rare,Adds +2 Charisma (Permanent)
XP Booster,Consumable,Rare,Award +10 XP
Sleeping Draught,Consumable,Common,Reduces Cooldown for resting by 10 min
Mystery Meat,Consumable,Uncommon,Randomly ±2 to one stat (Permanent)
Elixir of Vitality,Consumable,Legendary,Fully restores all stats and health; Adds +1 Level
Leather Hat,Equipment,Common,Helmet: +5 Max Health
Wizard Hat,Equipment,Rare,Helmet: +15 Max Intelligence
Knight's Armor,Equipment,Rare,Chest: +15 Max Strength
Golden Boots,Equipment,Uncommon,Legging: +10 Max Charisma
Laser Pointer,Equipment,Common,Weapon: +5 Max Strength
Celestial Crown,Equipment,Legendary,Helmet: +20 max to all stats
Dragon Scale Shield,Equipment,Legendary,Weapon: +50 Max Health
Feathers,Material,Common, Crafting material (coming soon)
Phoenix Feather,Material,Legendary, Crafting material (coming soon)
1 Item Name Type Rarity Description
2 Basic Kibble Consumable Common Adds +20 food resources
3 Superfood Smoothie Consumable Uncommon Adds +30 food resources; Restores 5 Intelligence
4 Energy Drink Consumable Rare Reduces Cooldown by 5 min
5 Golden Apple Consumable Legendary Adds +20 Intelligence (Permanent); Adds +100 food resources
6 Healing Potion Consumable Uncommon Adds +20 to Health; Adds +20 food resources
7 Charisma Cookie Consumable Rare Adds +2 Charisma (Permanent)
8 XP Booster Consumable Rare Award +10 XP
9 Sleeping Draught Consumable Common Reduces Cooldown for resting by 10 min
10 Mystery Meat Consumable Uncommon Randomly ±2 to one stat (Permanent)
11 Elixir of Vitality Consumable Legendary Fully restores all stats and health; Adds +1 Level
12 Leather Hat Equipment Common Helmet: +5 Max Health
13 Wizard Hat Equipment Rare Helmet: +15 Max Intelligence
14 Knight's Armor Equipment Rare Chest: +15 Max Strength
15 Golden Boots Equipment Uncommon Legging: +10 Max Charisma
16 Laser Pointer Equipment Common Weapon: +5 Max Strength
17 Celestial Crown Equipment Legendary Helmet: +20 max to all stats
18 Dragon Scale Shield Equipment Legendary Weapon: +50 Max Health
19 Feathers Material Common Crafting material (coming soon)
20 Phoenix Feather Material Legendary Crafting material (coming soon)

141
Migrations/20250201173643_Initial.Designer.cs generated
View File

@ -1,141 +0,0 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using PetCompanion.Data;
#nullable disable
namespace PetCompanion.Migrations
{
[DbContext(typeof(ApplicationDbContext))]
[Migration("20250201173643_Initial")]
partial class Initial
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder.HasAnnotation("ProductVersion", "9.0.1");
modelBuilder.Entity("PetCompanion.Models.Pet", b =>
{
b.Property<string>("Id")
.HasColumnType("TEXT");
b.Property<DateTime>("BasicActionCooldown")
.HasColumnType("TEXT");
b.Property<int>("Class")
.HasColumnType("INTEGER");
b.Property<DateTime>("GatherActionSince")
.HasColumnType("TEXT");
b.Property<bool>("IsDead")
.HasColumnType("INTEGER");
b.Property<int>("Level")
.HasColumnType("INTEGER");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("PetBasicAction")
.HasColumnType("INTEGER");
b.Property<int>("PetGatherAction")
.HasColumnType("INTEGER");
b.Property<string>("UserId")
.IsRequired()
.HasColumnType("TEXT");
b.HasKey("Id");
b.ToTable("Pets");
});
modelBuilder.Entity("PetCompanion.Models.PetStats", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Charisma")
.HasColumnType("INTEGER");
b.Property<int>("Intelligence")
.HasColumnType("INTEGER");
b.Property<int>("MaxCharisma")
.HasColumnType("INTEGER");
b.Property<int>("MaxIntelligence")
.HasColumnType("INTEGER");
b.Property<int>("MaxStrength")
.HasColumnType("INTEGER");
b.Property<int>("Strength")
.HasColumnType("INTEGER");
b.HasKey("PetId");
b.ToTable("PetStats");
});
modelBuilder.Entity("PetCompanion.Models.Resources", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Food")
.HasColumnType("INTEGER");
b.Property<int>("Gold")
.HasColumnType("INTEGER");
b.Property<int>("Junk")
.HasColumnType("INTEGER");
b.Property<int>("Wisdom")
.HasColumnType("INTEGER");
b.HasKey("PetId");
b.ToTable("Resources");
});
modelBuilder.Entity("PetCompanion.Models.PetStats", b =>
{
b.HasOne("PetCompanion.Models.Pet", null)
.WithOne("Stats")
.HasForeignKey("PetCompanion.Models.PetStats", "PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.Resources", b =>
{
b.HasOne("PetCompanion.Models.Pet", null)
.WithOne("Resources")
.HasForeignKey("PetCompanion.Models.Resources", "PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.Pet", b =>
{
b.Navigation("Resources")
.IsRequired();
b.Navigation("Stats")
.IsRequired();
});
#pragma warning restore 612, 618
}
}
}

92
Migrations/20250201173643_Initial.cs
View File

@ -1,92 +0,0 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace PetCompanion.Migrations
{
/// <inheritdoc />
public partial class Initial : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Pets",
columns: table => new
{
Id = table.Column<string>(type: "TEXT", nullable: false),
Name = table.Column<string>(type: "TEXT", nullable: false),
Class = table.Column<int>(type: "INTEGER", nullable: false),
Level = table.Column<int>(type: "INTEGER", nullable: false),
UserId = table.Column<string>(type: "TEXT", nullable: false),
IsDead = table.Column<bool>(type: "INTEGER", nullable: false),
PetGatherAction = table.Column<int>(type: "INTEGER", nullable: false),
GatherActionSince = table.Column<DateTime>(type: "TEXT", nullable: false),
PetBasicAction = table.Column<int>(type: "INTEGER", nullable: false),
BasicActionCooldown = table.Column<DateTime>(type: "TEXT", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Pets", x => x.Id);
});
migrationBuilder.CreateTable(
name: "PetStats",
columns: table => new
{
PetId = table.Column<string>(type: "TEXT", nullable: false),
Intelligence = table.Column<int>(type: "INTEGER", nullable: false),
Strength = table.Column<int>(type: "INTEGER", nullable: false),
Charisma = table.Column<int>(type: "INTEGER", nullable: false),
MaxIntelligence = table.Column<int>(type: "INTEGER", nullable: false),
MaxStrength = table.Column<int>(type: "INTEGER", nullable: false),
MaxCharisma = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_PetStats", x => x.PetId);
table.ForeignKey(
name: "FK_PetStats_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "Resources",
columns: table => new
{
PetId = table.Column<string>(type: "TEXT", nullable: false),
Wisdom = table.Column<int>(type: "INTEGER", nullable: false),
Gold = table.Column<int>(type: "INTEGER", nullable: false),
Food = table.Column<int>(type: "INTEGER", nullable: false),
Junk = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Resources", x => x.PetId);
table.ForeignKey(
name: "FK_Resources_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "PetStats");
migrationBuilder.DropTable(
name: "Resources");
migrationBuilder.DropTable(
name: "Pets");
}
}
}

634
Migrations/20250204213845_InitialCreate.Designer.cs generated Normal file
View File

@ -0,0 +1,634 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using PetCompanion.Data;
#nullable disable
namespace PetCompanion.Migrations
{
[DbContext(typeof(ApplicationDbContext))]
[Migration("20250204213845_InitialCreate")]
partial class InitialCreate
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder.HasAnnotation("ProductVersion", "9.0.1");
modelBuilder.Entity("PetCompanion.Models.EquippedItem", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<int>("EquipTarget")
.HasColumnType("INTEGER");
b.Property<int>("GameItemId")
.HasColumnType("INTEGER");
b.Property<string>("PetId")
.IsRequired()
.HasColumnType("TEXT");
b.HasKey("Id");
b.HasIndex("GameItemId");
b.HasIndex("PetId");
b.ToTable("EquippedItems");
});
modelBuilder.Entity("PetCompanion.Models.GameItem", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<string>("Description")
.IsRequired()
.HasColumnType("TEXT");
b.Property<string>("Effect")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("EquipTarget")
.HasColumnType("INTEGER");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("Price")
.HasColumnType("INTEGER");
b.Property<int>("Rarity")
.HasColumnType("INTEGER");
b.Property<int>("Type")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.ToTable("GameItems");
});
modelBuilder.Entity("PetCompanion.Models.Inventory", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Capacity")
.HasColumnType("INTEGER");
b.PrimitiveCollection<string>("Items")
.IsRequired()
.HasColumnType("TEXT");
b.HasKey("PetId");
b.ToTable("Inventories");
});
modelBuilder.Entity("PetCompanion.Models.Pet", b =>
{
b.Property<string>("Id")
.HasColumnType("TEXT");
b.Property<DateTime>("BasicActionCooldown")
.HasColumnType("TEXT");
b.Property<int>("Class")
.HasColumnType("INTEGER");
b.Property<int>("Experience")
.HasColumnType("INTEGER");
b.Property<DateTime>("GatherActionSince")
.HasColumnType("TEXT");
b.Property<int>("Health")
.HasColumnType("INTEGER");
b.Property<bool>("IsDead")
.HasColumnType("INTEGER");
b.Property<int>("Level")
.HasColumnType("INTEGER");
b.Property<int>("MaxHealth")
.HasColumnType("INTEGER");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("PetBasicAction")
.HasColumnType("INTEGER");
b.Property<int>("PetGatherAction")
.HasColumnType("INTEGER");
b.Property<int>("SkillPoints")
.HasColumnType("INTEGER");
b.Property<string>("UserId")
.IsRequired()
.HasColumnType("TEXT");
b.HasKey("Id");
b.ToTable("Pets");
});
modelBuilder.Entity("PetCompanion.Models.PetSkill", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<int>("CurrentTier")
.HasColumnType("INTEGER");
b.Property<string>("PetId")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("SkillId")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.HasIndex("PetId");
b.HasIndex("SkillId");
b.ToTable("PetSkills");
});
modelBuilder.Entity("PetCompanion.Models.PetStats", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Agility")
.HasColumnType("INTEGER");
b.Property<int>("Charisma")
.HasColumnType("INTEGER");
b.Property<int>("Intelligence")
.HasColumnType("INTEGER");
b.Property<int>("Luck")
.HasColumnType("INTEGER");
b.Property<int>("MaxCharisma")
.HasColumnType("INTEGER");
b.Property<int>("MaxIntelligence")
.HasColumnType("INTEGER");
b.Property<int>("MaxStrength")
.HasColumnType("INTEGER");
b.Property<int>("Perception")
.HasColumnType("INTEGER");
b.Property<int>("Strength")
.HasColumnType("INTEGER");
b.HasKey("PetId");
b.ToTable("PetStats");
});
modelBuilder.Entity("PetCompanion.Models.Resources", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Food")
.HasColumnType("INTEGER");
b.Property<int>("Gold")
.HasColumnType("INTEGER");
b.Property<int>("Junk")
.HasColumnType("INTEGER");
b.Property<int>("Wisdom")
.HasColumnType("INTEGER");
b.HasKey("PetId");
b.ToTable("Resources");
});
modelBuilder.Entity("PetCompanion.Models.Skill", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<string>("Description")
.IsRequired()
.HasColumnType("TEXT");
b.Property<string>("Icon")
.IsRequired()
.HasColumnType("TEXT");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("PointsCost")
.HasColumnType("INTEGER");
b.PrimitiveCollection<string>("SkillsIdRequired")
.HasColumnType("TEXT");
b.Property<int>("Type")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.ToTable("Skills");
b.HasData(
new
{
Id = 1,
Description = "Increases maximum health of your pet, making it more resilient.",
Icon = "❤",
Name = "Vitality Mastery",
PointsCost = 1,
Type = 0
},
new
{
Id = 2,
Description = "Increases maximum intelligence of your pet, improving its learning capabilities.",
Icon = "🧠",
Name = "Mind Enhancement",
PointsCost = 1,
Type = 0
},
new
{
Id = 3,
Description = "Increases maximum strength of your pet, making it more powerful.",
Icon = "💪",
Name = "Strength Training",
PointsCost = 1,
Type = 0
},
new
{
Id = 4,
Description = "Increases maximum charisma of your pet, making it more charming.",
Icon = "🎭",
Name = "Charisma Boost",
PointsCost = 1,
Type = 0
},
new
{
Id = 5,
Description = "Increases luck of your pet, making it more fortunate to find rare items.",
Icon = "🍀",
Name = "Luck of the Draw",
PointsCost = 1,
SkillsIdRequired = "[4]",
Type = 0
},
new
{
Id = 6,
Description = "Increases agility of your pet, making it faster in combat.",
Icon = "🏃",
Name = "Agility Training",
PointsCost = 1,
SkillsIdRequired = "[3]",
Type = 0
},
new
{
Id = 7,
Description = "Increases perception of your pet, making it more aware of its surroundings.",
Icon = "👀",
Name = "Perception Boost",
PointsCost = 1,
SkillsIdRequired = "[2]",
Type = 0
});
});
modelBuilder.Entity("PetCompanion.Models.SkillEffect", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<string>("Effect")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("SkillId")
.HasColumnType("INTEGER");
b.Property<int>("Tier")
.HasColumnType("INTEGER");
b.Property<decimal>("Value")
.HasColumnType("TEXT");
b.HasKey("Id");
b.HasIndex("SkillId");
b.ToTable("SkillEffects");
b.HasData(
new
{
Id = 1,
Effect = "MaxHealth",
SkillId = 1,
Tier = 1,
Value = 25m
},
new
{
Id = 2,
Effect = "MaxHealth",
SkillId = 1,
Tier = 2,
Value = 50m
},
new
{
Id = 3,
Effect = "MaxHealth",
SkillId = 1,
Tier = 3,
Value = 100m
},
new
{
Id = 4,
Effect = "MaxIntelligence",
SkillId = 2,
Tier = 1,
Value = 5m
},
new
{
Id = 5,
Effect = "MaxIntelligence",
SkillId = 2,
Tier = 2,
Value = 10m
},
new
{
Id = 6,
Effect = "MaxIntelligence",
SkillId = 2,
Tier = 3,
Value = 20m
},
new
{
Id = 7,
Effect = "MaxStrength",
SkillId = 3,
Tier = 1,
Value = 5m
},
new
{
Id = 8,
Effect = "MaxStrength",
SkillId = 3,
Tier = 2,
Value = 10m
},
new
{
Id = 9,
Effect = "MaxStrength",
SkillId = 3,
Tier = 3,
Value = 20m
},
new
{
Id = 10,
Effect = "MaxCharisma",
SkillId = 4,
Tier = 1,
Value = 5m
},
new
{
Id = 11,
Effect = "MaxCharisma",
SkillId = 4,
Tier = 2,
Value = 10m
},
new
{
Id = 12,
Effect = "MaxCharisma",
SkillId = 4,
Tier = 3,
Value = 20m
},
new
{
Id = 13,
Effect = "Luck",
SkillId = 5,
Tier = 1,
Value = 1m
},
new
{
Id = 14,
Effect = "Luck",
SkillId = 5,
Tier = 2,
Value = 2m
},
new
{
Id = 15,
Effect = "Luck",
SkillId = 5,
Tier = 3,
Value = 3m
},
new
{
Id = 16,
Effect = "Agility",
SkillId = 6,
Tier = 1,
Value = 1m
},
new
{
Id = 17,
Effect = "Agility",
SkillId = 6,
Tier = 2,
Value = 2m
},
new
{
Id = 18,
Effect = "Agility",
SkillId = 6,
Tier = 3,
Value = 3m
},
new
{
Id = 19,
Effect = "Perception",
SkillId = 7,
Tier = 1,
Value = 1m
},
new
{
Id = 20,
Effect = "Perception",
SkillId = 7,
Tier = 2,
Value = 2m
},
new
{
Id = 21,
Effect = "Perception",
SkillId = 7,
Tier = 3,
Value = 3m
});
});
modelBuilder.Entity("PetCompanion.Models.EquippedItem", b =>
{
b.HasOne("PetCompanion.Models.GameItem", "GameItem")
.WithMany()
.HasForeignKey("GameItemId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("PetCompanion.Models.Pet", "Pet")
.WithMany("EquippedItemsList")
.HasForeignKey("PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("GameItem");
b.Navigation("Pet");
});
modelBuilder.Entity("PetCompanion.Models.Inventory", b =>
{
b.HasOne("PetCompanion.Models.Pet", "Pet")
.WithOne("Inventory")
.HasForeignKey("PetCompanion.Models.Inventory", "PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Pet");
});
modelBuilder.Entity("PetCompanion.Models.PetSkill", b =>
{
b.HasOne("PetCompanion.Models.Pet", "Pet")
.WithMany("Skills")
.HasForeignKey("PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("PetCompanion.Models.Skill", "Skill")
.WithMany("PetSkills")
.HasForeignKey("SkillId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Pet");
b.Navigation("Skill");
});
modelBuilder.Entity("PetCompanion.Models.PetStats", b =>
{
b.HasOne("PetCompanion.Models.Pet", null)
.WithOne("Stats")
.HasForeignKey("PetCompanion.Models.PetStats", "PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.Resources", b =>
{
b.HasOne("PetCompanion.Models.Pet", null)
.WithOne("Resources")
.HasForeignKey("PetCompanion.Models.Resources", "PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.SkillEffect", b =>
{
b.HasOne("PetCompanion.Models.Skill", "Skill")
.WithMany("Effects")
.HasForeignKey("SkillId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Skill");
});
modelBuilder.Entity("PetCompanion.Models.Pet", b =>
{
b.Navigation("EquippedItemsList");
b.Navigation("Inventory")
.IsRequired();
b.Navigation("Resources")
.IsRequired();
b.Navigation("Skills");
b.Navigation("Stats")
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.Skill", b =>
{
b.Navigation("Effects");
b.Navigation("PetSkills");
});
#pragma warning restore 612, 618
}
}
}

318
Migrations/20250204213845_InitialCreate.cs Normal file
View File

@ -0,0 +1,318 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
namespace PetCompanion.Migrations
{
/// <inheritdoc />
public partial class InitialCreate : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "GameItems",
columns: table => new
{
Id = table.Column<int>(type: "INTEGER", nullable: false)
.Annotation("Sqlite:Autoincrement", true),
Name = table.Column<string>(type: "TEXT", nullable: false),
Type = table.Column<int>(type: "INTEGER", nullable: false),
Rarity = table.Column<int>(type: "INTEGER", nullable: false),
Description = table.Column<string>(type: "TEXT", nullable: false),
Price = table.Column<int>(type: "INTEGER", nullable: false),
Effect = table.Column<string>(type: "TEXT", nullable: false),
EquipTarget = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_GameItems", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Pets",
columns: table => new
{
Id = table.Column<string>(type: "TEXT", nullable: false),
Name = table.Column<string>(type: "TEXT", nullable: false),
Class = table.Column<int>(type: "INTEGER", nullable: false),
Level = table.Column<int>(type: "INTEGER", nullable: false),
Experience = table.Column<int>(type: "INTEGER", nullable: false),
Health = table.Column<int>(type: "INTEGER", nullable: false),
MaxHealth = table.Column<int>(type: "INTEGER", nullable: false),
UserId = table.Column<string>(type: "TEXT", nullable: false),
IsDead = table.Column<bool>(type: "INTEGER", nullable: false),
PetGatherAction = table.Column<int>(type: "INTEGER", nullable: false),
GatherActionSince = table.Column<DateTime>(type: "TEXT", nullable: false),
PetBasicAction = table.Column<int>(type: "INTEGER", nullable: false),
BasicActionCooldown = table.Column<DateTime>(type: "TEXT", nullable: false),
SkillPoints = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Pets", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Skills",
columns: table => new
{
Id = table.Column<int>(type: "INTEGER", nullable: false)
.Annotation("Sqlite:Autoincrement", true),
Name = table.Column<string>(type: "TEXT", nullable: false),
Description = table.Column<string>(type: "TEXT", nullable: false),
Type = table.Column<int>(type: "INTEGER", nullable: false),
PointsCost = table.Column<int>(type: "INTEGER", nullable: false),
Icon = table.Column<string>(type: "TEXT", nullable: false),
SkillsIdRequired = table.Column<string>(type: "TEXT", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_Skills", x => x.Id);
});
migrationBuilder.CreateTable(
name: "EquippedItems",
columns: table => new
{
Id = table.Column<int>(type: "INTEGER", nullable: false)
.Annotation("Sqlite:Autoincrement", true),
PetId = table.Column<string>(type: "TEXT", nullable: false),
EquipTarget = table.Column<int>(type: "INTEGER", nullable: false),
GameItemId = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_EquippedItems", x => x.Id);
table.ForeignKey(
name: "FK_EquippedItems_GameItems_GameItemId",
column: x => x.GameItemId,
principalTable: "GameItems",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_EquippedItems_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "Inventories",
columns: table => new
{
PetId = table.Column<string>(type: "TEXT", nullable: false),
Items = table.Column<string>(type: "TEXT", nullable: false),
Capacity = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Inventories", x => x.PetId);
table.ForeignKey(
name: "FK_Inventories_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "PetStats",
columns: table => new
{
PetId = table.Column<string>(type: "TEXT", nullable: false),
Intelligence = table.Column<int>(type: "INTEGER", nullable: false),
Strength = table.Column<int>(type: "INTEGER", nullable: false),
Charisma = table.Column<int>(type: "INTEGER", nullable: false),
Luck = table.Column<int>(type: "INTEGER", nullable: false),
Agility = table.Column<int>(type: "INTEGER", nullable: false),
Perception = table.Column<int>(type: "INTEGER", nullable: false),
MaxIntelligence = table.Column<int>(type: "INTEGER", nullable: false),
MaxStrength = table.Column<int>(type: "INTEGER", nullable: false),
MaxCharisma = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_PetStats", x => x.PetId);
table.ForeignKey(
name: "FK_PetStats_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "Resources",
columns: table => new
{
PetId = table.Column<string>(type: "TEXT", nullable: false),
Wisdom = table.Column<int>(type: "INTEGER", nullable: false),
Gold = table.Column<int>(type: "INTEGER", nullable: false),
Food = table.Column<int>(type: "INTEGER", nullable: false),
Junk = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Resources", x => x.PetId);
table.ForeignKey(
name: "FK_Resources_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "PetSkills",
columns: table => new
{
Id = table.Column<int>(type: "INTEGER", nullable: false)
.Annotation("Sqlite:Autoincrement", true),
PetId = table.Column<string>(type: "TEXT", nullable: false),
SkillId = table.Column<int>(type: "INTEGER", nullable: false),
CurrentTier = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_PetSkills", x => x.Id);
table.ForeignKey(
name: "FK_PetSkills_Pets_PetId",
column: x => x.PetId,
principalTable: "Pets",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_PetSkills_Skills_SkillId",
column: x => x.SkillId,
principalTable: "Skills",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "SkillEffects",
columns: table => new
{
Id = table.Column<int>(type: "INTEGER", nullable: false)
.Annotation("Sqlite:Autoincrement", true),
SkillId = table.Column<int>(type: "INTEGER", nullable: false),
Tier = table.Column<int>(type: "INTEGER", nullable: false),
Effect = table.Column<string>(type: "TEXT", nullable: false),
Value = table.Column<decimal>(type: "TEXT", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_SkillEffects", x => x.Id);
table.ForeignKey(
name: "FK_SkillEffects_Skills_SkillId",
column: x => x.SkillId,
principalTable: "Skills",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.InsertData(
table: "Skills",
columns: new[] { "Id", "Description", "Icon", "Name", "PointsCost", "SkillsIdRequired", "Type" },
values: new object[,]
{
{ 1, "Increases maximum health of your pet, making it more resilient.", "❤", "Vitality Mastery", 1, null, 0 },
{ 2, "Increases maximum intelligence of your pet, improving its learning capabilities.", "🧠", "Mind Enhancement", 1, null, 0 },
{ 3, "Increases maximum strength of your pet, making it more powerful.", "💪", "Strength Training", 1, null, 0 },
{ 4, "Increases maximum charisma of your pet, making it more charming.", "🎭", "Charisma Boost", 1, null, 0 },
{ 5, "Increases luck of your pet, making it more fortunate to find rare items.", "🍀", "Luck of the Draw", 1, "[4]", 0 },
{ 6, "Increases agility of your pet, making it faster in combat.", "🏃", "Agility Training", 1, "[3]", 0 },
{ 7, "Increases perception of your pet, making it more aware of its surroundings.", "👀", "Perception Boost", 1, "[2]", 0 }
});
migrationBuilder.InsertData(
table: "SkillEffects",
columns: new[] { "Id", "Effect", "SkillId", "Tier", "Value" },
values: new object[,]
{
{ 1, "MaxHealth", 1, 1, 25m },
{ 2, "MaxHealth", 1, 2, 50m },
{ 3, "MaxHealth", 1, 3, 100m },
{ 4, "MaxIntelligence", 2, 1, 5m },
{ 5, "MaxIntelligence", 2, 2, 10m },
{ 6, "MaxIntelligence", 2, 3, 20m },
{ 7, "MaxStrength", 3, 1, 5m },
{ 8, "MaxStrength", 3, 2, 10m },
{ 9, "MaxStrength", 3, 3, 20m },
{ 10, "MaxCharisma", 4, 1, 5m },
{ 11, "MaxCharisma", 4, 2, 10m },
{ 12, "MaxCharisma", 4, 3, 20m },
{ 13, "Luck", 5, 1, 1m },
{ 14, "Luck", 5, 2, 2m },
{ 15, "Luck", 5, 3, 3m },
{ 16, "Agility", 6, 1, 1m },
{ 17, "Agility", 6, 2, 2m },
{ 18, "Agility", 6, 3, 3m },
{ 19, "Perception", 7, 1, 1m },
{ 20, "Perception", 7, 2, 2m },
{ 21, "Perception", 7, 3, 3m }
});
migrationBuilder.CreateIndex(
name: "IX_EquippedItems_GameItemId",
table: "EquippedItems",
column: "GameItemId");
migrationBuilder.CreateIndex(
name: "IX_EquippedItems_PetId",
table: "EquippedItems",
column: "PetId");
migrationBuilder.CreateIndex(
name: "IX_PetSkills_PetId",
table: "PetSkills",
column: "PetId");
migrationBuilder.CreateIndex(
name: "IX_PetSkills_SkillId",
table: "PetSkills",
column: "SkillId");
migrationBuilder.CreateIndex(
name: "IX_SkillEffects_SkillId",
table: "SkillEffects",
column: "SkillId");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "EquippedItems");
migrationBuilder.DropTable(
name: "Inventories");
migrationBuilder.DropTable(
name: "PetSkills");
migrationBuilder.DropTable(
name: "PetStats");
migrationBuilder.DropTable(
name: "Resources");
migrationBuilder.DropTable(
name: "SkillEffects");
migrationBuilder.DropTable(
name: "GameItems");
migrationBuilder.DropTable(
name: "Pets");
migrationBuilder.DropTable(
name: "Skills");
}
}
}

493
Migrations/ApplicationDbContextModelSnapshot.cs
View File

@ -17,6 +17,83 @@ namespace PetCompanion.Migrations
#pragma warning disable 612, 618
modelBuilder.HasAnnotation("ProductVersion", "9.0.1");
modelBuilder.Entity("PetCompanion.Models.EquippedItem", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<int>("EquipTarget")
.HasColumnType("INTEGER");
b.Property<int>("GameItemId")
.HasColumnType("INTEGER");
b.Property<string>("PetId")
.IsRequired()
.HasColumnType("TEXT");
b.HasKey("Id");
b.HasIndex("GameItemId");
b.HasIndex("PetId");
b.ToTable("EquippedItems");
});
modelBuilder.Entity("PetCompanion.Models.GameItem", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<string>("Description")
.IsRequired()
.HasColumnType("TEXT");
b.Property<string>("Effect")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("EquipTarget")
.HasColumnType("INTEGER");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("Price")
.HasColumnType("INTEGER");
b.Property<int>("Rarity")
.HasColumnType("INTEGER");
b.Property<int>("Type")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.ToTable("GameItems");
});
modelBuilder.Entity("PetCompanion.Models.Inventory", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Capacity")
.HasColumnType("INTEGER");
b.PrimitiveCollection<string>("Items")
.IsRequired()
.HasColumnType("TEXT");
b.HasKey("PetId");
b.ToTable("Inventories");
});
modelBuilder.Entity("PetCompanion.Models.Pet", b =>
{
b.Property<string>("Id")
@ -28,15 +105,24 @@ namespace PetCompanion.Migrations
b.Property<int>("Class")
.HasColumnType("INTEGER");
b.Property<int>("Experience")
.HasColumnType("INTEGER");
b.Property<DateTime>("GatherActionSince")
.HasColumnType("TEXT");
b.Property<int>("Health")
.HasColumnType("INTEGER");
b.Property<bool>("IsDead")
.HasColumnType("INTEGER");
b.Property<int>("Level")
.HasColumnType("INTEGER");
b.Property<int>("MaxHealth")
.HasColumnType("INTEGER");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
@ -47,6 +133,9 @@ namespace PetCompanion.Migrations
b.Property<int>("PetGatherAction")
.HasColumnType("INTEGER");
b.Property<int>("SkillPoints")
.HasColumnType("INTEGER");
b.Property<string>("UserId")
.IsRequired()
.HasColumnType("TEXT");
@ -56,17 +145,48 @@ namespace PetCompanion.Migrations
b.ToTable("Pets");
});
modelBuilder.Entity("PetCompanion.Models.PetSkill", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<int>("CurrentTier")
.HasColumnType("INTEGER");
b.Property<string>("PetId")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("SkillId")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.HasIndex("PetId");
b.HasIndex("SkillId");
b.ToTable("PetSkills");
});
modelBuilder.Entity("PetCompanion.Models.PetStats", b =>
{
b.Property<string>("PetId")
.HasColumnType("TEXT");
b.Property<int>("Agility")
.HasColumnType("INTEGER");
b.Property<int>("Charisma")
.HasColumnType("INTEGER");
b.Property<int>("Intelligence")
.HasColumnType("INTEGER");
b.Property<int>("Luck")
.HasColumnType("INTEGER");
b.Property<int>("MaxCharisma")
.HasColumnType("INTEGER");
@ -76,6 +196,9 @@ namespace PetCompanion.Migrations
b.Property<int>("MaxStrength")
.HasColumnType("INTEGER");
b.Property<int>("Perception")
.HasColumnType("INTEGER");
b.Property<int>("Strength")
.HasColumnType("INTEGER");
@ -106,6 +229,351 @@ namespace PetCompanion.Migrations
b.ToTable("Resources");
});
modelBuilder.Entity("PetCompanion.Models.Skill", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<string>("Description")
.IsRequired()
.HasColumnType("TEXT");
b.Property<string>("Icon")
.IsRequired()
.HasColumnType("TEXT");
b.Property<string>("Name")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("PointsCost")
.HasColumnType("INTEGER");
b.PrimitiveCollection<string>("SkillsIdRequired")
.HasColumnType("TEXT");
b.Property<int>("Type")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.ToTable("Skills");
b.HasData(
new
{
Id = 1,
Description = "Increases maximum health of your pet, making it more resilient.",
Icon = "❤",
Name = "Vitality Mastery",
PointsCost = 1,
Type = 0
},
new
{
Id = 2,
Description = "Increases maximum intelligence of your pet, improving its learning capabilities.",
Icon = "🧠",
Name = "Mind Enhancement",
PointsCost = 1,
Type = 0
},
new
{
Id = 3,
Description = "Increases maximum strength of your pet, making it more powerful.",
Icon = "💪",
Name = "Strength Training",
PointsCost = 1,
Type = 0
},
new
{
Id = 4,
Description = "Increases maximum charisma of your pet, making it more charming.",
Icon = "🎭",
Name = "Charisma Boost",
PointsCost = 1,
Type = 0
},
new
{
Id = 5,
Description = "Increases luck of your pet, making it more fortunate to find rare items.",
Icon = "🍀",
Name = "Luck of the Draw",
PointsCost = 1,
SkillsIdRequired = "[4]",
Type = 0
},
new
{
Id = 6,
Description = "Increases agility of your pet, making it faster in combat.",
Icon = "🏃",
Name = "Agility Training",
PointsCost = 1,
SkillsIdRequired = "[3]",
Type = 0
},
new
{
Id = 7,
Description = "Increases perception of your pet, making it more aware of its surroundings.",
Icon = "👀",
Name = "Perception Boost",
PointsCost = 1,
SkillsIdRequired = "[2]",
Type = 0
});
});
modelBuilder.Entity("PetCompanion.Models.SkillEffect", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<string>("Effect")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("SkillId")
.HasColumnType("INTEGER");
b.Property<int>("Tier")
.HasColumnType("INTEGER");
b.Property<decimal>("Value")
.HasColumnType("TEXT");
b.HasKey("Id");
b.HasIndex("SkillId");
b.ToTable("SkillEffects");
b.HasData(
new
{
Id = 1,
Effect = "MaxHealth",
SkillId = 1,
Tier = 1,
Value = 25m
},
new
{
Id = 2,
Effect = "MaxHealth",
SkillId = 1,
Tier = 2,
Value = 50m
},
new
{
Id = 3,
Effect = "MaxHealth",
SkillId = 1,
Tier = 3,
Value = 100m
},
new
{
Id = 4,
Effect = "MaxIntelligence",
SkillId = 2,
Tier = 1,
Value = 5m
},
new
{
Id = 5,
Effect = "MaxIntelligence",
SkillId = 2,
Tier = 2,
Value = 10m
},
new
{
Id = 6,
Effect = "MaxIntelligence",
SkillId = 2,
Tier = 3,
Value = 20m
},
new
{
Id = 7,
Effect = "MaxStrength",
SkillId = 3,
Tier = 1,
Value = 5m
},
new
{
Id = 8,
Effect = "MaxStrength",
SkillId = 3,
Tier = 2,
Value = 10m
},
new
{
Id = 9,
Effect = "MaxStrength",
SkillId = 3,
Tier = 3,
Value = 20m
},
new
{
Id = 10,
Effect = "MaxCharisma",
SkillId = 4,
Tier = 1,
Value = 5m
},
new
{
Id = 11,
Effect = "MaxCharisma",
SkillId = 4,
Tier = 2,
Value = 10m
},
new
{
Id = 12,
Effect = "MaxCharisma",
SkillId = 4,
Tier = 3,
Value = 20m
},
new
{
Id = 13,
Effect = "Luck",
SkillId = 5,
Tier = 1,
Value = 1m
},
new
{
Id = 14,
Effect = "Luck",
SkillId = 5,
Tier = 2,
Value = 2m
},
new
{
Id = 15,
Effect = "Luck",
SkillId = 5,
Tier = 3,
Value = 3m
},
new
{
Id = 16,
Effect = "Agility",
SkillId = 6,
Tier = 1,
Value = 1m
},
new
{
Id = 17,
Effect = "Agility",
SkillId = 6,
Tier = 2,
Value = 2m
},
new
{
Id = 18,
Effect = "Agility",
SkillId = 6,
Tier = 3,
Value = 3m
},
new
{
Id = 19,
Effect = "Perception",
SkillId = 7,
Tier = 1,
Value = 1m
},
new
{
Id = 20,
Effect = "Perception",
SkillId = 7,
Tier = 2,
Value = 2m
},
new
{
Id = 21,
Effect = "Perception",
SkillId = 7,
Tier = 3,
Value = 3m
});
});
modelBuilder.Entity("PetCompanion.Models.EquippedItem", b =>
{
b.HasOne("PetCompanion.Models.GameItem", "GameItem")
.WithMany()
.HasForeignKey("GameItemId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("PetCompanion.Models.Pet", "Pet")
.WithMany("EquippedItemsList")
.HasForeignKey("PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("GameItem");
b.Navigation("Pet");
});
modelBuilder.Entity("PetCompanion.Models.Inventory", b =>
{
b.HasOne("PetCompanion.Models.Pet", "Pet")
.WithOne("Inventory")
.HasForeignKey("PetCompanion.Models.Inventory", "PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Pet");
});
modelBuilder.Entity("PetCompanion.Models.PetSkill", b =>
{
b.HasOne("PetCompanion.Models.Pet", "Pet")
.WithMany("Skills")
.HasForeignKey("PetId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("PetCompanion.Models.Skill", "Skill")
.WithMany("PetSkills")
.HasForeignKey("SkillId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Pet");
b.Navigation("Skill");
});
modelBuilder.Entity("PetCompanion.Models.PetStats", b =>
{
b.HasOne("PetCompanion.Models.Pet", null)
@ -124,14 +592,39 @@ namespace PetCompanion.Migrations
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.SkillEffect", b =>
{
b.HasOne("PetCompanion.Models.Skill", "Skill")
.WithMany("Effects")
.HasForeignKey("SkillId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Skill");
});
modelBuilder.Entity("PetCompanion.Models.Pet", b =>
{
b.Navigation("EquippedItemsList");
b.Navigation("Inventory")
.IsRequired();
b.Navigation("Resources")
.IsRequired();
b.Navigation("Skills");
b.Navigation("Stats")
.IsRequired();
});
modelBuilder.Entity("PetCompanion.Models.Skill", b =>
{
b.Navigation("Effects");
b.Navigation("PetSkills");
});
#pragma warning restore 612, 618
}
}

25
Models/Enums/ItemEnums.cs
View File

@ -1,25 +0,0 @@
namespace PetCompanion.Models.Enums
{
public enum ItemType
{
Consumable,
Equipment,
Material
}
public enum ItemRarity
{
Common,
Uncommon,
Rare,
Legendary
}
public enum EquipmentSlot
{
Helmet,
Chest,
Leggings,
Weapon
}
}

20
Models/EquippedItem.cs Normal file
View File

@ -0,0 +1,20 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace PetCompanion.Models
{
public class EquippedItem
{
[Key]
public int Id { get; set; }
public string PetId { get; set; }
[ForeignKey("PetId")]
public virtual Pet Pet { get; set; }
public ItemEquipTarget EquipTarget { get; set; }
public int GameItemId { get; set; }
[ForeignKey("GameItemId")]
public virtual GameItem GameItem { get; set; }
}
}

41
Models/GameItem.cs Normal file
View File

@ -0,0 +1,41 @@
using System.ComponentModel.DataAnnotations;
namespace PetCompanion.Models
{
public class GameItem
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public ItemType Type { get; set; }
public ItemRarity Rarity { get; set; }
public string Description { get; set; }
public int Price { get; set; }
public string Effect { get; set; }
public ItemEquipTarget EquipTarget { get; set; }
}
public enum ItemType
{
Material,
Consumable,
Equipment
}
public enum ItemRarity
{
Common,
Uncommon,
Rare,
Legendary
}
public enum ItemEquipTarget
{
None,
Head,
Body,
Legs,
Weapon
}
}

79
Models/GameItems.cs
View File

@ -1,79 +0,0 @@
using PetCompanion.Models.Enums;
namespace PetCompanion.Models
{
public class MaterialItem : Item
{
public MaterialItem()
{
Type = ItemType.Material;
}
public override void Use(ref Pet pet)
{
// Materials cannot be used directly
}
}
public class StatBoostEquipment : EquipableItem
{
public Dictionary<string, int> StatBoosts { get; set; } = new();
public override void Equip(ref Pet pet)
{
base.Equip(ref pet);
if (IsEquipped)
{
foreach (var boost in StatBoosts)
{
switch (boost.Key.ToLower())
{
case "health":
pet.MaxHealth += boost.Value;
break;
case "intelligence":
pet.Stats.MaxIntelligence += boost.Value;
break;
case "strength":
pet.Stats.MaxStrength += boost.Value;
break;
case "charisma":
pet.Stats.MaxCharisma += boost.Value;
break;
}
}
}
}
public override void Unequip(ref Pet pet)
{
if (IsEquipped)
{
foreach (var boost in StatBoosts)
{
switch (boost.Key.ToLower())
{
case "health":
pet.MaxHealth -= boost.Value;
break;
case "intelligence":
pet.Stats.MaxIntelligence -= boost.Value;
break;
case "strength":
pet.Stats.MaxStrength -= boost.Value;
break;
case "charisma":
pet.Stats.MaxCharisma -= boost.Value;
break;
}
}
}
base.Unequip(ref pet);
}
public override void Use(ref Pet pet)
{
Equip(ref pet);
}
}
}

34
Models/Inventory.cs
View File

@ -1,28 +1,16 @@
namespace PetCompanion.Models
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text.Json.Serialization;
namespace PetCompanion.Models
{
public class Inventory
{
public List<Item> Items { get; set; } = new();
public int Capacity { get; set; }
public bool AddItem(Item item)
{
if (Items.Count < Capacity)
{
Items.Add(item);
return true;
}
return false;
}
public bool RemoveItem(Item item)
{
return Items.Remove(item);
}
public void TrashItem(Item item)
{
RemoveItem(item);
}
[Key, ForeignKey("Pet")]
public string PetId { get; set; }
[JsonIgnore]
public virtual Pet Pet { get; set; }
public List<int> Items { get; set; } = new List<int>();
public int Capacity { get; set; } = 20;
}
}

50
Models/Item.cs
View File

@ -1,50 +0,0 @@
using PetCompanion.Models.Enums;
namespace PetCompanion.Models
{
public abstract class Item
{
public string Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public ItemType Type { get; set; }
public ItemRarity Rarity { get; set; }
public abstract void Use(ref Pet pet);
}
public abstract class EquipableItem : Item
{
public EquipmentSlot Slot { get; set; }
public bool IsEquipped { get; set; }
public virtual void Equip(ref Pet pet)
{
if (!IsEquipped)
{
pet.Equipment[Slot]?.Unequip(ref pet);
pet.Equipment[Slot] = this;
IsEquipped = true;
}
}
public virtual void Unequip(ref Pet pet)
{
if (IsEquipped)
{
pet.Equipment[Slot] = null;
IsEquipped = false;
}
}
}
public class ConsumableItem : Item
{
public Action<Pet> Effect { get; set; }
public override void Use(ref Pet pet)
{
Effect?.Invoke(pet);
}
}
}

24
Models/Pet.cs
View File

@ -1,5 +1,5 @@
using System.ComponentModel.DataAnnotations;
using PetCompanion.Models.Enums;
using System.ComponentModel.DataAnnotations.Schema;
namespace PetCompanion.Models
{
@ -11,7 +11,6 @@ namespace PetCompanion.Models
public PetClass Class { get; set; }
public PetStats Stats { get; set; }
public Resources Resources { get; set; }
public Inventory Inventory { get; set; }
public int Level { get; set; }
public int Experience { get; set; }
public int Health { get; set; }
@ -25,16 +24,29 @@ namespace PetCompanion.Models
public PetBasicAction PetBasicAction { get; set; }
public DateTime BasicActionCooldown { get; set; }
public Dictionary<EquipmentSlot, EquipableItem> Equipment { get; set; } = new();
public int SkillPoints { get; set; } = 2;
public Pet()
public virtual ICollection<PetSkill> Skills { get; set; } = new List<PetSkill>();
public virtual Inventory Inventory { get; set; }
public virtual ICollection<EquippedItem> EquippedItemsList { get; set; } = new List<EquippedItem>();
[NotMapped]
public Dictionary<ItemEquipTarget, int> EquippedItems
{
foreach (EquipmentSlot slot in Enum.GetValues(typeof(EquipmentSlot)))
get => EquippedItemsList?.ToDictionary(e => e.EquipTarget, e => e.GameItemId) ?? new Dictionary<ItemEquipTarget, int>();
set
{
Equipment[slot] = null;
EquippedItemsList = value.Select(kvp => new EquippedItem
{
PetId = Id,
EquipTarget = kvp.Key,
GameItemId = kvp.Value
}).ToList();
}
}
public Pet() { }
public void IncrementIntelligence(int amount)
{
var newValue = Stats.Intelligence + amount;

15
Models/PetStats.cs
View File

@ -1,5 +1,6 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text.Json.Serialization;
namespace PetCompanion.Models
{
@ -7,10 +8,20 @@ namespace PetCompanion.Models
{
[Key, ForeignKey("Pet")]
public string PetId { get; set; }
// Display stats
public int Intelligence { get; set; }
public int Strength { get; set; }
public int Charisma { get; set; }
// Hidden stats (not displayed to the API)
[JsonIgnore]
public int Luck { get; set; } // used for rarity of item finds
[JsonIgnore]
public int Agility { get; set; } // used for combat
[JsonIgnore]
public int Perception { get; set; } // used for number of itens found
public int MaxIntelligence { get; set; }
public int MaxStrength { get; set; }
public int MaxCharisma { get; set; }
@ -67,6 +78,10 @@ namespace PetCompanion.Models
stats.MaxStrength = stats.Strength;
stats.MaxCharisma = stats.Charisma;
stats.Luck = 1;
stats.Agility = 1;
stats.Perception = 1;
return stats;
}
}

86
Models/Skill.cs Normal file
View File

@ -0,0 +1,86 @@
using System.ComponentModel.DataAnnotations;
using System.Text.Json.Serialization;
namespace PetCompanion.Models
{
public enum SkillType
{
GROUND,
GRAND
}
public enum SkillTier
{
I = 1,
II = 2,
III = 3
}
public class Skill
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public SkillType Type { get; set; }
public int PointsCost { get; set; }
public string Icon { get; set; }
public List<int>? SkillsIdRequired { get; set; }
public virtual ICollection<SkillEffect> Effects { get; set; }
[JsonIgnore]
public virtual ICollection<PetSkill> PetSkills { get; set; }
}
public class SkillEffect
{
[Key]
public int Id { get; set; }
public int SkillId { get; set; }
[JsonIgnore]
public virtual Skill Skill { get; set; }
public SkillTier Tier { get; set; }
public string Effect { get; set; }
public decimal Value { get; set; }
public void PetSkillUpgrade(ref Pet pet)
{
switch (Effect)
{
case "MaxHealth":
pet.MaxHealth += (int)Value;
break;
case "MaxIntelligence":
pet.Stats.MaxIntelligence += (int)Value;
break;
case "MaxStrength":
pet.Stats.MaxStrength += (int)Value;
break;
case "MaxCharisma":
pet.Stats.MaxCharisma += (int)Value;
break;
case "Luck":
pet.Stats.Luck += (int)Value;
break;
case "Agility":
pet.Stats.Agility += (int)Value;
break;
case "Perception":
pet.Stats.Perception += (int)Value;
break;
// Add more effects as needed
}
}
}
public class PetSkill
{
[Key]
public int Id { get; set; }
public string PetId { get; set; }
[JsonIgnore]
public virtual Pet Pet { get; set; }
public int SkillId { get; set; }
public virtual Skill Skill { get; set; }
public SkillTier CurrentTier { get; set; }
}
}

19
Program.cs
View File

@ -24,12 +24,22 @@ namespace PetCompanion
// Configure Entity Framework Core
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlite(connectionString));
{
options.UseSqlite(connectionString);
options.EnableSensitiveDataLogging();
});
builder.Services.AddScoped<PetClassRepository>();
builder.Services.AddScoped<PetClassService>();
builder.Services.AddScoped<SkillService>();
builder.Services.AddScoped<GameItemsRepository>();
builder.Services.AddScoped<GameItemService>();
builder.Services.AddScoped<PetRepository>();
builder.Services.AddScoped<PetService>();
builder.Services.AddScoped<PetSkillRepository>();
builder.Services.AddScoped<PetInventoryRepository>();
builder.Services.AddScoped<PetSkillService>();
builder.Services.AddScoped<PetInventoryService>();
// Add CORS policy
builder.Services.AddCors(options =>
@ -54,6 +64,13 @@ namespace PetCompanion
app.UseHttpsRedirection();
app.UseAuthorization();
// After app builder is created
using (var scope = app.Services.CreateScope())
{
var itemService = scope.ServiceProvider.GetRequiredService<GameItemService>();
itemService.LoadItemsFromCsv("GameItemsData.csv");
}
// Use CORS policy
app.UseCors("AllowAll");

32
Repositories/GameItemsRepository.cs Normal file
View File

@ -0,0 +1,32 @@
using PetCompanion.Data;
using PetCompanion.Models;
namespace PetCompanion.Repositories
{
public class GameItemsRepository
{
private readonly ApplicationDbContext _context;
public GameItemsRepository(ApplicationDbContext context)
{
_context = context;
}
public GameItem GetById(int id)
{
return _context.GameItems.Find(id);
}
public void Add(GameItem item)
{
_context.GameItems.Add(item);
_context.SaveChanges();
}
public void Update(GameItem item)
{
_context.GameItems.Update(item);
_context.SaveChanges();
}
}
}

176
Repositories/ItemRepository.cs
View File

@ -1,176 +0,0 @@
using System.Text.RegularExpressions;
using PetCompanion.Models;
using PetCompanion.Models.Enums;
namespace PetCompanion.Repositories
{
public class ItemRepository
{
private readonly Dictionary<string, Item> _itemTemplates = new();
private readonly Dictionary<ItemRarity, List<string>> _itemsByRarity = new();
private readonly Random _random = new();
public ItemRepository()
{
foreach (ItemRarity rarity in Enum.GetValues(typeof(ItemRarity)))
{
_itemsByRarity[rarity] = new List<string>();
}
LoadItemsFromCsv();
}
private void LoadItemsFromCsv()
{
var lines = File.ReadAllLines("Items.csv").Skip(1); // Skip header
foreach (var line in lines)
{
var parts = line.Split(',');
var name = parts[0];
var type = Enum.Parse<ItemType>(parts[1]);
var rarity = Enum.Parse<ItemRarity>(parts[2]);
var description = parts[3];
Item item = type switch
{
ItemType.Consumable => CreateConsumableItem(name, description, rarity),
ItemType.Equipment => CreateEquipmentItem(name, description, rarity),
ItemType.Material => CreateMaterialItem(name, description, rarity),
_ => throw new ArgumentException($"Unknown item type: {type}")
};
_itemTemplates.Add(name, item);
_itemsByRarity[rarity].Add(name);
}
}
private Item CreateConsumableItem(string name, string description, ItemRarity rarity)
{
var item = new ConsumableItem
{
Id = Guid.NewGuid().ToString(),
Name = name,
Description = description,
Type = ItemType.Consumable,
Rarity = rarity
};
// Parse effects from description
if (description.Contains("food resources"))
{
var foodAmount = int.Parse(Regex.Match(description, @"\+(\d+) food").Groups[1].Value);
item.Effect = (pet) => pet.Resources.Food += foodAmount;
}
else if (description.Contains("Intelligence"))
{
var amount = int.Parse(Regex.Match(description, @"\+(\d+)").Groups[1].Value);
item.Effect = (pet) => pet.IncrementIntelligence(amount);
}
// Add more effect parsing as needed
return item;
}
private Item CreateEquipmentItem(string name, string description, ItemRarity rarity)
{
var equipment = new StatBoostEquipment
{
Id = Guid.NewGuid().ToString(),
Name = name,
Description = description,
Type = ItemType.Equipment,
Rarity = rarity
};
// Parse slot and stats from description
var slotMatch = Regex.Match(description, @"(Helmet|Chest|Legging|Weapon):");
if (slotMatch.Success)
{
equipment.Slot = Enum.Parse<EquipmentSlot>(slotMatch.Groups[1].Value);
}
var statMatch = Regex.Match(description, @"\+(\d+) Max (\w+)");
if (statMatch.Success)
{
var amount = int.Parse(statMatch.Groups[1].Value);
var stat = statMatch.Groups[2].Value;
equipment.StatBoosts.Add(stat, amount);
}
return equipment;
}
private Item CreateMaterialItem(string name, string description, ItemRarity rarity)
{
return new MaterialItem
{
Id = Guid.NewGuid().ToString(),
Name = name,
Description = description,
Type = ItemType.Material,
Rarity = rarity
};
}
public Item CreateItem(string itemName)
{
if (_itemTemplates.TryGetValue(itemName, out var template))
{
// Create a new instance with a new ID but same properties
var json = System.Text.Json.JsonSerializer.Serialize(template);
var newItem = System.Text.Json.JsonSerializer.Deserialize<Item>(json);
newItem.Id = Guid.NewGuid().ToString();
return newItem;
}
throw new KeyNotFoundException($"Item template not found: {itemName}");
}
/// Usage:
/* var rarityProbabilities = new Dictionary<ItemRarity, int>
{
{ ItemRarity.Common, 50 }, // 50% chance
{ ItemRarity.Uncommon, 30 }, // 30% chance
{ ItemRarity.Rare, 15 }, // 15% chance
{ ItemRarity.Legendary, 5 } // 5% chance
};
var itemRepo = new ItemRepository();
var randomItem = itemRepo.GenerateRandomItem(rarityProbabilities);
*/
public Item GenerateRandomItem(Dictionary<ItemRarity, int> rarityProbabilities)
{
// Validate probabilities
if (rarityProbabilities.Values.Sum() != 100)
{
throw new ArgumentException("Rarity probabilities must sum to 100");
}
// Generate random number between 0 and 100
var roll = _random.Next(1, 101);
var currentThreshold = 0;
// Determine which rarity we hit
ItemRarity selectedRarity = ItemRarity.Common;
foreach (var probability in rarityProbabilities)
{
currentThreshold += probability.Value;
if (roll <= currentThreshold)
{
selectedRarity = probability.Key;
break;
}
}
// Get random item from selected rarity
var possibleItems = _itemsByRarity[selectedRarity];
if (possibleItems.Count == 0)
{
// Fallback to common if no items of selected rarity
possibleItems = _itemsByRarity[ItemRarity.Common];
}
var randomItemName = possibleItems[_random.Next(possibleItems.Count)];
return CreateItem(randomItemName);
}
}
}

71
Repositories/PetInventoryRepository.cs Normal file
View File

@ -0,0 +1,71 @@
using Microsoft.EntityFrameworkCore;
using PetCompanion.Data;
using PetCompanion.Models;
namespace PetCompanion.Repositories
{
public class PetInventoryRepository
{
private readonly ApplicationDbContext _context;
public PetInventoryRepository(ApplicationDbContext context)
{
_context = context;
}
public Inventory GetPetInventory(string petId)
{
return _context.Inventories
.FirstOrDefault(i => i.PetId == petId);
}
public Dictionary<ItemEquipTarget, int> GetEquippedItems(string petId)
{
var equippedItems = _context.EquippedItems
.Where(e => e.PetId == petId)
.ToDictionary(e => e.EquipTarget, e => e.GameItemId);
return equippedItems;
}
public void UpdateEquippedItems(string petId, Dictionary<ItemEquipTarget, int> equippedItems)
{
var existingItems = _context.EquippedItems
.Where(e => e.PetId == petId)
.ToList();
_context.EquippedItems.RemoveRange(existingItems);
var newEquippedItems = equippedItems.Select(kvp => new EquippedItem
{
PetId = petId,
EquipTarget = kvp.Key,
GameItemId = kvp.Value
});
_context.EquippedItems.AddRangeAsync(newEquippedItems);
_context.SaveChangesAsync();
}
public Inventory SavePetInventory(Inventory inventory)
{
if (_context.Inventories.Any(i => i.PetId == inventory.PetId))
{
_context.Inventories.Update(inventory);
}
else
{
_context.Inventories.Add(inventory);
}
_context.SaveChanges();
return inventory;
}
public Inventory UpdatePetInventory(Inventory inventory)
{
_context.Inventories.Update(inventory);
_context.SaveChanges();
return inventory;
}
}
}

10
Repositories/PetRepository.cs
View File

@ -19,6 +19,8 @@ namespace PetCompanion.Repositories
.Where(p => p.UserId == userId)
.Include(p => p.Stats)
.Include(p => p.Resources)
.Include(p => p.Inventory)
.Include(p => p.EquippedItemsList)
.ToList();
}
@ -28,6 +30,8 @@ namespace PetCompanion.Repositories
.Where(p => p.Id == petId && p.UserId == userId)
.Include(p => p.Stats)
.Include(p => p.Resources)
.Include(p => p.Inventory)
.Include(p => p.EquippedItemsList)
.FirstOrDefault();
}
@ -41,6 +45,12 @@ namespace PetCompanion.Repositories
public Pet UpdatePet(Pet pet)
{
context.Pets.Update(pet);
if (pet.Inventory != null)
{
context.Inventories.Update(pet.Inventory);
}
context.SaveChanges();
return pet;
}

39
Repositories/PetSkillRepository.cs Normal file
View File

@ -0,0 +1,39 @@
using Microsoft.EntityFrameworkCore;
using PetCompanion.Data;
using PetCompanion.Models;
namespace PetCompanion.Repositories
{
public class PetSkillRepository
{
private readonly ApplicationDbContext _context;
public PetSkillRepository(ApplicationDbContext context)
{
_context = context;
}
public IEnumerable<PetSkill> GetPetSkills(string petId)
{
return _context.PetSkills
.Include(ps => ps.Skill)
.ThenInclude(s => s.Effects)
.Where(ps => ps.PetId == petId)
.ToList();
}
public PetSkill SavePetSkill(PetSkill petSkill)
{
if (petSkill.Id == 0)
{
_context.PetSkills.Add(petSkill);
}
else
{
_context.PetSkills.Update(petSkill);
}
_context.SaveChanges();
return petSkill;
}
}
}

121
Services/GameItemService.cs Normal file
View File

@ -0,0 +1,121 @@
using CsvHelper;
using System.Globalization;
using PetCompanion.Models;
using PetCompanion.Repositories;
namespace PetCompanion.Services
{
public class GameItemService
{
private readonly GameItemsRepository gameItemsRepository;
public GameItemService(GameItemsRepository gameItemsRepository)
{
this.gameItemsRepository = gameItemsRepository;
}
public void LoadItemsFromCsv(string filePath)
{
using var reader = new StreamReader(filePath);
using var csv = new CsvReader(reader, CultureInfo.InvariantCulture);
var items = csv.GetRecords<GameItem>().ToList();
foreach (var item in items)
{
var existingItem = gameItemsRepository.GetById(item.Id);
if (existingItem == null)
{
gameItemsRepository.Add(item);
}
else
{
//gameItemsRepository.Update(item);
}
}
}
public void ApplyItemEffect(Pet pet, GameItem item)
{
var effects = item.Effect.Split(';');
foreach (var effect in effects)
{
ApplySingleEffect(pet, effect.Trim());
}
}
public void RemoveItemEffect(Pet pet, GameItem item)
{
var effects = item.Effect.Split(';');
foreach (var effect in effects)
{
RemoveSingleEffect(pet, effect.Trim());
}
}
private void ApplySingleEffect(Pet pet, string effect)
{
if (effect == "Nothing") return;
var parts = effect.Split('_');
var action = parts[0];
var target = parts[1];
var value = parts.Length > 2 ? int.Parse(parts[2]) : 0;
switch ($"{action}_{target}")
{
case "ADD_FOOD_RESOURCES":
pet.Resources.Food += value;
break;
case "ADD_INTELLIGENCE":
pet.Stats.Intelligence += value;
break;
case "ADD_HEALTH":
pet.Health = Math.Min(pet.Health + value, pet.MaxHealth);
break;
case "ADD_MAX_HEALTH":
pet.MaxHealth += value;
break;
// Add more effect handlers as needed
}
}
private void RemoveSingleEffect(Pet pet, string effect)
{
if (effect == "Nothing") return;
var parts = effect.Split('_');
var action = parts[0];
var target = parts[1];
var value = parts.Length > 2 ? int.Parse(parts[2]) : 0;
switch ($"{action}_{target}")
{
case "ADD_MAX_HEALTH":
pet.MaxHealth -= value;
pet.Health = Math.Min(pet.Health, pet.MaxHealth);
break;
case "ADD_MAX_INTELLIGENCE":
pet.Stats.MaxIntelligence -= value;
pet.Stats.Intelligence = Math.Min(pet.Stats.Intelligence, pet.Stats.MaxIntelligence);
break;
case "ADD_MAX_STRENGTH":
pet.Stats.MaxStrength -= value;
pet.Stats.Strength = Math.Min(pet.Stats.Strength, pet.Stats.MaxStrength);
break;
case "ADD_MAX_CHARISMA":
pet.Stats.MaxCharisma -= value;
pet.Stats.Charisma = Math.Min(pet.Stats.Charisma, pet.Stats.MaxCharisma);
break;
case "ADD_MAX_ALL_STATS":
pet.Stats.MaxIntelligence -= value;
pet.Stats.MaxStrength -= value;
pet.Stats.MaxCharisma -= value;
pet.Stats.Intelligence = Math.Min(pet.Stats.Intelligence, pet.Stats.MaxIntelligence);
pet.Stats.Strength = Math.Min(pet.Stats.Strength, pet.Stats.MaxStrength);
pet.Stats.Charisma = Math.Min(pet.Stats.Charisma, pet.Stats.MaxCharisma);
break;
}
}
}
}

155
Services/PetInventoryService.cs Normal file
View File

@ -0,0 +1,155 @@
using PetCompanion.Models;
using PetCompanion.Repositories;
namespace PetCompanion.Services
{
public class PetInventoryService
{
private readonly PetInventoryRepository petInventoryRepository;
private readonly PetRepository petRepository;
private readonly GameItemsRepository gameItemsRepository;
private readonly GameItemService gameItemService;
public PetInventoryService(
PetInventoryRepository petInventoryRepository,
PetRepository petRepository,
GameItemsRepository gameItemsRepository,
GameItemService gameItemService)
{
this.petInventoryRepository = petInventoryRepository;
this.petRepository = petRepository;
this.gameItemsRepository = gameItemsRepository;
this.gameItemService = gameItemService;
}
public Inventory GetInventory(string petId, string userId)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
return petInventoryRepository.GetPetInventory(petId);
}
public Inventory CreateInventory(string petId)
{
var inventory = new Inventory
{
PetId = petId,
Capacity = 20,
Items = new List<int>()
};
petInventoryRepository.SavePetInventory(inventory);
return inventory;
}
public Pet UseItem(string petId, string userId, int itemId)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
if (!pet.Inventory.Items.Any(i => i == itemId))
throw new Exception("Item not found in inventory");
var gameItem = gameItemsRepository.GetById(itemId);
gameItemService.ApplyItemEffect(pet, gameItem);
pet.Inventory.Items.Remove(itemId);
return petRepository.UpdatePet(pet);
}
public Pet EquipItem(string petId, string userId, int itemId)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
if (!pet.Inventory.Items.Any(i => i == itemId))
throw new Exception("Item not found in inventory");
var gameItem = gameItemsRepository.GetById(itemId);
if (gameItem.Type != ItemType.Equipment)
throw new Exception("Item is not equipment");
// If there's already an item equipped in that slot, unequip it first
if (pet.EquippedItems.ContainsKey(gameItem.EquipTarget))
{
UnequipItem(petId, userId, gameItem.EquipTarget);
}
// Apply equipment effects
gameItemService.ApplyItemEffect(pet, gameItem);
// Mark item as equipped
pet.EquippedItems[gameItem.EquipTarget] = itemId;
// Remove from inventory
pet.Inventory.Items.Remove(itemId);
petInventoryRepository.UpdateEquippedItems(petId, pet.EquippedItems);
return petRepository.UpdatePet(pet);
}
public Pet UnequipItem(string petId, string userId, ItemEquipTarget equipTarget)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
if (!pet.EquippedItems.ContainsKey(equipTarget))
throw new Exception("No item equipped in that slot");
var equippedItemId = pet.EquippedItems[equipTarget];
var equippedItem = gameItemsRepository.GetById(equippedItemId);
if (equippedItem != null)
{
// Remove equipment effects
gameItemService.RemoveItemEffect(pet, equippedItem);
// Add item back to inventory
pet.Inventory.Items.Add(equippedItemId);
}
pet.EquippedItems.Remove(equipTarget);
return petRepository.UpdatePet(pet);
}
public Pet DropItem(string petId, string userId, int itemId)
{
var pet = petRepository.GetPetById(petId, userId);
if (!pet.Inventory.Items.Any(i => i == itemId))
throw new Exception("Item not found in inventory");
var gameItem = gameItemsRepository.GetById(itemId);
pet.Inventory.Items.Remove(itemId);
return petRepository.UpdatePet(pet);
}
public Pet AddItemToPet(string petId, string userId, int itemId, int quantity)
{
var pet = petRepository.GetPetById(petId, userId);
var gameItem = gameItemsRepository.GetById(itemId);
if (gameItem == null)
throw new Exception("Item not found");
for (int i = 0; i < quantity; i++)
{
pet.Inventory.Items.Add(itemId);
}
return petRepository.UpdatePet(pet);
}
}
}

35
Services/PetService.cs
View File

@ -6,12 +6,23 @@ namespace PetCompanion.Services
public class PetService
{
private readonly PetRepository petRepository;
private readonly PetClassService _petClassService;
private readonly PetClassService petClassService;
private readonly GameItemService gameItemService;
private readonly GameItemsRepository gameItemsRepository;
private readonly PetInventoryService petInventoryService;
public PetService(PetRepository petRepository, PetClassService petClassService)
public PetService(
PetRepository petRepository,
PetClassService petClassService,
GameItemService gameItemService,
GameItemsRepository gameItemsRepository,
PetInventoryService petInventoryService)
{
this.petRepository = petRepository;
_petClassService = petClassService;
this.petClassService = petClassService;
this.gameItemService = gameItemService;
this.gameItemsRepository = gameItemsRepository;
this.petInventoryService = petInventoryService;
}
public IEnumerable<Pet> GetAllPets(Guid userId)
@ -39,7 +50,11 @@ namespace PetCompanion.Services
IsDead = false
};
return petRepository.CreatePet(pet);
var createdPet = petRepository.CreatePet(pet);
var inventory = petInventoryService.CreateInventory(petId);
return createdPet;
}
public Pet UpdatePetAction(string petId, string userId, PetUpdateActionRequest actionRequest)
@ -118,7 +133,7 @@ namespace PetCompanion.Services
throw new Exception("Pet not found");
}
return _petClassService.CalculateGatheredResources(pet.Stats, pet.Level, pet.PetGatherAction, pet.GatherActionSince);
return petClassService.CalculateGatheredResources(pet.Stats, pet.Level, pet.PetGatherAction, pet.GatherActionSince);
}
public Pet UpdatePetResources(string petId, string userId)
@ -129,7 +144,7 @@ namespace PetCompanion.Services
throw new Exception("Pet not found");
}
var gatheredResources = _petClassService.CalculateGatheredResources(pet.Stats, pet.Level, pet.PetGatherAction, pet.GatherActionSince);
var gatheredResources = petClassService.CalculateGatheredResources(pet.Stats, pet.Level, pet.PetGatherAction, pet.GatherActionSince);
pet.Resources.Wisdom += gatheredResources.Wisdom;
pet.Resources.Gold += gatheredResources.Gold;
@ -139,5 +154,13 @@ namespace PetCompanion.Services
return petRepository.UpdatePetResources(pet);
}
public Pet GetPet(string petId, string userId)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
return pet;
}
}
}

63
Services/PetSkillService.cs Normal file
View File

@ -0,0 +1,63 @@
using PetCompanion.Models;
using PetCompanion.Repositories;
namespace PetCompanion.Services
{
public class PetSkillService
{
private readonly PetSkillRepository _petSkillRepository;
private readonly PetRepository _petRepository;
public PetSkillService(PetSkillRepository petSkillRepository, PetRepository petRepository)
{
_petSkillRepository = petSkillRepository;
_petRepository = petRepository;
}
public IEnumerable<PetSkill> GetPetSkills(string petId, string userId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
return _petSkillRepository.GetPetSkills(petId);
}
public PetSkill AllocateSkillPoint(string petId, string userId, int skillId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
if (pet.SkillPoints <= 0)
throw new Exception("No skill points available");
var skills = _petSkillRepository.GetPetSkills(petId);
var existingSkill = skills.FirstOrDefault(s => s.SkillId == skillId);
if (existingSkill != null)
{
if (existingSkill.CurrentTier == SkillTier.III)
throw new Exception("Skill already at maximum tier");
existingSkill.CurrentTier++;
_petSkillRepository.SavePetSkill(existingSkill);
}
else
{
existingSkill = new PetSkill
{
PetId = petId,
SkillId = skillId,
CurrentTier = SkillTier.I
};
_petSkillRepository.SavePetSkill(existingSkill);
}
pet.SkillPoints--;
_petRepository.UpdatePet(pet);
return existingSkill;
}
}
}

84
Services/SkillService.cs Normal file
View File

@ -0,0 +1,84 @@
using PetCompanion.Models;
using PetCompanion.Data;
using Microsoft.EntityFrameworkCore;
using PetCompanion.Repositories;
namespace PetCompanion.Services
{
public class SkillService
{
private readonly ApplicationDbContext _context;
private readonly PetRepository _petRepository;
private readonly PetSkillRepository _petSkillRepository;
public SkillService(
ApplicationDbContext context,
PetRepository petRepository,
PetSkillRepository petSkillRepository)
{
_context = context;
_petRepository = petRepository;
_petSkillRepository = petSkillRepository;
}
public PetSkill AllocateSkillPoint(string petId, string userId, int skillId)
{
var pet = _context.Pets
.Include(p => p.Skills)
.FirstOrDefault(p => p.Id == petId && p.UserId == userId);
if (pet == null)
throw new Exception("Pet not found");
if (pet.SkillPoints <= 0)
throw new Exception("No skill points available");
var skill = _context.Skills
.Include(s => s.Effects)
.FirstOrDefault(s => s.Id == skillId);
if (skill == null)
throw new Exception("Skill not found");
var existingSkill = pet.Skills.FirstOrDefault(ps => ps.SkillId == skillId);
if (existingSkill != null)
{
if (existingSkill.CurrentTier == SkillTier.III)
throw new Exception("Skill already at maximum tier");
existingSkill.CurrentTier++;
var effect = skill.Effects.FirstOrDefault(e => e.Tier == existingSkill.CurrentTier);
if (effect != null)
effect.PetSkillUpgrade(ref pet);
_petSkillRepository.SavePetSkill(existingSkill);
}
else
{
var newSkill = new PetSkill
{
PetId = petId,
SkillId = skillId,
CurrentTier = SkillTier.I
};
_petSkillRepository.SavePetSkill(newSkill);
var effect = skill.Effects.FirstOrDefault(e => e.Tier == SkillTier.I);
if (effect != null)
effect.PetSkillUpgrade(ref pet);
}
pet.SkillPoints--;
_context.SaveChanges();
return _petSkillRepository.GetPetSkills(petId).First(ps => ps.SkillId == skillId);
}
public IEnumerable<Skill> GetAvailableSkills()
{
return _context.Skills
.Include(s => s.Effects)
.ToList();
}
}
}

1
pet-companion-api.csproj
View File

@ -11,6 +11,7 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="CsvHelper" Version="33.0.1" />
<PackageReference Include="Microsoft.Data.Sqlite" Version="9.0.1" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.1">
<PrivateAssets>all</PrivateAssets>