Inform 7

Agnishom · 2013-11-30 00:28:50

Okay ask him

bobbym · 2013-11-30 02:43:50

I will, do not worry.

Agnishom · 2014-01-01 05:18:52

I was wondering if I could code modern encryption systems on Inform 7

Agnishom · 2014-01-01 06:02:58

Here is a little Inform 7 code for generating Fibonacci Numbers:

"The Fibonacci Sequence"

Pisa is a room. Leonardo Fibonacci is a man in Pisa. "The modest Italian mathematician, Leonardo Fibonacci (1170-1250), beams at you."

Sequencing is an action applying to one number. Understand "sequence [number]" as sequencing.

Instead of sequencing, say "You make a feeble attempt, sketching in the sand, but it goes nowhere. Leonardo is sympathetic. 'Often goes wrong for me, too, actually. I didn't even invent the thing - the ancient Indians knew about it first.'"

Persuasion rule for asking Leonardo to try sequencing: persuasion succeeds.

Report Leonardo sequencing:
	let N be the number understood;
	say "Leonardo scratches his head and makes self-deprecating remarks, before coming up with [the first N terms of the Fibonacci sequence]."

[ An array need not be fixed in length, as the following example shows:]

To decide what list of numbers is the first (F - a number) terms of the Fibonacci sequence:
	let the Fibonacci sequence be {1, 1};
	let N be 3;
	while N < F:
		let the last term be entry (N - 1) of the Fibonacci sequence;
		let the penultimate term be entry (N - 2) of the Fibonacci sequence;
		let the next term be the last term plus the penultimate term;
		add the next term to the Fibonacci sequence;
		increment N;
	decide on the Fibonacci sequence.

Test me with "sequence 20 / leonardo, sequence 20".

Agnishom · 2014-01-01 06:26:51

A cheesy program

"XYZZY"

Understand "xyzzy" or "say xyzzy" or "cast xyzzy" as casting xyzzy.

Casting xyzzy is an action applying to nothing.

Check casting xyzzy:
	if the player does not wear the amulet of elocution, say "You are unable to articulate the second 'z' separately from the first, and the spell fails in a disdainful puff. Must be Parisian magic." instead;
	if the player has the plate, say "The plate of cheeses twitches uncomfortably, aware that it should be doing something, but not sure what." instead.

Carry out casting xyzzy:
	move the plate to the player. ch

Report casting xyzzy:
	say "Under the influence of the Amulet of Elocution, you pronounce this as Xhi-zee. And lo, from nowhere, a [plate] appears!"

The amulet of elocution is a wearable thing. It is carried by the player. The description is "A heavy gold ring on a chain. If heated in an ordinary house fire, it glows with the words, 'Moses Supposes His Toeses Are Roses.'"

The plate is a portable supporter. On the plate is a very ripe ooze. Instead of smelling the ooze, say "It smells like socks. This is going to be wonderful." The ooze is edible. The printed name of the plate is "plate[if the plate supports the ooze] of cheese[end if]". The description of the ooze is "Definitely genuinely cheese." Understand "cheese" as the ooze.

Instead of eating the ooze: remove the ooze from play; say "You are transported..."; move the player to Paradise.

The Cheez Factory is a room. "All around you are squares of pressed orange polymer, or possibly cheez. Your only hope is the magic word your uncle taught you: XYZZY." The squares of pressed orange polymer are scenery in the Factory. The description is "You see nothing special about the squares of pressed orange polymer. Nothing special at all." Understand "square" or "cheez" as the squares.

Paradise is a room. The description is "Well, it might just be one of the posh upper rings of purgatory, if you're entirely honest with yourself."

Test me with "x squares / x amulet / x cheese / xyzzy / wear amulet / xyzzy / x ooze / smell ooze /  eat ooze".

Agnishom · 2014-04-18 01:19:30

The mandelbrot fractal

"Mandelbrot"
 
The story headline is "A Non-Interactive Set".
 
Include Glimmr Drawing Commands by Erik Temple.
 
[Q20 fixed-point or floating-point: see definitions below]
Use floating-point math.
 
Finished is a room.
 
The graphics-window is a graphics g-window spawned by the main-window.
The position is g-placeabove.
 
When play begins:
	let f10 be 10 as float;
	now min re is ( -20 as float ) fdiv f10;
	now max re is ( 6 as float ) fdiv f10;
	now min im is ( -12 as float ) fdiv f10;
	now max im is ( 12 as float ) fdiv f10;
	now max iterations is 100;
	add color g-Black to the palette;
	add color g-Red to the palette;
	add hex "#FFA500" to the palette;
	add color g-Yellow to the palette;
	add color g-Green to the palette;
	add color g-Blue to the palette;
	add hex "#4B0082" to the palette;
	add hex "#EE82EE" to the palette;
	open up the graphics-window.
 
Min Re is a number that varies.
Max Re is a number that varies.
Min Im is a number that varies.
Max Im is a number that varies.
 
Max Iterations is a number that varies.
 
Min X is a number that varies.
Max X is a number that varies.
Min Y is a number that varies.
Max Y is a number that varies.
 
The palette is a list of numbers that varies.
 
