public MapObject(Grid2D <MapObject> grid2D, int x, int y)
{
_grid2D = grid2D;
this.x = x;
this.y = y;
_type = MapObjectType.Empty;
}
private TextBlock CreateTextBlock(MapObjectType mapObjectType)
{
TextBlock textblock = new TextBlock();
textblock.Text = mapObjectType.ToString();
return(textblock);
}
public static string get()
{
MapObjectType type = MapObjectType.Forester;
type = MapObjectType.Tree | MapObjectType.Warehouse;
return(type.ToString());
}
public static MapObject GetMapObject(int start, MapObjectType objType, byte[] bytes, Hex[] hexes, out int newStart)
{
switch (objType)
{
//case MapObjectType.Item:
// break;
case MapObjectType.Critter:
return new Critter(start, bytes, hexes, criNames, itemsProtoNames, out newStart);
case MapObjectType.Scenery:
return new Scenery(start, bytes, hexes, sceNames, itemsProtoNames, out newStart);
case MapObjectType.Wall:
return new Wall(start, bytes, hexes, wallNames, itemsProtoNames, out newStart);
//case MapObjectType.Tiles:
// break;
case MapObjectType.Misc:
return new Misc(start, bytes, hexes, miscNames, itemsProtoNames, out newStart);
//case MapObjectType.Interface:
// break;
//case MapObjectType.Invent:
// break;
//case MapObjectType.Head:
// break;
//case MapObjectType.Backgrnd:
// break;
//case MapObjectType.Skilldex:
// break;
//default:
// break;
}
newStart = start + 88;
return null;
}
public MapObjectProperties(int elevation, MapObjectType mapObjectType, bool isSinglePiece, int possibleInTileShift)
{
this.possibleInTileShift = possibleInTileShift;
this.isSinglePiece = isSinglePiece;
this.elevation = elevation;
this.mapObjectType = mapObjectType;
}
public MOBObject(BinaryReader br)
{
MOBObjectName = Encoding.ASCII.GetString(br.ReadBytes(60));
MOBObjectNameChar = GetCharsFromString(MOBObjectName, 60);
MOBObjectName = GetStringFromChars(MOBObjectNameChar);
ObjectZero1 = br.ReadUInt16();
ObjectFlag = (MapObjectType)br.ReadByte();
ObjectZero2 = br.ReadByte();
for (int i = 0; i < 3; i++)
{
Position[i] = br.ReadSingle();
}
for (int i = 0; i < 3; i++)
{
Rotation[i] = br.ReadSingle();
}
for (int i = 0; i < 3; i++)
{
Scale[i] = br.ReadSingle();
}
for (int i = 0; i < 3; i++)
{
HealthBarPosition1[i] = br.ReadSingle();
}
for (int i = 0; i < 3; i++)
{
HealthBarPosition2[i] = br.ReadSingle();
}
ObjectZero3 = br.ReadUInt32();
}
public Monster(List<Image.ImageUnit> frames, MapObjectType type)
: base(frames, type)
{
switch (type)
{
case MapObjectType.GreenSlime:
SetStatus(30, 20, 5, 1, 1, 1, new List<MonsterFeature> { MonsterFeature.None });
break;
case MapObjectType.BlueSlime:
SetStatus(50, 25, 5, 2, 1, 1, new List<MonsterFeature> { MonsterFeature.None });
break;
case MapObjectType.RedSlime:
SetStatus(80, 30, 5, 3, 2, 1, new List<MonsterFeature> { MonsterFeature.None });
break;
case MapObjectType.LittleBat:
SetStatus(40, 35, 20, 5, 2, 1, new List<MonsterFeature> { MonsterFeature.None });
break;
case MapObjectType.BigBat:
SetStatus(70, 80, 30, 7, 4, 2, new List<MonsterFeature> { MonsterFeature.TwiceAttack });
break;
case MapObjectType.Wizard:
SetStatus(70, 15, 10, 4, 2, 1, new List<MonsterFeature> { MonsterFeature.Penetrate });
break;
case MapObjectType.YellowWizard:
SetStatus(150, 25, 25, 10, 3, 1, new List<MonsterFeature> { MonsterFeature.Penetrate });
break;
case MapObjectType.Skeleton:
SetStatus(200, 100, 5, 7, 3, 1, new List<MonsterFeature> { MonsterFeature.None });
break;
}
}
public IList <MapObject> GetAllMapObjects(MapObjectType mapObjectType)
{
using (var repositoriesContainer = new InnostarRepositoriesContainer())
{
return(repositoriesContainer.MapObjectsRepository.GetAllMapObjects(mapObjectType));
}
}
public ObjectContent(XmlNode node)
{
if (node.Attributes[AttributeNames.MapObjectAttributes.Name] != null)
Name = node.Attributes[AttributeNames.MapObjectAttributes.Name].Value;
if (node.Attributes[AttributeNames.MapObjectAttributes.Type] != null)
Type = node.Attributes[AttributeNames.MapObjectAttributes.Type].Value;
if (node[AttributeNames.MapObjectAttributes.Properties] != null)
properties = new PropertyCollection(node[AttributeNames.MapObjectAttributes.Properties]);
int x = 0, y = 0, width = 0, height = 0;
if (node.Attributes[AttributeNames.MapObjectAttributes.X] != null)
x = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.X].Value);
if (node.Attributes[AttributeNames.MapObjectAttributes.Y] != null)
y = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Y].Value);
if (node.Attributes[AttributeNames.MapObjectAttributes.Width] != null)
width = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Width].Value);
if (node.Attributes[AttributeNames.MapObjectAttributes.Height] != null)
height = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.Height].Value);
Bounds = new Rectangle(x, y, width, height);
string objectPoints = String.Empty;
if (node.Attributes[AttributeNames.MapObjectAttributes.GID] != null)
{
objectType = MapObjectType.Tile;
GID = Utilities.TryToParseInt(node.Attributes[AttributeNames.MapObjectAttributes.GID].Value);
}
else if (node.Attributes[AttributeNames.MapObjectAttributes.Polygon] != null)
{
objectType = MapObjectType.Polygon;
objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polygon].Value;
}
else if (node.Attributes[AttributeNames.MapObjectAttributes.Polyline] != null)
{
objectType = MapObjectType.Polyline;
objectPoints = node.Attributes[AttributeNames.MapObjectAttributes.Polyline].Value;
}
if(!String.IsNullOrEmpty(objectPoints))
{
string[] splitPoints = objectPoints.Split(' ');
foreach(string splitPoint in splitPoints)
{
string[] coordinates = splitPoint.Split(',');
float coordinateX = 0f, coordinateY = 0f;
float.TryParse(coordinates[0], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateX);
float.TryParse(coordinates[1], NumberStyles.None, CultureInfo.InvariantCulture, out coordinateY);
points.Add(new Point((int)x, (int)y));
}
}
}
public byte[] GetMapObjectImage(MapObjectType mapObjectType, int id)
{
using (var repositoriesContainer = new InnostarRepositoriesContainer())
{
return(repositoriesContainer.MapObjectsRepository.GetMapObjectImage(mapObjectType, id));
}
}
public MapObject(List <Point> points, MapObjectType type)
{
Points = points;
Type = type;
Middlepoint = new Point((int)Math.Round(points.Sum(x => (double)x.X) / points.Count),
(int)Math.Round(points.Sum(y => (double)y.Y) / points.Count));
}
public MapObject(string name, Rectangle bounds, Orientation orientation, MapObjectType type, PropertyCollection properties)
{
Name = name;
Type = type;
Bounds = bounds;
Orientation = orientation;
Properties = properties;
}
private bool IsNoNameObject(MapObjectType mop)
{
return(mop.Equals(MapObjectType.Parking) ||
mop.Equals(MapObjectType.ParkingSlot) ||
mop.Equals(MapObjectType.Road) ||
mop.Equals(MapObjectType.WaitingRoom) ||
mop.Equals(MapObjectType.Building));
}
private MapObject CreateEditedObject()
{
MapObjectType type = SettingTypeOfEditedMapObject();
MapObject objectToEdit = SettingMapObject(type);
_mapObjectController.UpdateMapObject(objectToEdit);
return(objectToEdit);
}
private void OnBuildingBlockChoose(MapObjectType type)
{
buildingCursor.SetCursorOff();
if (type != MapObjectType.AIR)
{
buildingCursor.SetCursorOn(type, mapdata);
}
}
private void InsertTextToCell(MapObjectType mapObjectType, Grid cell)
{
TextBlock textblock = CreateTextBlock(mapObjectType);
textblock.SetValue(Grid.ColumnProperty, 1);
textblock.VerticalAlignment = VerticalAlignment.Center;
cell.Children.Add(textblock);
}
public void SetObjectTypeAt(Vector3Int position, MapObjectType type)
{
int x = Mathf.Clamp(position.x, 0, xSize - 1);
int y = Mathf.Clamp(position.y, 0, ySize - 1);
int z = Mathf.Clamp(position.z, 0, zSize - 1);
map[x, y, z] = type;
}
private void InsertRectangleToCell(MapObjectType mapObjectType, Grid cell)
{
Rectangle rectangle = CreateRectangle(mapObjectType);
rectangle.SetValue(Grid.ColumnProperty, 0);
rectangle.VerticalAlignment = VerticalAlignment.Center;
cell.Children.Add(rectangle);
}
public MapObjectContent(XmlNode node, ContentImporterContext context)
{
// get the object's name and type
if (node.Attributes["name"] != null)
Name = node.Attributes["name"].Value;
if (node.Attributes["type"] != null)
Type = node.Attributes["type"].Value;
// read the object properties
if (node["properties"] != null)
Properties = new PropertyCollection(node["properties"], context);
// parse out the bounds of the object. values default to 0 if the attribute is missing from the node.
int x = node.Attributes["x"] != null ? int.Parse(node.Attributes["x"].Value, CultureInfo.InvariantCulture) : 0;
int y = node.Attributes["y"] != null ? int.Parse(node.Attributes["y"].Value, CultureInfo.InvariantCulture) : 0;
int width = node.Attributes["width"] != null ? int.Parse(node.Attributes["width"].Value, CultureInfo.InvariantCulture) : 0;
int height = node.Attributes["height"] != null ? int.Parse(node.Attributes["height"].Value, CultureInfo.InvariantCulture) : 0;
Bounds = new Rectangle(x, y, width, height);
// stores a string of points to parse out if this object is a polygon or polyline
string pointsAsString = null;
// if there's a GID, it's a tile object
if (node.Attributes["gid"] != null)
{
ObjectType = MapObjectType.Tile;
GID = int.Parse(node.Attributes["gid"].Value, CultureInfo.InvariantCulture);
}
// if there's a polygon node, it's a polygon object
else if (node["polygon"] != null)
{
ObjectType = MapObjectType.Polygon;
pointsAsString = node["polygon"].Attributes["points"].Value;
}
// if there's a polyline node, it's a polyline object
else if (node["polyline"] != null)
{
ObjectType = MapObjectType.Polyline;
pointsAsString = node["polyline"].Attributes["points"].Value;
}
// if we have some points to parse, we do that now
if (pointsAsString != null)
{
// points are separated first by spaces
string[] pointPairs = pointsAsString.Split(' ');
foreach (string p in pointPairs)
{
// then we split on commas
string[] coords = p.Split(',');
// then we parse the X/Y coordinates
Points.Add(new Vector2(
float.Parse(coords[0], CultureInfo.InvariantCulture),
float.Parse(coords[1], CultureInfo.InvariantCulture)));
}
}
}
private Rectangle CreateRectangle(MapObjectType mapObjectType)
{
Rectangle rectangle = new Rectangle();
rectangle.Fill = MapObjectColors.getInstance().getColor(mapObjectType);
rectangle.Width = 25;
rectangle.Height = 25;
return(rectangle);
}
protected MapObjectBase(Format rsw, MapObjectType type)
{
_parentRsw = rsw;
Type = type;
// Defaults
Name = string.Empty;
Position = Vector3.Zero;
}
private MapObject SettingMapObject(MapObjectType type)
{
MapObject objectToEdit = SelectedMapObject;
DisplayMapObject.MapObjectType = type;
objectToEdit.MapObjectEntity = DisplayMapObject;
objectToEdit.Rectangle.Fill = type.ObjectTypeColor;
return(objectToEdit);
}
protected MapObjectBase(Format rsw, MapObjectType type)
{
_parentRsw = rsw;
Type = type;
// Defaults
Name = string.Empty;
Position = Vector3.Zero;
}
private void InsertValueToCell(MapObjectType mapObjectType, int row, int column)
{
Grid cell = CreateLegendCell(row, column);
InsertRectangleToCell(mapObjectType, cell);
InsertTextToCell(mapObjectType, cell);
Legend.Children.Add(cell);
}
public MapObject(String name, int Id, MapObjectMetrics MapObjectMetrics, MapObjectType MapObjectType, MapObjectDoor MapObjectDoor, MapObjectDescription MapObjectDescription)
{
this.Name = name;
this.Id = Id;
this.MapObjectMetrics = MapObjectMetrics;
this.MapObjectType = MapObjectType;
this.MapObjectDoor = MapObjectDoor;
this.MapObjectDescription = MapObjectDescription;
setMapObjectProperties(MapObjectMetrics);
}
public void SetCursorOn(MapObjectType type, MapData mapData)
{
this.currentCursorType = type;
cursorDescription = objectsMapper.GetDescriptionByType(type);
positiveCursor = cursorDescription.PositiveCursor;
positiveRotator = positiveCursor.GetComponent <BuildingBlockRotator>();
negativeCursor = cursorDescription.NegativeCursor;
negativeRotator = negativeCursor.GetComponent <BuildingBlockRotator>();
this.mapData = mapData;
isCursorOn = true;
}
private int GetIndexByType(MapObjectType type)
{
for (int i = 0; i < objectsMapper.Count; i++)
{
if (objectsMapper[i].type == type)
{
return(i);
}
}
return(-1);
}
public static GameObject CreateMapObject(MapObjectType type)
{
GameObject obj = Instantiate(MapMakerController.Instance.MapObjectsPrefabs[(int)type], MapMakerController.Instance.Map.transform);
Destroy(obj.GetComponent <Collider2D>());
obj.AddComponent <MapObjectController>().Type = type;
BoxCollider2D c = obj.AddComponent <BoxCollider2D>();
c.isTrigger = true;
return(obj);
}
public List <MapObject> SearchMapObjects(MapObjectType searchedMapObjectType)
{
List <MapObject> searchResultMapObjects = new List <MapObject>();
foreach (MapObject mapObject in MainWindow._allMapObjects)
{
if (mapObject.MapObjectEntity.MapObjectType.TypeOfMapObject == searchedMapObjectType.TypeOfMapObject)
{
searchResultMapObjects.Add(mapObject);
}
}
return(searchResultMapObjects);
}
public IList <MapObject> GetRelatedMapObjects(int id, MapObjectType parentMapObjectType, MapObjectType filterType)
{
using (var repositoriesContainer = new InnostarRepositoriesContainer())
{
var parentMapObject = new MapObject
{
Id = id,
MapObjectType = parentMapObjectType
};
return(repositoriesContainer.MapObjectsRepository.GetRelatedMapObjects(parentMapObject, filterType));
}
}
public int AssignObjectID(MapObjectType type)
{
switch (type)
{
case MapObjectType.Npc: return(++mNpcObjectIDs);
case MapObjectType.Mob: return(++mMobObjectIDs);
case MapObjectType.Reactor: return(++mReactorObjectIDs);
default: throw new ArgumentException(type.ToString());
}
}
public GameObject Instantiate(MapObjectType objectType, int sortingOrder)
{
string objType = objectType.ToString().Replace("_", "");
objType = objType.ToLower();
GameObject prefab = PrefabUtils.GetPrefab(this, objType);
GameObject go = Instantiate(prefab) as GameObject;
go.GetComponent<SpriteRenderer>().sortingOrder = sortingOrder;
return go;
}
private void SearchMapObjectsButton_Click(object sender, RoutedEventArgs e)
{
if (SearchObjectTypeComboBox.SelectedItem != null)
{
MapObjectType searchedMapObjectType = (MapObjectType)SearchObjectTypeComboBox.SelectedItem;
List <MapObject> searchResultMapObjects = _mapObjectController.SearchMapObjects(searchedMapObjectType);
ObjectSearchResultsDataGrid.ItemsSource = searchResultMapObjects;
}
else
{
return;
}
}
/// <summary>
/// Объекты в указанной зоне
/// </summary>
/// <param name="objType">Какие объекты выбирать</param>
/// <returns></returns>
public MapObject[] Select(MapObjectType objTypes)
{
List <MapObject> objs = new List <MapObject>();
foreach (MapObject mo in _objects)
{
if ((objTypes & mo.ObjectType) != 0)
{
objs.Add(mo);
}
}
;
return(objs.ToArray());
}
public bool CanBeBuildNearMe(MapObjectType type, out BuildCondition.RelativePosition position)
{
int count = canBeBuiltNearMe.Count;
for (int i = 0; i < count; i++)
{
if (canBeBuiltNearMe[i].type == type)
{
position = canBeBuiltNearMe[i].position;
return(true);
}
}
position = BuildCondition.RelativePosition.ON_THE_SIDE;
return(false);
}
public MapObject(string name, string type, MapObjectType objectType, Rectangle bounds, int gid, IEnumerable<Vector2> points, IEnumerable<KeyValuePair<string, string>> properties)
{
Name = name;
Type = type;
ObjectType = objectType;
Bounds = new Rectangle(bounds.X, bounds.Y, bounds.Width, bounds.Height);
GID = gid;
Points = new List<Vector2>();
foreach (var point in points)
Points.Add(new Vector2(point.X, point.Y));
Properties = new Dictionary<string, string>();
foreach (var property in properties)
Properties.Add(property.Key, property.Value);
}
public GenericMapObject(string name, MapObjectType objType, int HexInt)
{
TextureName = name;
HexPosition = HexInt;
switch (objType)
{
case MapObjectType.Item:
break;
case MapObjectType.Critter:
_prefix = "/art/critters/";
break;
case MapObjectType.Scenery:
break;
case MapObjectType.Wall:
break;
case MapObjectType.Tile:
break;
case MapObjectType.Misc:
break;
case MapObjectType.Interface:
break;
case MapObjectType.Invent:
break;
case MapObjectType.Head:
break;
case MapObjectType.Backgrnd:
break;
case MapObjectType.Skilldex:
break;
default:
break;
}
MapObjectType = objType;
_texture = new FRM(_repo + _prefix + TextureName + "AA.frm", MovementHelper.HexX(HexInt), MovementHelper.HexY(HexInt));
}
public MapObject(MapObjectType objectType, Map parent)
{
ObjectType = objectType;
Parent = parent;
X = Y = 0;
}
public MapObject(ImageUnit img, MapObjectType type)
: this(new List<ImageUnit>() { img }, type)
{
}
public void SetMapObject(int row, int col, MapObjectType type) => _map[row, col] = MapObjectFactory.CreateMapObject(type);
public static MapObject CreateMapObject(MapObjectType type)
{
switch (type)
{
// Item Zone
case MapObjectType.Floor1:
return new Item(_dataSet[(int)MapObjectImage.Floor1], type);
case MapObjectType.Block1:
return new Item(_dataSet[(int)MapObjectImage.Block1], type);
case MapObjectType.UpStair1:
return new Item(_dataSet[(int)MapObjectImage.UpStair1], type);
case MapObjectType.UpStair2:
return new Item(_dataSet[(int)MapObjectImage.UpStair2], type);
case MapObjectType.YellowKey:
return new Item(_dataSet[(int)MapObjectImage.YellowKey], type);
case MapObjectType.BlueKey:
return new Item(_dataSet[(int)MapObjectImage.BlueKey], type);
case MapObjectType.RedKey:
return new Item(_dataSet[(int)MapObjectImage.RedKey], type);
case MapObjectType.MonsterBook:
return null;
case MapObjectType.DownStair1:
return new Item(_dataSet[(int)MapObjectImage.DownStair1], type);
case MapObjectType.DownStair2:
return new Item(_dataSet[(int)MapObjectImage.DownStair2], type);
case MapObjectType.RedPotion:
return new Item(_dataSet[(int)MapObjectImage.RedPotion], type);
case MapObjectType.BluePotion:
return new Item(_dataSet[(int)MapObjectImage.BluePotion], type);
case MapObjectType.RedCrystal:
return new Item(_dataSet[(int)MapObjectImage.RedCrystal], type);
case MapObjectType.BlueCrystal:
return new Item(_dataSet[(int)MapObjectImage.BlueCrystal], type);
case MapObjectType.YellowDoor:
return new Item(_dataSet[(int)MapObjectImage.YellowDoor], type);
case MapObjectType.BlueDoor:
return new Item(_dataSet[(int)MapObjectImage.BlueDoor], type);
case MapObjectType.RedDoor:
return new Item(_dataSet[(int)MapObjectImage.RedDoor], type);
case MapObjectType.TeleportStaf:
return new Item(_dataSet[(int)MapObjectImage.TeleportStaf], type);
case MapObjectType.Sword1:
return new Item(_dataSet[(int)MapObjectImage.Sword1], type);
case MapObjectType.Sword2:
return new Item(_dataSet[(int)MapObjectImage.Sword2], type);
case MapObjectType.Sword3:
return new Item(_dataSet[(int)MapObjectImage.Sword3], type);
case MapObjectType.Sword4:
return new Item(_dataSet[(int)MapObjectImage.Sword4], type);
case MapObjectType.Sword5:
return new Item(_dataSet[(int)MapObjectImage.Sword5], type);
case MapObjectType.Shield1:
return new Item(_dataSet[(int)MapObjectImage.Shield1], type);
case MapObjectType.Shield2:
return new Item(_dataSet[(int)MapObjectImage.Shield2], type);
case MapObjectType.Shield3:
return new Item(_dataSet[(int)MapObjectImage.Shield3], type);
case MapObjectType.Shield4:
return new Item(_dataSet[(int)MapObjectImage.Shield4], type);
case MapObjectType.Shield5:
return new Item(_dataSet[(int)MapObjectImage.Shield5], type);
// Shop Zone
case MapObjectType.GoldShop:
return new Shop(_dataSet[(int)MapObjectImage.Shop], type);
case MapObjectType.ShopBody1:
return new Shop(_dataSet[(int)MapObjectImage.ShopBody1], type);
case MapObjectType.ShopBody2:
return new Shop(_dataSet[(int)MapObjectImage.ShopBody2], type);
case MapObjectType.ExpShop:
return new Shop(_dataSet[(int)MapObjectImage.NPC1], type);
// Monster Zone
case MapObjectType.GreenSlime:
return new Monster(_dataSet[(int)MapObjectImage.GreenSlime], type);
case MapObjectType.BlueSlime:
return new Monster(_dataSet[(int)MapObjectImage.BlueSlime], type);
case MapObjectType.RedSlime:
return new Monster(_dataSet[(int)MapObjectImage.RedSlime], type);
case MapObjectType.LittleBat:
return new Monster(_dataSet[(int)MapObjectImage.LittleBat], type);
case MapObjectType.BigBat:
return new Monster(_dataSet[(int)MapObjectImage.BigBat], type);
case MapObjectType.RedBat:
return new Monster(_dataSet[(int)MapObjectImage.RedBat], type);
case MapObjectType.Wizard:
return new Monster(_dataSet[(int)MapObjectImage.Wizard], type);
case MapObjectType.YellowWizard:
return new Monster(_dataSet[(int)MapObjectImage.YellowWizard], type);
case MapObjectType.RedWizard:
return new Monster(_dataSet[(int)MapObjectImage.RedWizard], type);
case MapObjectType.Skeleton:
return new Monster(_dataSet[(int)MapObjectImage.Skeleton], type);
case MapObjectType.ShieldSkeleton:
return new Monster(_dataSet[(int)MapObjectImage.ShieldSkeleton], type);
case MapObjectType.EliteSkeleton:
return new Monster(_dataSet[(int)MapObjectImage.EliteSkeleton], type);
}
throw new Exception("Not expected MapObject type " + (int)type + ".");
}
public Item(List<ImageUnit> frames, MapObjectType type)
: base(frames, type)
{
}
public Item(ImageUnit img, MapObjectType type)
: base(img, type)
{
}
// If you change this, update HelpPainter.cs
private static char ConvertMapObjectToChar(MapObjectType t)
{
switch (t)
{
case MapObjectType.OpenDoor:
return ';';
case MapObjectType.ClosedDoor:
return ':';
case MapObjectType.TreasureChest:
return '+';
case MapObjectType.Cosmetic:
return '_';
case MapObjectType.StairsDown:
return '>';
case MapObjectType.StairsUp:
return '<';
default:
throw new System.ArgumentException("Unknown Type - ConvertMapObjectToChar");
}
}
public Shop(List<ImageUnit> frames, MapObjectType type)
: base(frames, type)
{
_shop = Applet.Shop.GetInstance();
}
public MapObject(List<ImageUnit> frames, MapObjectType type)
{
_frames = new List<ImageUnit>(frames);
_currentFrame = 0;
_type = type;
}
public static List<MapPoi> GetPoiList(MapObjectType poiType)
{
using (var sc = new SqlConnection(ConnectionStringHelper.ConnectionString))
{
var cmd = new SqlCommand("sp_map_Poi_GetList", sc)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("@PoiType", (int)poiType);
sc.Open();
var reader = cmd.ExecuteReader();
var poiList = new List<MapPoi>();
while (reader.Read())
poiList.Add(FillPoiFromReader(reader));
return poiList;
}
}
public bool this[int x, int y, MapObjectType type, object obj]
{
get
{
if (Bounds.Height == Bounds.Width && Bounds.Width == 0)
{
Console.WriteLine("Floor " + FloorMapID + " not loaded!!");
return true;
}
if (y >= Bounds.Height || x >= Bounds.Width || x < 0 || y < 0)
return false;
if (Locations[x, y] == null)
Locations[x, y] = new FillStruct() { };
FillStruct filltype = Locations[x, y];
if (type == MapObjectType.InvalidCast)
return filltype.Full;
if (filltype.Full)
return false;
if (type == MapObjectType.Player)
{
return true;
}
else if (type == MapObjectType.Monster)
{
return filltype.Monsters == 0;
}
else if (type == MapObjectType.Item)
{
return filltype.Item == null;
}
return false;
}
set
{
if (value)
{
if (Bounds.Height == Bounds.Width && Bounds.Width == 0)
return;
if (y >= Bounds.Height || x >= Bounds.Width || x < 0 || y < 0)
return;
if (Locations[x, y] == null)
Locations[x, y] = new FillStruct() { };
if (type == MapObjectType.InvalidCast)
{
Locations[x, y].Full = false;
}
if (type == MapObjectType.Item)
Locations[x, y].Item = null;
if (type == MapObjectType.Monster)
Locations[x, y].Monsters = 0;
}
else
{
if (y >= Bounds.Height || x >= Bounds.Width)
return;
if (Locations[x, y] == null)
Locations[x, y] = new FillStruct() { };
if (type == MapObjectType.InvalidCast)
Locations[x, y].Full = true;
if (obj != null)
{
if (obj is Interfaces.INpc)
{
Locations[x, y].Npc = obj as Interfaces.INpc;
}
}
if (type == MapObjectType.Item)
Locations[x, y].Item = obj as Network.GamePackets.FloorItem;
if (type == MapObjectType.Monster)
Locations[x, y].Monsters = 1;
}
}
}
public void SetMapObject(Point position, MapObjectType type) => SetMapObject(position.Y, position.X, type);
public Shop(ImageUnit img, MapObjectType type)
: base(img, type)
{
_shop = Applet.Shop.GetInstance();
}
public Stairs(Point position, bool stairsUp)
{
m_type = stairsUp ? MapObjectType.StairsUp : MapObjectType.StairsDown;
m_position = position;
m_guid = Guid.NewGuid();
}
public static MapObject GetMapObject(string name, MapObjectType objType, int position)
{
return new GenericMapObject(name, objType, position);
}
