Why is my platform moving when my player is moving right or left

Question

1) In my code the problem is that my Platform underneath my player class are connected and when the player moves so does the platform and if so the player moves on the platform the entire time. Can someone tell me how to fix that? If you are wondering where to look for all the code and where it is going to be it is all the code here because I didn't Know what was causing the problem in my code.

import math
import os
import sys
# It is importing everything
import pygame
from pygame.locals import *

#The platform class is the problem I'm having
class Platform:
    def __init__(self, size, x, y, length, color, velocity):
        self.length = length
        self.size = size
        self.x = x
        self.y = y
        self.color = color
        self.velocity = velocity
        self.xVelocity = 0

    # This is what the platform class has and what it does
    def draw(self):
        display = pygame.display.get_surface()
        pygame.draw.rect(display, self.color, (int(self.x) - 80, int(self.y) + 225, int(self.x), int(self.y) - 45))

    # This is def draw function is showing that how I want my Platform to look like
    def do(self):
        self.draw()

2) When my player reaches the "end" of the screen it stops but I want to make it a scrolling screen and nothing happens and then there is no game when the player moves and scroll by itself. After someone tells me how to fix my second problem then I want the Background to kill the player if the background goes past the player.

# The def do function is running def draw function

class Player:
    def __init__(self, velocity, maxJumpRange, x, y, size):
        self.falling = True
        self.jumpCounter = 0
        self.xVelocity = 0
        self.y = y
        self.x = x
        self.jumping = False
        self.velocity = velocity
        self.maxJumpRange = maxJumpRange
        self.jump_offset = 0
        self.size = size

    # The player class is making how the Player is going to look and what are his limits

    def keys(self):
        k = pygame.key.get_pressed()
        # The def keys(self): is creating a variable for pygame.key.get_pressed() and underneath is a function to make the player move around
        if k[K_LEFT]:
            self.xVelocity = -self.velocity
        elif k[K_RIGHT]:
            self.xVelocity = self.velocity
        else:
            self.xVelocity = 0

        if k[K_SPACE] or k[K_UP] and not self.jumping and not self.falling:
            self.jumping = True
            self.jumpCounter = 0


    # The if k[K_Space] or k[K_UP] is making sure the player has a jump limit and can't continue jumping forever.
    def move(self):
        self.x += self.xVelocity
        # This to make sure that the player can move while he is jumping.
        if self.jumping:
            self.y -= self.velocity
            self.jumpCounter += 1
            if self.jumpCounter == self.maxJumpRange:
                self.jumping = False
                self.falling = True
        elif self.falling:
            if self.y <= h - 10 <= self.y + self.velocity:
                self.y = h - 10
                self.falling = False
            else:
                self.y += self.velocity

    def draw(self):
        display = pygame.display.get_surface()
        pygame.draw.circle(display, White, (int(self.x), int(self.y) - 25), 25, 0)

    def do(self):
        self.keys()
        self.move()
        self.draw()


# This Function is doing all of the Functions self.keys(), self.move(), self.draw()

def events():
    for event in pygame.event.get():
        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
            pygame.quit()
            sys.exit()


# This is to make sure that you can exit the game is needed

def keys(player):
    keys = pygame.key.get_pressed()
    if keys[K_UP] or keys[K_SPACE] and player.jumping == False and player.jump_offset == 0:
        player.jumping = True


# The function here to make sure that the player can jump

def do_jumping(player):
    jump_height = 25
    # Def do_jumping(player): is to adjust the jump_height of the player
    if player.jumping:
        player.jump_offset += 1
        if player.jump_offset >= jump_height:
            player.jumping = False
    elif player.jump_offset > 0 and player.jumping == False:
        player.jump_offset -= 1


# The above is showing how the makes sure the player doesn't jump higher then the jump height