[vertically mirrored version]
Window-drawing rule for the graphics-window when max im is fneg min im:
	clear the graphics-window;
	let point be { 0, 0 };
	now min X is 0 as float;
	now min Y is 0 as float;
	let mX be the width of the graphics-window minus 1;
	let mY be the height of the graphics-window minus 1;
	now max X is mX as float;
	now max Y is mY as float;
	let L be the column order with max mX;
	repeat with X running through L:
		now entry 1 in point is X;
		repeat with Y running from 0 to mY / 2:
			now entry 2 in point is Y;
			let the scaled point be the complex number corresponding to the point;
			let V be the Mandelbrot result for the scaled point;
			let C be the color corresponding to V;
			if C is 0, next;
			draw a rectangle (C) in the graphics-window at the point with size 1 by 1;
			now entry 2 in point is mY - Y;
			draw a rectangle (C) in the graphics-window at the point with size 1 by 1;
		yield to VM;
	rule succeeds.
 
[slower non-mirrored version]
Window-drawing rule for the graphics-window:
	clear the graphics-window;
	let point be { 0, 0 };
	now min X is 0 as float;
	now min Y is 0 as float;
	let mX be the width of the graphics-window minus 1;
	let mY be the height of the graphics-window minus 1;
	now max X is mX as float;
	now max Y is mY as float;
	let L be the column order with max mX;
	repeat with X running through L:
		now entry 1 in point is X;
		repeat with Y running from 0 to mY:
			now entry 2 in point is Y;
			let the scaled point be the complex number corresponding to the point;
			let V be the Mandelbrot result for the scaled point;
			let C be the color corresponding to V;
			if C is 0, next;
			draw a rectangle (C) in the graphics-window at the point with size 1 by 1;
		yield to VM;
	rule succeeds.
 
To decide which list of numbers is column order with max (N - number):
	let L be a list of numbers;
	let L2 be a list of numbers;
	let D be 64;
	let rev be false;
	while D > 0:
		let X be 0;
		truncate L2 to 0 entries;
		while X <= N:
			if D is 64 or X / D is odd, add X to L2;
			increase X by D;
		if rev is true:
			reverse L2;
			let rev be false;
		otherwise:
			let rev be true;
		add L2 to L;
		let D be D / 2;
	decide on L.
 
To decide which list of numbers is complex number corresponding to (P - list of numbers):
	let R be a list of numbers;
	extend R to 2 entries;
	let X be entry 1 in P as float;
	let X be (max re fsub min re) fmul (X fdiv max X);
	let X be X fadd min re;
	let Y be entry 2 in P as float;
	let Y be (max im fsub min im) fmul (Y fdiv max Y);
	let Y be Y fadd min im;
	now entry 1 in R is X;
	now entry 2 in R is Y;
	decide on R.
 
To decide which number is Mandelbrot result for (P - list of numbers):
	let c_re be entry 1 in P;
	let c_im be entry 2 in P;
	let z_re be 0 as float;
	let z_im be z_re;
	let threshold be 4 as float;
	let runs be 0;
	while 1 is 1:
		[ z = z * z ]
		let r2 be z_re fmul z_re;
		let i2 be z_im fmul z_im;
		let ri be z_re fmul z_im;
		let z_re be r2 fsub i2;
		let z_im be ri fadd ri;
		[ z = z + c ]
		let z_re be z_re fadd c_re;
		let z_im be z_im fadd c_im;
		let norm be (z_re fmul z_re) fadd (z_im fmul z_im);
		increase runs by 1;
		if norm is greater than threshold, decide on runs;
		if runs is max iterations, decide on 0.
 
To decide which number is color corresponding to (V - number):
	let L be the number of entries in the palette;
	let N be the remainder after dividing V by L;
	decide on entry (N + 1) in the palette.
 
Section - Fractional numbers (for Glulx only)
 
To decide which number is (N - number) as float: (- (numtof({N})) -).
To decide which number is (N - number) fadd (M - number): (- (fadd({N}, {M})) -).
To decide which number is (N - number) fsub (M - number): (- (fsub({N}, {M})) -).
To decide which number is (N - number) fmul (M - number): (- (fmul({N}, {M})) -).
To decide which number is (N - number) fdiv (M - number): (- (fdiv({N}, {M})) -).
To decide which number is fneg (N - number): (- (fneg({N})) -).
To yield to VM: (- glk_select_poll(gg_event); -).
 
Use Q20 fixed-point math translates as (- Constant Q20_MATH; -).
Use floating-point math translates as (- Constant FLOAT_MATH; -).
 
Include (-
#ifdef Q20_MATH;
! Q11.20 format: 1 sign bit, 11 integer bits, 20 fraction bits
[ numtof n r; @shiftl n 20 r; return r; ];
[ fadd n m; return n+m; ];
[ fsub n m; return n-m; ];
[ fmul n m; n = n + $$1000000000; @sshiftr n 10 n; m = m + $$1000000000; @sshiftr m 10 m; return n * m; ]; 
[ fdiv n m; @sshiftr m 20 m; return n / m; ];
[ fneg n; return -n; ];
#endif;
 
#ifdef FLOAT_MATH;
[ numtof f; @"S2:400" f f; return f; ];
[ fadd n m; @"S3:416" n m n; return n; ];
[ fsub n m; @"S3:417" n m n; return n; ];
[ fmul n m; @"S3:418" n m n; return n; ];
[ fdiv n m; @"S3:419" n m n; return n; ];
[ fneg n; @bitxor n $80000000 n; return n; ];
#endif;
-).

Math Is Fun Forum

#26 2013-11-30 00:28:50

Re: Inform 7

#27 2013-11-30 02:43:50

Re: Inform 7

#28 2014-01-01 05:18:52

Re: Inform 7

#29 2014-01-01 06:02:58

Re: Inform 7

#30 2014-01-01 06:26:51

Re: Inform 7

#31 2014-04-18 01:19:30

Re: Inform 7

Board footer