protected void AddRandomEnemies(int count)
{
Random rnd = new Random();
if (world.avatarManager.avatarDefinitions.Length > 1)
{
for (int i = 0; i < count; i++)
{
int avatarIndex = rnd.Next(0, world.avatarManager.avatarDefinitions.Length);
while (world.avatarManager.avatarDefinitions[avatarIndex].id.IndexOf("player") == 0)
{
avatarIndex = (avatarIndex + 1) % world.avatarManager.avatarDefinitions.Length;
}
AvatarDefinition avatarDefinition = world.avatarManager.avatarDefinitions[avatarIndex];
Vector3 pos = new Vector3(
world.sizeX * ((float)rnd.NextDouble() * 0.8f + 0.1f),
world.sizeY * 0.9f,
world.sizeZ * ((float)rnd.NextDouble() * 0.8f + 0.1f));
world.avatarManager.CreateAvatar(avatarDefinition, NextObjectId(), pos, true);
}
}
}
public static void ChangePenguinOutfit([NamedToggleValue(typeof(EquipmentNameGenerator), 0u)] int definitionId)
{
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
if (cPDataEntityCollection.TryGetComponent(cPDataEntityCollection.LocalPlayerHandle, out AvatarDetailsData component))
{
Dictionary <int, TemplateDefinition> dictionary = Service.Get <GameData>().Get <Dictionary <int, TemplateDefinition> >();
TemplateDefinition templateDefinition = dictionary[definitionId];
AvatarDefinition definitionByName = Service.Get <AvatarService>().GetDefinitionByName("penguinAvatar");
EquipmentModelDefinition equipmentDefinition = definitionByName.GetEquipmentDefinition(templateDefinition.AssetName);
DCustomEquipment dCustomEquipment = default(DCustomEquipment);
dCustomEquipment.DefinitionId = templateDefinition.Id;
dCustomEquipment.Name = equipmentDefinition.Name;
dCustomEquipment.Id = 1L + (long)definitionId;
dCustomEquipment.Parts = new DCustomEquipmentPart[equipmentDefinition.Parts.Length];
for (int i = 0; i < equipmentDefinition.Parts.Length; i++)
{
dCustomEquipment.Parts[i].SlotIndex = equipmentDefinition.Parts[i].SlotIndex;
DCustomEquipmentDecal[] decals = new DCustomEquipmentDecal[0];
dCustomEquipment.Parts[i].Decals = decals;
}
component.Outfit = new DCustomEquipment[1]
{
dCustomEquipment
};
}
}
/// <summary>
/// This is likely not compatible cross platform
/// </summary>
/// <param name="bf"></param>
/// <returns></returns>
public static byte[] ToBinary(BinaryFormatter bf, AvatarDefinition adf)
{
using (var ms = new System.IO.MemoryStream())
{
bf.Serialize(ms, new BinaryDefinition(adf));
return(ms.ToArray());
}
}
/// <summary>Creates an instance of IAvatar</summary>
/// <param name="definition">Avatar definition</param>
/// <returns>The created IAvatar instance</returns>
protected override IAvatar Create(AvatarDefinition definition)
{
return(new UnityAvatar(
definition.Id,
this.Resources.GetResource <PrefabResource>(definition.ResourceId),
definition.States,
definition.DefaultState));
}
protected ObjectBase(
AvatarDefinition avatarDefinition,
double mass,
IControllerFactory[] controllerFactories,
ControllerConfig[] builtInControllers,
ControllerConfig[] customControllers)
: base(avatarDefinition.Id, controllerFactories, builtInControllers, customControllers)
{
this.AvatarDefinition = avatarDefinition;
this.Mass = mass;
}
public void LoadDNAFromAvatarDefinition(AvatarDefinition adf)
{
var DNA = GetDNA();
foreach (var d in adf.Dna)
{
if (DNA.ContainsKey(d.Name))
{
DNA[d.Name].Set(d.Value);
}
}
}
private void BuildLayout(ExpressionInfo controllerExpressionInfo)
{
var def = new AvatarDefinition(controllerExpressionInfo.AvatarDescriptor);
IEnumerable <VrcParameterDefinition> parameters = def.Children.OfType <VrcParameterDefinition>();
foreach (VrcParameterDefinition parameterDefinition in parameters)
{
string parameter = parameterDefinition.Name;
VisualElement row = _dataRow.InstantiateTemplate(_parameterList.contentContainer);
row.Q("parameter").Add(ObjectHolder.CreateHolder(parameterDefinition, this));
foreach (AnimatorLayerDefinition l in GetLayers(def, parameter))
{
if (!l.TryGetFirstParent(out AnimatorDefinition _))
{
continue;
}
row.Q("layer").Add(ObjectHolder.CreateHolder(l, this));
}
foreach (MotionDefinition m in GetMotions(def, parameter))
{
if (m.Motion == null)
{
continue;
}
row.Q("misc").Add(ObjectHolder.CreateHolder(m, this));
}
foreach (VrcParameterDriverDefinition d in GetDrivers(def, parameter))
{
row.Q("misc").Add(ObjectHolder.CreateHolder(d, this));
}
foreach (MenuControlDefinition m in GetMenuControls(def, parameter))
{
if (!m.TryGetFirstParent(out MenuDefinition _))
{
continue;
}
row.Q("menu").Add(ObjectHolder.CreateHolder(m, this));
}
}
}
private AvatarDefinition ParseAvatarDefinition(XmlElement avatarDefinitionXML)
{
AvatarDefinition avatar = new AvatarDefinition();
avatar.id = GetAttributeStringValue(avatarDefinitionXML, "id");
avatar.description = GetAttributeStringValue(avatarDefinitionXML, "description");
avatar.energy = GetAttributeIntValue(avatarDefinitionXML, "energy", 0);
avatar.sizeInTiles = GetAttributeTilePositionValue(avatarDefinitionXML, "size");
List <AvatarPartDefinition> parts = new List <AvatarPartDefinition>();
foreach (XmlElement partXML in GetChildElements(avatarDefinitionXML["Parts"]))
{
parts.Add(ParseAvatarPartDefinition(partXML));
}
avatar.parts = parts.ToArray();
return(avatar);
}
public void LoadUMA()
{
if (string.IsNullOrEmpty(saveString))
{
return;
}
if (useCompressedString)
{
AvatarDefinition adf = AvatarDefinition.FromCompressedString(compressedString, '|');
Avatar.LoadAvatarDefinition(adf);
Avatar.BuildCharacter(false); // don't restore old DNA...
}
else if (useAvatarDefinition)
{
Avatar.LoadAvatarDefinition(avatarString);
Avatar.BuildCharacter(false); // We must not restore the old DNA
}
else
{
Avatar.LoadFromRecipeString(saveString);
}
}
private IEnumerable <MotionDefinition> GetMotions(AvatarDefinition avatarDefinition, string parameter)
{
return(GetLayers(avatarDefinition, parameter).SelectMany(l => l.GetChildren <MotionDefinition>()).Distinct().ToList());
}
/// <summary>Creates an instance of IAvatar</summary> /// <param name="definition">Avatar definition</param> /// <returns>The created IAvatar instance</returns> protected abstract IAvatar Create(AvatarDefinition definition);
private IEnumerable <MenuControlDefinition> GetMenuControls(AvatarDefinition avatarDefinition, string parameter)
{
return(avatarDefinition.GetChildren <MenuControlDefinition>().Where(m => m.Children.Any(c => (c as ParameterDefinition)?.Name == parameter)).Distinct().ToList());
}
private IEnumerable <VrcParameterDriverDefinition> GetDrivers(AvatarDefinition avatarDefinition, string parameter)
{
return(GetLayers(avatarDefinition, parameter).SelectMany(l => l.GetChildren <VrcParameterDriverDefinition>()).Where(v => v.GetChildren <ParameterDefinition>(parameter).Any()).Distinct().ToList());
}
public BinaryDefinition(AvatarDefinition Adf)
{
adf = Adf;
}
public static AvatarDefinition FromCompressedString(string compressed, char seperator = '\n')
{
char[] splitter = new char[1];
AvatarDefinition adf = new AvatarDefinition();
splitter[0] = seperator;
string[] SplitLines = compressed.Split(splitter);
List <SharedColorDef> Colors = new List <SharedColorDef>();
foreach (string s in SplitLines)
{
if (String.IsNullOrEmpty(s))
{
continue;
}
switch (s[0])
{
case 'R':
// Unpack Race
adf.RaceName = s.Substring(2).Trim();
break;
case 'W':
// Unpack Wardrobe
splitter[0] = ',';
adf.Wardrobe = s.Substring(2).Trim().Split(splitter, StringSplitOptions.RemoveEmptyEntries);
break;
case 'C':
// Unpack Colors
splitter[0] = '=';
string[] SharedColor = s.Substring(2).Trim().Split(splitter, StringSplitOptions.RemoveEmptyEntries);
if (SharedColor.Length > 1)
{
SharedColorDef scd = new SharedColorDef();
splitter[0] = ',';
string[] maincol = SharedColor[0].Split(splitter, StringSplitOptions.RemoveEmptyEntries);
if (maincol.Length > 1)
{
scd.name = maincol[0];
scd.count = Convert.ToInt32(maincol[1]);
splitter[0] = ';';
string[] ColorDefs = SharedColor[1].Split(splitter, StringSplitOptions.RemoveEmptyEntries);
List <ColorDef> theColors = new List <ColorDef>();
if (ColorDefs != null)
{
if (ColorDefs.Length > 0)
{
foreach (string c in ColorDefs)
{
splitter[0] = ',';
string[] vals = c.Split(splitter, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length == 2)
{
ColorDef cdef = new ColorDef(Convert.ToInt32(vals[0]), Convert.ToUInt32(vals[1], 16), 0);
theColors.Add(cdef);
}
else if (vals.Length == 3)
{
ColorDef cdef = new ColorDef(Convert.ToInt32(vals[0]), Convert.ToUInt32(vals[1], 16), Convert.ToUInt32(vals[2], 16));
theColors.Add(cdef);
}
}
}
}
scd.channels = theColors.ToArray();
Colors.Add(scd);
}
}
break;
case 'D':
// Unpack DNA
splitter[0] = ';';
string[] Dna = s.Substring(2).Trim().Split(splitter, StringSplitOptions.RemoveEmptyEntries);
if (Dna.Length > 0)
{
List <DnaDef> theDna = new List <DnaDef>();
foreach (string d in Dna)
{
splitter[0] = '=';
string[] dnaval = d.Split(splitter, StringSplitOptions.RemoveEmptyEntries);
if (dnaval.Length > 1)
{
DnaDef newDna = new DnaDef(dnaval[0], Convert.ToInt32(dnaval[1], 16));
theDna.Add(newDna);
}
}
adf.Dna = theDna.ToArray();
}
break;
}
}
adf.Colors = Colors.ToArray();
return(adf);
}
public void GenerateTestGameDef()
{
var eyemanAvatar = new AvatarDefinition
{
Id = "avatar.eyeman",
ResourceId = "avatar.prefab.eyeman",
DefaultState = "Idle",
States = new[]
{
new AvatarState {
Id = 0, Name = "Idle"
},
new AvatarState {
Id = 1, Name = "Walk"
},
},
};
var eyemanEntity = new EntityDefinition
{
Id = "entity.eyeman",
AvatarId = eyemanAvatar.Id,
Mass = 1,
Controllers = new[]
{
new ControllerConfig
{
ControllerId = "some.controller",
Settings = { { "Foo", "42" }, { "Bar", "Don't Panic" } }
},
},
};
var level = new LevelDefinition
{
Id = "level.alpha",
Title = "Test Level Alpha",
Description = "Alpha testing level",
Entities =
{
new LevelDefinition.EntityCollection.Entry
{
EntityId = eyemanEntity.Id, Direction = Vector3D.Zero, Position = new Vector3D(4f, 0f, 4f),
Controllers = new[]
{
new ControllerConfig
{
ControllerId = "some.controller",
Settings = { { "Foo", "57" }, { "Bar", "Keep Calm" } }
},
},
},
},
};
var game = new GameDefinition
{
Id = "game.eyeblock",
Title = "EYEBLOCK TAKE 2.0.1b",
LevelIds = new[] { level.Id },
Settings = new Dictionary <string, string>
{
{ "foo", "bar" },
{ "hello", "world" },
{ "answer", "42" },
},
};
var resources = new IResource[]
{
eyemanAvatar, eyemanEntity, level, game
};
var resourcesXml = string.Join("\n\n\n", resources.Select(res => res.ToString()).ToArray());
Assert.IsFalse(string.IsNullOrEmpty(resourcesXml));
}
private void ExecuteHorizontalMovement(float deltaTime)
{
TilePosition avatarActual = Graphics.Vector3ToTilePosition(avatar.position);
AvatarDefinition avatarDefinition = (AvatarDefinition)avatar.definition;
int yActualHead = avatarActual.y + avatarDefinition.sizeInTiles.y - 1;
if (yActualHead >= avatar.world.sizeY)
{
yActualHead = avatarActual.y;
}
Vector3 totalDeltaMov = avatar.input.moveDirection * WALK_SPEED * deltaTime;
float totalDeltaLen = totalDeltaMov.magnitude;
while (totalDeltaLen > 0.0f)
{
float actualDeltaLen;
if (totalDeltaLen > MAX_DELTA_POSITION)
{
totalDeltaLen -= MAX_DELTA_POSITION;
actualDeltaLen = MAX_DELTA_POSITION;
}
else
{
actualDeltaLen = totalDeltaLen;
totalDeltaLen = 0.0f;
}
Vector3 deltaMov = avatar.input.moveDirection * actualDeltaLen;
if (avatarActual.y < avatar.world.sizeY)
{
//Validate horizontal
if (deltaMov.x != 0.0f)
{
TilePosition avatarNew = avatarActual;
if (deltaMov.x < 0.0f)
{
avatarNew.x = Graphics.FloatToTilePosition(avatar.position.x + deltaMov.x - Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
else
{
avatarNew.x = Graphics.FloatToTilePosition(avatar.position.x + deltaMov.x + Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
TilePosition avatarHeadNew = avatarNew;
avatarHeadNew.y = yActualHead;
if (avatar.world.tileManager.IsValidTile(avatarNew) == false ||
avatar.world.tileManager.GetTileSolid(avatarNew) ||
avatar.world.tileManager.IsValidTile(avatarHeadNew) == false ||
avatar.world.tileManager.GetTileSolid(avatarHeadNew))
{
deltaMov.x = 0.0f;
}
}
//Validate forward
if (deltaMov.z != 0.0f)
{
TilePosition avatarNew = avatarActual;
if (deltaMov.z < 0.0f)
{
avatarNew.z = Graphics.FloatToTilePosition(avatar.position.z + deltaMov.z - Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
else
{
avatarNew.z = Graphics.FloatToTilePosition(avatar.position.z + deltaMov.z + Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
TilePosition avatarHeadNew = avatarNew;
avatarHeadNew.y = yActualHead;
if (avatar.world.tileManager.IsValidTile(avatarNew) == false ||
avatar.world.tileManager.GetTileSolid(avatarNew) ||
avatar.world.tileManager.IsValidTile(avatarHeadNew) == false ||
avatar.world.tileManager.GetTileSolid(avatarHeadNew))
{
deltaMov.z = 0.0f;
}
}
//Validate the combination
if (deltaMov.x != 0.0f && deltaMov.z != 0.0f)
{
TilePosition avatarNew = avatarActual;
if (deltaMov.x < 0.0f)
{
avatarNew.x = Graphics.FloatToTilePosition(avatar.position.x + deltaMov.x - Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
else
{
avatarNew.x = Graphics.FloatToTilePosition(avatar.position.x + deltaMov.x + Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
if (deltaMov.z < 0.0f)
{
avatarNew.z = Graphics.FloatToTilePosition(avatar.position.z + deltaMov.z - Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
else
{
avatarNew.z = Graphics.FloatToTilePosition(avatar.position.z + deltaMov.z + Graphics.HALF_TILE_SIZE * PLAYER_BORDER_TOLERANCE);
}
TilePosition avatarHeadNew = avatarNew;
avatarHeadNew.y = yActualHead;
if (avatar.world.tileManager.IsValidTile(avatarNew) == false ||
avatar.world.tileManager.GetTileSolid(avatarNew) ||
avatar.world.tileManager.IsValidTile(avatarHeadNew) == false ||
avatar.world.tileManager.GetTileSolid(avatarHeadNew))
{
//Both horizontal and forward movements where ok.. but not the combination, cancel both!
deltaMov.z = 0.0f;
deltaMov.x = 0.0f;
}
}
}
else
{
if (deltaMov.x < 0.0f && avatarActual.x < 0 || deltaMov.x > 0.0f && avatarActual.x >= avatar.world.sizeX)
{
deltaMov.x = 0;
}
if (deltaMov.z < 0.0f && avatarActual.z < 0 || deltaMov.z > 0.0f && avatarActual.z >= avatar.world.sizeZ)
{
deltaMov.z = 0;
}
}
avatar.position += deltaMov;
}
}
private IEnumerable <AnimatorLayerDefinition> GetLayers(AvatarDefinition avatarDefinition, string parameter)
{
return(avatarDefinition.GetChildren <AnimatorLayerDefinition>().Where(a => a.GetChildren <ParameterDefinition>().Any(p => p.Name == parameter)).Distinct().ToList());
}
