public void SetCharacterRenderer(CharacterRenderer rend)
{
m_rend = rend;
//update draw location
Rectangle rendRect = rend.DrawAreaWithOffset;
DrawLocation = new Vector2(rendRect.Right + 20, rendRect.Y + rend.TopPixel);
if (DrawAreaWithOffset.Right > Game.GraphicsDevice.PresentationParameters.BackBufferWidth - 15)
{
//case: goes off the right side of the screen, show on the left
DrawLocation = new Vector2(rendRect.X - DrawArea.Width - 20, drawLocation.Y);
}
//MAGIC NUMBER: 308px is the bottom of the display area for map stuff
if (DrawAreaWithOffset.Bottom > 308)
{
//case: goes off bottom of the screen, adjust new rectangle so it is above 308
DrawLocation = new Vector2(drawLocation.X, 298 - DrawArea.Height);
}
else if (DrawAreaWithOffset.Y < 25)
{
//case: goes off top of screen, adjust new rectangle so it aligns with top of character head
DrawLocation = new Vector2(drawLocation.X, 35);
}
EOGame.Instance.Hud.SetStatusLabel(DATCONST2.STATUS_LABEL_TYPE_ACTION, DATCONST2.STATUS_LABEL_MENU_BELONGS_TO_PLAYER, m_rend.Character.Name);
Visible = true;
}
// TestData - Should be based on name not slot
CharacterRenderer CreateRendererBySlot(int slot)
{
switch (slot)
{
case 0:
return(CharacterRenderer.CreateNormalSized("data/characters/chara6.png", 21, true));
case 1:
return(CharacterRenderer.CreateNormalSized("data/characters/chara7.png", 15, true));
case 2:
return(CharacterRenderer.CreateNormalSized("data/characters/chara2.png", 12, false));
case 3:
return(CharacterRenderer.CreateNormalSized("data/characters/chara2.png", 69, false));
case 4:
return(CharacterRenderer.CreateNormalSized("data/characters/chara2.png", 21, false));
case 5:
return(CharacterRenderer.CreateExtraLarge("data/characters/$monster_bird1.png", 0));
default:
throw new NotImplementedException();
}
}
CharacterRenderer CreateRenderer(Character c)
{
CharacterRenderer renderer = CreateRendererBySlot(c.Slot);
Cache [c.Name] = renderer;
return(renderer);
}
public void Apply(CharacterRenderer _renderer)
{
var _datas = new List <CharacterSkinPart> {
head,
body,
mainArm,
subArm,
mainLeg,
subLeg,
};
var _rendererDictionary = new Dictionary <CharacterSkinPart, SpriteRenderer> {
{ head, _renderer.head },
{ body, _renderer.body },
{ mainArm, _renderer.mainArm },
{ subArm, _renderer.subArm },
{ mainLeg, _renderer.mainLeg },
{ subLeg, _renderer.subLeg },
};
foreach (var _data in _datas)
{
Apply(_rendererDictionary[_data], _data);
}
}
void AddToList(GameObject[] gameObjects, List <CharacterRenderer> _unsortedCharacterRenderers)
{
for (int i = 0; i < gameObjects.Length; i++)
{
CharacterRenderer characterRenderer = gameObjects[i].GetComponent <CharacterRenderer>();
_unsortedCharacterRenderers.Add(characterRenderer);
}
}
CharacterRenderer CreateRenderer(Character c)
{
string key = GetKey(c);
CharacterRenderer renderer = CreateRendererByClass(key);
Cache [key] = renderer;
return(renderer);
}
public void Awake()
{
rigidBody = GetComponent <Rigidbody2D>();
renderer = GetComponentInChildren <CharacterRenderer>();
attack = GetComponent <Attack>();
dying = GetComponent <Dying>();
soundPlayer = GetComponentInChildren <CharacterSoundsPlayer>();
}
public EOChatBubble(CharacterRenderer following)
: base(EOGame.Instance)
{
m_ref = following;
m_isChar = true;
DrawOrder = following.Character.ID + (int)ControlDrawLayer.BaseLayer + 1; //use ID for draw order
_initLabel();
Visible = false;
EOGame.Instance.Components.Add(this);
}
public void move(CharTmpl chars, CharacterRenderer newRend, SpriteRenderer rend, Transform where)
{
if (Input.anyKeyDown)
{
if (Input.GetMouseButtonDown(0))
{
where.position = new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0);
}
}
}
void OnTriggerExit2D(Collider2D collider)
{
if (collider.GetComponent <CharacterRenderer>() && collider.GetType() == typeof(CapsuleCollider2D))
{
print("exit");
CharacterRenderer renderer = collider.GetComponent <CharacterRenderer>();
renderer.RemoveLight(this);
renderer.RemoveShadow(this);
}
}
void OnTriggerEnter2D(Collider2D collider)
{
print(name);
if (collider.GetComponent <CharacterRenderer>() && collider.GetType() == typeof(CapsuleCollider2D))
{
print("enter");
CharacterRenderer renderer = collider.GetComponent <CharacterRenderer>();
renderer.AddLight(this);
renderer.CreateShadow(this, shadowPrefab);
}
}
private void Start()
{
Marth = new CharTmpl(charName, charClass);
rend = new CharacterRenderer(sprite);
rends = gameObject.AddComponent <SpriteRenderer>();
var wheres = gameObject.GetComponent <Transform>();
rend.firstRender(sprite, rends);
wheres.position = new Vector2(0, 0);
wheres.localScale = (new Vector2((float)0.61, (float)0.51));
}
public static void MinimumSort(LayerMask layerMask)
{
// Declare the object array and the array of sorted characters
float visionRadius = 20f;
Collider2D[] unsortedColliders = Physics2D.OverlapCircleAll(Camera.main.transform.position, visionRadius, layerMask);
List <CharacterRenderer> unsortedCharacterRenderers = new List <CharacterRenderer>();
for (int i = 0; i < unsortedColliders.Length; i++)
{
Collider2D collider = unsortedColliders[i];
if (collider.GetComponent <CharacterRenderer>() && collider.GetType() == typeof(CapsuleCollider2D))
{
unsortedCharacterRenderers.Add(collider.GetComponent <CharacterRenderer>());
}
}
List <float> unsortedCharacterDepths = new List <float>();
for (int i = 0; i < unsortedCharacterRenderers.Count; i++)
{
CharacterRenderer characterRenderer = unsortedCharacterRenderers[i];
unsortedCharacterDepths.Add(characterRenderer.depth);
}
List <CharacterRenderer> sortedCharacterRenderers = new List <CharacterRenderer>();
while (unsortedCharacterDepths.Count > 0)
{
int numCharacters = unsortedCharacterRenderers.Count;
for (int i = 0; i < numCharacters; i++)
{
CharacterRenderer characterRenderer = unsortedCharacterRenderers[i];
if (characterRenderer.depth == unsortedCharacterDepths.Max())
{
sortedCharacterRenderers.Add(characterRenderer);
unsortedCharacterRenderers.Remove(characterRenderer);
unsortedCharacterDepths.Remove(unsortedCharacterDepths.Max());
break;
}
}
}
for (int i = 0; i < sortedCharacterRenderers.Count; i++)
{
//print(characterRenderers[i].name + ", " + i.ToString());
sortedCharacterRenderers[i].spriteRenderer.sortingOrder = i;
}
}
private void Start()
{
characterRenderer = GetComponentInChildren <CharacterRenderer>();
previousPosX = transform.position.x;
Agent = GetComponent <NavMeshAgent>();
Agent.updateRotation = false;
Agent.updateUpAxis = false;
if (!isServer)
{
return;
}
Animator = GetComponent <Animator>();
PositionDatas = FindObjectOfType <PNJPositionDatas>();
ChangeState(new PNJMoveState(this, PositionDatas.GetPosition()));
}
// Start is called before the first frame update
void Awake()
{
Dead = InitiallyDead;
var animator = GetComponent <Animator>();
renderer = GetComponent <CharacterRenderer>();
selection = GetComponent <UnitSelection>();
dyingAnimation = new ActionAnimation(animator, renderer, "Dying", 0.5f);
soundPlayer = GetComponentInChildren <CharacterSoundsPlayer>();
movement = GetComponent <CharacterMovement>();
switchOffAbleComponents = new ComponentsSet(this,
"Attack",
"CharacterMovement",
"ClickCatching",
"UnitSelection",
"Navigator");
}
/* --- Methods --- */
public static void InsertSort()
{
// Declare the object array and the array of sorted characters
GameObject[] characters = GameObject.FindGameObjectsWithTag("Character");
List <CharacterRenderer> characterRenderers = new List <CharacterRenderer>();
// There is no need to sort if there is less than two characters
if (characters.Length < 2)
{
return;
}
// Add the first input into the characters array
characterRenderers.Add(characters[0].GetComponent <CharacterRenderer>());
// Itterate through the rest of the list
for (int i = 1; i < characters.Length; i++)
{
CharacterRenderer characterRenderer = characters[i].GetComponent <CharacterRenderer>();
bool inserted = false;
for (int j = 0; j < characterRenderers.Count; j++)
{
// The larger the depth, the further behind the character is
if (characterRenderer.depth > characters[j].GetComponent <CharacterRenderer>().depth)
{
characterRenderers.Insert(j, characterRenderer);
inserted = true;
break;
}
}
if (!inserted)
{
characterRenderers.Add(characterRenderer);
}
}
for (int i = 0; i < characterRenderers.Count; i++)
{
print(characterRenderers[i].name + ", " + i.ToString());
characterRenderers[i].spriteRenderer.sortingOrder = i;
}
}
public ActionAnimation(Animator a, CharacterRenderer cr, string name, float maxLength)
{
animator = a;
renderer = cr;
ActionName = name;
AnimationInProgress = false;
string animationPrefix = renderer.PreparedAnimationPrefix;
maxAnimationLength = maxLength;
directions = new string[]
{
$"{animationPrefix}{ActionName} N",
$"{animationPrefix}{ActionName} NE",
$"{animationPrefix}{ActionName} E",
$"{animationPrefix}{ActionName} SE",
$"{animationPrefix}{ActionName} S",
$"{animationPrefix}{ActionName} SW",
$"{animationPrefix}{ActionName} W",
$"{animationPrefix}{ActionName} NW"
};
}
void Awake()
{
m_Hp = GetComponent <HasHP>();
m_Hp.hp = hpMax;
m_Hp.postDead = Die;
// components
m_Renderers = GetComponent <CharacterRenderer> ();
m_Animator = GetComponent <Animator>();
m_NetworkAnimator = GetComponent <NetworkAnimator>();
m_InterpolatePosition = gameObject.AddComponent <InterpolatePosition>();
// detector
crateDetector.doObtain = Obtain;
damageDetector.doDamage = Hit;
terrainDetector.postDetect = (Collision) =>
{
m_Floating = false;
terrainDetector.gameObject.SetActive(false);
};
}
/// <summary>
/// Rendert die Spielelemente der aktuellen Szene
/// </summary>
private void RenderItems(Area area, Point offset, GameTime gameTime)
{
// Items von hinten nach vorne rendern
foreach (var item in area.Items.OrderBy(i => i.Position.Y))
{
// Renderer ermitteln und ggf. neu erzeugen
ItemRenderer renderer;
if (!itemRenderer.TryGetValue(item, out renderer))
{
// ACHTUNG: Hier können potentiell neue Items nachträglich hinzu kommen zu denen die Textur noch fehlt
// Das muss geprüft und ggf nachgeladen werden.
Texture2D texture = GetItemTexture(item.Texture);
if (item is Character)
{
renderer = new CharacterRenderer(item as Character, Camera, texture, font);
}
else
{
renderer = new SimpleItemRenderer(item, Camera, texture, font);
}
itemRenderer.Add(item, renderer);
}
// Ermitteln, ob Item im Interaktionsbereich ist
bool highlight = false;
if (item is IInteractable && game.Local.Player.InteractableItems.Contains(item as IInteractable) ||
item is IAttackable && game.Local.Player.AttackableItems.Contains(item as IAttackable))
{
highlight = true;
}
// Item rendern
renderer.Draw(spriteBatch, offset, gameTime, highlight);
}
// TODO: Nicht mehr verwendete Renderer entfernen
}
CharacterRenderer CreateRendererByClass(string characterClass)
{
switch (characterClass)
{
case "Mage":
return(CharacterRenderer.CreateNormalSized("data/characters/chara6.png", 21, true));
case "Thief":
return(CharacterRenderer.CreateNormalSized("data/characters/chara2.png", 21, false));
case "Monster-Imp":
return(CharacterRenderer.CreateExtraLargeAndTall("data/characters/elemental.png", 3));
case "Monster-Bear":
return(CharacterRenderer.CreateSquare("data/animals/animals5.png", 75));
case "Monster-Dark Knight":
return(CharacterRenderer.CreateFourByThree("data/characters/$monster_dknight2.png", 6));
default:
throw new NotImplementedException();
}
}
public void Apply(CharacterRenderer _renderer)
{
var _datas = new List<CharacterSkinPart> {
head,
body,
mainArm,
subArm,
mainLeg,
subLeg,
};
var _rendererDictionary = new Dictionary<CharacterSkinPart, SpriteRenderer> {
{ head, _renderer.head },
{ body, _renderer.body },
{ mainArm, _renderer.mainArm },
{ subArm, _renderer.subArm },
{ mainLeg, _renderer.mainLeg },
{ subLeg, _renderer.subLeg },
};
foreach (var _data in _datas )
Apply(_rendererDictionary[_data], _data);
}
public void AddOtherPlayer(CharacterData c, WarpAnimation anim = WarpAnimation.None)
{
CharacterRenderer otherRend = null;
lock (_rendererListLock)
{
Character other = otherRenderers.Select(x => x.Character).FirstOrDefault(x => x.Name == c.Name && x.ID == c.ID);
if (other == null)
{
other = new Character(m_api, c);
lock (_rendererListLock)
{
otherRenderers.Add(otherRend = new CharacterRenderer(other));
otherRenderers[otherRenderers.Count - 1].Visible = true;
otherRenderers[otherRenderers.Count - 1].Initialize();
}
other.RenderData.SetUpdate(true);
}
else
{
other.ApplyData(c);
}
}
if (anim == WarpAnimation.Admin && otherRend != null)
{
var effectRenderer = new EffectRenderer((EOGame) Game, otherRend, delegate { });
effectRenderer.SetEffectInfoTypeAndID(EffectType.WarpDestination, 0);
effectRenderer.ShowEffect();
}
}
private void _renderSpellOnPlayer(short spellID, CharacterRenderer renderer)
{
if (spellID < 1) return;
var spellInfo = World.Instance.ESF.GetSpellRecordByID(spellID);
var effect = new EffectRenderer((EOGame)Game, renderer, delegate { });
effect.SetEffectInfoTypeAndID(EffectType.Spell, spellInfo.Graphic);
effect.ShowEffect();
}
public override void LoadContent()
{
characterRenderer = new CharacterRenderer(spriteBatch);
}
private void Awake()
{
rbody = GetComponent <Rigidbody2D>();
isoRenderer = GetComponentInChildren <CharacterRenderer>();
target = rbody.position;
}
public void SetRenderer(CharacterRenderer _characterRenderer)
{
characterRenderer = _characterRenderer;
}
private void Awake()
{
m_Renderer = GetComponent <CharacterRenderer>();
m_Renderer.Manager = this;
}
private void Awake()
{
isoRenderer = GetComponentInChildren <CharacterRenderer>();
}
public EOCreateCharacterDialog(Texture2D cursorTexture, KeyboardDispatcher dispatcher)
{
bgTexture = ((EOGame)Game).GFXManager.TextureFromResource(GFXTypes.PreLoginUI, 20);
_setSize(bgTexture.Width, bgTexture.Height);
charCreateSheet = ((EOGame)Game).GFXManager.TextureFromResource(GFXTypes.PreLoginUI, 22);
inputBox = new XNATextBox(new Rectangle(80, 57, 138, 19), cursorTexture, Constants.FontSize08)
{
LeftPadding = 5,
DefaultText = " ",
MaxChars = 12,
Selected = true,
TextColor = Constants.LightBeigeText,
Visible = true
};
inputBox.SetParent(this);
dispatcher.Subscriber = inputBox;
//four arrow buttons
for (int i = 0; i < arrowButtons.Length; ++i)
{
XNAButton btn = new XNAButton(charCreateSheet, new Vector2(196, 85 + i * 26), new Rectangle(185, 38, 19, 19), new Rectangle(206, 38, 19, 19))
{
Visible = true
};
btn.OnClick += ArrowButtonClick;
btn.SetParent(this);
arrowButtons[i] = btn;
}
charRender = new CharacterRenderer(new Vector2(269, 83), new CharRenderData { gender = 0, hairstyle = 1, haircolor = 0, race = 0 });
charRender.SetParent(this);
srcRects[0] = new Rectangle(0, 38, 23, 19);
srcRects[1] = new Rectangle(0, 19, 23, 19);
srcRects[2] = new Rectangle(0, 0, 23, 19);
srcRects[3] = new Rectangle(46, 38, 23, 19);
//ok/cancel buttons
XNAButton ok = new XNAButton(smallButtonSheet, new Vector2(157, 195), _getSmallButtonOut(SmallButton.Ok), _getSmallButtonOver(SmallButton.Ok))
{
Visible = true
};
ok.OnClick += (s, e) =>
{
if (inputBox.Text.Length < 4)
{
EOMessageBox.Show(DATCONST1.CHARACTER_CREATE_NAME_TOO_SHORT);
return;
}
Close(ok, XNADialogResult.OK);
};
ok.SetParent(this);
dlgButtons.Add(ok);
XNAButton cancel = new XNAButton(smallButtonSheet, new Vector2(250, 195), _getSmallButtonOut(SmallButton.Cancel), _getSmallButtonOver(SmallButton.Cancel))
{
Visible = true
};
cancel.OnClick += (s, e) => Close(cancel, XNADialogResult.Cancel);
cancel.SetParent(this);
dlgButtons.Add(cancel);
endConstructor();
}
public EffectRenderer(INativeGraphicsManager gfxManager,
CharacterRenderer character,
Action cleanupAction = null)
: this(gfxManager, (DrawableGameComponent)character, cleanupAction) { }
public void ShowContextMenu(CharacterRenderer player)
{
m_contextMenu.SetCharacterRenderer(player);
}
void Awake () {
m_Hp = GetComponent<HasHP>();
m_Hp.hp = hpMax;
m_Hp.postDead = Die;
// components
m_Renderers = GetComponent<CharacterRenderer> ();
m_Animator = GetComponent<Animator>();
m_NetworkAnimator = GetComponent<NetworkAnimator>();
m_InterpolatePosition = gameObject.AddComponent<InterpolatePosition>();
// detector
crateDetector.doObtain = Obtain;
damageDetector.doDamage = Hit;
terrainDetector.postDetect = (Collision) =>
{
m_Floating = false;
terrainDetector.gameObject.SetActive(false);
};
}
public EffectRenderer(EOGame game, CharacterRenderer character, Action cleanupAction)
: this(game, (DrawableGameComponent)character, cleanupAction) { }
private void DrawTarget(CharacterRenderer character)
{
character.Draw(_sb, true);
}
// Start is called before the first frame update
void Start()
{
isoRenderer = GetComponentInChildren <CharacterRenderer>();
}
private void _spikeDamageShared(CharacterRenderer rend, int damageAmount, int percentHealth, bool isPlayerDead)
{
rend.SetDamageCounterValue(damageAmount, percentHealth);
if (isPlayerDead)
rend.Die();
}
public void AddOtherPlayer(CharacterData c, WarpAnimation anim = WarpAnimation.None)
{
CharacterRenderer otherRend = null;
lock (_characterListLock)
{
Character other = _characterRenderers.Select(x => x.Character).FirstOrDefault(x => x.Name == c.Name && x.ID == c.ID);
if (other == null)
{
other = new Character(_api, c);
lock (_characterListLock)
{
_characterRenderers.Add(otherRend = new CharacterRenderer(other));
_characterRenderers[_characterRenderers.Count - 1].Visible = true;
_characterRenderers[_characterRenderers.Count - 1].Initialize();
}
other.RenderData.SetUpdate(true);
}
else
{
other.ApplyData(c);
}
}
if (anim == WarpAnimation.Admin && otherRend != null)
otherRend.ShowWarpArrive();
}
private Rectangle GetTargetRectangle(CharacterRenderer character)
{
//Because the rendering code is terrible, the character rectangle needs an additional offset
var rect = character.DrawAreaWithOffset;
rect.Offset(6, 11);
return rect;
}
private void _renderSpellOnPlayer(short spellID, CharacterRenderer renderer)
{
if (spellID < 1) return;
var spellInfo = World.Instance.ESF.GetSpellRecordByID(spellID);
renderer.ShowSpellAnimation(spellInfo.Graphic);
}
public void ResetGameElements()
{
if (m_mapRender != null)
{
m_mapRender.Dispose();
m_mapRender = null;
}
if (m_charRender != null)
{
m_charRender.Dispose();
m_charRender = null;
}
if(MapCache != null) MapCache.Clear();
}
private void doShowCharacters()
{
//remove any existing character renderers
var toRemove = Components.OfType<CharacterRenderer>();
foreach (CharacterRenderer eor in toRemove)
eor.Close();
//show the new data
CharacterRenderer[] render = new CharacterRenderer[World.Instance.MainPlayer.CharData.Length];
for (int i = 0; i < World.Instance.MainPlayer.CharData.Length; ++i)
render[i] = new CharacterRenderer(new Vector2(395, 60 + i * 124), World.Instance.MainPlayer.CharData[i]);
}
