BG1, PRELOAD BG2, PRELOAD

Logic Blog

Analogue Logic 1 - Fundamentals

Rating: 9 votes, 5.00 average.
Ana.logue Signal Processing
Binary's for n00bs foo'!!!


Part 1 - Concepts and Fundamentals




I’ve decided to kick off Logic Blog 2.0 with our first steps into the world of analogue (or ana.logue in-game because yes, sensible words are still filtered in LBP2, *sigh*) logic. Analogue signal processing is the non-obvious side of LBP2 logic and whilst most creators with some experience with LBP1 logic are going to be comfortable with the digital side of things (basic AND, OR operations, switching things on and off, etc), the analogue system is liable to pass many people by as it’s largely hidden from the user. It’s also very, very powerful.

In LBP1 we didn’t really have that much use for analogue signal manipulation and the tools that were available weren’t very suited to the jobs of producing analogue signals or doing anything much interesting with them, we mostly stuck to boolean operations, except for basic things like gradually increasing the speed of a bolt and very occasionally something a little more complex.

However, now we have movers and rotators and hologram etc., that respond very well to analogue controls for quite subtle effects and also we have processing devices that allow us to do some very interesting operations on these signals and opens up a wide range of tuning and refinement that would be impossible, or at least prohibitively complex, with digital systems. Analogue processing is also where you will find some very subtle effects beyond the boring TRUE / FALSE of digital processing.*



------------------------------------------------------------------------------------------------------


1. Introductions to Analogue Signals
We'll begin with an overview of analogue signals in LBP and some terminology definitions:


1.1. Representations of Analogue Signals in LBP2.
For the sake of the logic blog (and probably in general around the forums), you will likely see me referring to the values of analogue signals in LBP2 in the same terms as they are on he battery device: an signed integer between -100% and +100%, though I’ll often miss of the percent signs, because I’m lazy. In actual fact, I’ve found that analogue signals do (or at least can) have a much finer granularity than that. I can successfully differentiate between 99.93% and 100% - and I believe that the actual game granularity is finer still. I'm not sure how much use this would be, though awareness of this fact may be useful for bug fixing.

Spoiler Spoiler - geekNotes: On Analogue / Digital Duality



1.2. Notes on Negativity
In addition, when dealing with negative values (which we will touch on here, but not in great depth) some switches will not cope with negative values in the way you might expect. Typically this involves taking the magnitude of the value only. That is to say that -55% is considered to be the same thing as +55%, when only considering magnitude. Which, obviously, it isn’t and this fact can cause some problems if you aren’t expecting it – especially when you need to keep track of which devices only deal with magnitude and which use the signed value. And to make matters worse, some devices swap between which values they use, depending on how you’ve tweaked them


1.3. Notes on Inversion
Pretty much every device that has an output in this game can have that output inverted (or NOTted if you like). For the most part, an inverted signal will be 100 – s, where s is the normal, uninverted value. This of course makes no sense with negative values of s, as the result would be out of range. It appears that the LBP way to get around it is to treat all analogue values as magnitude, before inversion, so:

Code:
   s   | inverted s  
--------------------
    0  |    100 
  100  |      0 
   35  |     65 
  -35  |     65
  -70  |     30
To avoid confusion, I’ll be using the terms “Negative” and “negation” to refer to changing a value from positive to negative and vice versa, and the term “inverse” and “inversion” to refer to this characteristic of the NOT function in LBP.

Of course nothing is that simple, there is one exception to this rule. The Combiner device, when set to invert output actually gives the negated value (magnitude equal, but sign changed). Therefore an inverted output on a combiner is not the same as running the output through a NOT gate. It's the same as swapping around the inputs, so one really wonders if this is a bug or not (it has been reported).



------------------------------------------------------------------------------------------------------


2. Analogue Signal Sources

This section covers analogue signal sources, which for the most part are very simple, other than the tag and player sensors, which are surprisingly complex. These signal sources will be the initial inputs to your analogue processing system as they don’t have any explicit inputs themselves. Though many of them are sensors that that arguably should be considered to have an input – what I mean is that there is no wire coming in.


