public Creature(Vector2 position, int birthDay)
{
// За допомогою стягнутого класу ПрімітівХелпер - стягує меш з куба
this.mesh = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube);
// Фукнція, що додає до геймОбджекта потрібні нам компоненти і правильно інціалізує їх
ImplementComponents();
// Ініціалізація полів
this.id = Creature.ID_COUNTER++;
this.hunger = 0;
this.thirst = 0;
this.birthDay = birthDay;
this.deathDay = (int)Random.Range(DEATH_RANGE.x, DEATH_RANGE.y);
this.speed = Random.Range(0.7f, 3);
this.weight = 0;
// this.isMoving = false;
// this.isLookingFor = false;
// this.targetCell = new Vector2(position.x, position.y);
this.targetPath = new Vector2[1];
this.targetPath[0] = new Vector2(position.x, position.y);
this.pathIndex = 0;
// this.isAlive = true;
this.state = CreatureState.Standing;
this.meshHeight = 1;
this.position = new Vector3(position.x,
Creature.objectMap[(int)position.x, (int)position.y].transform.position.y + this.meshHeight,
position.y);
// Позначення в глобальному масиві, що дана клітка зайнята
Creature.digitalMap[(int)position.x, (int)position.y] = 9;
// Вибір випадкового напрямку, кліток
RandomizeMove();
}
GameObject createSky()
{
GameObject skyGo = PrimitiveHelper.CreatePrimitive(PrimitiveType.Quad, false, "Sky");
// Mesh meshCube = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube);
skyGo.transform.position = new Vector3(0, 100, 790);
skyGo.transform.localScale = new Vector3(1700, 1200, 1);
skyGo.transform.parent = gameObject.transform;
//9) Give it a Material
// Material material = new Material(PrimitiveHelper.GetMaterialStandard());
Material skyMa = new Material(Shader.Find("Aviator/LinearGradientColor"));
skyMa.SetColor("_color1", AviatorColors.Sky);
skyMa.SetColor("_color2", AviatorColors.Fog);
MeshRenderer skyMr = skyGo.GetComponent <MeshRenderer>();
skyMr.material = skyMa;
skyMr.shadowCastingMode = ShadowCastingMode.Off;
skyMr.receiveShadows = false;
skyGo.isStatic = true;
return(skyGo);
}
public void Map_object_when_null_values_are_typed()
{
//Arrange
//Expression<Func<UserModel, bool>> selection = s => s != null && s.AccountModel != null && s.AccountModel.Bal > 555.20;
ParameterExpression userParam = Expression.Parameter(typeof(UserModel), "s");
MemberExpression accountModelProperty = Expression.MakeMemberAccess(userParam, PrimitiveHelper.GetFieldOrProperty(typeof(UserModel), "AccountModel"));
Expression <Func <UserModel, bool> > selection = Expression.Lambda <Func <UserModel, bool> >
(
Expression.AndAlso
(
Expression.AndAlso
(
Expression.NotEqual(userParam, Expression.Constant(null, typeof(UserModel))),
Expression.NotEqual(accountModelProperty, Expression.Constant(null, typeof(AccountModel)))
),
Expression.GreaterThan
(
Expression.MakeMemberAccess(accountModelProperty, PrimitiveHelper.GetFieldOrProperty(typeof(AccountModel), "Bal")),
Expression.Constant(555.20, typeof(double))
)
),
userParam
);
//Act
Expression <Func <User, bool> > selectionMapped = mapper.MapExpression <Expression <Func <User, bool> > >(selection);
List <User> users = Users.Where(selectionMapped).ToList();
//Assert
Assert.True(users.Count == 2);
}
private void OnUpdatePinch(float fDistance)
{
float fZoomAverage = PrimitiveHelper.GetCalcReverseFloat(_fStartPinchZoomSize, fDistance);
fZoomAverage = Mathf.Clamp(fZoomAverage, p_iCameraZoomMin, p_iCameraZoomMax);
if (_bIsCameraOrtho)
{
_pCamera.orthographicSize = fZoomAverage;
}
else
{
// 터치 2개 중앙부터 Plane 까지 쏜 좌표값 구하기
Vector3 v3CenterRayPos = PrimitiveHelper.GetPlaneRaycastPos(_sPlaneCurrentAxis, _pCamera.ScreenPointToRay(PrimitiveHelper.GetCenterByResolution()));
_pTransCamera.position = v3CenterRayPos - _pTransCamera.forward * fZoomAverage;
}
if (p_fZoomSmoothFactor > 0f)
{
_fLerpPinchDistance = Mathf.Lerp(_fLerpPinchDistance, fDistance, Time.deltaTime * p_fZoomSmoothFactor);
}
else
{
_fLerpPinchDistance = fDistance;
}
}
void DrawCollider(Collider col, Color color)
{
if (col == null)
{
return;
}
Mesh mesh = null;
if (col is SphereCollider)
{
mesh = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Sphere);
}
else if (col is BoxCollider)
{
mesh = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube);
}
else if (col is CapsuleCollider)
{
mesh = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Capsule);
}
else if (col is MeshCollider)
{
mesh = ((MeshCollider)col).sharedMesh;
}
if (mesh == null)
{
return;
}
Config.Debug.HitboxMaterial.SetColor("_Color", color);
Config.Debug.HitboxMaterial.SetPass(0);
Graphics.DrawMeshNow(mesh, Gizmo.GetColliderMatrix(col));
}
private Vector3 ProcShake(Vector3 vecFollowPos)
{
if (_fRemainShakePow > 0f)
{
_fRemainShakePow -= _fShakeMinusDelta;
if (_fRemainShakePow <= 0f)
{
if (_bFollowX == false)
{
vecFollowPos.x = _vecOriginPos.x;
}
if (_bFollowY == false)
{
vecFollowPos.y = _vecOriginPos.y;
}
if (_bFollowZ == false)
{
vecFollowPos.z = _vecOriginPos.z;
}
}
else
{
Vector3 vecShakePos = PrimitiveHelper.RandomRange(vecFollowPos.AddFloat(-_fRemainShakePow), vecFollowPos.AddFloat(_fRemainShakePow));
//if (_bFollowX) vecFollowPos.x = vecShakePos.x;
//if (_bFollowY) vecFollowPos.y = vecShakePos.y;
//if (_bFollowZ) vecFollowPos.z = vecShakePos.z;
vecFollowPos = vecShakePos;
}
}
return(vecFollowPos);
}
private void Awake()
{
decalRoot = transform;
particleSystem = gameObject.AddComponent <ParticleSystem>();
particleSystem.loop = false;
particleSystem.playOnAwake = false;
particleSystem.enableEmission = false;
particleSystem.simulationSpace = ParticleSystemSimulationSpace.World;
ParticleSystem.ShapeModule shape = particleSystem.shape;
shape.enabled = false;
ParticleSystemRenderer renderer = decalRoot.GetComponent <ParticleSystemRenderer>();
renderer.renderMode = ParticleSystemRenderMode.Mesh;
renderer.alignment = ParticleSystemRenderSpace.World;
// renderer.sortMode = ParticleSystemSortMode.YoungestInFront;
renderer.enableGPUInstancing = true;
renderer.castShadows = false;
renderer.receiveShadows = false;
renderer.material = Resources.Load <Material>("Materials/ParticleDecalMaterial");
renderer.mesh = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Quad);
for (int i = 0; i < CAPACITY; i++)
{
data[i] = new ParticleDecalData();
}
}
GameObject createSea()
{// parent = new GameObject("Sea");
// parent.transform.parent = gameObject.transform;
//1) Create an empty GameObject with the required Components
// GameObject seaGo = PrimitiveHelper.CreatePrimitive(PrimitiveType.Cylinder, false, "Sea");
GameObject seaGo = new GameObject("Sea");
DrawCylinder cylinder = seaGo.AddComponent <DrawCylinder>();
cylinder.segmentsHeight = 10;
cylinder.segmentsRadial = 40;
// Mesh meshCube = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube);
seaGo.transform.position = Vector3.down * Aviator.seaRadius;
seaGo.transform.Rotate(Vector3.right * -90);
// seaGo.transform.localScale = new Vector3(1200, 400, 1200); // for unity built-in PrimitiveType.Cylinder
// remember to divide y by cylinder.segmentsHeight
seaGo.transform.localScale = new Vector3(Aviator.seaRadius, Aviator.seaLength / cylinder.segmentsHeight, Aviator.seaRadius); // for self-built DrawCylinder
seaGo.transform.parent = gameObject.transform;
//9) Give it a Material
MeshRenderer seaMr = seaGo.AddComponent <MeshRenderer>();
Material seaMa = seaMr.material;
seaMa.SetColor("_Color", AviatorColors.Blue);
PrimitiveHelper.SetMaterialTransparent(seaMa);
seaGo.AddComponent <Sea>();
return(seaGo);
}
void SetType() //Sets the units to a random unit type
{
if (type == 0)
{
this.ChangeMesh(gameObject, PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube));
this.name = "Factory";
this.production = 50;
this.maxHealth = 200;
this.health = 200;
MaterialSet();
}
else if (type == 1)
{
this.name = "Resouce Building";
this.resources = 1000;
this.maxHealth = 100;
this.health = 100;
MaterialSet();
}
else
{
this.ChangeMesh(gameObject, PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube));
this.name = "Factory";
this.production = 50;
this.maxHealth = 200;
this.health = 200;
MaterialSet();
}
}
// ========================================================================== //
/* public - [Do] Function
* 외부 객체가 호출(For External class call)*/
/* public - [Event] Function
* 프랜드 객체가 호출(For Friend class call)*/
#endregion Public
// ========================================================================== //
#region Protected
/* protected - [abstract & virtual] */
/* protected - [Event] Function
* 자식 객체가 호출(For Child class call) */
/* protected - Override & Unity API */
protected override void OnPlayEvent()
{
base.OnPlayEvent();
_vecPos = PrimitiveHelper.RandomRange(_vecRandom_Min, _vecRandom_Max);
transform.localPosition = _vecPos;
}
public static string GetEnumDescription(Type enumType, object enumValue)
{
var value = enumValue.ToString();
if (enumType == typeof(object))
{
enumType = GetEnumType(enumValue.GetType());
}
if (enumValue is int)
{
value = Enum.GetName(enumType, enumValue);
}
if (value == null)
{
return(enumValue.ToString());
}
var field = (enumType.IsNullableType() ? PrimitiveHelper.GetTypeOfNullable(enumType) : enumType).GetField(value);
if (field == null)
{
return(value);
}
var attributes =
(DescriptionAttribute[])field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return((attributes.Length > 0) ? attributes[0].Description : value);
}
public void Shake(out bool bIsFinish)
{
if (_fRemainShakePow > 0f)
{
Vector3 vecShakePos = PrimitiveHelper.RandomRange(vecOriginPos.AddFloat(-_fRemainShakePow), vecOriginPos.AddFloat(_fRemainShakePow));
if (eShakePosType != EShakePos.All)
{
if (eShakePosType == EShakePos.Y || eShakePosType == EShakePos.YZ || eShakePosType == EShakePos.Z)
{
vecShakePos.x = vecOriginPos.x;
}
if (eShakePosType == EShakePos.X || eShakePosType == EShakePos.XZ || eShakePosType == EShakePos.Z)
{
vecShakePos.y = vecOriginPos.y;
}
if (eShakePosType == EShakePos.X || eShakePosType == EShakePos.XY || eShakePosType == EShakePos.Y)
{
vecShakePos.z = vecOriginPos.z;
}
}
pTransform.position = vecShakePos;
_fRemainShakePow -= _fShakeMinusDelta;
bIsFinish = false;
}
else
{
pTransform.position = vecOriginPos;
bIsFinish = true;
}
}
// ========================== [ Division ] ========================== //
private IEnumerator CoStartShake()
{
_vecOriginPos = transform.localPosition;
while (_fRemainShakePow > 0f)
{
// Vector3 vecOriginPos = transform.localPosition;
Vector3 vecShakePos = PrimitiveHelper.RandomRange(_vecOriginPos.AddFloat(-_fRemainShakePow), _vecOriginPos.AddFloat(_fRemainShakePow));
if(_eShakePosType != EShakePos.All)
{
if (_eShakePosType == EShakePos.Y || _eShakePosType == EShakePos.YZ || _eShakePosType == EShakePos.Z)
vecShakePos.x = _vecOriginPos.x;
if (_eShakePosType == EShakePos.X || _eShakePosType == EShakePos.XZ|| _eShakePosType == EShakePos.Z)
vecShakePos.y = _vecOriginPos.y;
if (_eShakePosType == EShakePos.X || _eShakePosType == EShakePos.XY || _eShakePosType == EShakePos.Y)
vecShakePos.z = _vecOriginPos.z;
}
transform.localPosition = vecShakePos;
_fRemainShakePow -= _fShakeMinusDelta;
yield return null;
}
if (_bBackToOriginPos)
transform.localPosition = _vecOriginPos;
yield break;
}
private void Update()
{
if (_bIsShaking)
{
if (_fRemainShakePow > 0f)
{
Vector3 vecShakePos = PrimitiveHelper.RandomRange(_vecOriginPos.AddFloat(-_fRemainShakePow), _vecOriginPos.AddFloat(_fRemainShakePow));
if (_eShakePosType != EShakePos.All)
{
if (_eShakePosType == EShakePos.Y || _eShakePosType == EShakePos.YZ || _eShakePosType == EShakePos.Z)
{
vecShakePos.x = _vecOriginPos.x;
}
if (_eShakePosType == EShakePos.X || _eShakePosType == EShakePos.XZ || _eShakePosType == EShakePos.Z)
{
vecShakePos.y = _vecOriginPos.y;
}
if (_eShakePosType == EShakePos.X || _eShakePosType == EShakePos.XY || _eShakePosType == EShakePos.Y)
{
vecShakePos.z = _vecOriginPos.z;
}
}
transform.localPosition = vecShakePos;
_fRemainShakePow -= _fShakeMinusDelta;
}
else
{
transform.localPosition = _vecOriginPos;
_bIsShaking = false;
}
}
}
private void OnUpdateDrag(Vector3 v3StartTouchPos, Vector3 v3CurrentTouchPos)
{
// Ray 의 첫번째 지점. (터치한 첫번째 좌표 부분부터)
Vector3 v3IntersectPosOne = PrimitiveHelper.GetPlaneRaycastPos(_sPlaneCurrentAxis, _pCamera.ScreenPointToRay(v3StartTouchPos));
// Ray 의 두번째 지점. (움직이는 두번째 좌표 까지)
Vector3 v3IntersectPosTwo = PrimitiveHelper.GetPlaneRaycastPos(_sPlaneCurrentAxis, _pCamera.ScreenPointToRay(v3CurrentTouchPos));
// 두개의 좌표를 계산 - 마지막 카메라 좌표까지
Vector3 v3DragOffset = _v3StartCameraPos - (v3IntersectPosTwo - v3IntersectPosOne);
if (p_fCameraMoveSmoothFactor > 0f)
{
_pTransCamera.position = Vector3.Lerp(_pTransCamera.position, v3DragOffset, Time.deltaTime * p_fCameraMoveSmoothFactor);
}
else
{
_pTransCamera.position = v3DragOffset;
}
_pTransCamera.position = ProcClampCamPosition(_pTransCamera.position);
// 매 프레임마다 이전좌표 현재좌표 계산후 저장 (드래그 끝난 후 자동 드래그때문)
ProcAddMoveVelocity((_v3PrevCameraPos - _pTransCamera.position) / Time.deltaTime);
_v3PrevCameraPos = _pTransCamera.position;
}
static public string CalculateHashPassword(int iLength)
{
_pStrBuilder.Length = 0;
for (int i = 0; i < iLength; i++)
{
ERandomCharType eRandomType = (ERandomCharType)Random.Range(0, PrimitiveHelper.GetEnumLength <ERandomCharType>());
int iRandomChar = 0;
switch (eRandomType)
{
case ERandomCharType.LowerCase:
iRandomChar = Random.Range(Convert.ToInt32('a'), Convert.ToInt32('z'));
_pStrBuilder.Append(Convert.ToChar(iRandomChar));
break;
case ERandomCharType.UpperCase:
iRandomChar = Random.Range(Convert.ToInt32('A'), Convert.ToInt32('Z'));
_pStrBuilder.Append(Convert.ToChar(iRandomChar));
break;
case ERandomCharType.Number:
iRandomChar = Random.Range(0, 10);
_pStrBuilder.Append(iRandomChar.ToString());
break;
}
}
return(_pStrBuilder.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="ps"></param>
/// <param name="resource"></param>
/// <param name="rotate">是否旋转模型x轴90度</param>
/// <returns></returns>
private static Mesh AssembleMesh(ParticleSystem ps, Dictionary <int, object> resource, bool rotate = false)
{
Mesh mesh = null;
if (ps.SurfId != 0)
{
//Surface3D surf = resource[(int)ps.SurfId] as Surface3D;
//obj = new GameObject("ps.Name");
//obj.AddComponent<MeshFilter>();
//obj.AddComponent<MeshRenderer>();
//obj.GetComponent<MeshRenderer>().sharedMaterial = mtl;
ps.UnityResourceParam.MeshPath = SceneFileCopy.GetRelativeMeshDir(ps.RootFileName) + ps.Name + ".prefab";
Surface3D surf = resource[(int)ps.SurfId] as Surface3D;
mesh = new Mesh();
mesh.name = ps.Name;
int verticesCountInMesh = surf.VertexVector.Count / surf.SizePerVertex;
Vector3[] xyz = new Vector3[surf.NumTriangles * 3];
Vector2[] uv1 = new Vector2[surf.NumTriangles * 3];
for (int i = 0; i < verticesCountInMesh; ++i)
{
//旋转方向
xyz[i] = new Vector3(
surf.VertexVector[i * surf.SizePerVertex + surf.Offset[Surface3D.POSITION] + 0],
surf.VertexVector[i * surf.SizePerVertex + surf.Offset[Surface3D.POSITION] + 1],
surf.VertexVector[i * surf.SizePerVertex + surf.Offset[Surface3D.POSITION] + 2]
);
uv1[i] = new Vector2(
surf.VertexVector[i * surf.SizePerVertex + surf.Offset[Surface3D.UV0] + 0],
//unity的UV坐标和as3不一样
1 - surf.VertexVector[i * surf.SizePerVertex + surf.Offset[Surface3D.UV0] + 1]
);
}
int[] triangles = new int[surf.IndexVector.Count];
for (int i = 0; i < triangles.Length; ++i)
{
triangles[i] = (int)surf.IndexVector[i];
}
mesh.vertices = xyz;
mesh.uv = uv1;
mesh.triangles = triangles;
mesh.RecalculateNormals();
if (rotate)
{
PrimitiveHelper.RotateMeshVertices(mesh, new Vector3(0, 0, 0), new Vector3(90, 0, 0));
mesh.RecalculateBounds();
mesh.RecalculateNormals();
}
UnityEditor.AssetDatabase.CreateAsset(mesh, ps.UnityResourceParam.MeshPath);
UnityEditor.AssetDatabase.Refresh();
}
return(mesh);
}
public void OnDrawGizmos()
{
#if UNITY_EDITOR
if (!SKSGlobalRenderSettings.Gizmos)
{
return;
}
//Change Portal colors
Renderer renderer;
if (renderer = gameObject.GetComponent <Renderer>())
{
Material[] materials = renderer.sharedMaterials;
if (!OriginalMaterial)
{
OriginalMaterial = new Material(Resources.Load <Material>("Materials/Visible effects/PortalControllerMat"));
}
Material material = OriginalMaterial;//new Material(OriginalMaterial);
material.SetColor("_Color", color);
renderer.sharedMaterial = material;
}
GUIStyle style = new GUIStyle();
style.normal.textColor = Color.red;
if (!TargetController)
{
Handles.Label(transform.position, "No Target Set", style);
return;
}
if (!PortalMaterial)
{
Handles.Label(transform.position, "No Portal Material Set", style);
return;
}
if ((!Mask && !SKSGlobalRenderSettings.ShouldOverrideMask) || (SKSGlobalRenderSettings.ShouldOverrideMask && !SKSGlobalRenderSettings.Mask))
{
Handles.Label(transform.position, "No Mask Set", style);
return;
}
if (Application.isPlaying)
{
Gizmos.color = color;
if (PortalScript)
{
Gizmos.matrix = PortalScript.transform.localToWorldMatrix;
Gizmos.matrix *= Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1, 1, 0.1f));
Gizmos.DrawMesh(PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube));
}
}
#endif
}
public void DoShakeObject(float fShakePow, float fTime)
{
_vecOriginPos = _pTransformCached.localPosition;
Vector3 vecShakePos = PrimitiveHelper.RandomRange(_vecOriginPos.AddFloat(-fShakePow), _vecOriginPos.AddFloat(fShakePow));
iTween.ShakePosition(_pGameObjectCached, vecShakePos, fTime);
//if(_bMachineShaking)
// PCManagerFramework.instance.DoShakeMobile();
}
private static void FillRenderModule(UnityEngine.ParticleSystem ups, ParticleSystem ps)
{
ParticleSystemRenderer psr = ups.GetComponent <ParticleSystemRenderer>();
psr.sortingOrder = ps.Layer;
var material = UnityEditor.AssetDatabase.LoadAssetAtPath(ps.UnityResourceParam.MaterialPath, typeof(Material)) as Material;
psr.renderMode = (ParticleSystemRenderMode)ps.RenderParam.BillboardType;
if (psr.renderMode == ParticleSystemRenderMode.Mesh)
{
if (ps.SurfId != 0)
{
psr.mesh = UnityEditor.AssetDatabase.LoadAssetAtPath(ps.UnityResourceParam.MeshPath, typeof(Mesh)) as Mesh;
}
else
{
if (!File.Exists(SceneFileCopy.GetRelativeMeshDir(ps.RootFileName) + "quad90.prefab"))
{
PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Quad, true, SceneFileCopy.GetRelativeMeshDir(ps.RootFileName) + "quad90.prefab");
}
psr.mesh = UnityEditor.AssetDatabase.LoadAssetAtPath(SceneFileCopy.GetRelativeMeshDir(ps.RootFileName) + "quad90.prefab", typeof(Mesh)) as Mesh;
}
}
else if (psr.renderMode == ParticleSystemRenderMode.Stretch)
{
psr.lengthScale = 1.0f;
var texture = material.mainTexture as Texture2D;
var newtexture = ImageUtil.rotateTexture(texture, true);
newtexture.alphaIsTransparency = true;
newtexture.filterMode = texture.filterMode;
newtexture.wrapMode = texture.wrapMode;
newtexture.name = texture.name + "_rotNeg90";
//UnityEditor.AssetDatabase.CreateAsset(newtexture, SceneFileCopy.GetRelativeTextureDir(ps.RootFileName) + newtexture.name);
//UnityEditor.AssetDatabase.Refresh();
material.SetTexture("_MainTex", newtexture);
float baseTilingX = 1f;
float baseTilingY = 1f;
float baseOffsetX = 0f;
float baseOffsetY = 0f;
material.SetTextureScale("_MainTex", new Vector2(baseTilingX, baseTilingY));
material.SetTextureOffset("_MainTex", new Vector2(baseOffsetX, baseOffsetY));
uint color = 0xFFFFFFFF;
material.SetColor("_Color", new Color(((color >> 16) & 0xFF) / 255.0f,
((color >> 8) & 0xFF) / 255.0f,
(color & 0xFF) / 255.0f,
((color >> 24) & 0xFF) / 255.0f));
UnityEditor.AssetDatabase.Refresh();
}
//如果有mesh，强制使用meshbillboard 类型
if (ps.SurfId != 0)
{
psr.renderMode = ParticleSystemRenderMode.Mesh;
psr.mesh = UnityEditor.AssetDatabase.LoadAssetAtPath(ps.UnityResourceParam.MeshPath, typeof(Mesh)) as Mesh;
}
psr.material = material;
}
public static bool IsLiteralType(this Type type)
{
if (PrimitiveHelper.IsNullableType(type))
{
type = Nullable.GetUnderlyingType(type);
}
return(LiteralTypes.Contains(type) || typeof(Enum).IsAssignableFrom(type));
}
public static Mesh GetPrimitiveMesh(PrimitiveType type)
{
if (!PrimitiveHelper.primitiveMeshes.ContainsKey(type))
{
PrimitiveHelper.CreatePrimitiveMesh(type);
}
return(PrimitiveHelper.primitiveMeshes[type]);
}
public void DoStartTween(float fFrom, float fTo, float fMax)
{
float fCalc_From = PrimitiveHelper.GetPercentage_1(fFrom, fMax);
float fCalc_To = PrimitiveHelper.GetPercentage_1(fTo, fMax);
_pTweenProgress.ResetToBeginning();
_pTweenProgress.from = fCalc_From;
_pTweenProgress.to = fCalc_To;
_pTweenProgress.PlayForward();
}
private void Update()
{
if (Input.GetMouseButtonDown(0))
{
var go = PrimitiveHelper.CreatePrimitive(PrimitiveType.Cube, true);
var gP = Camera.main.ScreenPointToRay(Input.mousePosition).GetGridPosition();
go.transform.position = gP;
Debug.Log(gP);
}
}
private void CreateBall()
{
GameObject go = PrimitiveHelper.CreatePrimitiveGameObject(PrimitiveType.Sphere, true);
ball = go.AddComponent <Rigidbody>();
go.layer = LayerMask.NameToLayer(LAYER_NAME);
ball.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
go.transform.SetParent(transform.parent);
}
public static GameObject CreatePrimitive(PrimitiveType type, Material material)
{
GameObject gameObject = new GameObject(type.ToString());
MeshFilter meshFilter = gameObject.AddComponent <MeshFilter>();
meshFilter.sharedMesh = PrimitiveHelper.GetPrimitiveMesh(type);
gameObject.AddComponent <MeshRenderer>().material = material;
gameObject.AddComponent <MeshCollider>().sharedMesh = meshFilter.sharedMesh;
return(gameObject);
}
/* protected - Variable declaration */
/* private - Variable declaration */
// ========================================================================== //
/* public - [Do] Function
* 외부 객체가 호출(For External class call)*/
/* public - [Event] Function
* 프랜드 객체가 호출(For Friend class call)*/
// ========================================================================== //
/* protected - [abstract & virtual] */
/* protected - [Event] Function
* 자식 객체가 호출(For Child class call) */
/* protected - Override & Unity API */
protected override void OnPlayEvent()
{
base.OnPlayEvent();
_vecRotate = PrimitiveHelper.RandomRange(_vecRandomRotateSpeed_Min, _vecRandomRotateSpeed_Max);
transform.Rotate(_vecRotate);
if (_bExcuteUpdate)
{
StartCoroutine("CoUpdateRotate");
}
}
void Awake()
{
def = FindObjectOfType <MarbleSkinDefinitions>();
allSkins = FindObjectsOfType <MarbleSkin>();
mat = GetComponent <Renderer>().material;
mod = GetComponent <MeshFilter>().mesh;
unlock = FindObjectOfType <SkinUnlockManager>();
sphere = PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Sphere);
marMirror = (Mesh)Resources.Load("Marbles/MirroredMarble", typeof(Mesh));
marUnique = (Mesh)Resources.Load("Marbles/UniqueMarble", typeof(Mesh));
}
// Start is called before the first frame update
void Start()
{
// my inital motives/goals
mGoals = new Goal[3];
mGoals[0] = new Goal("Eat", 4);
mGoals[1] = new Goal("Sleep", 3);
mGoals[2] = new Goal("Bathroom", 3);
//// the actions I know how to do
mActions = new Action[6];
mActions[0] = new Action("eat a snack", PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Capsule));
mActions[0].targetGoals.Add(new Goal("Eat", -2f));
mActions[0].targetGoals.Add(new Goal("Sleep", -1f));
mActions[0].targetGoals.Add(new Goal("Bathroom", +1f));
mActions[1] = new Action("sleep in the bed", PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cube));
mActions[1].targetGoals.Add(new Goal("Eat", +2f));
mActions[1].targetGoals.Add(new Goal("Sleep", -4f));
mActions[1].targetGoals.Add(new Goal("Bathroom", +2f));
mActions[2] = new Action("visit the bathroom", PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cylinder));
mActions[2].targetGoals.Add(new Goal("Eat", 0f));
mActions[2].targetGoals.Add(new Goal("Sleep", 0f));
mActions[2].targetGoals.Add(new Goal("Bathroom", -4f));
mActions[3] = new Action("eat dinner", PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Plane));
mActions[3].targetGoals.Add(new Goal("Eat", -2f));
mActions[3].targetGoals.Add(new Goal("Sleep", -1f));
mActions[3].targetGoals.Add(new Goal("Bathroom", +1f));
mActions[4] = new Action("Nap on the couch", PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Quad));
mActions[4].targetGoals.Add(new Goal("Eat", +2f));
mActions[4].targetGoals.Add(new Goal("Sleep", -4f));
mActions[4].targetGoals.Add(new Goal("Bathroom", +2f));
mActions[5] = new Action("Take A Shower", PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Sphere));
mActions[5].targetGoals.Add(new Goal("Eat", 0f));
mActions[5].targetGoals.Add(new Goal("Sleep", 0f));
mActions[5].targetGoals.Add(new Goal("Bathroom", -4f));
// the rate my goals change just as a result of time passing
mChangeOverTime = new Action("tick");
mChangeOverTime.targetGoals.Add(new Goal("Eat", +4f));
mChangeOverTime.targetGoals.Add(new Goal("Sleep", +1f));
mChangeOverTime.targetGoals.Add(new Goal("Bathroom", +2f));
Debug.Log("Starting clock. One hour will pass every " + TICK_LENGTH + " seconds.");
InvokeRepeating("Tick", 0f, TICK_LENGTH);
Debug.Log("Hit E to do something.");
}
void OnDrawGizmosSelected()
{
Gizmos.color = navigable ? new Color(1.0f, 1.0f, 0, 0.5f) : new Color(1.0f, 0, 0, 0.5f);
Gizmos.DrawCube(new Vector3(xP, 0, zP), new Vector3(xS, 0.1f, zS));
Gizmos.color = Color.black;
Gizmos.DrawWireCube(new Vector3(xP, 0, zP), new Vector3(xS, 0.1f, zS));
Gizmos.color = new Color(0.0f, 1.0f, 1.0f);
Vector3 a = new Vector3(xP, 0.055f, zP);
foreach (NavigationPlane connection in connections)
{
if (connection != null)
{
Vector3 b = new Vector3(connection.xP, 0.055f, connection.zP);
Vector3 arrow = 0.4f * (Quaternion.Euler(0, -45, 0) * (a - b).normalized);
Gizmos.DrawLine(a, b);
Gizmos.DrawLine(b, b + arrow);
Gizmos.DrawLine(b, b + (Quaternion.Euler(0, 90, 0) * arrow));
}
}
foreach (Exception exception in exceptions)
{
if (exception.shape == ExceptionShape.CIRCLE)
{
Gizmos.color = exception.navigable ? Color.green : Color.red;
Gizmos.DrawMesh(PrimitiveHelper.GetPrimitiveMesh(PrimitiveType.Cylinder),
new Vector3(exception.xP, 0, exception.zP), Quaternion.identity,
new Vector3(exception.xS * 2, 0.0525f, exception.xS * 2));
}
else if (exception.shape == ExceptionShape.RECT)
{
Gizmos.color = exception.navigable ? Color.green : Color.red;
Gizmos.DrawCube(new Vector3(exception.xP, 0, exception.zP),
new Vector3(exception.xS, 0.105f, exception.zS));
}
else if (exception.shape == ExceptionShape.ROT_RECT)
{
Matrix4x4 push = Gizmos.matrix;
Gizmos.matrix = Matrix4x4.TRS(new Vector3(exception.xP, 0, exception.zP),
Quaternion.EulerRotation(0, exception.rot, 0), Vector3.one) *
Matrix4x4.Translate(new Vector3(-exception.xP, 0, -exception.zP)) * Gizmos.matrix;
Gizmos.color = exception.navigable ? Color.green : Color.red;
Gizmos.DrawCube(new Vector3(exception.xP, 0, exception.zP),
new Vector3(exception.xS, 0.105f, exception.zS));
Gizmos.matrix = push;
}
}
UnityEditor.Handles.Label(new Vector3(xP, 0.5f, zP), name, GUI.skin.button);
}
