Scolring - Forum

proto make_string_list =  fun [S [S r1] I ] [S r1];;

proto build_line_return_string = fun[[S r1] I I S]  S;;

proto build_line_return_string = fun[[S r1] I I S]  S;;
proto make_string_list =  fun [S [S r1] I ] [S r1];;




fun make_string_list(element, list, iterations) =
let 0 -> counter in
(
while (counter < iterations) do
(
set list = element::list;
set counter=counter+1;
);
);
list;;



fun build_line_return_string (list, multiplier, counter, output_string)=
	
	//end of list, return full string
	if ((hd list)== nil) then
	(
	
	output_string;
	)
	else
	//not end of list yet
	(	
	if ((mod counter multiplier)==0)
	then
	(
	//add head of list to end of string, add line return since we are at a multiple of multiplier that 
        //determines line length and 
        //feed tail of list and changed string back into function
	set output_string= strcatn output_string::(hd list):: "\n"::nil;
	set counter = counter +1;
	build_line_return_string tl list multiplier counter output_string;
	)
	else
	(
        //add head of list to end of string followed by a space, feed tail of list 
        //and changed string  back into function
	set output_string = strcatn output_string::(hd list)::" "::nil;
	set counter = counter +1;
	build_line_return_string  tl list multiplier counter output_string;

	);
	);;	
	
fun main()=
_showconsole; 
let make_string_list "vv" nil 100-> string_list in
_fooS build_line_return_string string_list 2 1 nil;
0;;

struct   Cylinder =[

	Icylindernumber	:	I,

	Icylinderindex		:	I,

	Fradius				: 	F,

	Fheight				: 	F,

	funlifespan			:	Timer,
	Ilifespanlength 	:	I,

	Sbirthfphrase		:	S,

	Sdeathphrase		:	S,

	fundyingclyinder	:	fun [Cylinder] S,

	funreturnarea		:	fun [Cylinder] F,

	funreturnvolume	:	fun[Cylinder] F,

	fbirthfunction  	:  fun[Cylinder] S,

	fdeathfunction  	:  fun[Cylinder] S

	

	]mkCylinder;;


//global list of Cylinders to grow and shrink

typeof lCylinderlist=[Cylinder r1];;
//global list of intergers to grab for new cylinders if they are free and to hold indeces of dead cylinders

typeof lDeleted_cylinder_ids = [I r1];;

typeof ICylinder_counter=		I;;

var Ihighest_Cylinder_Index= 0;;



//fun [Cylinder] F

fun returnarea(cylinder)=

   PIf*. cylinder.Fradius;; 

//fun [Cylinder] F 

fun returnvolume(cylinder)=

   (returnarea cylinder)*. cylinder.Fheight;; 



//fun [Cylinder] S

fun birthphase(cylinder)=

   _fooS strcatn "My name is: ":: (itoa(cylinder.Icylinderindex))::" and now I am being born, hello!"::nil;
   _fooS strcatn "My lifespan is :":: (itoa (cylinder.Ilifespanlength)):: " milliseconds."::nil;;

//fun [Cylinder] S     

fun deathphase(cylinder)=

   _fooS strcatn "My name is: ":: (itoa(cylinder.Icylinderindex))::" and now I am dying, goodbye!"::nil;;

/* --------- */



// Miscelleanous

// Note : A function already exists for that in the standard library

fun removeItemInList (list, item)=

	if list == nil then

		nil

	else

		if item == hd list then

			tl list

		else

			(hd list) :: removeItemInList tl list item;;

			

/* --------- */



//fun [] I

//get an id from lDeleted_cylinder_ids....if there are no ids available, return 0, once an index is encountered, return the index

fun get_deleted_cylinder_ID ()=

_fooS "get_deleted_cylinder_ID called";

let hd lDeleted_cylinder_ids -> head in

(

	if (head == nil)  then 

		(

		// there are no available deleted cylinder indexes, they have been used up between the function calling this function and the execution

		//of the line below

		nil;

	) else

	(

	

		_fooS strcatn "head of lDeleted_cylinder_ids is ":: (itoa head)::nil;

		//remove head from lDeleted_cylinder_ids

		set lDeleted_cylinder_ids=  (tl  lDeleted_cylinder_ids);

		_fooS strcatn "the new head of the lDeleted_cylinder_ids list is: " ::(itoa(hd lDeleted_cylinder_ids))::nil;

		_fooS strcatn "the head of the list in this function after resetting list is: ":: (itoa head)::nil; 

		head; 

	



	);

);;

	

//fun [[Cylinder r1] I] I

