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

not working inventory :c

Browse Source
This commit is contained in:
Jose Henrique 2025-02-04 17:47:18 -03:00
parent f234b5d84d
commit 7a2c3d2f67
22 changed files with 2713 additions and 49 deletions
Show Stats Download Patch File Download Diff File 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)
{
_logger = logger;
_inventoryService = inventoryService;
}
[HttpGet("{petId}")]
public async Task<IActionResult> GetInventory(string petId)
{
try
{
var inventory = await _inventoryService.GetInventory(petId, userId.ToString());
return Ok(inventory);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPut("{petId}/{itemId}/use")]
public async Task<IActionResult> UseItem(string petId, int itemId)
{
try
{
var updatedPet = await _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;
}
}

21
Controllers/SkillController.cs
View File

@ -8,15 +8,18 @@ namespace PetCompanion.Controllers
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)
SkillService skillService,
PetSkillService petSkillService)
{
_logger = logger;
_skillService = skillService;
_petSkillService = petSkillService;
}
[HttpGet]
@ -26,12 +29,26 @@ namespace PetCompanion.Controllers
return Ok(skills);
}
[HttpGet("{petId}/skills")]
public async Task<IActionResult> GetPetSkills(string petId)
{
try
{
var skills = await _petSkillService.GetPetSkills(petId, userId.ToString());
return Ok(skills);
}
catch (Exception ex)
{
return BadRequest(ex.Message);
}
}
[HttpPost("{petId}/allocate/{skillId}")]
public async Task<IActionResult> AllocateSkillPoint(string petId, int skillId)
{
try
{
var result = await _skillService.AllocateSkillPoint(petId, userId.ToString(), skillId);
var result = await _petSkillService.AllocateSkillPoint(petId, userId.ToString(), skillId);
return Ok(result);
}
catch (Exception ex)

39
Data/ApplicationDbContext.cs
View File

@ -15,6 +15,10 @@ namespace PetCompanion.Data
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<InventoryItem> InventoryItems { get; set; }
public DbSet<EquippedItem> EquippedItems { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
@ -48,11 +52,44 @@ namespace PetCompanion.Data
.WithMany(s => s.Effects)
.HasForeignKey(se => se.SkillId);
modelBuilder.Entity<InventoryItem>()
.HasOne<Inventory>()
.WithMany(i => i.Items)
.HasForeignKey(ii => ii.InventoryId);
modelBuilder.Entity<InventoryItem>()
.HasOne(ii => ii.GameItem);
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();
foreach (var skill in skills)
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);

42
Items.csv → GameItemsData.csv
View File

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

677
Migrations/20250202234056_InitialCreate.Designer.cs generated Normal file
View File

@ -0,0 +1,677 @@
// <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("20250202234056_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.HasKey("PetId");
b.ToTable("Inventories");
});
modelBuilder.Entity("PetCompanion.Models.InventoryItem", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<int>("GameItemId")
.HasColumnType("INTEGER");
b.Property<string>("InventoryId")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("Quantity")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.HasIndex("GameItemId");
b.HasIndex("InventoryId");
b.ToTable("InventoryItems");
});
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.InventoryItem", b =>
{
b.HasOne("PetCompanion.Models.GameItem", "GameItem")
.WithMany()
.HasForeignKey("GameItemId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("PetCompanion.Models.Inventory", null)
.WithMany("Items")
.HasForeignKey("InventoryId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("GameItem");
});
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.Inventory", b =>
{
b.Navigation("Items");
});
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
}
}
}

357
Migrations/20250202234056_InitialCreate.cs Normal file
View File