2.1. Grab, Impact Water and Sticker Sensors
There is no real sense in having an analogue outputs for these (except maybe water – indicating depth – but then that’s tricky to quantify into a percentage). So they output 100% if the particular conditions of the switch are met, and 0% if they are not.


2.2. Batteries
Batteries will always output the value you set them to, which is an integer between -100% to +100%. This may seem a little pointless, but in analogue signal processing it can often be useful to define offsets and thresholds that are fixed in the system – batteries provide this and they are give convenient system tuning.


2.3. Score and Projectile Sensors and the paintswitch.
The analogue output for these devices can be described as the percentage complete they are. So for the score sensor, the analogue output is:

(target score – current score) / target score


2.4. Player Sensors
Much like when you used to use the sensor switches with speed output in LBP1, the value of the signal from a player sensor is greater the closer the player is to the sensor. It’s quite hard to quantify, as placing sackboy accurately is basically impossible, but it seems that the relationship is roughly linear, except for the fact that there is a smallish area close to the switch that will always give 100%, meaning that you don’t have to be slap bang on top of the sensor for it to read 100%. Of course if the angle is smaller 360 then you will read zero if outside that angle. However, that’s not the whole story, as the player sensor now has a couple of new tweaks, both of which give interesting results if you analyse the analogue outputs.

Firstly, the minimum range tweak, which gives you a dead zone in the centre of the detection area. It should be clear that if you are in the dead zone then the signal output will be 0. However, on the edge of the dead zone, the analogue signal outputs 100%, so the scale is modified to accommodate for this. In addition, you also lose the 100% zone on the sensor if your minimum radius is greater than zero. As this is a bit confusing, I made a graph to demonstrate both the effects of the 100% zone and the size of the deadzone on the signal value:



fig 2.4.1. The Effect of Minimum Radius on Player Sensor Outputs


Secondly, there is the new “Number of Players Required” tweak. Obviously, if you don’t have the correct number of players in the sensor area, then output is zero, however, if you do have the right number of players (or more), it bases the value on the distance of the nth player. So if you select “require 2” on the sensor, it will tell you the distance to the second closest sackboy. Which is nice.


2.5. Tag Sensors
These work in almost the same way as the player sensors do, with 100% zones and dead zones, with detection of the nth closest matching tag (remembering that tag labels exist, so if labels do not match, neither do the tags). The tag sensor also has one other useful tweak, Output Value. The default, “closeness” will output a value similar to the graph in fig 2.4.1., whereas “signal strength” will output the value of the signal that is input to the tag - including the sign.

This means that it is possible to wirelessly transmit analogue values in the full range (+/- 100%) by simply using a tag and sensor. which is quite a significant feature when you remember that emitted objects cannot be wired to anything that is not emitted with them.

Apologies for the misinformation in the original text, it seems I didn't do my research well enough on this particular aspect. Thanks to Rogar for pointing out my failures. What can I say, I am only human, despite what you may have heard rumoured....




------------------------------------------------------------------------------------------------------


3. Analogue Signal Processing
Following on from analogue signal sources are the devices that are used to do the processing. Some of these aren't actually analogue processors, as they can't utilise analogue inputs and I suppose if used in an analogue system they are sources, but I've split it this way because it seemed like a good idea at the time and renumbering sections is a pain. Deal with it.

3.1.Toggles, Randomisers and Select Switches
These have no concept of analogue input and will only respond to the digital aspect of the input signal(s). The outputs do have an analogue component, however this will take a value at 0% or 100%, nothing in between.


3.2. Counters
The counter, like the devices above, doesn’t have an concept of analogue inputs, however, as with the projectile sensors etc. its analogue output is the ratio of maximum value to current value. This makes the counter (amongst other things) a very useful tool for debugging analogue signal processors – much like the battery allows easy tuning through tweak settings, the counter allows quick modification of test data from a Controlinator test harness (I am now almost exclusively using Controlinators for component - level testing in LBP2). It's also quite useful if you wish to adjust offsets and thresholds to modify your system at runtime - for example, to modify difficulty automatically each time the player fails, or to increase difficulty as you go up a level.


