public MapObjectGround(int tileID, Position3D position)
: base(position)
{
ItemID = tileID;
m_normals = new Vector3[4];
SortThreshold = -1;
SortTiebreaker = -1;
// set no draw flag
m_noDraw = (ItemID < 3 || (ItemID >= 0x1AF && ItemID <= 0x1B5));
// get draw data
UltimaData.LandData landData = UltimaData.TileData.LandData[ItemID & 0x3FFF];
if (landData.TextureID <= 0)
{
m_draw_3DStretched = false;
m_draw_texture = UltimaData.ArtData.GetLandTexture(ItemID);
m_draw_width = m_draw_height = 44;
m_draw_X = 0;
m_draw_Y = (int)(Z * 4);
m_draw_hue = Vector2.Zero;
m_pickType = PickTypes.PickGroundTiles;
m_draw_flip = false;
}
else
{
m_draw_3DStretched = true;
m_draw_texture = UltimaData.TexmapData.GetTexmapTexture(landData.TextureID);
}
// set pick type
m_pickType = PickTypes.PickGroundTiles;
}
public MapObjectDynamic(DynamicObject entity, Position3D position, int itemID, int frame, int hue, bool useGumpArt)
: base(position)
{
OwnerEntity = entity;
ItemID = itemID;
m_frame = frame;
// set up draw variables
if (useGumpArt)
{
m_draw_texture = UltimaData.GumpData.GetGumpXNA(ItemID + frame);
m_draw_width = m_draw_texture.Width;
m_draw_height = m_draw_texture.Height;
m_draw_X = (m_draw_width >> 1);
m_draw_Y = (int)(Z * 4) + m_draw_height - 22;
}
else
{
m_draw_texture = UltimaData.ArtData.GetStaticTexture(ItemID + frame);
m_draw_width = m_draw_texture.Width;
m_draw_height = m_draw_texture.Height;
m_draw_X = (m_draw_width >> 1) - 22;
m_draw_Y = (int)(Z * 4) + m_draw_height - 44;
}
m_draw_hue = Utility.GetHueVector(hue);
m_pickType = PickTypes.PickNothing;
m_draw_flip = false;
}
public MapObjectStatic(int staticTileID, int sortInfluence, Position3D position)
: base(position)
{
ItemID = staticTileID;
SortTiebreaker = sortInfluence;
m_itemData = UltimaData.TileData.ItemData[ItemID & 0x3FFF];
// Set threshold.
int background = (m_itemData.IsBackground) ? 0 : 1;
if (!m_itemData.IsBackground)
SortThreshold++;
if (!(m_itemData.Height == 0))
SortThreshold++;
if (m_itemData.IsSurface)
SortThreshold--;
// get no draw flag
if (m_itemData.Name == "nodraw" || ItemID <= 0)
m_noDraw = true;
// set up draw variables
m_draw_texture = UltimaData.ArtData.GetStaticTexture(ItemID);
m_draw_width = m_draw_texture.Width;
m_draw_height = m_draw_texture.Height;
m_draw_X = (m_draw_width >> 1) - 22;
m_draw_Y = (int)(Z * 4) + m_draw_height - 44;
m_draw_hue = Vector2.Zero;
m_pickType = PickTypes.PickStatics;
m_draw_flip = false;
}
public MapObjectText(Position3D position, BaseEntity ownerEntity, string text, int hue, int fontID)
: base(position)
{
OwnerEntity = ownerEntity;
Hue = hue;
FontID = fontID;
// set up draw data
m_draw_texture = Texture = ASCIIText.GetTextTexture(text, 1);
m_draw_width = m_draw_texture.Width;
m_draw_height = m_draw_texture.Height;
m_draw_X = (m_draw_width >> 1) - 22 - (int)((Position.X_offset - Position.Y_offset) * 22);
m_draw_Y = ((int)Position.Z_offset * 4) + m_draw_height - 44 - (int)((Position.X_offset + Position.Y_offset) * 22);
m_draw_hue = Utility.GetHueVector(Hue);
m_pickType = PickTypes.PickObjects;
m_draw_flip = false;
}
public MapObjectItem(int itemID, Position3D position, int direction, BaseEntity ownerEntity, int hue)
: base(position)
{
ItemID = itemID;
OwnerEntity = ownerEntity;
Facing = direction;
Hue = hue;
// set up draw data
m_draw_texture = UltimaData.ArtData.GetStaticTexture(ItemID);
m_draw_width = m_draw_texture.Width;
m_draw_height = m_draw_texture.Height;
m_draw_X = (m_draw_width >> 1) - 22;
m_draw_Y = (int)(Z * 4) + m_draw_height - 44;
m_draw_hue = Utility.GetHueVector(Hue);
m_pickType = PickTypes.PickObjects;
m_draw_flip = false;
}
public MapObjectMobile(Position3D position, int facing, int action, float frame, BaseEntity ownerEntity)
: base(position)
{
if (frame >= 1.0f)
return;
m_layers = new MapObjectMobileLayer[(int)EquipLayer.LastUserValid];
Facing = facing;
Action = action;
m_frame = frame;
OwnerEntity = ownerEntity;
// set pick type
m_pickType = PickTypes.PickObjects;
// set up draw data
m_draw_flip = (Facing > 4) ? true : false;
m_draw_IsometricOverlap = true;
}
public MapObjectCorpse(Position3D position, int direction, BaseEntity ownerEntity, int nHue, int bodyID, float frame)
: base(0x2006, position, direction, ownerEntity, nHue)
{
BodyID = bodyID;
FrameIndex = (int)(frame * UltimaData.BodyConverter.DeathAnimationFrameCount(bodyID));
UltimaData.AnimationFrame iFrame = getFrame();
if (iFrame == null)
{
m_noDraw = true;
return;
}
m_draw_texture = iFrame.Texture;
m_draw_width = m_draw_texture.Width;
m_draw_height = m_draw_texture.Height;
m_draw_X = iFrame.Center.X - 22;
m_draw_Y = iFrame.Center.Y + (int)(Z * 4) + m_draw_height - 22;
m_draw_hue = Utility.GetHueVector(Hue);
m_pickType = PickTypes.PickObjects;
m_draw_flip = false;
}
private Position3D getNextTile(Position3D current, Position3D goal, out Direction facing)
{
facing = getNextFacing(current, goal);
Vector3 nextTile = MovementCheck.OffsetTile(current.Tile_V3, facing);
int nextAltitude;
bool moveIsOkay = MovementCheck.CheckMovement((Mobile)m_entity, IsometricRenderer.Map, current.Tile_V3, facing, out nextAltitude);
nextTile.Z = nextAltitude;
if (moveIsOkay)
{
if (IsRunning)
facing |= Direction.Running;
return new Position3D(nextTile);
}
else
{
return null;
}
}
private Direction getNextFacing(Position3D current, Position3D goal)
{
Direction facing;
if (goal.X < current.X)
{
if (goal.Y < current.Y)
facing = Direction.Up;
else if (goal.Y > current.Y)
facing = Direction.Left;
else
facing = Direction.West;
}
else if (goal.X > current.X)
{
if (goal.Y < current.Y)
facing = Direction.Right;
else if (goal.Y > current.Y)
facing = Direction.Down;
else
facing = Direction.East;
}
else
{
if (goal.Y < current.Y)
facing = Direction.North;
else if (goal.Y > current.Y)
facing = Direction.South;
else
{
// We should never reach this.
facing = Facing & Direction.FacingMask;
}
}
return facing;
}
public void Update(double frameMS)
{
flushDrawObjects();
// Are we moving? (if our current location != our destination, then we are moving)
if (IsMoving)
{
MoveSequence += ((float)(frameMS) / TimeToCompleteMove(Facing).Milliseconds);
if (MoveSequence < 1f)
{
m_currentPosition.Offset_V3 = (m_goalPosition.Tile_V3 - m_currentPosition.Tile_V3) * MoveSequence;
}
else
{
m_currentPosition = m_goalPosition;
MoveSequence = 0f;
}
}
else
{
MoveEvent moveEvent;
int sequence;
while ((moveEvent = m_moveEvents.GetMoveEvent(out sequence)) != null)
{
if (m_entity.IsClientEntity)
SendMoveRequestPacket(new MoveRequestPacket((byte)moveEvent.Facing, (byte)sequence, moveEvent.Fastwalk));
Facing = (Direction)moveEvent.Facing;
Position3D p = new Position3D(
moveEvent.X, moveEvent.Y, moveEvent.Z);
if (p != m_currentPosition)
{
m_goalPosition = p;
return;
}
}
}
}
public void Move_Instant(int x, int y, int z, int facing)
{
m_moveEvents.ResetMoveSequence();
flushDrawObjects();
Facing = ((Direction)facing & Direction.FacingMask);
m_goalPosition = m_currentPosition = new Position3D(x, y, z);
}
internal void drawOverheads(MapTile tile, Position3D position)
{
// base entities do not draw, but they can have overheads, so we draw those.
foreach (KeyValuePair<int, Overhead> overhead in m_overheads)
{
if (!overhead.Value.IsDisposed)
overhead.Value.Draw(tile, position);
}
}
public AMapObject(Position3D position)
{
Position = position;
}
internal override void Draw(MapTile tile, Position3D position)
{
tile.FlushObjectsBySerial(Serial);
int hue = m_isHued ? m_hue : 0;
tile.AddMapObject(new MapObjectDynamic(this, position, m_baseItemID, (int)(m_frameSequence * m_frameLength), hue, m_useGumpArtInsteadOfTileArt));
}
internal override void Draw(MapTile tile, Position3D position)
{
if (Ignored)
return;
tile.AddMapObject(new MapObjectItem(DisplayItemID, position, DrawFacing, this, Hue));
drawOverheads(tile, new Position3D(position.Point_V3));
}
public Movement(BaseEntity entity)
{
m_entity = entity;
m_currentPosition = new Position3D();
m_moveEvents = new MoveEvents();
}
internal override void Draw(MapTile tile, Position3D position)
{
m_movement.ClearImmediate();
tile.AddMapObject(new MapObjectCorpse(position, DrawFacing, this, Hue, m_corpseBody, m_corpseFrame));
drawOverheads(tile, new Position3D(m_movement.Position.Point_V3));
}
internal override void Draw(MapTile tile, Position3D position)
{
if (IsMoving)
{
if (IsRunning)
m_animation.Animate(MobileAction.Run);
else
m_animation.Animate(MobileAction.Walk);
}
else
{
if (!m_animation.IsAnimating)
m_animation.Animate(MobileAction.Stand);
}
MapObjectMobile mobtile = new MapObjectMobile(position, DrawFacing, m_animation.ActionIndex, m_animation.AnimationFrame, this);
tile.AddMapObject(mobtile);
int[] drawLayers = m_DrawLayerOrder;
bool hasOuterTorso = m_equipment[(int)EquipLayer.OuterTorso] != null && m_equipment[(int)EquipLayer.OuterTorso].AnimationDisplayID != 0;
for (int i = 0; i < drawLayers.Length; i++)
{
// when wearing something on the outer torso the other torso stuff is not drawn
if (hasOuterTorso && (drawLayers[i] == (int)EquipLayer.InnerTorso || drawLayers[i] == (int)EquipLayer.MiddleTorso))
{
continue;
}
if (drawLayers[i] == (int)EquipLayer.Body)
{
mobtile.AddLayer(BodyID, Hue);
}
else if (m_equipment[drawLayers[i]] != null && m_equipment[drawLayers[i]].AnimationDisplayID != 0)
{
mobtile.AddLayer(m_equipment[drawLayers[i]].AnimationDisplayID, m_equipment[drawLayers[i]].Hue);
}
}
drawOverheads(tile, new Position3D(m_movement.Position.Tile_V3));
}
internal virtual void Draw(MapTile tile, Position3D position)
{
}
internal override void Draw(MapTile tile, Position3D position)
{
// string text = Utility.WrapASCIIText(m_font, m_text, 200);
// tile.Add(new TileEngine.MapObjectText(position, m_ownerEntity, text, m_hue, m_font));
}
public MapObjectPrerendered(Position3D position)
: base(position)
{
m_objects.Add(this);
}
internal override void Draw(MapTile tile, Position3D position)
{
if (m_unloadedTiles.Count == 0)
return;
List<Point> drawnTiles = new List<Point>();
foreach (Point p in m_unloadedTiles)
{
int x = tile.X + p.X - m_components.Center.X;
int y = tile.Y + p.Y - m_components.Center.Y;
MapTile t = IsometricRenderer.Map.GetMapTile(x, y, false);
if (t != null)
{
drawnTiles.Add(p);
if (!m_hasCustomTiles)
{
if (p.X < m_components.Width && p.Y < m_components.Height)
{
foreach (StaticTile s in m_components.Tiles[p.X][p.Y])
{
t.AddMapObject(new MapObjectStatic(s.ID, 0, new Position3D(x, y, s.Z)));
}
}
}
else
{
foreach (StaticTile s in m_customHouseTiles)
{
if ((s.X == p.X) && (s.Y == p.Y))
{
t.AddMapObject(new MapObjectStatic(s.ID, 0, new Position3D(s.X, s.Y, s.Z)));
}
}
}
}
}
foreach (Point p in drawnTiles)
{
m_unloadedTiles.Remove(p);
}
}