@ -0,0 +1,357 @@
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),
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.CreateTable(
name: "InventoryItems",
columns: table => new
{
Id = table.Column<int>(type: "INTEGER", nullable: false)
.Annotation("Sqlite:Autoincrement", true),
InventoryId = table.Column<string>(type: "TEXT", nullable: false),
GameItemId = table.Column<int>(type: "INTEGER", nullable: false),
Quantity = table.Column<int>(type: "INTEGER", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_InventoryItems", x => x.Id);
table.ForeignKey(
name: "FK_InventoryItems_GameItems_GameItemId",
column: x => x.GameItemId,
principalTable: "GameItems",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_InventoryItems_Inventories_InventoryId",
column: x => x.InventoryId,
principalTable: "Inventories",
principalColumn: "PetId",
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_InventoryItems_GameItemId",
table: "InventoryItems",
column: "GameItemId");
migrationBuilder.CreateIndex(
name: "IX_InventoryItems_InventoryId",
table: "InventoryItems",
column: "InventoryId");
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: "InventoryItems");
migrationBuilder.DropTable(
name: "PetSkills");
migrationBuilder.DropTable(
name: "PetStats");
migrationBuilder.DropTable(
name: "Resources");
migrationBuilder.DropTable(
name: "SkillEffects");
migrationBuilder.DropTable(
name: "GameItems");
migrationBuilder.DropTable(
name: "Inventories");
migrationBuilder.DropTable(
name: "Skills");
migrationBuilder.DropTable(
name: "Pets");
}
}
}

674
Migrations/ApplicationDbContextModelSnapshot.cs Normal file
View File

@ -0,0 +1,674 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using PetCompanion.Data;
#nullable disable
namespace PetCompanion.Migrations
{
[DbContext(typeof(ApplicationDbContext))]
partial class ApplicationDbContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(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.HasKey("PetId");
b.ToTable("Inventories");
});
modelBuilder.Entity("PetCompanion.Models.InventoryItem", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("INTEGER");
b.Property<int>("GameItemId")
.HasColumnType("INTEGER");
b.Property<string>("InventoryId")
.IsRequired()
.HasColumnType("TEXT");
b.Property<int>("Quantity")
.HasColumnType("INTEGER");
b.HasKey("Id");
b.HasIndex("GameItemId");
b.HasIndex("InventoryId");
b.ToTable("InventoryItems");
});
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.InventoryItem", b =>
{
b.HasOne("PetCompanion.Models.GameItem", "GameItem")
.WithMany()
.HasForeignKey("GameItemId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("PetCompanion.Models.Inventory", null)
.WithMany("Items")
.HasForeignKey("InventoryId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("GameItem");
});
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.Inventory", b =>
{
b.Navigation("Items");
});
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
}
}
}

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
}
}

26
Models/Inventory.cs Normal file
View File

@ -0,0 +1,26 @@
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text.Json.Serialization;
namespace PetCompanion.Models
{
public class Inventory
{
[Key, ForeignKey("Pet")]
public string PetId { get; set; }
[JsonIgnore]
public virtual Pet Pet { get; set; }
public virtual ICollection<InventoryItem> Items { get; set; } = new List<InventoryItem>();
public int Capacity { get; set; } = 20;
}
public class InventoryItem
{
[Key]
public int Id { get; set; }
public string InventoryId { get; set; }
public int GameItemId { get; set; }
public virtual GameItem GameItem { get; set; }
public int Quantity { get; set; }
}
}

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,19 +24,30 @@ 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 virtual ICollection<PetSkill> Skills { get; set; } = new List<PetSkill>();
public Pet()
public virtual Inventory Inventory { get; set; }
[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 virtual ICollection<EquippedItem> EquippedItemsList { get; set; } = new List<EquippedItem>();
public Pet() { }
public void IncrementIntelligence(int amount)
{
var newValue = Stats.Intelligence + amount;

4
Models/Skill.cs
View File

@ -1,4 +1,5 @@
using System.ComponentModel.DataAnnotations;
using System.Text.Json.Serialization;
namespace PetCompanion.Models
{
@ -26,6 +27,7 @@ namespace PetCompanion.Models
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; }
}
@ -34,6 +36,7 @@ namespace PetCompanion.Models
[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; }
@ -74,6 +77,7 @@ namespace PetCompanion.Models
[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; }

18
Program.cs
View File

@ -24,13 +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 =>
@ -55,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();
}
}
}

67
Repositories/PetInventoryRepository.cs Normal file
View File