3.3. ANDs ORs XORs and NOTs
These are our basic digital processing components, but they also have analogue processing abilities that are likely to be rather unexpected. The NOT simply passes the signal through, inverting it if required (remembering the inability to invert negatives above), but the others have some interesting properties when you look at the analogue component of their outputs.

The AND gate is effectively a min() function - it’s output is equal to the smallest value input. So for signals of 10, 63 and 42, the output would be 10. To compliment this, the OR gate is a max() function, so the output value from the same three signals would be 63. Note that these definitions make sense in terms of using binary (0 / 1) inputs for the same gates, which is probably why this happened.

Spoiler Spoiler - geekNotes: on Handling of Negative Values


The XOR is a strange beast and seems to do something along the lines of a max() function on the analogue inputs, but then combines this with it’s binary output. Which means that to understand the complete behaviour you have to keep track of both analogue and digital inputs, which as described in the geekNotes above, and as we will find out at a later date when we dig deeper into the duality of signals, are generally divergent if any processing has been carried out on them. I’m sure we can utilise this to our advantage at some point but for now I’m struggling to find genuine uses and I don’t like it, so we shall move swiftly onto something I do like:


3.4. Combiners and Splitters
The Combiner works out as a simple subtraction device and output is equal to the difference between the two inputs. It’s definitely worth noting that the inputs on these are taken to be magnitude only so you can’t use negative numbers within a subtraction and achieve the correct arithmetic result. The output can be negative and will be arithmetically correct, assuming that both inputs are positive. This might be a bit confusing, so here are some examples:

Code:
     Inputs   | Correct | Combiner
   +   |   _  | Answer  | Output
------------------------------------
  100  |   35 |    65   |    65
   50  |   65 |   -15   |   -15
   50  |  -10 |    60   |    40
  -50  |   30 |   -80   |    20
When including negative values in the subtraction, as either operand, the result is incorrect. 50 – (-10) should give 60, however the actual calculation performed is 50 – 10, to give 40.

The splitter is pretty simple – if the input is negative it outputs the magnitude of the signal through the negative output, if the signal is positive then it outputs the magnitude through the positive output. In both cases the signal output is a positive value. Splitting signals is very useful given the caveats associated with manipulating negative values and can also be used for simple things like checking "is this signal positive or negative?".


3.5. Timer
If any device is the king of analogue processing, it’s the timer. Simple enough to just trigger an event every few seconds, yet powerful enough to be used at the core of a data storage device or even integration (yes, LBP2 has calculus) of analogue signals against time and a whole bunch of stuff in between. It can also be quite neatly geared up as a signal source, to produce periodic waveforms (natively triangle and sawtooth, but with a couple of bits of extra logic, square waves, trapezoids and possibly sine and cosine – though I’ve not quite got as far as achieving true sine and cosine yet, but I think I know how).

The output of the timer is, much like some of the other tools, the ratio of max value to current value. However, in addition to binary inputs (of which there are a few nice things such as “start counting up / down” and “forwards / backwards”) the timer also has a speed setting, which is fantastic. Basically, if you put a 50% analogue signal into a timer with speed inputs, then the timer will fill up half as fast as normal, change it to 25% and the rate of change halves again, drop it to 0% and it stops. But this also works for negative values as well, and a negative input will reduce the value of the timer, at a rate proportional to the input value.


3.6. Sequencers
I’m not actually going to go into the usage of sequencers here, I'll save that for a later date, as they has a very specific and unique role in the world of analogue signal processing, when we get around to turning it from a technical curiosity into a powerful decision-making tool.



------------------------------------------------------------------------------------------------------


4. A "Simple" Example

