public void UpdateTerrain(CurvySplineSegment segment, bool refresh = false, bool refreshTrees = false, ModelObject sgo = null)
{
if (!refresh && _Loader.levelEditor != null && !_Loader.levelEditor.autoRefreshTerrain || lowQualityAndAndroid)
{
return;
}
//refreshTrees = highOrNotAndroid && refreshTrees;
Random.seed = 0;
if (hideTerrain || segment == null && sgo == null && !refresh)
{
return;
}
if (refresh)
{
((TerrainHelper)FindObjectOfType(typeof(TerrainHelper))).OnDisable();
}
Debug.Log("update Terrain " + refresh + " " + refreshTrees);
if (heights == null || refresh)
{
//if (flatTerrain)
//{
// heights = oldHeightsFlat
//}
//else
if (flatTerrain)
{
td.SetHeights(0, 0, oldHeightsFlat);
}
heights = td.GetHeights(0, 0, td.heightmapHeight, td.heightmapWidth);
alphas = td.GetAlphamaps(0, 0, td.alphamapHeight, td.alphamapWidth);
if (miny == MaxValue)
{
for (int i = 0; i < td.heightmapHeight; i++)
{
for (int j = 0; j < td.heightmapWidth; j++)
{
miny = Mathf.Min(heights[i, j], miny);
}
}
}
}
var points = new List <Vector5>();
const int minDist = 50;
foreach (CurvySpline2 a in FindObjectsOfType(typeof(CurvySpline2)))
{
if (!a.shape)
{
for (int i = 0; i < a.Length; i += refresh ? 3 : 10)
{
var sg = a.DistanceToSegment(i);
if (sg.flying)
{
continue;
}
Vector2 bounds = sg.GetBounds();
//bounds.x *= sg.scale;
//bounds.y;
//bounds.x = Mathf.Abs(bounds.x);
//bounds.y = Mathf.Abs(bounds.y);
var v = a.InterpolateByDistance(i) + Vector3.down * bounds.y;
if (refresh)
{
points.Add(new Vector5(v.x, v.y, v.z, 0, bounds.x));
}
else if (segment != null)
{
var w = CurvySpline2.DistancePointLine(ZeroY(v), ZeroY(segment.Position), ZeroY(segment.NextControlPoint.Position));
if (w < minDist)
{
points.Add(new Vector5(v.x, v.y, v.z, w, bounds.x));
}
}
}
}
}
if (refresh)
{
foreach (ModelObject a in FindObjectsOfType(typeof(ModelObject)))
{
UpdateModelObject(a, points);
}
}
else if (sgo)
{
UpdateModelObject(sgo, points);
}
print("Update Terrain " + points.Count);
var changed = new List <Vector2>();
if (refresh || used == null)
{
used = new bool[td.heightmapWidth, td.heightmapHeight];
}
bool[,] used2 = new bool[td.heightmapWidth, td.heightmapHeight];
print(td.heightmapScale.y);
foreach (Vector5 v5 in points.OrderBy(a => a.dist > minDist / 2f).ThenByDescending(a => a.v.y))
{
Vector3 p = v5.v;
Debug.DrawRay(p, Vector3.up, Color.red, 1);
RaycastHit h;
if (terrain.collider.Raycast(new Ray(p + Vector3.up * 100, Vector3.down), out h, 1000))
{
var y = (int)(h.textureCoord.x * td.heightmapWidth);
var x = (int)(h.textureCoord.y * td.heightmapHeight);
int sz = (int)((v5.width * 2f + 20) / td.heightmapScale.x);
var th = (TerrainHelper)FindObjectOfType(typeof(TerrainHelper));
var oldHeights = flatTerrain ? oldHeightsFlat : th.oldHeights;
for (int j = -sz; j < sz; j++)
{
for (int k = -sz; k < sz; k++)
{
float f = 1f - new Vector2(j, k).magnitude / sz;
f = Mathf.Clamp01(f * 1.3f);
int x2 = x + j;
int y2 = y + k;
if (x2 > 0 && x2 < td.heightmapWidth && y2 > 0 && y2 < td.heightmapHeight)
{
if (f >= 1)
{
used[x2, y2] = true;
}
if (!used2[x2, y2])
{
changed.Add(new Vector2((float)x2 / td.heightmapWidth, (float)y2 / td.heightmapHeight));
used2[x2, y2] = true;
}
var h2 = (p.y - terrain.transform.position.y) / td.heightmapScale.y;
var f2 = Mathf.Lerp(oldHeights[x2, y2], h2, f);
if (f2 > heights[x2, y2] && (!used[x2, y2] || f >= 1) && v5.dist < minDist / 2f || f >= 1 && f2 <= heights[x2, y2])
{
heights[x2, y2] = f2;
}
}
//else if (!warkingShown)
//{
// warkingShown = true;
// if (_Loader.levelEditor != null)
// ShowPopup("Warning you are out of terrain bounds, visual bugs will apear");
//}
}
}
}
}
//if (refresh)
// foreach (ModelObject a in FindObjectsOfType(typeof(ModelObject)))
// {
// var bounds = a.renderer.bounds;
// var e = bounds.center - terrain.GetPosition();
// var p = td.heightmapWidth / td.size.x;
// var py = 1f / td.size.y;
// e.x *= p;
// e.z *= p;
// e.y *= py;
// bounds.center = e;
// e = bounds.extents;
// e.x *= p;
// e.z *= p;
// e.y *= py;
// bounds.extents = e;
// for (int i = Mathf.Max(0, (int)bounds.min.x); i < Mathf.Min(bounds.max.x, td.heightmapWidth); i++)
// for (int j = Mathf.Max(0, (int)bounds.min.z); j < Mathf.Min(td.heightmapWidth, bounds.max.z); j++)
// heights[j, i] = bounds.min.y;
// }
td.SetHeights(0, 0, heights);
foreach (Vector2 a in changed)
{
var n = td.GetInterpolatedNormal(a.y, a.x);
var x = (int)(a.x * td.alphamapWidth);
var y = (int)(a.y * td.alphamapHeight);
var f = 1 - (n.y * n.y * n.y);
if (f > .96f)
{
if (Mathf.Abs(n.x) > Mathf.Abs(n.z))
{
SetAlpha(x, y, f, 4);
}
else
{
SetAlpha(x, y, f, 5);
}
}
else
{
SetAlpha(x, y, f, 1);
}
}
if (refreshTrees && !flatTerrain)
{
List <TreeInstance> trees = new List <TreeInstance>(oldTreeInstances);
td.SetAlphamaps(0, 0, alphas);
terrain.collider.enabled = false;
StartCoroutine(AddMethod(delegate { terrain.collider.enabled = true; }));
RefreshTrees(used, trees);
Debug.LogWarning("Set Trees " + trees.Count);
//terrain.Flush();
//DestroyImmediate(terrain.collider);
//terrain.gameObject.AddComponent<TerrainCollider>().terrainData = td;
td.treeInstances = trees.ToArray();
}
//terrain.enabled = true;
if (!refresh)
{
try
{
td.GetType().GetMethod("SetBasemapDirty", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(td, new object[] { false });
}
catch (Exception e) { Debug.Log(e.Message); }
}
}
public new void Update()
{
if (KeyDebug(KeyCode.E))
{
if (shape)
{
print(name + GetBounds(true) + GetBounds(true).max);
}
}
var game = _Game != null && _Game.gameObject.activeSelf;
if (game && FramesElapsed(10, random))
{
foreach (var a in Segments)
{
float d = DistancePointLine(mainCameraTransform.position, a.Position, a.NextControlPoint.Position);
if (splitScreen)
{
d = Mathf.Min(DistancePointLine(_Player2.pos, a.Position, a.NextControlPoint.Position), d);
}
float ext;
if (d < 100)
{
ext = .1f;
}
else
{
ext = 3;
}
foreach (SplinePathMeshBuilder b in a.sbs)
{
if (b.ExtrusionParameter != ext)//&& (b.refreshed != Time.frameCount || b.ExtrusionParameter > ext)
{
b.ExtrusionParameter = ext;
//print("Set Ext "+ext);
b.Refresh();
}
//b.refreshed = Time.frameCount;
}
}
//_Player.cam .position-pos
}
if (game)
{
return;
}
if (levelEditor == null)
{
Closed = shape || Closed;
}
else
{
if (levelEditor.shapeEditor && shape)
{
var closed = shape && (levelEditor.spline != this);
if (Closed != closed)
{
Closed = closed;
if (closed)
{
SetPivot();
}
Refresh();
}
}
if (shape && guiText == null)
{
guiText = new GameObject(name + " Text").AddComponent <GUIText>();
}
if (guiText != null)
{
guiText.enabled = Closed && levelEditor.shapeEditor;
guiText.text = name;
guiText.transform.position = levelEditor.shapeCamera.WorldToViewportPoint(GetCenter() + Vector3.forward * 3);
}
}
if (!shape)
{
var updated = GenerateSbs();
if (updated)
{
Refresh();
}
}
Bounds screen = new Bounds();
screen.SetMinMax(Vector3.zero, new Vector3(Screen.width, Screen.height, 10000));
//if (!shape)
if (_Loader.levelEditor != null)
{
foreach (var a in Segments)
//if (a.NextControlPoint != null)
{
var mpos = Input.mousePosition;
var camera = _Loader.levelEditor.camera;
var s1 = camera.WorldToScreenPoint(a.Position);
var s2 = camera.WorldToScreenPoint(a.NextControlPoint.Position);
a.z = a.dist = MaxValue;
if (screen.Contains(s1) || screen.Contains(s2))
{
Vector3 project = CurvySpline2.ProjectPointLineVector2(mpos, s1, s2);
if (screen.Contains(project))
{
a.z = project.z;
var p1 = camera.ScreenToWorldPoint(mpos + Vector3.forward * project.z);
var p2 = a.pivot = camera.ScreenToWorldPoint(project);
//Debug.DrawLine(p1, p2, Color.blue);
a.dist = (p1 - p2).magnitude;
}
}
}
}
//else
// a.dist = float.MaxValue;
base.Update();
}
public void Update()
{
var time = Mathf.Min(extraTime, Time.deltaTime * 3);
extraTime -= time;
var deltaTime = Time.deltaTime + time;
if (deltaTime == 0)
{
return;
}
frame++;
//var emitter = _Game.smoke2;
//emitter.transform.position = pos;
//if (frame < 5)
// emitter.Emit(1);
vel = transform.forward * bulletSpeed2 * deltaTime;
if (velm > 1000)
{
Destroy2(gameObject);
}
velm += vel.magnitude;
if (speedUp != 0)
{
bulletSpeed2 += speedUp * deltaTime;
bulletSpeed2 = Mathf.Min(bulletSpeed2, maxSpeed2);
}
//RaycastHit h ;
foreach (RaycastHit h in Physics.RaycastAll(transform.position, transform.forward, vel.magnitude, Layer.allmask).OrderBy(a => a.distance))
{
var IsMine = wep.pl == _Player;
var bs = h.transform.root.GetComponent <bs>();
var zombie = bs as Zombie;
if (zombie != null && IsMine)
{
wep.pl.ZombieHit(zombie, 0);
}
var hitPl = bs as Player;
//if (hitPl != null && b && online && h.collider.tag == Tag.HitBox)
//if (hitPl.IsMine && !hitPl.dead)
if (hitPl != null && online && h.collider.tag == Tag.HitBox)
{
var b = remote ? !IsMine && hitPl.IsMine : IsMine;
var b2 = hitPl != wep.pl;
if (b && b2 && !hitPl.dead)
{
if (wep.pl != null && (wep.pl.teamEnum != hitPl.teamEnum || _Loader.dmNoCtf))
{
//var p = Mathf.Max(2f - CurvySpline2.DistancePointLine(pl.rigidbody.worldCenterOfMass, transform.position, transform.position + transform.forward * 10), 0) / 2;
//print(CurvySpline2.DistancePointLine(pl.rigidbody.worldCenterOfMass, transform.position, transform.position + transform.forward * 10));
hitPl.CallRPC(hitPl.SetLife, hitPl.life - wep.damage, wep.pl.playerId);
if (freeze)
{
//pl.freeze += .3f;
//if (pl.freeze > 1)
hitPl.CallRPC(hitPl.Freeze);
}
}
}
if (hitPl != wep.pl && !hitPl.sameTeam && _Player.checkVisible(h.point))
{
hitPl.meshTest.Damage(h.point, h.normal);
hitPl.meshTest.Hit(h.point, vel);
_Game.Emit(h.point, h.normal, _Game.sparks);
}
}
//CreateDecal(h);
if ((hitPl != wep.pl || hitPl == null))
{
if (explosion != null)
{
if (rocket && (IsMine || _Player.teamEnum != wep.pl.teamEnum))
{
_Player.rigidbody.AddExplosionForce(explosionForce, h.point, explosionRadius);
float damage = (explosionRadius - (h.point - _Player.pos).magnitude) / explosionRadius * wep.damage;
if (damage > 0)
{
_Player.CallRPC(_Player.SetLife, _Player.life - damage, wep.pl.playerId);
}
Destroy2(gameObject);
}
Destroy(Instantiate(explosion, h.point + h.normal, Quaternion.identity), 2);
}
if (wep.bulletHitSound.Length > 0 && checkVisible(pos) /*|| h.collider.tag == Tag.model*/ && Vector3.Distance(_Player.camera.transform.position, pos) < 100)
{
var audioClip = wep.bulletHitSound[Random.Range(0, wep.bulletHitSound.Length)];
PlayAtPosition(h.point, audioClip, hitPl && hitPl.IsMine ? 0 : 200);
}
}
if (bs == null)
{
if (!lowQuality)
{
_Game.Emit(h.point, h.normal, _Game.bulletHit);
Hole(hole != null ? hole : res.hole, h.point, h.normal);
}
Destroy2(gameObject);
break;
}
}
if (wep.pl.IsMine && targetable)
{
_Game.cursorTexture.enabled = false;
_Game.cursorTexture2.enabled = true;
var r = _Player.camera.ViewportPointToRay(new Vector3(.5f, .5f));
var lineStart = r.origin;
var pointOnLine = CurvySpline2.ProjectPointLine(pos, lineStart, lineStart + r.direction * 1000);
//Debug.DrawLine(pos, pointOnLine);
transform.forward = Vector3.RotateTowards(transform.forward, (pointOnLine - lineStart).normalized, 1 * Time.deltaTime, 0);
//transform.forward = Vector3.RotateTowards(transform.forward, (pointOnLine - (pos - r.direction * 10)).normalized, .5f * Time.deltaTime, 0);
}
if (wep.slide)
{
RaycastHit h2;
if (Physics.Raycast(pos, -transform.up, out h2, 2, Layer.levelMask))
{
//if (pos.y - h2.point.y < 2)
//pos = h2.point + Vector3.up*2;
//pos = Vector3.Lerp(pos, h2.point + Vector3.up * 2, Time.deltaTime * 10);
pos += Vector3.up * Time.deltaTime * 5;
}
}
transform.position += vel;
}
