362 lines
20 KiB
C#
362 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using CustomNPCFramework.Framework.Enums;
|
|
using CustomNPCFramework.Framework.ModularNpcs;
|
|
using CustomNPCFramework.Framework.ModularNpcs.CharacterAnimationBases;
|
|
using CustomNPCFramework.Framework.ModularNpcs.ColorCollections;
|
|
using CustomNPCFramework.Framework.ModularNpcs.ModularRenderers;
|
|
using CustomNPCFramework.Framework.NPCS;
|
|
using StardewValley;
|
|
|
|
namespace CustomNPCFramework.Framework.Graphics
|
|
{
|
|
/// <summary>Used to hold a collection of strings.</summary>
|
|
public class NamePairings
|
|
{
|
|
public string leftString;
|
|
public string rightString;
|
|
public string upString;
|
|
public string downString;
|
|
|
|
public NamePairings(string LeftString, string RightString, string UpString, string DownString)
|
|
{
|
|
this.leftString = LeftString;
|
|
this.rightString = RightString;
|
|
this.upString = UpString;
|
|
this.downString = DownString;
|
|
}
|
|
}
|
|
|
|
/// <summary>Used to contain all of the asset managers.</summary>
|
|
public class AssetPool
|
|
{
|
|
/// <summary>A dictionary holding all of the asset managers. (Name, AssetManager)</summary>
|
|
public Dictionary<string, AssetManager> assetPool;
|
|
|
|
/// <summary>Construct an instance.</summary>
|
|
public AssetPool()
|
|
{
|
|
this.assetPool = new Dictionary<string, AssetManager>();
|
|
}
|
|
|
|
/// <summary>Adds an asset manager to the asset pool.</summary>
|
|
/// <param name="pair">A key value pair with the convention being (Manager Name, Asset Manager)</param>
|
|
public void addAssetManager(KeyValuePair<string, AssetManager> pair)
|
|
{
|
|
this.assetPool.Add(pair.Key, pair.Value);
|
|
}
|
|
|
|
/// <summary>Adds an asset manager to the asset pool.</summary>
|
|
/// <param name="assetManagerName">The name of the asset manager to be added.</param>
|
|
/// <param name="assetManager">The asset manager object to be added to the asset pool.</param>
|
|
public void addAssetManager(string assetManagerName, AssetManager assetManager)
|
|
{
|
|
this.assetPool.Add(assetManagerName, assetManager);
|
|
}
|
|
|
|
/// <summary>Get an asset manager from the asset pool from a name.</summary>
|
|
/// <param name="name">The name of the asset manager to return.</param>
|
|
public AssetManager getAssetManager(string name)
|
|
{
|
|
this.assetPool.TryGetValue(name, out AssetManager asset);
|
|
return asset;
|
|
}
|
|
|
|
/// <summary>Remove an asset manager from the asset pool.</summary>
|
|
/// <param name="key">The name of the asset manager to remove.</param>
|
|
public void removeAssetManager(string key)
|
|
{
|
|
this.assetPool.Remove(key);
|
|
}
|
|
|
|
/// <summary>Go through all of the asset managers and load assets according to their respective paths.</summary>
|
|
public void loadAllAssets()
|
|
{
|
|
foreach (KeyValuePair<string, AssetManager> assetManager in this.assetPool)
|
|
assetManager.Value.loadAssets();
|
|
}
|
|
|
|
/// <summary>Creates an extended animated sprite object given the asset name in the asset manager.</summary>
|
|
/// <param name="name">The asset name.</param>
|
|
public AnimatedSpriteExtended getAnimatedSpriteFromAsset(string name)
|
|
{
|
|
this.assetPool.TryGetValue(name, out AssetManager asset);
|
|
var assetSheet = asset.getAssetByName(name);
|
|
return new AnimatedSpriteExtended(assetSheet.path.Clone().ToString(), assetSheet.index, (int)assetSheet.assetInfo.assetSize.X, (int)assetSheet.assetInfo.assetSize.Y);
|
|
}
|
|
|
|
/// <summary>Generates a new AnimatedSpriteCollection object from the data held in an asset sheet.</summary>
|
|
/// <param name="assetSheet">An asset sheet that holds the data for textures.</param>
|
|
/// <param name="type">The type of asset to get from the sheet. Hair, eyes, shoes, etc.</param>
|
|
public AnimatedSpriteCollection getSpriteCollectionFromSheet(AssetSheet assetSheet, AnimationType type)
|
|
{
|
|
var left = new AnimatedSpriteExtended(assetSheet.clone().getTexture(Direction.left, type), assetSheet);
|
|
var right = new AnimatedSpriteExtended(assetSheet.clone().getTexture(Direction.right, type), assetSheet);
|
|
var up = new AnimatedSpriteExtended(assetSheet.clone().getTexture(Direction.up, type), assetSheet);
|
|
var down = new AnimatedSpriteExtended(assetSheet.clone().getTexture(Direction.down, type), assetSheet);
|
|
return new AnimatedSpriteCollection(left, right, up, down, Direction.down);
|
|
}
|
|
|
|
/// <summary>Gets an animated sprite collection (ie a hair style facing all four directions) from a list of asset names.</summary>
|
|
/// <param name="left">The name of the asset for the left facing sprite.</param>
|
|
/// <param name="right">The name of the asset for the right facing sprite.</param>
|
|
/// <param name="up">The name of the asset for the up facing sprite.</param>
|
|
/// <param name="down">The name of the asset for the down facing sprite.</param>
|
|
/// <param name="startingDirection">The sprite's starting direction.</param>
|
|
public AnimatedSpriteCollection getAnimatedSpriteCollectionFromAssets(string left, string right, string up, string down, Direction startingDirection = Direction.down)
|
|
{
|
|
var leftSprite = this.getAnimatedSpriteFromAsset(left);
|
|
var rightSprite = this.getAnimatedSpriteFromAsset(right);
|
|
var upSprite = this.getAnimatedSpriteFromAsset(up);
|
|
var downSprite = this.getAnimatedSpriteFromAsset(down);
|
|
return new AnimatedSpriteCollection(leftSprite, rightSprite, upSprite, downSprite, startingDirection);
|
|
|
|
}
|
|
|
|
/// <summary>Get an AnimatedSpriteCollection from a name pairing.</summary>
|
|
/// <param name="pair">A collection of strings that hold information on directional textures.</param>
|
|
/// <param name="startingDirection">The direction in which the sprite should face.</param>
|
|
public AnimatedSpriteCollection getAnimatedSpriteCollectionFromAssets(NamePairings pair, Direction startingDirection = Direction.down)
|
|
{
|
|
return this.getAnimatedSpriteCollectionFromAssets(pair.leftString, pair.rightString, pair.upString, pair.downString);
|
|
}
|
|
|
|
/// <summary>Get a collection of sprites to generate a collective animated sprite.</summary>
|
|
/// <param name="BodySprites">The collection of sprites to be used for the boyd of the npc.</param>
|
|
/// <param name="EyeSprites">The collection of sprites to be used for the eye of the npc.</param>
|
|
/// <param name="HairSprites">The collection of sprites to be used for the hair of the npc.</param>
|
|
/// <param name="ShirtsSprites">The collection of sprites to be used for the shirts of the npc.</param>
|
|
/// <param name="PantsSprites">The collection of sprites to be used for the pants of the npc.</param>
|
|
/// <param name="ShoesSprites">The collection of sprites to be used for the shoes of the npc.</param>
|
|
/// <param name="AccessoriesSprites">The collection of sprites to be used for the accessories of the npc.</param>
|
|
/// <param name="DrawColors">The collection of collors to be used for chaing the color of an individual asset.</param>
|
|
public StandardCharacterAnimation GetStandardCharacterAnimation(NamePairings BodySprites, NamePairings EyeSprites, NamePairings HairSprites, NamePairings ShirtsSprites, NamePairings PantsSprites, NamePairings ShoesSprites, List<NamePairings> AccessoriesSprites, StandardColorCollection DrawColors = null)
|
|
{
|
|
var body = this.getAnimatedSpriteCollectionFromAssets(BodySprites);
|
|
var eyes = this.getAnimatedSpriteCollectionFromAssets(EyeSprites);
|
|
var hair = this.getAnimatedSpriteCollectionFromAssets(HairSprites);
|
|
var shirts = this.getAnimatedSpriteCollectionFromAssets(ShirtsSprites);
|
|
var pants = this.getAnimatedSpriteCollectionFromAssets(PantsSprites);
|
|
var shoes = this.getAnimatedSpriteCollectionFromAssets(ShoesSprites);
|
|
|
|
List<AnimatedSpriteCollection> accessories = new List<AnimatedSpriteCollection>();
|
|
foreach (var v in AccessoriesSprites)
|
|
accessories.Add(this.getAnimatedSpriteCollectionFromAssets(v));
|
|
|
|
if (DrawColors == null)
|
|
DrawColors = new StandardColorCollection();
|
|
|
|
return new StandardCharacterAnimation(body, eyes, hair, shirts, pants, shoes, accessories, DrawColors);
|
|
}
|
|
|
|
/// <summary>Get a list of parts that can apply for this criteria.</summary>
|
|
/// <param name="assetManagerName">The name of the asset manager.</param>
|
|
/// <param name="gender">The gender critera.</param>
|
|
/// <param name="season">The season critera.</param>
|
|
/// <param name="type">The part type critera.</param>
|
|
public List<AssetSheet> getListOfApplicableBodyParts(string assetManagerName, Genders gender, Seasons season, PartType type)
|
|
{
|
|
var parts = this.getAssetManager(assetManagerName).getListOfAssetsThatMatchThisCriteria(gender, season, type);
|
|
return parts;
|
|
}
|
|
|
|
/// <summary>Generate a basic NPC based on the NPC data here.</summary>
|
|
/// <param name="gender">The NPC gender.</param>
|
|
/// <param name="minNumOfAccessories">The minimum number of accessories to generate.</param>
|
|
/// <param name="maxNumOfAccessories">The maximum number of accessories to generate.</param>
|
|
/// <param name="drawColors">The colors for the NPC's different assets.</param>
|
|
public ExtendedNpc generateNPC(Genders gender, int minNumOfAccessories, int maxNumOfAccessories, StandardColorCollection drawColors = null)
|
|
{
|
|
Seasons myseason = Seasons.spring;
|
|
|
|
if (Game1.currentSeason == "spring") myseason = Seasons.spring;
|
|
if (Game1.currentSeason == "summer") myseason = Seasons.summer;
|
|
if (Game1.currentSeason == "fall") myseason = Seasons.fall;
|
|
if (Game1.currentSeason == "winter") myseason = Seasons.winter;
|
|
|
|
List<AssetSheet> bodyList = new List<AssetSheet>();
|
|
List<AssetSheet> eyesList = new List<AssetSheet>();
|
|
List<AssetSheet> hairList = new List<AssetSheet>();
|
|
List<AssetSheet> shirtList = new List<AssetSheet>();
|
|
List<AssetSheet> shoesList = new List<AssetSheet>();
|
|
List<AssetSheet> pantsList = new List<AssetSheet>();
|
|
List<AssetSheet> accessoryList = new List<AssetSheet>();
|
|
|
|
//Get all applicable parts from this current asset manager
|
|
foreach (var assetManager in this.assetPool)
|
|
{
|
|
var body = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.body);
|
|
foreach (var piece in body) bodyList.Add(piece);
|
|
|
|
var eyes = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.eyes);
|
|
foreach (var piece in eyes) eyesList.Add(piece);
|
|
|
|
var hair = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.hair);
|
|
foreach (var piece in hair) hairList.Add(piece);
|
|
|
|
var shirt = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.shirt);
|
|
foreach (var piece in shirt) shirtList.Add(piece);
|
|
|
|
var pants = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.pants);
|
|
foreach (var piece in pants) pantsList.Add(piece);
|
|
|
|
var shoes = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.shoes);
|
|
foreach (var piece in shoes) shoesList.Add(piece);
|
|
|
|
var accessory = this.getListOfApplicableBodyParts(assetManager.Key, gender, myseason, PartType.accessory);
|
|
foreach (var piece in accessory) accessoryList.Add(piece);
|
|
}
|
|
|
|
|
|
Random r = new Random(DateTime.Now.Millisecond);
|
|
int amount = r.Next(minNumOfAccessories, maxNumOfAccessories + 1);
|
|
|
|
int bodyIndex;
|
|
int eyesIndex;
|
|
int hairIndex;
|
|
int shirtIndex;
|
|
int pantsIndex;
|
|
int shoesIndex;
|
|
|
|
if (bodyList.Count != 0)
|
|
bodyIndex = r.Next(0, bodyList.Count - 1);
|
|
else
|
|
{
|
|
Class1.ModMonitor.Log("Error: Not enough body templates to generate an npc. Aborting", StardewModdingAPI.LogLevel.Error);
|
|
return null;
|
|
}
|
|
|
|
if (eyesList.Count != 0)
|
|
eyesIndex = r.Next(0, eyesList.Count - 1);
|
|
else
|
|
{
|
|
Class1.ModMonitor.Log("Error: Not enough eyes templates to generate an npc. Aborting", StardewModdingAPI.LogLevel.Error);
|
|
return null;
|
|
}
|
|
|
|
if (hairList.Count != 0)
|
|
hairIndex = r.Next(0, hairList.Count - 1);
|
|
else
|
|
{
|
|
Class1.ModMonitor.Log("Error: Not enough hair templates to generate an npc. Aborting", StardewModdingAPI.LogLevel.Error);
|
|
return null;
|
|
}
|
|
|
|
if (shirtList.Count != 0)
|
|
shirtIndex = r.Next(0, shirtList.Count - 1);
|
|
else
|
|
{
|
|
Class1.ModMonitor.Log("Error: Not enough shirt templates to generate an npc. Aborting", StardewModdingAPI.LogLevel.Error);
|
|
return null;
|
|
}
|
|
|
|
if (pantsList.Count != 0)
|
|
pantsIndex = r.Next(0, pantsList.Count - 1);
|
|
else
|
|
{
|
|
Class1.ModMonitor.Log("Error: Not enough pants templates to generate an npc. Aborting", StardewModdingAPI.LogLevel.Error);
|
|
return null;
|
|
}
|
|
|
|
if (shoesList.Count != 0)
|
|
shoesIndex = r.Next(0, shoesList.Count - 1);
|
|
else
|
|
{
|
|
Class1.ModMonitor.Log("Error: Not enough shoes templates to generate an npc. Aborting", StardewModdingAPI.LogLevel.Error);
|
|
return null;
|
|
}
|
|
|
|
List<int> accIntList = new List<int>();
|
|
if (accessoryList.Count != 0)
|
|
{
|
|
for (int i = 0; i < amount; i++)
|
|
{
|
|
int acc = r.Next(0, accessoryList.Count - 1);
|
|
accIntList.Add(acc);
|
|
}
|
|
}
|
|
|
|
//Get a single sheet to pull from.
|
|
AssetSheet bodySheet = bodyList.ElementAt(bodyIndex);
|
|
AssetSheet eyesSheet = eyesList.ElementAt(eyesIndex);
|
|
AssetSheet hairSheet = hairList.ElementAt(hairIndex);
|
|
AssetSheet shirtSheet = shirtList.ElementAt(shirtIndex);
|
|
AssetSheet pantsSheet = pantsList.ElementAt(pantsIndex);
|
|
AssetSheet shoesSheet = shoesList.ElementAt(shoesIndex);
|
|
|
|
List<AssetSheet> accessorySheet = new List<AssetSheet>();
|
|
foreach (int v in accIntList)
|
|
accessorySheet.Add(accessoryList.ElementAt(v));
|
|
|
|
if (drawColors == null)
|
|
drawColors = new StandardColorCollection();
|
|
|
|
var render = this.generateBasicRenderer(bodySheet, eyesSheet, hairSheet, shirtSheet, pantsSheet, shoesSheet, accessorySheet, drawColors);
|
|
return new ExtendedNpc(new Sprite(this.getDefaultSpriteImage(bodySheet)), render, new Microsoft.Xna.Framework.Vector2(0, 0) * Game1.tileSize, 2, NpcNames.getRandomNpcName(gender));
|
|
}
|
|
|
|
/// <summary>Creates a character renderer (a collection of textures) from a bunch of different asset sheets.</summary>
|
|
/// <param name="bodySheet">The textures for the NPC's body.</param>
|
|
/// <param name="eyesSheet">The textures for the NPC's eyes.</param>
|
|
/// <param name="hairSheet">The textures for the NPC's hair.</param>
|
|
/// <param name="shirtSheet">The textures for the NPC's shirt.</param>
|
|
/// <param name="pantsSheet">The textures for the NPC's pants.</param>
|
|
/// <param name="shoesSheet">The textures for the NPC's shoes.</param>
|
|
/// <param name="accessorySheet">The textures for the NPC's accessories.</param>
|
|
/// <param name="drawColors">The colors for the NPC's different assets.</param>
|
|
public virtual BasicRenderer generateBasicRenderer(AssetSheet bodySheet, AssetSheet eyesSheet, AssetSheet hairSheet, AssetSheet shirtSheet, AssetSheet pantsSheet, AssetSheet shoesSheet, List<AssetSheet> accessorySheet, StandardColorCollection drawColors = null)
|
|
{
|
|
if (drawColors == null)
|
|
drawColors = new StandardColorCollection();
|
|
|
|
// Get all of the appropriate animations.
|
|
StandardCharacterAnimation standingAnimation = this.generateCharacterAnimation(bodySheet, eyesSheet, hairSheet, shirtSheet, pantsSheet, shoesSheet, accessorySheet, AnimationType.standing, drawColors);
|
|
StandardCharacterAnimation movingAnimation = this.generateCharacterAnimation(bodySheet, eyesSheet, hairSheet, shirtSheet, pantsSheet, shoesSheet, accessorySheet, AnimationType.walking, drawColors);
|
|
StandardCharacterAnimation swimmingAnimation = this.generateCharacterAnimation(bodySheet, eyesSheet, hairSheet, shirtSheet, pantsSheet, shoesSheet, accessorySheet, AnimationType.swimming, drawColors);
|
|
|
|
return new BasicRenderer(standingAnimation, movingAnimation, swimmingAnimation);
|
|
}
|
|
|
|
/// <summary>Generate a Standard Character Animation from some asset sheets. (collection of textures to animations)</summary>
|
|
/// <param name="body">The textures for the NPC's body.</param>
|
|
/// <param name="eyes">The textures for the NPC's eyes.</param>
|
|
/// <param name="hair">The textures for the NPC's hair.</param>
|
|
/// <param name="shirt">The textures for the NPC's shirt.</param>
|
|
/// <param name="pants">The textures for the NPC's pants.</param>
|
|
/// <param name="shoes">The textures for the NPC's shoes.</param>
|
|
/// <param name="accessories">The textures for the NPC's accessories.</param>
|
|
/// <param name="animationType">The animation type to generate.</param>
|
|
/// <param name="drawColors">The colors for the NPC's different assets.</param>
|
|
public virtual StandardCharacterAnimation generateCharacterAnimation(AssetSheet body, AssetSheet eyes, AssetSheet hair, AssetSheet shirt, AssetSheet pants, AssetSheet shoes, List<AssetSheet> accessories, AnimationType animationType, StandardColorCollection drawColors = null)
|
|
{
|
|
AnimatedSpriteCollection bodySprite = this.getSpriteCollectionFromSheet(body, animationType);
|
|
AnimatedSpriteCollection eyesSprite = this.getSpriteCollectionFromSheet(eyes, animationType);
|
|
AnimatedSpriteCollection hairSprite = this.getSpriteCollectionFromSheet(hair, animationType);
|
|
AnimatedSpriteCollection shirtSprite = this.getSpriteCollectionFromSheet(shirt, animationType);
|
|
AnimatedSpriteCollection pantsSprite = this.getSpriteCollectionFromSheet(pants, animationType);
|
|
AnimatedSpriteCollection shoesSprite = this.getSpriteCollectionFromSheet(shoes, animationType);
|
|
|
|
List<AnimatedSpriteCollection> accessoryCollection = new List<AnimatedSpriteCollection>();
|
|
foreach (var v in accessories)
|
|
{
|
|
AnimatedSpriteCollection acc = this.getSpriteCollectionFromSheet(v, AnimationType.standing);
|
|
accessoryCollection.Add(acc);
|
|
}
|
|
|
|
if (drawColors == null)
|
|
drawColors = new StandardColorCollection();
|
|
|
|
return new StandardCharacterAnimation(bodySprite, eyesSprite, hairSprite, shirtSprite, pantsSprite, shoesSprite, accessoryCollection, drawColors);
|
|
}
|
|
|
|
/// <summary>Get the string for the standard character sprite to be used from this asset sheet.</summary>
|
|
/// <param name="imageGraphics">The standard asset sheet to be used.</param>
|
|
public virtual string getDefaultSpriteImage(AssetSheet imageGraphics)
|
|
{
|
|
return Class1.getRelativeDirectory(Path.Combine(imageGraphics.path, imageGraphics.assetInfo.standingAssetPaths.downString));
|
|
}
|
|
}
|
|
}
|