UPawn - Remaking Pawn in UnrealScript

Discussions about Coding and Scripting

UPawn - Remaking Pawn in UnrealScript

Postby Gustavo6046 » Mon Feb 27, 2017 7:30 pm

Do you know the Pawn class? Chances are you do. You know, that ugly, native, unflexible, boring class which is hard to extend and harsh to subclass.

Well, not for long!

Presenting, UPawn. Well, it's not done yet, but this pre-alpha code compiles. Whenever it does something I'll test it.
In fact, this is a remade version of Pawn, which uses the projectile physics to be able to walk on surfaces in a flexible way, but that's not it! It also supports Fun, and in the future, it'll have many more features!

Code: Select all
//=============================================================================
// UPawn.
//=============================================================================
class UPawn expands Actor;

enum PawnType
{
   PT_None,
   PT_Native,
   PT_New,
   PT_Both
};

enum PawnPhysics
{
   PP_Walking,
   PP_Falling,
   PP_Swimming,
   PP_Flying
};

enum NavigationClass
{
   NC_Breadcrumb,
   Nc_Native
};

struct WeaponUse
{
   var()   float      MinRange, MaxRange;
   var()   float      AverageDmg;
   var()   float      SplashRange;
   var()   float      ProjSpeed;
   var()   float      ShootRate;
};

struct AnyPawn
{
   var()   PawnType   ThisType;
   var()   Pawn      Native;
   var()   UPawn      New;
};

// UPhysics.
var(UPhysics)   float            MaxFloorPitch;
var(UPhysics)   Vector            MovementBob;
var(UPhysics)   float            JumpSpeed;
var(UPhysics)   float            WalkSpeed;
var(UPhysics)   AnyPawn            Mount;

// Artificial Intelligence of UPawn.
var(AI)         float            EyeHeight;
var(AI)         float            Cowardness;
var(AI)         float            Smartness;
var(AI)         float            Boredness;
var(AI)         float            Eagerness; // how fast the fun of playing only a single Toy is lost
var(AI)         class<Weapon>      FavoriteGun;
var(AI)         WeaponUse         GunStats;
var(AI)         Pawn            Enemies[32];
var(AI)         Pawn            PriorityEnemy;
var(AI)         NavigationClass      NavType;
var            Actor            Toy;
var            float            ToyStrenght;
var            int               PlayTimes;

// Inventory stuff.
var(PawnInv)   Inventory         StartingInv[64];
var(PawnInv)   Weapon            CurrentWeapon;

var(Anim)      float            IdleSpeed;
var(Anim)      float            BoredModifier; // multiplies idle anim speed when bored

var            Rotator            FloorNormal;
var            Vector            WalkOffset;
var            Vector            OldVel;
var            Actor            NvCurrent;
var            Actor            NvNext;
var            int               PathSize;
var            Inventory         Inv;
var            float            CurrentSpeed;
var            name            InterruptingWalk;
var            name            OldState;
var            bool            bMoving;


simulated function PreBeginPlay()
{
   local Vector v, n;

   v = Location;
   v.Z -= 16384;

   Trace(v, n, v);

   FloorNormal = Rotator(n);
}

simulated function bool ActorCloser(Actor Other, Actor aFrom)
{
   return aFrom == None || VSize(Other.Location - Location) < VSize(aFrom.Location - Location);
}

simulated function WalkToward(Actor Target, float Speed, bool bStrafe)
{
   WalkNormal(Rotator(Target.Location - Location).Yaw, VSize(Location - Target.Location), Speed, bStrafe);
}

simulated function WalkTo(Vector Target, float Speed, bool bStrafe)
{
   WalkNormal(Rotator(Target - Location).Yaw, VSize(Location - Target), Speed, bStrafe);
}

simulated function WalkNormal(float Angle, float Distance, float Speed, bool bStrafe)
{
   local Rotator Dir;

   Dir = FloorNormal;
   Dir.Yaw = Angle;

   if ( !bStrafe )
      SetRotation(Dir);

   WalkOffset += Vector(Dir) * Distance;
   CurrentSpeed = WalkSpeed * Speed;
   OldState = GetStateName();

   GoToState('Walking');
}

