Dwarf Fortress Wiki - User contributions [en]

File:And,Or,AndOr, Prototype adder STATE 2.PNG

2011-04-02T20:38:24Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 2.PNG": realized the doors were all open, this one looks better.

a=1,b=1,c=0 Sum=10

File:And,Or,AndOr, Prototype adder STATE 3.PNG

2010-11-25T22:05:23Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 3.PNG": Fixed bit sticking problem, Updated for DF2010

a=1,b=1,c=1 Sum=11

File:And,Or,AndOr, Prototype adder STATE 2.PNG

2010-11-25T22:04:51Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 2.PNG": Fixed bit sticking problem, Updated for DF2010

a=1,b=1,c=0 Sum=10

File:And,Or,AndOr, Prototype adder STATE 1.PNG

2010-11-25T22:04:28Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 1.PNG": Fixed bit sticking problem, Updated for DF2010

a=1,b=0,c=0 Sum=0

File:And,Or,AndOr, Prototype adder STATE 0.PNG

2010-11-25T22:02:19Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 0.PNG": Reverted to version as of 22:01, 25 November 2010

a=0,b=0,c=0 sum=0

File:And,Or,AndOr, Prototype adder STATE 0.PNG

2010-11-25T22:01:58Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 0.PNG": Wrong image

a=0,b=0,c=0 sum=0

File:And,Or,AndOr, Prototype adder STATE 0.PNG

2010-11-25T22:01:09Z

LordOOTFD: uploaded a new version of "File:And,Or,AndOr, Prototype adder STATE 0.PNG": Fixed bit sticking problem, Updated for DF2010

a=0,b=0,c=0 sum=0

v0.31:Animal logic

2010-02-08T04:13:08Z

LordOOTFD: forgot something elementary there, if someone can make this clearer go right on ahead.