@ -0,0 +1,67 @@
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 async Task<Inventory> GetPetInventory(string petId)
{
return await _context.Inventories
.Include(i => i.Items)
.ThenInclude(ii => ii.GameItem)
.FirstOrDefaultAsync(i => i.PetId == petId);
}
public async Task<Dictionary<ItemEquipTarget, int>> GetEquippedItems(string petId)
{
var equippedItems = await _context.EquippedItems
.Where(e => e.PetId == petId)
.ToDictionaryAsync(e => e.EquipTarget, e => e.GameItemId);
return equippedItems;
}
public async Task SaveInventory(Inventory inventory)
{
var existingInventory = await _context.Inventories
.Include(i => i.Items)
.FirstOrDefaultAsync(i => i.PetId == inventory.PetId);
if (existingInventory == null)
{
_context.Inventories.Add(inventory);
}
else
{
// Clear existing items
_context.InventoryItems.RemoveRange(existingInventory.Items);
// Update inventory properties
// existingInventory.Capacity = inventory.Capacity;
// Add new items
foreach (var item in inventory.Items)
{
existingInventory.Items.Add(new InventoryItem
{
InventoryId = existingInventory.PetId,
GameItemId = item.GameItemId,
Quantity = item.Quantity,
GameItem = item.GameItem
});
}
}
await _context.SaveChangesAsync();
}
}
}

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 async Task<IEnumerable<PetSkill>> GetPetSkills(string petId)
{
return await _context.PetSkills
.Include(ps => ps.Skill)
.ThenInclude(s => s.Effects)
.Where(ps => ps.PetId == petId)
.ToListAsync();
}
public async Task<PetSkill> SavePetSkill(PetSkill petSkill)
{
if (petSkill.Id == 0)
{
_context.PetSkills.Add(petSkill);
}
else
{
_context.PetSkills.Update(petSkill);
}
await _context.SaveChangesAsync();
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;
}
}
}
}

184
Services/PetInventoryService.cs Normal file
View File