simulated function Actor NextTo(Actor Target)
{
   local Breadcrumb Closest, B;
   local NavigationHelper H;

   if ( Breadcrumb(NvCurrent) != None )
   {
      foreach AllActors(class'Breadcrumb', B)
         if ( ActorCloser(B, Closest) )
            Closest = B;

      NvNext = Breadcrumb(NvCurrent).FindPathToBreadcrumb(Closest).Next;
   }

   else if ( NavigationPoint(NvCurrent) != None )
   {
      H = Spawn(class'NavigationHelper', self);
      H.LoadPathToward(Target);

      NvNext = H.Helped(true);
   }

   return NvNext;
}

simulated function bool Walkable(vector Normal)
{
   return Rotator(Normal).Pitch / 65535 < MaxFloorPitch;
}

simulated function StopWalking(name NewState)
{
   if ( IsInState('Walking') )
      InterruptingWalk = NewState;
}

simulated function Tick(float TimeDelta)
{
   if ( bMoving )
   {
      Velocity = OldVel;

      bMoving = false;
   }
}

simulated function GotFun(Actor Source, float Strenght)
{
   Boredness -= Strenght;

   if ( Source == Toy )
   {
      ToyStrenght -= PlayTimes * Eagerness - Strenght;
      PlayTimes++;

      return;
   }

   if ( Strenght > ToyStrenght )
   {
      Toy = Source;
      ToyStrenght = Strenght;
      PlayTimes = 0;
   }
}

simulated function TickMove(Vector NewLocation)
{
   Velocity = NewLocation - Location;
   OldVel = Velocity;

   bMoving = true;
}

simulated function HitWall(vector HitNormal, Actor Wall)
{
   Landed(HitNormal);
}

simulated function Landed(vector Normal)
{
   if ( !Walkable(Normal) )
      return;

   FloorNormal = Rotator(Normal);
}

auto state Idle
{
   function Timer()
   {
      Boredness += 1;
   }

Begin:
   SetTimer(0.5, true);

   if ( Boredness > 16 )
      GoToState('Bored');

   LoopAnim('Idle', IdleSpeed);
}

function Roam()
{
   local Vector v, Norm, f;

   v = Location + VRand() * 60;

   while ( !FastTrace(v) )
      v = Location + VRand() * 60;

   f = v;
   f.Z -= CollisionHeight * 1.6;

   Trace(v, Norm, f, v);

   WalkTo(v, 0.9, false);
}

state Bored
{
   function Timer()
   {
      Boredness += 1;

      if ( FRand() < Eagerness )
         Roam();
   }

Begin:
   LoopAnim('Idle', IdleSpeed + BoredModifier);

   if ( Boredness > 36 )
      Roam();
}

state Walking
{
   function EndWalk()
   {
      GoToState(OldState);
   }

   function Tick(float TimeDelta)
   {
      while ( VSize(WalkOffset) > (CurrentSpeed * 2.0) )
      {
         if ( InterruptingWalk != 'None' )
         {
            EndWalk();

            GoToState(InterruptingWalk);
         }

         else
         {
            TickMove(Location + Normal(WalkOffset) * CurrentSpeed);

            WalkOffset -= Normal(WalkOffset);
         }
      }

      EndWalk();
   }
}


I know this project is going to be VERY hard to code. That's why I'm a programmer! ;)
User avatar
Gustavo6046
Inhuman
 
Posts: 789
Joined: Mon Jun 01, 2015 7:08 pm
Personal rank: Finite

Re: UPawn - Remaking Pawn in UnrealScript

Postby ShaiHulud » Tue Feb 28, 2017 2:38 am

Interesting concept. There aren't a lot of obvious entry points for modifying the stock bot behaviour, which makes it a bit tricky to bend them to your will (and another reason I've been planning to investigate FerBotz for building off of instead in future).
ShaiHulud
Adept
 
