public World(string name, BoundingBox boundingBox, Vector tileDimensions)
: base(boundingBox, tileDimensions)
{
this.Name = name;
this.ItemCache = new ItemCache();
log.InfoFormat("created world {0}", name);
}
public Vector(Vector v)
: this()
{
X = v.X;
Y = v.Y;
Z = v.Z;
}
public static OperationRequest CreateWorld(string worldName, BoundingBox boundingBox, Vector tileDimensions)
{
var request = new OperationRequest { OperationCode = (byte)OperationCode.CreateWorld, Parameters = new Dictionary<byte, object>() };
request.Parameters.Add((byte)ParameterCode.WorldName, worldName);
request.Parameters.Add((byte)ParameterCode.BoundingBox, boundingBox);
request.Parameters.Add((byte)ParameterCode.TileDimensions, tileDimensions);
return request;
}
public void RegionIndexesAndBorders5()
{
var min = new Vector { X = 0, Y = 0 };
var max = new Vector { X = 100, Y = 100 };
var tileDimensions = new Vector { X = 1, Y = 1 };
var world = new GridWorld(new BoundingBox(min, max), tileDimensions);
RegionIndexesAndBorders(world);
}
/// <summary>
/// Initializes a new instance of the <see cref="MmoWorld"/> class.
/// </summary>
/// <param name="name">
/// The world name.
/// </param>
/// <param name="topLeftCorner">
/// The top left corner.
/// </param>
/// <param name="bottomRightCorner">
/// The bottom right corner.
/// </param>
/// <param name="tileDimensions">
/// The tile dimensions.
/// </param>
public MmoWorld(string name, Vector topLeftCorner, Vector bottomRightCorner, Vector tileDimensions)
: base(topLeftCorner, bottomRightCorner, tileDimensions, new MmoItemCache())
{
this.name = name;
log.InfoFormat("created world {0}", name);
const string PropertyKeyColor = "color";
const string PropertyKeyInterestAreaAttached = "attached";
const string PropertyKeyText = "text";
const string PropertyKeyViewDistanceEnter = "enter";
const string PropertyKeyViewDistanceExit = "exit";
var viewDistanceEnter = new Vector { X = (this.TileDimensions.X / 2) + 1, Y = (this.TileDimensions.Y / 2) + 1 };
var viewDistanceExit = new Vector
{
X = Math.Max(viewDistanceEnter.X + this.TileDimensions.X, (int)(1.5f * viewDistanceEnter.X)),
Y = Math.Max(viewDistanceEnter.Y + this.TileDimensions.Y, (int)(1.5f * viewDistanceEnter.Y))
};
int color;
unchecked
{
color = (int)0xFFFFFFFF;
}
var properties = new Hashtable
{
{ PropertyKeyInterestAreaAttached, true },
{ PropertyKeyViewDistanceEnter, viewDistanceEnter.ToFloatArray() },
{ PropertyKeyViewDistanceExit, viewDistanceExit.ToFloatArray() },
{ PropertyKeyColor, color },
{ PropertyKeyText, "NPC" }
};
// left and right are swapped in island demo
this.npc1 = new Npc(topLeftCorner, properties, "top right npc", (byte)ItemType.Avatar, this, viewDistanceEnter, viewDistanceExit);
this.npc2 = new Npc(bottomRightCorner, properties, "bottom left npc", (byte)ItemType.Avatar, this, viewDistanceEnter, viewDistanceExit);
var bottomLeftCorner = new Vector { X = topLeftCorner.X, Y = bottomRightCorner.Y };
this.npc3 = new Npc(
bottomLeftCorner,
properties,
"bottom right npc",
(byte)ItemType.Avatar,
this,
viewDistanceEnter,
viewDistanceExit);
var topRightCorner = new Vector { X = bottomRightCorner.X, Y = topLeftCorner.Y };
this.npc4 = new Npc(
topRightCorner,
properties,
"top left npc",
(byte)ItemType.Avatar,
this,
viewDistanceEnter,
viewDistanceExit);
}
public static void CreateWorld(Game game, string worldName, BoundingBox boundingBox, Vector tileDimensions)
{
var data = new Dictionary<byte, object>
{
{ (byte)ParameterCode.WorldName, worldName },
{ (byte)ParameterCode.BoundingBox, boundingBox },
{ (byte)ParameterCode.TileDimensions, tileDimensions }
};
game.SendOperation(OperationCode.CreateWorld, data, true, Settings.OperationChannel);
}
public bool MoveAbsolute(Vector newPosition, Vector rotation)
{
if (!this.Game.WorldData.BoundingBox.Contains2d(newPosition))
{
return false;
}
this.SetPositions(newPosition, this.Position, rotation, this.Rotation);
Operations.Move(this.Game, this.Id, newPosition, rotation, this.Game.Settings.SendReliable);
return true;
}
public static void Move(Client client, string itemId, Vector position)
{
var data = new Dictionary<byte, object> { { (byte)ParameterCode.Position, position } };
if (itemId != null)
{
data.Add((byte)ParameterCode.ItemId, itemId);
}
client.SendOperation((byte)OperationCode.Move, data, true);
}
public static void CreateWorld(Client client, string worldName, BoundingBox boundingBox, Vector tileDimensions)
{
var data = new Dictionary<byte, object>
{
{ (byte)ParameterCode.WorldName, worldName },
{ (byte)ParameterCode.BoundingBox, boundingBox },
{ (byte)ParameterCode.TileDimensions, tileDimensions }
};
client.SendOperation((byte)OperationCode.CreateWorld, data, true);
}
public static OperationRequest Move(string itemId, Vector position)
{
var request = new OperationRequest { OperationCode = (byte)OperationCode.Move, Parameters = new Dictionary<byte, object>() };
request.Parameters.Add((byte)ParameterCode.Position, position);
if (itemId != null)
{
request.Parameters.Add((byte)ParameterCode.ItemId, itemId);
}
return request;
}
public static void AddInterestArea(Game game, byte cameraId, Vector position, Vector viewDistanceEnter, Vector viewDistanceExit)
{
var data = new Dictionary<byte, object>
{
{ (byte)ParameterCode.InterestAreaId, cameraId },
{ (byte)ParameterCode.ViewDistanceEnter, viewDistanceEnter },
{ (byte)ParameterCode.ViewDistanceExit, viewDistanceExit },
{ (byte)ParameterCode.Position, position }
};
game.SendOperation(OperationCode.AddInterestArea, data, true, Settings.ItemChannel);
}
private static void RegionIndexesAndBorders(GridWorld world)
{
Region region;
var current = new Vector();
for (current.X = world.Area.Min.X; current.X < world.Area.Max.X; current.X++)
{
for (current.Y = world.Area.Min.Y; current.Y < world.Area.Max.Y; current.Y++)
{
Assert.IsNotNull(world.GetRegion(current), current.ToString());
}
}
try
{
for (current.Y = world.Area.Min.Y; current.Y < world.Area.Max.Y; current.Y += world.TileDimensions.Y)
{
// current.Y = (float)Math.Round(current.Y, 2);
for (current.X = world.Area.Min.X; current.X < world.Area.Max.X; current.X += world.TileDimensions.X)
{
// current.X = (float)Math.Round(current.X, 2);
Assert.IsNotNull(region = world.GetRegion(current), "null at {0}", current);
}
}
}
catch (IndexOutOfRangeException)
{
Console.WriteLine(current);
throw;
}
current.X = world.Area.Min.X - 1;
Assert.IsNull(world.GetRegion(current));
current.Y = world.Area.Min.Y - 1;
Assert.IsNull(world.GetRegion(current));
current.X = world.Area.Min.X;
Assert.IsNull(world.GetRegion(current));
current.Y = world.Area.Max.Y + 1;
Assert.IsNull(world.GetRegion(current));
current.X = world.Area.Max.X + 1;
Assert.IsNull(world.GetRegion(current));
current.Y = world.Area.Max.Y;
Assert.IsNull(world.GetRegion(current));
Assert.NotNull(world.GetRegion(world.Area.Min));
Assert.IsNull(world.GetRegion(world.Area.Max));
world.GetRegions(world.Area);
}
public static OperationRequest EnterWorld(
string worldName, string username, Hashtable properties, Vector position, Vector viewDistanceEnter, Vector viewDistanceExit)
{
var request = new OperationRequest { OperationCode = (byte)OperationCode.EnterWorld, Parameters = new Dictionary<byte, object>() };
request.Parameters.Add((byte)ParameterCode.WorldName, worldName);
request.Parameters.Add((byte)ParameterCode.Username, username);
request.Parameters.Add((byte)ParameterCode.Position, position);
request.Parameters.Add((byte)ParameterCode.ViewDistanceEnter, viewDistanceEnter);
request.Parameters.Add((byte)ParameterCode.ViewDistanceExit, viewDistanceExit);
if (properties != null)
{
request.Parameters.Add((byte)ParameterCode.Properties, properties);
}
return request;
}
/// <summary>
/// Registers an Item with the radar.
/// </summary>
/// <remarks>
/// The radar will receive position changes from the item and publish them with his Channel.
/// The publish interval can be configured with Settings.RadarUpdateInterval.
/// </remarks>
public void AddItem(Item item, Vector position)
{
this.actionQueue.EnqueueAction(
() =>
{
this.itemPositions.Add(item, position);
// update radar every 10 seconds
IDisposable positionUpdates = item.PositionUpdateChannel.SubscribeToLast(
this.fiber, this.UpdatePosition, Settings.RadarUpdateInterval);
IDisposable disposeMessage = item.DisposeChannel.Subscribe(this.fiber, this.RemoveItem);
var unsubscriber = new UnsubscriberCollection(positionUpdates, disposeMessage);
this.itemSubscriptions.Add(item, unsubscriber);
this.PublishUpdate(item, position, false, true);
});
}
public void OnRadarUpdate(string itemId, ItemType itemType, Vector position, bool remove)
{
itemId += itemType;
if (remove)
{
this.itemPositions.Remove(itemId);
return;
}
if (!this.itemPositions.ContainsKey(itemId))
{
this.itemPositions.Add(itemId, position);
return;
}
this.itemPositions[itemId] = position;
}
public Item(Vector position, Vector rotation, Hashtable properties, MmoActorOperationHandler owner, string id, byte type, World world)
{
this.Position = position;
this.Rotation = rotation;
this.Owner = owner;
this.eventChannel = new MessageChannel<ItemEventMessage>(ItemEventMessage.CounterEventSend);
this.disposeChannel = new MessageChannel<ItemDisposedMessage>(MessageCounters.CounterSend);
this.positionUpdateChannel = new MessageChannel<ItemPositionMessage>(MessageCounters.CounterSend);
this.properties = properties ?? new Hashtable();
if (properties != null)
{
this.PropertiesRevision++;
}
this.id = id;
this.world = world;
this.type = type;
}
public static void EnterWorld(
Client client, string worldName, string username, Hashtable properties, Vector position, Vector viewDistanceEnter, Vector viewDistanceExit)
{
var data = new Dictionary<byte, object>
{
{ (byte)ParameterCode.WorldName, worldName },
{ (byte)ParameterCode.Username, username },
{ (byte)ParameterCode.Position, position },
{ (byte)ParameterCode.ViewDistanceEnter, viewDistanceEnter },
{ (byte)ParameterCode.ViewDistanceExit, viewDistanceExit }
};
if (properties != null)
{
data.Add((byte)ParameterCode.Properties, properties);
}
client.SendOperation((byte)OperationCode.EnterWorld, data, true);
}
public GridWorld(BoundingBox area, Vector tileDimensions)
{
// 2D grid: extend Z to max possible
this.Area = area;
this.TileDimensions = tileDimensions;
this.TileX = (int)Math.Ceiling(Area.Size.X / (double)tileDimensions.X);
this.TileY = (int)Math.Ceiling(Area.Size.Y / (double)tileDimensions.Y);
this.worldRegions = new Region[TileX][];
for (int x = 0; x < TileX; x++)
{
this.worldRegions[x] = new Region[TileY];
for (int y = 0; y < TileY; y++)
{
this.worldRegions[x][y] = new Region(x, y);
}
}
}
public static void EnterWorld(
Game game, string worldName, string username, Hashtable properties, Vector position, Vector rotation, Vector viewDistanceEnter, Vector viewDistanceExit)
{
var data = new Dictionary<byte, object>
{
{ (byte)ParameterCode.WorldName, worldName },
{ (byte)ParameterCode.Username, username },
{ (byte)ParameterCode.Position, position },
{ (byte)ParameterCode.ViewDistanceEnter, viewDistanceEnter },
{ (byte)ParameterCode.ViewDistanceExit, viewDistanceExit }
};
if (properties != null)
{
data.Add((byte)ParameterCode.Properties, properties);
}
if (!rotation.IsZero)
{
data.Add((byte)ParameterCode.Rotation, rotation);
}
game.SendOperation(OperationCode.EnterWorld, data, true, Settings.OperationChannel);
}
private void OnKeyDown(object sender, KeyEventArgs e)
{
// ignore keyboard when entering text
if (this.textBoxPlayerText.Focused)
{
return;
}
switch (e.KeyCode)
{
case Keys.Space:
{
this.tabControlTabs.SuspendLayout();
if (this.tabControlTabs.SelectedTab == this.tabPageSettings)
{
var t = this.tabPageSettings.Tag as TabPage;
this.tabControlTabs.SelectedTab = t;
}
else
{
this.tabControlTabs.SelectedTab = this.tabPageSettings;
}
this.tabControlTabs.ResumeLayout(true);
return;
}
case Keys.Oemplus:
case Keys.Add:
{
var newPage = new GameTabPage { Padding = new Padding(3), UseVisualStyleBackColor = true };
this.tabControlTabs.TabPages.Add(newPage);
this.StartGame(newPage, Program.GetDefaultSettings());
newPage.Run();
return;
}
}
var page = this.tabControlTabs.SelectedTab as GameTabPage;
if (page == null)
{
return;
}
Game game = page.Game;
var settings = (Settings)game.Settings;
switch (e.KeyCode)
{
case Keys.M:
{
if (settings.AutoMove)
{
settings.AutoMove = false;
}
else
{
settings.AutoMove = true;
page.AutoMove();
}
break;
}
case Keys.W:
case Keys.NumPad8:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveUp, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.A:
case Keys.NumPad4:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveLeft, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.S:
case Keys.NumPad2:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveDown, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.D:
case Keys.NumPad6:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveRight, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.NumPad5:
{
game.Avatar.MoveAbsolute(game.WorldData.BoundingBox.Max / 2, Vector.Zero);
break;
}
case Keys.NumPad7:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveUpLeft, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.NumPad9:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveUpRight, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.NumPad1:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveDownLeft, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.NumPad3:
{
game.Avatar.MoveRelative(AddVelocity(Game.MoveDownRight, settings.AutoMoveVelocity), Vector.Zero);
break;
}
case Keys.OemMinus:
case Keys.Subtract:
{
this.StopGame(page);
break;
}
case Keys.Insert:
{
page.SpawnBot();
break;
}
case Keys.Delete:
{
page.DestroyBot();
break;
}
case Keys.OemOpenBrackets:
{
Vector viewDistance = new Vector(page.MainCamera.ViewDistanceEnter);
viewDistance.X = Math.Min(page.Game.WorldData.Width, viewDistance.X - (page.Game.WorldData.TileDimensions.X / 2));
viewDistance.Y = Math.Min(page.Game.WorldData.Height, viewDistance.Y - (page.Game.WorldData.TileDimensions.Y / 2));
page.MainCamera.SetViewDistance(viewDistance);
break;
}
case Keys.OemCloseBrackets:
{
Vector viewDistance = new Vector(page.MainCamera.ViewDistanceEnter);
viewDistance.X = Math.Min(page.Game.WorldData.Width, viewDistance.X + (page.Game.WorldData.TileDimensions.X/2));
viewDistance.Y = Math.Min(page.Game.WorldData.Height, viewDistance.Y + (page.Game.WorldData.TileDimensions.Y/2));
page.MainCamera.SetViewDistance(viewDistance);
break;
}
}
}
private static Vector AddVelocity(Vector input, int velocity)
{
return input*velocity;
}
/// <summary>
/// Override to include the <see cref = "Coordinate" /> for the <see cref = "MmoRadar" />.
/// </summary>
/// <param name = "position">
/// The position.
/// </param>
/// <param name = "region">
/// The region.
/// </param>
/// <returns>
/// An instance of <see cref = "MmoItemPositionUpdate" />.
/// </returns>
protected override ItemPositionMessage GetPositionUpdateMessage(Vector position, Region region)
{
return new MmoItemPositionUpdate(this, position, region, this.Coordinate);
}
public InterestArea(byte cameraId, Game game, Vector position)
{
this.game = game;
this.cameraId = cameraId;
this.Position = position;
}
public void SetViewDistance(Vector viewDistance)
{
if (viewDistance.X < 0)
{
viewDistance.X = 0;
}
if (viewDistance.Y < 0)
{
viewDistance.Y = 0;
}
this.ViewDistanceEnter = viewDistance;
this.ViewDistanceExit = Vector.Max(
this.ViewDistanceEnter + this.game.WorldData.TileDimensions, this.ViewDistanceEnter*1.5f
);
Operations.SetViewDistance(this.game, this.ViewDistanceEnter, this.ViewDistanceExit);
this.game.Avatar.SetInterestAreaViewDistance(this);
}
public void Move(Vector newPosition)
{
if (this.AttachedItem == null)
{
this.Position = newPosition;
Operations.MoveInterestArea(this.game, this.cameraId, newPosition);
return;
}
throw new InvalidOperationException("cannot move attached interest area manually");
}
private static void EnterWorld(
Client client, string worldName, Vector position, Vector viewDistanceEnter, Vector viewDistanceExit, Hashtable properties)
{
client.ResetEvent();
client.SendOperation(Operations.EnterWorld(worldName, client.Username, properties, position, viewDistanceEnter, viewDistanceExit));
ReceiveOperationResponse(client, ReturnCode.Ok); // blocking
}
private void PublishUpdate(Item item, Vector position, bool remove, bool unreliable)
{
var updateEvent = GetUpdateEvent(item, position, remove);
IEventData eventData = new EventData((byte)EventCode.RadarUpdate, updateEvent);
var message = new ItemEventMessage(item, eventData, new SendParameters { Unreliable = unreliable, ChannelId = Settings.RadarEventChannel });
this.channel.Publish(message);
}
public ItemSnapshot(Item source, Vector position, Vector rotation, Region worldRegion, int propertiesRevision)
{
this.Source = source;
this.Position = position;
this.Rotation = rotation;
this.PropertiesRevision = propertiesRevision;
}
public Client(string name, Vector position)
: this(name)
{
this.Position = position;
}
private static object GetUpdateEvent(Item item, Vector position, bool remove)
{
return new RadarUpdate { ItemId = item.Id, ItemType = item.Type, Position = position, Remove = remove };
}
