Possible new chip?

So I've been pondering on this idea for some time, and some of my car ideas went up in flames, which had to do with this exact problem.

I was secretly working a Mach 6. The speed racer car, and I only mentioning this due to Fox Explorer's Jumping Scenario. How the hell are the jumping jacks going to work?!

So for the possible new chip, it would be a sliding chip. Either resting on the '---' chip as if it's a frame on a 180 angle, beside said chip like a spring, or anywhere in-between.

Is said chip possible? If so, should we contain it to either X or Y values (Z is not possible, or is it?), or can it be coded to act on both sets? I believe this is a question for the admins and the 'oldies' to RC.

just use hidden frames and inverse kinematics.

RA2lover wrote:just use hidden frames and inverse kinematics.

Inverse Kinematics? Explain?

Tried using hidden frames, it made the cars exaggeratedly jumpy and would lose control at even the lowest of speeds, that or the speed of the jacks dragged the cars in which even direction it bent towards striking the ground.

Let me wiki that for you.

tl;dr:the idea is to control an object's position by changing the angles of its joints - our hands already do that!

anyway, i just made a model in 5 minutes to show it.

Code:

// [RCD]
Val{
  VAR1(default=90, max=90)
  VAR2(default=180, max=180)
}
Key{
  0:VAR1(step=-5), VAR2(step=-10)
  1:VAR1(step=5), VAR2(step=10)
}
Body{
  Core(){
    N:Weight(){
      N:Frame(angle=-VAR1, option=1){
        N:Frame(angle=VAR2, option=1){
          N:Weight(angle=-VAR1){
            S:Cowl(){}
          }
        }
      }
      N:Cowl(){}
    }
    S:Chip(angle=90){
      S:Weight(angle=90, option=8){
        S:Weight(option=8){}
      }
    }
  }
}
Lua{function main()
out(0,"just use arrow keys")
end}


it can achieve 3 degrees of freedom, but i'm too lazy to use trigonometry

The thing is, frames are very flexible, so they aren't the best for this, if it needs to support much load.

LB has what you're after (I think), but RC doesn't unless you use other chips to simulate it