Posts: 341
Joined: Sat Dec 22, 2012 6:37 am

Re: UPawn - Remaking Pawn in UnrealScript

Postby sektor2111 » Tue Feb 28, 2017 6:38 am

ShaiHulud wrote:Interesting concept.
and probably useless done by a "programmer".
First of all
Code: Select all
//=============================================================================
// Pawn, the base class of all actors that can be controlled by players or AI.
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
class Pawn extends Actor
   abstract
   native
   nativereplication;
.....
var      vector      LastSeenPos;       // enemy position when I last saw enemy (auto updated if EnemyNotVisible() enabled)
var      vector      LastSeeingPos;      // position where I last saw enemy (auto updated if EnemyNotVisible enabled)
var      float      LastSeenTime;
var       Pawn       Enemy; //LOL I'm gonna see who will fight with an actor and not a Pawn

Then all creatures having an ENEMY are taking in account a Pawn and NOT an Actor to not forget all "Pawn(Owner)" and all chained things with Pawn. It is when everything will get broken in a full mess... but no worries I did not see more things finished and fully operational yet in forum by our sweet friend. Good luck, Gustavo, with your project ! When it will be ready I'll be the one using it...

PS: If this would be operational it would be created years ago...
User avatar
sektor2111
Godlike
 
Posts: 4042
Joined: Sun May 09, 2010 6:15 pm
Location: On the roof.

Re: UPawn - Remaking Pawn in UnrealScript

Postby Gustavo6046 » Tue Feb 28, 2017 5:54 pm

sektor2111 wrote:
Code: Select all
var       Pawn       Enemy; //LOL I'm gonna see who will fight with an actor and not a Pawn



First, I'm intending to replace Pawn (unless of course I come up with some fucked up Pawn subclass which manages to work with those UPawn thingies around). Second, I'm intending to have UPawn support Pawn, and both GusPackII Breadcrumbs (when available) and NavigationPoints.

(where are the preprocessor statements :?: )

Finally, I'm not going to code a ton of stuff at the same time -- got to fix GusBot3's command wrapper.

But don't worry ~ I've got physics planned. I'm going to extend every feature I see wrong or limited in Pawn ~ everything else will be consequences. :)

As for replication, I'll analyze variables that need to be replicated, and for now set most functions as "simulated" ~ I'll unsimulate some functions after the code.
User avatar
Gustavo6046
Inhuman
 
Posts: 789
Joined: Mon Jun 01, 2015 7:08 pm
Personal rank: Finite

Re: UPawn - Remaking Pawn in UnrealScript

Postby PrinceOfFunky » Wed Mar 01, 2017 3:21 am

At this point you should put a "brain" variable to use neural networks and genetic algorithms .o.
Image
User avatar
PrinceOfFunky
Godlike
 
Posts: 1040
Joined: Mon Aug 31, 2015 10:31 pm

Re: UPawn - Remaking Pawn in UnrealScript

Postby Gustavo6046 » Wed Mar 01, 2017 3:55 am

PrinceOfFunky wrote:At this point you should put a "brain" variable to use neural networks and genetic algorithms .o.


holy shit I already tried that ages ago why can't I do neural networks g r r r r r
(although I do know that, nowadays, this is not exactly the way one does a neural network. help me plzzzz)

NeuralNetwork
Code: Select all
//=============================================================================
// NeuralNetwork.
//=============================================================================
class NeuralNetwork expands Info;

var   byte      NumLayers;
var   NeuralLayer   Layers[32];

function SetUp(int InputSize, int Sizes[32])
{
   local   int   i;

   for ( i = 0; i < NumLayers; i++ )
   {
      Layers[i] = Spawn(class'NeuralLayer', self);
      Layers[i].OutputSize = Sizes[i];

      if ( i == 0 )
         Layers[i].SetUp(InputSize);

      else
         Layers[i].SetUp(Sizes[i - 1]);
   }
}