fun get_highest_id_from_cylinderlist (cylinderlist, id)=

//we want to get the highest Cylinder.Icylinderindex that exists in this list

if ((hd cylinderlist)==nil)&& ((sizelist lCylinderlist)==0) then

(

_fooS "there are no items in the list at all";

1;

)

else if ((hd cylinderlist)==nil)&& ((sizelist lCylinderlist)>0) then

(

      _fooS "we are at the end of a list that has items in it";

      _fooS strcat  "the following value is the highest value found in the complete list is: " (itoa id);

      //since we are making a new cylinder with an index that does not exist, increment global

      //Ihighest_Cylinder_Index by 1 from the highest found id

      set Ihighest_Cylinder_Index = id+1;

      Ihighest_Cylinder_Index;

) 

else

   //we are not at the end of the list yet

(

   //_fooS "there are items in the list and we are not at the end yet";

   let hd cylinderlist -> cylinder in

   let cylinder.Icylinderindex -> this_index in

   if (this_index > id) then

      (

         set id = this_index;

         //_fooS strcat "the highest id found so far is: " (itoa id);

         //we havve the higghest id so far, recursively search through rest of list

         //to see if we can find a higher id

         get_highest_id_from_cylinderlist (tl cylinderlist) id;



      )

   else

      (

         //don't change the id, we have the highest found so far

         //so we recursively search through rest of list

        // _fooS strcat "the highest id found so far is: " (itoa id);

         get_highest_id_from_cylinderlist (tl cylinderlist) id;



      );

);;



//fun[] I

fun get_highest_id_from_all_lists()=

	let  get_deleted_cylinder_ID -> result in

	(

//if there are no items in lDeleted_cylinder_ids, go search for highest id in lCylinderlist

if (result == nil) then

   (

    

    get_highest_id_from_cylinderlist  lCylinderlist nil;

   )

   else

   (

     result;

      

   );

   );;





//fun [cylinder] lCylinderlist



fun delete_cylinder(timer, dcylinder)=

   //destroy the timer

   _deltimer timer;

   //execute death function

   exec dcylinder.fdeathfunction with [dcylinder];

   //add the deleted cylinder index to the lDeleted_cylinder_ids list, so we can grab it if it is free and we add a new cylinder

   let dcylinder.Icylinderindex -> lindex in

   ( 

   _fooS strcatn "cylinder with index number ":: (itoa lindex):: " has died"::nil;

   //add index to lDeleted_cylinder_ids

   set lDeleted_cylinder_ids =lindex:: lDeleted_cylinder_ids;

   //decrement amount of cylinders in existence

   set  ICylinder_counter= ICylinder_counter-1;

   //remove cylinder from lCylinderlist

   set lCylinderlist= removeItemInList lCylinderlist dcylinder;
   _fooS strcatn "there are now :" ::(itoa(sizelist   lDeleted_cylinder_ids))::" cylinders in the lDeleted_cylinder_ids list."::nil;

   _fooS "the list of deleted cylinder id's is below:";  

   _fooIdList  lDeleted_cylinder_ids;

 

    _fooS strcatn "there are now ":: (itoa (sizelist lCylinderlist))::" cylinders in the lCylinderlist. \n \n \n":: nil;

    lCylinderlist;

   );;



//fun [Cylinder Timer] Cylinder

fun makeCylinderTimer (sCylinder, lifespan)=
	 //assign the lifespan in milliseconds for our ephemeral cylinder
   set sCylinder.Ilifespanlength = lifespan;

	set sCylinder.funlifespan = _rfltimer _starttimer _channel lifespan @delete_cylinder sCylinder;

	sCylinder;; 

  

//fun [] Cylinder

fun add_cylinder()=

   //whenever we add a cylinder, no matter where its id comes from, we are incemeneting the ICylinder_counter by one

   set ICylinder_counter=ICylinder_counter+1;

   //get cylinder id

   let get_highest_id_from_all_lists -> id in

   let  mkCylinder [ICylinder_counter id 2.0 22.0 nil nil nil nil nil nil nil nil nil ]->lcylinder in
   let rand/20 -> llifespan in

   let makeCylinderTimer lcylinder llifespan-> lcylinder in


   (

     


       //assign birth and death functions

      set lcylinder.fbirthfunction = @birthphase;

      set lcylinder.fdeathfunction =  @deathphase;

      set lcylinder.funreturnarea = @returnvolume;

      set lcylinder.funreturnvolume = @returnarea;

       //execute birth function

      _fooS "\n \n \n \n";

       _fooS "new cylinder created!";

      exec lcylinder.fbirthfunction with [lcylinder];

      let exec lcylinder.funreturnarea with [lcylinder] ->result in

      _fooS strcat "my area is " (ftoa result);

      let exec lcylinder.funreturnvolume with [lcylinder] ->result in

      _fooS strcat "my volume is " (ftoa result);



      //add cylinder to global lCylinderlist

      set lCylinderlist= lcylinder::lCylinderlist;

      _fooS strcatn "there are now ":: (itoa (sizelist lCylinderlist))::" cylinders in the lCylinderlist.":: nil;

      _fooS strcatn "the new cylinder id is: ":: (itoa id)::nil;

      lcylinder;

  );;

  