So far, all we've done is look at the basic tools and their functions and it doesn't seem like much could be done with them - really we've only got a few sensors to detect the state of the world, and a few basic operations we can carry out and that's all there is to our analogue toolset... But when you think about it, this is actually more functionality than the individual components we used to use for logic in the old game and look what we achieved with that.

Next instalment I'll actually put together a couple of neat microchips that will allow us to expand this toolset with more functions, but as this is a bit long and technical so far, I don't want to do any in-depth examples, so I'll finish off with a simple waveform manipulation circuit I dreamt up, which is shown below (click for higher res):


fig 4.0.1. Wavform Filtering Circuit


4.1. Signal sources
In this case, we're using the timer (labelled 1 in fig 4.0.1) and some batteries (2, 4, 6) as the signal sources. The timer is configured with the following settings:

Target Time: 2s (note, this is arbitrary)
Input Action: Forwards / Backwards
Invert Output: Yes

This set-up will produce a triangle wave, as looping the inverted output back to the forwards/backwards input causes the timer to fill up linearly, then empty linearly, then repeat. I don't want to go too much into exactly why this is, but that is what it does, as per the graph below:



fig 4.1.1. Triangle Wave (System Input)


Note that the period of the signal is twice the Target Time setting (as the timer must fill up for 2 seconds and then empty for 2 seconds).


4.2. Signal Limiting
As discussed above, some of the simplest operations we can do on analogue signals is min() and max(), using ANDs and ORs. We can use this to achieve some boundary limiting on the signal, preventing the signal going above 80% or below 20%.

So taking the output of the timer and using an OR gate (labelled 3) with a battery (2) set to output constant 20% will give us a max function, which leads to a lower boundary. To clarify: if the timer output is greater than 20, the output of the OR gate is equal to the timer, but if the timer drops below 20, then the OR gate will output 20.

After this we do the same thing with an AND gate (5) to do a min() with an 80% battery (4), to give an upper limit, and the resulting output of the AND gate is shown below (with the original wave in dotted lines). You can see that the timer's output is ignored when it exceeds the minimum and maximum bounds that we have set for it:



fig 4.2.1. Trapezoid Waveform (triangle with boundary limiting)


Conceptually it is a little confusing that we use a min() function to create a maximum value, but that is the way of the world, I'm afraid - it's certainly not my fault!


4.3. Removing the DC Offset
Sometimes, especially with waveforms, it's useful to have them centred around 0, and to do this we need to shift the whole wave down by 50 (the point at which it is currently centred - its average value). This is a simple subtraction operation using a combiner (7) and a battery set to 50% (6) and results are as shown:



fig 4.3.1. Trapezoid Waveform with DC component removed


4.6. Extending the concept
The advantage of centring the signal around zero is that over time, the value averages to zero - if you were to put that signal into a mover, it would move forwards a bit, then backwards a bit, then repeat, but it wouldn't drift from its original location. The same is true if you put the signal into a timer with speed input.

The timer with speed input actually works out as being an integration of the input signal against time. I'm not going to explain why - those of you with enough calculus to understand why can probably work it out on your own. One reason integration is good is that it can quite often give us curvy waveforms, and curvy is nice, for all manner of reasons

Integrating our trapezoidal waveform (fig 4.3.1) actually turns out to be a rough approximation of a sine wave, as shown below:



fig 4.3.1. Trapezoid Waveform Integrated to Approximate Sine


Note: This is only an approximation of a sine wave, I think it's possible to produce completely accurate sine and cosine signals, in the range -100% to 100%, but I haven't tried out that mechanism yet as it's a weird complex loopback system, that makes my head hurt to think about it.

To achieve this result I have actually fed the signal into timer starting at 50% and then deducted 50% from the output value, to recentre the signal around zero. This is shown below as an extension of the original image (components 8 and 9 provide this extra processing - the 50% battery at 6 is reused as shown):


fig 4.4.1. Extended Waveform Filtering Circuit


Spoiler Spoiler - geekNotes: More on Analogue / Digital Duality