function Activate(out float Inputs[63], float Fitness)
{
   local   float   Results[63];
   local   int      i;

   Log(Layers[0].Nodes[0].InputSize);
   for ( i = 0; i < Layers[0].Nodes[0].InputSize; i++ )
      Results[i] = Inputs[i];

   for ( i = 0; i < NumLayers; i++ )
      Layers[i].Activate(Results, Fitness);

   Log(Layers[NumLayers - 1].OutputSize);
   for ( i = 0; i < Layers[NumLayers - 1].OutputSize; i++ )
      Inputs[i] = Results[i];
}

static function NeuralNetwork QuickBuild(Actor NNUser, byte InputSize, int Sizes[32], optional byte NumLayers)
{
   local   int            i;
   local   NeuralNetwork   FinalNN;

   if ( NumLayers < 1 )
   {
      NumLayers = 0;

      for ( i = 0; i < 32; i++ )
      {
         if ( Sizes[i] < 1 )
            break;

         NumLayers++;
      }

      if ( NumLayers == 0 )
         return None;
   }

   FinalNN = NNUser.Spawn(class'NeuralNetwork', NNUser);
   FinalNN.NumLayers = NumLayers;
   FinalNN.SetUp(InputSize, Sizes);

   return FinalNN;
}


NeuralLayer
Code: Select all
//=============================================================================
// NeuralLayer.
//=============================================================================
class NeuralLayer expands Info;

var   LinearNode   Nodes[63];
var   byte      OutputSize;

function SetUp(byte InputSize)
{
   local int i;

   for ( i = 0; i < OutputSize; i++ )
   {
      Nodes[i] = Spawn(class'LinearNode', self);
      Nodes[i].InputSize = InputSize;
      Nodes[i].SetUp();
   }
}

function Activate(out float Inputs[63], float Fitness)
{
   local float Result[64];
   local int i;

   for ( i = 0; i < OutputSize; i++ )
   {
      Result[i] = Nodes[i].ActivateNode(Inputs, Spawn(class'MinFitness'));
   }
      
   for ( i = 0; i < OutputSize; i++ )
      Inputs[i] = Result[i];
}


LinearNode
Code: Select all
//=============================================================================
// LinearNode.
//=============================================================================
class LinearNode expands Info;

var      float      Weights[63];
var      byte      InputSize;

var()   float      Eta;

function SetUp()
{
   local int i;

   for ( i = 0; i < InputSize; i++ )
      Weights[i] = FRand() * 2.0 - 1.0;
}

function float ProcessOutput(float Output)
{
   return Output;
}

function float Dot63(float A[63], float B[63])
{
   local float Result;
   local int    i;

   for ( i = 0; i < InputSize; i++ )
      Result += A[i] * B[i];

   return Result;
}

function float ActivateNode(float Inputs[63], MinFitness FitnessEvaluator)
{
   local float Result;
   local int    i;

   Result = Dot63(Inputs, Weights);
   
   for ( i = 0; i < InputSize; i++ )
      Weights[i] += Eta * ProcessOutput(Result) * (1 - FitnessEvaluator.Evaluator(i, Eta, Weights[i], Result, Inputs[i])) * Inputs[i];

   return Result;
}


SigmoidNode
Code: Select all
//=============================================================================
// SigmoidNode.
//=============================================================================
class SigmoidNode expands LinearNode;

function float ProcessOutput(float Output)
{
   return 1.0 / (1.0 + 2.718281828459045235360287 ** -Output);
}


UnitStepNode
Code: Select all
//=============================================================================
// UnitStepNode.
//=============================================================================
class UnitStepNode expands LinearNode;

function float ProcessOutput(float Output)
{
   if ( Output < 0 )
      return 0;

   return 1;
}


Sorry for my autism excitation, I'm just excited duh for the coincidence of you talking about a neural network when I already tried doing one in UnrealScript.
User avatar
Gustavo6046
Inhuman
 
