void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
//List<int> syncTemp;
if (stream.isWriting)
{
//Debug.Log("Wirting!");
//syncTemp = puzzle1Answer;
/*
for(int i =0;i<syncTemp.Count;i++)
{
stream.Serialize(ref syncTemp[i]);
}
*/
//stream.Serialize(ref syncTemp);
}
else
{
//Debug.Log("Received!");
//stream.Serialize(ref syncTemp);
/*
for(int i =0;i<syncTemp.Count;i++)
{
syncTemp[i] = puzzle1Answer[i];
}
*/
//syncTemp = puzzle1Answer;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
Vector3 syncVelocity = Vector3.zero;
if (stream.isWriting)
{
syncPosition = GetComponent<Rigidbody>().position;
stream.Serialize(ref syncPosition);
syncPosition = GetComponent<Rigidbody>().velocity;
stream.Serialize(ref syncVelocity);
//finPos = GetComponent<Rigidbody>().transform;
//Debug.Log("FinPos: " + finPos);
}
else
{
stream.Serialize(ref syncPosition);
stream.Serialize(ref syncVelocity);
syncTime = 0f;
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
syncEndPosition = syncPosition + syncVelocity * syncDelay;
syncStartPosition = GetComponent<Rigidbody>().position;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
Vector3 syncVelocity = Vector3.zero;
if (stream.isWriting)
{
syncPosition = rigidbody.position;
stream.Serialize(ref syncPosition);
syncPosition = rigidbody.velocity;
stream.Serialize(ref syncVelocity);
}
else
{
stream.Serialize(ref syncPosition);
stream.Serialize(ref syncVelocity);
syncTime = 0f;
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
syncEndPosition = syncPosition + syncVelocity * syncDelay;
syncStartPosition = rigidbody.position;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
BoardLocation newLocation= new BoardLocation(new IntVector2(0,0), new IntVector2(0,0));
int maxSpeed = 0;
IntVector2 direction = new IntVector2(0,0);
BoardLocation lastBoardLocation = new BoardLocation(new IntVector2( 0, 0), new IntVector2(0,0));
if (stream.isWriting)
{
newLocation = this.boardLocation;
maxSpeed = this.maxSpeed;
direction = this.direction;
lastBoardLocation = this.lastBoardLocation;
newLocation.Serialize( stream );
stream.Serialize( ref maxSpeed );
direction.Serialize( stream );
lastBoardLocation.Serialize( stream );
}
else
{
newLocation.DeSerialize( stream );
stream.Serialize( ref maxSpeed );
direction.DeSerialize( stream );
lastBoardLocation.DeSerialize( stream );
this.boardLocation = newLocation;
this.maxSpeed = maxSpeed;
this.direction = direction;
this.lastBoardLocation = lastBoardLocation;
}
}
public void OnSerializeNetworkView2D(BitStream stream, NetworkMessageInfo info,
UnitActionCommand pUnitActionCommand, bool pIsAlive)
{
Transform lTransform = characterController.transform;
Vector3 lData = Vector3.zero;
//---------------------------------------------------
if (stream.isWriting)
{
lData = lTransform.position;
lData.z = yVelocity;
}
//---------------------------------------------------
stream.Serialize(ref lData);
//---------------------------------------------------
if (stream.isReading)
{
yVelocity = lData.z;
lData.z = 0f;
lTransform.position = lData;
var lDeltaTime = (float)(Network.time - info.timestamp);
if (lDeltaTime > 0.02f)
update2D(pUnitActionCommand, UnitFace.getValue(pUnitActionCommand.face),
pIsAlive, lDeltaTime * Time.timeScale);
lastUpdateTime = Time.time;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (!stream.isWriting)
{
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if(stream.isWriting) {
//Position Synchronization
Vector3 position = transform.position; stream.Serialize(ref position);
//Rotation Synchronization
Quaternion rotation = transform.rotation; stream.Serialize(ref rotation);
//Current Movement
Vector3 directionVector = motor.inputMoveDirection;
stream.Serialize(ref directionVector);
}
else {
//Position Synchronization
Vector3 position = Vector3.zero; stream.Serialize(ref position);
transform.position = position;
//Rotation synchronization
Quaternion rotation = Quaternion.identity; stream.Serialize(ref rotation);
transform.rotation = rotation;
//Current Movement
Vector3 directionVector = Vector3.zero;
stream.Serialize(ref directionVector);
motor.inputMoveDirection = directionVector;
}
}
public virtual void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (_animator != null) {
foreach (AnimatorControllerParameter param in _animator.parameters) {
AnimatorControllerParameterType paramType = param.type;
switch (paramType) {
case AnimatorControllerParameterType.Bool:
bool boolParam = _animator.GetBool (param.nameHash);
stream.Serialize (ref boolParam);
if (stream.isReading) {
_animator.SetBool (param.nameHash, boolParam);
}
break;
case AnimatorControllerParameterType.Float:
float floatParam = _animator.GetFloat (param.nameHash);
stream.Serialize (ref floatParam);
if (stream.isReading) {
_animator.SetFloat (param.nameHash, floatParam);
}
break;
case AnimatorControllerParameterType.Int:
int intParam = _animator.GetInteger (param.nameHash);
stream.Serialize (ref intParam);
if (stream.isReading) {
_animator.SetInteger (param.nameHash, intParam);
}
break;
}
}
}
}
void OnSerializeNetworkView( BitStream stream, NetworkMessageInfo info )
{
Vector3 syncPosition = Vector3.zero; // для синхронизации позиции
Vector3 syncVelocity = Vector3.zero; // для синхронизации действующей силы
Quaternion syncRotation = Quaternion.identity; // для синхронизации поворота
if ( stream.isWriting ) { // если отправляем в сеть то считываем данные обьекта и отправляем
syncPosition = rigidbody.position;
stream.Serialize( ref syncPosition );
syncPosition = rigidbody.velocity;
stream.Serialize( ref syncVelocity );
syncRotation = rigidbody.rotation;
stream.Serialize( ref syncRotation );
} else { // иначе считываем из сети
stream.Serialize( ref syncPosition );
stream.Serialize( ref syncVelocity );
stream.Serialize( ref syncRotation );
syncTime = 0f; // сбрасываем время синхронизации
syncDelay = Time.time - lastSynchronizationTime; // получаем дельту придыдущей синхронизации
lastSynchronizationTime = Time.time; // записываем новое время последней синхронизации
syncEndPosition = syncPosition + syncVelocity * syncDelay; // конечная точка в которую двигаеться обьект
syncStartPosition = rigidbody.position; // начальная точка равна текущей позиции
syncEndRotation = syncRotation; // конечный поворот
syncStartRotation = rigidbody.rotation; // начальный поворот
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
Quaternion rot = Quaternion.identity;
if (stream.isWriting)
{
syncPosition = transform.position;
rot = transform.rotation;
stream.Serialize(ref syncPosition);
stream.Serialize(ref rot);
}
else
{
stream.Serialize(ref syncPosition);
stream.Serialize(ref rot);
syncTime = 0f;
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
syncStartPosition = transform.position;
syncEndPosition = syncPosition;
qSrot = transform.rotation;
qErot = rot;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncDest = Vector3.zero;
Vector3 syncPos = Vector3.zero;
if (stream.isWriting && Network.isServer)
{
syncDest = destination;
syncPos = this.gameObject.transform.position;
stream.Serialize(ref syncDest);
stream.Serialize(ref syncPos);
}
else if (stream.isReading)
{
stream.Serialize(ref syncDest);
stream.Serialize(ref syncPos);
destination = syncDest;
if (agent != null)
agent.SetDestination (destination);
/*
Vector3 diffPos = this.gameObject.transform.position - syncPos;
if (diffPos.sqrMagnitude >= 1){
this.gameObject.transform.position = syncPos;
}
*/
}
}
//Sends or Recieves Serialized variables over the network.
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
//Variable to be used over the network.
Vector3 syncPosition = Vector3.zero;
//If you're the owner of the object you are sending the objects position over the network.
if(stream.isWriting)
{
//Set syncPosition to this objects current position.
syncPosition = transform.position;
//Send the position over the network.
stream.Serialize(ref syncPosition);
}
//You're recieving the position from the Owner.
else
{
//Serialize the new incoming position.
stream.Serialize(ref syncPosition);
syncTime = 0.0f;
syncDelay = Time.time - lastSyncTime;
lastSyncTime = Time.time;
syncStartPosition = transform.position;
syncEndPosition = syncPosition;
}
}
// Update is called once per frame
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
{
Vector3 position = rigidbody.position;
Vector3 forward = transform.forward;
Vector3 velocity = rigidbody.velocity;
Vector3 angularVelocity = rigidbody.angularVelocity;
if(stream.isWriting)
{
stream.Serialize(ref position);
stream.Serialize(ref forward);
stream.Serialize(ref velocity);
stream.Serialize(ref angularVelocity);
}
else
{
stream.Serialize(ref position);
targetPosition = position;
stream.Serialize(ref forward);
targetForward = forward;
stream.Serialize(ref velocity);
speed = velocity;
stream.Serialize(ref angularVelocity);
angularSpeed = angularVelocity;
}
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
if ((networkView.isMine) && stream.isWriting)
{
//Write data to stream
syncPosition = transform.position;
stream.Serialize(ref syncPosition);
print (gameObject.name);
}
else
{
//Get data from stream
stream.Serialize(ref syncPosition);
//Calculate sync delay (ping, kind of)
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
NetworkManager.changeMenuDebugStatus("syncDelay: "+syncDelay);
//Set new start and end position for movement interpolation
syncStartPosition = syncEndPosition;
syncEndPosition = syncPosition;
print (syncStartPosition);
print ("end: "+syncEndPosition);
}
}
protected virtual void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (selected == _PlayerOwn || stream.isReading)
{
if (stream.isWriting)
{
syncPos = pos;
syncRot = rot;
//syncVel = controller.velocity;
}
stream.Serialize(ref syncPos);
stream.Serialize(ref syncRot);
//stream.Serialize(ref syncVel);
if (stream.isReading)
{
if (syncPos == Vector3.zero)
{ }
else
{
pos = syncPos;
rot = syncRot;
}
//vel = syncVel;
}
}
}
/*
[RPC]
public void reeling(float angle)
{
}
*/
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (stream.isWriting) {
} else {
// if (boat)
// transform.position = new Vector3(transform.position.x, boat.transform.position.y + boatOffsetY, transform.position.z);
/* Quaternion receivedRot = new Quaternion(0, 0, 0, 0);
stream.Serialize(ref receivedRot);
Quaternion rotationToUse = receivedRot;
transform.rotation = rotationToUse;*/
Vector3 receivedRot = Vector3.zero;
stream.Serialize (ref receivedRot);
acceRotationVector = receivedRot;
Quaternion rotation = Quaternion.LookRotation (receivedRot);
float angle = Quaternion.Angle (transform.rotation, rotation);
rotZ = rotation.eulerAngles.z;
rotX = rotation.eulerAngles.x;
rotY = rotation.eulerAngles.y;
if (angle > rotationBreak) {
transform.rotation = Quaternion.Lerp (transform.rotation, rotation, Time.deltaTime * rotationSpeed);
// Works -> transform.rotation = Quaternion.Lerp(transform.rotation, rotation, Time.deltaTime * rotationSpeed);
}
}
}
public void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 pos = observedTransform.position;
Quaternion rot = observedTransform.rotation;
if (stream.isWriting) {
//Debug.Log("Server is writing");
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
else {
//This code takes care of the local client!
stream.Serialize(ref pos);
stream.Serialize(ref rot);
receiver.serverPosition = pos;
receiver.serverRotation = rot;
//Smoothly correct clients position
//receiver.lerpToTarget();
//Take care of data for interpolating remote objects movements
// Shift up the buffer
for ( int i = serverStateBuffer.Length - 1; i >= 1; i-- ) {
serverStateBuffer[i] = serverStateBuffer[i-1];
}
//Override the first element with the latest server info
serverStateBuffer[0] = new NetworkState((float)info.timestamp, pos, rot);
}
}
public void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 pos = observedTransform.position;
Quaternion rot = observedTransform.rotation;
if(stream.isWriting) {
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
else{
stream.Serialize(ref pos);
stream.Serialize(ref rot);
reciever.serverPos = pos;
reciever.serverRot = rot;
reciever.lerpToTarget();
for( int i = serverStateBuffer.Length - 1; i >= 1;i--){
serverStateBuffer[i] = serverStateBuffer[i-1];
}
serverStateBuffer[0] = new NetState();
serverStateBuffer[0].setState((float)info.timestamp, pos, rot);
}
}
private void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (stream.isWriting)
{
Debug.Log("Writing.");
Vector3 pos = this.transform.position;
Vector3 orientation = this.transform.eulerAngles;
stream.Serialize(ref pos);
stream.Serialize(ref orientation);
}
else
{
Debug.Log("Receiving.");
Vector3 pos = Vector3.zero;
Vector3 orientation = Vector3.zero;
stream.Serialize(ref pos);
stream.Serialize(ref orientation);
this.transform.position = pos;
this.transform.eulerAngles = orientation;
}
}
/* This function is automatically called every time it sends or receives datas.
(To use for data that constantly changed) */
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Quaternion syncRotation = Quaternion.identity;
// The player is writing to the stream (= he moves its own Character...)
if (stream.isWriting)
{
syncRotation = transform.localRotation;
stream.Serialize(ref syncRotation);
}
// The ClientInstance of the player's opponent need to be moved
else
{
stream.Serialize(ref syncRotation);
// Interpolation : smoothing the transition from the old to the new data values
syncTime = 0f;
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
// Prediction : the rotation is "updated" before the new data is received
syncStartRotation = transform.localRotation;
syncEndRotation = syncRotation;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
//locateMarkersAndLimbs();
Vector3 tempPos = Vector3.zero;
Quaternion tempRot = Quaternion.identity;
//ADD THE parentP2 changes here as well! To stop jitter!!
if((Network.isServer)&&(stream.isWriting))
{
if(!parentP1)
{
tempPos = transform.position;
tempRot = transform.rotation;
stream.Serialize(ref tempPos);
stream.Serialize(ref tempRot);
}
}
if(Network.isClient)
{
if(!parentP1)
{
stream.Serialize(ref tempPos);
stream.Serialize(ref tempRot);
transform.position = tempPos;
transform.rotation = tempRot;
}
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (stream.isWriting)
{
Vector3 pos = transform.localPosition;
Quaternion rot = transform.localRotation;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
}
else
{
Vector3 pos = Vector3.zero;
Quaternion rot = Quaternion.identity;
stream.Serialize(ref pos);
stream.Serialize(ref rot);
for (int i = m_BufferedState.Length - 1; i >= 1; i--)
{
m_BufferedState[i] = m_BufferedState[i - 1];
}
State state;
state.timestamp = info.timestamp;
state.pos = pos;
state.rot = rot;
m_BufferedState[0] = state;
m_TimestampCount = Mathf.Min(m_TimestampCount + 1, m_BufferedState.Length);
for (int i = 0; i < m_TimestampCount - 1; i++)
{
if (m_BufferedState[i].timestamp < m_BufferedState[i + 1].timestamp)
Debug.Log("State inconsistent");
}
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Quaternion _syncDirection = Quaternion.identity;
Vector3 _syncPosition = Vector3.zero;
Vector3 _syncVelocity = Vector3.zero;
if (stream.isWriting)
{
_syncDirection = this.transform.rotation;
_syncPosition = this.transform.position;
_syncVelocity = this.rigidbody.velocity;
stream.Serialize(ref _syncDirection);
stream.Serialize(ref _syncPosition);
stream.Serialize(ref _syncVelocity);
}
else
{
stream.Serialize(ref _syncDirection);
stream.Serialize(ref _syncPosition);
stream.Serialize(ref _syncVelocity);
if(Quaternion.Angle(this.transform.rotation,_syncDirection) > 10 ){
this.gameObject.transform.rotation = Quaternion.Lerp(this.transform.rotation, _syncDirection,5 );
}
if( Vector3.Distance(this.transform.position,_syncPosition) > 10 ){
this.gameObject.transform.position = Vector3.Lerp(this.transform.position, _syncPosition,5);
}
if(Vector3.Distance(this.rigidbody.velocity,_syncVelocity)> 10){
this.rigidbody.velocity = Vector3.Lerp(this.rigidbody.velocity, _syncVelocity , 5);
}
}
}
public void OnSerialNetworkView(BitStream stream, NetworkMessageInfo info)
{
float punch = punchSpeed;
float direction = directionMultiplyerX;
float health = HP;
if (stream.isWriting)
{
punch = punchSpeed;
stream.Serialize(ref punch);
direction = directionMultiplyerX;
stream.Serialize(ref direction);
health = HP;
stream.Serialize(ref health);
}
else
{
stream.Serialize(ref punch);
punchSpeed = punch;
stream.Serialize(ref direction);
directionMultiplyerX = direction;
stream.Serialize(ref health);
HP = health;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
float net_currentAmmo = 0;
float net_maxAmmo = 0;
float net_ammoRegenRate = 0;
if (stream.isWriting)
{
net_currentAmmo = currentAmmo;
net_maxAmmo = maxAmmo;
net_ammoRegenRate = ammoRegenRate;
stream.Serialize(ref net_currentAmmo);
stream.Serialize(ref net_maxAmmo);
stream.Serialize(ref net_ammoRegenRate);
}
else if (stream.isReading)
{
stream.Serialize(ref net_currentAmmo);
stream.Serialize(ref net_maxAmmo);
stream.Serialize(ref net_ammoRegenRate);
currentAmmo = net_currentAmmo;
maxAmmo = net_maxAmmo;
ammoRegenRate = net_ammoRegenRate;
}
}
private void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
Vector3 syncVelocity = Vector3.zero;
if (stream.isWriting)
{
syncPosition = transform.position;
stream.Serialize(ref syncPosition);
syncVelocity = _controller.velocity;
stream.Serialize(ref syncVelocity);
}
else
{
stream.Serialize(ref syncPosition);
stream.Serialize(ref syncVelocity);
_syncTime = 0f;
_syncDelay = Time.time - _lastSynchroTime;
_lastSynchroTime = Time.time;
_syncEndPosition = syncPosition + syncVelocity * _syncDelay;
_syncStartPosition = transform.position;
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 pos = observedRigidbody.position;
Quaternion rot = observedRigidbody.rotation;
float vel = observedRigidbody.velocity.magnitude;
if(stream.isWriting)
{
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref vel);
}
else
{
stream.Serialize(ref pos);
stream.Serialize(ref rot);
stream.Serialize(ref vel);
receiver.serverPosition = pos;
receiver.serverRotation = rot;
receiver.serverVelocity = vel;
receiver.lerpToTarget();
for(int i = serverStateBuffer.Length - 1; i >= 1; i--)
{
serverStateBuffer[i] = serverStateBuffer[i-1];
}
serverStateBuffer[0] = new NetState(info.timestamp, pos, rot);
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
var sync_pos = new Vector3();
var sync_rot = new Quaternion();
var sync_hp = 0.0f;
if (stream.isReading)
{
stream.Serialize(ref sync_pos);
stream.Serialize(ref sync_rot);
stream.Serialize(ref sync_hp);
transform.position = sync_pos;
transform.rotation = sync_rot;
m_CurrentHP = sync_hp;
}
else
{
sync_pos = transform.position;
sync_rot = transform.rotation;
sync_hp = m_CurrentHP;
stream.Serialize(ref sync_pos);
stream.Serialize(ref sync_rot);
stream.Serialize(ref sync_hp);
}
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
Vector3 syncPosition = Vector3.zero;
Quaternion syncRotation = Quaternion.identity;
Vector3 syncVelocity = Vector3.zero;
if (stream.isWriting)
{
syncPosition = transform.position;
stream.Serialize(ref syncPosition);
syncRotation = transform.rotation;
stream.Serialize(ref syncRotation);
syncVelocity = controller.velocity;
stream.Serialize(ref syncVelocity);
}
else
{
stream.Serialize(ref syncPosition);
stream.Serialize(ref syncRotation);
stream.Serialize(ref syncVelocity);
syncTime = 0f;
syncDelay = Time.time - lastSynchronizationTime;
lastSynchronizationTime = Time.time;
syncEndPosition = syncPosition + syncVelocity * syncDelay;
syncStartPosition = transform.position;
syncEndRotation = syncRotation;
syncStartRotation = transform.rotation;
}
}
void OnSerializeNetworkView (BitStream stream, NetworkMessageInfo info)
{
if (stream.isWriting) {
//This is executed on the owner of the networkview
//The owner sends it's color over the network
//send color
Vector3 tempcolor = new Vector3(gameObject.GetComponent<Renderer>().material.color.r,gameObject.GetComponent<Renderer>().material.color.g,gameObject.GetComponent<Renderer>().material.color.b);
stream.Serialize (ref tempcolor);//"Encode" it, and send it
} else {
//Executed on all non-owners
//receive a color and set the object to it
//get color
Vector3 tempcolor = Vector3.zero;
Color colorReceive = Color.black;
stream.Serialize (ref tempcolor);
colorReceive = new Color(tempcolor.x, tempcolor.y, tempcolor.z, 1.0f);
//We've just recieved the current servers position of this object in 'posReceive'.
renderer.material.color = colorReceive;
//To reduce laggy movement a bit you could comment the line above and use position lerping below instead:
//transform.position = Vector3.Lerp(transform.position, posReceive, 0.9f); //"lerp" to the posReceive by 90%
//It would be even better to save the last received server position and lerp to it in Update because it is executed more often than OnSerializeNetworkView
}
}
public override void WriteOutOfBandHeader(BitStream bitStream)
{
RakNetPINVOKE.RakPeer_WriteOutOfBandHeader(swigCPtr, BitStream.getCPtr(bitStream));
}
void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
callIfExist(idOnSerializeNetworkView, stream, info);
}
public override void Crack(DataCracker context, BitStream data, long?size)
{
long startPos = data.PositionBits;
BitStream sizedData = ReadSizedData(data, size);
if (this.Count > 0)
{
origionalElement = this[0];
Clear();
}
long min = minOccurs;
long max = maxOccurs;
var rel = relations.Of <CountRelation>().Where(context.HasCracked).FirstOrDefault();
if (rel != null)
{
min = max = rel.GetValue();
}
else if (minOccurs == 1 && maxOccurs == 1)
{
min = max = occurs;
}
if (((min > maxOccurs && maxOccurs != -1) || (min < minOccurs)) && min != occurs)
{
string msg = "{0} has invalid count of {1} (minOccurs={2}, maxOccurs={3}, occurs={4}).".Fmt(
debugName, min, minOccurs, maxOccurs, occurs);
throw new CrackingFailure(msg, this, data);
}
for (int i = 0; max == -1 || i < max; ++i)
{
logger.Debug("Crack: ======================");
logger.Debug("Crack: {0} Trying #{1}", origionalElement.debugName, i + 1);
long pos = sizedData.PositionBits;
if (pos == sizedData.LengthBits)
{
logger.Debug("Crack: Consumed all bytes. {0}", sizedData.Progress);
break;
}
var clone = makeElement(i);
Add(clone);
try
{
context.CrackData(clone, sizedData);
// If we used 0 bytes and met the minimum, we are done
if (pos == sizedData.PositionBits && i == min)
{
RemoveAt(clone.parent.IndexOf(clone));
break;
}
}
catch (CrackingFailure)
{
logger.Debug("Crack: {0} Failed on #{1}", debugName, i + 1);
// If we couldn't satisfy the minimum propigate failure
if (i < min)
{
throw;
}
RemoveAt(clone.parent.IndexOf(clone));
sizedData.SeekBits(pos, System.IO.SeekOrigin.Begin);
break;
}
}
if (this.Count < min)
{
string msg = "{0} only cracked {1} of {2} elements.".Fmt(debugName, Count, min);
throw new CrackingFailure(msg, this, data);
}
if (size.HasValue && data != sizedData)
{
data.SeekBits(startPos + sizedData.PositionBits, System.IO.SeekOrigin.Begin);
}
}
public override void Crack(DataCracker context, BitStream data, long?size)
{
// Consume padding bytes
ReadSizedData(data, size);
}
public void ReadWriteNumbersOddOffset()
{
BitStream bs = new BitStream();
BitWriter w = new BitWriter(bs);
BitReader r = new BitReader(bs);
w.LittleEndian();
r.LittleEndian();
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
Assert.AreEqual(3, bs.LengthBits);
Assert.AreEqual(3, bs.PositionBits);
//Max
w.WriteSByte(sbyte.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(0, r.ReadBit());
Assert.AreEqual(1, r.ReadBit());
Assert.AreEqual(1, r.ReadBit());
Assert.AreEqual(1, r.ReadBit());
Assert.AreEqual(1, r.ReadBit());
Assert.AreEqual(1, r.ReadBit());
Assert.AreEqual(1, r.ReadBit());
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(sbyte.MaxValue, r.ReadSByte());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt16(short.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(short.MaxValue, r.ReadInt16());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt32(67305985);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(67305985, r.ReadInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt32(Int32.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int32.MaxValue, r.ReadInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt64(Int64.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int64.MaxValue, r.ReadInt64());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteByte(byte.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(byte.MaxValue, r.ReadByte());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteUInt16(ushort.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(ushort.MaxValue, r.ReadUInt16());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteUInt32(UInt32.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(UInt32.MaxValue, r.ReadUInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteUInt64(UInt64.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(UInt64.MaxValue, r.ReadUInt64());
//Min
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteSByte(sbyte.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(sbyte.MinValue, r.ReadSByte());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt16(short.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(short.MinValue, r.ReadInt16());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt32(Int32.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int32.MinValue, r.ReadInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt64(Int64.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int64.MinValue, r.ReadInt64());
// BIG ENDIAN //////////////////////////////////////////
bs.SetLength(0);
r.BigEndian();
w.BigEndian();
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
//Max
w.WriteSByte(sbyte.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(sbyte.MaxValue, r.ReadSByte());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt16(short.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(short.MaxValue, r.ReadInt16());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt32(67305985);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(67305985, r.ReadInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt32(Int32.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int32.MaxValue, r.ReadInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt64(Int64.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int64.MaxValue, r.ReadInt64());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteByte(byte.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(byte.MaxValue, r.ReadByte());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteUInt16(ushort.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(ushort.MaxValue, r.ReadUInt16());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteUInt32(UInt32.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(UInt32.MaxValue, r.ReadUInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteUInt64(UInt64.MaxValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(UInt64.MaxValue, r.ReadUInt64());
//Min
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteSByte(sbyte.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(sbyte.MinValue, r.ReadSByte());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt16(short.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(short.MinValue, r.ReadInt16());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt32(Int32.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int32.MinValue, r.ReadInt32());
bs.SetLength(0);
w.WriteBit(1);
w.WriteBit(1);
w.WriteBit(1);
w.WriteInt64(Int64.MinValue);
bs.SeekBits(3, System.IO.SeekOrigin.Begin);
Assert.AreEqual(Int64.MinValue, r.ReadInt64());
}
protected override void OnLoadBegin(BitStream stream, Action <T> loadingDoneHandler)
{
OnLoad(stream, loadingDoneHandler);
}
/// <summary> /// When overridden in the derived class, handles sending data to the server. /// </summary> /// <param name="bs">The data to send.</param> protected abstract void SendData(BitStream bs);
protected override BitStream internalEncode(BitStream data)
{
var b64s = System.Text.ASCIIEncoding.ASCII.GetString(data.Value);
return(new BitStream(System.Convert.FromBase64String(b64s)));
}
public static bool DeserializeCompressed(string str, BitStream bs, bool readLanguageId)
{
bool ret = RakNetPINVOKE.RakString_DeserializeCompressed__SWIG_2(str, BitStream.getCPtr(bs), readLanguageId);
return(ret);
}
public void ReadMsg(BitStream stream)
{
Type = PrefetchType.Sound;
SoundIndex = stream.ReadInt(SourceConstants.MAX_SOUND_INDEX_BITS);
}
public static void SerializeCompressed(string str, BitStream bs)
{
RakNetPINVOKE.RakString_SerializeCompressed__SWIG_5(str, BitStream.getCPtr(bs));
}
public static bool DeserializeCompressed(string str, BitStream bs)
{
bool ret = RakNetPINVOKE.RakString_DeserializeCompressed__SWIG_3(str, BitStream.getCPtr(bs));
return(ret);
}
public void SerializeCompressed(BitStream bs)
{
RakNetPINVOKE.RakString_SerializeCompressed__SWIG_2(swigCPtr, BitStream.getCPtr(bs));
}
public bool Deserialize(BitStream bs)
{
bool ret = RakNetPINVOKE.RakString_Deserialize__SWIG_0(swigCPtr, BitStream.getCPtr(bs));
return(ret);
}
public static void Serialize(string str, BitStream bs)
{
RakNetPINVOKE.RakString_Serialize__SWIG_1(str, BitStream.getCPtr(bs));
}
public static void SerializeCompressed(string str, BitStream bs, byte languageId)
{
RakNetPINVOKE.RakString_SerializeCompressed__SWIG_4(str, BitStream.getCPtr(bs), languageId);
}
// Token: 0x060032A5 RID: 12965 RVA: 0x000BFFB0 File Offset: 0x000BE1B0
void Deserialize(BitStream stream)
{
base.Deserialize(stream);
}
public void SerializeCompressed(BitStream bs, byte languageId, bool writeLanguageId)
{
RakNetPINVOKE.RakString_SerializeCompressed__SWIG_0(swigCPtr, BitStream.getCPtr(bs), languageId, writeLanguageId);
}
public void Read(BitStream stream)
{
stream.Read(out this.mapName);
int ilc = 0;
stream.Read(out ilc);
for (int i = 0; i < ilc; i++)
{
int id;
Vec3f pos, dir;
stream.Read(out id);
stream.Read(out pos);
stream.Read(out dir);
Vob v = sWorld.VobDict[id];
v.Position = pos;
v.Direction = dir;
addVob(v);
v.Spawn(this.Map, v.Position, v.Direction);
}
int vlc = 0;
stream.Read(out vlc);
for (int i = 0; i < vlc; i++)
{
int id;
Vec3f pos, dir;
stream.Read(out id);
stream.Read(out pos);
stream.Read(out dir);
Vob v = sWorld.VobDict[id];
v.Position = pos;
v.Direction = dir;
addVob(v);
v.Spawn(this.Map, v.Position, v.Direction);
}
int nlc = 0;
stream.Read(out nlc);
for (int i = 0; i < nlc; i++)
{
int id;
Vec3f pos, dir;
stream.Read(out id);
stream.Read(out pos);
stream.Read(out dir);
if (id == Player.Hero.ID)
{
continue;
}
Vob v = sWorld.VobDict[id];
v.Position = pos;
v.Direction = dir;
addVob(v);
v.Spawn(this.Map, v.Position, v.Direction);
//((NPCProto)v).Disable();
}
}
public void Serialize(BitStream bs)
{
RakNetPINVOKE.RakString_Serialize__SWIG_0(swigCPtr, BitStream.getCPtr(bs));
}
void IReplicationServerCallback.SendEvent(BitStream stream, bool reliable, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.RPC, stream, reliable, endpoint);
}
// Token: 0x060032A4 RID: 12964 RVA: 0x000BFFA4 File Offset: 0x000BE1A4
void Serialize(BitStream stream)
{
base.Serialize(stream);
}
void IReplicationServerCallback.SendWorldBattleData(BitStream stream, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.WORLD_BATTLE_DATA, stream, true, endpoint);
}
void IReplicationServerCallback.SentClientJoined(BitStream stream, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.CLIENT_CONNNECTED, stream, true, endpoint);
}
void IReplicationServerCallback.SendReplicationDestroy(BitStream stream, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_DESTROY, stream, true, endpoint);
}
void IReplicationServerCallback.SendJoinResult(BitStream stream, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.JOIN_RESULT, stream, true, endpoint);
}
void IReplicationServerCallback.SendServerData(BitStream stream, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.SERVER_DATA, stream, true, endpoint);
}
void IReplicationServerCallback.SendStateSync(BitStream stream, EndpointId endpoint, bool reliable)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.SERVER_STATE_SYNC, stream, reliable, endpoint);
}
public bool Deserialize(BitStream inBitStream)
{
bool ret = RakNetPINVOKE.FileList_Deserialize(swigCPtr, BitStream.getCPtr(inBitStream));
return(ret);
}
void IReplicationServerCallback.SendReplicationCreateStreamed(BitStream stream, EndpointId endpoint)
{
SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_STREAM_BEGIN, stream, true, endpoint);
}