------------------------------------------------------------------------------------------------------


5. Summary

So, this was an overview of the basics of analogue processing, and whilst the end bit of that example may have seemed a little unbasic (that's a word, right?), all I've done is some of the standard analogue processing tools. The logic network in question has 9 components in it, and most of those were humble batteries. If we can transform a triangle wave into a sine wave using only 9 components, this should highlight how powerful this analogue signal processing is.

Obviously, generating a sine wave is not the most practical of examples and I'm sure for many of you, periodic waveform manipulation is not the first thing you think of when considering useful gameplay logic. But it's worth noting that there are entire fields of engineering that rely upon waveform manipulation to keep our lives ticking along in the cushty way that they do, so don't be turning your nose up at the lovely, lovely sine waves

Anyways, the logic blog has always been about technique and methodology, expanding or improving the toolsets available in an application agnostic manner. The little bits of signal limiting and subtraction presented here are useful techniques to know and will lead onto many applications once you become comfortable with solving problems in an analogue manner.

I'm not entirely sure what I'm doing next time, but it's likely to be some extensions of this analogue signal processing, including addition and signal sampling. Hopefully, for all our sakes, it'll work out a little shorter than this one.


*Note to Digital Systems: I didn't mean what I said there, I still love you


Disclaimer:
LBP2, at time of writing, is still in beta and it's possible that some of the techniques described here will not work 100% in the final release, and so any of this information is subject to change.

.

Updated 10-06-2010 at 07:51 PM by rtm223

Categories
Logic Blog

Comments

Page 2 of 3 FirstFirst 1 2 3 LastLast
  1. mutant_red_peas's Avatar
    I read the first few bits then I just lost track and... thought about the gorgeous Sunday Roast I had on Sunday, and how suspiciously similar it tasted to the last one I had. Poor turkey. And I checked out the various graphs and pictures that came along 'cos I like them

    I've came to the conclusion after another Roast Dinner that NO-ONE should speak of this blog again until the rest of us (see rtm223's spotlight) are up at the level he's at. Then it's all hunky-dory.

    E.G. 1 E.G. 2

    He's here We're all here!






    The rest of us are down here.


    E.G 2 is when this blog can be spoken of again.

    Joke. This is great stuff. Well done.
  2. mutant_red_peas's Avatar
    That graph went awfully wrong... sorry...
  3. Ungreth's Avatar
    OK, now my head is totally fried. In lay terms, can you give some examples of the potential practical applications of analogue logic? I'm guessing pulsing/flickering lights would be one use, but I'm betting that you have more elaborate plans for all this analogue stuff than producing fancy lighting effects.

    Convince me that it's worth my time to invest my limited brainpower in learning all this complex stuff.
  4. Balorn's Avatar
    GREAT info! However I do have a question. You say:
    "The XOR is a strange beast and seems to do something along the lines of a max() function on the analogue inputs, but then combines this with it’s binary output."
    How, exactly? I'd like to know because I'm building some LBP2 logic simulator circuits in Logisim that actually handle the analog/digital duality, and I don't have enough information to build a working XOR with just that. (Can't test it myself as I'm not in beta.)

    Oh, and one other thing: what digital output does the Combiner produce if the digital part of both inputs is On?

    Edit: I've made a thread with more detailed questions and some details about what I'm working on making.
    Updated 10-26-2010 at 07:43 AM by Balorn
  5. rtm223's Avatar
    The combiner goes to FALSE if both components are TRUE. It's still essentially a subtraction circuit, but with ternary digital output:

    Code:
     - | + | out
    ---|---|------ 
     0 | 0 |  0
     0 | 1 |  1
     1 | 0 | -1
     1 | 1 |  0
    It's very similar to the XOR, just that you get that negative 1 output from it. The idea really of this device is to replace the three-way switch with winches on control method, but it has a more strongly defined output for when both inputs are active.


    I did see your thread, and I'll get to it in a bit and answer the other questions there if I know the answers
  6. schm0's Avatar
    So, I think I'm understanding this correctly. But can you think of a couple examples where custom-designed ana.logue output would have a practical purpose in LBP2?

    The few I can think of is dynamic speed or output for any number of objects (lights, enemies, platforms, what-have-you), but... what else?

    What about setting up a waveform such as the one in your example and triggering "cyclical" events based on output (i.e. object 1 at -20, object 2 at 0, object 3 at +40)... would that work?

    And what about throwing in some white noise with a randomizer? Can you create the waveform equivalent of static?
  7. Rogar's Avatar
    What analogue logic gives you in a practical sense is ways to compare sensor inputs. For example, you can compare player and/or tag sensor signals to see which signal is the closest, or the strongest.

    For cyclical events you'll probably want to use a sequencer.
  8. rtm223's Avatar
    Yep, dynamic speed is the primary one, but you can also threashold and compare signals to make decisions, much as you would in a classic programming conditional (if statement).

    I agree with Rogar that if you have a cyclic signal and want to trigger thresholds then the basic sequencer will do the job well enough.

    As for white noise, kinda. White is a bit over the top as the highest frequency you can represent in LBP2 analogue is 15Hz (the Nyquist Frquency). You can generate noise on the signal in various ways. I managed to reproduce my firelighting effects, that you may have seen in my spotlight video, using microchips, with randomised patterns for two signals (a high amplitude, low frequency signal and a low amplitude high frequency noise signal) which were superimposed by adding the two together, which is effectively the effect you are after.
  9. Balorn's Avatar
    Using the probe I made I worked out how XOR behaves (at least for 2 inputs), so I'm putting it here for reference if anyone else wants to know. The only thing I'm not sure of is if -0 ever comes into play, because my probe can't detect that (not that it matters for 99% of things).

    If both digital inputs are 0:
    • The digital output is 0
    • The analog output is the same as the analog input which has the largest magnitude (just like OR)


    If one digital input is 0 and the other is 1:
    • The digital output is 1
    • The analog output is the same as the analog input which has the largest magnitude


    If one digital input is 0 and the other is -1:
    • The digital output is -1
    • The analog output is the same as the analog input which has the largest magnitude


    Note that in the previous two cases it is quite easy to have the digital and analog outputs have different signs.

    If neither digital input is 0 (+1 or -1 doesn't matter):
    • The digital output is 0
    • The analog output is 0


    It seems straightforward, but who knows what use it may have. I'm sure someone will come up with something.
  10. rtm223's Avatar
    See? Ewwww. It's not very nice.

    I'd hypothesise that the extended functionality of the device for more inputs would simply be:

    if 2 or more digital inputs are non-zero, both outputs go to zero.

    Based on the fact that the XOR with greater than 2 inputs becomes a 1-hot function, rather than modulo-2 addition, which is what I'd personally consider to be a description for n-input XOR.
  11. Balorn's Avatar
    I've found a use for analog XOR. It's somewhat hard to describe, and mostly useful for testing things, but it's not entirely useless.

    I've planned a circuit (I'm at work so I can't actually build it yet) to make signals that can be manually created with fixed arbitrary analog and digital signals independent of each other. So for example if you want to see what happens when you connect a wire with -1 digital and 37% analog to something, or +1 digital and -90% analog, or whatever, you can create that signal easily once this is built.

    First, make batteries or other circutis to make two signals, one with the digital signal you want (call it desiredD) and one with the analog signal you want (call it desiredA).

    Next, use an analog adder circuit to add two 50% signals. The output of this can be either left alone, put through a NOT, or connected to a splitter with outputs OR'd to itself and you can end up with pure signals of Analog100%+Digital0 (I'll call this a100), Analog0%+Digital1 (dPos) and Analog0%+DigitalNegative1(dNeg). These will be used in the next stage of the circuit.

    The next step is to isolate the desired analog and digital parts from the unwanted digital and analog parts of those wires respectively. For analog simply AND the desiredA signal with a100. For the digital part use simple digital logic (and a splitter to detect negative) on desiredD to determine whether the digital part should be 0, dPos or dNeg. This will get you signals with the desired analog part and digital 0 (call it onlyA) and one with the desired digital part and analog 0 (call it onlyD).

    Now that you have isolated the desired digital and analog values, simply XOR onlyA and onlyD together (yeah, it took that long to actually get to it) to get a wire with both the digital and analog being whatever you want.

    It sounds somewhat convoluted, but this can be used to create a Poke tool (the inverse of the logic probes we've made) that can ouptut any combination of digital and analog signals (with the possible exception of -0), which can be extremely useful for testing things.

    Edit: Got home, tested it, and confirmed the concept works perfectly in-game. Here is what I built, shown in Logisim for clarity. It takes two inputs, and the output is the digital part of one combined with the analog part of the other, regardless of value or sign (with the exception of digital -0 which is just weird).

    Each is simply one of these.

    Edit 2: Whups, had a minor wiring problem when I cleaned up how the circuit looked. Fixed now. If anyone tried recreating it and found it didn't work, reload the image and try again. (If more than one output of the Selector is being used, you're looking at the old version.)

    Edit 3: Grr, forgot to test one case... and I've discovered that when it comes to signals where the analog and digital parts have different signs, the AND gate can be just as much of a problem as the XOR appeared.

    At first I thought my probe was broken, but I confirmed it with a rotator. I'm currently doing extensive testing on how the gates behave in odd circumstances.

    See this post for some early results of my testing.
    Updated 10-31-2010 at 04:50 PM by Balorn
  12. TOXIC_KILLA_'s Avatar
    wow , looks complex
  13. OmeletteduFromage's Avatar
    Well, if this is what is used to make things work in lBP 2 I'm screwed. Seriously rtm223, why and how do you think of this stuff? I just can't comprehend why someone would want such extensive knowledge of video game components.
  14. rtm223's Avatar
    For funzies?


    No, you won't need this knowledge to make things work in LBP2, just in the same way as you never needed hardcore LBP1 logic to make things work in that game and many of the "top" creators don't have mad logic skills. But, fully understanding the tools at your disposal allows you to achieve more.

    Not to mention that the whole LBP engine is simply fascinating, from a software and engineering standpoint. It's a completely unique toolset, with very few design paradigms that haven't been lifted from other places and shoehorned to fit. Developing the paradigms to fit this toolset is one of the most interesting technical challenges I've ever come across.
  15. Shanghaidilly's Avatar
    Good stuff!!

    Question on the splitter. If it provides the magnitude on one wire, what's the value on the other? Zero?

    If so, using two of these I've designed a min() function circuit that results in the true minimum analog value and not just based on magnitude. Working on a max() function circuit now.
  16. Phazerz123's Avatar
    Mind=Blown
  17. SSTAGG1's Avatar
    What occurs when multiple tags of different strengths are within the range of a tag sensor set to detect signal strength?

    Is the output the closest tag, the strongest, the weakest, or a combination of the strengths? Am away from PS3 right now, but had an idea for a new damage system, and if it's a combination, that'd be awesome.
  18. rtm223's Avatar
    strongest. Which is bloody annoying if you ask me, but what you gonna do, eh?

    If you require 2 then it returns the value of the 2nd strongest, etc.
  19. SSTAGG1's Avatar
    It was just an idea I had for a non-impact based damage system. Would get rid of several tags and additions in the system I'm using, but isn't as flexible to complex shapes being damaged (actually, it is, depends on how quickly destroyers work though, since it relies on the tag to transmit signal for a single frame and then get destroyed the next) Here is the result of my ideas.
    Updated 02-24-2011 at 05:29 AM by SSTAGG1
  20. ShiftyDog's Avatar
    i don't get it because i never worked with analog before. but i know that positive act normal and negative is inverted... just don't know the amount of percentage, but i guess that it something to do with the amount of power of the output?
Page 2 of 3 FirstFirst 1 2 3 LastLast