Posts: 789
Joined: Mon Jun 01, 2015 7:08 pm
Personal rank: Finite

Re: UPawn - Remaking Pawn in UnrealScript

Postby PrinceOfFunky » Wed Mar 01, 2017 5:04 am

Gustavo6046 wrote:
Spoiler: show
PrinceOfFunky wrote:At this point you should put a "brain" variable to use neural networks and genetic algorithms .o.


holy shit I already tried that ages ago why can't I do neural networks g r r r r r
(although I do know that, nowadays, this is not exactly the way one does a neural network. help me plzzzz)

NeuralNetwork
Code: Select all
//=============================================================================
// NeuralNetwork.
//=============================================================================
class NeuralNetwork expands Info;

var   byte      NumLayers;
var   NeuralLayer   Layers[32];

function SetUp(int InputSize, int Sizes[32])
{
   local   int   i;

   for ( i = 0; i < NumLayers; i++ )
   {
      Layers[i] = Spawn(class'NeuralLayer', self);
      Layers[i].OutputSize = Sizes[i];

      if ( i == 0 )
         Layers[i].SetUp(InputSize);

      else
         Layers[i].SetUp(Sizes[i - 1]);
   }
}

function Activate(out float Inputs[63], float Fitness)
{
   local   float   Results[63];
   local   int      i;

   Log(Layers[0].Nodes[0].InputSize);
   for ( i = 0; i < Layers[0].Nodes[0].InputSize; i++ )
      Results[i] = Inputs[i];

   for ( i = 0; i < NumLayers; i++ )
      Layers[i].Activate(Results, Fitness);

   Log(Layers[NumLayers - 1].OutputSize);
   for ( i = 0; i < Layers[NumLayers - 1].OutputSize; i++ )
      Inputs[i] = Results[i];
}

static function NeuralNetwork QuickBuild(Actor NNUser, byte InputSize, int Sizes[32], optional byte NumLayers)
{
   local   int            i;
   local   NeuralNetwork   FinalNN;

   if ( NumLayers < 1 )
   {
      NumLayers = 0;

      for ( i = 0; i < 32; i++ )
      {
         if ( Sizes[i] < 1 )
            break;

         NumLayers++;
      }

      if ( NumLayers == 0 )
         return None;
   }

   FinalNN = NNUser.Spawn(class'NeuralNetwork', NNUser);
   FinalNN.NumLayers = NumLayers;
   FinalNN.SetUp(InputSize, Sizes);

   return FinalNN;
}


NeuralLayer
Code: Select all
//=============================================================================
// NeuralLayer.
//=============================================================================
class NeuralLayer expands Info;

var   LinearNode   Nodes[63];
var   byte      OutputSize;

function SetUp(byte InputSize)
{
   local int i;

   for ( i = 0; i < OutputSize; i++ )
   {
      Nodes[i] = Spawn(class'LinearNode', self);
      Nodes[i].InputSize = InputSize;
      Nodes[i].SetUp();
   }
}

function Activate(out float Inputs[63], float Fitness)
{
   local float Result[64];
   local int i;

   for ( i = 0; i < OutputSize; i++ )
   {
      Result[i] = Nodes[i].ActivateNode(Inputs, Spawn(class'MinFitness'));
   }
      
   for ( i = 0; i < OutputSize; i++ )
      Inputs[i] = Result[i];
}


LinearNode
Code: Select all
//=============================================================================
// LinearNode.
//=============================================================================
class LinearNode expands Info;

var      float      Weights[63];
var      byte      InputSize;

var()   float      Eta;

function SetUp()
{
   local int i;

   for ( i = 0; i < InputSize; i++ )
      Weights[i] = FRand() * 2.0 - 1.0;
}

function float ProcessOutput(float Output)
{
   return Output;
}

function float Dot63(float A[63], float B[63])
{
   local float Result;
   local int    i;

   for ( i = 0; i < InputSize; i++ )
      Result += A[i] * B[i];

   return Result;
}