w = 576
h = 516
hw = w / 2
hh = h / 2
AREA = w * h
# The above is showing the width the height and Area
os.environ['SDL_VIDEO_WINDOW_POS'] = "50,50"
p = Player(hh, hw, 290, 250, 30)
# the above is showing what the graphics are
pygame.init()
Clock = pygame.time.Clock()
DS = pygame.display.set_mode((w, h))  # This is what the display size is
pygame.display.set_caption("Try to get point B")
FPS = 120
Black = (0, 0, 0, 255)
White = (255, 255, 255, 255)
pl = Platform(290, 250, 50, 70, White, 0)
Red = (255, 0, 0)
Solid_Fill = 0
# Bkgd stands for background
bkgd = pygame.image.load("scroll.png").convert()  # scroll.png is the png im using to use as the background
bkgdWidth = bkgd.get_rect().size[0]
print(bkgdWidth)
bkgdHeight = bkgd.get_rect().size
stageWidth = bkgdWidth * 2
StagePosX = 0
startScollingPosx = hw
circleRadius = 25
circlePosX = circleRadius
playerPosX = circleRadius
playerPosY = 377
playerVelocityX = 0
playerVelocityY = 0
platformVelocityX = 0
platformVelocityY = 0
x = 0
# The above is showing the player Velocity, player position y and x and what the stage position is, Ignore platform 
# velocity. 
# What the while true loop is doing is to make sure that the background moves while the player moves
while True:
    events()

    k = pygame.key.get_pressed()
    if k[K_RIGHT]:
        playerVelocityX = 1
        pl.xVelocity = 0
    elif k[K_LEFT]:
        playerVelocityX = -1
        pl.xVelocity = 0
    else:
        playerVelocityX = 0
        pl.xVelocity = 0

    playerPosX += playerVelocityX
    if playerPosX > stageWidth - circleRadius:
        playerPosX = stageWidth - circleRadius
    if playerPosX < circleRadius:
        playerPosX = circleRadius
    if playerPosX < startScollingPosx:
        circlePosX = playerPosX
    elif playerPosX > stageWidth - startScollingPosx:
        circlePosX - stageWidth + w
    else:
        circlePosX = startScollingPosx
        StagePosX -= playerVelocityX
# The code below show is working how to balance the Display size and rel x is the easier of saying that
    rel_x = StagePosX % bkgdWidth
    DS.blit(bkgd, (rel_x - bkgdWidth, 0))
    if rel_x < w:
        DS.blit(bkgd, (rel_x, 0))
    events()
    keys(p)
    do_jumping(p)
    pygame.draw.circle(DS, White, (math.floor(p.x), math.floor(p.y) - math.floor(p.jump_offset)), math.floor(p.size), math.floor(Solid_Fill))
    platform_color = Red
    pl.color = Red
    pl.draw()
    if p.jump_offset == 0:
        pl.color = White
    pl.do()
    pygame.display.update()
    Clock.tick(FPS)
    DS.fill(Black)

3) Lastly sorry for the lack of good code and where to look around the code because I didn't Know what was causing the problem in my code so I had to put out all of it.

Answer 1

I edited your code a bit so fix the problems you had, I did change the image as i didn't have it, but i fixed jumping and standing on platform by making player constantly fall and check if the player collides with the platform. I also added the scrolling background. Got rid of the unnecessary code as mentioned in my comments. changed the player move to do the jump from there. changed the size in platform to a list so it has width and height. got rid of velocity too as platforms didn't move.

import math
import os
import sys
# It is importing everything
import pygame
from pygame.locals import *

class Platform:
    def __init__(self, size, x, y, color):
        #size is a list, this means it has width and height
        self.size = size
        self.x = x
        self.y = y
        self.color = color

    # This is what the platform class has and what it does
    def draw(self):
        display = pygame.display.get_surface()
        pygame.draw.rect(display, self.color, (int(self.x), int(self.y), self.size[0], self.size[1]))

    # This is def draw function is showing that how I want my Platform to look like
    def do(self):
        self.draw()


# The def do function is running def draw function

