User:Reversedragon/Wavebuilder/2410-22 wave-score - Revision history

Reversedragon: category

2025-07-11T06:41:44Z

Reversedragon: Property links

2025-06-13T10:19:51Z

Property links

← Older revision		Revision as of 10:19, 13 June 2025
Line 51:		Line 51:
	* a concept's "canonical" point value is considered to be the <i class="line">lowest</i> sum required to create it, but I have also recorded the highest possible sums I know of to create particular concepts mostly just for fun.		* a concept's "canonical" point value is considered to be the <i class="line">lowest</i> sum required to create it, but I have also recorded the highest possible sums I know of to create particular concepts mostly just for fun.
	* a third possible metric is "[https://github.com/expitau/InfiniteCraftWiki cost]", which is the total number of <i class="line">unique</i> elements required to create an element.		* a third possible metric is "[https://github.com/expitau/InfiniteCraftWiki cost]", which is the total number of <i class="line">unique</i> elements required to create an element.

	</div>		</div>

	<div class="bop-foot">		<div class="bop-foot">

	<dl class="bop-meta">~~<!--~~		<dl class="bop-meta">
	{{~~BopFwd~~\|~~Philosophical Research~~:~~MDem/5.2/1111 FreeWill~~\|~~link~~}}		{{BopRev\|Ontology:P156\| Wavebuilder: quilt score (cost) }}
	; {{~~BopComment~~}} -->		{{BopRev\|Ontology:P157\| Wavebuilder: ply count (moves) }}
			{{BopRev\|Ontology:P158\| Wavebuilder: wave sum }}
			<!-- ; -->{{BopComment}}
	{{BopCreated\|2024-10-22T03:16:28Z}}		{{BopCreated\|2024-10-22T03:16:28Z}}
	{{BopComment\| REJECTED from Reddit for karma. post karma 1, comment karma 11}}		{{BopComment\| REJECTED from Reddit for karma. post karma 1, comment karma 11}}

Reversedragon: annotate Lisp code

2025-05-28T06:36:08Z

annotate Lisp code

← Older revision		Revision as of 06:36, 28 May 2025
Line 23:		Line 23:
	If you can understand Lisp, these are the exact algorithms currently used for sum and moves:		If you can understand Lisp, these are the exact algorithms currently used for sum and moves:

	<pre>(defun hyle-sum-+ (a b) ; add up element sums to produce result sum		<pre>(defun hyle-sum-+ (a b) ; add up element sums to produce result sum
	(max		(max ; out of these two values...
	(if (equal (hyle-id a) (hyle-id b))		(if (equal (hyle-id a) (hyle-id b)) ; if the same element is used twice...
	(+ (hyle-sum a) 1)		(+ (hyle-sum a) 1) ; ...count one as a basic turn-1 element
	(+ (hyle-sum a) (hyle-sum b)))		(+ (hyle-sum a) (hyle-sum b))) ; ...otherwise add their scores
	1))		1)) ; ...return either the sum or a number no less than 1

	(defun hyle-moves-+ (a b) ; add up element moves		(defun hyle-moves-+ (a b) ; add up element moves/turns/"plies"
	(+ 1 (max (hyle-moves a) (hyle-moves b))))</pre>		(+ 1 ; each new combination adds exactly one move to...
			(max (hyle-moves a) (hyle-moves b)))) ; the single element of the two with the greatest number of moves.</pre>

	<hr class="dash" />		<hr class="dash" />

Reversedragon: cost metric

2025-04-29T05:36:42Z

cost metric

← Older revision		Revision as of 05:36, 29 April 2025
Line 38:		Line 38:

	If you have any thoughts on how to improve this scoring system such as other metrics to add — maybe there's some great insight from advanced mathematics on networks of combining elements that I missed? maybe there are crazy patterns to First Discoveries I didn't think about? — feel free to share them. I would gladly add a good metric to wavebuilder for what it counts for (the project is very unfinished), but in general I feel like Infinite Craft guides need better analysis tools so we can really start finding and discussing interesting patterns.		If you have any thoughts on how to improve this scoring system such as other metrics to add — maybe there's some great insight from advanced mathematics on networks of combining elements that I missed? maybe there are crazy patterns to First Discoveries I didn't think about? — feel free to share them. I would gladly add a good metric to wavebuilder for what it counts for (the project is very unfinished), but in general I feel like Infinite Craft guides need better analysis tools so we can really start finding and discussing interesting patterns.

			</div>

			<div class="bop">
			<h3><time datetime="2024-11-24T18:16:02Z">24-11</time></h3>

			<ins>[This is taken from one of the prototype dictionaries within the Wavebuilder code repository.]</ins>

			* the point value of every concept (<code>:sum</code>) is either 1 or the sum of the previous two concepts' point values.
			* elements also have a <code>:moves</code> number shown after the colon, which is the raw number of actions required to reach the element after each previous element already exists.
			* a concept's "canonical" point value is considered to be the <i class="line">lowest</i> sum required to create it, but I have also recorded the highest possible sums I know of to create particular concepts mostly just for fun.
			* a third possible metric is "[https://github.com/expitau/InfiniteCraftWiki cost]", which is the total number of <i class="line">unique</i> elements required to create an element.

	</div>		</div>