function float ActivateNode(float Inputs[63], MinFitness FitnessEvaluator)
{
   local float Result;
   local int    i;

   Result = Dot63(Inputs, Weights);
   
   for ( i = 0; i < InputSize; i++ )
      Weights[i] += Eta * ProcessOutput(Result) * (1 - FitnessEvaluator.Evaluator(i, Eta, Weights[i], Result, Inputs[i])) * Inputs[i];

   return Result;
}


SigmoidNode
Code: Select all
//=============================================================================
// SigmoidNode.
//=============================================================================
class SigmoidNode expands LinearNode;

function float ProcessOutput(float Output)
{
   return 1.0 / (1.0 + 2.718281828459045235360287 ** -Output);
}


UnitStepNode
Code: Select all
//=============================================================================
// UnitStepNode.
//=============================================================================
class UnitStepNode expands LinearNode;

function float ProcessOutput(float Output)
{
   if ( Output < 0 )
      return 0;

   return 1;
}


Sorry for my autism excitation, I'm just excited duh for the coincidence of you talking about a neural network when I already tried doing one in UnrealScript.

I'm studying it on my own too and it is surely more difficult then a genetic algorithm, but after some studies I found this Java library source code, I studied the code and I understood some things I didn't get before while studying ANN's.
Does you code even compile tho? I didn't know you could use arrays as function's parameters.
If you can't manage to get a first person view of what the UPawn sees, you still could give actors that are next to it and sounds around it as input data to the ANN, you wouldn't even need a convolutional NN since you wouldn't need to apply any segmentation of the data.
Image
User avatar
PrinceOfFunky
Godlike
 
Posts: 1040
Joined: Mon Aug 31, 2015 10:31 pm

Re: UPawn - Remaking Pawn in UnrealScript

Postby JackGriffin » Wed Mar 01, 2017 7:53 am

Why is all this even a discussion? At what point are you just making a new game?
PS: If this would be operational it would be created years ago...

/thread
So long, and thanks for all the fish
JackGriffin
Godlike
 
Posts: 3766
Joined: Fri Jan 14, 2011 1:53 pm
Personal rank: -Retired-

Re: UPawn - Remaking Pawn in UnrealScript

Postby PrinceOfFunky » Wed Mar 01, 2017 9:26 am

PS: If this would be operational it would be created years ago...

There must be a reason if EpicGames made the possibility for all calsses to be extendible within UnrealScript.
The fact that we have a UnrealScript compilator is to have a "full" control of the game mechanisms, it works like with UnrealEditor, the fact that a map already exists doesn't mean that it would be useless to create a new one or modify that map itself. I think in a community we should let people believe in themselves, instead than telling them that doing it is useless.
Image
User avatar
PrinceOfFunky
Godlike
 
Posts: 1040
Joined: Mon Aug 31, 2015 10:31 pm

Re: UPawn - Remaking Pawn in UnrealScript

Postby JackGriffin » Wed Mar 01, 2017 2:45 pm

Please. How does saying "this is a bad idea" in any way equate with "letting people believe in themselves"? It's a bad idea in every sense. The fact that no one has even approached the idea without creating a new game tells you it's likely confirmed to be bad. Don't try piling an unwarranted emotional facet to the discussion, it just doesn't belong in the marketplace of ideas.
So long, and thanks for all the fish
JackGriffin
Godlike
 
Posts: 3766
Joined: Fri Jan 14, 2011 1:53 pm
Personal rank: -Retired-

Re: UPawn - Remaking Pawn in UnrealScript

Postby sektor2111 » Wed Mar 01, 2017 5:05 pm