Animal logic functions by taking advantage of the path finding algorithm in dwarf fortress, all animals seek to find the shortest (lowest cost) path to their desired targets (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic and less reliable than either fluid of mechanical logic.

==Definitions==

For clarity definitions of the terms used in animal logic are listed here:

'''Ground''': for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

'''Purge''': Path to ground with no inputs

'''Path cost''': The number of steps the animal must make to reach ground

'''Fusion Gate''': Simply one or more logic gates built into the same system (this is more than simply stringing gates)

'''Compund Gate''': Gate which uses two or more gates set to different path costs.

'''And Gate''': And takes x inputs and output TRUE if ALL are TRUE.

'''NAnd Gate''': NAnd takes x inputs and returns TRUE if ALL are FALSE.

'''AndOr Gate''': AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

'''Or Gate''': Or takes x input and output TRUE if ANY are true.

'''Not Gate''': Not takes a single input and inverts it to the oposite state TRUE if FALSE.

'''XOr Gate''': XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

'''NOr Gate''': NOr takes x input and returns TRUE if ALL inputs are FALSE.

'''XNOr Gate''': XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

The basics of construction for an animal logic takes advantage of an animal's tendency to continue to path through tightly closed doors, despite them not being able to pass. it goes without saying that all doors not wired to mechanisms need to be tightly closed.

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, and by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states allowing more than a single on or off signal. For simplicity and streamlining these systems only use binary information, but theoretically they could be made to compute in decimal or some other system; however, these gates are maddeningly complex and very hard if not impossible to build.

==SIMPLE GATES==

There are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path keeping the animal constantly pathing out of it's enclosure. This constant pathing allows the gate to respond more quickly and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as they're more effective for general use.

'''And'''

This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

'''Multi And'''

############
ANYNUMD^ D
############

'''NAnd'''

Reconfigured And gate, see And.
#########
ABCD ^D
#########

'''Or'''

Basic gate, returns true if either input is true.
#####
AD^ D
B####
#####

'''Multi Or'''

#######
A #####
N #####
Y D^ D
N #####
M #####
#######

'''NOr'''

Basically a reconfigured Or gate
#####
AD ^D
B####
#####

'''Not'''

The simplest gate, It takes a single input and inverts it. False->True, True->False
#######
AD ^D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compound gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compound gate might be used to convert decimal numbers into binary using And gates.

'''XOr'''

Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE position by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

'''XNor'''

Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

'''Complex Compound gate, Octal display ALU'''

Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

'''AndOr'''

This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

'''NAndOr'''

Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

'''OrandOr'''

This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

'''OrandAnd'''

This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

The development of more complex gates requires carful calibration of the path cost of each path to allow the gate to switch states correctly and display the correct result.

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

'''Binary Adder'''

A binary adder is constrcuted of two or three "sum" gates and a purge path. a half adder only adds two numbers and only needs two sum gates, 1 and 2. Full adders using carry to allow chaining require three sum gates, 1,2 and 3. because binary is base two that translates to 01,10,11 as the sums, when the second bit is a 1, the gate is "carrying" the value up to the next level.

An building the adder the higest path must have the most preferential path to ground or it will not properly function.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

The above design is flawed as the Sum 1, and 2 paths can become "stuck" if the adder improperly cycles. It can be manually readjusted however this defeats the purpose. A new design which solves these problems is forthcoming, however simply lengthening the coridoors will solve the problem.

'''Decimal Adder'''

While it can be done, It's significantly more complex than simply making a set of decimal converters working with binary adders.

'''hexadecimal adder'''

A hexidecimal adder works on a simmilar level to the binary adder, however it uses 64 sum gates ranging from 0 to 31. [[User:LordOOTFD]] is developing a prototype adder which utilizes a floating carry bit to function as a full adder.

'''Subtractors'''

inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

While kittens are the most reliable cores for logic gates because of their three pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Puppies are quite reliable with Two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''Dogs'''

While dogs may seem an attractive option for logic cores, they will be far more useful as wardogs or hunting dogs to protect dorfs.
Dogs path to the activity zone.

'''Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work even if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

Goblin powered logic is highly ironic, especially if it involves controlling your goblin killing magma trap.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

v0.31:Animal logic

2010-02-08T04:07:38Z

LordOOTFD: Reposting stuff from my user page in formal format, appologies for the delay.

Animal logic functions by taking advantage of the path finding algorithm in dwarf fortress, all animals seek to find the shortest (lowest cost) path to their desired targets (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic and less reliable than either fluid of mechanical logic.

==Definitions==

For clarity definitions of the terms used in animal logic are listed here:

'''Ground''': for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

'''Purge''': Path to ground with no inputs

'''Path cost''': The number of steps the animal must make to reach ground

'''Fusion Gate''': Simply one or more logic gates built into the same system (this is more than simply stringing gates)

'''Compund Gate''': Gate which uses two or more gates set to different path costs.

'''And Gate''': And takes x inputs and output TRUE if ALL are TRUE.

'''NAnd Gate''': NAnd takes x inputs and returns TRUE if ALL are FALSE.

'''AndOr Gate''': AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

'''Or Gate''': Or takes x input and output TRUE if ANY are true.

'''Not Gate''': Not takes a single input and inverts it to the oposite state TRUE if FALSE.

'''XOr Gate''': XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

'''NOr Gate''': NOr takes x input and returns TRUE if ALL inputs are FALSE.

'''XNOr Gate''': XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, and by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states allowing more than a single on or off signal. For simplicity and streamlining these systems only use binary information, but theoretically they could be made to compute in decimal or some other system; however, these gates are maddeningly complex and very hard if not impossible to build.

==SIMPLE GATES==

There are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path keeping the animal constantly pathing out of it's enclosure. This constant pathing allows the gate to respond more quickly and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as they're more effective for general use.

'''And'''

This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

'''Multi And'''

############
ANYNUMD^ D
############

'''NAnd'''

Reconfigured And gate, see And.
#########
ABCD ^D
#########

'''Or'''

Basic gate, returns true if either input is true.
#####
AD^ D
B####
#####

'''Multi Or'''

#######
A #####
N #####
Y D^ D
N #####
M #####
#######

'''NOr'''

Basically a reconfigured Or gate
#####
AD ^D
B####
#####

'''Not'''

The simplest gate, It takes a single input and inverts it. False->True, True->False
#######
AD ^D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compound gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compound gate might be used to convert decimal numbers into binary using And gates.

'''XOr'''

Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE position by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

'''XNor'''

Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

'''Complex Compound gate, Octal display ALU'''

Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

'''AndOr'''

This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

'''NAndOr'''

Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

'''OrandOr'''

This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

'''OrandAnd'''

This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

The development of more complex gates requires carful calibration of the path cost of each path to allow the gate to switch states correctly and display the correct result.

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

'''Binary Adder'''

A binary adder is constrcuted of two or three "sum" gates and a purge path. a half adder only adds two numbers and only needs two sum gates, 1 and 2. Full adders using carry to allow chaining require three sum gates, 1,2 and 3. because binary is base two that translates to 01,10,11 as the sums, when the second bit is a 1, the gate is "carrying" the value up to the next level.

An building the adder the higest path must have the most preferential path to ground or it will not properly function.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

The above design is flawed as the Sum 1, and 2 paths can become "stuck" if the adder improperly cycles. It can be manually readjusted however this defeats the purpose. A new design which solves these problems is forthcoming, however simply lengthening the coridoors will solve the problem.

'''Decimal Adder'''

While it can be done, It's significantly more complex than simply making a set of decimal converters working with binary adders.

'''hexadecimal adder'''

A hexidecimal adder works on a simmilar level to the binary adder, however it uses 64 sum gates ranging from 0 to 31. [[User:LordOOTFD]] is developing a prototype adder which utilizes a floating carry bit to function as a full adder.

'''Subtractors'''

inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

While kittens are the most reliable cores for logic gates because of their three pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Puppies are quite reliable with Two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''Dogs'''

While dogs may seem an attractive option for logic cores, they will be far more useful as wardogs or hunting dogs to protect dorfs.
Dogs path to the activity zone.

'''Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work even if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

Goblin powered logic is highly ironic, especially if it involves controlling your goblin killing magma trap.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

40d:Computing

2010-01-29T06:30:21Z

LordOOTFD: Link to my user page section on animal logic.

Computing in dwarf fortress is the practice of setting up complex constructions to perform logical operations and calculations, ideally to control some functionality of your fortress, or such a doddle. Even if it isn't a young concept anymore, there is still lots of room for improvement and development. One reason is that there are many ways to solve one problem. Innovation and invention is encouraged.
== General ==

Concepts of computing in dwarf fortress are far away from what you can call a programmable computer. Even though all necessary components are proven to exist, a construction working like a real computer may be too complex to be built in dwarf fortress. Nevertheless, early computing machines and electronic devices are comparably simple. These concepts can be easily transferred into dwarf fortress. So dwarfputing is more or less a kind of electronics, casting logic in hardware.

== Basics ==
=== Binary information ===
Binary information can have one of two possible states: true or false, respectively 1 or 0. In dwarf fortress they can be represented by different entities:
* on/off state or signal of a [[trigger]]
* power or connection state of a [[machine component]]
* open or closed state of a [[door]] or similar buildings
* [[pressure plate|low/high]] or [[flow|flowing/standing]] [[water|fluid]]
* present [[creature]]s and [[dwarf|borgs]]
* ...
Electronic devices and computers base on this elementary form of information, and if you want to go into computing, you’ll have to familiarize with it. [http://en.wikipedia.org/wiki/Propositional_calculus propositional calculus]
=== Input/Output ===
Input can be any trigger - [[lever]] or [[pressure plate]]. Typically your dwarfs are pulling levers, creatures are walking over your pressure plates, or fluid is covering those plates to initiate computing. The bottom line is you'll always have levers, pressure plates, or a combination of both sending binary signals: on/off. 
Note: Although [[pressure plates]] can be constructed to trigger at different fluid levels, the output will always be just a binary on/off. So everything you build will have a binary base. 
 
Input elements
* manual: [[lever]] -> binary on/off signal
* triggered: [[pressure plate]] -> binary on/off signal

According to input, output can be anything that is able to react to an on/off signal. This can be doors, bridges, floodgates allowing or stopping flow, gears controlling pumps and much more. Just refer to the [[lever#On/Off states|lever]] page for a detailed list. Independent of what you finally want to control with your dwarfputer, there are always pressure plates generating this signal. In some special configurations - when [[mechanical logic]] is involved - output may not be a on/off signal but power, thus running or not running a machine component. 
 
Output elements
* signal: [[pressure plate]] -> binary on/off signal -> linkable Object(s)
* power: [[gear assembly]] -> binary power on/power off -> machine

=== Binary logic ===
Basic binary logic takes one or two input bits and creates an output based on them. The devices that perform these operations are commonly called '''logic gates'''. 
* NOT - takes one input and returns the opposite of the input 
{| class="wikitable" border=1
|-
! input A
! NOT
|-
| 0
| 1
|-
| 1
| 0
|} 
* AND - takes two inputs and returns true if both inputs are true
* OR - takes two inputs and returns true if at least one input is true
* XOR - takes two inputs and returns true if exactly one input is true
* NAND - takes two inputs and returns true if either input is false
* NOR - takes two inputs and returns true if both inputs are false
* NXOR - takes two inputs and returns true if both inputs are identical 
{| class="wikitable" border=1
|-
! input A
! input B
! AND
! OR
! XOR
! NAND
! NOR
! NXOR
|-
| 0
| 0
| 0
| 0
| 0
| 1
| 1
| 1
|-
| 0
| 1
| 0
| 1
| 1
| 1
| 0
| 0
|-
| 1
| 0
| 0
| 1
| 1
| 1
| 0
| 0
|-
| 1
| 1
| 1
| 1
| 0
| 0
| 0
| 1
|} 
The most human-understandable logic system requires NOT, AND and OR gates, but having a design for either a NAND or a NOR gate is enough to build any of the other gates. Some gates are easier to create or need fewer components than others depending on what discipline your logic relies on.
=== Complex gates ===
* [[Latch]] - storing and reading a single binary value
* [[Repeater]] - sending a repeating signal
* [[Counter]]/[[Adder]] - binary calculation
== Disciplines ==
There are 4 main disciplines of dwarfputing, depending on what will drive the dwarfputer. Each of them has its assets and drawbacks.
=== Fluid logic ===
[[Fluid logic]] is controlling the ''flow of fluid'' over different pressure plates. Fluid logic can be easily constructed and every known logic gate in dwarf fortress has already been built with it. On the other hand this discipline depends on a somehow unlimited source of the used fluid to deal with its [[evaporation]] and [[Water#Water_in_Fortress_Mode|destruction]].
=== Mechanical logic ===
[[Mechanical logic]] uses systems of axles and [[gear assemblies]] to build logical gates. Mechanical logic reacts very fast and can be easily constructed. Especially the feature of gears to toggle on every signal instead of reacting different to on/off signals makes mechanical logic gates very flexible. On the other hand this discipline depends on much mechanical power. And because of the lack of some kind of rotation sensor, you will generally need a pump, a pressure plate and any fluid to convert power into on/off signals.
=== Borg logic ===
[[Borg logic]] controlling the path of your dwarves to direct them over pressure plates. They will be driven by constant hauling jobs or military designations. Pressure plates are used in similar setups to those in the fluid logic method. It is theorized that Borg logic would be quicker and easier to set up than fluid logic, although it would require a very large population dedicated to nothing but borging. The tendency of dwarves to eat, sleep, drink, makes this discipline quite unreliable. There are no known examples of borg logic, and it is purely theoretical at this time. Maybe the discovery of [[one-way]] ramps will push its development.
=== Animal logic ===
[[Animal logic]] is like borg logic but uses animals or captured hostiles to trigger pressure plates. Animals have a natural 'follow the leader' tendency and never starve. Hostiles will always target your dwarves and will also need no food or sleep.
== Examples ==
There are few examples of a really useful dwarfputer and some concepts which have the potential to become useful for others. But in most cases they are made just for fun. What doesn't mean to diminish their designers achievements, because these are in general the more complex ones. At the moment there are no known examples of animal or borg logic.
=== Useful ===
* Magma trap
** This is an example of an useful dwarfputer controlling a magma trap. It automatically floods an area with lava, cleans up and resets afterwards. The timing is perfectly adjusted to let the victims vanish only leaving their valuable metal behind. video: http://mkv25.net/dfma/movie-1808-perfectmagmatrap design: http://i576.photobucket.com/albums/ss208/kanddak/magmatrap.png

=== Concepts ===
* repeater
** mechanical logic http://mkv25.net/dfma/movie-1370-pump-basedautorepeater
* adding machine
** mechanical logic, 6-bit: http://mkv25.net/dfma/movie-1561-addingmachine
** fluid logic, 8-bit: http://mkv25.net/dfma/movie-1084-numberabbeydemonstration
=== Such a doddle ===
* decimal display for 4-bit binary input
** mechanical logic, decimal with overflow-bit: http://mkv25.net/dfma/movie-1745-dwarfputerv01
** probably fluid logic: http://mkv25.net/dfma/movie-1657-7segmentlcddisplay
** fluid logic, hexadecimal: http://mkv25.net/dfma/movie-1092-7-segmentdisplaydemonstration
* tic tac toe
** mechanical logic http://mkv25.net/dfma/movie-1813-tictactoev10simple

== See Also ==
* [[Fluid logic]]
* [[Mechanical logic]]
* [[Repeater]]
== Related user pages ==
[[User:BaronW]] - A calculator capable of addition and subtraction with inputs of up to 1023.

[[User:SL/Logic Gates]] - These use mechanisms for connecting gates and devices and so forth, but fluid for logic. They're built on top of a body of water, and require power (for a pump or two per gate).

[[User:Kyace/Adder]] - A full adder built using fluid logic, with a video of a rough prototype. Trivial to combine 8 of these to make a fluid device capable of adding two 8 bit numbers together.

[[User:Soundandfury#Logic_Gates]] - These have a water supply reservoir above and a drain below. The drained water can be pumped back to the supply reservoir.

[[User:Bidok]] - Animal logic with all gates, memory, repeater and counter. All powered by kittens.

[[User:LordOOTFD#Animal_Logic]] - Animal logic with fast complex gates, building upon Bidok's kitten powered systems.

[[User:Hussell#Assorted_Devices]] - Fluid logic

[[User:Gammon]] - Fluid logic. Very detailed CMOS gates.
[[Category:Guides]]
[[Category:Computing]]

User:LordOOTFD

2010-01-29T06:25:22Z

LordOOTFD:

please excuse my terrible formatting, I'm still figuring it out as my copious edit count will show.

==Animal Logic==

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

'''Ground''': for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

'''Purge''': Path to ground with no inputs

'''Path cost''': The number of steps the animal must make to reach ground

'''Fusion Gate''': Simply one or more logic gates built into the same system (this is more than simply stringing gates)

'''Compund Gate''': Gate which uses two or more gates set to different path costs.

'''And Gate''': And takes x inputs and output TRUE if ALL are TRUE.

'''NAnd Gate''': NAnd takes x inputs and returns TRUE if ALL are FALSE.

'''AndOr Gate''': AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

'''Or Gate''': Or takes x input and output TRUE if ANY are true.

'''Not Gate''': Not takes a single input and inverts it to the oposite state TRUE if FALSE.

'''XOr Gate''': XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

'''NOr Gate''': NOr takes x input and returns TRUE if ALL inputs are FALSE.

'''XNOr Gate''': XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute in decimal or some other system; however, this is maddening and all attempts have resulted in abominations which I do not wish to remember.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path keeping the animal constantly pathing out of it's enclosure this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

'''And'''

This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

'''Multi And'''

############
ANYNUMD^ D
############

'''NAnd'''

Reconfigured And gate, see And.
#########
ABCD ^D
#########

'''Or'''

Basic gate
#####
AD^ D
B####
#####

'''Multi Or'''

#######
A #####
N #####
Y D^ D
N #####
M #####
#######

'''NOr'''

Basically a reconfigured Or gate
#####
AD ^D
B####
#####

'''Not'''

The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compound gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compound gate might be used to convert decimal numbers into binary using And gates

'''XOr'''

Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE position by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

'''XNor'''

Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

'''Complex Compound gate, Octal display ALU'''

Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

'''AndOr'''

This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

'''NAndOr'''

Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

'''OrandOr'''

This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

'''OrandAnd'''

This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

'''Binary Adder'''

The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

'''Decimal Adder'''

While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

'''hexadecimal adder'''

The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

'''Subtractors'''

inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''Dogs'''

The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

'''Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T06:24:11Z

LordOOTFD:

please excuse my terrible formatting, I'm still figuring it out as my copious edit count will show.

==Animal Logic==

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

'''Ground''': for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

'''Purge''': Path to ground with no inputs

'''Path cost''': The number of steps the animal must make to reach ground

'''Fusion Gate''': Simply one or more logic gates built into the same system (this is more than simply stringing gates)

'''Compund Gate''': Gate which uses two or more gates set to different path costs.

'''And Gate''': And takes x inputs and output TRUE if ALL are TRUE.

'''NAnd Gate''': NAnd takes x inputs and returns TRUE if ALL are FALSE.

'''AndOr Gate''': AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

'''Or Gate''': Or takes x input and output TRUE if ANY are true.

'''Not Gate''': Not takes a single input and inverts it to the oposite state TRUE if FALSE.

'''XOr Gate''': XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

'''NOr Gate''': NOr takes x input and returns TRUE if ALL inputs are FALSE.

'''XNOr Gate''': XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute in decimal or some other system; however, this is maddening and all attempts have resulted in abominations which I do not wish to remember.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path keeping the animal constantly pathing out of it's enclosure this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

'''And'''

This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

'''Multi And'''

############
ANYNUMD^ D
############

'''NAnd'''

Reconfigured And gate, see And.
#########
ABCD ^D
#########

'''Or'''

Basic gate
#####
AD^ D
B####
#####

'''Multi Or'''

#######
A #####
N #####
Y D^ D
N #####
M #####
#######

'''NOr'''

Basically a reconfigured Or gate
#####
AD ^D
B####
#####

'''Not'''

The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compound gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compound gate might be used to convert decimal numbers into binary using And gates

'''XOr'''

Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE position by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

'''XNor'''

Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

'''Complex Compound gate, Octal display ALU'''

Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

'''AndOr'''

This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

'''NAndOr'''

Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

'''OrandOr'''

This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

'''OrandAnd'''

This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

'''Binary Adder'''

The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
'''Bold text'''Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

'''Decimal Adder'''

While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

'''hexadecimal adder'''

The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

'''Subtractors'''

inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''Dogs'''

The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

'''Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T06:07:18Z

LordOOTFD:

please excuse my terrible formatting, I'm still figuring it out as my copious edit count will show.

==Animal Logic==

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

'''Ground''': for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

'''Purge''': Path to ground with no inputs

'''Path cost''': The number of steps the animal must make to reach ground

'''Fusion Gate''': Simply one or more logic gates built into the same system (this is more than simply stringing gates)

'''Compund Gate''': Gate which uses two or more gates set to different path costs.

'''And Gate''': And takes x inputs and output TRUE if ALL are TRUE.

'''NAnd Gate''': NAnd takes x inputs and returns TRUE if ALL are FALSE.

'''AndOr Gate''': AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

'''Or Gate''': Or takes x input and output TRUE if ANY are true.

'''Not Gate''': Not takes a single input and inverts it to the oposite state TRUE if FALSE.

'''XOr Gate''': XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

'''NOr Gate''': NOr takes x input and returns TRUE if ALL inputs are FALSE.

'''XNOr Gate''': XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute in decimal or some other system; however, this is maddening and all attempts have resulted in abominations which I do not wish to remember.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path keeping the animal constantly pathing out of it's enclosure this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

'''And'''

This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

'''Multi And'''

############
ANYNUMD^ D
############

'''NAnd'''

Reconfigured And gate, see And.
#########
ABCD ^D
#########

'''Or'''

Basic gate
#####
AD^ D
B####
#####

'''Multi Or'''

#######
A #####
N #####
Y D^ D
N #####
M #####
#######

'''NOr'''

Basically a reconfigured Or gate
#####
AD ^D
B####
#####

'''Not'''

The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compound gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compound gate might be used to convert decimal numbers into binary using And gates

'''XOr'''

Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE position by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

'''XNor'''

Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

'''Complex Compound gate, Octal display ALU'''

Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

'''AndOr'''

This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

'''NAndOr'''

Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

'''OrandOr'''

This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

'''OrandAnd'''

This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

'''Binary Adder'''

The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
'''Bold text'''Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

'''Decimal Adder'''

While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

'''hexadecimal adder'''

The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

'''Subtractors'''

inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''
Dogs'''

The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

'''
Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T06:06:23Z

LordOOTFD:

please excuse my terrible formatting, I'm still figuring it out as my copious edit count will show.

==Animal Logic==

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

'''Ground''': for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.
'''
Purge''': Path to ground with no inputs
'''
Path cost''': The number of steps the animal must make to reach ground

'''Fusion Gate''': Simply one or more logic gates built into the same system (this is more than simply stringing gates)

'''Compund Gate''': Gate which uses two or more gates set to different path costs.
'''
And Gate''': And takes x inputs and output TRUE if ALL are TRUE.
'''
NAnd Gate''': NAnd takes x inputs and returns TRUE if ALL are FALSE.

'''AndOr Gate''': AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

'''Or Gate''': Or takes x input and output TRUE if ANY are true.
'''
Not Gate''': Not takes a single input and inverts it to the oposite state TRUE if FALSE.
'''
XOr Gate''': XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.
'''
NOr Gate''': NOr takes x input and returns TRUE if ALL inputs are FALSE.

'''XNOr Gate''': XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute in decimal or some other system; however, this is maddening and all attempts have resulted in abominations which I do not wish to remember.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path keeping the animal constantly pathing out of it's enclosure this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

'''And'''

This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

'''Multi And'''

############
ANYNUMD^ D
############

'''NAnd'''

Reconfigured And gate, see And.
#########
ABCD ^D
#########

'''Or'''

Basic gate
#####
AD^ D
B####
#####

'''Multi Or'''

#######
A #####
N #####
Y D^ D
N #####
M #####
#######

'''NOr'''

Basically a reconfigured Or gate
#####
AD ^D
B####
#####

'''Not'''

The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compound gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compound gate might be used to convert decimal numbers into binary using And gates

'''XOr'''

Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE position by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

'''XNor'''

Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

'''Complex Compound gate, Octal display ALU'''

Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

'''AndOr'''

This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

'''NAndOr'''

Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

'''OrandOr'''

This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

'''OrandAnd'''

This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

'''Binary Adder'''

The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
'''Bold text'''Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

'''Decimal Adder'''

While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

'''hexadecimal adder'''

The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

'''Subtractors'''

inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''
Dogs'''

The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

'''
Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:54:52Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

'''Kittens'''

Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

'''Puppies'''

Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

'''Animal Children'''

Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

'''Cats'''

Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

'''
Dogs'''

The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

'''
Cattle'''

Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

'''Other animals'''

Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

'''Goblins'''

I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:53:09Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|sum 00
Image:9bit adder prototype interface pannel.PNG|9bit adder interface
Image:9bit adder prototype.PNG|9bit adder
Image:9bit adder prototype 10100010notes.PNG|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:29:20Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|frame|Prototype digital adder
Image:And,Or,AndOr, Prototype adder STATE 3.PNG|frame|sum 11
Image:And,Or,AndOr, Prototype adder STATE 2.PNG|frame|sum 10
Image:And,Or,AndOr, Prototype adder STATE 1.PNG|frame|sum 01
Image:And,Or,AndOr, Prototype adder STATE 0.PNG|frame|sum 00
Image:9bit adder prototype interface pannel.PNG|frame|9bit adder interface
Image:9bit adder prototype.PNG|frame|9bit adder
Image:9bit adder prototype 10100010notes.PNG|frame|9bit adder, notes show the decimal value of each adder's bit
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:28:36Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures

<gallery>
[[Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|frame|Prototype digital adder]]
[[Image:And,Or,AndOr, Prototype adder STATE 3.PNG|frame|sum 11]]
[[Image:And,Or,AndOr, Prototype adder STATE 2.PNG|frame|sum 10]]
[[Image:And,Or,AndOr, Prototype adder STATE 1.PNG|frame|sum 01]]
[[Image:And,Or,AndOr, Prototype adder STATE 0.PNG|frame|sum 00]]
[[Image:9bit adder prototype interface pannel.PNG|frame|9bit adder interface]]
[[Image:9bit adder prototype.PNG|frame|9bit adder]]
[[Image:9bit adder prototype 10100010notes.PNG|frame|9bit adder, notes show the decimal value of each adder's bit]]
</gallery>

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:27:56Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|frame|Prototype digital adder]]
[[Image:And,Or,AndOr, Prototype adder STATE 3.PNG|frame|sum 11]]
[[Image:And,Or,AndOr, Prototype adder STATE 2.PNG|frame|sum 10]]
[[Image:And,Or,AndOr, Prototype adder STATE 1.PNG|frame|sum 01]]
[[Image:And,Or,AndOr, Prototype adder STATE 0.PNG|frame|sum 00]]
[[Image:9bit adder prototype interface pannel.PNG|frame|9bit adder interface]]
[[Image:9bit adder prototype.PNG|frame|9bit adder]]
[[Image:9bit adder prototype 10100010notes.PNG|frame|9bit adder, notes show the decimal value of each adder's bit]]

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

File:9bit adder prototype 10100010notes.PNG

2010-01-29T05:27:08Z

LordOOTFD: 9bit adder showing bit values

9bit adder showing bit values

User:LordOOTFD

2010-01-29T05:22:47Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG|frame|Prototype digital adder]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:20:52Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:14:17Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compound gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:12:23Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

==SIMPLE GATES==

there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

==Compound Gates==

Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compond gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

==Fusion gates==

These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

==Complex Gates==

==Adders==
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

==Animals==

Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

==Putting it all together==

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:08:27Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

GATES
there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

Compound Gates
Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compond gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

Fusion gates
These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

Complex Gate

Adders
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

Animals
Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

Putting it all together

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:06:05Z

LordOOTFD: Undo revision 61928 by LordOOTFD (Talk)

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

GATES
there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
<blockquote>
#########
ABCD^ D
#########
</blockquote>

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

Compound Gates
Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compond gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

Fusion gates
These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

Complex Gate

Adders
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

Animals
Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

Putting it all together

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:05:32Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

GATES
there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
====And===
#########
ABCD^ D
#########
test

Complex Gate

Adders
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

Animals
Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

Putting it all together

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T05:03:33Z

LordOOTFD:

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.

Purge: Path to ground with no inputs

Path cost: The number of steps the animal must make to reach ground

Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)

Compund Gate: Gate which uses two or more gates set to different path costs.

And Gate: And takes x inputs and output TRUE if ALL are TRUE.

NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.

AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)

Or Gate: Or takes x input and output TRUE if ANY are true.

Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.

XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.

NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.

XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.

For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate

Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.

Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

GATES
there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
<blockquote>
#########
ABCD^ D
#########
</blockquote>

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

Compound Gates
Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compond gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

Fusion gates
These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

Complex Gate

Adders
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

Animals
Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

Putting it all together

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

User:LordOOTFD

2010-01-29T04:58:44Z

LordOOTFD: Created page with 'Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parent…'

Animal logic works as a function of the path finding algorithm in dwarf fortress, as all animals seek to find the lowest cost path to their desired objects (activity zone, parents, dwarfs, valuable objects, etc) this can be used to create very very complex logic gates. Animal logic has three principle advantages, speed, compactness, and simplified functions; however, animal logic is slower than mechanical logic, less reliable than either, and logic is often inverted.

Throughout this document I will be using a number of terms which may not be immediately obvious so I'll list them here:

Ground: for simplicity the thing the animal is pathing to is refereed to as ground as that is the ground state which it wishes to reach. Ground is always the left unless otherwise noted.
Purge: Path to ground with no inputs
Path cost: The number of steps the animal must make to reach ground
Fusion Gate: Simply one or more logic gates built into the same system (this is more than simply stringing gates)
Compund Gate: Gate which uses two or more gates set to different path costs.
And Gate: And takes x inputs and output TRUE if ALL are TRUE.
NAnd Gate: NAnd takes x inputs and returns TRUE if ALL are FALSE.
AndOr Gate: AndOr takes x inputs and returns TRUE if X-Y are TRUE. (this gate is exclusive to animal logic, and is a single step fusion of And, and Or)
Or Gate: Or takes x input and output TRUE if ANY are true.
Not Gate: Not takes a single input and inverts it to the oposite state TRUE if FALSE.
XOr Gate: XOr takes 2 or more inputs and output TRUE if ONLY ONE is TRUE but NOT ALL are TRUE.
NOr Gate: NOr takes x input and returns TRUE if ALL inputs are FALSE.
XNOr Gate: XNOr takes 2 or more inputs and returns TRUE if ALL are TRUE, OR FALSE.
For a better explanation of gates see:http://en.wikipedia.org/wiki/Logic_gate
Notation: #:always wall ^:pressure plate X:floodgate,grate,bars,bridge,etc(explained per entry) D:door,open, but kept tightly shut(pet impassable) d:door, input value not specified Letters:doors/floodgates,grates,bar,etc Specified inputs(these are generally interchangeable, if not this will be noted in the entry) g:Ground, some entries need it for clarity. C: Either an input in diagrams, or the state Carry is refereed to as a state within an adder.
Gates will always be capitalized in the way they are within the entry, I.E. And, Or, AndOr, XNOr, etc

There are three principle logic gates in any logic system, And, Or, and Not. Animal logic can easily create all logic gates and is able to handle multi input-output, and fusion gates. The principle reason for this is pathfinding always prefers the shortest path to ground, by controlling this path you can control the animal within the gate. The advantage of animal pathing is that the gate can have multiple states, more than a single on or off signal. For simplicity and streamlining the systems I have designed only use binary outputs, but theoretically they could be made to compute natively in decimal; however, this is a bit more complicated than a week of study allows.

GATES
there are two primary ways to make a gate, single path and dual path, the single path gate only allows the animal a single exit and this forces it into a non pathing state until there is input, at which point it will "wake up" and move; however, this kind of gate is slow and unreliable. Dual path gates always have an open path, keeping the animal constantly pathing out of it's enclosure, this allows the gate to respond faster and retain higher reliability; however, the constant pathing may cause noticeable frame rate drops with large logic sets. I will only be discussing the dual path gates, as I find them to be better in general use.

And
This simple gate is made by confining the animal into a straight coridor; the ground path will have two or more doors which are connected to the input, while the second longer path remains clear. the gate can be configured as an NAnd gate by simply moving the pressure plate. if the plate is by the ground path it functions as an And gate returning TRUE if the ground path is open, and if the plate is by the purge path it will return FALSE when the inputs are TRUE
#########
ABCD^ D
#########

Multi And
############
ANYNUMD^ D
############

NAnd
Reconfigured And gate, see And.
#########
ABCD ^D
#########

Or
Basic gate
#####
AD^ D
B####
#####

Multi Or
#######
A #####
N #####
Y D^ D
N #####
M #####
#######

NOr
Basically a reconfigured Or gate
#####
AD ^D
B####
#####

Not
The simplest gate, It only takes a single imput.
#######
AD^ D
#######

Compound Gates
Basically two or more gates arranged with different path costs to ground. These gates can be configured in a number of different ways, these being the simplest. It may be possible to make these gates as single gates but that would require inverting some of the input. Simple compund gates use two simple gates and handle two inputs, complex compund gates have more then two simple gates and need more than two inputs. a Complex compund gate might be used to convert decimal numbers into binary using And gates

XOr
Compound of And and Or, when ONLY ONE is TRUE returns TRUE
If A and B are false the animal moves to the FALSE position by Purge, if A or B is true, the animal moves to the TRUE position at the Or gate, if both A and B are true the animal moves to the FALSE postion by the And gate.

#g########
# ABD D #
# ####^# #
# ####D# #
# ###BA# #
# #
##########
And path cost: 4
Or path cost: 10
Purge path cost: 14

XNor
Inverse of XOr: Return TRUE if BOTH are TRUE OR FALSE
If A and B are false the animal move to the TRUE position by Purge, if A or B is true, the animal moves to the FALSE position at the Or gate, if both A and B are true the animal moves to the TRUE postion by the And gate.

#g#########
# #
##B###### #
###A## DA #
####D^##B #
#####D### #
###### #
###########
And path cost: 4
Or path cost: 10
Purge path cost: 15

Complex Compond gate, Octal display ALU
Inputs are 1,2,4 these correspond to the binary values of the inputs, outputs are A,B,C,D,E,F,G,H being 0,1,2,3,4,5,6,7 respectively in the output display. I used octal for sanity, but this could be easily scaled to work for decimal (up to 10, beyond that you need a converter not an if switch) or hexadecimal(hex will be easy to handle, and probably easier to convert down to decimal)

#################
#
# # # # # # #1# #
# # #1# #1#2#2# #
#1#2#2#4#4#4#4# #
#D#D#D#D#D#D#D#D#
# #
#################

# ######
# 1 D #
# #### #
# 2 D #
# #### #
# 12 D #
# #### #
# 4 D #
# #### #
# 14 D #
# #### #
# 24 D #
# #### #
# 124D #
# #### #
# D #
########

Fusion gates
These are gates which are constructed by physically combining the two gates to get a specific output.

AndOr
This gate will evaluate if either of x And statements are TRUE. This gate is built as a straight line similar to the And gate
######
#C####
ABD^ D
C#####
######

NAndOr
Reconfigured AndOr gate, see AndOr
######
#C####
ABD ^D
C#####
######

OrandOr
This gate returns true if either A or B and either C or D is true.

######
AC####
BED^ D
######

OrandAnd
This gate returns true if either A or B is true, and E and C are true.

#######
A######
BCED^ D
#######

Complex Gate

Adders
A Full adder can be made as a Compound Fusion gate, by combining, And, AndOr, and Or gates

Binary Adder
The first binary adder I attempted was structured like an electronic adder using an array of simple gates. It contained five animals and used grates to control the logic, based off of bidok's logic gates. This adder functioned correctly but it was very inefficient with space, and highly unreliable often taking ten plus minutes to properly align. I refined this design by lining the gates up into a linear arrangement, but this failed to solve the efficiency problems.

I then realized that simply limiting my Adder to using Electronic gates was silly realizing the key point of animal logic I designed a single stage gate, which had four output states: 0,1,C,1&C. this allowed me to compress the Adder into a single circuit. Modifying the design further the use of doors allows the new design to function at approximately 4-6 times the speed of the prototype adder.

The Binary Adder function by adding three values, A,B, and Carry. Carry is only involved if the previous adder had a result of 2, or 3. the adder works by detecting if (A Or B Or C = True)Sum=1, Or (A And B, Or, A And C, Or B And C = True)Sum=2, Or (A And B And C = True)Sum=3, Or (A And B And C = False)Sum=0. With this basic logic one simply needs to configure the output for 1 if the answer is 1, C if the answer is 2, and 1 and C if the answer is 3. the gates must also be arranged so the Highest Sum has the shortest path to ground as otherwise the gate would return nonsense.

Stand alone Adders (they don't carry into another adder) require 22 mechanisms, and 14 doors.
Start Adders (They feed into the next Adder and include a carry) require 32 mechanisms, and 14 doors.
Chain Adders (The receive Carry, and pass a Carry bit up) require 32 mechanisms, and 14 doors
While Materials intensive the gates only take up 13x9 urists, ideal for chaining along mining tunnels.

Reference pictures
[[Image:Xnor,Xor,Nand,Or_prototype_adder_STATE_1]]
Add pictures of the states here

By chaining these gates you can perform most binary math, the easiest of which is addition. In my old fort I built and tested my initial 9 Bit Addition computer. the design failed in two circumstances, the AndOr gate of bit 32 had a lower path cost than the And gate when the animal was at Sum 2, and the Or gate in bit 4 had a lower path cost than ground if the lower door was open.

The gates in the Super Snail adder can be reset to the correct positions by forbidding the doors which fault. I'm working on a more reliable compact adder.

Decimal Adder
While it can be done, It's massively more complex than simply making a set of decimal converters working with numbers over 10,

hexadecimal adder
The hex adder makes use of 32 sum gates per side of a single adder, making it geometrically more complex than the binary adder, however it does make animal management more streamlined. more information to come.

Status
Sum gates 0-31 done
layout pending
working prototype pending
finished dorfputer pending

Subtractors
inverse adder, simple but not yet tested.

Animals
Choosing the animal which works as the logic core for an animal logic systems is somewhat important, depending on your needs and the available animals. however pretty much anything will do as long as you can remember which animal fits into which gate (to avoid designating the same animal for more than one pit).

Kittens
Put those worthless cats to work, load them into your fortress's logic core and make them work for their keep. while kittens are the most reliable cores for logic gates with their 3 pathing goals they're also problematic as they grow into cats which only have two, and may cause catsplosions inside your logical cores. Ideally kittens should be replaced yearly or biyearly as their growth defines.
Kittens path to the activity zone, their parents, and vermin.

Puppies
Why should your fortresses working animals only work once they grow up? throw the puppies into the logic core and have them work from the day of their birth. Puppies are quite reliable with their two pathing goals, but retain the problem of maturation.
Puppies path to the activity zone, and their parents.

Animal Children
Using the non matured animals for something useful before butchering may be quite effective, however they still must be flushed when they mature.
Animal children path to the activity zone, and their parents.

Cats
Aggravating animals, throw them into the computer and get some worth out of them. Otherwise useless cats become useful when used for logic, with two pathing goals they're responsive, and multiply quickly. watch out for catsplosions while using these critters
Cats path to the activity zone, and Vermin.

Dogs
The workhorse of your fortress, because horses can't do anything useful. I'd recommend not using dogs as they're put to better use as wardogs to protect your dorfs.
Dogs path to the activity zone.

Cattle
Large lumbering bovines, the advantage of Cattle is you can tell the sexes apart, they also make the pressure plates continue to work if you forget to reassign the trigger weight.
Cattle path to the activity zone.

Other animals
Any animals work, but the above are probably your best choice, excluding any modded animals. however if you have a GCS handy a GCS powered computer would be awesome, so take this as you will.
Other animals have different pathing goals, but most only path to the activity zone.

Goblins
I'm working on an incremental goblin powered system, results pending.

Putting it all together

When it comes time to automate your systems the first thing you need to know is what needs to automated and what should remain manual. an obsidian farm with completely autonomous control of the casting process is all well and good, until it drowns all your legendary miners when it prematurely triggers. all systems should have manual controls and failsafes to help avoid FUN! (but because we all love FUN sometimes you forget to fully connect that emergency drain, or that failsafe system you built somehow failed.)

once you know the steps you need in your system it comes time to select the parts you need to automate, whether it be basic logic gates or more sophisticated multiple trigger systems.

This is mainly pure logic and I can't really help with that, but post a requirement in the talk page and if I see it I'll work on it. Consult the computing page on this wiki, and look up digital logic on Wikipedia. past that it's pretty fundamental and I don't really think I can adequately describe it.

File:Xnor,Xor,Nand,Or prototype adder STATE 1.PNG

2010-01-29T04:33:00Z

LordOOTFD: Prototype adder using pure logic

Prototype adder using pure logic

File:And,Or,AndOr, Prototype adder STATE 3.PNG

2010-01-29T04:32:03Z

LordOOTFD: a=1,b=1,c=1 Sum=11

a=1,b=1,c=1 Sum=11

File:And,Or,AndOr, Prototype adder STATE 2.PNG

2010-01-29T04:31:43Z

LordOOTFD: a=1,b=1,c=0 Sum=10

a=1,b=1,c=0 Sum=10

File:And,Or,AndOr, Prototype adder STATE 1.PNG

2010-01-29T04:31:14Z

LordOOTFD: a=1,b=0,c=0 Sum=0

a=1,b=0,c=0 Sum=0

File:And,Or,AndOr, Prototype adder STATE 0.PNG

2010-01-29T04:30:46Z

LordOOTFD: a=0,b=0,c=0 sum=0

a=0,b=0,c=0 sum=0

File:9bit adder prototype interface pannel.PNG

2010-01-29T04:21:17Z

LordOOTFD: Interface pannel for 9bit adder, showing the current computation.

Interface pannel for 9bit adder, showing the current computation.

File:9bit adder prototype.PNG

2010-01-29T04:18:22Z

LordOOTFD: State is 10100010

State is 10100010