AFAIK there are no scenarios for LB yet(especially because takeya didn't release the lbsys scope function documentation).

This kind of goes along with the hidden frame idea posted above. It will sometimes jump "semi-correctly" and others it will just flip over.

Code:



// [RCD] BasicCar
Val
{
   BRAKE(default=0, max=80, step=80)
   ENGINE(default=0, min=-2500, max=2500, step=2500)
   HANDLE(default=0, min=-20, max=20, step=5)
   HBRAKE(default=0, max=100, step=100)
   JUMP(default=0, max=90, step=4)
   JUMP2(default=180, max=180, step=8)
}
Key
{
   0:Engine(step=-500)
   1:Engine(step=500)
   2:Handle(step=-0.5)
   3:Handle(step=0.5)
   4:JUMP(step=60), JUMP2(step=-120)
   7:Brake(step=30), HBrake(step=20)
   8:HBrake(step=20)
}
Body
{
   Core() {
      N:Chip() {
         N:Rudder(angle=Handle) {
            W:Frame() {
               W:Wheel(angle=90, brake=Brake) { }
               S:Frame(angle=JUMP, option=1) {
                  S:Frame(angle=JUMP2, option=1) {
                     S:Frame(angle=JUMP, option=1) {
                        N:Frame(option=1) {
                           S:Trim(angle=90) { }
                        }
                     }
                  }
               }
               S:Frame(option=1) {
                  N:Trim(angle=90) { }
               }
            }
            E:Frame() {
               E:Wheel(angle=90, brake=Brake) { }
               S:Frame(angle=JUMP, option=1) {
                  S:Frame(angle=JUMP2, option=1) {
                     S:Frame(angle=JUMP, option=1) {
                        N:Frame(option=1) {
                           S:Trim(angle=90) { }
                        }
                     }
                  }
               }
               S:Frame(option=1) {
                  N:Trim(angle=90) { }
               }
            }
            N:Frame(angle=90, option=1) { }
         }
      }
      S:Chip() {
         W:Frame() {
            W:Wheel(angle=90, power=Engine, brake=HBrake) { }
            N:Frame(angle=JUMP, option=1) {
               N:Frame(angle=JUMP2, option=1) {
                  N:Frame(angle=JUMP, option=1) {
                     S:Frame(option=1) {
                        N:Trim(angle=90) { }
                     }
                  }
               }
            }
            N:Frame(option=1) {
               S:Trim(angle=90) { }
            }
         }
         E:Frame() {
            E:Wheel(angle=90, power=-Engine, brake=HBrake) { }
            N:Frame(angle=JUMP, option=1) {
               N:Frame(angle=JUMP2, option=1) {
                  N:Frame(angle=JUMP, option=1) {
                     S:Frame(option=1) {
                        N:Trim(angle=90) { }
                     }
                  }
               }
            }
            N:Frame(option=1) {
               S:Trim(angle=90) { }
            }
         }
      }
   }
}
Script
{
   print 0,"Welcome to Rigid-Chips World."
   print 1,"  FPS=",_FPS(),"  Chips=",_CHIPS(),"  Weight=",_WEIGHT()
   print 2,"  Width=",_WIDTH(),"  Height=",_HEIGHT()
   print 3,"  Faces=",_FACE()
   print 4,"  Vel=",_VEL()
   print 5,"  R=",_RED(32,32)
   print 6,"  G=",_GREEN(32,32)
   print 7,"  B=",_BLUE(32,32)

   print 10,"Normal Basic controls but Z makes it jump"
   print 11,"Kind of..."}





@ JHaskly

Question;
Yes, frames are 'fragile' (not a good idea to use chip, causes wind force, neither weight, or trim either. I have thought on how to do it with rudders recently), though if you are able to "strike the ground" at a 90 degree, how does the system respond? Will it bend, or will it most likely snap off at the connecting to the body of the car or any other connection?

EDIT;

@ RA2

This is more or less what I'm talking about, yet if you change the degrees at 25 I find, it disrupts the cars movement.

Jack 1

Code:

// [RCD]
Val
{
   VAR1(default=-180, min=-360, max=-180)
   VAR2(default=180, max=180)
}
Key
{
   0:VAR1(step=10), VAR2(step=-10)
   1:VAR1(step=-10), VAR2(step=10)
}
Body
{
   Core() {
      N:Weight(angle=-90) {
         N:Cowl() { }
         N:RudderF(angle=VAR1) {
            N:RudderF(angle=VAR2) { }
         }
      }
      S:Chip(angle=90) {
         S:Weight(angle=90, option=8) {
            S:Weight(option=8) { }
         }
      }
   }
}
Lua
{function main()
out(0,"just use arrow keys")
end}


Jack 1.5

Code:

// [RCD]
Val
{
   VAR1(default=-180, min=-360, max=-180)
   VAR2(default=180, max=180)
}
Key
{
   0:VAR1(step=10), VAR2(step=-10)
   1:VAR1(step=-10), VAR2(step=10)
}
Body
{
   Core() {
      N:Weight(angle=-90) {
         N:Cowl() { }
         N:RudderF(angle=VAR1) {
            N:RudderF(angle=VAR2) {
               N:Frame() { }
            }
         }
      }
      S:Chip(angle=90) {
         S:Weight(angle=90, option=8) {
            S:Weight(option=8) { }
         }
      }
   }
}
Lua
{function main()
out(0,"just use arrow keys")
end}


Jack 2

Code:

// [RCD]
Val
{
   VAR1(default=-180, min=-360, max=-180)
   VAR2(default=180, max=180)
   VAR3(default=180, max=180)
}
Key
{
   0:VAR1(step=10), VAR2(step=-10), VAR3(step=-10)
   1:VAR1(step=-10), VAR2(step=10), VAR3(step=10)
}
Body
{
   Core() {
      N:Weight(angle=-90) {
         N:Cowl() { }
         N:RudderF(angle=VAR1) {
            N:RudderF(angle=VAR2) {
               N:RudderF(angle=VAR3) { }
            }
         }
      }
      S:Chip(angle=90) {
         S:Weight(angle=90, option=8) {
            S:Weight(option=8) { }
         }
      }
   }
}
Lua
{function main()
out(0,"just use arrow keys")
end}


If the frame strikes perpendicular to the ground, there isn't usually an issue. When something connected to the frame strikes the ground, that "limb" often bounces and flexes a fair bit.

It's possible to make things like this if you're willing to make a script in the scenario. I've mentioned something about making a function that lets you do this sort of thing. Right now, I just have something that lets me rotate a ball attached to the end of the chip, but if I replace the ball with another chip, and let you mess with where it connects, I could theoretically get a chip with this functionality along with all the others at the same time. Also, it would allow circular linking.

Great idea