Sandbox Development

[shanejfilomena]

i totally was not alive: ignore my earlier self

[alterecco]

I wanted to know how to add a check to see if a player has a mining license when selling ore.

You would need to overwrite the sell screen.

[RPC]

Ok, new,related, question:
What does this mean? O.O

Code: Select all

(comShowSellScreen
									"*"						; items bought from player
									)

and

Code: Select all

(setq comShowSellScreen (lambda (itemsToBuy returnScreen screenOptions)
				(block Nil
					; Generate the function that computes price and availability
					(switch
						(isfunction itemsToBuy)
							(setq gMargin itemsToBuy)
							
						; If itemsToBuy is set, then combine with station's Trade descriptors
						(and itemsToBuy (not (eq itemsToBuy "*")))
							(setq gMargin 
								(lambda (theItem)
									(switch
										(not (itmMatches theItem itemsToBuy))
											Nil
											
										(intComputeBuyPrice theItem)
										)
									)
								)
							
						; Otherwise, rely on station's Trade descriptors
						(setq gMargin intComputeBuyPrice)
						)

					; Handle some options (Nil is OK)
					(setq gTitle (item screenOptions 0))
					(setq gMaxPrice (item screenOptions 1))
					
					; Result
					(setq gResult 0)

					; Show the screen
					(scrShowScreen gScreen "&dsExchangeSell;")
					)
				))

Alterecco: you mean the dsExchangeSell?

[alterecco]

So... the sell/buy screens are a little complicated. I will try to explain.

In your first code block, you see a call to comShowSellScreen, passing a single argument `*`.

The second code block is the function itself. You might notice that the function has three arguments, but it is the first that is most interesting (the second one is deprecated). Most of the comShowSellScreen function deals with handling the itemsToBuy argument. The two screens dsExchangeSell and dsExchangeBuy are generic, and rely on some global variables to function. These variables are what this function sets. The most important of these variables is gMargin.

gMargin is used to determine if the screen will display the item for trade and at what price. It can be a function or a criteria.

gMargin as function: gMargin can be a function that takes an item as an argument, and returns Nil if the item can not be bought at the station, or the price of the item if it can be bought. An example of this (one that would support your ore-license thingy) would be:

Code: Select all

(comShowSellScreen (lambda (theItem)
    (switch

        (and (itmMatches theItem "* +Ore") (not ([test for mining license])))
            Nil

        (intComputeBuyPrice theItem)
    )
))

That call to comShowSellScreen passes a function along as the itemsToBuy argument. The function will be called once for every possible item the station can buy. If the item is ore, and the player does not have a license, then the function returns Nil, and the item will not be shown in the list. If the item passes that test, then it's price will be computed by a standard function that is also in Transcendence.xml (intComputeBuyPrice). It would of course be possible to add multiple checks to that function.

gMargin as criteria: The simplest way to use gMargin is to just pass in a item criteria (as in your first code block). If the criteria passed in is `*`, then the stations Trade descriptors (the stuff in the <Trade> tag) take charge. If the station has no Trade descriptors, then everything is for sale valued at 100%. If the criteria is not `*`, but something more complex, then comShowSellScreen sets gMargin to a function and leaves the handing to that function (as described above). That function checks if the item matches the criteria, and returns nil if not. Else it returns the buy price as computed by intComputeBuyPrice.

screenOptions is a list that can be passed in as well. The first element of that list will be used as the title of the Buy screen (gTitle), the second argument will be used as gMaxPrice, which determines the maximum price the station will pay for any item. Both values are optional, and the entire argument can be left out.

Finally, the comShowSellScreen function ends with displaying the actual screen.

comShowSellScreen has a twin, comShowBuyScreen. It works in a similar fashion.


I hope that was clear enough. Just ask and I will try to clear up any unclear points.