@ -0,0 +1,184 @@
using PetCompanion.Models;
using PetCompanion.Repositories;
namespace PetCompanion.Services
{
public class PetInventoryService
{
private readonly PetInventoryRepository _inventoryRepository;
private readonly PetRepository _petRepository;
private readonly GameItemsRepository _gameItemsRepository;
public PetInventoryService(
PetInventoryRepository inventoryRepository,
PetRepository petRepository,
GameItemsRepository gameItemsRepository)
{
_inventoryRepository = inventoryRepository;
_petRepository = petRepository;
_gameItemsRepository = gameItemsRepository;
}
public async Task<Inventory> GetInventory(string petId, string userId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
return await _inventoryRepository.GetPetInventory(petId);
}
public async Task<Inventory> CreateInventory(string petId)
{
var inventory = new Inventory
{
PetId = petId,
Capacity = 20,
Items = new List<InventoryItem>()
};
await _inventoryRepository.SaveInventory(inventory);
return inventory;
}
public async Task<Pet> UseItem(string petId, string userId, int itemId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
var inventory = await _inventoryRepository.GetPetInventory(petId);
var item = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (item == null || item.Quantity <= 0)
throw new Exception("Item not found in inventory");
item.Quantity--;
if (item.Quantity <= 0)
inventory.Items.Remove(item);
await _inventoryRepository.SaveInventory(inventory);
return _petRepository.UpdatePet(pet);
}
public async Task<Pet> EquipItem(string petId, string userId, int itemId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
var inventory = await _inventoryRepository.GetPetInventory(petId);
var item = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (item == null || item.Quantity <= 0)
throw new Exception("Item not found in inventory");
if (item.GameItem.Type != ItemType.Equipment)
throw new Exception("Item is not equipment");
var equippedItems = await _inventoryRepository.GetEquippedItems(petId);
if (equippedItems.ContainsKey(item.GameItem.EquipTarget))
{
await UnequipItem(petId, userId, item.GameItem.EquipTarget);
}
item.Quantity--;
if (item.Quantity <= 0)
inventory.Items.Remove(item);
await _inventoryRepository.SaveInventory(inventory);
return _petRepository.UpdatePet(pet);
}
public async Task<Pet> UnequipItem(string petId, string userId, ItemEquipTarget equipTarget)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
var equippedItems = await _inventoryRepository.GetEquippedItems(petId);
if (!equippedItems.ContainsKey(equipTarget))
return pet;
var itemId = equippedItems[equipTarget];
var item = _gameItemsRepository.GetById(itemId);
if (item != null)
{
var inventory = await _inventoryRepository.GetPetInventory(petId);
var inventoryItem = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (inventoryItem != null)
inventoryItem.Quantity++;
else
inventory.Items.Add(new InventoryItem
{
GameItemId = itemId,
Quantity = 1,
GameItem = item,
InventoryId = pet.Id
});
await _inventoryRepository.SaveInventory(inventory);
}
return _petRepository.UpdatePet(pet);
}
public async Task<Pet> DropItem(string petId, string userId, int itemId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
var inventory = await _inventoryRepository.GetPetInventory(petId);
if (inventory == null)
throw new Exception("Inventory not found");
var item = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (item == null || item.Quantity <= 0)
throw new Exception("Item not found in inventory");
item.Quantity--;
if (item.Quantity <= 0)
inventory.Items.Remove(item);
await _inventoryRepository.SaveInventory(inventory);
return pet;
}
public async Task<Pet> AddItemToPet(string petId, string userId, int itemId, int quantity)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
var gameItem = _gameItemsRepository.GetById(itemId);
if (gameItem == null)
throw new Exception("Item not found");
var inventory = await _inventoryRepository.GetPetInventory(petId);
if (inventory == null)
throw new Exception("Inventory not found");
var existingItem = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (existingItem != null)
{
existingItem.Quantity += quantity;
}
else
{
inventory.Items.Add(new InventoryItem
{
GameItemId = itemId,
Quantity = quantity,
GameItem = gameItem,
InventoryId = inventory.PetId
});
}
await _inventoryRepository.SaveInventory(inventory);
return pet;
}
}
}

169
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).Result;
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,147 @@ namespace PetCompanion.Services
return petRepository.UpdatePetResources(pet);
}
public Pet UseItem(string petId, string userId, int itemId)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (inventoryItem == null || inventoryItem.Quantity <= 0)
throw new Exception("Item not found in inventory");
gameItemService.ApplyItemEffect(pet, inventoryItem.GameItem);
inventoryItem.Quantity--;
if (inventoryItem.Quantity <= 0)
pet.Inventory.Items.Remove(inventoryItem);
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");
var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (inventoryItem == null || inventoryItem.Quantity <= 0)
throw new Exception("Item not found in inventory");
if (inventoryItem.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(inventoryItem.GameItem.EquipTarget))
{
UnequipItem(pet, inventoryItem.GameItem.EquipTarget);
}
// Apply equipment effects
gameItemService.ApplyItemEffect(pet, inventoryItem.GameItem);
// Mark item as equipped
pet.EquippedItems[inventoryItem.GameItem.EquipTarget] = itemId;
// Remove from inventory
inventoryItem.Quantity--;
if (inventoryItem.Quantity <= 0)
pet.Inventory.Items.Remove(inventoryItem);
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");
UnequipItem(pet, equipTarget);
return petRepository.UpdatePet(pet);
}
private void UnequipItem(Pet pet, ItemEquipTarget equipTarget)
{
if (!pet.EquippedItems.ContainsKey(equipTarget))
return;
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
var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == equippedItemId);
if (inventoryItem != null)
inventoryItem.Quantity++;
else
pet.Inventory.Items.Add(new InventoryItem
{
GameItemId = equippedItemId,
Quantity = 1,
GameItem = equippedItem,
InventoryId = pet.Id
});
}
pet.EquippedItems.Remove(equipTarget);
}
public Pet GetPet(string petId, string userId)
{
var pet = petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
return pet;
}
public Pet DropItem(string petId, string userId, int itemId)
{
var pet = GetPet(petId, userId);
var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (inventoryItem == null || inventoryItem.Quantity <= 0)
throw new Exception("Item not found in inventory");
inventoryItem.Quantity--;
if (inventoryItem.Quantity <= 0)
pet.Inventory.Items.Remove(inventoryItem);
return petRepository.UpdatePet(pet);
}
public Pet AddItemToPet(string petId, string userId, int itemId, int quantity)
{
var pet = GetPet(petId, userId);
var gameItem = gameItemsRepository.GetById(itemId);
if (gameItem == null)
throw new Exception("Item not found");
var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
if (inventoryItem != null)
{
inventoryItem.Quantity += quantity;
}
else
{
pet.Inventory.Items.Add(new InventoryItem
{
GameItemId = itemId,
Quantity = quantity,
GameItem = gameItem,
InventoryId = pet.Id
});
}
return petRepository.UpdatePet(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 async Task<IEnumerable<PetSkill>> GetPetSkills(string petId, string userId)
{
var pet = _petRepository.GetPetById(petId, userId);
if (pet == null)
throw new Exception("Pet not found");
return await _petSkillRepository.GetPetSkills(petId);
}
public async Task<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 = await _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++;
await _petSkillRepository.SavePetSkill(existingSkill);
}
else
{
existingSkill = new PetSkill
{
PetId = petId,
SkillId = skillId,
CurrentTier = SkillTier.I
};
await _petSkillRepository.SavePetSkill(existingSkill);
}
pet.SkillPoints--;
_petRepository.UpdatePet(pet);
return existingSkill;
}
}
}

