// Use this for initialization
void Start()
{
// Get the Presenter from the card host components
this.CharacterCardSelectorPresenter = CharacterCardHost.GetComponent <CardSelectorPresenter>();
this.WeaponCardSelectorPresenter = WeaponCardHost.GetComponent <CardSelectorPresenter>();
this.RoomCardSelectorPresenter = RoomCardHost.GetComponent <CardSelectorPresenter>();
// cache the default camera position
this.defaultCameraPosition = Camera.main.transform.position;
// Clear out move options on start.
ClearAllMoveOptions();
// TODO: Subscribe to server listener for when move options are available.
// TODO: Test code. Comment me out later
var mockObject1 = new MoveViewModel(StandardEnums.MoveEnum.MoveToHallway, StandardEnums.LocationEnum.DinKitch);
var mockObject2 = new MoveViewModel(StandardEnums.MoveEnum.MoveToRoomAndSuggest, StandardEnums.LocationEnum.Library);
var mockObject3 = new MoveViewModel(StandardEnums.MoveEnum.StayInRoomAndSuggest, StandardEnums.LocationEnum.Lounge);
var mockObject4 = new MoveViewModel(StandardEnums.MoveEnum.TakeSecretPassageAndSuggest, StandardEnums.LocationEnum.Hall);
var mockObject5 = new MoveViewModel(StandardEnums.MoveEnum.MakeAnAccusation, null);
var mockObject6 = new MoveViewModel(StandardEnums.MoveEnum.EndTurn, null);
var mockObject7 = new MoveViewModel(StandardEnums.MoveEnum.MoveToHallway, StandardEnums.LocationEnum.LibBill);
AddMoveOptions(new List <MoveViewModel>()
{
mockObject1, mockObject2, mockObject3, mockObject4, mockObject5, mockObject6, mockObject7
});
cachedMoveMessage = null;
}
/// <summary>
/// When move button is clicked, make the move for the player.
/// </summary>
/// <param name="movePerformed"></param>
private void MoveButtonClickHandler(MoveViewModel movePerformed)
{
// Start creating the MoveMessage object and see if suggestion/accusation info is needed
cachedMoveMessage = new MoveMessage(movePerformed.MoveID, movePerformed.LocationID);
switch (movePerformed.MoveID)
{
// If the MoveID requires a suggestion to happen, start prompting for Character Selection
case StandardEnums.MoveEnum.MoveToRoomAndSuggest:
case StandardEnums.MoveEnum.TakeSecretPassageAndSuggest:
case StandardEnums.MoveEnum.StayInRoomAndSuggest:
PromptForCharacterSelection();
break;
// If the MoveID is for an accusation, start prompting for a Room Selection
case StandardEnums.MoveEnum.MakeAnAccusation:
PromptForRoomSelection();
break;
// Otherwise, we have all the info we need and we can send the result to the server!
case StandardEnums.MoveEnum.MoveToHallway:
case StandardEnums.MoveEnum.EndTurn:
SendMoveToServer();
break;
}
}
/// <summary>
/// Send the cached move message to the server
/// </summary>
private void SendMoveToServer()
{
// Send move to server
this.cachedMoveMessage = null;
ClearAllMoveOptions();
}
private void button2_Click(object sender, EventArgs e)
{
var sendObj = new Send();
var msg = new MoveMessage {Comment = "Message", What = Guid.NewGuid(), Where = new Point(100,100)};
sendObj.CreateConnection("192.168.1.68", 5672, "guest", "guest");
sendObj.SendSerializableObject(msg, "2.2.2");
}
private void Setup(MoveMessage setupMessage)
{
Log("Let's setup");
var map = Converter.Convert(setupMessage.map);
var myPunter = setupMessage.punter;
scorer.Init(map);
punter.Init(map, setupMessage.punters, new Punter {
Id = myPunter
});
var gameStateMessage = new GameStateMessage
{
MapContract = setupMessage.map,
Moves = new List <MoveCommand>(),
Punters = setupMessage.punters,
MyPunter = myPunter,
ScorerState = scorer.State,
PunterState = punter.State
};
transport.Send(new SetupCommand {
ready = myPunter, state = gameStateMessage
});
}
private void ElementOnMouseMove(object sender, MouseEventArgs mouseEventArgs)
{
if (!((UIElement)sender).IsMouseCaptured)
{
return;
}
var parent = Application.Current.Windows[1];
var mousePos = mouseEventArgs.GetPosition(parent);
var diff = (mousePos - _mouseStartPosition);
if (MovingHost)
{
difX = _hostStartPosition.X + (diff.X / GlobalSettings.Instance.mapzoom) - lastX;
lastX = _hostStartPosition.X + (diff.X / GlobalSettings.Instance.mapzoom);
difY = _hostStartPosition.Y + (diff.Y / GlobalSettings.Instance.mapzoom) - lastY;
lastY = _hostStartPosition.Y + (diff.Y / GlobalSettings.Instance.mapzoom);
if (difX + difY != 0)
{
hostmoved = true;
}
MoveMessage move = new MoveMessage();
move.Col = difX;
move.Row = difY;
Messenger.Default.Send(move);
}
else if (MovingMap)
{
var scrollViewer = Application.Current.Windows[1].FindChild <ScrollViewer>("MapViewer");
scrollViewer.ScrollToHorizontalOffset(-diff.X + diffPoint.X);
scrollViewer.ScrollToVerticalOffset(-diff.Y + diffPoint.Y);
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
MessageHeader header = JsonUtility.FromJson <MessageHeader>(recMsg);
switch (header.type)
{
case MessageType.HEARTBEAT:
Debug.Log("Heartbeat");
break;
case MessageType.BATTLE_MSG:
var bMsg = JsonUtility.FromJson <BattleMessage>(recMsg);
BattleData.SetBattleData(bMsg);
Debug.Log("Battle Started");
GameController.Instance.StartMultiplayerBattle();
break;
case MessageType.MOVE_MSG: //Move Received
var mMsg = JsonUtility.FromJson <MoveMessage>(recMsg);
move = mMsg;
Debug.Log("Move " + mMsg.MoveName + " Received");
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
public static MoveMessage Move(Guid playerId, int targetX, int targetY)
{
if (targetX < 0 || targetX > 2000 || targetY < 0 || targetY > 2000)
{
throw new ArgumentException("Target position is out of bounds");
}
using (var context = new DataContext())
{
var player = context.Players.Include(p => p.Ship).FirstOrDefault(p => p.Id == playerId && p.Active);
if (player == null)
{
throw new ArgumentException(string.Format("Player with Id {0} was not found", playerId));
}
var ship = player.Ship;
ship.TargetX = targetX;
ship.TargetY = targetY;
ship.Speed = 5 + ship.SpaceLevel * 2;
context.SaveChanges();
var message = new MoveMessage()
{
ShipId = ship.Id,
X = ship.X,
Y = ship.Y,
TargetX = ship.TargetX,
TargetY = ship.TargetY,
Speed = ship.Speed,
Level = ship.SpaceLevel,
};
return(message);
}
}
public void MapScrollUp(object sender, MouseWheelEventArgs mouseEventArgs)
{
MoveMessage move = new MoveMessage();
move.Zoom = mouseEventArgs.Delta;
Messenger.Default.Send(move);
}
void UpdateMovement()
{
if (m_moveMessage.Count == 0)
{
m_desiredSpeed = 0;
return;
}
// Adjust the forward speed towards the desired speed.
m_desiredSpeed = maxSpeed;
m_currentSpeed = Mathf.MoveTowards(m_currentSpeed, m_desiredSpeed, acceleration * Time.deltaTime);
MoveMessage step = m_moveMessage.Peek();
Vector3 position = step.position;
float distance = Vector3.Distance(transform.position, position);
if (distance > 3.0f)
{ // if the distance between current position and next position are not close
transform.LookAt(position);
}
float t = (distance < float.Epsilon) ? 1.0f : (m_currentSpeed + 0.1f) * Time.deltaTime / distance;
// cannot greater than 1
t = t > 1.0f ? 1.0f : t;
position = Vector3.Lerp(transform.position, position, t);
if (step.message == MsgType.MOVE)
{
// prject this position on to ground
Vector3 hit = HitGround(position);
if ((hit - transform.position).sqrMagnitude > 0.1f)
{ // not too close, prevent dead loop
position = hit;
}
}
DebugUtil.DrawLine(transform.position, position, Color.red);
transform.position = position;
// send to server to revise the sprite position
PositionRevise();
if (step.message == MsgType.END_BACK ||
step.message == MsgType.BEGIN_BACK)
{
// end chase enemy
m_target = null;
}
if (Mathf.Abs(1.0f - t) < 0.001)
{ // is nearly begin or end position
m_receiver.OnReceiveMessage(step.message, this, step.position);
m_moveMessage.Dequeue();
if (step.message == MsgType.END_CHASE)
{
DebugUtil.DrawLine(transform.position, transform.position + Vector3.up, Color.green);
}
}
}
private static object process(MoveMessage moveMessage)
{
if (moveMessage == null)
{
return(null);
}
var movingPlayer = Players.FirstOrDefault(plyr => plyr.playerID == moveMessage.playerID);
movingPlayer.X = moveMessage.NewX;
movingPlayer.Y = moveMessage.NewY;
Console.WriteLine("{0} has moved to X: {1} Y: {2} at {3}",
movingPlayer.GamerTag,
movingPlayer.X.ToString(),
movingPlayer.Y.ToString(),
DateTime.Now.ToString());
if (movingPlayer != null)
{
//movingPlayer.X = moveMessage.NewX;
//movingPlayer.Y = moveMessage.NewY;
//movingPlayer.header = "Moved_To";
//NetOutgoingMessage MovedMessage = server.CreateMessage();
//string json = JsonConvert.SerializeObject(movingPlayer);
//MovedMessage.Write(json);
//server.SendToAll(MovedMessage, NetDeliveryMethod.ReliableOrdered);
DataHandler.sendNetMess <MoveMessage>(server, moveMessage, SENT.TOALL);
}
return(moveMessage);
}
public MoveMessage GetMove()
{
var _move = move;
move = null;
return(_move);
}
// Client
private void OnMoveMessage(NetworkMessage _networkMessage)
{
// Read message
MoveMessage msg = _networkMessage.ReadMessage <MoveMessage>();
//Debug.Log("Received movement update for object: " + msg.objectId.ToString());
if (msg.objectType == 0)
{
// Send msg to player object
PlayerManager tempPlayer = NetworkHelper.GetObjectByNetIdValue <PlayerManager>((uint)msg.objectId, false);
tempPlayer.OnPlayerMove(msg.position, msg.rotation, msg.time);
}
else if (msg.objectType == 1) // bullet
{
Bullet temp = NetworkHelper.GetObjectByNetIdValue <Bullet>((uint)msg.objectId, false);
if (temp)
{
temp.OnMovementReceived(msg.position, msg.rotation, msg.time);
}
}
else if (msg.objectType == 2)
{
Flag temp = NetworkHelper.GetObjectByNetIdValue <Flag>((uint)msg.objectId, false);
if (temp)
{
temp.OnMovementReceived(msg.position, msg.rotation, msg.time);
}
}
}
private void OnMove(MoveMessage data)
{
var delta = data.SumMovements();
X += delta.x;
Y += delta.y;
UpdateRegion();
/*
* client implicitly sets the facing direction for the movign entity itself
* so there is no need to call SetFacingDirection and send out an entity-wide message
* we can just silently change the direction and if we need to ever check it, we
* will find good data no matter what.
*/
// also we set the last moving direction here
if (data.IsWalking)
{
FacingState = new DirecionFacingState(data.Dir1, this);
LastMovedDirection = data.Dir1;
}
else
{
LastMovedDirection = data.Dir2;
FacingState = new DirecionFacingState(data.Dir2, this);
}
}
private void Scoring(MapContract map,
List <MoveCommand> lastMoves,
List <MoveCommand> moves)
{
Log("SCORING!");
var scores = LogScores(map, moves);
var serializedScores = JsonConvert.SerializeObject(scores.OrderByDescending(x => x.Item2).Select(x => new { Punter = x.Item1.Id, Score = x.Item2 }));
File.WriteAllText("scores.txt", serializedScores);
foreach (var connection in session.Clients)
{
var scoringMessage = new MoveMessage
{
stop = new MoveMessage.InternalStop
{
moves = lastMoves,
scores = scores
.Select(x => new MoveMessage.Score
{
punter = x.Item1.Id,
score = x.Item2
})
.ToArray()
}
};
connection.Client.Write(serializer.Serialize(scoringMessage));
}
Thread.Sleep(1000);
Environment.Exit(0);
}
public void SendMove()
{
var moveMessage = new MoveMessage(moveCommand.Item.Guid.ToString(), moveCommand.Destination.Guid.ToString());
var messageString = JsonConvert.SerializeObject(moveMessage, _serializerSettings);
Debug.Log(messageString);
Debug.Log("Sending");
webSocket.Send(messageString);
}
public void CloneTest()
{
var message1 = new EmptyMessage();
var clone1 = message1.Clone();
Assert.IsTrue(clone1 is EmptyMessage);
//string message1Json = message1.ToString();
//Debug.Log(message1Json);
Game.Initialize();
Game.SetTestMode();
var card = new Card00001(Game.Player);
var targets = new List <Card>()
{
card
};
var message2 = new MoveMessage()
{
Targets = targets,
Reason = card.sk1
};
var clone2 = message2.Clone() as MoveMessage;
Assert.IsTrue(clone2 is MoveMessage);
Assert.IsTrue(clone2.Reason == card.sk1);
Assert.IsFalse(clone2.Targets == targets);
Assert.IsTrue(clone2.Targets.SequenceEqual(targets));
//string message2Json = message2.ToString();
//Debug.Log(message2Json);
DeployMessage message3 = new DeployMessage()
{
Targets = targets,
ActionedList = new List <bool>()
{
true
},
ToFrontFieldList = new List <bool>()
{
false
},
Reason = null
};
DeployMessage clone3 = message3.Clone() as DeployMessage;
Assert.IsTrue(clone3 is DeployMessage);
Assert.IsTrue(clone3.Reason == null);
Assert.IsFalse(clone3.Targets == targets);
Assert.IsTrue(clone3.Targets.SequenceEqual(targets));
Assert.IsTrue(clone3.ActionedList[0]);
Assert.IsFalse(clone3.ToFrontFieldList[0]);
clone3.ActionedList[0] = false;
Assert.IsFalse(clone3.ActionedList[0]);
Assert.IsTrue(message3.ActionedList[0]);
//string message3Json = message3.ToString();
//Debug.Log(message2Json);
}
public void OnMoveMessage(MoveMessage message)
{
var entity = World.Entities.FirstOrDefault(e => e.Id == message.EntityId);
if (entity is Hero hero)
{
hero.Direction = message.Direction;
}
}
public void SendMove(Move move, bool hit)
{
var movemsg = new MoveMessage();
movemsg.MoveName = move.Base.name;
movemsg.hit = hit;
SendToServer(JsonUtility.ToJson(movemsg));
}
private void valid_NewPositions(MoveMessage newPosition)
{
foreach (Player op in OtherPlayers)
{
if (op.id.ToString() == newPosition.playerID)
{
op.position = new Vector2(newPosition.NewX, newPosition.NewY);
}
}
}
private void OnMoveMessageReceived(BaseMessage msg)
{
MoveMessage mmsg = msg as MoveMessage;
uint playerId = mmsg.PlayerId;
MovementComponent movementComponent = GameManager.Instance.GetPlayerComponent <MovementComponent>(playerId);
if (movementComponent != null)
{
movementComponent.OnMoveMsgReceived(mmsg);
}
}
void Start()
{
connectionIndexMap = new Dictionary <string, int>();
Server server = new Server(new IPEndPoint(IPAddress.Parse("127.0.0.1"), listenPort));
server.OnClientConnected += (object sender, OnClientConnectedHandler e) =>
{
Debug.Log("Player Connected:" + e.GetClient().GetGuid());
PrefabEntityLibrary.PlayerSpawnQueue.Enqueue(e.GetClient().GetGuid());
// Connects the incoming websocket to the com.unity.transport systems.
};
server.OnClientDisconnected += (object sender, OnClientDisconnectedHandler e) =>
{
Debug.Log("Player Disconnected:" + e.GetClient().GetGuid());
// Disconnect from the proxy server when a client is gone.
// int connectionIdx = connectionIndexMap[e.GetClient().GetGuid()];
// mProxConnections[connectionIdx] = default(NetworkConnection);
};
server.OnMessageReceived += (object sender, OnMessageReceivedHandler e) =>
{
//e.GetClient().GetGuid()
string clientId = e.GetClient().GetGuid();
string msg = e.GetMessage();
string[] args = msg.Split(',');
if (args[0].Equals("move"))
{
Debug.Log("RJXXXXXXXXXXX message from server.....");
MoveMessage mm = new MoveMessage();
mm.clientId = e.GetClient().GetGuid();
mm.movePost.x = (float)Convert.ToDouble(args[1]);
mm.movePost.y = (float)(float)Convert.ToDouble(args[2]);
NetMoveQueue.queue.Enqueue(mm);
// EntityQuery query = GetEntityQuery(typeof(NetworkComponent));
}
else if (args[0].Equals("fire"))
{
}
else if (args[0].Equals("shield"))
{
}
};
server.OnSendMessage += (object sender, OnSendMessageHandler e) =>
{
// Console.WriteLine("Sent message: '{0}' to client {1}", e.GetMessage(), e.GetClient().GetGuid());
};
}
public async Task PlayerMove(GameMessage message)
{
MoveMessage moveMsg = message as MoveMessage;
if (moveMsg == null)
{
throw new Exception($"Player move recieved a message that was not of type {typeof(MoveMessage)} but was {message.GetType()}");
}
logger.LogInformation($"Player {moveMsg.PlayerId} moved in direction {moveMsg.Direction}");
await stream.OnNextAsync(message);
}
public void SendMovementMessage(int _objectId, Vector3 _position, Quaternion _rotation, float _time)
{
MoveMessage msg = new MoveMessage();
msg.objectId = _objectId;
msg.position = _position;
msg.rotation = _rotation;
msg.time = _time;
msg.objectType = 0;
NetworkManager.singleton.client.Send(CustomMsgType.Move, msg);
//Debug.Log("Sent movement msg");
}
// Server
private void OnMovement(NetworkMessage _networkMessage)
{
// Read message
MoveMessage temp = _networkMessage.ReadMessage <MoveMessage>();
// this is player movement
if (temp.objectType == 0)
{
// Update server replication
PlayerManager tempPlayer = NetworkHelper.GetObjectByNetIdValue <PlayerManager>((uint)temp.objectId, true);
tempPlayer.OnPlayerMove(temp.position, temp.rotation, temp.time);
NetworkServer.SendToAll(CustomMsgType.Move, temp);
}
}
protected override void onMessageMove(MoveMessage gm)
{
InfoLog.WriteInfo("MessageMove: PlayerID:" + gm.IdPlayer + " UnitID:" + gm.IdUnit, EPrefix.Move);
Player p = this.players[gm.IdPlayer];
Unit u = p.GetUnit(ObjectID.From(gm.IdUnit, gm.IdPlayer));
if (u == null)
{
InfoLog.WriteInfo("MessageMove: PlayerID:" + gm.IdPlayer + " unit has been already destroyed", EPrefix.Move);
return;
}
u.OrderedAttack = false;
u.MoveTo(gm.Destination);
}
// Server
private void SendMovementMessage()
{
this.timeBetweenMovementEnd = Time.time;
MoveMessage msg = new MoveMessage();
msg.objectId = (int)this.netId.Value;
msg.position = this.transform.position;
msg.rotation = this.transform.rotation;
msg.time = (this.timeBetweenMovementEnd - this.timeBetweenMovementStart);
msg.objectType = 1;
//NetworkManager.singleton.client.Send(CustomMsgType.Move, msg);
NetworkServer.SendToAll(CustomMsgType.Move, msg);
}
public static InstanceData Move(MoveMessage msg)
{
switch (msg.type)
{
case "node":
MoveableNode mnode = new MoveableNode(new InstanceID()
{
NetNode = (ushort)msg.id
});
mnode.MoveCall(msg.position != null ? msg.position.ToUnity() : mnode.position);
return(NetLogic.PrepareNode((ushort)msg.id));
case "segment":
MoveableSegment seg = new MoveableSegment(new InstanceID()
{
NetSegment = (ushort)msg.id
});
seg.MoveCall(msg.position != null ? msg.position.ToUnity() : seg.position);
return(NetLogic.PrepareSegment((ushort)msg.id));
case "building":
MoveableBuilding b = new MoveableBuilding(new InstanceID()
{
Building = (ushort)msg.id
});
b.MoveCall(msg.position != null ? msg.position.ToUnity() : b.position, msg.is_angle_defined ? msg.angle : b.angle);
return(ManagersLogic.PrepareBuilding((ushort)msg.id));
case "prop":
MoveableProp p = new MoveableProp(new InstanceID()
{
Prop = (ushort)msg.id
});
p.MoveCall(msg.position != null ? msg.position.ToUnity() : p.position, msg.is_angle_defined ? msg.angle : p.angle);
return(ManagersLogic.PrepareProp((ushort)msg.id));
case "tree":
MoveableTree t = new MoveableTree(new InstanceID()
{
Tree = msg.id
});
t.MoveCall(msg.position != null ? msg.position.ToUnity() : t.position);
return(ManagersLogic.PrepareTree(msg.id));
default:
throw new Exception($"Cannot move {msg.type}");
}
}
public bool Move(MoveType direction)
{
if (gameFinished != true)
{
ConsoleWriter.Show(GUID + " wants to move from: " + Location + " in direction: " + direction);
MoveMessage msg = new MoveMessage(GUID, GameId, direction);
LastActionTaken = ActionToComplete = ActionType.Move;
LastMoveTaken = direction;
var futureLocation = CalculateFutureLocation(Location, direction);
Controller.BeginSend(msg.Serialize()); //każda akcja od razu się wysyła, ustawia również LastActionTaken i dla move LastMoveTaken !!!!!
WaitForActionComplete();
return(Location != null && Location.Equals(futureLocation));
}
return(false);
}
public void Accept()
{
if (moveRequests.Count > 0)
{
MoveRequest mr = moveRequests[0];
// broadcast.
var moveMessage = new MoveMessage();
moveMessage.id = mr.id;
moveMessage.direction = mr.direction;
NetworkServer.SendToAll(CustomNetMsg.Move, moveMessage);
moveRequests.RemoveAt(0);
UpdateMoveRequestUI();
handleMovement(moveMessage.id, moveMessage.direction);
}
}
bool HandleMoveMessage(BaseMessage msg)
{
if (mat.color == Color.red)
{
MoveMessage castMsg = msg as MoveMessage;
if (moveVector == castMsg._vecValue)
{
moveVector = new Vector3(0, 0, 0);
moving = false;
return(false);
}
moveVector = castMsg._vecValue;
moving = true;
upswing = true;
return(false);
}
return(false);
}