Reversedragon: formatting

2025-04-29T04:34:27Z

formatting

← Older revision		Revision as of 04:34, 29 April 2025
Line 1:		Line 1:
	<~~pre~~># Can anyone help add my "wave score"?		{{BopCSS}}<!--
			-->
			= Can anyone help add my "wave score"? =

	I've been idly working on a parallel combination game called "wavebuilder". That part mostly isn't important, but in the process I created a numerical scoring system for elements, and I'm wondering if anyone who is already familiar with Firefox extensions (or even Chrome, but I definitely want a Firefox one) could add this scoring system to an extension like Infinite Craft Helper. (It might also be neat to see on a database like InfiniBrowser.)		<div class="bop top">

			<ins>[The following entry was "posted" (and automatically removed by moderator bots) on a subreddit for [https://en.wikipedia.org/wiki/Infinite_Craft Infinite Craft].]</ins>

			I've been idly working on a parallel combination game called "wavebuilder". That part mostly isn't important, but in the process I created a <strong>numerical scoring system for elements</strong>, and I'm wondering if anyone who is already familiar with Firefox extensions (or even Chrome, but I definitely want a Firefox one) could add this scoring system to an extension like Infinite Craft Helper. (It might also be neat to see on a database like InfiniBrowser.)

	Basically it works like this:		Basically it works like this:

	* An element's sum starts at 1 and is calculated as the sum of the two elements that created it. If the same element is combined twice, one of them is considered to have a sum of 1.		* An element's <strong>sum</strong> starts at 1 and is calculated as the sum of the two elements that created it. If the same element is combined twice, one of them is considered to have a sum of 1.
	* An element's moves count is simply the number of combinations required to create it, measured as the longest path from a parent element plus 1.		* An element's <strong>moves</strong> count is simply the number of combinations required to create it, measured as the longest path from a parent element plus 1.
	* An element's score is listed as sum:moves, like this: `Gargoyle 14:6`		* An element's score is listed as <strong>sum:moves</strong>, like this: <code>Gargoyle 14:6</code>
	* I also sometimes found it interesting to list elements with their largest possible sum: `Airship = 14:8 / 85`		** I also sometimes found it interesting to list elements with their largest possible <strong>sum</strong>: <code>Airship = 14:8 / 85</code>
	* I usually just call this system the "wavebuilder score", although it could maybe be called the "wave score" or something.		* I usually just call this system the "wavebuilder score", although it could maybe be called the "wave score" or something.
	* In my opinion the "canonical" score for an element is the lowest one — within reasonable limits of a palette of ~2000 elements or less.		* In my opinion the "canonical" score for an element is the lowest one — within reasonable limits of a palette of ~2000 elements or less.
	* (This would mean that to be properly accurate, the extension would have to recalculate all the elements that depend on a given element, but that's a problem for whoever wants to code in JavaScript. I haven't actually coded this into my program yet.)		** (This would mean that to be properly accurate, the extension would have to recalculate all the elements that depend on a given element, but that's a problem for whoever wants to code in JavaScript. I haven't actually coded this into my program yet.)

	~~___~~		<hr class="dash" />

	If you can understand Lisp, these are the exact algorithms currently used for sum and moves:		If you can understand Lisp, these are the exact algorithms currently used for sum and moves:

	~~```~~		<pre>(defun hyle-sum-+ (a b) ; add up element sums to produce result sum
	(defun hyle-sum-+ (a b) ; add up element sums to produce result sum
	(max		(max
	(if (equal (hyle-id a) (hyle-id b))		(if (equal (hyle-id a) (hyle-id b))
Line 26:		Line 31:

	(defun hyle-moves-+ (a b) ; add up element moves		(defun hyle-moves-+ (a b) ; add up element moves
	(+ 1 (max (hyle-moves a) (hyle-moves b))))		(+ 1 (max (hyle-moves a) (hyle-moves b))))</pre>
	~~```~~

	~~___~~		<hr class="dash" />

	I think I'm most interested in seeing how ridiculously huge the sums on people's First Discoveries get, although this has many other possible uses, like finding the smallest sum or moves score for an element (which is basically what I designed it for).		I think I'm most interested in seeing how ridiculously huge the sums on people's First Discoveries get, although this has many other possible uses, like finding the <em>smallest</em> sum or moves score for an element (which is basically what I designed it for).

	If you have any thoughts on how to improve this scoring system such as other metrics to add — maybe there's some great insight from advanced mathematics on networks of combining elements that I missed? maybe there are crazy patterns to First Discoveries I didn't think about? — feel free to share them. I would gladly add a good metric to wavebuilder for what it counts for (the project is very unfinished), but in general I feel like Infinite Craft guides need better analysis tools so we can really start finding and discussing interesting patterns.		If you have any thoughts on how to improve this scoring system such as other metrics to add — maybe there's some great insight from advanced mathematics on networks of combining elements that I missed? maybe there are crazy patterns to First Discoveries I didn't think about? — feel free to share them. I would gladly add a good metric to wavebuilder for what it counts for (the project is very unfinished), but in general I feel like Infinite Craft guides need better analysis tools so we can really start finding and discussing interesting patterns.

			</div>

	<~~!--~~		<div class="bop-foot">
	---

	:~~: cr~~. 2024-10-22T03:16:28Z		<dl class="bop-meta"><!--
	; REJECTED for karma. post karma 1, comment karma 11 ~~(!)~~		{{BopFwd\|Philosophical Research:MDem/5.2/1111 FreeWill\|link}}
	~~:: t.~~ 2410-22_wave-score		; {{BopComment}} -->
	~~; using Markdown formatting rules~~		{{BopCreated\|2024-10-22T03:16:28Z}}
	-->~~</pre>~~		{{BopComment\| REJECTED from Reddit for karma. post karma 1, comment karma 11}}
			{{BopHandle\|2410-22_wave-score}}
			</dl></div><!--
			-->[[Category:Wavebuilder ontology]] __NOTOC__

Reversedragon: archive scrap as-is; cr. 2024-10-22T03:16:28Z

2025-04-29T03:19:49Z

archive scrap as-is; cr. 2024-10-22T03:16:28Z

New page

<pre># Can anyone help add my "wave score"?

I've been idly working on a parallel combination game called "wavebuilder". That part mostly isn't important, but in the process I created a **numerical scoring system for elements**, and I'm wondering if anyone who is already familiar with Firefox extensions (or even Chrome, but I definitely want a Firefox one) could add this scoring system to an extension like Infinite Craft Helper. (It might also be neat to see on a database like InfiniBrowser.)

Basically it works like this:

* An element's **sum** starts at 1 and is calculated as the sum of the two elements that created it. If the same element is combined twice, one of them is considered to have a sum of 1.
* An element's **moves** count is simply the number of combinations required to create it, measured as the longest path from a parent element plus 1.
* An element's score is listed as **sum:moves**, like this: `Gargoyle 14:6`
* I also sometimes found it interesting to list elements with their largest possible *sum*: `Airship = 14:8 / 85`
* I usually just call this system the "wavebuilder score", although it could maybe be called the "wave score" or something.
* In my opinion the "canonical" score for an element is the lowest one — within reasonable limits of a palette of ~2000 elements or less.
* (This would mean that to be properly accurate, the extension would have to recalculate all the elements that depend on a given element, but that's a problem for whoever wants to code in JavaScript. I haven't actually coded this into my program yet.)

___

If you can understand Lisp, these are the exact algorithms currently used for sum and moves:

```
(defun hyle-sum-+ (a b) ; add up element sums to produce result sum
(max
(if (equal (hyle-id a) (hyle-id b))
(+ (hyle-sum a) 1)
(+ (hyle-sum a) (hyle-sum b)))
1))

(defun hyle-moves-+ (a b) ; add up element moves
(+ 1 (max (hyle-moves a) (hyle-moves b))))
```

___

I think I'm most interested in seeing how ridiculously huge the sums on people's First Discoveries get, although this has many other possible uses, like finding the *smallest* sum or moves score for an element (which is basically what I designed it for).

If you have any thoughts on how to improve this scoring system such as other metrics to add — maybe there's some great insight from advanced mathematics on networks of combining elements that I missed? maybe there are crazy patterns to First Discoveries I didn't think about? — feel free to share them. I would gladly add a good metric to wavebuilder for what it counts for (the project is very unfinished), but in general I feel like Infinite Craft guides need better analysis tools so we can really start finding and discussing interesting patterns.

</pre>

← Older revision		Revision as of 06:41, 11 July 2025
Line 64:		Line 64:
	{{BopHandle\|2410-22_wave-score}}		{{BopHandle\|2410-22_wave-score}}
	</dl></div><!--		</dl></div><!--
	-->[[Category:Wavebuilder ~~ontology~~]] __NOTOC__		-->[[Category:Wavebuilder]] __NOTOC__