public override void UpdateBadLifeRegen()
{
if (player.whoAmI != Main.LocalPlayer.whoAmI)
{
return;
}
TransformationDefinition transformation = GetCurrentTransformation();
if (transformation == null)
{
return;
}
base.UpdateBadLifeRegen();
float negativeLifeRegen = transformation.GetHealthDrainRate(this);
if (negativeLifeRegen > 0)
{
if (player.lifeRegen > 0)
{
player.lifeRegen = 0;
}
player.lifeRegenTime = 0;
player.lifeRegen -= (int)Math.Ceiling(negativeLifeRegen);
}
}
private void DrawTransformation(UIPanel panel, TransformationDefinition transformation, Texture2D icon, int left, int top)
{
UIImageButton transformationButton = null;
UIImage
unknownImage = null,
unknownGrayImage = null,
lockedImage = null;
transformationButton = InitializeButton(icon, new MouseEvent((evt, element) => TrySelectingTransformation(transformation, evt, element)), left, top, panel);
unknownImage = InitializeImage(UnknownImageTexture, 0, 0, transformationButton);
unknownImage.ImageScale = 0f;
unknownImage.Width.Set(1, 0f);
unknownImage.Height.Set(1, 0f);
unknownGrayImage = InitializeImage(UnknownGrayImageTexture, 0, 0, unknownImage);
unknownGrayImage.ImageScale = 0f;
unknownGrayImage.Width.Set(1, 0f);
unknownGrayImage.Height.Set(1, 0f);
lockedImage = InitializeImage(LockedImageTexture, 0, 0, unknownGrayImage);
lockedImage.ImageScale = 0f;
lockedImage.Width.Set(1, 0f);
lockedImage.Height.Set(1, 0f);
if (!_transformationImagePairs.ContainsKey(transformation))
{
_transformationImagePairs.Add(transformation, new UIImagePair(new Point(left, top), transformationButton, unknownImage, unknownGrayImage, lockedImage));
}
}
private void RecursiveInitializeTransformation(Node <TransformationDefinition> node, ref int yOffset)
{
TransformationDefinition transformation = node.Current;
Texture2D texture = transformation.BuffType.GetTexture();
if (!CheckIfDraw(transformation))
{
return; // Needs edge-case check.
}
int xOffset = PADDING_X;
if (node.Parents.Length > 0 && _transformationImagePairs.ContainsKey(node.Parents[0].Current))
{
Node <TransformationDefinition> previousNode = node.Parents[0];
UIImagePair previousPair = _transformationImagePairs[previousNode.Current];
xOffset = _transformationImagePairs[previousNode.Current].position.X + (int)previousPair.button.Width.Pixels + SMALL_SPACE * 2;
}
DrawTransformation(transformation, texture, xOffset, yOffset);
for (int i = 0; i < node.Children.Count; i++)
{
Node <TransformationDefinition> child = node.Children[i];
RecursiveInitializeTransformation(child, ref yOffset);
if (node.Children.Count > 1 && CheckIfDraw(child) && node.Children[node.Children.Count - 1] != child)
{
yOffset += texture.Height + SMALL_SPACE * 2;
}
}
}
/// <summary>
/// Return the aura effect currently active on the player.
/// </summary>
/// <param name="modPlayer">The player being checked</param>
public static AuraAnimationInfo GetAuraEffectOnPlayer(this MyPlayer modPlayer)
{
TransformationDefinition transformation = modPlayer.GetCurrentTransformation();
if (modPlayer.ActiveTransformations.Count == 0)
{
return(null);
}
if (modPlayer.player.dead)
{
return(null);
}
if (transformation != null)
{
return(transformation.Appearance.auraAnimation);
}
if (modPlayer.isCharging)
{
return(AuraAnimations.createChargeAura);
}
return(null);
}
public override void PreUpdate()
{
TransformationDefinition transformation = GetCurrentTransformation();
if (transformation != null)
{
if (!player.armor[10].vanity && player.armor[10].headSlot == -1)
{
if (transformation.Appearance.hair != null && transformation.Appearance.hair.hairTexture != null)
{
hair = mod.GetTexture(transformation.Appearance.hair.hairTexture);
}
else
{
hair = null;
}
}
}
else
{
hair = null;
}
if (player.dead)
{
hair = null;
}
}
// TODO Remove this and make it unlock correctly.
public override void OnPlayerUnlockTransformation(MyPlayer player, TransformationDefinition transformation)
{
if (transformation == player.TransformationDefinitionManager.SSJ3Definition)
{
TryUnlock(player);
}
}
private static void TrySelectingTransformation(TransformationDefinition def, UIMouseEvent evt, UIElement listeningElement)
{
DBTPlayer dbtPlayer = Main.LocalPlayer.GetModPlayer <DBTPlayer>();
if (dbtPlayer.HasAcquiredTransformation(def) && def.DoesDisplayInCharacterMenu(dbtPlayer))
{
// TODO Add sounds.
//SoundHelper.PlayVanillaSound(SoundID.MenuTick);
if (!dbtPlayer.SelectedTransformations.Contains(def))
{
dbtPlayer.SelectTransformation(def);
Main.NewText($"Selected {def.DisplayName}, Mastery: {Math.Round(def.GetMaxMastery(dbtPlayer) * def.GetCurrentMastery(dbtPlayer), 2)}%");
}
else
{
Main.NewText($"{def.DisplayName} Mastery: {Math.Round(100f * def.GetCurrentMastery(dbtPlayer), 2)}%");
}
}
/*else if (def.SelectionRequirementsFailed.Invoke(player, def))
* {
* SoundHelper.PlayVanillaSound(SoundID.MenuClose);
*
* if (def.FailureText == null) return;
* Main.NewText(def.FailureText);
* }*/
}
private static void TrySelectingTransformation(TransformationDefinition def, UIMouseEvent evt, UIElement listeningElement)
{
MyPlayer player = Main.LocalPlayer.GetModPlayer <MyPlayer>();
if (def.DoesShowInMenu(player) && player.PlayerTransformations.ContainsKey(def) && def.MeetsSelectionRequirements(player))
{
SoundHelper.PlayVanillaSound(SoundID.MenuTick);
if (player.SelectedTransformation != def)
{
player.SelectedTransformation = def;
Main.NewText($"Selected {def.Text}, Mastery: {Math.Round(100f * def.GetPlayerMastery(player), 2)}%");
}
else
{
Main.NewText($"{def.Text} Mastery: {Math.Round(100f * def.GetPlayerMastery(player), 2)}%");
}
}
else if (def.SelectionRequirementsFailed.Invoke(player, def))
{
SoundHelper.PlayVanillaSound(SoundID.MenuClose);
if (def.FailureText == null)
{
return;
}
Main.NewText(def.FailureText);
}
}
private void DrawInfoPanel(TransformationDefinition def)
{
DBTPlayer dbtPlayer = Main.LocalPlayer.GetModPlayer <DBTPlayer>();
bool hasOverload = false;
if (!InfoPanelOpened)
{
InfoPanelOpened = true;
InfoPanel = InitializeImage(InfoPanelTexture, -12, 294, BackPanel);
InfoPanel.Width.Set(InfoPanelTexture.Width, 0f);
InfoPanel.Height.Set(InfoPanelTexture.Height, 0f);
if (def.GetUnmasteredOverloadGrowthRate(dbtPlayer) > 0)
{
hasOverload = true;
}
formName = InitializeText(def.DisplayName, 12, 8, 0.8f, def.Appearance.GeneralColor.Value, InfoPanel);
if (def.GetMasteredKiDrain(dbtPlayer) <= 0 && def.GetUnmasteredKiDrain(dbtPlayer) != 0)
{
formStats = InitializeText("Stats: \nDamage: " + (def.GetDamageMultiplier(dbtPlayer) - 1f) * 100 + "% \nSpeed: "
+ (def.GetSpeedMultiplier(dbtPlayer) - 1f) * 100 + "% \nKi Drain: " + def.GetUnmasteredKiDrain(dbtPlayer) * 60 + "/s"
+ (hasOverload ? "\nOverload: While Unmastered = " + def.GetUnmasteredOverloadGrowthRate(dbtPlayer) * 60
+ "/s + While Mastered = " + def.GetMasteredOverloadGrowthRate(dbtPlayer) * 60 + "/s" : null), 12, 28, 0.6f, Color.White, InfoPanel);
}
else
{
if (def.GetUnmasteredKiDrain(dbtPlayer) <= 0)
{
formStats = InitializeText("Stats: \nDamage: " + (def.GetDamageMultiplier(dbtPlayer) - 1f) * 100 + "% \nSpeed: " +
(def.GetSpeedMultiplier(dbtPlayer) - 1f) * 100 + "%" + (hasOverload ? "\nOverload: While Unmastered = " +
def.GetUnmasteredOverloadGrowthRate(dbtPlayer) * 60 + "/s + While Mastered = " +
def.GetMasteredOverloadGrowthRate(dbtPlayer) * 60 + "/s" : null), 12, 28, 0.6f, Color.White, InfoPanel);
}
else
{
formStats = InitializeText("Stats: \nDamage: " + (def.GetDamageMultiplier(dbtPlayer) - 1f) * 100 + "% \nSpeed: "
+ (def.GetSpeedMultiplier(dbtPlayer) - 1f) * 100 + "% \nKi Drain: While Unmastered = " + def.GetUnmasteredKiDrain(dbtPlayer) * 60
+ "/s + While Mastered = " + def.GetMasteredKiDrain(dbtPlayer) * 60 + "/s" + (hasOverload ? "\nOverload: While Unmastered = "
+ def.GetUnmasteredOverloadGrowthRate(dbtPlayer) * 60 + "/s + While Mastered = " + def.GetMasteredOverloadGrowthRate(dbtPlayer) * 60
+ "/s" : null), 12, 28, 0.6f, Color.White, InfoPanel);
}
}
formUnlock = InitializeText(def.DisplayName, 30, 16, 0f, Color.White, InfoPanel);
}
else
{
InfoPanel = null;
formName = null;
formStats = null;
formUnlock = null;
InfoPanelOpened = false;
DrawInfoPanel(def);
}
}
public bool CanTransform(TransformationDefinition transformation)
{
if (transformation == null || IsTransformBlocked() || IsExhaustedFromTransformation() || IsTransformedInto(transformation))
{
return(false);
}
return(transformation.CanTransformInto(this));
}
public void RemoveTransformation(TransformationDefinition transformation)
{
player.ClearBuff(transformation.GetBuffId());
if (!Main.dedServ && Main.netMode == NetmodeID.MultiplayerClient && player.whoAmI == Main.myPlayer)
{
NetworkHelper.formSync.SendFormChanges(256, player.whoAmI, player.whoAmI, transformation.UnlocalizedName, 0);
}
}
public void Acquire(TransformationDefinition definition)
{
if (AcquiredTransformations.ContainsKey(definition))
{
return;
}
AcquiredTransformations.Add(definition, new PlayerTransformation(definition));
definition.OnPlayerAcquiredTransformation(this);
}
public void SelectTransformation(TransformationDefinition transformation)
{
if (!TryCombiningTransformations(transformation))
{
SelectedTransformations.Clear();
SelectedTransformations.Add(transformation);
}
else
{
SelectedTransformations.Add(transformation);
}
}
public bool HasAcquiredTransformation(TransformationDefinition definition)
{
for (int i = 0; i < AcquiredTransformations.Count; i++)
{
if (AcquiredTransformations.ContainsKey(definition))
{
return(true);
}
}
return(false);
}
public bool IsTransformed(TransformationDefinition definition)
{
for (int i = 0; i < ActiveTransformations.Count; i++)
{
if (ActiveTransformations.Contains(definition))
{
return(true);
}
}
return(false);
}
public void Untransform(TransformationDefinition definition)
{
for (int i = ActiveTransformations.Count - 1; i >= 0; i--)
{
TransformationDefinition transformation = ActiveTransformations[i];
if (transformation == definition)
{
ActiveTransformations.Remove(transformation);
player.ClearBuff(mod.GetBuff(definition.BuffType.Name).Type);
}
}
}
internal void LoadMasteryEntry(KeyValuePair <string, object> kvp)
{
if (kvp.Key.StartsWith(PlayerTransformation.MASTERY_PREFIX))
{
TransformationDefinition transformation = TransformationDefinitionManager.Instance[kvp.Key.Substring(PlayerTransformation.MASTERY_PREFIX.Length)];
if (AcquiredTransformations.ContainsKey(transformation))
{
return;
}
AcquiredTransformations.Add(transformation, new PlayerTransformation(transformation, float.Parse(kvp.Value.ToString())));
}
}
public static void DrawLayer(PlayerDrawInfo drawInfo)
{
if (Main.netMode == NetmodeID.Server)
{
return;
}
DBTPlayer modPlayer = drawInfo.drawPlayer.GetModPlayer <DBTPlayer>();
TransformationDefinition transformation = modPlayer.ActiveTransformations.FirstOrDefault();
int frame = modPlayer.TailFrameTimer / 8;
Color tailColor = Color.White;
float XOffset;
SpriteEffects spriteEffects;
if (drawInfo.drawPlayer.direction == 1)
{
spriteEffects = SpriteEffects.None;
XOffset = 3f;
}
else
{
spriteEffects = SpriteEffects.FlipHorizontally;
XOffset = 1.8f;
}
if (transformation != null)
{
if (modPlayer.IsTransformed(TransformationDefinitionManager.Instance.SSJ4) || modPlayer.IsTransformed(TransformationDefinitionManager.Instance.SSJ4FP))
{
tailColor = new Color(224, 51, 66);
}
else
{
tailColor = transformation.Appearance.Hair.Color.Value;
}
}
else
{
tailColor = drawInfo.drawPlayer.hairColor;
}
Color color = Lighting.GetColor((int)drawInfo.drawPlayer.position.X / 16, (int)drawInfo.drawPlayer.position.Y / 16, tailColor);
//Color trueTailColor = new Color(tailColor.R, tailColor.G, tailColor.B, alpha.A);
Texture2D texture = DBTMod.Instance.GetTexture("Effects/PrimalTail");
int frameSize = texture.Height / 14;
float drawX = (drawInfo.position.X + drawInfo.drawPlayer.width / XOffset - Main.screenPosition.X);
float drawY = (drawInfo.position.Y + drawInfo.drawPlayer.height / 0.11f - Main.screenPosition.Y);
Main.spriteBatch.Draw(texture, new Vector2(drawX, drawY), new Rectangle(0, frameSize * frame, texture.Width, frameSize), color, drawInfo.drawPlayer.bodyRotation, new Vector2(texture.Width / 2f, texture.Height / 2f), 1f, spriteEffects, 0);
}
/*private float overloadHealthChange = 1f;
* public void HandleOverloadHealthChange()
* {
* if (IsOverloading())
* {
* overloadHealthChange = Main.rand.NextFloat(0.3f, 1.5f);
* player.statLifeMax2 = (int)Math.Ceiling(player.statLifeMax2 * overloadHealthChange);
* }
* }*/
public override void PreUpdate()
{
TransformationDefinition transformation = GetCurrentTransformation();
if (transformation != null)
{
if (!player.armor[10].vanity && player.armor[10].headSlot == -1)
{
if (!IsPlayerTransformed())
{
hair = mod.GetTexture("Hairs/Base/BaseHair" + ssjHairStyles[HairAppearance.BASE_HAIRSTYLE_KEY]);
}
else
{
if (transformation.Appearance.hair != null && transformation.Appearance.hair.hairTexture != null && transformation.Appearance.hair.hairName != null)
{
int hairStyleId = 1;
if (ssjHairStyles.ContainsKey(transformation.Appearance.hair.hairName))
{
hairStyleId = ssjHairStyles[transformation.Appearance.hair.hairName];
}
hair = mod.GetTexture(transformation.Appearance.hair.hairTexture + hairStyleId);
}
else
{
hair = null;
}
}
}
}
else
{
hair = mod.GetTexture("Hairs/Base/BaseHair" + ssjHairStyles[HairAppearance.BASE_HAIRSTYLE_KEY]);
}
if (player.dead)
{
hair = mod.GetTexture("Hairs/Base/BaseHair" + ssjHairStyles[HairAppearance.BASE_HAIRSTYLE_KEY]);
}
if (transformation == null || player.dead)
{
hairColor = player.hairColor;
}
else
{
hairColor = Color.White;
}
}
public void Transform(TransformationDefinition definition)
{
for (int i = 0; i < ActiveTransformations.Count; i++)
{
if (ActiveTransformations[i] == definition)
{
return;
}
}
ActiveTransformations.Add(definition);
player.AddBuff(mod.GetBuff(definition.BuffType.Name).Type, definition.Duration);
if (Main.netMode == NetmodeID.MultiplayerClient && player.whoAmI == Main.myPlayer)
{
NetworkPacketManager.Instance.PlayerTransformedPacket.SendPacketToServer(player.whoAmI, (byte)player.whoAmI, definition.UnlocalizedName);
}
}
public void Transform(TransformationDefinition definition)
{
for (int i = 0; i < ActiveTransformations.Count; i++)
{
if (ActiveTransformations[i] == definition)
{
return;
}
}
ActiveTransformations.Add(definition);
player.AddBuff(mod.GetBuff(definition.BuffType.Name).Type, definition.Duration);
if (player.whoAmI == Main.myPlayer)
{
new PlayerTransformedPacket(definition).Send();
}
}
public void AddTransformation(TransformationDefinition transformation, int duration)
{
player.AddBuff(transformation.GetBuffId(), duration, false);
ActiveTransformations.Add(transformation);
transformation.OnPlayerTransformed(this);
if (!string.IsNullOrWhiteSpace(transformation.Text))
{
CombatText.NewText(player.Hitbox, transformation.TextColor, transformation.Text, false, false);
}
if (!Main.dedServ && Main.netMode == NetmodeID.MultiplayerClient && player.whoAmI == Main.myPlayer)
{
NetworkHelper.formSync.SendFormChanges(256, player.whoAmI, player.whoAmI, transformation.UnlocalizedName, duration);
}
isTransformationAnimationPlaying = true;
}
public void Untransform(TransformationDefinition definition)
{
for (int i = ActiveTransformations.Count - 1; i >= 0; i--)
{
TransformationDefinition transformation = ActiveTransformations[i];
if (transformation == definition)
{
ActiveTransformations.Remove(transformation);
if (player.whoAmI == Main.myPlayer)
{
new PlayerUntransformedPacket(transformation).Send();
}
player.ClearBuff(mod.GetBuff(definition.BuffType.Name).Type);
}
}
}
private static void TrySelectingTransformation(TransformationDefinition def, UIMouseEvent evt, UIElement listeningElement)
{
DBTPlayer dbtPlayer = Main.LocalPlayer.GetModPlayer <DBTPlayer>();
if (def.CheckPrePlayerConditions() && dbtPlayer.HasAcquiredTransformation(def) && def.BaseConditions(dbtPlayer))
{
// TODO Add sounds.
//SoundHelper.PlayVanillaSound(SoundID.MenuTick);
if (!dbtPlayer.SelectedTransformations.Contains(def))
{
dbtPlayer.SelectTransformation(def);
Main.NewText($"Selected {def.DisplayName}, Mastery: {Math.Round(def.GetMaxMastery(dbtPlayer) * def.GetCurrentMastery(dbtPlayer), 2)}%");
}
else
{
Main.NewText($"{def.DisplayName} Mastery: {Math.Round(100f * def.GetCurrentMastery(dbtPlayer), 2)}%");
}
}
}
private void DrawTransformation(TransformationDefinition transformation, Texture2D icon, int left, int top)
{
UIImageButton transformationButton = null;
UIImage
unknownImage = null,
unknownGrayImage = null,
lockedImage = null;
transformationButton = InitializeButton(icon, new MouseEvent((evt, element) => TrySelectingTransformation(transformation, evt, element)), left, top, BackPanelImage);
unknownImage = InitializeImage(_unknownImageTexture, 0, 0, transformationButton);
unknownImage.ImageScale = 0f;
unknownGrayImage = InitializeImage(_unknownGrayImageTexture, 0, 0, unknownImage);
unknownGrayImage.ImageScale = 0f;
lockedImage = InitializeImage(_lockedImageTexture, 0, 0, unknownGrayImage);
lockedImage.ImageScale = 0f;
_transformationImagePairs.Add(transformation, new UIImagePair(new Point(left, top), transformationButton, unknownImage, unknownGrayImage, lockedImage));
}
public void DoTransform(TransformationDefinition transformation)
{
// don't.. try to apply the same transformation. This just stacks projectile auras and looks dumb.
if (IsTransformedInto(transformation))
{
return;
}
// make sure to swap kaioken with super kaioken when appropriate.
if (transformation == TransformationDefinitionManager.SuperKaiokenDefinition)
{
RemoveTransformation(TransformationDefinitionManager.KaiokenDefinition);
}
// remove all *transformation* buffs from the player.
// this needs to know we're powering down a step or not
EndTransformations();
// add whatever buff it is for a really long time.
AddTransformation(transformation, transformation.Duration);
}
public void ChangeMastery(TransformationDefinition definition, float change)
{
PlayerTransformation playerTransformation = AcquiredTransformations[definition];
float maxMastery = playerTransformation.Definition.GetMaxMastery(this);
if (playerTransformation.CurrentMastery >= maxMastery)
{
return;
}
if (playerTransformation.CurrentMastery + change > maxMastery)
{
change = maxMastery - playerTransformation.CurrentMastery;
}
if (Trait != null)
{
Trait.OnPlayerMasteryGained(this, ref change, playerTransformation.CurrentMastery);
}
playerTransformation.ChangeMastery(this, change);
definition.OnPlayerMasteryChanged(this, change, playerTransformation.CurrentMastery);
}
public void GainMastery(TransformationDefinition definition, float gain)
{
PlayerTransformation playerTransformation = AcquiredTransformations[definition];
float maxMastery = playerTransformation.Definition.GetMaxMastery(this);
if (playerTransformation.CurrentMastery >= maxMastery)
{
return;
}
if (playerTransformation.CurrentMastery + gain > maxMastery)
{
gain = maxMastery - playerTransformation.CurrentMastery;
}
if (Trait != null)
{
Trait.OnPlayerMasteryGained(this, ref gain, playerTransformation.CurrentMastery);
}
playerTransformation.CurrentMastery += gain;
definition.OnPlayerMasteryGain(this, gain, playerTransformation.CurrentMastery);
}
public override void ModifyDrawInfo(ref PlayerDrawInfo drawInfo)
{
// TODO Add logistics into TransformationDefinition class.
TransformationDefinition transformation = GetCurrentTransformation();
if (transformation == null)
{
if (originalEyeColor.HasValue && player.eyeColor != originalEyeColor.Value)
{
player.eyeColor = originalEyeColor.Value;
}
return;
}
if (transformation.Appearance.hair == null)
{
return;
}
ReadOnlyColor hairColor = transformation.Appearance.hair.hairColor;
if (hairColor != null)
{
drawInfo.hairColor = hairColor;
}
if (transformation.Appearance.hair.hairShader.HasValue)
{
drawInfo.hairShader = 1;
}
if (transformation.Appearance.eyeColor != null)
{
ChangeEyeColor(transformation.Appearance.eyeColor.Value);
}
}
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
DBTPlayer dbtPlayer = Main.LocalPlayer.GetModPlayer <DBTPlayer>();
foreach (KeyValuePair <TransformationDefinition, UIImagePair> kvp in _transformationImagePairs)
{
TransformationDefinition definition = kvp.Key;
bool canAcquire = definition.CheckPrePlayerConditions() && definition.BaseConditions(dbtPlayer);
bool currentlyUnlockable = kvp.Key.CanUnlock(dbtPlayer);
bool visible = kvp.Key.DoesDisplayInCharacterMenu(dbtPlayer);
bool unlocked = dbtPlayer.HasAcquiredTransformation(kvp.Key);
if (!canAcquire || !visible)
{
kvp.Value.button.Width = StyleDimension.Empty;
kvp.Value.button.Height = StyleDimension.Empty;
kvp.Value.button.SetVisibility(0f, 0f);
}
if (canAcquire)
{
kvp.Value.unknownImage.ImageScale = !visible ? 0f : (!currentlyUnlockable ? 0f : (unlocked ? 0f : 1f));
kvp.Value.unknownImageGray.ImageScale = !visible ? 0f : currentlyUnlockable && dbtPlayer.HasAcquiredTransformation(kvp.Key) ? 0f : 1f;
kvp.Value.lockedImage.ImageScale = !visible ? 0f : unlocked || currentlyUnlockable ? 0f : 1f;
}
}
// Disabled as it crashes with SpriteBatch.
/*for (int i = 0; i < _polyLinesToDraw.Count; i++)
* if (_polyLinesToDraw[i].Length > 1)
* Main.spriteBatch.DrawPolyLine(_polyLinesToDraw[i], Color.White);*/
}