class Player:
    def __init__(self, velocity, maxJumpRange, x, y, size):
        self.falling = True
        self.jumpCounter = 0
        self.xVelocity = 0
        self.y = y
        self.x = x
        self.jumping = False
        self.velocity = velocity
        self.maxJumpRange = maxJumpRange
        self.jump_offset = 0
        self.size = size
        self.TouchedGround = False

    # The player class is making how the Player is going to look and what are his limits

    def keys(self):
        k = pygame.key.get_pressed()
        # The def keys(self): is creating a variable for pygame.key.get_pressed() and underneath is a function to make the player move around
        if k[K_LEFT]:
            self.xVelocity = -self.velocity
        elif k[K_RIGHT]:
            self.xVelocity = self.velocity
        else:
            self.xVelocity = 0

        if (k[K_SPACE] or k[K_UP]) and not self.jumping and self.TouchedGround:
            self.jumping = True
            self.jumpCounter = 0
            self.TouchedGround = False


    # The if k[K_Space] or k[K_UP] is making sure the player has a jump limit and can't continue jumping forever.
    def move(self):
        self.x += self.xVelocity
        # if the player is jumping, change y value
        if self.jumping:
            self.y -= self.velocity
            self.jumpCounter += 1
            if self.jumpCounter == self.maxJumpRange:
                self.jumping = False
                self.falling = True
        elif self.falling:
            self.y += self.velocity
            self.jumpCounter -= 1


    def draw(self):
        display = pygame.display.get_surface()
        pygame.draw.circle(display, White, (int(self.x), int(self.y)), self.size)

    def do(self):
        self.keys()
        self.move()
        self.draw()


# This Function is doing all of the Functions self.keys(), self.move(), self.draw()

def events():
    for event in pygame.event.get():
        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
            pygame.quit()
            sys.exit()



#window size

w = 576
h = 516

# The above is showing the width the height and Area
os.environ['SDL_VIDEO_WINDOW_POS'] = "50,50"
# the above is showing what the graphics are

#player
p = Player(1, 100, 290, 250, 30)


#start pygame
pygame.init()
Clock = pygame.time.Clock()
DS = pygame.display.set_mode((w, h))  # This is what the display size is
pygame.display.set_caption("Try to get point B")



#variables
FPS = 120
Black = (0, 0, 0, 255)
White = (255, 255, 255, 255)
Red = (255, 0, 0)


# Bkgd stands for background
bkgd = pygame.Surface((w,h))  # didnt have the image so i made it blue
bkgd.fill((0,0,255))


#platforms
pl = Platform([290,20], 250, 350, White)
#this is a list that holds all the platforms
platforms_list = [pl,Platform([200,20], 100, 450, White), Platform([200,20], 400, 250, White)]

#this is how much to scroll the background by
background_scroll = 0


# What the while true loop is doing is to make sure that the background moves while the player moves
while True:
    events()

    #blit the background, since the image is same size as window blit twice so when scrolls, you dont have blackness 
    DS.blit(bkgd, (-background_scroll, 0))
    DS.blit(bkgd, (w-background_scroll, 0))

    #check for x button clicked
    events()

    #update the player
    p.do()

    #update platforms and check for collision with player
    platform_color = Red
    for platform in platforms_list:
        platform.color = platform_color
        if p.jumping == 0:
            platform.color = White
        platform.do()
        #if bottom of player is in the platform, move the player on top of the platform
        if p.y + p.size > platform.y and p.y + p.size < platform.y + platform.size[1]:
            if p.x > platform.x and p.x < platform.x + platform.size[0]:
                p.y = platform.y - p.size  
                p.TouchedGround = True

    #if the player reaches the side of the screen, move the background and platforms to make it look like it is moving
    if p.x + p.size >= w:
        p.x = w - p.size
        background_scroll += 1
        for platform in platforms_list:
            platform.x -= 1
        if background_scroll == w:
            background_scroll = 0
    #same but for the left
    if p.x - p.size <= 0:
        p.x = 0 + p.size
        background_scroll -= 1
        for platform in platforms_list:
            platform.x += 1
        if background_scroll == 0:
            background_scroll = w

    #update screen
    pygame.display.update()
    Clock.tick(FPS)
    DS.fill(Black)