30
Services/SkillService.cs
View File

@ -7,18 +7,23 @@ namespace PetCompanion.Services
{
public class SkillService
{
private readonly ApplicationDbContext context;
private readonly PetRepository petRepository;
private readonly ApplicationDbContext _context;
private readonly PetRepository _petRepository;
private readonly PetSkillRepository _petSkillRepository;
public SkillService(ApplicationDbContext context, PetRepository petRepository)
public SkillService(
ApplicationDbContext context,
PetRepository petRepository,
PetSkillRepository petSkillRepository)
{
this.context = context;
this.petRepository = petRepository;
_context = context;
_petRepository = petRepository;
_petSkillRepository = petSkillRepository;
}
public async Task<PetSkill> AllocateSkillPoint(string petId, string userId, int skillId)
{
var pet = await context.Pets
var pet = await _context.Pets
.Include(p => p.Skills)
.FirstOrDefaultAsync(p => p.Id == petId && p.UserId == userId);
@ -28,7 +33,7 @@ namespace PetCompanion.Services
if (pet.SkillPoints <= 0)
throw new Exception("No skill points available");
var skill = await context.Skills
var skill = await _context.Skills
.Include(s => s.Effects)
.FirstOrDefaultAsync(s => s.Id == skillId);
@ -45,6 +50,8 @@ namespace PetCompanion.Services
var effect = skill.Effects.FirstOrDefault(e => e.Tier == existingSkill.CurrentTier);
if (effect != null)
effect.PetSkillUpgrade(ref pet);
await _petSkillRepository.SavePetSkill(existingSkill);
}
else
{
@ -54,21 +61,22 @@ namespace PetCompanion.Services
SkillId = skillId,
CurrentTier = SkillTier.I
};
pet.Skills.Add(newSkill);
await _petSkillRepository.SavePetSkill(newSkill);
var effect = skill.Effects.FirstOrDefault(e => e.Tier == SkillTier.I);
if (effect != null)
effect.PetSkillUpgrade(ref pet);
}
pet.SkillPoints--;
await context.SaveChangesAsync();
await _context.SaveChangesAsync();
return pet.Skills.First(ps => ps.SkillId == skillId);
return (await _petSkillRepository.GetPetSkills(petId)).First(ps => ps.SkillId == skillId);
}
public async Task<IEnumerable<Skill>> GetAvailableSkills()
{
return await context.Skills
return await _context.Skills
.Include(s => s.Effects)
.ToListAsync();
}

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>