Funky let's get into problem "Remaking Pawn" What Remake ? What compatibility will you have with the rest of UT things ? EPIC did not wrote "shouldn't be modified" because of some nightmare - it's because Pawn is boosted by Engine natively which another class won't get in account that soon, unless you will rewrite some C++ stuff for this task :mrgreen: .
While so called Pawn expands actor with nothing native from engine dedicated to Pawn, this is only a self-defaming. Look at weapon code, at entire Botpack. Sample, function "killed" it will never get called properly because it is demanding PAWN and not other expanded actor. Aside, Pawn is main root supported natively, it can be expanded in a lot of forms without reinventing any broken wheels - BOTZ is the most relevant example in expanding Pawn rather that blabbering a similar nearby class so you probably don't even understand why this will be a broken thing, and YES, mainly looks useless without creating a completely new game type as long as such stuff has 0 zero compatibility with UT. Bot will never fight with a let's say KeyPoint and this actor is nothing similar with "Pawn" except name-fragment U-Pawn - "amazingly" engine doesn't use grammar so this blabbering spree is nothing without an entire package which will summarize a few tens of MB - see current stock.

Given previous activity I can predict how long will take this thing, But I prefer to spectate because it's a funny show after all... :lol2:
You can look 100 times at this
Code: Select all
class UPawn expands Actor;
and maybe you'll get what I mean.
In UnrealScript if you don't like an actor you can subclass it, overriding bad functions, and writing others without RE-creating it. We have already Pawn expanding Actor another class expanding actor will never be a true natively supported Pawn because OF HEADERS - keep dreaming green horses on the roof if that's cool, but this is programming LOGIC in Unreal Engine.
User avatar
sektor2111
Godlike
 
Posts: 4042
Joined: Sun May 09, 2010 6:15 pm
Location: On the roof.

Re: UPawn - Remaking Pawn in UnrealScript

Postby SilverSound » Thu Mar 02, 2017 12:11 am

To sum up what Sektor is saying:

You need UT source code and some new native stuff to be able to do this properly.

Things like "UnPawn.cpp" <(Has movement and AI related things) "UnActor.cpp"<(Has a whole entire everything)

These are some guesses of what you would need to change. But who knows what Pawn is linked to in native code. Could be a bunch of stuff. And I don't feel like going through shit..

You want to change movement? Well you need to change things in UnPawn.cpp and UnPhysics.cpp.

Unless you learn C++ and get your self the src and a licence you won't have luck in your endeavors. But I'm not going to say "Don't do it"

Experiment and see what you guys can do with it. I'm sure you will hit a lot of walls with out the keys though.
"Woah what?! I wish I was recording that...."
User avatar
SilverSound
Adept
 
Posts: 282
Joined: Fri Nov 06, 2015 10:12 am
Location: St. Cloud, Florida
Personal rank: Curious

Re: UPawn - Remaking Pawn in UnrealScript

Postby papercoffee » Thu Mar 02, 2017 12:20 am

SilverSound wrote:I'm sure you will hit a lot of walls with out the keys though.

I like this metaphor :mrgreen:
User avatar
papercoffee
Godlike
 
Posts: 9213
Joined: Wed Jul 15, 2009 11:36 am
Location: Cologne, the city with the big cathedral.
Personal rank: coffee addicted !!!

Re: UPawn - Remaking Pawn in UnrealScript

Postby Gustavo6046 » Thu Mar 02, 2017 1:11 am

i'm... I'm speechless. I could have subclassed Pawn, but that would mean bugs, and loads of redirecting functions. sektor is right. I should focus on my model converter in Python... epic, fuck you, I just want to make my models
User avatar
Gustavo6046
Inhuman
 
Posts: 789
Joined: Mon Jun 01, 2015 7:08 pm
Personal rank: Finite

Re: UPawn - Remaking Pawn in UnrealScript

Postby PrinceOfFunky » Thu Mar 02, 2017 2:38 am

Gustavo6046 wrote:I should focus on my model converter in Python

Oh well, goodbye UPawn. lol
Image
User avatar
PrinceOfFunky
Godlike
 
Posts: 1040
Joined: Mon Aug 31, 2015 10:31 pm

Next

Return to Coding, Scripting

Who is online

Users browsing this forum: No registered users and 1 guest