using UnityEngine;
using System.Collections;
public class HexGridSnap : MonoBehaviour {
static float size,h,r,b,a;
static void Init (float size) {
HexGridSnap.size = size;
h = Mathf.Sin(30*Mathf.Deg2Rad) * size;
r = Mathf.Cos(30*Mathf.Deg2Rad) * size;
b = size + 2 * h;
a = 2 * r;
}
static Vector3 Snap(Vector3 p) {
var u = p.x;
var v = p.z;
var x = u - u % a + r;
var y = v - v % b + ((x - r) / a % 1) * b / 2;
return new Vector3(x, p.y, y);
}
}
motorRPM = minRPM + (wheelRPM * finalDriveRatio * gearRatios.Evaluate(gearIndex));
totalMotorTorque = torqueCurve.Evaluate(motorRPM) * gearRatios.Evaluate(gearIndex) * finalDriveRatio * accel;
Master Chief rides to the rescue, solving all OSX Server problems in his path...
simon@metaplay:~$ uptime
12:49:18 up 923 days, 4 min, 1 user, load average: 0.00, 0.00, 0.00
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class GUISizer {
static float WIDTH = 1024;
static float HEIGHT = 768;
static List<Matrix4x4> stack = new List<Matrix4x4> ();
static public void BeginGUI() {
stack.Add (GUI.matrix);
Matrix4x4 m = new Matrix4x4 ();
var w = (float)Screen.width;
var h = (float)Screen.height;
var aspect = w / h;
var scale = 1f;
var offset = Vector3.zero;
if(aspect < (WIDTH/HEIGHT)) { //screen is taller
scale = (Screen.width/WIDTH);
offset.y += (Screen.height-(HEIGHT*scale))*0.5f;
} else { // screen is wider
scale = (Screen.height/HEIGHT);
offset.x += (Screen.width-(WIDTH*scale))*0.5f;
}
m.SetTRS(offset,Quaternion.identity,Vector3.one*scale);
GUI.matrix *= m;
}
static public void EndGUI() {
GUI.matrix = stack[stack.Count - 1];
stack.RemoveAt (stack.Count - 1);
}
}
using UnityEngine;
using System.Collections;
public class LOD : MonoBehaviour
{
//distances where LOD transitions occur.
public float[] lodLevels = new float[] { 1000f, 800f, 600f, 400f, 200f, 100f, 50f, 10f };
//These are the builtin LOD values for Unity shaders.
int[] shaderLOD = new int[] { 600, 500, 400, 300, 250, 200, 150, 100 };
void Start ()
{
StartCoroutine ("UpdateLOD");
}
void SetLOD (int LOD)
{
foreach (var i in renderer.sharedMaterials) {
i.shader.maximumLOD = shaderLOD[LOD];
}
}
IEnumerator UpdateLOD ()
{
var period = Random.value;
var cam = Camera.main.transform;
float[] levels = new float[lodLevels.Length];
int i = 0;
foreach (var level in lodLevels) {
levels[i++] = level * level;
}
while (true) {
var distance = (transform.position - cam.position).sqrMagnitude;
var LOD = levels.Length - 1;
foreach (var level in levels) {
if (distance > level) {
SetLOD (LOD);
break;
}
LOD--;
}
// make LOD checking non deterministic. avoids stampeding LOD calls?
yield return new WaitForSeconds (period);
}
}
}
using UnityEngine;It is used to create components which persist across level loads, without needing to create GameObjects to hold those components in the editor. It solves the problem where you may need to load levels in a specific order to make sure your persistent game objects are available in the level you wish to test.
using System.Collections;
public class Manager : MonoBehaviour {
static public T Instance<T>() where T : Component {
T component;
var g = GameObject.Find("/" + typeof(T).ToString());
if(g == null) {
g = new GameObject(typeof(T).ToString());
component = g.AddComponent<T>();
DontDestroyOnLoad(g);
} else {
component = g.GetComponent<T>();
}
return component;
}
}
Manager.Instance<MusicMixer>();And if it does not exist in the level already, it will be created and returned, and also used across subsequent references to the MusicMixer.
using System;
using System.Threading;
public class RingQueue
{
private int size;
private int read = 0;
private int write = 0;
private int count = 0;
private T[] objects;
private AutoResetEvent addEvent;
private AutoResetEvent popEvent;
public RingQueue (int size)
{
addEvent = new AutoResetEvent (false);
popEvent = new AutoResetEvent (false);
this.size = size;
objects = new T[size + 1];
}
public bool Empty {
get {
lock (this) {
return (read == write) && (count == 0);
}
}
}
public bool Full {
get {
lock (this) {
return (read == write) && (count > 0);
}
}
}
public void Add (T item)
{
lock (popEvent) {
if (Full) {
popEvent.WaitOne ();
}
objects[write] = item;
count++;
write = (write + 1) % size;
addEvent.Set ();
}
}
public T Pop ()
{
lock (addEvent) {
if (Empty) {
addEvent.WaitOne ();
}
T item = objects[read];
count--;
read = (read + 1) % size;
popEvent.Set ();
return item;
}
}
}
using UnityEngine;
using System.Collections;
using System.Threading;
public class FibraTest : Fibra {
public IEnumerator Busy() {
Debug.Log("Before Continue.");
yield return new FiContinue();
Debug.Log("After Continue.");
yield return new FiContinue();
Debug.Log("Finished.");
yield return new FiSleep(3);
Debug.Log("Ok really finished. Well with this CPU anyway:" + Thread.CurrentThread.ManagedThreadId.ToString());
yield return new FiBranch();
Debug.Log("I'm in another thread:" + Thread.CurrentThread.ManagedThreadId.ToString());
Thread.Sleep(1000);
yield return new FiContinue();
Debug.Log("Done:" + Thread.CurrentThread.ManagedThreadId.ToString());
}
// Use this for initialization
void Start () {
StartGreenThread("Busy");
}
// Update is called once per frame
public new void Update () {
base.Update();
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Threading;
public abstract class FInstruction
{
public abstract bool Execute (Fibra scheduler, IEnumerator task);
}
public class FiContinue : FInstruction
{
public override bool Execute (Fibra scheduler, IEnumerator task)
{
return true;
}
}
public class FiBranch : FInstruction
{
public override bool Execute (Fibra scheduler, IEnumerator task)
{
ThreadPool.QueueUserWorkItem(delegate(object state) {
bool removeTask = false;
try {
if (task.MoveNext ()) {
var fi = task.Current as FInstruction;
removeTask = !fi.Execute (scheduler, task);
} else
removeTask = true;
} catch(Exception e) {
// Do something in here!
}
if(!removeTask) {
scheduler.StartGreenThread(task);
}
});
return false;
}
}
public class FiSleep : FInstruction
{
float seconds;
public FiSleep (float seconds)
{
this.seconds = seconds;
}
IEnumerator Sleep (Fibra scheduler, IEnumerator task)
{
yield return new WaitForSeconds (seconds);
scheduler.StartGreenThread (task);
}
public override bool Execute (Fibra scheduler, IEnumerator task)
{
scheduler.StartCoroutine (Sleep (scheduler, task));
return false;
}
}
public class Fibra : MonoBehaviour
{
static List<IEnumerator> tasks = new List<IEnumerator> ();
static Dictionary<string, IEnumerator> names = new Dictionary<string, IEnumerator> ();
public void StartGreenThread (string taskName, params object[] args)
{
var method = this.GetType ().GetMethod (taskName);
if (args.Length == 0)
args = null;
var task = method.Invoke (this, args) as IEnumerator;
names.Add (taskName, task);
StartGreenThread (task);
}
public void StopGreenThread (string taskName)
{
var task = names[taskName];
Fibra.tasks.Remove (task);
names.Remove (taskName);
}
public void StartGreenThread (IEnumerator task)
{
lock(Fibra.tasks) {
Fibra.tasks.Add (task);
}
}
public void Update ()
{
for (int i = 0; i < Fibra.tasks.Count; i++) {
bool removeTask = false;
var task = tasks[i];
if (task.MoveNext ()) {
var fi = task.Current as FInstruction;
removeTask = !fi.Execute (this, task);
} else
removeTask = true;
if (removeTask)
tasks.RemoveAt (i--);
}
}
}
sudo apt-get install avahi-daemon avahi-autoipd
auto eth0(The ipv4ll is the magic bit.)
iface eth0 inet ipv4ll
sudo /etc/init.d/networking restart
listen SomethingHappens;
notify SomethingHappens;
_1.png)
_5.png)
_6.png)
_7.png)
if deviceVersion != "iPhone4":
GoReallySlowMode(True)
SuckLotsOfBattery()
WaitSomeSeconds(Random() * 10)
ThinkAboutDoingSomething()
PretendToDoSomething()
FinallyDoSomething(reallyJerkyMode=True)
using System;
using System.Threading;
using UnityEngine;
public class ThreadedComponent : MonoBehaviour
{
Thread thread;
Mutex mainLoop;
void Awake() {
mainLoop = new Mutex(true);
thread = new Thread(ThreadWorker);
}
void Start() {
thread.Start();
}
void OnApplicationQuit() {
thread.Abort();
}
void ThreadWorker() {
//Catch and report any exceptions here,
//so that Unity doesn't crash!
try {
_ThreadWorker();
} catch(Exception e) {
if(!(e is ThreadAbortException))
Debug.LogError("Unexpected Death: " + e.ToString());
}
}
void Update() {
//Gives the thread a chance to work with gameobjects.
mainLoop.ReleaseMutex();
mainLoop.WaitOne();
}
void _ThreadWorker() {
while(true) {
//Play nice with other threads...
Thread.Sleep(0);
//Do random work here...
//Wait till it is safe to work with GameObjects.
mainLoop.WaitOne();
//Work with gameobject in here...
//But don't take too long!
mainLoop.ReleaseMutex();
//Signal Unity that we're done with GameObjects.
}
}
}
