public static void Main(string[] args) { int num; prog pg = new prog(); Console.WriteLine("Enter a decimal number: "); num = int.Parse(Console.ReadLine()); Console.WriteLine("The binary equivalent of num is :"); pg.binaryconversion(num); Console.ReadLine(); }
// public delegate void ScreenShotCallBack(int status, int imageSize, IntPtr imageData); // private readonly ScreenShotCallBack _SubscriptionDelegate; public static void Main(string[] args) { prog pr = new prog(); // _callingDelegateA = img_data_save; int a = pr.add_nums(); Console.WriteLine(a); pr.getByteArray(); System.Console.WriteLine("Reached"); }
public Abstrakt2() { var go = new prog(); go.run(1); go.run(1); go.run(2); go.run(1); go.run(1); go.run(1); }
void Start() { kprog = new prog(); action1 ka0 = new action1(1); action1 ka1 = new action1(2); action2 ka2 = new action2(3, "yo"); action1 ka3 = new action1(-1); kprog.nodes = new node[] { ka0, ka1, ka2, ka3 }; string prog = JsonUtility.ToJson(kprog, true); print(prog); StreamWriter writer = new StreamWriter("Assets/Resources/test2.txt"); writer.WriteLine(prog); writer.Close(); print("done"); }
private void button1_Click(object sender, EventArgs e) { prog var1 = new prog(); var1.start_data(this); //pass along instance of your main form }
/* ============= SV_RunThink Runs thinking code if time. There is some play in the exact time the think function will be called, because it is called before any movement is done in a frame. Not used for pushmove objects, because they must be exact. Returns false if the entity removed itself. ============= */ static bool SV_RunThink(prog.edict_t ent) { double thinktime; thinktime = ent.v.nextthink; if (thinktime <= 0 || thinktime > sv.time + host.host_frametime) return true; if (thinktime < sv.time) thinktime = sv.time; // don't let things stay in the past. // it is possible to start that way // by a trigger with a local time. ent.v.nextthink = 0; prog.pr_global_struct[0].time = thinktime; prog.pr_global_struct[0].self = prog.EDICT_TO_PROG(ent); prog.pr_global_struct[0].other = prog.EDICT_TO_PROG(sv.edicts[0]); prog.PR_ExecuteProgram(prog.pr_functions[ent.v.think]); return !ent.free; }
/* ============= SV_Physics_Toss Toss, bounce, and fly movement. When onground, do nothing. ============= */ static void SV_Physics_Toss(prog.edict_t ent) { //trace_t trace; double[] move = new double[3]; double backoff; // regular thinking if (!SV_RunThink (ent)) return; // if onground, return without moving if ( ((int)ent.v.flags & FL_ONGROUND) != 0 ) return; SV_CheckVelocity (ent); // add gravity if (ent.v.movetype != MOVETYPE_FLY && ent.v.movetype != MOVETYPE_FLYMISSILE) SV_AddGravity (ent); // move angles mathlib.VectorMA (ent.v.angles, host.host_frametime, ent.v.avelocity, ref ent.v.angles); // move origin mathlib.VectorScale (ent.v.velocity, host.host_frametime, ref move); /*trace = SV_PushEntity (ent, move); if (trace.fraction == 1) return;*/ if (ent.free) return; if (ent.v.movetype == MOVETYPE_BOUNCE) backoff = 1.5; else backoff = 1; //ClipVelocity (ent.v.velocity, trace.plane.normal, ent.v.velocity, backoff); // stop if on ground /*if (trace.plane.normal[2] > 0.7) { if (ent.v.velocity[2] < 60 || ent.v.movetype != MOVETYPE_BOUNCE) { ent.v.flags = (int)ent.v.flags | FL_ONGROUND; ent.v.groundentity = EDICT_TO_PROG(trace.ent); VectorCopy (vec3_origin, ent.v.velocity); VectorCopy (vec3_origin, ent.v.avelocity); } }*/ // check for in water //SV_CheckWaterTransition (ent); }
/* ================ SV_Physics_Pusher ================ */ static void SV_Physics_Pusher(prog.edict_t ent) { double thinktime; double oldltime; double movetime; oldltime = ent.v.ltime; thinktime = ent.v.nextthink; if (thinktime < ent.v.ltime + host.host_frametime) { movetime = thinktime - ent.v.ltime; if (movetime < 0) movetime = 0; } else movetime = host.host_frametime; if (movetime != 0) { //SV_PushMove (ent, movetime); // advances ent.v.ltime if not blocked } if (thinktime > oldltime && thinktime <= ent.v.ltime) { ent.v.nextthink = 0; prog.pr_global_struct[0].time = sv.time; prog.pr_global_struct[0].self = prog.EDICT_TO_PROG(ent); prog.pr_global_struct[0].other = prog.EDICT_TO_PROG(sv.edicts[0]); prog.PR_ExecuteProgram(prog.pr_functions[ent.v.think]); if (ent.free) return; } }
//============================================================================ /* ============= SV_Physics_None Non moving objects can only think ============= */ static void SV_Physics_None(prog.edict_t ent) { // regular thinking SV_RunThink (ent); }
/* ============= SV_Physics_Noclip A moving object that doesn't obey physics ============= */ static void SV_Physics_Noclip(prog.edict_t ent) { // regular thinking if (!SV_RunThink (ent)) return; mathlib.VectorMA (ent.v.angles, host.host_frametime, ent.v.avelocity, ref ent.v.angles); mathlib.VectorMA(ent.v.origin, host.host_frametime, ent.v.velocity, ref ent.v.origin); //SV_LinkEdict (ent, false); }
/* ================ SV_Physics_Client Player character actions ================ */ static void SV_Physics_Client(prog.edict_t ent, int num) { if ( ! svs.clients[num-1].active ) return; // unconnected slot // // call standard client pre-think // prog.pr_global_struct[0].time = sv.time; prog.pr_global_struct[0].self = prog.EDICT_TO_PROG(ent); prog.PR_ExecuteProgram(prog.pr_functions[prog.pr_global_struct[0].PlayerPreThink]); // // do a move // SV_CheckVelocity (ent); // // decide which move function to call // switch ((int)ent.v.movetype) { case MOVETYPE_NONE: if (!SV_RunThink (ent)) return; break; case MOVETYPE_WALK: if (!SV_RunThink (ent)) return; /*if (!SV_CheckWater (ent) && ! ((int)ent.v.flags & FL_WATERJUMP) ) SV_AddGravity (ent); SV_CheckStuck (ent); SV_WalkMove (ent);*/ break; case MOVETYPE_TOSS: case MOVETYPE_BOUNCE: //SV_Physics_Toss (ent); break; case MOVETYPE_FLY: if (!SV_RunThink (ent)) return; //SV_FlyMove (ent, host.host_frametime, null); break; case MOVETYPE_NOCLIP: if (!SV_RunThink (ent)) return; mathlib.VectorMA (ent.v.origin, host.host_frametime, ent.v.velocity, ref ent.v.origin); break; default: sys_linux.Sys_Error ("SV_Physics_client: bad movetype " + (int)ent.v.movetype); break; } // // call standard player post-think // //SV_LinkEdict (ent, true); prog.pr_global_struct[0].time = sv.time; prog.pr_global_struct[0].self = prog.EDICT_TO_PROG(ent); prog.PR_ExecuteProgram(prog.pr_functions[prog.pr_global_struct[0].PlayerPostThink]); }
/* ================ SV_CheckVelocity ================ */ static void SV_CheckVelocity(prog.edict_t ent) { int i; // // bound velocity // for (i=0 ; i<3 ; i++) { if (double.IsNaN(ent.v.velocity[i])) { console.Con_Printf ("Got a NaN velocity on " + prog.pr_string(ent.v.classname) + "\n"); ent.v.velocity[i] = 0; } if (double.IsNaN(ent.v.origin[i])) { console.Con_Printf("Got a NaN origin on " + prog.pr_string(ent.v.classname) + "\n"); ent.v.origin[i] = 0; } if (ent.v.velocity[i] > sv_maxvelocity.value) ent.v.velocity[i] = sv_maxvelocity.value; else if (ent.v.velocity[i] < -sv_maxvelocity.value) ent.v.velocity[i] = -sv_maxvelocity.value; } }
/* ============ SV_AddGravity ============ */ static void SV_AddGravity(prog.edict_t ent) { double ent_gravity; /*eval_t *val; val = GetEdictFieldValue(ent, "gravity"); if (val && val._float) ent_gravity = val._float; else*/ ent_gravity = 1.0; ent.v.velocity[2] -= ent_gravity * sv_gravity.value * host.host_frametime; }