fun add_another_cylinder_after_timer(timer, param)=

   

_deltimer timer;

let 100 -> counter in

while (counter >0) do

(

add_cylinder;

set counter= counter-1;

);;





fun main()=

_showconsole;

let 20 -> counter in

while (counter >0) do

(

add_cylinder;

set counter= counter-1;

);

_rfltimer _starttimer _channel 4000 @add_another_cylinder_after_timer  nil;;

typeof list1 =[I r1];;
typeof list2 =[I r1];;

fun remove_from_list(l,p)=
 if l==nil then nil
 else let l -> [a nxt] in
  if a==p then nxt
  else a::remove_from_list nxt p;;


fun removeItemInList (list, item)=
	if list == nil then
		nil
	else
		if item == hd list then
			tl list
		else
			(hd list) :: removeItemInList tl list item;;
			
fun main()=
   _showconsole; 
   set list1= 2::8::561::591::nil;
   set list2= 2::8::561::591::nil;
    _fooS  "we are starting with list1 below:";
    _fooIdList  list1; 
    remove_from_list list1 561;
    _fooS  "the list after remove_from_list is below";
    _fooIdList list1;
     _fooS  "we are starting with list2 below:";
    _fooIdList  list2; 
    removeItemInList list2 561;
    _fooS  "the list after removeItemInList is below";
    _fooIdList list2;;

struct   Cylinder =[
	Icylindernumber:	I,
	Icylinderindex:	I,
	Fradius			: 	F,
	Fheight			: 	F,
	Tlifespan		:	Timer,	
	Sbirthfphrase	:	S,
	Sdeathphrase	:	S,
	fundyingclyinder:	fun [Cylinder] S,
	funreturnarea	:	fun [Cylinder] F,
	funreturnvolume:	fun[Cylinder] F
	
	]mkCylinder;;
	
typeof lCylinderlist=[Cylinder r1];;
typeof lDeleted_cylinder_ids= [I r1];;
typeof ICylinder_counter=		I;;
var Ihighest_Cylinder_Index= 0;;

fun get_highest_id_from_cylinderlist (cylinderlist, id)=
//we want to get the highest Cylinder.Icylinderindex that exists in this list!!!!!
if ((hd cylinderlist)==nil)&& ((sizelist lCylinderlist)==0) then
(
_fooS "there are no items in the list at all";
1;
)
else if ((hd cylinderlist)==nil)&& ((sizelist lCylinderlist)>0) then
(
_fooS "we are at the end of a list that has items in it";
_fooS strcat  "the following value is the highest value found in the complete list is: " (itoa id);
id;
) 
else
//we are not at the end of the list yet
(
_fooS "there are items in the list and we are not at the end yet";
let hd cylinderlist -> cylinder in
let cylinder.Icylinderindex -> this_index in
if (this_index > id) then
(
set id = this_index;
_fooS strcat "the highest id found so far is: " (itoa id);
//we havve the higghest id so far, recursively search through rest of list
//to see if we can find a higher id
get_highest_id_from_cylinderlist (tl cylinderlist) id;

)
else
(
//don't change the id, we have the highest found so far
//so we recursively search through rest of list
_fooS strcat "the highest id found so far is: " (itoa id);
get_highest_id_from_cylinderlist (tl cylinderlist) id;

);
);;


fun main()=
_showconsole;
let mkCylinder [1 879 nil nil nil nil nil nil nil nil]-> cylinder1 in
let mkCylinder [2 1056 nil nil nil nil nil nil nil nil]-> cylinder2 in
let mkCylinder [3 3456 nil nil nil nil nil nil nil nil]-> cylinder3 in
set lCylinderlist = cylinder1:: cylinder2::cylinder3::lCylinderlist; 
let nth_list lCylinderlist 0-> dcylinder in
let dcylinder.Icylinderindex -> index in
_fooS strcatn "the result of the index search through the list is:  ":: (itoa  (get_highest_id_from_cylinderlist lCylinderlist nil))::nil;;